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_022_01.h

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

    16 // 

    17 //

    18 

    19 

    20 #if (!defined __STEP_022_XX_H__)

    21 #define __STEP_022_XX_H__

    22 

    23 

    24 //

    25 //	Test step 022.01

    26 //

    27 

    28 NONSHARABLE_CLASS(CCommDbTest022_01) : public CTestStepCommDb

    29 {

    30 public:

    31 	CCommDbTest022_01();

    32 	~CCommDbTest022_01();

    33 

    34 	virtual enum TVerdict doTestStepL( void );

    35 	TInt executeStepL();

    36 	TVerdict doTestStepPreambleL();

    37 

    38 private:

    39 

    40 };

    41 

    42 

    43 //

    44 //	Test step 022.02

    45 //

    46 

    47 NONSHARABLE_CLASS(CCommDbTest022_02) : public CTestStepCommDb

    48 {

    49 public:

    50 	CCommDbTest022_02();

    51 	~CCommDbTest022_02();

    52 

    53 	virtual enum TVerdict doTestStepL( void );

    54 	TInt executeStepL();

    55 	TVerdict doTestStepPreambleL();

    56 

    57 private:

    58 

    59 };

    60 

    61 

    62 

    63 

    64 //

    65 //	Test step 022.03

    66 //

    67 

    68 NONSHARABLE_CLASS(CCommDbTest022_03) : public CTestStepCommDb

    69 {

    70 public:

    71 	CCommDbTest022_03();

    72 	~CCommDbTest022_03();

    73 

    74 	virtual enum TVerdict doTestStepL( void );

    75 	TInt executeStepL();

    76 	TVerdict doTestStepPreambleL();

    77 

    78 private:

    79 

    80 };

    81 

    82 

    83 //

    84 //	Test step 022.04

    85 //

    86 

    87 NONSHARABLE_CLASS(CCommDbTest022_04) : public CTestStepCommDb

    88 {

    89 public:

    90 	CCommDbTest022_04();

    91 	~CCommDbTest022_04();

    92 

    93 	virtual enum TVerdict doTestStepL( void );

    94 	TInt executeStepL();

    95 	TVerdict doTestStepPreambleL();

    96 

    97 private:

    98 

    99 };

   100 

   101 

   102 

   103 

   104 //

   105 //	Test step 022.05

   106 //

   107 

   108 NONSHARABLE_CLASS(CCommDbTest022_05) : public CTestStepCommDb

   109 {

   110 public:

   111 	CCommDbTest022_05();

   112 	~CCommDbTest022_05();

   113 

   114 	virtual enum TVerdict doTestStepL( void );

   115 	TInt executeStepL();

   116 	TVerdict doTestStepPreambleL();

   117 

   118 private:

   119 

   120 };

   121 

   122 

   123 //

   124 //	Test step 022.06

   125 //

   126 

   127 NONSHARABLE_CLASS(CCommDbTest022_06) : public CTestStepCommDb

   128 {

   129 public:

   130 	CCommDbTest022_06();

   131 	~CCommDbTest022_06();

   132 

   133 	virtual enum TVerdict doTestStepL( void );

   134 	TInt executeStepL();

   135 	TVerdict doTestStepPreambleL();

   136 

   137 private:

   138 

   139 };

   140 

   141 

   142 //

   143 //	Test step 022.07

   144 //

   145 

   146 NONSHARABLE_CLASS(CCommDbTest022_07) : public CTestStepCommDb

   147 {

   148 public:

   149 	CCommDbTest022_07();

   150 	~CCommDbTest022_07();

   151 

   152 	virtual enum TVerdict doTestStepL( void );

   153 	TInt executeStepL();

   154 	TVerdict doTestStepPreambleL();

   155 

   156 private:

   157 

   158 };

   159 

   160 

   161 

   162 //

   163 //	Test step 022.08

   164 //

   165 

   166 NONSHARABLE_CLASS(CCommDbTest022_08) : public CTestStepCommDb

   167 {

   168 public:

   169 	CCommDbTest022_08();

   170 	~CCommDbTest022_08();

   171 

   172 	virtual enum TVerdict doTestStepL( void );

   173 	TInt executeStepL();

   174 	TVerdict doTestStepPreambleL();

   175 

   176 private:

   177 

   178 };

   179 

   180 

   181 //

   182 //	Test step 022.09

   183 //

   184 

   185 NONSHARABLE_CLASS(CCommDbTest022_09) : public CTestStepCommDb

   186 {

   187 public:

   188 	CCommDbTest022_09();

   189 	~CCommDbTest022_09();

   190 

   191 	virtual enum TVerdict doTestStepL( void );

   192 	TInt executeStepL();

   193 	TVerdict doTestStepPreambleL();

   194 

   195 private:

   196 

   197 };

   198 

   199 

   200 //

   201 //	Test step 022.10

   202 //

   203 

   204 NONSHARABLE_CLASS(CCommDbTest022_10) : public CTestStepCommDb

   205 {

   206 public:

   207 	CCommDbTest022_10();

   208 	~CCommDbTest022_10();

   209 

   210 	virtual enum TVerdict doTestStepL( void );

   211 	TInt executeStepL();

   212 	TVerdict doTestStepPreambleL();

   213 

   214 private:

   215 

   216 };

   217 

   218 

   219 //

   220 //	Test step 022.11

   221 //

   222 

   223 NONSHARABLE_CLASS(CCommDbTest022_11) : public CTestStepCommDb

   224 {

   225 public:

   226 	CCommDbTest022_11();

   227 	~CCommDbTest022_11();

   228 

   229 	virtual enum TVerdict doTestStepL( void );

   230 	TInt executeStepL();

   231 	TVerdict doTestStepPreambleL();

   232 

   233 private:

   234 

   235 };

   236 

   237 

   238 //

   239 //	Test step 022.12

   240 //

   241 

   242 NONSHARABLE_CLASS(CCommDbTest022_12) : public CTestStepCommDb

   243 {

   244 public:

   245 	CCommDbTest022_12();

   246 	~CCommDbTest022_12();

   247 

   248 	virtual enum TVerdict doTestStepL( void );

   249 	TInt executeStepL();

   250 	TVerdict doTestStepPreambleL();

   251 

   252 private:

   253 

   254 };

   255 

   256 

   257 //

   258 //	Test step 022.13

   259 //

   260 

   261 NONSHARABLE_CLASS(CCommDbTest022_13) : public CTestStepCommDb

   262 {

   263 public:

   264 	CCommDbTest022_13();

   265 	~CCommDbTest022_13();

   266 

   267 	virtual enum TVerdict doTestStepL( void );

   268 	TInt executeStepL();

   269 	TVerdict doTestStepPreambleL();

   270 

   271 private:

   272 

   273 };

   274 

   275 

   276 //

   277 //	Test step 022.14

   278 //

   279 

   280 NONSHARABLE_CLASS(CCommDbTest022_14) : public CTestStepCommDb

   281 {

   282 public:

   283 	CCommDbTest022_14();

   284 	~CCommDbTest022_14();

   285 

   286 	virtual enum TVerdict doTestStepL( void );

   287 	TInt executeStepL();

   288 	TVerdict doTestStepPreambleL();

   289 

   290 private:

   291 

   292 };

   293 

   294 

   295 //

   296 //	Test step 022.15

   297 //

   298 

   299 NONSHARABLE_CLASS(CCommDbTest022_15) : public CTestStepCommDb

   300 {

   301 public:

   302 	CCommDbTest022_15();

   303 	~CCommDbTest022_15();

   304 

   305 	virtual enum TVerdict doTestStepL( void );

   306 	TInt executeStepL();

   307 	TVerdict doTestStepPreambleL();

   308 

   309 private:

   310 

   311 };

   312 

   313 

   314 //

   315 //	Test step 022.16

   316 //

   317 

   318 NONSHARABLE_CLASS(CCommDbTest022_16) : public CTestStepCommDb

   319 {

   320 public:

   321 	CCommDbTest022_16();

   322 	~CCommDbTest022_16();

   323 

   324 	virtual enum TVerdict doTestStepL( void );

   325 

   326 private:

   327 

   328 };

   329 

   330 

   331 //

   332 //	Test step 022.17

   333 //

   334 

   335 NONSHARABLE_CLASS(CCommDbTest022_17) : public CTestStepCommDb

   336 {

   337 public:

   338 	CCommDbTest022_17();

   339 	~CCommDbTest022_17();

   340 

   341 	virtual enum TVerdict doTestStepL( void );

   342 

   343 private:

   344 

   345 };

   346 

   347 //

   348 //	Test step 022.18

   349 //

   350 

   351 NONSHARABLE_CLASS(CCommDbTest022_18) : public CTestStepCommDb

   352 {

   353 public:

   354 	CCommDbTest022_18();

   355 	~CCommDbTest022_18();

   356 

   357 	virtual enum TVerdict doTestStepL( void );

   358 

   359 private:

   360 

   361 };

   362 

   363 //

   364 //	Test step 022.19

   365 //

   366 

   367 NONSHARABLE_CLASS(CCommDbTest022_19) : public CTestStepCommDb

   368 {

   369 public:

   370 	CCommDbTest022_19();

   371 	~CCommDbTest022_19();

   372 

   373 	virtual enum TVerdict doTestStepL( void );

   374 

   375 private:

   376 

   377 };

   378 

   379 //

   380 //	Test step 022.20

   381 //

   382 

   383 NONSHARABLE_CLASS(CCommDbTest022_20) : public CTestStepCommDb

   384 {

   385 public:

   386 	CCommDbTest022_20();

   387 	~CCommDbTest022_20();

   388 

   389 	virtual enum TVerdict doTestStepL( void );

   390 

   391 private:

   392 

   393 };

   394 

   395 //

   396 //	Test step 022.21

   397 //

   398 

   399 NONSHARABLE_CLASS(CCommDbTest022_21) : public CTestStepCommDb

   400 {

   401 public:

   402 	CCommDbTest022_21();

   403 	~CCommDbTest022_21();

   404 

   405 	virtual enum TVerdict doTestStepL( void );

   406 

   407 private:

   408 

   409 };

   410 

   411 //

   412 //	Test step 022.22

   413 //

   414 

   415 NONSHARABLE_CLASS(CCommDbTest022_22) : public CTestStepCommDb

   416 {

   417 public:

   418 	CCommDbTest022_22();

   419 	~CCommDbTest022_22();

   420 

   421 	virtual enum TVerdict doTestStepL( void );

   422 

   423 private:

   424 

   425 };

   426 

   427 //

   428 //	Test step 022.23

   429 //

   430 

   431 NONSHARABLE_CLASS(CCommDbTest022_23) : public CTestStepCommDb

   432 {

   433 public:

   434 	CCommDbTest022_23();

   435 	~CCommDbTest022_23();

   436 

   437 	virtual enum TVerdict doTestStepL( void );

   438 

   439 private:

   440 

   441 };

   442 

   443 //

   444 //	Test step 022.24

   445 //

   446 

   447 NONSHARABLE_CLASS(CCommDbTest022_24) : public CTestStepCommDb

   448 {

   449 public:

   450 	CCommDbTest022_24();

   451 	~CCommDbTest022_24();

   452 

   453 	virtual enum TVerdict doTestStepL( void );

   454 

   455 private:

   456 

   457 };

   458 

   459 //

   460 //	Test step 022.25

   461 //

   462 

   463 NONSHARABLE_CLASS(CCommDbTest022_25) : public CTestStepCommDb

   464 {

   465 public:

   466 	CCommDbTest022_25();

   467 	~CCommDbTest022_25();

   468 

   469 	virtual enum TVerdict doTestStepL( void );

   470 

   471 private:

   472 

   473 };

   474 

   475 //

   476 //	Test step 022.26

   477 //

   478 

   479 NONSHARABLE_CLASS(CCommDbTest022_26) : public CTestStepCommDb

   480 {

   481 public:

   482 	CCommDbTest022_26();

   483 	~CCommDbTest022_26();

   484 

   485 	virtual enum TVerdict doTestStepL( void );

   486 

   487 private:

   488 

   489 };

   490 

   491 //

   492 //	Test step 022.27

   493 //

   494 

   495 NONSHARABLE_CLASS(CCommDbTest022_27) : public CTestStepCommDb

   496 {

   497 public:

   498 	CCommDbTest022_27();

   499 	~CCommDbTest022_27();

   500 

   501 	virtual enum TVerdict doTestStepL( void );

   502 

   503 private:

   504 

   505 };

   506 

   507 //

   508 //	Test step 022.28

   509 //

   510 

   511 NONSHARABLE_CLASS(CCommDbTest022_28) : public CTestStepCommDb

   512 {

   513 public:

   514 	CCommDbTest022_28();

   515 	~CCommDbTest022_28();

   516 

   517 	virtual enum TVerdict doTestStepL( void );

   518 

   519 private:

   520 

   521 };

   522 

   523 //

   524 //	Test step 022.29

   525 //

   526 

   527 NONSHARABLE_CLASS(CCommDbTest022_29) : public CTestStepCommDb

   528 {

   529 public:

   530 	CCommDbTest022_29();

   531 	~CCommDbTest022_29();

   532 

   533 	virtual enum TVerdict doTestStepL( void );

   534 

   535 private:

   536 

   537 };

   538 

   539 //

   540 //	Test step 022.30

   541 //

   542 

   543 NONSHARABLE_CLASS(CCommDbTest022_30) : public CTestStepCommDb

   544 {

   545 public:

   546 	CCommDbTest022_30();

   547 	~CCommDbTest022_30();

   548 

   549 	TInt executeStepL();

   550 	virtual enum TVerdict doTestStepL( void );

   551 

   552 private:

   553 

   554 };

   555 

   556 #endif //(__STEP_022_XX_H__)