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 "UsbOtgWatcherTest.h"

    23 #include "testdebug.h"

    24 #include "panic.h"

    25 //#include "UsbWatcherInternalPSKeys.h"

    26 #include "mockusbman.h"

    27 #include "mockcusbnotifmanager.h"

    28 #include <usbpersonalityids.h>

    29 #include "cusbindicatornotifier.h"

    30 

    31 // EXTERNAL DATA STRUCTURES

    32 

    33 // EXTERNAL FUNCTION PROTOTYPES  

    34 

    35 // CONSTANTS

    36 

    37 // MACROS

    38 

    39 // LOCAL CONSTANTS AND MACROS

    40 

    41 // MODULE DATA STRUCTURES

    42 

    43 // LOCAL FUNCTION PROTOTYPES

    44 

    45 // FORWARD DECLARATIONS

    46 

    47 // ============================= LOCAL FUNCTIONS ===============================

    48 

    49 // -----------------------------------------------------------------------------

    50 // -----------------------------------------------------------------------------

    51 

    52 // ============================ MEMBER FUNCTIONS ===============================

    53 

    54 // -----------------------------------------------------------------------------

    55 // CtUsbOtgWatcher::TestConstructL

    56 // Construct here all test resources for test methods. 

    57 // Called from ConstructL. 

    58 // -----------------------------------------------------------------------------

    59 

    60 void CtUsbOtgWatcher::TestConstructL()

    61     {

    62     TRACE_FUNC_ENTRY

    63     

    64     iStubber = CStubber::NewL();

    65     

    66     TRACE_FUNC_EXIT

    67     }

    68 

    69 // -----------------------------------------------------------------------------

    70 // CtUsbOtgWatcher::TestDelete

    71 // Delete here all resources allocated and opened from test methods. 

    72 // Called from destructor. 

    73 // -----------------------------------------------------------------------------

    74 

    75 void CtUsbOtgWatcher::TestDelete() 

    76     {

    77     TRACE_FUNC_ENTRY

    78     

    79     delete iStubber;

    80     

    81     TRACE_FUNC_EXIT

    82     }

    83 

    84 // -----------------------------------------------------------------------------

    85 // CtUsbOtgWatcher::TestBlocksInfoL

    86 // Add new test block parameter entries below

    87 // -----------------------------------------------------------------------------

    88 

    89 void CtUsbOtgWatcher::TestBlocksInfoL()

    90     {

    91     

    92     TESTENTRY( "ExampleTestL", CtUsbOtgWatcher::ExampleTestL )

    93             {

    94             TESTPARAM( eGetString, eTestOption1 )

    95             TESTPARAM( eGetString, eTestOption2 )

    96             TESTPARAM( eGetInt, eTestIntOption1 )

    97             TESTPARAM( eGetChar, eTestCharOption1 )

    98             }

    99     

   100     TESTENTRY( "SetupTearDown", CtUsbOtgWatcher::SetupTearDownL )

   101                 {

   102                 TESTPARAM( eGetString, eTestOption1 )

   103                 }

   104 

   105     TESTENTRY( "PinOnTest_Success", CtUsbOtgWatcher::PinOnTest_SuccessL )

   106                 {

   107                 TESTPARAM( eGetString, eTestOption1 )

   108                 }

   109     

   110     TESTENTRY( "PinOffTest_Success", CtUsbOtgWatcher::PinOffTest_SuccessL )

   111                 {

   112                 TESTPARAM( eGetString, eTestOption1 )

   113                 }

   114     

   115     TESTENTRY( "PinOnTest_EmptyCable", CtUsbOtgWatcher::PinOnTest_EmptyCableL )

   116                 {

   117                 TESTPARAM( eGetString, eTestOption1 )

   118                 }

   119     

   120     TESTENTRY( "PinOnTest_TryStartError", CtUsbOtgWatcher::PinOnTest_TryStartErrorL )

   121                 {

   122                 TESTPARAM( eGetString, eTestOption1 )

   123                 }

   124     

   125     TESTENTRY( "PinOnTest_BusRequestError", CtUsbOtgWatcher::PinOnTest_BusRequestErrorL )

   126                 {

   127                 TESTPARAM( eGetString, eTestOption1 )

   128                 }

   129     

   130     TESTENTRY( "DeviceAttached_BadHubPostion", CtUsbOtgWatcher::DeviceAttached_BadHubPostionL )

   131                 {

   132                 TESTPARAM( eGetString, eTestOption1 )

   133                 }

   134     

   135     TESTENTRY( "DeviceAttached_TooMuchRequired", CtUsbOtgWatcher::DeviceAttached_TooMuchRequiredL )

   136                 {

   137                 TESTPARAM( eGetString, eTestOption1 )

   138                 }

   139     

   140     TESTENTRY( "DeviceAttached_SupportedDevice", CtUsbOtgWatcher::DeviceAttached_SupportedDeviceL )

   141                 {

   142                 TESTPARAM( eGetString, eTestOption1 )

   143                 }

   144     

   145     TESTENTRY( "DeviceDetached_SupportedDevice", CtUsbOtgWatcher::DeviceDetached_SupportedDeviceL )

   146                 {

   147                 TESTPARAM( eGetString, eTestOption1 )

   148                 }

   149  

   150      TESTENTRY( "IndicatorNotifier_IndicatorActivateL", CtUsbOtgWatcher::IndicatorNotifier_IndicatorActivateL )

   151                 {

   152                 TESTPARAM( eGetString, eTestOption1 )

   153                 }

   154     }

   155 

   156 // Add test block methods implementation here

   157 // -----------------------------------------------------------------------------

   158 // CtUsbOtgWatcher::ExampleTestL

   159 // -----------------------------------------------------------------------------

   160 

   161 void CtUsbOtgWatcher::ExampleTestL( TUsbOtgWatcherTestBlockParams& aParams,

   162                                             TUsbOtgWatcherTestResult& aTestResult )

   163     {

   164     TRACE_FUNC_ENTRY

   165     

   166     //iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   167     

   168     if ( !aParams.iTestOption1.Compare( _L( "API" ) ) )

   169         {

   170 		TRACE_INFO( "Api test option: %S", &aParams.iTestOption1 )

   171 		TRACE_INFO( "Api test sub-option: %S", &aParams.iTestOption2 )

   172 		TRACE_INFO( "Api test int option: %d", aParams.iTestIntOption1 )

   173 		TRACE_INFO( "Api test char option: %c", TText( aParams.iTestCharOption1 ) )

   174         }

   175     else if ( !aParams.iTestOption1.Compare( _L( "MODULE" ) ) )

   176         {

   177 		TRACE_INFO( "Module test option: %S", &aParams.iTestOption1 )

   178 		TRACE_INFO( "Module test sub-option: %S", &aParams.iTestOption2 )

   179 		TRACE_INFO( "Module test int option: %d", aParams.iTestIntOption1 )

   180 		TRACE_INFO( "Module test char option: %c", TText( aParams.iTestCharOption1 ) )

   181         }

   182     else if ( !aParams.iTestOption1.Compare( _L( "BRANCH" ) ) )

   183         {

   184 		TRACE_INFO( "Branch test option: %S", &aParams.iTestOption1 )

   185 		TRACE_INFO( "Branch test sub-option: %S", &aParams.iTestOption2 )

   186 		TRACE_INFO( "Branch test int option: %d", aParams.iTestIntOption1 )

   187 		TRACE_INFO( "Branch test char option: %c", TText( aParams.iTestCharOption1 ) )

   188         }

   189     else

   190         {

   191         TRACE( "Invalid test parameter" )

   192         TRACE_FUNC_EXIT

   193         User::Leave( KErrNotFound );

   194         }

   195     

   196     aTestResult = ETestCasePassed;

   197     TRACE_FUNC_EXIT

   198     }

   199 

   200 

   201 void CtUsbOtgWatcher::SetupTearDownL( TUsbOtgWatcherTestBlockParams& aParams,

   202                                             TUsbOtgWatcherTestResult& aTestResult )

   203     {

   204     TRACE_FUNC_ENTRY;

   205 

   206     TRACE( "Create classes of the state machine" );

   207     SetupL();

   208     

   209     TRACE( "Destroy classes of the state machine" );

   210     TearDown();

   211 

   212     aTestResult = ETestCasePassed;

   213     }

   214 

   215 

   216 void CtUsbOtgWatcher::PinOnTest_SuccessL( TUsbOtgWatcherTestBlockParams& aParams,

   217         TUsbOtgWatcherTestResult& aTestResult )

   218     {

   219     TRACE(">>CtUsbOtgWatcher::PinOnTest_SuccessL");

   220     

   221     SetupL();

   222     

   223     // Idpin observer should be subscribed

   224     STIF_ASSERT_TRUE(iWatcher->IdPinObserver()->iObserver != NULL);

   225     

   226     TRACE( "State machine initialized" );

   227     CUsbStateHostAInitiate* aInitiate = (CUsbStateHostAInitiate*)(iWatcher->State(EUsbStateHostAInitiate));

   228     STIF_ASSERT_NOT_NULL(aInitiate);

   229     

   230     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusDown, iWatcher->VBusObserver()->VBus());    

   231 

   232     TRACE( "Trigger pin on" );

   233     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceIdle" ) ) );

   234     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   235     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   236     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   237     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   238 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   239     

   240     STIF_ASSERT_NOT_LEAVES(iWatcher->IdPinObserver()->TriggerPinOnL());

   241     TRACE_INFO("Status iWatcher->iUsbServiceControl->iStatus: %d",iWatcher->iUsbServiceControl->iStatus.Int());

   242     

   243     iWatcher->iUsbServiceControl->RunL();

   244         

   245     TRACE_INFO("iWatcher->IdPinObserver()->IsTestResultNoneError(): %d", iWatcher->IdPinObserver()->IsTestResultNoneError() ? 1 : 0 );

   246     STIF_ASSERT_TRUE(iWatcher->IdPinObserver()->IsTestResultNoneError());

   247     

   248     TRACE_INFO("iWatcher->VBusObserver()->iObserver: %d", iWatcher->VBusObserver()->iObserver ? 1 : 0 );

   249     STIF_ASSERT_TRUE(iWatcher->VBusObserver()->iObserver != NULL);

   250     

   251     TRACE_INFO("iWatcher->OtgStateObserver()->iObserver: %d", iWatcher->OtgStateObserver()->iObserver ? 1 : 0 );

   252     STIF_ASSERT_TRUE(iWatcher->OtgStateObserver()->iObserver != NULL);

   253     

   254     TRACE_INFO("iWatcher->BusActivityObserver()->iObserver: %d", iWatcher->BusActivityObserver()->iObserver ? 1 : 0 );

   255     STIF_ASSERT_TRUE(iWatcher->BusActivityObserver()->iObserver != NULL);    

   256     

   257     TRACE_INFO("iWatcher->HostEventNotificationObserver()->iObserver: %d", iWatcher->HostEventNotificationObserver()->iObserver ? 1 : 0 );

   258     STIF_ASSERT_TRUE(iWatcher->HostEventNotificationObserver()->iObserver != NULL);

   259     

   260     TRACE_INFO("iWatcher->MessageNotificationObserver()->iObserver: %d", iWatcher->MessageNotificationObserver()->iObserver ? 1 : 0 );

   261     STIF_ASSERT_TRUE(iWatcher->MessageNotificationObserver()->iObserver != NULL);

   262       

   263     TRACE_INFO("CUsbVBusObserver::EVBusUp == iWatcher->VBusObserver()->VBus(): %d", CUsbVBusObserver::EVBusUp == iWatcher->VBusObserver()->VBus() ? 1 : 0 );

   264     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus()); 

   265         

   266     

   267     TRACE( "Trigger vbus on" );

   268     STIF_ASSERT_NOT_LEAVES(iWatcher->VBusObserver()->TriggerVBusUpL());

   269     

   270     TRACE_INFO("iWatcher->VBusObserver()->IsTestResultNoneError(): %d", iWatcher->VBusObserver()->IsTestResultNoneError() ? 1 : 0 );

   271     STIF_ASSERT_TRUE(iWatcher->VBusObserver()->IsTestResultNoneError());

   272     

   273     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus());

   274     

   275     TRACE_INFO("iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostAInitiate]: %d", iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostAInitiate] ? 1 : 0 );

   276     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostAInitiate]);

   277     

   278     TRACE_INFO("aInitiate->iAttachmentTimer->IsActive(): %d", aInitiate->iAttachmentTimer->IsActive() ? 1 : 0 );

   279     STIF_ASSERT_TRUE(aInitiate->iAttachmentTimer->IsActive());

   280     

   281     TRACE_INFO("CUsbVBusObserver::EVBusUp == iWatcher->VBusObserver()->VBus(): %d", CUsbVBusObserver::EVBusUp == iWatcher->VBusObserver()->VBus() ? 1 : 0 );

   282     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus());

   283 

   284 //    iUsbMan->StartCancel(iWatcher->iUsbServiceControl->iStatus);

   285     

   286     TearDown();

   287 

   288     aTestResult = ETestCasePassed;

   289     

   290     TRACE("<<CtUsbOtgWatcher::PinOnTest_SuccessL");

   291     }

   292 

   293 void CtUsbOtgWatcher::PinOffTest_SuccessL( TUsbOtgWatcherTestBlockParams& aParams,

   294         TUsbOtgWatcherTestResult& aTestResult )

   295     {

   296     TRACE(">>CtUsbOtgWatcher::PinOffTest_SuccessL");

   297     SetupL();

   298     

   299     // Idpin observer should be subscribed

   300     STIF_ASSERT_TRUE(iWatcher->IdPinObserver()->iObserver != NULL);

   301     

   302     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusDown, iWatcher->VBusObserver()->VBus());

   303 

   304     TRACE( "Trigger pin on" );

   305     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   306     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceIdle" ) ) );

   307     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   308     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   309     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   310     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   311 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   312     iWatcher->IdPinObserver()->TriggerPinOnL();

   313     iWatcher->iUsbServiceControl->RunL();

   314     

   315     TRACE( "Trigger vbus on" );

   316     iWatcher->VBusObserver()->TriggerVBusUpL();  

   317     

   318     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostAInitiate]);    

   319     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus());

   320 //    iUsbMan->StartCancel(iWatcher->iUsbServiceControl->iStatus);

   321         

   322     TRACE( "Trigger vbus off" );

   323     iWatcher->IdPinObserver()->TriggerPinOffL();

   324     iWatcher->iUsbServiceControl->RunL();

   325     

   326     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() != NULL);

   327 

   328     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() != iWatcher->iStates[EUsbStateHostAInitiate]);

   329     STIF_ASSERT_TRUE(iWatcher->VBusObserver()->IsTestResultNoneError());

   330     STIF_ASSERT_TRUE(iWatcher->IdPinObserver()->IsTestResultNoneError());

   331     STIF_ASSERT_TRUE(iWatcher->VBusObserver()->iObserver != NULL);

   332     STIF_ASSERT_TRUE(iWatcher->OtgStateObserver()->iObserver != NULL);

   333     STIF_ASSERT_TRUE(iWatcher->BusActivityObserver()->iObserver != NULL);

   334     STIF_ASSERT_TRUE(iWatcher->HostEventNotificationObserver()->iObserver != NULL);

   335     STIF_ASSERT_TRUE(iWatcher->MessageNotificationObserver()->iObserver != NULL);    

   336 

   337 //    iUsbMan->StartCancel(iWatcher->iUsbServiceControl->iStatus);

   338     TearDown();

   339 

   340     aTestResult = ETestCasePassed;

   341     

   342     TRACE("<<CtUsbOtgWatcher::PinOffTest_SuccessL");

   343     }

   344 

   345 void CtUsbOtgWatcher::PinOnTest_EmptyCableL( TUsbOtgWatcherTestBlockParams& aParams,

   346         TUsbOtgWatcherTestResult& aTestResult )

   347     {

   348     TRACE(">>CtUsbOtgWatcher::PinOnTest_EmptyCable");

   349     SetupL();

   350     

   351     TRACE("State machine initialized");

   352     CUsbStateHostAInitiate* aInitiate = (CUsbStateHostAInitiate*)(iWatcher->State(EUsbStateHostAInitiate));

   353 

   354     TRACE( "Trigger pin on" );

   355     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   356     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   357     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   358     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   359     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   360 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   361        

   362     STIF_ASSERT_NOT_LEAVES(iWatcher->IdPinObserver()->TriggerPinOnL());

   363     iWatcher->iUsbServiceControl->RunL();

   364     

   365     TRACE( "Trigger vbus on" );

   366     STIF_ASSERT_NOT_LEAVES(iWatcher->VBusObserver()->TriggerVBusUpL());

   367     

   368 //    STIF_ASSERT_TRUE(iWatcher->NotifManager()->GetUsbIconBlinking());

   369     

   370     TRACE( "Trigger attachment timer elapsed" );

   371     STIF_ASSERT_NOT_LEAVES(aInitiate->iAttachmentTimer->TriggerTimerElapsedL());

   372     aInitiate->iAttachmentTimer->TriggerTimerElapsedL();

   373     STIF_ASSERT_TRUE(aInitiate->iAttachmentTimer->IsTestResultNoneError());

   374 

   375     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostHandleDropping]);

   376     STIF_ASSERT_TRUE(KUsbUiNotifOtgError == iWatcher->iNotifManager->iCat); 

   377     STIF_ASSERT_TRUE(EUsbOtgErrorAttachTimedOut == iWatcher->iNotifManager->iNotifId);

   378     

   379     STIF_ASSERT_TRUE(NULL != iWatcher->iNotifManager->iObserver);

   380     STIF_ASSERT_FALSE(iWatcher->iNotifManager->iUsbIconBlinking);

   381     STIF_ASSERT_FALSE(iWatcher->iNotifManager->iUsbIconShown);

   382     

   383     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusDown, iWatcher->VBusObserver()->VBus());

   384     TearDown();

   385 

   386     aTestResult = ETestCasePassed;

   387     

   388     TRACE("<<CtUsbOtgWatcher::PinOnTest_EmptyCable");

   389     }

   390 

   391 void CtUsbOtgWatcher::PinOnTest_TryStartErrorL( TUsbOtgWatcherTestBlockParams& aParams,

   392         TUsbOtgWatcherTestResult& aTestResult )

   393     {

   394     TRACE(">>CtUsbOtgWatcher::PinOnTest_TryStartErrorL");

   395 

   396     SetupL();

   397     

   398     CUsbStateHostAInitiate* aInitiate = (CUsbStateHostAInitiate*)(iWatcher->State(EUsbStateHostAInitiate));

   399     STIF_ASSERT_NOT_NULL(aInitiate);

   400 

   401     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   402     iWatcher->Usb().SetTryStartError(KErrGeneral);

   403     STIF_ASSERT_PANIC(ECanNotStartUsbServices, iWatcher->IdPinObserver()->TriggerPinOnL());

   404 

   405     TestModuleIf().SetExitReason( CTestModuleIf::ENormal, KErrNone );

   406     

   407     TearDown();

   408 

   409     aTestResult = ETestCasePassed;

   410 

   411     TRACE("<<CtUsbOtgWatcher::PinOnTest_TryStartErrorL");

   412     }

   413 

   414 void CtUsbOtgWatcher::PinOnTest_BusRequestErrorL( TUsbOtgWatcherTestBlockParams& aParams,

   415         TUsbOtgWatcherTestResult& aTestResult )

   416     {

   417     TRACE(">>CtUsbOtgWatcher::PinOnTest_BusRequestErrorL");

   418     

   419     SetupL();

   420     

   421     CUsbStateHostAInitiate* aInitiate = (CUsbStateHostAInitiate*)(iWatcher->State(EUsbStateHostAInitiate));

   422     STIF_ASSERT_NOT_NULL(aInitiate);

   423 

   424     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   425     iWatcher->Usb().SetBusRequestError(KErrGeneral);

   426     STIF_ASSERT_PANIC(EBusRequestError, iWatcher->IdPinObserver()->TriggerPinOnL());

   427 

   428     TestModuleIf().SetExitReason( CTestModuleIf::ENormal, KErrNone );

   429     

   430     TearDown();

   431 

   432     aTestResult = ETestCasePassed;

   433 

   434     TRACE("<<CtUsbOtgWatcher::PinOnTest_BusRequestErrorL");

   435     }

   436 

   437 void CtUsbOtgWatcher::DeviceAttached_BadHubPostionL( TUsbOtgWatcherTestBlockParams& aParams,

   438         TUsbOtgWatcherTestResult& aTestResult )

   439     {

   440     TRACE(">>CtUsbOtgWatcher::DeviceAttached_BadHubPostionL");

   441     SetupL();

   442 

   443     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   444     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceIdle" ) ) );

   445     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   446     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   447     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   448     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   449 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   450     

   451     TRACE( "PinOn triggered" );

   452     STIF_ASSERT_NOT_LEAVES(iWatcher->IdPinObserver()->TriggerPinOnL());

   453     iWatcher->iUsbServiceControl->RunL();

   454     

   455     TRACE( "Trigger vbus on" );

   456     STIF_ASSERT_NOT_LEAVES(iWatcher->VBusObserver()->TriggerVBusUpL());

   457 

   458     TRACE( "BadHubPosition triggered" );

   459     STIF_ASSERT_NOT_LEAVES(iWatcher->MessageNotificationObserver()->TriggerBadHubPositionL());

   460     TRACE( "BadHubPosition test result" );

   461     STIF_ASSERT_TRUE(iWatcher->MessageNotificationObserver()->IsTestResultNoneError());

   462 

   463     TRACE( "Poscondition check" );

   464     STIF_ASSERT_TRUE(KUsbUiNotifOtgError == iWatcher->iNotifManager->iCat);   

   465     STIF_ASSERT_TRUE(EUsbOtgHubUnsupported == iWatcher->iNotifManager->iNotifId);

   466     STIF_ASSERT_TRUE(NULL != iWatcher->iNotifManager->iObserver);

   467     

   468     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusDown, iWatcher->VBusObserver()->VBus());

   469 

   470     TearDown();

   471 

   472     aTestResult = ETestCasePassed;

   473 

   474     TRACE("<<CtUsbOtgWatcher::DeviceAttached_BadHubPostionL");

   475     }

   476 

   477 void CtUsbOtgWatcher::DeviceAttached_TooMuchRequiredL( TUsbOtgWatcherTestBlockParams& aParams,

   478         TUsbOtgWatcherTestResult& aTestResult )

   479     {

   480     TRACE("<<CtUsbOtgWatcher::DeviceAttached_TooMuchRequiredL");

   481     SetupL();

   482 

   483     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   484     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceIdle" ) ) );

   485     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   486     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   487     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   488     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   489 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   490         

   491     TRACE( "PinOn triggered" );

   492     STIF_ASSERT_NOT_LEAVES(iWatcher->IdPinObserver()->TriggerPinOnL());

   493     iWatcher->iUsbServiceControl->RunL();

   494     

   495     TRACE( "Trigger vbus on" );

   496     STIF_ASSERT_NOT_LEAVES(iWatcher->VBusObserver()->TriggerVBusUpL());

   497 

   498 //    STIF_ASSERT_TRUE(iWatcher->iNotifManager->GetUsbIconBlinking());

   499     TDeviceEventInformation eventInfo;

   500     eventInfo.iEventType = EDeviceAttachment;

   501     eventInfo.iError = KErrBadPower;

   502     TRACE( "Trigger device attched - KErrBadPower" );

   503     iWatcher->HostEventNotificationObserver()->TriggerDeviceAttachedL(eventInfo);

   504     

   505     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostDelayNotAttachedHandle]);

   506 //    STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostHandleDropping]);

   507 

   508     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus());

   509 

   510 //    TRACE( "Trigger timer ETooMuchPowerRequiredTimer elapsed" );

   511 //    CUsbStateHostHandle* stateHostHandle = (CUsbStateHostHandle*)iWatcher->CurrentHostState();

   512 //    STIF_ASSERT_NOT_LEAVES( stateHostHandle->iTooMuchPowerTimer->TriggerTimerElapsedL() );

   513     

   514 //    STIF_ASSERT_FALSE(iWatcher->iNotifManager->iUsbIconBlinking);

   515 //    STIF_ASSERT_FALSE(iWatcher->iNotifManager->iUsbIconShown);

   516     

   517 //    STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusDown, iWatcher->VBusObserver()->VBus());

   518 

   519     TearDown();

   520 

   521     aTestResult = ETestCasePassed;

   522     

   523     TRACE("<<CtUsbOtgWatcher::DeviceAttached_TooMuchRequiredL");

   524     }

   525 

   526 void CtUsbOtgWatcher::DeviceAttached_SupportedDeviceL( TUsbOtgWatcherTestBlockParams& aParams,

   527         TUsbOtgWatcherTestResult& aTestResult )

   528     {

   529     TRACE(">>CtUsbOtgWatcher::DeviceAttached_SupportedDeviceL");

   530     

   531     SetupL();

   532 

   533     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   534     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceIdle" ) ) );

   535     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   536     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   537     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   538     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   539 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   540     

   541     iLog->Log(_L("PinOn triggered"));

   542     STIF_ASSERT_NOT_LEAVES(iWatcher->IdPinObserver()->TriggerPinOnL());

   543     iWatcher->iUsbServiceControl->RunL();

   544     iLog->Log(_L("Trigger vbus on"));

   545     STIF_ASSERT_NOT_LEAVES(iWatcher->VBusObserver()->TriggerVBusUpL());

   546 

   547     TDeviceEventInformation eventInfo;

   548     eventInfo.iEventType = EDeviceAttachment;

   549     eventInfo.iError = 0;

   550     iLog->Log(_L("Trigger device attached"));

   551     iWatcher->HostEventNotificationObserver()->TriggerDeviceAttachedL(eventInfo);

   552 

   553     eventInfo.iEventType = EDriverLoad;

   554     eventInfo.iError = 0;

   555     iLog->Log(_L("Trigger device driver loaded"));

   556     iWatcher->HostEventNotificationObserver()->TriggerDriverLoadSuccessL(eventInfo);

   557     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostAHost]);

   558 

   559 //    STIF_ASSERT_FALSE(iWatcher->iNotifManager->iUsbIconBlinking);

   560 //    

   561 //    STIF_ASSERT_TRUE(iWatcher->iNotifManager->iUsbIconShown);

   562 

   563     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus());

   564     

   565     TearDown();

   566 

   567     aTestResult = ETestCasePassed;

   568 

   569     TRACE("<<CtUsbOtgWatcher::DeviceAttached_SupportedDeviceL");

   570     }

   571 

   572 void CtUsbOtgWatcher::DeviceDetached_SupportedDeviceL( TUsbOtgWatcherTestBlockParams& aParams,

   573         TUsbOtgWatcherTestResult& aTestResult )

   574     {

   575     TRACE(">>CtUsbOtgWatcher::DeviceDetached_SupportedDeviceL");

   576     

   577     SetupL();

   578 

   579     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

   580     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceIdle" ) ) );

   581     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   582     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   583     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   584     iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, _L8( "UsbPersonalityIdMTP" ) ) );

   585 //    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EServiceState, 0, 0, _L8( "EUsbServiceStarted" ) ) );

   586     

   587     TRACE( "PinOn triggered" );

   588     STIF_ASSERT_NOT_LEAVES(iWatcher->IdPinObserver()->TriggerPinOnL());

   589     iWatcher->iUsbServiceControl->RunL();

   590     TRACE( "Trigger vbus on" );

   591     STIF_ASSERT_NOT_LEAVES(iWatcher->VBusObserver()->TriggerVBusUpL());

   592 

   593     TDeviceEventInformation eventInfo;

   594     eventInfo.iEventType = EDeviceAttachment;

   595     eventInfo.iError = 0;

   596     TRACE( "Trigger device attached" );

   597     iWatcher->HostEventNotificationObserver()->TriggerDeviceAttachedL(eventInfo);

   598 

   599     eventInfo.iEventType = EDriverLoad;

   600     eventInfo.iError = 0;

   601     TRACE( "Trigger device driver loaded" );

   602     iWatcher->HostEventNotificationObserver()->TriggerDriverLoadSuccessL(eventInfo);

   603 

   604     eventInfo.iEventType = EDeviceDetachment;

   605     eventInfo.iError = 0;

   606     TRACE( "Trigger device detached" );

   607     iWatcher->HostEventNotificationObserver()->TriggerDeviceDetachedL(eventInfo);

   608     

   609     STIF_ASSERT_TRUE(iWatcher->CurrentHostState() == iWatcher->iStates[EUsbStateHostAInitiate]);

   610 

   611 //    STIF_ASSERT_TRUE(iWatcher->iNotifManager->iUsbIconBlinking);

   612 

   613     STIF_ASSERT_EQUALS(CUsbVBusObserver::EVBusUp, iWatcher->VBusObserver()->VBus());

   614 

   615     TearDown();

   616 

   617     aTestResult = ETestCasePassed;

   618 

   619     TRACE("<<CtUsbOtgWatcher::DeviceDetached_SupportedDeviceL");

   620     }

   621 

   622 void CtUsbOtgWatcher::IndicatorNotifier_IndicatorActivateL( TUsbOtgWatcherTestBlockParams& aParams,

   623                             TUsbOtgWatcherTestResult& aTestResult )

   624     {

   625     TRACE(">> IndicatorNotifier_IndicatorActivateL"); 

   626      

   627     SetupL();

   628     

   629     CUsbNotifManager* notifManager = CUsbNotifManager::NewL(*iWatcher);

   630     CleanupStack::PushL(notifManager);

   631     CUsbIndicatorNotifier* notifier = CUsbIndicatorNotifier::NewL(*notifManager, *iWatcher);

   632     CleanupStack::PushL(notifier);        

   633     

   634     notifier->ToggleConnectingIndicator(ETrue);

   635     

   636     STIF_ASSERT_TRUE(notifier->iConnectingIndicatorOn);

   637                                 

   638     CleanupStack::PopAndDestroy(2);         

   639     

   640     TearDown();

   641       

   642     aTestResult = ETestCasePassed;                         

   643     TRACE("<< IndicatorNotifier_IndicatorActivateL");                                   

   644     }

   645 

   646 // Add other member functions implementation here

   647 

   648 void CtUsbOtgWatcher::SetupL()

   649     {

   650     TRACE_FUNC_ENTRY;

   651     

   652     TRACE( "UsbMan initialization" );

   653     iUsbMan = RUsb::NewL();

   654     User::LeaveIfNull(iUsbMan);

   655     TInt err; 

   656     

   657     TUsbServiceState serviceState;

   658     //set service state

   659     iUsbMan->SetUsbServiceState(EUsbServiceIdle);

   660     

   661     err = iUsbMan->GetServiceState(serviceState);

   662     TRACE_INFO( "UsbMan.GetServiceState err: %d", err );

   663     User::LeaveIfError(err);

   664 

   665     TRACE_INFO( "UsbMan.GetServiceState serviceState: %d, exspected: %d", serviceState, EUsbServiceIdle );

   666     if(serviceState != EUsbServiceIdle)

   667         {

   668         TRACE("UsbMan ServiceState didn't set properly!");

   669         User::Leave(KErrNotFound);

   670         }

   671    

   672     TRACE( "UsbOtgWatcher initialization" );

   673     iWatcher = CUsbOtgWatcher::NewL(*iUsbMan);

   674     if( !iWatcher )

   675         {

   676         TRACE("CUsbOtgWatcher::NewL Failed!");

   677         User::LeaveIfNull(iWatcher);

   678         }    

   679     

   680     iWatcher->VBusObserver()->SetRUsb(iUsbMan);

   681     

   682     TRACE_FUNC_EXIT;

   683     }

   684 

   685 void CtUsbOtgWatcher::TearDown()

   686     {

   687     TRACE_FUNC_ENTRY;

   688     

   689     TRACE("delete iWatcher");

   690     if (iWatcher)

   691         delete iWatcher;

   692     

   693     TRACE("delete iUsbMan");

   694     if (iUsbMan)

   695         delete iUsbMan;

   696     

   697     TRACE_FUNC_EXIT;

   698     }

   699 

   700 // ========================== OTHER EXPORTED FUNCTIONS =========================

   701 // None

   702 

   703 //  [End of File] - Do not remove