// 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_c32.h"

#include "TTHREAD.H"

#include <e32test.h>

#include "C32COMM.H"

#include "dummy.h"

#include <rsshared.h>

#include <e32cmn.h>

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#define LDD_NAME _L("ECOMM")

#define LDD_NAMETST _L("ECOMMTST")

#else

#define PDD_NAME _L("EUART1")  //< Physical Device Driver #1

#define LDD_NAME _L("ECOMM")   //< Logical Device Driver

#define LDD_NAMETST _L("ECOMMTST")

#endif

#if (!defined __WINS__ && defined EKA1)

#define PDD2_NAME _L("EUART2") //< Physical Device Driver #2

#endif

const TInt KInvalidArgument=-1;

CTestLoopback::CTestLoopback()

	{

	SetTestStepName(_L("TestLoopback"));

	}

TInt CTestLoopback::DataReadThread(TAny* aArg)

/**

 * Thread which attempts to read a chunk of data from loopback port

 */

	{

	CTestLoopback* stepTest = reinterpret_cast<CTestLoopback*> (aArg);

	_LIT(KPortName1,"LOOPBACK::1");

	_LIT(KCSYName,"LOOPBACK.CSY");

	RCommServ commServ;

	TInt res=commServ.Connect();

	if(res!=KErrNone)

		{

		stepTest->iState1 = __LINE__ - 2;

		return(res);

		}

	res=commServ.LoadCommModule(KCSYName);

	if(res!=KErrNone)

		{

		stepTest->iState2 = __LINE__ - 2;

		return(res);

		}

	res=stepTest->iSerialPortList[0].Open(commServ,KPortName1,ECommShared);

	if(res!=KErrNone)

		{

		stepTest->iState3 = __LINE__ - 2;

		return(res);

		}

	TRequestStatus stat0;

	TBuf8<20> readBuf;

	for (TInt i=0;i<=200;i++)

		{

		stepTest->iSerialPortList[0].ReadOneOrMore(stat0,readBuf);

		User::WaitForRequest(stat0);

		res = stat0.Int();

		if(res!=KErrNone)

			{

			stepTest->iState4 = __LINE__ - 2;

			return(res);

			}

		}

	stepTest->iSem.Signal();

	stepTest->iSerialPortList[0].Close();

	return KErrNone;

	}

TVerdict CTestLoopback::doTestStepL()

	{

	INFO_PRINTF1(_L("==================================="));

	INFO_PRINTF1(_L("Test : TestLoopback"));

	INFO_PRINTF1(_L("==================================="));

	_LIT(KCsyName,"LOOPBACK.CSY");

	_LIT(KPortName0,"LOOPBACK::0");

	_LIT8(KServerText,"Test Loopback : ");

	iSem.CreateLocal(0);

	RCommServ commServ;

	TInt ret=commServ.Connect();

	ret=commServ.LoadCommModule(KCsyName);

	TESTCHECKL(ret,KErrNone);

	ret=iSerialPortList[1].Open(commServ,KPortName0,ECommShared);

	TESTCHECKL(ret,KErrNone);

	RThread readThread;

	TInt res=readThread.Create(_L("DataReadThread"),DataReadThread,KDefaultStackSize,KDefaultHeapSizeThread,KDefaultHeapSizeThread,this);

	TESTCHECKL(res, KErrNone);

	TRequestStatus stat;

	readThread.Logon(stat);

	readThread.Resume();

	TRequestStatus stat0;

	for (TInt i=0;i<=200;i++)

		{

		TBuf8<20> writeBuf;

		writeBuf.Append(KServerText);

		writeBuf.AppendNum(i);

		if(i<=9)

			{

			writeBuf.AppendFill(' ',3);

			}

		if ((i >= 10) && (i<=99))

			{

			writeBuf.AppendFill(' ',2);

			}

		if((i >= 100) && (i <= 999))

			{

			writeBuf.AppendFill(' ', 1);

			}

		iSerialPortList[1].Write(stat0,writeBuf);

		User::WaitForRequest(stat0);

		TESTCHECKL(stat0.Int(), KErrNone);

		}

	iSem.Wait();

	User::WaitForRequest(stat);

	TESTCHECKL(stat.Int(), KErrNone);

	iSem.Close();

	CLOSE_AND_WAIT(readThread);

	iSerialPortList[1].Close();

	commServ.Close();

	if(iState1 != KErrNone)

		{

		INFO_PRINTF2(_L("Error occured, iState1, in DataReadThread at line %d, expected KErrNone."), iState1);

		SetTestStepResult(EFail);

		}

	if(iState2 != KErrNone)

		{

		INFO_PRINTF2(_L("Error occured, iState2, in DataReadThread at line %d, expected KErrNone."), iState2);

		SetTestStepResult(EFail);

		}		

	if(iState3 != KErrNone)

		{

		INFO_PRINTF2(_L("Error occured, iState3, in DataReadThread at line %d, expected KErrNone."), iState3);

		SetTestStepResult(EFail);

		}				

	if(iState4 != KErrNone)

		{

		INFO_PRINTF2(_L("Error occured, iState4, in DataReadThread at line %d, expected KErrNone."), iState4);

		SetTestStepResult(EFail);

		}

	return TestStepResult();

	}

CTestAllocMoreWriteMem::CTestAllocMoreWriteMem()

	{

	SetTestStepName(_L("TestAllocMoreWriteMem"));

	}

TVerdict CTestAllocMoreWriteMem::doTestStepL()

	{

	INFO_PRINTF1(_L("==================================="));

	INFO_PRINTF1(_L("Test : TestAllocMoreWriteMem"));

	INFO_PRINTF1(_L("==================================="));

	_LIT(KCsyName,"LOOPBACK.CSY");

	_LIT(KPortName0,"LOOPBACK::0");

	_LIT8(KServerText,"Test Loopback : ");

	RCommServ commServ;

	TInt ret=commServ.Connect();

	ret=commServ.LoadCommModule(KCsyName);

	TESTCHECKL(ret,KErrNone);

	TRequestStatus stat0;										

	ret = iSerialPortList[1].Open(commServ,KPortName0,ECommShared);

	TESTCHECKL(ret,KErrNone);

	// This many loops ensures we need to allocate more memory for 

	// write buffer.

    const TInt KNumOfLoopIterations = 1500;

    for (TInt i = 0; i < KNumOfLoopIterations; i++)

		{

	    TBuf8<20> writeBuf;

		writeBuf.Append(KServerText);

		writeBuf.AppendNum(i);

		if(i <=9)

			{

			writeBuf.AppendFill(' ', 3);

			}

		if ((i >= 10) && (i <= 99))

			{

			writeBuf.AppendFill(' ', 2);

			}

		if((i >= 100) && (i <= 999))

			{

			writeBuf.AppendFill(' ', 1);

			}

		iSerialPortList[1].Write(stat0,writeBuf);

		User::WaitForRequest(stat0);

		TESTCHECKL(stat0.Int(), KErrNone);

		}

	TInt numOfBuffers = 0;

	// This method has been used to query the amount of data in the 

	// write buffer

	numOfBuffers = iSerialPortList[1].QueryReceiveBuffer();

	// The default buffer size for a write port is 4096. If we write

	// more than 4096 bytes we can confirm we have allocated more memory

	// for the write port

	TESTCHECKCONDITIONL(numOfBuffers == (20 * KNumOfLoopIterations));

	iSerialPortList[1].Close();

	commServ.Close();

	return TestStepResult();

	}	

CTestMemoryWriteFail::CTestMemoryWriteFail()

	{

	SetTestStepName(_L("TestMemoryWriteFail"));

	}

TVerdict CTestMemoryWriteFail::doTestStepL()

	{

	INFO_PRINTF1(_L("==================================="));

	INFO_PRINTF1(_L("Test : TestMemoryWriteFail"));

	INFO_PRINTF1(_L("==================================="));

#ifdef _DEBUG

	// The following test can only be tested under DEBUG situations as the 

	// __DbgFailNext returns KErrNone for the RELEASE situation

	_LIT(KCsyName,"LOOPBACK.CSY");

	_LIT(KPortName0,"LOOPBACK::0");

	RCommServ commServ;

	TInt ret=commServ.Connect();

	ret=commServ.LoadCommModule(KCsyName);

	TESTCHECKL(ret,KErrNone);

	TRequestStatus stat0;										

	ret = iSerialPortList[1].Open(commServ,KPortName0,ECommShared);

	TESTCHECKL(ret,KErrNone);

	// The following code writes in small chunks of data filling the write data

	// with X's

	TBuf8<64> writeData;

	writeData.Fill('X', 64);

	// 64 * 64 = 4096, currently the default buffer size

	const TInt KLoopFillBuffer = 64;

	for(int i = 0; i < KLoopFillBuffer; i++)

		{

		iSerialPortList[1].Write(stat0,writeData);	

		User::WaitForRequest(stat0);

		TESTCHECKL(stat0.Int(), KErrNone);

		}

    // if the size of the standard write buffer is 4096 bytes then

    // the above will fill in all the data

    // if we try and write more data a new memory allocation is required.

    commServ.__DbgFailNext(1);

	iSerialPortList[1].Write(stat0, writeData);

	User::WaitForRequest(stat0);

    TESTCHECKL(stat0.Int(), KErrNoMemory);

    commServ.__DbgFailNext(-1);

	iSerialPortList[1].Close();

	commServ.Close();

#else	

	INFO_PRINTF1(_L("Test : TestMemoryWriteFail not executed for non debug tests"));

#endif

	return TestStepResult();													

	}

CTestResetBuffers::CTestResetBuffers()

	{

	SetTestStepName(_L("TestResetBuffers"));

	}

TVerdict CTestResetBuffers::doTestStepL()

	{

	INFO_PRINTF1(_L("==================================="));

	INFO_PRINTF1(_L("Test : TestResetBuffers"));

	INFO_PRINTF1(_L("==================================="));

	_LIT(KCsyName,"LOOPBACK.CSY");

	_LIT(KPortName0,"LOOPBACK::0");

	_LIT8(KServerText,"Test Loopback : ");

	RCommServ commServ;

	TInt ret=commServ.Connect();

	ret=commServ.LoadCommModule(KCsyName);

	TESTCHECKL(ret,KErrNone);

	TRequestStatus stat0;										

	ret = iSerialPortList[1].Open(commServ,KPortName0,ECommShared);

	TESTCHECKL(ret,KErrNone);

	// This value is to ensure we exceed the standard write buffer size

	const TInt KNumOfLoopIterations = 1500;

    for (TInt i = 0; i < KNumOfLoopIterations; i++)

		{

	    TBuf8<20> writeBuf;

		writeBuf.Append(KServerText);

		writeBuf.AppendNum(i);

		if(i <=9)

			{

			writeBuf.AppendFill(' ', 3);

			}

		if ((i >= 10) && (i <= 99))

			{

			writeBuf.AppendFill(' ', 2);

			}

		if((i >= 100) && (i <= 999))

			{

			writeBuf.AppendFill(' ', 1);

			}

		iSerialPortList[1].Write(stat0,writeBuf);

		User::WaitForRequest(stat0);

		TESTCHECKL(stat0.Int(), KErrNone);

		}

	TInt numOfBuffers = 0;

	// This method has been used to query the amount of data in the 

	// write buffer

	numOfBuffers = iSerialPortList[1].QueryReceiveBuffer();

	// check the amount of data we have in our buffer. 

	// 20 bytes * number of times around the loop

	TESTCHECKCONDITION(numOfBuffers == (20 * KNumOfLoopIterations));

	// reset the amount of data in our buffer

	ret = iSerialPortList[1].ResetBuffers();

	TESTCHECKL(ret, KErrNone);

	numOfBuffers = iSerialPortList[1].QueryReceiveBuffer();

	TESTCHECKCONDITION(numOfBuffers == 0);

	iSerialPortList[1].Close();

	commServ.Close();

	return TestStepResult();	

	}

CTestCorrectDataRead::CTestCorrectDataRead()

	{

	SetTestStepName(_L("TestCorrectDataRead"));

	}	

TVerdict CTestCorrectDataRead::doTestStepL()

	{

	INFO_PRINTF1(_L("==================================="));

	INFO_PRINTF1(_L("Test : TestCorrectDataRead"));

	INFO_PRINTF1(_L("==================================="));

	_LIT(KCsyName,"LOOPBACK.CSY");

	_LIT(KPortName0,"LOOPBACK::0");

	_LIT(KPortName1,"LOOPBACK::1");

	_LIT8(KServerText,"Test Loopback : ");

	RCommServ commServ;

	TInt ret=commServ.Connect();

	ret=commServ.LoadCommModule(KCsyName);

	TESTCHECKL(ret,KErrNone);

	TRequestStatus stat, stat0;										

	ret = iSerialPortList[1].Open(commServ,KPortName0,ECommShared);

	TESTCHECKL(ret,KErrNone);

	ret = iSerialPortList[0].Open(commServ,KPortName1, ECommShared);

	TESTCHECKL(ret,KErrNone);

	// This value is to ensure we exceed the standard write buffer size

	const TInt KNumOfLoopIterations = 1500;

    for (TInt i = 0; i < KNumOfLoopIterations; i++)

		{

	    TBuf8<20> writeBuf;

		writeBuf.Append(KServerText);

		writeBuf.AppendNum(i);

		if(i <=9)

			{

			writeBuf.AppendFill(' ', 3);

			}

		if ((i >= 10) && (i <= 99))

			{

			writeBuf.AppendFill(' ', 2);

			}

		if((i >= 100) && (i <= 999))

			{

			writeBuf.AppendFill(' ', 1);

			}

		iSerialPortList[1].Write(stat0,writeBuf);

		User::WaitForRequest(stat0);

		TESTCHECKL(stat0.Int(), KErrNone);

		}

	for (TInt i = 0; i < KNumOfLoopIterations; i++)

		{

		TBuf8<20> readBuf;

		TBuf8<20> compareBuf;

		compareBuf.Append(KServerText);

		compareBuf.AppendNum(i);

		if(i <= 9)

			{

			compareBuf.AppendFill(' ', 3);

			}

		if ((i >= 10) && (i <= 99))

			{

			compareBuf.AppendFill(' ', 2);

			}

		if((i >= 100) && (i <= 999))

			{

			compareBuf.AppendFill(' ', 1);

			}

		iSerialPortList[0].Read(stat0, readBuf);

		User::WaitForRequest(stat0);

		TESTCHECKL(stat0.Int(), KErrNone);

		// compare what we have read against what we are expecting. Remember

		// this is a first in last out buffer so the first read will read a 

		// "Loopback : 0"

		TESTCHECKCONDITION(readBuf == compareBuf);

		}

	iSerialPortList[0].Close();

	iSerialPortList[1].Close();

	commServ.Close();

	return TestStepResult();

	}

CTestMaxBufferOverflow::CTestMaxBufferOverflow()

	{

	SetTestStepName(_L("TestMaxBufferOverflow"));

	}	

TVerdict CTestMaxBufferOverflow::doTestStepL()

	{

	INFO_PRINTF1(_L("==================================="));

	INFO_PRINTF1(_L("Test : TestMaxBufferOverflow"));