1 /*

     2 * Copyright (c) 2002-2009 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:          SenServiceManager_stif class member functions

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 // INCLUDE FILES

    27 #include <StifTestInterface.h>

    28 #include "senservicemanagerbctest.h"

    29 

    30 // EXTERNAL DATA STRUCTURES

    31 //extern  ?external_data;

    32 

    33 // EXTERNAL FUNCTION PROTOTYPES  

    34 //extern ?external_function( ?arg_type,?arg_type );

    35 

    36 // CONSTANTS

    37 //const ?type ?constant_var = ?constant;

    38 

    39 // MACROS

    40 //#define ?macro ?macro_def

    41 

    42 // LOCAL CONSTANTS AND MACROS

    43 //const ?type ?constant_var = ?constant;

    44 //#define ?macro_name ?macro_def

    45 

    46 // MODULE DATA STRUCTURES

    47 //enum ?declaration

    48 //typedef ?declaration

    49 

    50 // LOCAL FUNCTION PROTOTYPES

    51 //?type ?function_name( ?arg_type, ?arg_type );

    52 

    53 // FORWARD DECLARATIONS

    54 //class ?FORWARD_CLASSNAME;

    55 

    56 // ============================= LOCAL FUNCTIONS ===============================

    57 

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

    59 // ?function_name ?description.

    60 // ?description

    61 // Returns: ?value_1: ?description

    62 //          ?value_n: ?description_line1

    63 //                    ?description_line2

    64 // -----------------------------------------------------------------------------

    65 //

    66 /*

    67 ?type ?function_name(

    68     ?arg_type arg,  // ?description

    69     ?arg_type arg)  // ?description

    70     {

    71 

    72     ?code  // ?comment

    73 

    74     // ?comment

    75     ?code

    76     }

    77 */

    78 

    79 // ============================ MEMBER FUNCTIONS ===============================

    80 

    81 // -----------------------------------------------------------------------------

    82 // CSenServiceManagerBCTest::CSenServiceManagerBCTest

    83 // C++ default constructor can NOT contain any code, that

    84 // might leave.

    85 // -----------------------------------------------------------------------------

    86 //

    87 CSenServiceManagerBCTest::CSenServiceManagerBCTest()

    88     {

    89 

    90     }

    91 

    92 // -----------------------------------------------------------------------------

    93 // CSenServiceManagerBCTest::ConstructL

    94 // Symbian 2nd phase constructor can leave.

    95 //

    96 // Note: If OOM test case uses STIF Logger, then STIF Logger must be created

    97 // with static buffer size parameter (aStaticBufferSize). Otherwise Logger 

    98 // allocates memory from heap and therefore causes error situations with OOM 

    99 // testing. For more information about STIF Logger construction, see STIF Users 

   100 // Guide.

   101 // -----------------------------------------------------------------------------

   102 //

   103 void CSenServiceManagerBCTest::ConstructL()

   104     {

   105     iLog = CStifLogger::NewL( KSenServiceManager_stifLogPath, 

   106                           KSenServiceManager_stifLogFile);

   107 

   108     // Sample how to use logging

   109     _LIT( KLogStart, "SenServiceManager_stif logging starts!" );

   110     iLog->Log( KLogStart );

   111     

   112     iActiveScheduler = new CActiveScheduler;

   113 	CActiveScheduler::Install( iActiveScheduler );

   114 	

   115 

   116     }

   117 

   118 // -----------------------------------------------------------------------------

   119 // CSenServiceManagerBCTest::NewL

   120 // Two-phased constructor.

   121 // -----------------------------------------------------------------------------

   122 //

   123 CSenServiceManagerBCTest* CSenServiceManagerBCTest::NewL()

   124     {

   125     CSenServiceManagerBCTest* self = new (ELeave) CSenServiceManagerBCTest;

   126 

   127     CleanupStack::PushL( self );

   128     self->ConstructL();

   129     CleanupStack::Pop();

   130 

   131     return self;

   132 

   133     }

   134 

   135 // Destructor

   136 CSenServiceManagerBCTest::~CSenServiceManagerBCTest()

   137     {

   138     delete iLog;

   139     

   140     delete iActiveScheduler;

   141    

   142     }

   143 

   144 // -----------------------------------------------------------------------------

   145 // CSenServiceManagerBCTest::InitL

   146 // InitL is used to initialize the Test Module.

   147 // -----------------------------------------------------------------------------

   148 //

   149 TInt CSenServiceManagerBCTest::InitL( 

   150     TFileName& /*aIniFile*/, 

   151     TBool /*aFirstTime*/ )

   152     {

   153     return KErrNone;

   154 

   155     }

   156 

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

   158 // CSenServiceManagerBCTest::GetTestCasesL

   159 // GetTestCases is used to inquire test cases from the Test Module. Test

   160 // cases are stored to array of test cases. The Test Framework will be 

   161 // the owner of the data in the RPointerArray after GetTestCases return

   162 // and it does the memory deallocation. 

   163 // -----------------------------------------------------------------------------

   164 //

   165 TInt CSenServiceManagerBCTest::GetTestCasesL( 

   166     const TFileName& /*aConfig*/, 

   167     RPointerArray<TTestCaseInfo>& aTestCases )

   168     {

   169 

   170     // Loop through all test cases and create new

   171     // TTestCaseInfo items and append items to aTestCase array    

   172     for( TInt i = 0; Case(i).iMethod != NULL; i++ )

   173         {

   174 

   175         // Allocate new TTestCaseInfo from heap for a testcase definition.

   176         TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo();

   177 

   178         // PushL TTestCaseInfo to CleanupStack.    

   179         CleanupStack::PushL( newCase );

   180 

   181         // Set number for the testcase.

   182         // When the testcase is run, this comes as a parameter to RunTestCaseL.

   183         newCase->iCaseNumber = i;

   184 

   185         // Set title for the test case. This is shown in UI to user.

   186         newCase->iTitle.Copy( Case(i).iCaseName );

   187 

   188         // Append TTestCaseInfo to the testcase array. After appended 

   189         // successfully the TTestCaseInfo object is owned (and freed) 

   190         // by the TestServer. 

   191         User::LeaveIfError(aTestCases.Append ( newCase ) );

   192 

   193         // Pop TTestCaseInfo from the CleanupStack.

   194         CleanupStack::Pop( newCase );

   195 

   196         }

   197 

   198     return KErrNone;

   199 

   200     }

   201 

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

   203 // CSenServiceManagerBCTest::RunTestCaseL

   204 // RunTestCaseL is used to run an individual test case specified 

   205 // by aTestCase. Test cases that can be run may be requested from 

   206 // Test Module by GetTestCases method before calling RunTestCase.

   207 // -----------------------------------------------------------------------------

   208 //

   209 TInt CSenServiceManagerBCTest::RunTestCaseL( 

   210     const TInt aCaseNumber,   

   211     const TFileName& /*aConfig*/,

   212     TTestResult& aResult )

   213     {

   214 

   215     // Return value

   216     TInt execStatus = KErrNone;

   217 

   218     // Get the pointer to test case function

   219     TCaseInfo tmp = Case ( aCaseNumber );

   220 

   221     _LIT( KLogStartTC, "Starting testcase [%S]" );

   222     iLog->Log( KLogStartTC, &tmp.iCaseName);

   223 

   224     // Check that case number was valid

   225     if ( tmp.iMethod != NULL )

   226         {

   227         // Valid case was found, call it via function pointer

   228         iMethod = tmp.iMethod;        

   229         execStatus  = ( this->*iMethod )( aResult );

   230         }

   231     else

   232         {

   233         // Valid case was not found, return error.

   234         execStatus = KErrNotFound;

   235         }

   236 

   237     // Return case execution status (not the result of the case execution)

   238     return execStatus;

   239 

   240     }

   241 

   242 // -----------------------------------------------------------------------------

   243 // CSenServiceManagerBCTest::OOMTestQueryL

   244 // Used to check if a particular test case should be run in OOM conditions and 

   245 // which memory allocations should fail.    

   246 // -----------------------------------------------------------------------------

   247 //

   248 TBool CSenServiceManagerBCTest::OOMTestQueryL( 

   249                                 const TFileName& /* aTestCaseFile */, 

   250                                 const TInt aCaseNumber, 

   251                                 TOOMFailureType& /* aFailureType */, 

   252                                 TInt& aFirstMemFailure, 

   253                                 TInt& aLastMemFailure ) 

   254     {

   255     _LIT( KLogOOMTestQueryL, "CSenServiceManagerBCTest::OOMTestQueryL" );

   256     iLog->Log( KLogOOMTestQueryL );     

   257 

   258     aFirstMemFailure = Case( aCaseNumber ).iFirstMemoryAllocation;

   259     aLastMemFailure = Case( aCaseNumber ).iLastMemoryAllocation;

   260 

   261     return Case( aCaseNumber ).iIsOOMTest;

   262 

   263     }

   264 

   265 // -----------------------------------------------------------------------------

   266 // CSenServiceManagerBCTest::OOMTestInitializeL

   267 // Used to perform the test environment setup for a particular OOM test case. 

   268 // Test Modules may use the initialization file to read parameters for Test 

   269 // Module initialization but they can also have their own configure file or 

   270 // some other routine to initialize themselves.  

   271 //

   272 // NOTE: User may add implementation for OOM test environment initialization.

   273 // Usually no implementation is required.

   274 // -----------------------------------------------------------------------------

   275 //

   276 void CSenServiceManagerBCTest::OOMTestInitializeL( 

   277                                 const TFileName& /* aTestCaseFile */, 

   278                                 const TInt /* aCaseNumber */ )

   279     {

   280     }

   281 

   282 // -----------------------------------------------------------------------------

   283 // CSenServiceManagerBCTest::OOMHandleWarningL

   284 // In some cases the heap memory allocation should be skipped, either due to

   285 // problems in the OS code or components used by the code being tested, or even 

   286 // inside the tested components which are implemented this way on purpose (by 

   287 // design), so it is important to give the tester a way to bypass allocation 

   288 // failures.

   289 //

   290 // NOTE: User may add implementation for OOM test warning handling. Usually no

   291 // implementation is required.

   292 // -----------------------------------------------------------------------------

   293 //

   294 void CSenServiceManagerBCTest::OOMHandleWarningL( 

   295                                 const TFileName& /* aTestCaseFile */,

   296                                 const TInt /* aCaseNumber */, 

   297                                 TInt& /* aFailNextValue */ )

   298     {

   299     }

   300 

   301 // -----------------------------------------------------------------------------

   302 // CSenServiceManagerBCTest::OOMTestFinalizeL

   303 // Used to perform the test environment cleanup for a particular OOM test case.

   304 //

   305 // NOTE: User may add implementation for OOM test environment finalization.

   306 // Usually no implementation is required.

   307 // -----------------------------------------------------------------------------

   308 //

   309 void CSenServiceManagerBCTest::OOMTestFinalizeL( 

   310                                 const TFileName& /* aTestCaseFile */, 

   311                                 const TInt /* aCaseNumber */ )

   312     {

   313     }

   314 

   315 // ========================== OTHER EXPORTED FUNCTIONS =========================

   316 

   317 // -----------------------------------------------------------------------------

   318 // LibEntryL is a polymorphic Dll entry point

   319 // Returns: CTestModuleBase*: Pointer to Test Module object

   320 // -----------------------------------------------------------------------------

   321 //

   322 EXPORT_C CTestModuleBase* LibEntryL()

   323     {

   324     return CSenServiceManagerBCTest::NewL();

   325 

   326     }

   327 

   328 // -----------------------------------------------------------------------------

   329 // SetRequirements handles test module parameters(implements evolution

   330 // version 1 for test module's heap and stack sizes configuring).

   331 // Returns: TInt: Symbian error code.

   332 // -----------------------------------------------------------------------------

   333 //

   334 EXPORT_C TInt SetRequirements( CTestModuleParam*& /*aTestModuleParam*/, 

   335                                 TUint32& /*aParameterValid*/ )

   336     {

   337 

   338     /* --------------------------------- NOTE ---------------------------------

   339     USER PANICS occurs in test thread creation when:

   340     1) "The panic occurs when the value of the stack size is negative."

   341     2) "The panic occurs if the minimum heap size specified is less

   342        than KMinHeapSize".

   343        KMinHeapSize: "Functions that require a new heap to be allocated will

   344        either panic, or will reset the required heap size to this value if

   345        a smaller heap size is specified".

   346     3) "The panic occurs if the minimum heap size specified is greater than

   347        the maximum size to which the heap can grow".

   348     Other:

   349     1) Make sure that your hardware or Symbian OS is supporting given sizes.

   350        e.g. Hardware might support only sizes that are divisible by four.

   351     ------------------------------- NOTE end ------------------------------- */

   352 

   353     // Normally STIF uses default heap and stack sizes for test thread, see:

   354     // KTestThreadMinHeap, KTestThreadMinHeap and KStackSize.

   355     // If needed heap and stack sizes can be configured here by user. Remove

   356     // comments and define sizes.

   357 

   358 /*

   359     aParameterValid = KStifTestModuleParameterChanged;

   360 

   361     CTestModuleParamVer01* param = CTestModuleParamVer01::NewL();

   362     // Stack size

   363     param->iTestThreadStackSize= 16384; // 16K stack

   364     // Heap sizes

   365     param->iTestThreadMinHeap = 4096;   // 4K heap min

   366     param->iTestThreadMaxHeap = 1048576;// 1M heap max

   367 

   368     aTestModuleParam = param;

   369 */

   370     return KErrNone;

   371 

   372     }

   373 

   374 

   375 //  End of File