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

    23 #include "testdebug.h"

    24 #include <ecom/ecom.h>

    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 // CUsbMscPersonalityTest::TestConstructL

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

    51 // Called from ConstructL. 

    52 // -----------------------------------------------------------------------------

    53 

    54 void CUsbMscPersonalityTest::TestConstructL()

    55     {

    56     TRACE_FUNC_ENTRY

    57 

    58     if (!CActiveScheduler::Current())

    59         {

    60         iScheduler = new (ELeave) CActiveScheduler;

    61         CActiveScheduler::Install(iScheduler);

    62         }

    63 

    64     iUsb = new (ELeave) RUsb;

    65     iNotifier = CUsbPersonalityNotifier::NewL();

    66     iParams = new (ELeave) TUsbPersonalityParams(*iUsb, *iNotifier);

    67     //    iParams->SetPersonalityId(2);

    68     iPlugin = CUsbPersonalityPlugin::NewL(*iParams, TUid::Uid(0x1020DF7B));

    69     

    70     TRACE_FUNC_EXIT

    71     }

    72 

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

    74 // CUsbMscPersonalityTest::TestDelete

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

    76 // Called from destructor. 

    77 // -----------------------------------------------------------------------------

    78 

    79 void CUsbMscPersonalityTest::TestDelete()

    80     {

    81     TRACE_FUNC_ENTRY

    82 

    83     if (iScheduler)

    84         {

    85         iScheduler->Stop();

    86         delete iScheduler;

    87         iScheduler = NULL;

    88         }

    89 

    90     if (iUsb)

    91         {

    92         delete iUsb;

    93         iUsb = NULL;

    94         }

    95 

    96     if (iNotifier)

    97         {

    98         delete iNotifier;

    99         }

   100 

   101     if (iParams)

   102         {

   103         delete iParams;

   104         iParams = NULL;

   105         }

   106 

   107     if (iPlugin)

   108         {

   109         iPlugin->Cancel();

   110         delete iPlugin;

   111         iPlugin = NULL;

   112         }

   113 

   114     if (iActive)

   115         {

   116         delete iActive;

   117         iActive = NULL;

   118         }

   119     

   120     if (iDismountClient)

   121         {

   122         delete iDismountClient;

   123         iDismountClient = NULL;

   124         }

   125     

   126     REComSession::FinalClose();

   127 

   128     TRACE_FUNC_EXIT

   129     }

   130 

   131 // -----------------------------------------------------------------------------

   132 // CUsbMscPersonalityTest::TestBlocksInfoL

   133 // Add new test block parameter entries below

   134 // -----------------------------------------------------------------------------

   135 

   136 void CUsbMscPersonalityTest::TestBlocksInfoL()

   137     {

   138 

   139     TESTENTRY( "ExampleTestL", CUsbMscPersonalityTest::ExampleTestL )

   140         {

   141         TESTPARAM( eGetString, eTestOption1 )

   142         TESTPARAM( eGetString, eTestOption2 )

   143         TESTPARAM( eGetInt, eTestIntOption1 )

   144         TESTPARAM( eGetChar, eTestCharOption1 )

   145         }

   146     TESTENTRY( "PreparePersonalityStartTestL", CUsbMscPersonalityTest::PreparePersonalityStartTestL )

   147         {

   148         TESTPARAM( eGetString, eTestOption1 )

   149         }

   150     TESTENTRY( "FinishPersonalityStartTestL", CUsbMscPersonalityTest::FinishPersonalityStartTestL )

   151         {

   152         TESTPARAM( eGetString, eTestOption1 )

   153         }

   154     TESTENTRY( "PreparePersonalityStopTestL", CUsbMscPersonalityTest::PreparePersonalityStopTestL )

   155         {

   156         TESTPARAM( eGetString, eTestOption1 )

   157         }

   158     TESTENTRY( "FinishPersonalityStopTestL", CUsbMscPersonalityTest::FinishPersonalityStopTestL )

   159         {

   160         TESTPARAM( eGetString, eTestOption1 )

   161         }

   162     TESTENTRY( "InitializationTestL", CUsbMscPersonalityTest::InitializationTestL )

   163         {

   164         TESTPARAM( eGetString, eTestOption1 )

   165         }

   166     TESTENTRY( "StateChangeNotifyTestL", CUsbMscPersonalityTest::StateChangeNotifyTestL )

   167         {

   168         TESTPARAM( eGetString, eTestOption1 )

   169         }

   170     TESTENTRY( "StateChangeNotifyUndefinedTestL", CUsbMscPersonalityTest::StateChangeNotifyUndefinedTestL )

   171         {

   172         TESTPARAM( eGetString, eTestOption1 )

   173         }

   174     TESTENTRY( "StateChangeNotifyStateAddressTestL", CUsbMscPersonalityTest::StateChangeNotifyStateAddressTestL )

   175         {

   176         TESTPARAM( eGetString, eTestOption1 )

   177         }

   178     TESTENTRY( "ConfirmPersonalityUnloadTestL", CUsbMscPersonalityTest::ConfirmPersonalityUnloadTestL )

   179         {

   180         TESTPARAM( eGetString, eTestOption1 )

   181         }

   182     TESTENTRY( "AllowDismountAfter2SecTestL", CUsbMscPersonalityTest::AllowDismountAfter2SecTestL )

   183         {

   184         TESTPARAM( eGetString, eTestOption1 )

   185         }

   186     TESTENTRY( "AllowDismountTestL", CUsbMscPersonalityTest::AllowDismountTestL )

   187         {

   188         TESTPARAM( eGetString, eTestOption1 )

   189         }

   190     TESTENTRY( "NotAllowDismountTestL", CUsbMscPersonalityTest::NotAllowDismountTestL )

   191         {

   192         TESTPARAM( eGetString, eTestOption1 )

   193         }

   194     TESTENTRY( "AllowDismountTooLateTestL", CUsbMscPersonalityTest::AllowDismountTooLateTestL )

   195         {

   196         TESTPARAM( eGetString, eTestOption1 )

   197         }

   198 

   199     }

   200 

   201 // Add test block methods implementation here

   202 // -----------------------------------------------------------------------------

   203 // CUsbMscPersonalityTest::ExampleTestL

   204 // -----------------------------------------------------------------------------

   205 

   206 void CUsbMscPersonalityTest::ExampleTestL(

   207         TUsbMscPersonalityTestBlockParams& aParams,

   208         TUsbMscPersonalityTestResult& aTestResult)

   209     {

   210     TRACE_FUNC_ENTRY

   211 

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

   213         {

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

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

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

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

   218         }

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

   220         {

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

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

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

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

   225         }

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

   227         {

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

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

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

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

   232         }

   233     else

   234         {

   235         TRACE( "Invalid test parameter" )

   236         TRACE_FUNC_EXIT

   237         User::Leave(KErrNotFound);

   238         }

   239 

   240     aTestResult = ETestCasePassed;

   241     TRACE_FUNC_EXIT

   242     }

   243 

   244 void CUsbMscPersonalityTest::InitializeTestObjectsL()

   245     {

   246     iActive

   247             = CUsbMscPersonalityTestActiveObject::NewL(iPlugin, iLog, iParams);

   248     iDismountClient = CDismountClient::NewL(iLog);

   249     TRACE ( " test objects initialized " );

   250     }

   251 

   252 void CUsbMscPersonalityTest::DeleteTestObjects()

   253     {

   254     delete iActive;

   255     iActive = NULL;

   256     delete iDismountClient;

   257     iDismountClient = NULL;

   258     TRACE ( " test objects deleted " );

   259     }

   260 

   261 void CUsbMscPersonalityTest::InitializationTestL(

   262         TUsbMscPersonalityTestBlockParams& aParams,

   263         TUsbMscPersonalityTestResult& aTestResult)

   264     {

   265     InitializeTestObjectsL();

   266     TRACE( "checking iPlugin")

   267     if (iPlugin)

   268         {

   269         aTestResult = ETestCasePassed;

   270         }

   271     else

   272         {

   273         TRACE( "no iplugin instance")

   274         }

   275 

   276     DeleteTestObjects();

   277     }

   278 

   279 void CUsbMscPersonalityTest::ExecuteDismounting()

   280     {

   281     iActive->PreparePersonalityStart(iRequestStatus);

   282     iActive->FinishPersonalityStart(iRequestStatus);

   283     iActive->PreparePersonalityStop(iRequestStatus);

   284     iActive->FinishPersonalityStop(iRequestStatus);

   285     }

   286 

   287 void CUsbMscPersonalityTest::PreparePersonalityStartTestL(

   288         TUsbMscPersonalityTestBlockParams& aParams,

   289         TUsbMscPersonalityTestResult& aTestResult)

   290     {

   291     InitializeTestObjectsL();

   292 

   293     iActive->PreparePersonalityStart(iRequestStatus);

   294 

   295     TRACE_INFO( "prepare personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   296     User::LeaveIfError(iRequestStatus.Int());

   297     

   298     aTestResult = ETestCasePassed;

   299     DeleteTestObjects();

   300     }

   301 

   302 void CUsbMscPersonalityTest::FinishPersonalityStartTestL(

   303         TUsbMscPersonalityTestBlockParams& aParams,

   304         TUsbMscPersonalityTestResult& aTestResult)

   305     {

   306     InitializeTestObjectsL();

   307 

   308     iActive->PreparePersonalityStart(iRequestStatus);

   309     TRACE_INFO( "prepare personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   310     User::LeaveIfError(iRequestStatus.Int());

   311 

   312     iActive->FinishPersonalityStart(iRequestStatus);

   313     TRACE_INFO( "finish personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   314 

   315     iActive->PreparePersonalityStop(iRequestStatus);

   316     iActive->FinishPersonalityStart(iRequestStatus);

   317     User::LeaveIfError(iRequestStatus.Int());

   318 

   319     aTestResult = ETestCasePassed;

   320 

   321     DeleteTestObjects();

   322     }

   323 

   324 void CUsbMscPersonalityTest::PreparePersonalityStopTestL(

   325         TUsbMscPersonalityTestBlockParams& aParams,

   326         TUsbMscPersonalityTestResult& aTestResult)

   327     {

   328     InitializeTestObjectsL();

   329 

   330     iActive->PreparePersonalityStart(iRequestStatus);

   331     TRACE_INFO( "prepare personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   332     User::LeaveIfError( iRequestStatus.Int() );

   333 

   334     iActive->FinishPersonalityStart(iRequestStatus);

   335     TRACE_INFO( "finish personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   336     User::LeaveIfError( iRequestStatus.Int() );

   337 

   338     iActive->PreparePersonalityStop(iRequestStatus);

   339     TRACE_INFO( "prepare personality stop status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   340     User::LeaveIfError( iRequestStatus.Int() );

   341         

   342     aTestResult = ETestCasePassed;

   343 

   344     DeleteTestObjects();

   345     }

   346 

   347 void CUsbMscPersonalityTest::FinishPersonalityStopTestL(

   348         TUsbMscPersonalityTestBlockParams& aParams,

   349         TUsbMscPersonalityTestResult& aTestResult)

   350     {

   351     InitializeTestObjectsL();

   352 

   353     iActive->PreparePersonalityStart(iRequestStatus);

   354     TRACE_INFO( "prepare personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   355     User::LeaveIfError( iRequestStatus.Int() );

   356 

   357     iActive->FinishPersonalityStart(iRequestStatus);

   358     TRACE_INFO( "finish personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   359     User::LeaveIfError( iRequestStatus.Int() );

   360 

   361     iActive->PreparePersonalityStop(iRequestStatus);

   362     TRACE_INFO( "prepare personality stop status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   363     User::LeaveIfError( iRequestStatus.Int() );

   364 

   365     iActive->FinishPersonalityStop(iRequestStatus);

   366     TRACE_INFO( "finish personality stop status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   367     User::LeaveIfError( iRequestStatus.Int() );

   368         

   369     aTestResult = ETestCasePassed;

   370 

   371     DeleteTestObjects();

   372     }

   373 

   374 void CUsbMscPersonalityTest::ConfirmPersonalityUnloadTestL(

   375         TUsbMscPersonalityTestBlockParams& aParams,

   376         TUsbMscPersonalityTestResult& aTestResult)

   377     {

   378     InitializeTestObjectsL();

   379 

   380     TRACE_INFO( "prepare personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   381     User::LeaveIfError( iRequestStatus.Int() );

   382 

   383     iActive->FinishPersonalityStart(iRequestStatus);

   384     TRACE_INFO( "finish personality start status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   385     User::LeaveIfError( iRequestStatus.Int() );

   386 

   387     iActive->ConfirmPersonalityUnload(iRequestStatus);

   388     User::After(5000);

   389     TRACE_INFO( "confirm personality unload status: %d, expected: %d", iRequestStatus.Int(), KErrNone );

   390     User::LeaveIfError( iRequestStatus.Int() );

   391         

   392     aTestResult = ETestCasePassed;

   393 

   394     DeleteTestObjects();

   395     }

   396 

   397 void CUsbMscPersonalityTest::StateChangeNotifyTestL(

   398         TUsbMscPersonalityTestBlockParams& aParams,

   399         TUsbMscPersonalityTestResult& aTestResult)

   400     {

   401     InitializeTestObjectsL();

   402 

   403     TUsbDeviceState state = EUsbDeviceStateDefault;

   404     iPlugin->StateChangeNotify(state);

   405 

   406     aTestResult = ETestCasePassed;

   407 

   408     DeleteTestObjects();

   409     }

   410 

   411 void CUsbMscPersonalityTest::StateChangeNotifyUndefinedTestL( TUsbMscPersonalityTestBlockParams& aParams, 

   412                 TUsbMscPersonalityTestResult& aTestResult )

   413     {

   414     InitializeTestObjectsL();

   415 

   416     TUsbDeviceState state = EUsbDeviceStateUndefined;

   417     iPlugin->StateChangeNotify(state);

   418 

   419     aTestResult = ETestCasePassed;

   420 

   421     DeleteTestObjects();

   422     }

   423 

   424 void CUsbMscPersonalityTest::StateChangeNotifyStateAddressTestL( TUsbMscPersonalityTestBlockParams& aParams, 

   425                 TUsbMscPersonalityTestResult& aTestResult )

   426     {

   427     InitializeTestObjectsL();

   428 

   429     TUsbDeviceState state = EUsbDeviceStateAddress;

   430     iPlugin->StateChangeNotify(state);

   431 

   432     User::After( 2000000 );

   433     iPlugin->Cancel();

   434     

   435     aTestResult = ETestCasePassed;

   436 

   437     DeleteTestObjects();

   438     }

   439 

   440 void CUsbMscPersonalityTest::AllowDismountAfter2SecTestL(

   441         TUsbMscPersonalityTestBlockParams& aParams,

   442         TUsbMscPersonalityTestResult& aTestResult)

   443     {

   444     InitializeTestObjectsL();

   445     iDismountClient->StartL(EAllowDismountAfter2Sec);

   446     iActive->PreparePersonalityStart(iRequestStatus);

   447     ExecuteDismounting();

   448 

   449     aTestResult = ETestCasePassed;

   450     DeleteTestObjects();

   451     }

   452 

   453 void CUsbMscPersonalityTest::AllowDismountTestL(

   454         TUsbMscPersonalityTestBlockParams& aParams,

   455         TUsbMscPersonalityTestResult& aTestResult)

   456     {

   457     InitializeTestObjectsL();

   458     iDismountClient->StartL(EAllowDismount);

   459     iActive->PreparePersonalityStart(iRequestStatus);

   460     ExecuteDismounting();

   461 

   462     aTestResult = ETestCasePassed;

   463     DeleteTestObjects();

   464     }

   465 

   466 void CUsbMscPersonalityTest::NotAllowDismountTestL(

   467         TUsbMscPersonalityTestBlockParams& aParams,

   468         TUsbMscPersonalityTestResult& aTestResult)

   469     {

   470     InitializeTestObjectsL();

   471     iDismountClient->StartL(ENotAllowDismount);

   472     iActive->PreparePersonalityStart(iRequestStatus);

   473     ExecuteDismounting();

   474 

   475     aTestResult = ETestCasePassed;

   476     DeleteTestObjects();

   477     }

   478 

   479 void CUsbMscPersonalityTest::AllowDismountTooLateTestL(

   480         TUsbMscPersonalityTestBlockParams& aParams,

   481         TUsbMscPersonalityTestResult& aTestResult)

   482     {

   483     InitializeTestObjectsL();

   484     iDismountClient->StartL(EAllowDismountTooLate);

   485     iActive->PreparePersonalityStart(iRequestStatus);

   486     ExecuteDismounting();

   487 

   488     aTestResult = ETestCasePassed;

   489     DeleteTestObjects();

   490     }

   491 // Add other member functions implementation here

   492 

   493 

   494 // ========================== OTHER EXPORTED FUNCTIONS =========================

   495 // None

   496 

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