1 // Copyright (c) 1997-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 //

    15 

    16 #include "TE_c32base.h"

    17 

    18 #ifndef TE_C32_H

    19 #define TE_C32_H

    20 

    21 class CTestLoopback : public CC32TestStep

    22 	{

    23 public:

    24 	CTestLoopback();

    25 	~CTestLoopback(){};

    26 	virtual enum TVerdict doTestStepL();

    27 	static TInt DataReadThread(TAny* aArg);

    28 private:

    29 	RSemaphore iSem;

    30 	TInt iState1;		// test 1

    31 	TInt iState2;		// test 2

    32 	TInt iState3;		// test 3

    33 	TInt iState4;		// test 3

    34 	};

    35 

    36 class CTestInit : public CC32TestStep

    37 	{

    38 public:

    39 	CTestInit();

    40 	~CTestInit(){};

    41 	virtual enum TVerdict doTestStepL();

    42 	TVerdict doTestStepPreambleL() { return EPass; }

    43 	TVerdict doTestStepPostambleL() { return EPass; }

    44 	};

    45 

    46 

    47 class CTestAllocMoreWriteMem : public CC32TestStep

    48 	{

    49 public:

    50 	CTestAllocMoreWriteMem();

    51 	~CTestAllocMoreWriteMem() {};

    52 	virtual enum TVerdict doTestStepL();

    53 	};

    54 

    55 

    56 class CTestMemoryWriteFail : public CC32TestStep

    57 	{

    58 public:

    59 	CTestMemoryWriteFail();

    60 	~CTestMemoryWriteFail() {};

    61 	virtual enum TVerdict doTestStepL();

    62 	};

    63 

    64 

    65 class CTestResetBuffers : public CC32TestStep

    66 	{

    67 public:

    68 	CTestResetBuffers();

    69 	~CTestResetBuffers() {};

    70 	virtual enum TVerdict doTestStepL();

    71 	};

    72 

    73 

    74 class CTestCorrectDataRead : public CC32TestStep

    75 	{

    76 public:

    77 	CTestCorrectDataRead();

    78 	~CTestCorrectDataRead() {};

    79 	virtual enum TVerdict doTestStepL();

    80 	};

    81 

    82 class CTestMaxBufferOverflow : public CC32TestStep

    83 	{

    84 public:

    85 	CTestMaxBufferOverflow();

    86 	~CTestMaxBufferOverflow() {};

    87 	virtual enum TVerdict doTestStepL();

    88 	};

    89 

    90 class CTestDoubleStart : public CC32TestStep

    91 	{

    92 public:

    93 	CTestDoubleStart();

    94 	~CTestDoubleStart(){};

    95 

    96  	virtual TVerdict doTestStepPreambleL( void );

    97 	virtual TVerdict doTestStepPostambleL( void );

    98 	virtual enum TVerdict doTestStepL();

    99 	static TInt StartC32Thread(TAny* aArg);

   100 

   101 private:

   102 	//RSemaphore iSem;

   103 	TInt iState1;		// test 1

   104 	};

   105 

   106 class CTestOpen : public CC32TestStep

   107 	{

   108 public:

   109 	CTestOpen();

   110 	~CTestOpen(){};

   111 	virtual enum TVerdict doTestStepL();

   112 	};

   113 	

   114 class CTestInfo : public CC32TestStep

   115 	{

   116 public:

   117 	CTestInfo();

   118 	~CTestInfo(){};

   119 	virtual enum TVerdict doTestStepL();

   120 	};

   121 	

   122 class CTestDoubleRead : public CC32TestStep

   123 	{

   124 public:

   125 	CTestDoubleRead();

   126 	~CTestDoubleRead(){};

   127 	static TInt DoubleReadThread(TAny* aArg);

   128 	virtual enum TVerdict doTestStepL();

   129 private:

   130 	TBuf16<15> iBuffer;

   131 	TInt iState1;

   132 	TInt iState2;	

   133 	TInt iState3;	

   134 	TInt iState4;	

   135 	};

   136 	

   137 class CTestTimerAllocation : public CC32TestStep

   138 	{

   139 public:

   140 	CTestTimerAllocation();

   141 	~CTestTimerAllocation(){};

   142 	static void TestTimerAllocationL(TInt aAllocFailValue);

   143 	static TInt TimerThread(TAny* aArg);

   144 	virtual enum TVerdict doTestStepL();

   145 	};

   146 	

   147 class CTestConfigPanic : public CC32TestStep

   148 	{

   149 public:

   150 	CTestConfigPanic();

   151 	~CTestConfigPanic(){};

   152 	static TInt ConfigPanic(TAny* aArg);

   153 	virtual enum TVerdict doTestStepL();

   154 private:

   155 	TInt iState1; 		 // test 1

   156 	TInt iState2;		 // test 2

   157 	TInt iState3;		 // test 3

   158 	};

   159 

   160 class CTestBadDescriptorPanic : public CC32TestStep

   161 	{

   162 public:

   163 	CTestBadDescriptorPanic();

   164 	~CTestBadDescriptorPanic(){};

   165 	static TInt BadDescriptor(TAny* aArg);

   166 	virtual enum TVerdict doTestStepL();

   167 private:

   168 	TInt iState1;		// test 1

   169 	TInt iState2;		// test 2

   170 	TInt iState3;		// test 3	

   171 	};

   172 

   173 

   174 class CTestBusyReturn : public CC32TestStep

   175 	{

   176 public:

   177 	CTestBusyReturn();

   178 	~CTestBusyReturn(){};

   179 	static TInt CreateThread(TAny* aArg);

   180 	static TInt OpenAndReadThreadL(TAny* aArg);

   181 	virtual enum TVerdict doTestStepL();

   182 private:

   183 	RSemaphore iSem;	

   184 	TBuf16<255> iBuffer;

   185 	TInt iState1;		// test 1

   186 	TInt iState2;		// test 2

   187 	TInt iState3;		// test 3

   188 	};	

   189 

   190 

   191 class CTestCancel : public CC32TestStep

   192 	{

   193 public:

   194 	CTestCancel();

   195 	~CTestCancel(){};

   196 	static TInt CancelThread(TAny* aArg);

   197 	virtual enum TVerdict doTestStepL();

   198 private:

   199 	TBuf16<255> iBuffer;

   200 	TInt iState1;		// test 1

   201 	TInt iState2;		// test 2

   202 	TInt iState3;		// test 3

   203 	TInt iState4;		// test 4

   204 	TInt iState5;

   205 	TInt iState6;

   206 	TInt iState7;

   207 };	

   208 

   209 class CTestGetSetConfig : public CC32TestStep

   210 	{

   211 public:

   212 	CTestGetSetConfig();

   213 	~CTestGetSetConfig(){};

   214 	virtual enum TVerdict doTestStepL();

   215 	};		

   216 

   217 class CTestTimeOut : public CC32TestStep

   218 	{

   219 public:

   220 	CTestTimeOut();

   221 	~CTestTimeOut(){};

   222 	virtual enum TVerdict doTestStepL();

   223 	};		

   224 

   225 class CTestThreadPanic : public CC32TestStep

   226 	{

   227 public:

   228 	CTestThreadPanic();

   229 	~CTestThreadPanic(){};

   230 	virtual enum TVerdict doTestStepL();

   231 private:

   232 	static TInt OpenExclusiveThread(TAny* aArg);

   233 	static TInt OpenSharedThread(TAny* aArg);

   234 private:

   235 	RSemaphore iSem1;	

   236 	RSemaphore iSem2;

   237 	TBuf16<255> iBuffer;

   238 	TInt iState1;		// test 1

   239 	TInt iState2;		// test 2

   240 	TInt iState3;		// test 3

   241 	TInt iState4;		// test 4

   242 	};		

   243 

   244 class CTestBufferOptions : public CC32TestStep

   245 	{

   246 public:

   247 	CTestBufferOptions();

   248 	~CTestBufferOptions(){};

   249 	virtual enum TVerdict doTestStepL();

   250 	};		

   251 

   252 class CTestOOMConnection : public CC32TestStep

   253 	{

   254 public:

   255 	CTestOOMConnection();

   256 	~CTestOOMConnection(){};

   257 	virtual enum TVerdict doTestStepL();

   258 	};		

   259 

   260 class CTestOOMPortCreation : public CC32TestStep

   261 	{

   262 public:

   263 	CTestOOMPortCreation();

   264 	~CTestOOMPortCreation(){};

   265 	virtual enum TVerdict doTestStepL();

   266 	};		

   267 

   268 class CTestSetSignalsPanicBug : public CC32TestStep

   269 	{

   270 public:

   271 	CTestSetSignalsPanicBug();

   272 	~CTestSetSignalsPanicBug(){};

   273 	virtual enum TVerdict doTestStepL();

   274 	};			

   275 

   276 class CTestStartServerThread : public CC32TestStep

   277 	{

   278 public:

   279 	CTestStartServerThread();

   280 	~CTestStartServerThread(){};

   281 	virtual enum TVerdict doTestStepL();

   282 	};				

   283 

   284 class CTestCapsV02 : public CC32TestStep

   285 	{

   286 public:

   287 	CTestCapsV02();

   288 	~CTestCapsV02(){};

   289 	virtual enum TVerdict doTestStepL();

   290 	};		

   291 

   292 class CTestOpenPortsWithHighNumbers : public CC32TestStep

   293 	{

   294 public:

   295 	CTestOpenPortsWithHighNumbers();

   296 	~CTestOpenPortsWithHighNumbers(){};

   297 	virtual enum TVerdict doTestStepL();

   298 	};		

   299 

   300 class CTestReadWrite : public CC32TestStep

   301 	{

   302 public:

   303 	CTestReadWrite();

   304 	~CTestReadWrite(){};

   305 	virtual enum TVerdict doTestStepL();

   306 	};

   307 	

   308 class CTestReadWrite2 : public CC32TestStep

   309 	{

   310 public:

   311 	CTestReadWrite2();

   312 	~CTestReadWrite2(){};

   313 	virtual enum TVerdict doTestStepL();

   314 	};		

   315 

   316 class CTestSignalLines : public CC32TestStep

   317 	{

   318 public:

   319 	CTestSignalLines();

   320 	~CTestSignalLines(){};

   321 	virtual enum TVerdict doTestStepL();

   322 	};		

   323 	

   324 class CTestQueryreceiveBuffer : public CC32TestStep

   325 	{

   326 public:

   327 	CTestQueryreceiveBuffer();

   328 	~CTestQueryreceiveBuffer(){};

   329 	virtual enum TVerdict doTestStepL();

   330 	};		

   331 	

   332 class CTestWrite0 : public CC32TestStep

   333 	{

   334 public:

   335 	CTestWrite0();

   336 	~CTestWrite0(){};

   337 	virtual enum TVerdict doTestStepL();

   338 	};		

   339 	

   340 class CTestReadOneOrMore : public CC32TestStep

   341 	{

   342 public:

   343 	CTestReadOneOrMore();

   344 	~CTestReadOneOrMore(){};

   345 	virtual enum TVerdict doTestStepL();

   346 	};		

   347 	

   348 class CTestBufferReadWrite : public CC32TestStep

   349 	{

   350 public:

   351 	CTestBufferReadWrite();

   352 	~CTestBufferReadWrite(){};

   353 	virtual enum TVerdict doTestStepL();

   354 	};			

   355 	

   356 class CTestBufferreadOneOrMore : public CC32TestStep

   357 	{

   358 public:

   359 	CTestBufferreadOneOrMore();

   360 	~CTestBufferreadOneOrMore(){};

   361 	virtual enum TVerdict doTestStepL();

   362 	};			

   363 

   364 class CTestNotifySignals : public CC32TestStep

   365 	{

   366 public:

   367 	CTestNotifySignals();

   368 	~CTestNotifySignals(){};

   369 	virtual enum TVerdict doTestStepL();

   370 	};		

   371 	

   372 class CTestRxDataAvailable : public CC32TestStep

   373 	{

   374 public:

   375 	CTestRxDataAvailable();

   376 	~CTestRxDataAvailable(){};

   377 	virtual enum TVerdict doTestStepL();

   378 	};		

   379 

   380 class CTestHelloEllo : public CC32TestStep

   381 	{

   382 public:

   383 	CTestHelloEllo();

   384 	~CTestHelloEllo(){};

   385 	virtual enum TVerdict doTestStepL();

   386 	};			

   387 

   388 class CLsc32ListAvailablePorts	: public CC32TestStep

   389 	{

   390 public:

   391 	CLsc32ListAvailablePorts();

   392 	~CLsc32ListAvailablePorts(){};

   393 	virtual enum TVerdict doTestStepL();

   394 	};			

   395 

   396 class CLsc32ListNumberOfLoadedCSYs	: public CC32TestStep

   397 	{

   398 public:

   399 	CLsc32ListNumberOfLoadedCSYs();

   400 	~CLsc32ListNumberOfLoadedCSYs(){};

   401 	virtual enum TVerdict doTestStepL();

   402 	};		

   403 

   404 class CLsc32LoadUnloadCsy : public CC32TestStep

   405 	{

   406 public:

   407 	CLsc32LoadUnloadCsy();

   408 	~CLsc32LoadUnloadCsy(){};

   409 	virtual enum TVerdict doTestStepL();

   410 	};		

   411 

   412 class CLsc32GetPortInfo : public CC32TestStep		

   413 	{

   414 public:

   415 	CLsc32GetPortInfo();

   416 	~CLsc32GetPortInfo(){};

   417 	virtual enum TVerdict doTestStepL();

   418 	};					

   419 

   420 class CDummyTest : public CC32TestStep		

   421 	{

   422 public:

   423 	CDummyTest();

   424 	~CDummyTest(){};

   425 	virtual enum TVerdict doTestStepL();

   426 private:

   427 	void WaitingTestsL(TCommRole aRole);

   428 	void DummyClientTestsL(TCommRole aRole, TBool aHeapCheck);

   429 	void DummyPreemptableTestsL(TCommRole aRole);

   430 	void ShowSignals(TUint asig, TCommRole aRole);

   431 	void ShowFlow(TFlowControl aFlow);

   432 	void ShowConfig(TCommNotificationV01 aConfig);

   433 	void ShowCapsV02(TCommCapsV02 aCaps);

   434 	void ShowCapsV01(TCommCapsV01 aCaps);

   435 	RComm iDPort0; //< comm port 0

   436 	RComm iDPort1; //< comm port 1

   437 	RComm iDPort2; //< comm port 2

   438 	};		

   439 

   440 class CTestDCEPort : public CC32TestStep		

   441 	{

   442 public:

   443 	CTestDCEPort();

   444 	~CTestDCEPort(){};

   445 	virtual enum TVerdict doTestStepL();

   446 	virtual enum TVerdict doTestStepPreambleL();

   447 	virtual enum TVerdict doTestStepPostambleL();

   448 	};

   449 	

   450 class CTestPlatSecOpenPortDummy : public CC32TestStep

   451 	{

   452 public:

   453 	CTestPlatSecOpenPortDummy();

   454 	~CTestPlatSecOpenPortDummy(){};

   455 	virtual enum TVerdict doTestStepL();

   456 	};

   457 

   458 

   459 class CTestOpenWhenAvailable : public CC32TestStep

   460 	{

   461 public:

   462 	virtual enum TVerdict doTestStepL();

   463 	};

   464 

   465 

   466 #endif //TE_C32_H

   467 

   468 

   469