1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // step_007_01.cpp

    15 // This is the header file for CommDb test 007.XX group of scenarios 

    16 // 

    17 //

    18 

    19 

    20 #if (!defined __STEP_007_XX_H__)

    21 #define __STEP_007_XX_H__

    22 

    23 

    24 //

    25 //	Test step 007.01

    26 //

    27 

    28 NONSHARABLE_CLASS(CCommDbTest007_01) : public CTestStepCommDb

    29 {

    30 public:

    31 	CCommDbTest007_01();

    32 	~CCommDbTest007_01();

    33 

    34 	virtual enum TVerdict doTestStepL( void );

    35 	TInt executeStepL();

    36 	TVerdict doTestStepPreambleL();

    37 

    38 private:

    39 

    40 };

    41 

    42 //

    43 //	Test step 007.02

    44 //

    45 

    46 NONSHARABLE_CLASS(CCommDbTest007_02) : public CTestStepCommDb

    47 {

    48 public:

    49 	CCommDbTest007_02();

    50 	~CCommDbTest007_02();

    51 

    52 	virtual enum TVerdict doTestStepL( void );

    53 	TInt executeStepL();

    54 	TVerdict doTestStepPreambleL();

    55 

    56 private:

    57 

    58 };

    59 

    60 //

    61 //	Test step 007.03

    62 //

    63 

    64 NONSHARABLE_CLASS(CCommDbTest007_03) : public CTestStepCommDb

    65 {

    66 public:

    67 	CCommDbTest007_03();

    68 	~CCommDbTest007_03();

    69 

    70 	virtual enum TVerdict doTestStepL( void );

    71 	TInt executeStepL();

    72 	TVerdict doTestStepPreambleL();

    73 

    74 private:

    75 

    76 };

    77 //

    78 //	Test step 007.04

    79 //

    80 

    81 NONSHARABLE_CLASS(CCommDbTest007_04) : public CTestStepCommDb

    82 {

    83 public:

    84 	CCommDbTest007_04();

    85 	~CCommDbTest007_04();

    86 

    87 	virtual enum TVerdict doTestStepL( void );

    88 	TInt executeStepL();

    89 	TVerdict doTestStepPreambleL();

    90 

    91 private:

    92 

    93 };

    94 

    95 //

    96 //	Test step 007.05

    97 //

    98 

    99 NONSHARABLE_CLASS(CCommDbTest007_05) : public CTestStepCommDb

   100 {

   101 public:

   102 	CCommDbTest007_05();

   103 	~CCommDbTest007_05();

   104 

   105 	virtual enum TVerdict doTestStepL( void );

   106 	TInt executeStepL();

   107 	TVerdict doTestStepPreambleL();

   108 

   109 private:

   110 

   111 };

   112 //

   113 //	Test step 007.06

   114 //

   115 

   116 NONSHARABLE_CLASS(CCommDbTest007_06) : public CTestStepCommDb

   117 {

   118 public:

   119 	CCommDbTest007_06();

   120 	~CCommDbTest007_06();

   121 

   122 	virtual enum TVerdict doTestStepL( void );

   123 	TInt executeStepL();

   124 	TVerdict doTestStepPreambleL();

   125 

   126 private:

   127 

   128 };

   129 //

   130 //	Test step 007.07

   131 //

   132 

   133 NONSHARABLE_CLASS(CCommDbTest007_07) : public CTestStepCommDb

   134 {

   135 public:

   136 	CCommDbTest007_07();

   137 	~CCommDbTest007_07();

   138 

   139 	virtual enum TVerdict doTestStepL( void );

   140 	TInt executeStepL();

   141 	TVerdict doTestStepPreambleL();

   142 

   143 private:

   144 

   145 };

   146 //

   147 //	Test step 007.08

   148 //

   149 

   150 NONSHARABLE_CLASS(CCommDbTest007_08) : public CTestStepCommDb

   151 {

   152 public:

   153 	CCommDbTest007_08();

   154 	~CCommDbTest007_08();

   155 

   156 	virtual enum TVerdict doTestStepL( void );

   157 	TInt executeStepL();

   158 	TVerdict doTestStepPreambleL();

   159 

   160 private:

   161 

   162 };

   163 //

   164 //	Test step 007.09

   165 //

   166 

   167 NONSHARABLE_CLASS(CCommDbTest007_09) : public CTestStepCommDb

   168 {

   169 public:

   170 	CCommDbTest007_09();

   171 	~CCommDbTest007_09();

   172 

   173 	virtual enum TVerdict doTestStepL( void );

   174 	TInt executeStepL();

   175 	TVerdict doTestStepPreambleL();

   176 

   177 private:

   178 

   179 };

   180 //

   181 //	Test step 007.10

   182 //

   183 

   184 NONSHARABLE_CLASS(CCommDbTest007_10) : public CTestStepCommDb

   185 {

   186 public:

   187 	CCommDbTest007_10();

   188 	~CCommDbTest007_10();

   189 

   190 	virtual enum TVerdict doTestStepL( void );

   191 	TInt executeStepL();

   192 	TVerdict doTestStepPreambleL();

   193 

   194 private:

   195 

   196 };

   197 //

   198 //	Test step 007.11

   199 //

   200 

   201 NONSHARABLE_CLASS(CCommDbTest007_11) : public CTestStepCommDb

   202 {

   203 public:

   204 	CCommDbTest007_11();

   205 	~CCommDbTest007_11();

   206 

   207 	virtual enum TVerdict doTestStepL( void );

   208 	TInt executeStepL();

   209 	TVerdict doTestStepPreambleL();

   210 

   211 private:

   212 

   213 };

   214 //

   215 //	Test step 007.12

   216 //

   217 

   218 NONSHARABLE_CLASS(CCommDbTest007_12) : public CTestStepCommDb

   219 {

   220 public:

   221 	CCommDbTest007_12();

   222 	~CCommDbTest007_12();

   223 

   224 	virtual enum TVerdict doTestStepL( void );

   225 	TInt executeStepL();

   226 	TVerdict doTestStepPreambleL();

   227 

   228 private:

   229 

   230 };

   231 //

   232 //	Test step 007.13

   233 //

   234 /*

   235 //Removed since this test will not compile on Code warrior due to having an array of zero length

   236 

   237 NONSHARABLE_CLASS(CCommDbTest007_13) : public CTestStepCommDb

   238 {

   239 public:

   240 	CCommDbTest007_13();

   241 	~CCommDbTest007_13();

   242 

   243 	virtual enum TVerdict doTestStepL( void );

   244 	TInt executeStepL();

   245 	TVerdict doTestStepPreambleL();

   246 

   247 private:

   248 

   249 };

   250 */

   251 

   252 //

   253 //	Test step 007.14

   254 //

   255 

   256 NONSHARABLE_CLASS(CCommDbTest007_14) : public CTestStepCommDb

   257 {

   258 public:

   259 	CCommDbTest007_14();

   260 	~CCommDbTest007_14();

   261 

   262 	virtual enum TVerdict doTestStepL( void );

   263 	TInt executeStepL();

   264 	TVerdict doTestStepPreambleL();

   265 

   266 private:

   267 

   268 };

   269 //

   270 //	Test step 007.15

   271 //

   272 

   273 NONSHARABLE_CLASS(CCommDbTest007_15) : public CTestStepCommDb

   274 {

   275 public:

   276 	CCommDbTest007_15();

   277 	~CCommDbTest007_15();

   278 

   279 	virtual enum TVerdict doTestStepL( void );

   280 	TInt executeStepL();

   281 	TVerdict doTestStepPreambleL();

   282 

   283 private:

   284 

   285 };

   286 

   287 //

   288 //	Test step 007.16

   289 //

   290 

   291 NONSHARABLE_CLASS(CCommDbTest007_16) : public CTestStepCommDb

   292 {

   293 public:

   294 	CCommDbTest007_16();

   295 	~CCommDbTest007_16();

   296 

   297 	virtual enum TVerdict doTestStepL( void );

   298 	TInt executeStepL();

   299 	TVerdict doTestStepPreambleL();

   300 

   301 private:

   302 

   303 };

   304 

   305 //

   306 //	Test step 007.17

   307 //

   308 

   309 NONSHARABLE_CLASS(CCommDbTest007_17) : public CTestStepCommDb

   310 {

   311 public:

   312 	CCommDbTest007_17();

   313 	~CCommDbTest007_17();

   314 

   315 	virtual enum TVerdict doTestStepL( void );

   316 	

   317 private:

   318 

   319 };

   320 

   321 //

   322 //	Test step 007.18

   323 //

   324 

   325 NONSHARABLE_CLASS(CCommDbTest007_18) : public CTestStepCommDb

   326 {

   327 public:

   328 	CCommDbTest007_18();

   329 	~CCommDbTest007_18();

   330 

   331 	virtual enum TVerdict doTestStepL( void );

   332 	

   333 private:

   334 

   335 };

   336 

   337 //

   338 //	Test step 007.19

   339 //

   340 

   341 NONSHARABLE_CLASS(CCommDbTest007_19) : public CTestStepCommDb

   342 {

   343 public:

   344 	CCommDbTest007_19();

   345 	~CCommDbTest007_19();

   346 

   347 	virtual enum TVerdict doTestStepL( void );

   348 	

   349 private:

   350 

   351 };

   352 

   353 //

   354 //	Test step 007.20

   355 //

   356 

   357 NONSHARABLE_CLASS(CCommDbTest007_20) : public CTestStepCommDb

   358 {

   359 public:

   360 	CCommDbTest007_20();

   361 	~CCommDbTest007_20();

   362 

   363 	virtual enum TVerdict doTestStepL( void );

   364 	

   365 private:

   366 

   367 };

   368 

   369 #endif //(__STEP_007_XX_H__)