mpx/tsrc/public/basic/collectiontest/inc/mpxcollectiontest.h
author hgs
Tue, 21 Sep 2010 11:25:55 -0500
changeset 62 b276843a15ba
permissions -rw-r--r--
201037
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
62
hgs
parents:
diff changeset
     1
/*
hgs
parents:
diff changeset
     2
* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).
hgs
parents:
diff changeset
     3
* All rights reserved.
hgs
parents:
diff changeset
     4
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     5
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     6
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     8
*
hgs
parents:
diff changeset
     9
* Initial Contributors:
hgs
parents:
diff changeset
    10
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    11
*
hgs
parents:
diff changeset
    12
* Contributors:
hgs
parents:
diff changeset
    13
*
hgs
parents:
diff changeset
    14
* Description:  MpxCollectionTest test module.
hgs
parents:
diff changeset
    15
*
hgs
parents:
diff changeset
    16
*/
hgs
parents:
diff changeset
    17
hgs
parents:
diff changeset
    18
#ifndef MPXCOLLECTIONTEST_H
hgs
parents:
diff changeset
    19
#define MPXCOLLECTIONTEST_H
hgs
parents:
diff changeset
    20
hgs
parents:
diff changeset
    21
// INCLUDES
hgs
parents:
diff changeset
    22
#include <e32base.h>
hgs
parents:
diff changeset
    23
#include <stiftestmodule.h>
hgs
parents:
diff changeset
    24
#include <mpxcollectionobserver.h>
hgs
parents:
diff changeset
    25
hgs
parents:
diff changeset
    26
// MACROS
hgs
parents:
diff changeset
    27
// Function pointer related internal definitions
hgs
parents:
diff changeset
    28
// Hack around known GCC bug.
hgs
parents:
diff changeset
    29
#ifndef __GCC32__
hgs
parents:
diff changeset
    30
#define GETPTR
hgs
parents:
diff changeset
    31
#else
hgs
parents:
diff changeset
    32
#define GETPTR &
hgs
parents:
diff changeset
    33
#endif  
hgs
parents:
diff changeset
    34
#define ENTRY(str,func) {(TText*)L##str, GETPTR func}
hgs
parents:
diff changeset
    35
#define FUNCENTRY(func) {(TText*)L#func, GETPTR func}
hgs
parents:
diff changeset
    36
hgs
parents:
diff changeset
    37
hgs
parents:
diff changeset
    38
// FORWARD DECLARATIONS
hgs
parents:
diff changeset
    39
class MMPXCollectionUtility;
hgs
parents:
diff changeset
    40
class MMPXHarvesterUtility;
hgs
parents:
diff changeset
    41
class CStifLogger;
hgs
parents:
diff changeset
    42
class CMPXCollectionPath;
hgs
parents:
diff changeset
    43
class CMpxCollectionTest;
hgs
parents:
diff changeset
    44
class CConsoleMain;
hgs
parents:
diff changeset
    45
hgs
parents:
diff changeset
    46
// DATA TYPES
hgs
parents:
diff changeset
    47
// A typedef for function that does the actual testing,
hgs
parents:
diff changeset
    48
typedef TInt (CMpxCollectionTest::* TestFunction)(TTestResult&);    
hgs
parents:
diff changeset
    49
hgs
parents:
diff changeset
    50
// CLASS DECLARATION
hgs
parents:
diff changeset
    51
hgs
parents:
diff changeset
    52
/**
hgs
parents:
diff changeset
    53
*  An internal structure containing a test case name and
hgs
parents:
diff changeset
    54
*  the pointer to function doing the test
hgs
parents:
diff changeset
    55
*/
hgs
parents:
diff changeset
    56
class TCaseInfoInternal
hgs
parents:
diff changeset
    57
    {
hgs
parents:
diff changeset
    58
    public:
hgs
parents:
diff changeset
    59
        const TText* iCaseName;
hgs
parents:
diff changeset
    60
        TestFunction iMethod;
hgs
parents:
diff changeset
    61
    };
hgs
parents:
diff changeset
    62
hgs
parents:
diff changeset
    63
// CLASS DECLARATION
hgs
parents:
diff changeset
    64
hgs
parents:
diff changeset
    65
/**
hgs
parents:
diff changeset
    66
*  A structure containing a test case name and
hgs
parents:
diff changeset
    67
*  the pointer to function doing the test
hgs
parents:
diff changeset
    68
*/
hgs
parents:
diff changeset
    69
class TCaseInfo
hgs
parents:
diff changeset
    70
    {
hgs
parents:
diff changeset
    71
    public:
hgs
parents:
diff changeset
    72
        TPtrC iCaseName;    
hgs
parents:
diff changeset
    73
        TestFunction iMethod;
hgs
parents:
diff changeset
    74
hgs
parents:
diff changeset
    75
    TCaseInfo( const TText* a ) : iCaseName( (TText*) a )
hgs
parents:
diff changeset
    76
        {        
hgs
parents:
diff changeset
    77
        };
hgs
parents:
diff changeset
    78
hgs
parents:
diff changeset
    79
    };
hgs
parents:
diff changeset
    80
hgs
parents:
diff changeset
    81
hgs
parents:
diff changeset
    82
// CLASS DECLARATION
hgs
parents:
diff changeset
    83
hgs
parents:
diff changeset
    84
/**
hgs
parents:
diff changeset
    85
*  This a MpxCollectionTest class.
hgs
parents:
diff changeset
    86
*/
hgs
parents:
diff changeset
    87
class CMpxCollectionTest: public CTestModuleBase
hgs
parents:
diff changeset
    88
    {
hgs
parents:
diff changeset
    89
    public:  // Constructors and destructor
hgs
parents:
diff changeset
    90
        
hgs
parents:
diff changeset
    91
        /**
hgs
parents:
diff changeset
    92
        * Two-phased constructor.
hgs
parents:
diff changeset
    93
        */
hgs
parents:
diff changeset
    94
        static CMpxCollectionTest* NewL();
hgs
parents:
diff changeset
    95
        
hgs
parents:
diff changeset
    96
        /**
hgs
parents:
diff changeset
    97
        * Destructor.
hgs
parents:
diff changeset
    98
        */
hgs
parents:
diff changeset
    99
        virtual ~CMpxCollectionTest();
hgs
parents:
diff changeset
   100
        
hgs
parents:
diff changeset
   101
    public: // Functions from base classes
hgs
parents:
diff changeset
   102
hgs
parents:
diff changeset
   103
hgs
parents:
diff changeset
   104
        /**
hgs
parents:
diff changeset
   105
        * From CTestModuleBase InitL is used to initialize the 
hgs
parents:
diff changeset
   106
        *       MpxCollectionTest. It is called once for every instance of 
hgs
parents:
diff changeset
   107
        *       TestModuleMpxCollectionTest after its creation.
hgs
parents:
diff changeset
   108
        * @param aIniFile Initialization file for the test module (optional)
hgs
parents:
diff changeset
   109
        * @param aFirstTime Flag is true when InitL is executed for first 
hgs
parents:
diff changeset
   110
        *               created instance of MpxCollectionTest.
hgs
parents:
diff changeset
   111
        * @return Symbian OS error code
hgs
parents:
diff changeset
   112
        */
hgs
parents:
diff changeset
   113
        TInt InitL( TFileName& aIniFile, TBool aFirstTime );
hgs
parents:
diff changeset
   114
hgs
parents:
diff changeset
   115
        /**
hgs
parents:
diff changeset
   116
        * From CTestModuleBase GetTestCasesL is used to inquiry test cases 
hgs
parents:
diff changeset
   117
        *   from MpxCollectionTest. 
hgs
parents:
diff changeset
   118
        * @param aTestCaseFile Test case file (optional)
hgs
parents:
diff changeset
   119
        * @param aTestCases  Array of TestCases returned to test framework
hgs
parents:
diff changeset
   120
        * @return Symbian OS error code
hgs
parents:
diff changeset
   121
        */
hgs
parents:
diff changeset
   122
        TInt GetTestCasesL( const TFileName& aTestCaseFile, 
hgs
parents:
diff changeset
   123
                            RPointerArray<TTestCaseInfo>& aTestCases );
hgs
parents:
diff changeset
   124
    
hgs
parents:
diff changeset
   125
        /**
hgs
parents:
diff changeset
   126
        * From CTestModuleBase RunTestCaseL is used to run an individual 
hgs
parents:
diff changeset
   127
        *   test case. 
hgs
parents:
diff changeset
   128
        * @param aCaseNumber Test case number
hgs
parents:
diff changeset
   129
        * @param aTestCaseFile Test case file (optional)
hgs
parents:
diff changeset
   130
        * @param aResult Test case result returned to test framework (PASS/FAIL)
hgs
parents:
diff changeset
   131
        * @return Symbian OS error code (test case execution error, which is 
hgs
parents:
diff changeset
   132
        *           not reported in aResult parameter as test case failure).
hgs
parents:
diff changeset
   133
        */   
hgs
parents:
diff changeset
   134
        TInt RunTestCaseL( const TInt aCaseNumber, 
hgs
parents:
diff changeset
   135
                           const TFileName& aTestCaseFile,
hgs
parents:
diff changeset
   136
                           TTestResult& aResult );
hgs
parents:
diff changeset
   137
        
hgs
parents:
diff changeset
   138
    private:
hgs
parents:
diff changeset
   139
hgs
parents:
diff changeset
   140
        /**
hgs
parents:
diff changeset
   141
        * C++ default constructor.
hgs
parents:
diff changeset
   142
        */
hgs
parents:
diff changeset
   143
        CMpxCollectionTest();
hgs
parents:
diff changeset
   144
hgs
parents:
diff changeset
   145
        /**
hgs
parents:
diff changeset
   146
        * By default Symbian 2nd phase constructor is private.
hgs
parents:
diff changeset
   147
        */
hgs
parents:
diff changeset
   148
        void ConstructL();
hgs
parents:
diff changeset
   149
hgs
parents:
diff changeset
   150
        /**
hgs
parents:
diff changeset
   151
        * Function returning test case name and pointer to test case function.
hgs
parents:
diff changeset
   152
        * @param aCaseNumber test case number
hgs
parents:
diff changeset
   153
        * @return TCaseInfo 
hgs
parents:
diff changeset
   154
        */
hgs
parents:
diff changeset
   155
        const TCaseInfo Case ( const TInt aCaseNumber ) const;
hgs
parents:
diff changeset
   156
        
hgs
parents:
diff changeset
   157
        /**
hgs
parents:
diff changeset
   158
        * Initialize environment before test
hgs
parents:
diff changeset
   159
        */
hgs
parents:
diff changeset
   160
        void InitializeL( CActiveScheduler* scheduler );
hgs
parents:
diff changeset
   161
        
hgs
parents:
diff changeset
   162
        /**
hgs
parents:
diff changeset
   163
        * Cleanup environment after test
hgs
parents:
diff changeset
   164
        */
hgs
parents:
diff changeset
   165
        void Cleanup();
hgs
parents:
diff changeset
   166
        
hgs
parents:
diff changeset
   167
        /**
hgs
parents:
diff changeset
   168
        * Actual Hardcoded test case functions are listed below.
hgs
parents:
diff changeset
   169
        */
hgs
parents:
diff changeset
   170
        
hgs
parents:
diff changeset
   171
        /**
hgs
parents:
diff changeset
   172
        * Common test case driver for all Collection tests.
hgs
parents:
diff changeset
   173
        * @param aResult Test case result (PASS/FAIL)
hgs
parents:
diff changeset
   174
        * @return Symbian OS error code (test case execution error
hgs
parents:
diff changeset
   175
        *   that is not returned as test case result in aResult)
hgs
parents:
diff changeset
   176
        */
hgs
parents:
diff changeset
   177
        TInt CommonTestL( TInt testIndex, TTestResult& aResult );
hgs
parents:
diff changeset
   178
		
hgs
parents:
diff changeset
   179
    private:    // Help functions
hgs
parents:
diff changeset
   180
hgs
parents:
diff changeset
   181
  	    TInt Test0001L(TTestResult& aResult) { return CommonTestL(  1, aResult); }
hgs
parents:
diff changeset
   182
	    TInt Test0002L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  2, aResult); }
hgs
parents:
diff changeset
   183
	    TInt Test0003L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  3, aResult); }
hgs
parents:
diff changeset
   184
	    TInt Test0004L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  4, aResult); }
hgs
parents:
diff changeset
   185
	    TInt Test0005L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  5, aResult); }
hgs
parents:
diff changeset
   186
	    TInt Test0006L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  6, aResult); }
hgs
parents:
diff changeset
   187
	    TInt Test0007L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  7, aResult); }
hgs
parents:
diff changeset
   188
	    TInt Test0008L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  8, aResult); }
hgs
parents:
diff changeset
   189
	    TInt Test0009L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(  9, aResult); }
hgs
parents:
diff changeset
   190
	    TInt Test0010L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 10, aResult); }
hgs
parents:
diff changeset
   191
  	    TInt Test0011L(TTestResult& aResult) { return CommonTestL( 11, aResult); }
hgs
parents:
diff changeset
   192
	    TInt Test0012L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 12, aResult); }
hgs
parents:
diff changeset
   193
	    TInt Test0013L(TTestResult& aResult) { return CommonTestL( 13, aResult); }
hgs
parents:
diff changeset
   194
	    TInt Test0014L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 14, aResult); }
hgs
parents:
diff changeset
   195
	    TInt Test0015L(TTestResult& aResult) { return CommonTestL( 15, aResult); }
hgs
parents:
diff changeset
   196
	    TInt Test0016L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 16, aResult); }
hgs
parents:
diff changeset
   197
	    TInt Test0017L(TTestResult& aResult) { return CommonTestL( 17, aResult); }
hgs
parents:
diff changeset
   198
	    TInt Test0018L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 18, aResult); }
hgs
parents:
diff changeset
   199
	    TInt Test0019L(TTestResult& aResult) { return CommonTestL( 19, aResult); }
hgs
parents:
diff changeset
   200
	    TInt Test0020L(TTestResult& aResult) { return CommonTestL( 20, aResult); }
hgs
parents:
diff changeset
   201
  	    TInt Test0021L(TTestResult& aResult) { return CommonTestL( 21, aResult); }
hgs
parents:
diff changeset
   202
	    TInt Test0022L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 22, aResult); }
hgs
parents:
diff changeset
   203
	    TInt Test0023L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 23, aResult); }
hgs
parents:
diff changeset
   204
	    TInt Test0024L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 24, aResult); }
hgs
parents:
diff changeset
   205
	    TInt Test0025L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 25, aResult); }
hgs
parents:
diff changeset
   206
	    TInt Test0026L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 26, aResult); }
hgs
parents:
diff changeset
   207
	    TInt Test0027L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 27, aResult); }
hgs
parents:
diff changeset
   208
	    TInt Test0028L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 28, aResult); }
hgs
parents:
diff changeset
   209
	    TInt Test0029L(TTestResult& aResult)    { return 0; } //return CommonTestL( 29, aResult); }
hgs
parents:
diff changeset
   210
	    TInt Test0030L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 30, aResult); }
hgs
parents:
diff changeset
   211
  	    TInt Test0031L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 31, aResult); }
hgs
parents:
diff changeset
   212
	    TInt Test0032L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 32, aResult); }
hgs
parents:
diff changeset
   213
	    TInt Test0033L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 33, aResult); }
hgs
parents:
diff changeset
   214
	    TInt Test0034L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 34, aResult); }
hgs
parents:
diff changeset
   215
	    TInt Test0035L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 35, aResult); }
hgs
parents:
diff changeset
   216
	    TInt Test0036L(TTestResult& aResult) { return CommonTestL( 36, aResult); }
hgs
parents:
diff changeset
   217
	    TInt Test0037L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 37, aResult); }
hgs
parents:
diff changeset
   218
	    TInt Test0038L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 38, aResult); }
hgs
parents:
diff changeset
   219
	    TInt Test0039L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 39, aResult); }
hgs
parents:
diff changeset
   220
	    TInt Test0040L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 40, aResult); }
hgs
parents:
diff changeset
   221
  	    TInt Test0041L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 41, aResult); }
hgs
parents:
diff changeset
   222
	    TInt Test0042L(TTestResult& aResult) { return CommonTestL( 42, aResult); }
hgs
parents:
diff changeset
   223
	    TInt Test0043L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 43, aResult); }
hgs
parents:
diff changeset
   224
	    TInt Test0044L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 44, aResult); }
hgs
parents:
diff changeset
   225
	    TInt Test0045L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 45, aResult); }
hgs
parents:
diff changeset
   226
	    TInt Test0046L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 46, aResult); }
hgs
parents:
diff changeset
   227
	    TInt Test0047L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 47, aResult); }
hgs
parents:
diff changeset
   228
	    TInt Test0048L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 48, aResult); }
hgs
parents:
diff changeset
   229
	    TInt Test0049L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 49, aResult); }
hgs
parents:
diff changeset
   230
	    TInt Test0050L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 50, aResult); }
hgs
parents:
diff changeset
   231
  	    TInt Test0051L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 51, aResult); }
hgs
parents:
diff changeset
   232
	    TInt Test0052L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 52, aResult); }
hgs
parents:
diff changeset
   233
	    TInt Test0053L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 53, aResult); }
hgs
parents:
diff changeset
   234
	    TInt Test0054L(TTestResult& aResult) { return CommonTestL( 54, aResult); }
hgs
parents:
diff changeset
   235
	    TInt Test0055L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 55, aResult); }
hgs
parents:
diff changeset
   236
	    TInt Test0056L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 56, aResult); }
hgs
parents:
diff changeset
   237
	    TInt Test0057L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 57, aResult); }
hgs
parents:
diff changeset
   238
	    TInt Test0058L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 58, aResult); }
hgs
parents:
diff changeset
   239
	    TInt Test0059L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 59, aResult); }
hgs
parents:
diff changeset
   240
	    TInt Test0060L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 60, aResult); }
hgs
parents:
diff changeset
   241
  	    TInt Test0061L(TTestResult& aResult) { return 0; } //return CommonTestL( 61, aResult); }
hgs
parents:
diff changeset
   242
	    TInt Test0062L(TTestResult& aResult) { return 0; } //return CommonTestL( 62, aResult); }
hgs
parents:
diff changeset
   243
	    TInt Test0063L(TTestResult& aResult) { return 0; } //return CommonTestL( 63, aResult); }
hgs
parents:
diff changeset
   244
	    TInt Test0064L(TTestResult& aResult) { return 0; } //return CommonTestL( 64, aResult); }
hgs
parents:
diff changeset
   245
	    TInt Test0065L(TTestResult& aResult) { return 0; } //return CommonTestL( 65, aResult); }
hgs
parents:
diff changeset
   246
	    TInt Test0066L(TTestResult& aResult) { return 0; } //return CommonTestL( 66, aResult); }
hgs
parents:
diff changeset
   247
	    TInt Test0067L(TTestResult& aResult) { return 0; } //return CommonTestL( 67, aResult); }
hgs
parents:
diff changeset
   248
	    TInt Test0068L(TTestResult& aResult) { return 0; } //return CommonTestL( 68, aResult); }
hgs
parents:
diff changeset
   249
	    TInt Test0069L(TTestResult& aResult) { return 0; } //return CommonTestL( 69, aResult); }
hgs
parents:
diff changeset
   250
	    TInt Test0070L(TTestResult& aResult) { return CommonTestL( 70, aResult); }
hgs
parents:
diff changeset
   251
  	    TInt Test0071L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 71, aResult); }
hgs
parents:
diff changeset
   252
	    TInt Test0072L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 72, aResult); }
hgs
parents:
diff changeset
   253
	    TInt Test0073L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 73, aResult); }
hgs
parents:
diff changeset
   254
	    TInt Test0074L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 74, aResult); }
hgs
parents:
diff changeset
   255
	    TInt Test0075L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 75, aResult); }
hgs
parents:
diff changeset
   256
	    TInt Test0076L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 76, aResult); }
hgs
parents:
diff changeset
   257
	    TInt Test0077L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 77, aResult); }
hgs
parents:
diff changeset
   258
	    TInt Test0078L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 78, aResult); }
hgs
parents:
diff changeset
   259
	    TInt Test0079L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 79, aResult); }
hgs
parents:
diff changeset
   260
	    TInt Test0080L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 80, aResult); }
hgs
parents:
diff changeset
   261
  	    TInt Test0081L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 81, aResult); }
hgs
parents:
diff changeset
   262
	    TInt Test0082L(TTestResult& aResult) { return CommonTestL( 82, aResult); }
hgs
parents:
diff changeset
   263
	    TInt Test0083L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 83, aResult); }
hgs
parents:
diff changeset
   264
	    TInt Test0084L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 84, aResult); }
hgs
parents:
diff changeset
   265
	    TInt Test0085L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 85, aResult); }
hgs
parents:
diff changeset
   266
	    TInt Test0086L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 86, aResult); }
hgs
parents:
diff changeset
   267
	    TInt Test0087L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 87, aResult); }
hgs
parents:
diff changeset
   268
	    TInt Test0088L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 88, aResult); }
hgs
parents:
diff changeset
   269
	    TInt Test0089L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 89, aResult); }
hgs
parents:
diff changeset
   270
	    TInt Test0090L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 90, aResult); }
hgs
parents:
diff changeset
   271
  	    TInt Test0091L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 91, aResult); }
hgs
parents:
diff changeset
   272
	    TInt Test0092L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 92, aResult); }
hgs
parents:
diff changeset
   273
	    TInt Test0093L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 93, aResult); }
hgs
parents:
diff changeset
   274
	    TInt Test0094L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 94, aResult); }
hgs
parents:
diff changeset
   275
	    TInt Test0095L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 95, aResult); }
hgs
parents:
diff changeset
   276
	    TInt Test0096L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 96, aResult); }
hgs
parents:
diff changeset
   277
	    TInt Test0097L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 97, aResult); }
hgs
parents:
diff changeset
   278
	    TInt Test0098L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 98, aResult); }
hgs
parents:
diff changeset
   279
	    TInt Test0099L(TTestResult& aResult) 	{ return 0; } //return CommonTestL( 99, aResult); }
hgs
parents:
diff changeset
   280
  	    TInt Test0100L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(100, aResult); }	    
hgs
parents:
diff changeset
   281
  	    TInt Test0101L(TTestResult& aResult) { return CommonTestL(101, aResult); }
hgs
parents:
diff changeset
   282
	    TInt Test0102L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(102, aResult); }
hgs
parents:
diff changeset
   283
	    TInt Test0103L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(103, aResult); }
hgs
parents:
diff changeset
   284
	    TInt Test0104L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(104, aResult); }
hgs
parents:
diff changeset
   285
	    TInt Test0105L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(105, aResult); }
hgs
parents:
diff changeset
   286
	    TInt Test0106L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(106, aResult); }
hgs
parents:
diff changeset
   287
	    TInt Test0107L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(107, aResult); }
hgs
parents:
diff changeset
   288
	    TInt Test0108L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(108, aResult); }
hgs
parents:
diff changeset
   289
	    TInt Test0109L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(109, aResult); }
hgs
parents:
diff changeset
   290
	    TInt Test0110L(TTestResult& aResult) { return CommonTestL(110, aResult); }
hgs
parents:
diff changeset
   291
  	    TInt Test0111L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(111, aResult); }
hgs
parents:
diff changeset
   292
	    TInt Test0112L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(112, aResult); }
hgs
parents:
diff changeset
   293
	    TInt Test0113L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(113, aResult); }
hgs
parents:
diff changeset
   294
	    TInt Test0114L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(114, aResult); }
hgs
parents:
diff changeset
   295
	    TInt Test0115L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(115, aResult); }
hgs
parents:
diff changeset
   296
	    TInt Test0116L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(116, aResult); }
hgs
parents:
diff changeset
   297
	    TInt Test0117L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(117, aResult); }
hgs
parents:
diff changeset
   298
	    TInt Test0118L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(118, aResult); }
hgs
parents:
diff changeset
   299
	    TInt Test0119L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(119, aResult); }
hgs
parents:
diff changeset
   300
	    TInt Test0120L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(120, aResult); }
hgs
parents:
diff changeset
   301
  	    TInt Test0121L(TTestResult& aResult) { return CommonTestL(121, aResult); }
hgs
parents:
diff changeset
   302
	    TInt Test0122L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(122, aResult); }
hgs
parents:
diff changeset
   303
	    TInt Test0123L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(123, aResult); }
hgs
parents:
diff changeset
   304
	    TInt Test0124L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(124, aResult); }
hgs
parents:
diff changeset
   305
	    TInt Test0125L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(125, aResult); }
hgs
parents:
diff changeset
   306
	    TInt Test0126L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(126, aResult); }
hgs
parents:
diff changeset
   307
	    TInt Test0127L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(127, aResult); }
hgs
parents:
diff changeset
   308
	    TInt Test0128L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(128, aResult); }
hgs
parents:
diff changeset
   309
	    TInt Test0129L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(129, aResult); }
hgs
parents:
diff changeset
   310
	    TInt Test0130L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(130, aResult); }
hgs
parents:
diff changeset
   311
  	    TInt Test0131L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(131, aResult); }
hgs
parents:
diff changeset
   312
	    TInt Test0132L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(132, aResult); }
hgs
parents:
diff changeset
   313
	    TInt Test0133L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(133, aResult); }
hgs
parents:
diff changeset
   314
	    TInt Test0134L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(134, aResult); }
hgs
parents:
diff changeset
   315
	    TInt Test0135L(TTestResult& aResult)	{ return 0; } //return CommonTestL(135, aResult); }
hgs
parents:
diff changeset
   316
	    TInt Test0136L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(136, aResult); }
hgs
parents:
diff changeset
   317
	    TInt Test0137L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(137, aResult); }
hgs
parents:
diff changeset
   318
	    TInt Test0138L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(138, aResult); }
hgs
parents:
diff changeset
   319
	    TInt Test0139L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(139, aResult); }
hgs
parents:
diff changeset
   320
	    TInt Test0140L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(140, aResult); }
hgs
parents:
diff changeset
   321
  	    TInt Test0141L(TTestResult& aResult) { return CommonTestL(141, aResult); }
hgs
parents:
diff changeset
   322
	    TInt Test0142L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(142, aResult); }
hgs
parents:
diff changeset
   323
	    TInt Test0143L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(143, aResult); }
hgs
parents:
diff changeset
   324
	    TInt Test0144L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(144, aResult); }
hgs
parents:
diff changeset
   325
	    TInt Test0145L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(145, aResult); }
hgs
parents:
diff changeset
   326
	    TInt Test0146L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(146, aResult); }
hgs
parents:
diff changeset
   327
	    TInt Test0147L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(147, aResult); }
hgs
parents:
diff changeset
   328
	    TInt Test0148L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(148, aResult); }
hgs
parents:
diff changeset
   329
	    TInt Test0149L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(149, aResult); }
hgs
parents:
diff changeset
   330
	    TInt Test0150L(TTestResult& aResult) { return CommonTestL(150, aResult); }
hgs
parents:
diff changeset
   331
  	    TInt Test0151L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(151, aResult); }
hgs
parents:
diff changeset
   332
	    TInt Test0152L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(152, aResult); }
hgs
parents:
diff changeset
   333
	    TInt Test0153L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(153, aResult); }
hgs
parents:
diff changeset
   334
	    TInt Test0154L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(154, aResult); }
hgs
parents:
diff changeset
   335
	    TInt Test0155L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(155, aResult); }
hgs
parents:
diff changeset
   336
	    TInt Test0156L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(156, aResult); }
hgs
parents:
diff changeset
   337
	    TInt Test0157L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(157, aResult); }
hgs
parents:
diff changeset
   338
	    TInt Test0158L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(158, aResult); }
hgs
parents:
diff changeset
   339
	    TInt Test0159L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(159, aResult); }
hgs
parents:
diff changeset
   340
	    TInt Test0160L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(160, aResult); }
hgs
parents:
diff changeset
   341
  	    TInt Test0161L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(161, aResult); }
hgs
parents:
diff changeset
   342
	    TInt Test0162L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(162, aResult); }
hgs
parents:
diff changeset
   343
	    TInt Test0163L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(163, aResult); }
hgs
parents:
diff changeset
   344
	    TInt Test0164L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(164, aResult); }
hgs
parents:
diff changeset
   345
	    TInt Test0165L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(165, aResult); }
hgs
parents:
diff changeset
   346
	    TInt Test0166L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(166, aResult); }
hgs
parents:
diff changeset
   347
	    TInt Test0167L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(167, aResult); }
hgs
parents:
diff changeset
   348
	    TInt Test0168L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(168, aResult); }
hgs
parents:
diff changeset
   349
	    TInt Test0169L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(169, aResult); }
hgs
parents:
diff changeset
   350
	    TInt Test0170L(TTestResult& aResult) { return CommonTestL(170, aResult); }
hgs
parents:
diff changeset
   351
  	    TInt Test0171L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(171, aResult); }
hgs
parents:
diff changeset
   352
	    TInt Test0172L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(172, aResult); }
hgs
parents:
diff changeset
   353
	    TInt Test0173L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(173, aResult); }
hgs
parents:
diff changeset
   354
	    TInt Test0174L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(174, aResult); }
hgs
parents:
diff changeset
   355
	    TInt Test0175L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(175, aResult); }
hgs
parents:
diff changeset
   356
	    TInt Test0176L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(176, aResult); }
hgs
parents:
diff changeset
   357
	    TInt Test0177L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(177, aResult); }
hgs
parents:
diff changeset
   358
	    TInt Test0178L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(178, aResult); }
hgs
parents:
diff changeset
   359
	    TInt Test0179L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(179, aResult); }
hgs
parents:
diff changeset
   360
	    TInt Test0180L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(180, aResult); }
hgs
parents:
diff changeset
   361
  	    TInt Test0181L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(181, aResult); }
hgs
parents:
diff changeset
   362
	    TInt Test0182L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(182, aResult); }
hgs
parents:
diff changeset
   363
	    TInt Test0183L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(183, aResult); }
hgs
parents:
diff changeset
   364
	    TInt Test0184L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(184, aResult); }
hgs
parents:
diff changeset
   365
	    TInt Test0185L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(185, aResult); }
hgs
parents:
diff changeset
   366
	    TInt Test0186L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(186, aResult); }
hgs
parents:
diff changeset
   367
	    TInt Test0187L(TTestResult& aResult) { return 0; } //return CommonTestL(187, aResult); }
hgs
parents:
diff changeset
   368
	    TInt Test0188L(TTestResult& aResult) { return 0; } //return CommonTestL(188, aResult); }
hgs
parents:
diff changeset
   369
	    TInt Test0189L(TTestResult& aResult) { return 0; } //return CommonTestL(189, aResult); }
hgs
parents:
diff changeset
   370
	    TInt Test0190L(TTestResult& aResult) { return CommonTestL(190, aResult); }
hgs
parents:
diff changeset
   371
  	    TInt Test0191L(TTestResult& aResult) { return CommonTestL(191, aResult); }
hgs
parents:
diff changeset
   372
	    TInt Test0192L(TTestResult& aResult) { return CommonTestL(192, aResult); }
hgs
parents:
diff changeset
   373
	    TInt Test0193L(TTestResult& aResult) { return CommonTestL(193, aResult); }
hgs
parents:
diff changeset
   374
	    TInt Test0194L(TTestResult& aResult) { return CommonTestL(194, aResult); }
hgs
parents:
diff changeset
   375
	    TInt Test0195L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(195, aResult); }
hgs
parents:
diff changeset
   376
	    TInt Test0196L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(196, aResult); }
hgs
parents:
diff changeset
   377
	    TInt Test0197L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(197, aResult); }
hgs
parents:
diff changeset
   378
	    TInt Test0198L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(198, aResult); }
hgs
parents:
diff changeset
   379
	    TInt Test0199L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(199, aResult); }
hgs
parents:
diff changeset
   380
	    TInt Test0200L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(200, aResult); }
hgs
parents:
diff changeset
   381
  	    TInt Test0201L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(201, aResult); }
hgs
parents:
diff changeset
   382
	    TInt Test0202L(TTestResult& aResult) 	{ return 0; } //return CommonTestL(202, aResult); }
hgs
parents:
diff changeset
   383
hgs
parents:
diff changeset
   384
    private:    // Data
hgs
parents:
diff changeset
   385
        
hgs
parents:
diff changeset
   386
        // Pointer to test (function) to be executed
hgs
parents:
diff changeset
   387
        TestFunction 		iMethod;
hgs
parents:
diff changeset
   388
        
hgs
parents:
diff changeset
   389
        // Pointer to an active scheduler. Needed for MCModel
hgs
parents:
diff changeset
   390
        CActiveScheduler* 	iScheduler;
hgs
parents:
diff changeset
   391
        
hgs
parents:
diff changeset
   392
        // Pointer to a Logger. Helps to write log information
hgs
parents:
diff changeset
   393
        CStifLogger* 		iLogger;
hgs
parents:
diff changeset
   394
hgs
parents:
diff changeset
   395
        CConsoleMain* 		iMainConsole;
hgs
parents:
diff changeset
   396
    };
hgs
parents:
diff changeset
   397
hgs
parents:
diff changeset
   398
#endif      // MpxCOLLECTIONTEST_H
hgs
parents:
diff changeset
   399
            
hgs
parents:
diff changeset
   400
// End of File