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:

    15 * This is the header file for Usb test section 1

    16 *

    17 */

    18 

    19 #ifndef __USBTEST1_H__

    20 #define __USBTEST1_H__

    21 

    22 

    23 ///////////////////////////////////////////////

    24 // Test 1.1

    25 NONSHARABLE_CLASS(CTestStartUsb) : public CTestStepUsb

    26 {

    27 public:

    28 	CTestStartUsb();

    29 	virtual ~CTestStartUsb();

    30 

    31 	virtual enum TVerdict doTestStepL( void );

    32 

    33 private:

    34 };

    35 

    36 

    37 ///////////////////////////////////////////////

    38 // Test 1.2

    39 NONSHARABLE_CLASS(CTestWaitForUsb) : public CTestStepUsb

    40 {

    41 public:

    42 	CTestWaitForUsb();

    43 	virtual ~CTestWaitForUsb();

    44 

    45 	virtual enum TVerdict doTestStepL( void );

    46 

    47 private:

    48 };

    49 

    50 

    51 ///////////////////////////////////////////////

    52 // Test 1.3

    53 NONSHARABLE_CLASS(CTestStartCsy) : public CTestStepUsb

    54 {

    55 public:

    56 	CTestStartCsy();

    57 	virtual ~CTestStartCsy();

    58 

    59 	virtual enum TVerdict doTestStepL( void );

    60 

    61 private:

    62 };

    63 

    64 

    65 ///////////////////////////////////////////////

    66 // Test 1.4

    67 NONSHARABLE_CLASS(CTestOpenDTEPort) : public CTestStepUsb

    68 {

    69 public:

    70 	CTestOpenDTEPort();

    71 	~CTestOpenDTEPort();

    72 

    73 	virtual enum TVerdict doTestStepL( void );

    74 

    75 private:

    76 };

    77 

    78 

    79 ///////////////////////////////////////////////

    80 // Test 1.5

    81 NONSHARABLE_CLASS(CTestOpenDCEPort) : public CTestStepUsb

    82 {

    83 public:

    84 	CTestOpenDCEPort();

    85 	virtual ~CTestOpenDCEPort();

    86 

    87 	virtual enum TVerdict doTestStepL( void );

    88 

    89 private:

    90 };

    91 

    92 ///////////////////////////////////////////////

    93 // Test 1.6

    94 NONSHARABLE_CLASS(CTestPostRead) : public CTestStepUsb

    95 {

    96 public:

    97 	CTestPostRead();

    98 	virtual ~CTestPostRead();

    99 

   100 	virtual enum TVerdict doTestStepL( void );

   101 

   102 private:

   103 };

   104 

   105 ///////////////////////////////////////////////

   106 // Test 1.7

   107 NONSHARABLE_CLASS(CTestPostWrite) : public CTestStepUsb

   108 {

   109 public:

   110 	CTestPostWrite();

   111 	virtual ~CTestPostWrite();

   112 

   113 	virtual enum TVerdict doTestStepL( void );

   114 

   115 private:

   116 };

   117 

   118 ///////////////////////////////////////////////

   119 // Test 1.8

   120 NONSHARABLE_CLASS(CTestCancelRead) : public CTestStepUsb

   121 {

   122 public:

   123 	CTestCancelRead();

   124 	virtual ~CTestCancelRead();

   125 

   126 	virtual enum TVerdict doTestStepL( void );

   127 

   128 private:

   129 };

   130 

   131 ///////////////////////////////////////////////

   132 // Test 1.9

   133 NONSHARABLE_CLASS(CTestCancelWrite) : public CTestStepUsb

   134 {

   135 public:

   136 	CTestCancelWrite();

   137 	virtual ~CTestCancelWrite();

   138 

   139 	virtual enum TVerdict doTestStepL( void );

   140 

   141 private:

   142 };

   143 

   144 ///////////////////////////////////////////////

   145 // Test 1.10

   146 NONSHARABLE_CLASS(CTestWaitForRead) : public CTestStepUsb

   147 {

   148 public:

   149 	CTestWaitForRead();

   150 	virtual ~CTestWaitForRead();

   151 

   152 	virtual enum TVerdict doTestStepL( void );

   153 

   154 private:

   155 };

   156 

   157 ///////////////////////////////////////////////

   158 // Test 1.11

   159 NONSHARABLE_CLASS(CTestWaitForWrite) : public CTestStepUsb

   160 {

   161 public:

   162 	CTestWaitForWrite();

   163 	virtual ~CTestWaitForWrite();

   164 

   165 	virtual enum TVerdict doTestStepL( void );

   166 

   167 private:

   168 };

   169 

   170 ///////////////////////////////////////////////

   171 // Test 1.12

   172 NONSHARABLE_CLASS(CTestPostReadOneOrMore) : public CTestStepUsb

   173 {

   174 public:

   175 	CTestPostReadOneOrMore();

   176 	virtual ~CTestPostReadOneOrMore();

   177 

   178 	virtual enum TVerdict doTestStepL( void );

   179 

   180 private:

   181 };

   182 

   183 ///////////////////////////////////////////////

   184 // Test 1.13

   185 NONSHARABLE_CLASS(CTestClosePort) : public CTestStepUsb

   186 {

   187 public:

   188 	CTestClosePort();

   189 	virtual ~CTestClosePort();

   190 

   191 	virtual enum TVerdict doTestStepL( void );

   192 

   193 private:

   194 };

   195 

   196 ///////////////////////////////////////////////

   197 // Test 1.14

   198 NONSHARABLE_CLASS(CTestCloseCommServer) : public CTestStepUsb

   199 {

   200 public:

   201 	CTestCloseCommServer();

   202 	virtual ~CTestCloseCommServer();

   203 

   204 	virtual enum TVerdict doTestStepL( void );

   205 

   206 private:

   207 };

   208 

   209 ///////////////////////////////////////////////

   210 // Test 1.15

   211 NONSHARABLE_CLASS(CTestCloseUsbServer) : public CTestStepUsb

   212 {

   213 public:

   214 	CTestCloseUsbServer();

   215 	virtual ~CTestCloseUsbServer();

   216 

   217 	virtual enum TVerdict doTestStepL( void );

   218 

   219 private:

   220 };

   221 

   222 ///////////////////////////////////////////////

   223 // Test 1.16

   224 NONSHARABLE_CLASS(CTestStopUsb) : public CTestStepUsb

   225 {

   226 public:

   227 	CTestStopUsb();

   228 	virtual ~CTestStopUsb();

   229 

   230 	virtual enum TVerdict doTestStepL( void );

   231 

   232 private:

   233 };

   234 

   235 ///////////////////////////////////////////////

   236 // Test 1.17

   237 NONSHARABLE_CLASS(CTestNotifySignalChange) : public CTestStepUsb

   238 {

   239 public:

   240 	CTestNotifySignalChange();

   241 	virtual ~CTestNotifySignalChange();

   242 

   243 	virtual enum TVerdict doTestStepL( void );

   244 

   245 private:

   246 };

   247 

   248 ///////////////////////////////////////////////

   249 // Test 1.18

   250 NONSHARABLE_CLASS(CTestWaitForSignalChange) : public CTestStepUsb

   251 {

   252 public:

   253 	CTestWaitForSignalChange();

   254 	virtual ~CTestWaitForSignalChange();

   255 

   256 	virtual enum TVerdict doTestStepL( void );

   257 

   258 private:

   259 };

   260 

   261 ///////////////////////////////////////////////

   262 // Test 1.19

   263 NONSHARABLE_CLASS(CTestWaitForReadCancel) : public CTestStepUsb

   264 {

   265 public:

   266 	CTestWaitForReadCancel();

   267 	virtual ~CTestWaitForReadCancel();

   268 

   269 	virtual enum TVerdict doTestStepL( void );

   270 

   271 private:

   272 };

   273 

   274 ///////////////////////////////////////////////

   275 // Test 1.20

   276 NONSHARABLE_CLASS(CTestPostReadThenCancel) : public CTestStepUsb

   277 {

   278 public:

   279 	CTestPostReadThenCancel();

   280 	virtual ~CTestPostReadThenCancel();

   281 

   282 	virtual enum TVerdict doTestStepL( void );

   283 

   284 private:

   285 };

   286 

   287 ///////////////////////////////////////////////

   288 // Test 1.21

   289 NONSHARABLE_CLASS(CTestNotifyConfigChange) : public CTestStepUsb

   290 {

   291 public:

   292 	CTestNotifyConfigChange();

   293 	virtual ~CTestNotifyConfigChange();

   294 

   295 	virtual enum TVerdict doTestStepL( void );

   296 

   297 private:

   298 };

   299 

   300 ///////////////////////////////////////////////

   301 // Test 1.23

   302 NONSHARABLE_CLASS(CTestNotifyBreak) : public CTestStepUsb

   303 {

   304 public:

   305 	CTestNotifyBreak();

   306 	virtual ~CTestNotifyBreak();

   307 

   308 	virtual enum TVerdict doTestStepL( void );

   309 

   310 private:

   311 };

   312 

   313 ///////////////////////////////////////////////

   314 // Test 1.24

   315 NONSHARABLE_CLASS(CTestWaitForBreak) : public CTestStepUsb

   316 {

   317 public:

   318 	CTestWaitForBreak();

   319 	virtual ~CTestWaitForBreak();

   320 

   321 	virtual enum TVerdict doTestStepL( void );

   322 

   323 private:

   324 };

   325 

   326 ///////////////////////////////////////////////

   327 // Test 1.25

   328 NONSHARABLE_CLASS(CTestCloseAll) : public CTestStepUsb

   329 {

   330 public:

   331 	CTestCloseAll();

   332 	virtual ~CTestCloseAll();

   333 

   334 	virtual enum TVerdict doTestStepL( void );

   335 

   336 private:

   337 };

   338 

   339 #endif /* __USBTEST1_H__ */