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 

    30 // EXTERNAL DATA STRUCTURES

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES  

    33 

    34 // CONSTANTS

    35 

    36 // MACROS

    37 

    38 // LOCAL CONSTANTS AND MACROS

    39 

    40 // MODULE DATA STRUCTURES

    41 

    42 // LOCAL FUNCTION PROTOTYPES

    43 

    44 // FORWARD DECLARATIONS

    45 

    46 // ============================= LOCAL FUNCTIONS ===============================

    47 

    48 // -----------------------------------------------------------------------------

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

    50 

    51 // ============================ MEMBER FUNCTIONS ===============================

    52 

    53 // -----------------------------------------------------------------------------

    54 // CtUsbOtgWatcher::TestConstructL

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

    56 // Called from ConstructL. 

    57 // -----------------------------------------------------------------------------

    58 

    59 void CtUsbOtgWatcher::TestConstructL()

    60     {

    61     TRACE_FUNC_ENTRY

    62     

    63     iStubber = CStubber::NewL();

    64     

    65     TRACE_FUNC_EXIT

    66     }

    67 

    68 // -----------------------------------------------------------------------------

    69 // CtUsbOtgWatcher::TestDelete

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

    71 // Called from destructor. 

    72 // -----------------------------------------------------------------------------

    73 

    74 void CtUsbOtgWatcher::TestDelete() 

    75     {

    76     TRACE_FUNC_ENTRY

    77     

    78     delete iStubber;

    79     

    80     TRACE_FUNC_EXIT

    81     }

    82 

    83 // -----------------------------------------------------------------------------

    84 // CtUsbOtgWatcher::TestBlocksInfoL

    85 // Add new test block parameter entries below

    86 // -----------------------------------------------------------------------------

    87 

    88 void CtUsbOtgWatcher::TestBlocksInfoL()

    89     {

    90     

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

    92             {

    93             TESTPARAM( eGetString, eTestOption1 )

    94             TESTPARAM( eGetString, eTestOption2 )

    95             TESTPARAM( eGetInt, eTestIntOption1 )

    96             TESTPARAM( eGetChar, eTestCharOption1 )

    97             }

    98     

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

   100                 {

   101                 TESTPARAM( eGetString, eTestOption1 )

   102                 }

   103 

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

   105                 {

   106                 TESTPARAM( eGetString, eTestOption1 )

   107                 }

   108     

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

   110                 {

   111                 TESTPARAM( eGetString, eTestOption1 )

   112                 }

   113     

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

   115                 {

   116                 TESTPARAM( eGetString, eTestOption1 )

   117                 }

   118     

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

   120                 {

   121                 TESTPARAM( eGetString, eTestOption1 )

   122                 }

   123     

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

   125                 {

   126                 TESTPARAM( eGetString, eTestOption1 )

   127                 }

   128     

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

   130                 {

   131                 TESTPARAM( eGetString, eTestOption1 )

   132                 }

   133     

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

   135                 {

   136                 TESTPARAM( eGetString, eTestOption1 )

   137                 }

   138     

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

   140                 {

   141                 TESTPARAM( eGetString, eTestOption1 )

   142                 }

   143     

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

   145                 {

   146                 TESTPARAM( eGetString, eTestOption1 )

   147                 }

   148     }

   149 

   150 // Add test block methods implementation here

   151 // -----------------------------------------------------------------------------

   152 // CtUsbOtgWatcher::ExampleTestL

   153 // -----------------------------------------------------------------------------

   154 

   155 void CtUsbOtgWatcher::ExampleTestL( TUsbOtgWatcherTestBlockParams& aParams,

   156                                             TUsbOtgWatcherTestResult& aTestResult )

   157     {

   158     TRACE_FUNC_ENTRY

   159     

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

   161     

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

   163         {

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

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

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

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

   168         }

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

   170         {

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

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

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

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

   175         }

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

   177         {

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

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

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

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

   182         }

   183     else

   184         {

   185         TRACE( "Invalid test parameter" )

   186         TRACE_FUNC_EXIT

   187         User::Leave( KErrNotFound );

   188         }

   189     

   190     aTestResult = ETestCasePassed;

   191     TRACE_FUNC_EXIT

   192     }

   193 

   194 

   195 void CtUsbOtgWatcher::SetupTearDownL( TUsbOtgWatcherTestBlockParams& aParams,

   196                                             TUsbOtgWatcherTestResult& aTestResult )

   197     {

   198     TRACE_FUNC_ENTRY;

   199 

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

   201     SetupL();

   202     

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

   204     TearDown();

   205 

   206     aTestResult = ETestCasePassed;

   207     }

   208 

   209 

   210 void CtUsbOtgWatcher::PinOnTest_SuccessL( TUsbOtgWatcherTestBlockParams& aParams,

   211         TUsbOtgWatcherTestResult& aTestResult )

   212     {

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

   214     

   215     SetupL();

   216     

   217     // Idpin observer should be subscribed

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

   219     

   220     TRACE( "State machine initialized" );

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

   222     STIF_ASSERT_NOT_NULL(aInitiate);

   223     

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

   225 

   226     TRACE( "Trigger pin on" );

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

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

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

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

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

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

   233     

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

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

   236     

   237     iWatcher->iUsbServiceControl->RunL();

   238         

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

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

   241     

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

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

   244     

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

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

   247     

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

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

   250     

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

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

   253     

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

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

   256       

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

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

   259         

   260     

   261     TRACE( "Trigger vbus on" );

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

   263     

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

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

   266     

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

   268     

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

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

   271     

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

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

   274     

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

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

   277 

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

   279     

   280     TearDown();

   281 

   282     aTestResult = ETestCasePassed;

   283     

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

   285     }

   286 

   287 void CtUsbOtgWatcher::PinOffTest_SuccessL( TUsbOtgWatcherTestBlockParams& aParams,

   288         TUsbOtgWatcherTestResult& aTestResult )

   289     {

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

   291     SetupL();

   292     

   293     // Idpin observer should be subscribed

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

   295     

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

   297 

   298     TRACE( "Trigger pin on" );

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

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

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

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

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

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

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

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

   307     iWatcher->iUsbServiceControl->RunL();

   308     

   309     TRACE( "Trigger vbus on" );

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

   311     

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

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

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

   315         

   316     TRACE( "Trigger vbus off" );

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

   318     iWatcher->iUsbServiceControl->RunL();

   319     

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

   321 

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

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

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

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

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

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

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

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

   330 

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

   332     TearDown();

   333 

   334     aTestResult = ETestCasePassed;

   335     

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

   337     }

   338 

   339 void CtUsbOtgWatcher::PinOnTest_EmptyCableL( TUsbOtgWatcherTestBlockParams& aParams,

   340         TUsbOtgWatcherTestResult& aTestResult )

   341     {

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

   343     SetupL();

   344     

   345     TRACE("State machine initialized");

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

   347 

   348     TRACE( "Trigger pin on" );

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

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

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

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

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

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

   355        

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

   357     iWatcher->iUsbServiceControl->RunL();

   358     

   359     TRACE( "Trigger vbus on" );

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

   361     

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

   363     

   364     TRACE( "Trigger attachment timer elapsed" );

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

   366     aInitiate->iAttachmentTimer->TriggerTimerElapsedL();

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

   368 

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

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

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

   372     

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

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

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

   376     

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

   378     TearDown();

   379 

   380     aTestResult = ETestCasePassed;

   381     

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

   383     }

   384 

   385 void CtUsbOtgWatcher::PinOnTest_TryStartErrorL( TUsbOtgWatcherTestBlockParams& aParams,

   386         TUsbOtgWatcherTestResult& aTestResult )

   387     {

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

   389 

   390     SetupL();

   391     

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

   393     STIF_ASSERT_NOT_NULL(aInitiate);

   394 

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

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

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

   398 

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

   400     

   401     TearDown();

   402 

   403     aTestResult = ETestCasePassed;

   404 

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

   406     }

   407 

   408 void CtUsbOtgWatcher::PinOnTest_BusRequestErrorL( TUsbOtgWatcherTestBlockParams& aParams,

   409         TUsbOtgWatcherTestResult& aTestResult )

   410     {

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

   412     

   413     SetupL();

   414     

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

   416     STIF_ASSERT_NOT_NULL(aInitiate);

   417 

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

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

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

   421 

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

   423     

   424     TearDown();

   425 

   426     aTestResult = ETestCasePassed;

   427 

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

   429     }

   430 

   431 void CtUsbOtgWatcher::DeviceAttached_BadHubPostionL( TUsbOtgWatcherTestBlockParams& aParams,

   432         TUsbOtgWatcherTestResult& aTestResult )

   433     {

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

   435     SetupL();

   436 

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

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

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

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

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

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

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

   444     

   445     TRACE( "PinOn triggered" );

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

   447     iWatcher->iUsbServiceControl->RunL();

   448     

   449     TRACE( "Trigger vbus on" );

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

   451 

   452     TRACE( "BadHubPosition triggered" );

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

   454     TRACE( "BadHubPosition test result" );

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

   456 

   457     TRACE( "Poscondition check" );

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

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

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

   461     

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

   463 

   464     TearDown();

   465 

   466     aTestResult = ETestCasePassed;

   467 

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

   469     }

   470 

   471 void CtUsbOtgWatcher::DeviceAttached_TooMuchRequiredL( TUsbOtgWatcherTestBlockParams& aParams,

   472         TUsbOtgWatcherTestResult& aTestResult )

   473     {

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

   475     SetupL();

   476 

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

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

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

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

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

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

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

   484         

   485     TRACE( "PinOn triggered" );

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

   487     iWatcher->iUsbServiceControl->RunL();

   488     

   489     TRACE( "Trigger vbus on" );

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

   491 

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

   493     TDeviceEventInformation eventInfo;

   494     eventInfo.iEventType = EDeviceAttachment;

   495     eventInfo.iError = KErrBadPower;

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

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

   498     

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

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

   501 

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

   503 

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

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

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

   507     

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

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

   510     

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

   512 

   513     TearDown();

   514 

   515     aTestResult = ETestCasePassed;

   516     

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

   518     }

   519 

   520 void CtUsbOtgWatcher::DeviceAttached_SupportedDeviceL( TUsbOtgWatcherTestBlockParams& aParams,

   521         TUsbOtgWatcherTestResult& aTestResult )

   522     {

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

   524     

   525     SetupL();

   526 

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

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

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

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

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

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

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

   534     

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

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

   537     iWatcher->iUsbServiceControl->RunL();

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

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

   540 

   541     TDeviceEventInformation eventInfo;

   542     eventInfo.iEventType = EDeviceAttachment;

   543     eventInfo.iError = 0;

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

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

   546 

   547     eventInfo.iEventType = EDriverLoad;

   548     eventInfo.iError = 0;

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

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

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

   552 

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

   554 //    

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

   556 

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

   558     

   559     TearDown();

   560 

   561     aTestResult = ETestCasePassed;

   562 

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

   564     }

   565 

   566 void CtUsbOtgWatcher::DeviceDetached_SupportedDeviceL( TUsbOtgWatcherTestBlockParams& aParams,

   567         TUsbOtgWatcherTestResult& aTestResult )

   568     {

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

   570     

   571     SetupL();

   572 

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

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

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

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

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

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

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

   580     

   581     TRACE( "PinOn triggered" );

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

   583     iWatcher->iUsbServiceControl->RunL();

   584     TRACE( "Trigger vbus on" );

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

   586 

   587     TDeviceEventInformation eventInfo;

   588     eventInfo.iEventType = EDeviceAttachment;

   589     eventInfo.iError = 0;

   590     TRACE( "Trigger device attached" );

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

   592 

   593     eventInfo.iEventType = EDriverLoad;

   594     eventInfo.iError = 0;

   595     TRACE( "Trigger device driver loaded" );

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

   597 

   598     eventInfo.iEventType = EDeviceDetachment;

   599     eventInfo.iError = 0;

   600     TRACE( "Trigger device detached" );

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

   602     

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

   604 

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

   606 

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

   608 

   609     TearDown();

   610 

   611     aTestResult = ETestCasePassed;

   612 

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

   614     }

   615 

   616 

   617 // Add other member functions implementation here

   618 

   619 void CtUsbOtgWatcher::SetupL()

   620     {

   621     TRACE_FUNC_ENTRY;

   622     

   623     TRACE( "UsbMan initialization" );

   624     iUsbMan = RUsb::NewL();

   625     User::LeaveIfNull(iUsbMan);

   626     TInt err; 

   627     

   628     TUsbServiceState serviceState;

   629     //set service state

   630     iUsbMan->SetUsbServiceState(EUsbServiceIdle);

   631     

   632     err = iUsbMan->GetServiceState(serviceState);

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

   634     User::LeaveIfError(err);

   635 

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

   637     if(serviceState != EUsbServiceIdle)

   638         {

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

   640         User::Leave(KErrNotFound);

   641         }

   642    

   643     TRACE( "UsbOtgWatcher initialization" );

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

   645     if( !iWatcher )

   646         {

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

   648         User::LeaveIfNull(iWatcher);

   649         }    

   650     

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

   652     

   653     TRACE_FUNC_EXIT;

   654     }

   655 

   656 void CtUsbOtgWatcher::TearDown()

   657     {

   658     TRACE_FUNC_ENTRY;

   659     

   660     TRACE("delete iWatcher");

   661     if (iWatcher)

   662         delete iWatcher;

   663     

   664     TRACE("delete iUsbMan");

   665     if (iUsbMan)

   666         delete iUsbMan;

   667     

   668     TRACE_FUNC_EXIT;

   669     }

   670 

   671 // ========================== OTHER EXPORTED FUNCTIONS =========================

   672 // None

   673 

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