// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include "TE_c32base.h"

#ifndef TE_C32_H
#define TE_C32_H

class CTestLoopback : public CC32TestStep
	{
public:
	CTestLoopback();
	~CTestLoopback(){};
	virtual enum TVerdict doTestStepL();
	static TInt DataReadThread(TAny* aArg);
private:
	RSemaphore iSem;
	TInt iState1;		// test 1
	TInt iState2;		// test 2
	TInt iState3;		// test 3
	TInt iState4;		// test 3
	};

class CTestInit : public CC32TestStep
	{
public:
	CTestInit();
	~CTestInit(){};
	virtual enum TVerdict doTestStepL();
	TVerdict doTestStepPreambleL() { return EPass; }
	TVerdict doTestStepPostambleL() { return EPass; }
	};


class CTestAllocMoreWriteMem : public CC32TestStep
	{
public:
	CTestAllocMoreWriteMem();
	~CTestAllocMoreWriteMem() {};
	virtual enum TVerdict doTestStepL();
	};


class CTestMemoryWriteFail : public CC32TestStep
	{
public:
	CTestMemoryWriteFail();
	~CTestMemoryWriteFail() {};
	virtual enum TVerdict doTestStepL();
	};


class CTestResetBuffers : public CC32TestStep
	{
public:
	CTestResetBuffers();
	~CTestResetBuffers() {};
	virtual enum TVerdict doTestStepL();
	};


class CTestCorrectDataRead : public CC32TestStep
	{
public:
	CTestCorrectDataRead();
	~CTestCorrectDataRead() {};
	virtual enum TVerdict doTestStepL();
	};

class CTestMaxBufferOverflow : public CC32TestStep
	{
public:
	CTestMaxBufferOverflow();
	~CTestMaxBufferOverflow() {};
	virtual enum TVerdict doTestStepL();
	};

class CTestDoubleStart : public CC32TestStep
	{
public:
	CTestDoubleStart();
	~CTestDoubleStart(){};

 	virtual TVerdict doTestStepPreambleL( void );
	virtual TVerdict doTestStepPostambleL( void );
	virtual enum TVerdict doTestStepL();
	static TInt StartC32Thread(TAny* aArg);

private:
	//RSemaphore iSem;
	TInt iState1;		// test 1
	};

class CTestOpen : public CC32TestStep
	{
public:
	CTestOpen();
	~CTestOpen(){};
	virtual enum TVerdict doTestStepL();
	};
	
class CTestInfo : public CC32TestStep
	{
public:
	CTestInfo();
	~CTestInfo(){};
	virtual enum TVerdict doTestStepL();
	};
	
class CTestDoubleRead : public CC32TestStep
	{
public:
	CTestDoubleRead();
	~CTestDoubleRead(){};
	static TInt DoubleReadThread(TAny* aArg);
	virtual enum TVerdict doTestStepL();
private:
	TBuf16<15> iBuffer;
	TInt iState1;
	TInt iState2;	
	TInt iState3;	
	TInt iState4;	
	};
	
class CTestTimerAllocation : public CC32TestStep
	{
public:
	CTestTimerAllocation();
	~CTestTimerAllocation(){};
	static void TestTimerAllocationL(TInt aAllocFailValue);
	static TInt TimerThread(TAny* aArg);
	virtual enum TVerdict doTestStepL();
	};
	
class CTestConfigPanic : public CC32TestStep
	{
public:
	CTestConfigPanic();
	~CTestConfigPanic(){};
	static TInt ConfigPanic(TAny* aArg);
	virtual enum TVerdict doTestStepL();
private:
	TInt iState1; 		 // test 1
	TInt iState2;		 // test 2
	TInt iState3;		 // test 3
	};

class CTestBadDescriptorPanic : public CC32TestStep
	{
public:
	CTestBadDescriptorPanic();
	~CTestBadDescriptorPanic(){};
	static TInt BadDescriptor(TAny* aArg);
	virtual enum TVerdict doTestStepL();
private:
	TInt iState1;		// test 1
	TInt iState2;		// test 2
	TInt iState3;		// test 3	
	};


class CTestBusyReturn : public CC32TestStep
	{
public:
	CTestBusyReturn();
	~CTestBusyReturn(){};
	static TInt CreateThread(TAny* aArg);
	static TInt OpenAndReadThreadL(TAny* aArg);
	virtual enum TVerdict doTestStepL();
private:
	RSemaphore iSem;	
	TBuf16<255> iBuffer;
	TInt iState1;		// test 1
	TInt iState2;		// test 2
	TInt iState3;		// test 3
	};	


class CTestCancel : public CC32TestStep
	{
public:
	CTestCancel();
	~CTestCancel(){};
	static TInt CancelThread(TAny* aArg);
	virtual enum TVerdict doTestStepL();
private:
	TBuf16<255> iBuffer;
	TInt iState1;		// test 1
	TInt iState2;		// test 2
	TInt iState3;		// test 3
	TInt iState4;		// test 4
	TInt iState5;
	TInt iState6;
	TInt iState7;
};	

class CTestGetSetConfig : public CC32TestStep
	{
public:
	CTestGetSetConfig();
	~CTestGetSetConfig(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestTimeOut : public CC32TestStep
	{
public:
	CTestTimeOut();
	~CTestTimeOut(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestThreadPanic : public CC32TestStep
	{
public:
	CTestThreadPanic();
	~CTestThreadPanic(){};
	virtual enum TVerdict doTestStepL();
private:
	static TInt OpenExclusiveThread(TAny* aArg);
	static TInt OpenSharedThread(TAny* aArg);
private:
	RSemaphore iSem1;	
	RSemaphore iSem2;
	TBuf16<255> iBuffer;
	TInt iState1;		// test 1
	TInt iState2;		// test 2
	TInt iState3;		// test 3
	TInt iState4;		// test 4
	};		

class CTestBufferOptions : public CC32TestStep
	{
public:
	CTestBufferOptions();
	~CTestBufferOptions(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestOOMConnection : public CC32TestStep
	{
public:
	CTestOOMConnection();
	~CTestOOMConnection(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestOOMPortCreation : public CC32TestStep
	{
public:
	CTestOOMPortCreation();
	~CTestOOMPortCreation(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestSetSignalsPanicBug : public CC32TestStep
	{
public:
	CTestSetSignalsPanicBug();
	~CTestSetSignalsPanicBug(){};
	virtual enum TVerdict doTestStepL();
	};			

class CTestStartServerThread : public CC32TestStep
	{
public:
	CTestStartServerThread();
	~CTestStartServerThread(){};
	virtual enum TVerdict doTestStepL();
	};				

class CTestCapsV02 : public CC32TestStep
	{
public:
	CTestCapsV02();
	~CTestCapsV02(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestOpenPortsWithHighNumbers : public CC32TestStep
	{
public:
	CTestOpenPortsWithHighNumbers();
	~CTestOpenPortsWithHighNumbers(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestReadWrite : public CC32TestStep
	{
public:
	CTestReadWrite();
	~CTestReadWrite(){};
	virtual enum TVerdict doTestStepL();
	};
	
class CTestReadWrite2 : public CC32TestStep
	{
public:
	CTestReadWrite2();
	~CTestReadWrite2(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestSignalLines : public CC32TestStep
	{
public:
	CTestSignalLines();
	~CTestSignalLines(){};
	virtual enum TVerdict doTestStepL();
	};		
	
class CTestQueryreceiveBuffer : public CC32TestStep
	{
public:
	CTestQueryreceiveBuffer();
	~CTestQueryreceiveBuffer(){};
	virtual enum TVerdict doTestStepL();
	};		
	
class CTestWrite0 : public CC32TestStep
	{
public:
	CTestWrite0();
	~CTestWrite0(){};
	virtual enum TVerdict doTestStepL();
	};		
	
class CTestReadOneOrMore : public CC32TestStep
	{
public:
	CTestReadOneOrMore();
	~CTestReadOneOrMore(){};
	virtual enum TVerdict doTestStepL();
	};		
	
class CTestBufferReadWrite : public CC32TestStep
	{
public:
	CTestBufferReadWrite();
	~CTestBufferReadWrite(){};
	virtual enum TVerdict doTestStepL();
	};			
	
class CTestBufferreadOneOrMore : public CC32TestStep
	{
public:
	CTestBufferreadOneOrMore();
	~CTestBufferreadOneOrMore(){};
	virtual enum TVerdict doTestStepL();
	};			

class CTestNotifySignals : public CC32TestStep
	{
public:
	CTestNotifySignals();
	~CTestNotifySignals(){};
	virtual enum TVerdict doTestStepL();
	};		
	
class CTestRxDataAvailable : public CC32TestStep
	{
public:
	CTestRxDataAvailable();
	~CTestRxDataAvailable(){};
	virtual enum TVerdict doTestStepL();
	};		

class CTestHelloEllo : public CC32TestStep
	{
public:
	CTestHelloEllo();
	~CTestHelloEllo(){};
	virtual enum TVerdict doTestStepL();
	};			

class CLsc32ListAvailablePorts	: public CC32TestStep
	{
public:
	CLsc32ListAvailablePorts();
	~CLsc32ListAvailablePorts(){};
	virtual enum TVerdict doTestStepL();
	};			

class CLsc32ListNumberOfLoadedCSYs	: public CC32TestStep
	{
public:
	CLsc32ListNumberOfLoadedCSYs();
	~CLsc32ListNumberOfLoadedCSYs(){};
	virtual enum TVerdict doTestStepL();
	};		

class CLsc32LoadUnloadCsy : public CC32TestStep
	{
public:
	CLsc32LoadUnloadCsy();
	~CLsc32LoadUnloadCsy(){};
	virtual enum TVerdict doTestStepL();
	};		

class CLsc32GetPortInfo : public CC32TestStep		
	{
public:
	CLsc32GetPortInfo();
	~CLsc32GetPortInfo(){};
	virtual enum TVerdict doTestStepL();
	};					

class CDummyTest : public CC32TestStep		
	{
public:
	CDummyTest();
	~CDummyTest(){};
	virtual enum TVerdict doTestStepL();
private:
	void WaitingTestsL(TCommRole aRole);
	void DummyClientTestsL(TCommRole aRole, TBool aHeapCheck);
	void DummyPreemptableTestsL(TCommRole aRole);
	void ShowSignals(TUint asig, TCommRole aRole);
	void ShowFlow(TFlowControl aFlow);
	void ShowConfig(TCommNotificationV01 aConfig);
	void ShowCapsV02(TCommCapsV02 aCaps);
	void ShowCapsV01(TCommCapsV01 aCaps);
	RComm iDPort0; //< comm port 0
	RComm iDPort1; //< comm port 1
	RComm iDPort2; //< comm port 2
	};		

class CTestDCEPort : public CC32TestStep		
	{
public:
	CTestDCEPort();
	~CTestDCEPort(){};
	virtual enum TVerdict doTestStepL();
	virtual enum TVerdict doTestStepPreambleL();
	virtual enum TVerdict doTestStepPostambleL();
	};
	
class CTestPlatSecOpenPortDummy : public CC32TestStep
	{
public:
	CTestPlatSecOpenPortDummy();
	~CTestPlatSecOpenPortDummy(){};
	virtual enum TVerdict doTestStepL();
	};


class CTestOpenWhenAvailable : public CC32TestStep
	{
public:
	virtual enum TVerdict doTestStepL();
	};


#endif //TE_C32_H