// Copyright (c) 2004-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:

// Tests for packet loopback CSY

// 

//

/**

 @file

*/

#include <e32property.h>

#include <c32comm.h>

#include <e32def.h>

#include <e32base.h>

#include <test/testexecutelog.h>

#include "LoopbackTestStep.h"

#include "LoopbackConfig.h"

_LIT(KCsyName,"PKTLOOPBACK");

_LIT(KPortName1,"PKTLOOPBACK::501");

const TUint KPortUnitNum1 = 501;

_LIT(KPortName2,"PKTLOOPBACK::502");

const TUint KPortUnitNum2 = 502;

_LIT(KPortName3,"PKTLOOPBACK::503");

_LIT(KPortName4,"PKTLOOPBACK::504");

_LIT8(KWriteBuf1,"1Packet data1");

_LIT8(KWriteBuf2,"2Packet data2");

_LIT8(KWriteBuf3,"3Packet data3");

_LIT8(KWriteBuf4,"4Packet data4");

const TUint KConfiguredPortDelayMicroseconds = 100000;

const TUint KConfiguredPortLongDelayMicroseconds = 1000000;

const TUint KTooSmallBufferSize = 4;

const TUint KRegularBufferSize = 64;

const TUint KHugeBufferSize = 10000;

const TUint KLoopackConfigTestNumber1 = 1;

const TUint KLoopackConfigTestNumber2 = 2;

const TUint KLoopackConfigTestNumber3 = 3;

const TUint KLoopackConfigTestNumber4 = 4;

const TUint KLoopackConfigTestNumber5 = 5;

const TUint KLoopackConfigTestNumber6 = 6;

const TUint KLoopackConfigTestNumber7 = 7;

const TUint KLoopackConfigTestNumber8 = 8;

const TUint KLoopackConfigTestNumber9 = 9;

const TUint KLoopackConfigTestNumber10 = 10;

const TUint KLoopackConfigTestNumber11 = 11;

const TUint KLoopackConfigTestNumber12 = 12;

const TUint KLoopackConfigTestNumber13 = 13;

CLoopbackTestStepBase::CLoopbackTestStepBase(TInt aTestNumber)

	{

	iTestNumber = aTestNumber;

	}

CLoopbackTestStepBase::~CLoopbackTestStepBase()

	{

	iCommPort1.Close();

	iCommPort2.Close();

	iCommPort3.Close();

	iCommPort4.Close();

	iCommServer.Close();

	}

void CLoopbackTestStepBase::SetTestNumber(TInt aTestNumber)

  	{

  	TInt dummy;

	TInt ret = RProperty::Get(KUidPSPacketLoopbackCsyCategory, KPSLoopbackCsyTestNumber, dummy);

	if(ret == KErrNotFound)

		{

		RProperty::Define(KUidPSPacketLoopbackCsyCategory, KPSLoopbackCsyTestNumber, 

							KPSLoopbackCsyTestNumberKeyType);

		}		

	ret = RProperty::Set(KUidPSPacketLoopbackCsyCategory, KPSLoopbackCsyTestNumber, aTestNumber);

  	}

void CLoopbackTestStepBase::SetFlowControl(TUint aUnit, TBool aFlowControlOn)

  	{

  	TInt dummy;

	TInt ret = RProperty::Get(KUidPSCsyFlowControlCategory, aUnit, dummy);

	if(ret == KErrNotFound)

		{

		RProperty::Define(KUidPSCsyFlowControlCategory, aUnit, KPSLoopbackCsyFlowControlOnKeyType);

		}

	ret = RProperty::Set(KUidPSCsyFlowControlCategory, aUnit, aFlowControlOn);

  	}

void CLoopbackTestStepBase::SetReadResult(TUint aUnit, TInt aReadResult)

  	{

  	TInt dummy;

	TInt ret = RProperty::Get(KUidPSCsyReadResultCategory, aUnit, dummy);

	if(ret == KErrNotFound)

		{

		RProperty::Define(KUidPSCsyReadResultCategory, aUnit, KUidPSCsyReadResultCategoryKeyType);

		}

	ret = RProperty::Set(KUidPSCsyReadResultCategory, aUnit, aReadResult);

  	}

void CLoopbackTestStepBase::SetWriteResult(TUint aUnit, TInt aWriteResult)

  	{

  	TInt dummy;

	TInt ret = RProperty::Get(KUidPSCsyWriteResultCategory, aUnit, dummy);

	if(ret == KErrNotFound)

		{

		RProperty::Define(KUidPSCsyWriteResultCategory, aUnit, KUidPSCsyWriteResultCategoryKeyType);

		}

	ret = RProperty::Set(KUidPSCsyWriteResultCategory, aUnit, aWriteResult);

  	}

TVerdict CLoopbackTestStepBase::doTestStepPreambleL()

	{

	__UHEAP_MARK;

	SetTestNumber(iTestNumber);

	TestErrorCodeL( iCommServer.Connect(), _L("Connect to comm server") );

	TestErrorCodeL( iCommServer.LoadCommModule(KCsyName), _L("Loading comm module") );

	return TestStepResult();

	}

TVerdict CLoopbackTestStepBase::doTestStepPostambleL()

	{

	User::LeaveIfError(KErrNone);	// To prevent LeaveScan warning

	iCommPort1.Close();

	iCommPort2.Close();

	iCommPort3.Close();

	iCommPort4.Close();

	iCommServer.Close();

	__UHEAP_MARKEND;

	return EPass;

	}

void CLoopbackTestStepBase::TestErrorCodeL(TInt aErrCode, const TDesC& aMessage)

	{	

	TestErrorCodeL(aErrCode, KErrNone, aMessage);

	}

void CLoopbackTestStepBase::TestErrorCodeL(TInt aErrCode, TInt aExpectedErrCode, const TDesC& aMessage)

	{	

	if(aExpectedErrCode == aErrCode)

		{

		INFO_PRINTF3(_L("[%S]. err[%d], as expected. OK."), &aMessage, aErrCode);

		}

	else

		{

		ERR_PRINTF5(_L("Failed: [%S]. err[%d], expected [%d]. Leaving with [%d])."), &aMessage, aErrCode, aExpectedErrCode, aErrCode);

		User::Leave(aErrCode);

		}

	}

void CLoopbackTestStepBase::TestBooleanTrueL(TInt aBool, const TDesC& aMessage)

	{	

	if(aBool)

		{

		INFO_PRINTF2(_L("[%S] is true, as expected. OK."), &aMessage);

		}

	else

		{

		ERR_PRINTF2(_L("Failed: [%S] is false. Leaving with KErrGeneral)."), &aMessage);

		User::Leave(KErrGeneral);

		}

	}

void CLoopbackTestStepBase::TestErrorCodeAndDescriptorL(TInt aErrCode, TInt aExpectedErrCode, const TDesC8& aDesC, const TDesC8& aExpectedDesC, const TDesC& aMessage)

	{

	if ( (aExpectedErrCode == aErrCode) && (aDesC.Compare(aExpectedDesC) == 0) )

		{

		INFO_PRINTF4(_L("[%S]. err[%d], and string [%S] as expected. OK."), &aMessage, aErrCode, &aExpectedDesC);

		}

	else if (aExpectedErrCode == aErrCode)

		{

		ERR_PRINTF5(_L("Failed: [%S]. err[%d], expected [%d]. Leaving with [%d])."), &aMessage, aErrCode, aExpectedErrCode, aErrCode);

		User::Leave(aErrCode);

		}

	else

		{

		ERR_PRINTF4(_L("Failed: [%S]. String [%S] received, expected [%S]. Leaving with KErrGeneral."), &aMessage, &aDesC, &aExpectedDesC);

		User::Leave(KErrGeneral);

		}

	}

void CLoopbackTestStepBase::TestErrorCodeAndDescriptorL(TInt aErrCode, const TDesC8& aDesC, const TDesC8& aExpectedDesC, const TDesC& aMessage)

	{

	TestErrorCodeAndDescriptorL(aErrCode, KErrNone, aDesC, aExpectedDesC, aMessage);

	}

CLoopbackTestStep1::~CLoopbackTestStep1()

	{

	}

CLoopbackTestStep1::CLoopbackTestStep1() : CLoopbackTestStepBase(KLoopackConfigTestNumber1)

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KLoopbackTestStep1);

	}

TVerdict CLoopbackTestStep1::doTestStepL()

/**

Test that two different sets of loopback ports can read/write to their corresponding loopback port

The test's ini file is configured to have commPort1 and commPort2 as loopback ports, and 

commPort3 and commPort4 as loopback ports

*/

	{

	// open the 4 ports

	TestErrorCodeL( iCommPort1.Open(iCommServer, KPortName1, ECommExclusive, ECommRoleDCE), _L("Opening comm port 1") );

	TestErrorCodeL( iCommPort2.Open(iCommServer, KPortName2, ECommExclusive, ECommRoleDCE), _L("Opening comm port 2") );

	TestErrorCodeL( iCommPort3.Open(iCommServer, KPortName3, ECommExclusive, ECommRoleDCE), _L("Opening comm port 3") );

	TestErrorCodeL( iCommPort4.Open(iCommServer, KPortName4, ECommExclusive, ECommRoleDCE), _L("Opening comm port 4") );

	// There are a total of 4 writes (one to and from each port)

	// 2 of the reads occur before the write and 2 after

	// Issue the two reads before the writes

	TRequestStatus readStatus1, readStatus2;

	TBuf8<KRegularBufferSize> readBuf1;

	TBuf8<KRegularBufferSize> readBuf2;

	iCommPort1.ReadOneOrMore(readStatus1, readBuf1);

	iCommPort2.ReadOneOrMore(readStatus2, readBuf2);

	// Issue the writes on each port

	TRequestStatus writeStatus1, writeStatus2, writeStatus3, writeStatus4;

	iCommPort1.Write(writeStatus1, KWriteBuf1);

	iCommPort2.Write(writeStatus2, KWriteBuf2);

	iCommPort3.Write(writeStatus3, KWriteBuf3);

	iCommPort4.Write(writeStatus4, KWriteBuf4);

	User::WaitForRequest(writeStatus1);

	TestErrorCodeL(writeStatus1.Int(), _L("Writing to comm port 1"));

	User::WaitForRequest(writeStatus2);

	TestErrorCodeL(writeStatus2.Int(), _L("Writing to comm port 2"));

	User::WaitForRequest(writeStatus3);

	TestErrorCodeL(writeStatus3.Int(), _L("Writing to comm port 3"));

	User::WaitForRequest(writeStatus4);

	TestErrorCodeL(writeStatus4.Int(), _L("Writing to comm port 4"));

	// Check that the first 2 reads completed successfully

	User::WaitForRequest(readStatus1);

	TestErrorCodeAndDescriptorL(readStatus1.Int(), readBuf1, KWriteBuf2, _L("Read from comm port 1"));

	User::WaitForRequest(readStatus2);

	TestErrorCodeAndDescriptorL(readStatus2.Int(), readBuf2, KWriteBuf1, _L("Read from comm port 2"));

	// Issue the 2 reads after the writes and make sure they complete successfully

	TRequestStatus readStatus3, readStatus4;

	TBuf8<KRegularBufferSize> readBuf3;

	TBuf8<KRegularBufferSize> readBuf4;

	iCommPort3.ReadOneOrMore(readStatus3, readBuf3);

	User::WaitForRequest(readStatus3);

	TestErrorCodeAndDescriptorL(readStatus3.Int(), readBuf3, KWriteBuf4, _L("Read from comm port 3"));

	iCommPort4.ReadOneOrMore(readStatus4, readBuf4);

	User::WaitForRequest(readStatus4);

	TestErrorCodeAndDescriptorL(readStatus4.Int(), readBuf4, KWriteBuf3, _L("Read from comm port 4"));

	return TestStepResult();

	}

CLoopbackTestStep2::~CLoopbackTestStep2()

	{

	}

CLoopbackTestStep2::CLoopbackTestStep2() : CLoopbackTestStepBase(KLoopackConfigTestNumber2)

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KLoopbackTestStep2);

	}

TVerdict CLoopbackTestStep2::doTestStepL()

/**

Test that writes are successfully queued and sent.

The 2 ports opened are configured as loopback ports in the ini file

*/

	{

	TestErrorCodeL( iCommPort1.Open(iCommServer, KPortName1, ECommExclusive, ECommRoleDCE), _L("Opening comm port 1") );

	TestErrorCodeL( iCommPort2.Open(iCommServer, KPortName2, ECommExclusive, ECommRoleDCE), _L("Opening comm port 2") );

	// Issue 2 writes immediately one after the other in each direction

	TRequestStatus writeStatus1, writeStatus2, writeStatus3, writeStatus4;

	iCommPort1.Write(writeStatus1, KWriteBuf1);

	iCommPort1.Write(writeStatus2, KWriteBuf2);

	iCommPort2.Write(writeStatus3, KWriteBuf3);

	iCommPort2.Write(writeStatus4, KWriteBuf4);

	TBool writesSuccessful = EFalse;

	User::WaitForRequest(writeStatus1);

	User::WaitForRequest(writeStatus2);

	User::WaitForRequest(writeStatus3);

	User::WaitForRequest(writeStatus4);

	if (writeStatus1 == KErrNone && writeStatus2 == KErrNone && 

		writeStatus3 == KErrNone && writeStatus4 == KErrNone)

		{

		writesSuccessful = ETrue;

		}

	TestBooleanTrueL(writesSuccessful, _L("Writing to comm ports successful"));

	// Issue the reads

	TRequestStatus readStatus1, readStatus2, readStatus3, readStatus4;

	TBuf8<KRegularBufferSize> readBuf1, readBuf2, readBuf3, readBuf4;

	iCommPort2.ReadOneOrMore(readStatus1, readBuf1);

	User::WaitForRequest(readStatus1);

	iCommPort2.ReadOneOrMore(readStatus2, readBuf2);

	User::WaitForRequest(readStatus2);

	iCommPort1.ReadOneOrMore(readStatus3, readBuf3);

	iCommPort1.ReadOneOrMore(readStatus4, readBuf4);

	User::WaitForRequest(readStatus4);

	User::WaitForRequest(readStatus3);

	// Make sure the requests are all successful

	TestBooleanTrueL(readStatus1 == KErrNone && readStatus2 == KErrNone && 

					 readStatus3 == KErrNone && readStatus4 == KErrNone,

					 _L("Check that reading from comm ports returned no errors"));

	TestBooleanTrueL(readBuf1.Compare(KWriteBuf1) == 0 && readBuf2.Compare(KWriteBuf2) == 0 &&

					 readBuf3.Compare(KWriteBuf3) == 0 || readBuf4.Compare(KWriteBuf4) == 0,

					 _L("Check that correct values were read from comm ports"));

	return TestStepResult();

	}

CLoopbackTestStep3::~CLoopbackTestStep3()

	{

	}

CLoopbackTestStep3::CLoopbackTestStep3() : CLoopbackTestStepBase(KLoopackConfigTestNumber3)

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KLoopbackTestStep3);

	}

TVerdict CLoopbackTestStep3::doTestStepL()

/**

Test the 3 different orders in which read/write operations can occur as follows:

	1. The read is issued, then the write is issued, then the data is sent across the port

	2. The write is issued, then the read is issued, then the data is sent across the port

	3. The write is issued, then the data is sent across the port, then the read is issued

*/

	{

	TestErrorCodeL( iCommPort1.Open(iCommServer, KPortName1, ECommExclusive, ECommRoleDCE), _L("Opening comm port 1") );

	TestErrorCodeL( iCommPort2.Open(iCommServer, KPortName2, ECommExclusive, ECommRoleDCE), _L("Opening comm port 2") );

	TRequestStatus readStatus1, readStatus2;

	TBuf8<KRegularBufferSize> readBuf1, readBuf2;

	TRequestStatus writeStatus1;

	// 1. The read is issued, then the write is issued, then the data is sent across the port

	// fist issue the read

	iCommPort1.ReadOneOrMore(readStatus1, readBuf1);

	// second issue the write

	iCommPort2.Write(writeStatus1, KWriteBuf1);

	User::WaitForRequest(writeStatus1);

	TestErrorCodeL(writeStatus1.Int(), _L("Writing to comm port 1"));

	User::WaitForRequest(readStatus1);

	TestErrorCodeAndDescriptorL(readStatus1.Int(), readBuf1, KWriteBuf1, _L("Read from comm port 1"));

	// 2. The write is issued, then the read is issued, then the data is sent across the port

	// first issue the write

	iCommPort1.Write(writeStatus1, KWriteBuf2);

	User::WaitForRequest(writeStatus1);

	TestErrorCodeL(writeStatus1.Int(), _L("Writing to comm port 1"));

	// second issue the read before the data has the chance to be sent across the port

	iCommPort2.ReadOneOrMore(readStatus2, readBuf2);

	User::WaitForRequest(readStatus2);

	TestErrorCodeAndDescriptorL(readStatus2.Int(), readBuf2, KWriteBuf2, _L("Read from comm port 2"));

	// 3. The write is issued, then the data is sent across the port, then the read is issued

	// first issue the write

	iCommPort1.Write(writeStatus1, KWriteBuf2);

	User::WaitForRequest(writeStatus1);

	TestErrorCodeL(writeStatus1.Int(), _L("Writing to comm port 1"));

	// second wait until the data has the chance to be sent across the port (this delay is configured

	// to be 0.1s in the ini file, so we wait a bit longer)

	User::After(2*KConfiguredPortDelayMicroseconds);

	// third the read is issued

	iCommPort2.ReadOneOrMore(readStatus2, readBuf2);

	User::WaitForRequest(readStatus2);

	TestErrorCodeAndDescriptorL(readStatus2.Int(), readBuf2, KWriteBuf2, _L("Read from comm port 2"));

	return TestStepResult();

	}

CLoopbackTestStep4::~CLoopbackTestStep4()

	{

	}

CLoopbackTestStep4::CLoopbackTestStep4() : CLoopbackTestStepBase(KLoopackConfigTestNumber4)

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KLoopbackTestStep4);

	}

TVerdict CLoopbackTestStep4::doTestStepL()

/**

Test reading/writing to an un-opened port, or a port whose loopback port is un-opened

*/

	{

	TestErrorCodeL( iCommPort1.Open(iCommServer, KPortName1, ECommExclusive, ECommRoleDCE), _L("Opening comm port 1") );

	TRequestStatus readStatus;

	TBuf8<KRegularBufferSize> readBuf;

	TRequestStatus writeStatus;

	// issue read request before port is opened

	iCommPort1.ReadOneOrMore(readStatus, readBuf);

	// iCommPort2's loopback port is not yet opened, so write should fail

	iCommPort1.Write(writeStatus, KWriteBuf1);

	User::WaitForRequest(writeStatus);

	TestErrorCodeL(writeStatus.Int(), KErrNotReady, _L("Writing to comm port 1 before port 2 is opened"));

	TestErrorCodeL( iCommPort2.Open(iCommServer, KPortName2, ECommExclusive, ECommRoleDCE), _L("Opening comm port 2") );

	iCommPort2.Write(writeStatus, KWriteBuf2);

	User::WaitForRequest(writeStatus);

	// now wait for read request which should complete from before iCommPort2 was opened

	User::WaitForRequest(readStatus);

	TestErrorCodeL(writeStatus.Int(), _L("Writing to comm port 1 after port 2 is opened"));

	TestErrorCodeAndDescriptorL(readStatus.Int(), readBuf, KWriteBuf2, _L("Read from comm port 2"));

	iCommPort2.Close();

	// iCommPort1 is now closed, so both write should fail

	iCommPort1.Write(writeStatus, KWriteBuf1);

	User::WaitForRequest(writeStatus);

	TestErrorCodeL(writeStatus.Int(), KErrNotReady, _L("Writing to comm port 1 after port 2 is closed"));

	return TestStepResult();

	}

CLoopbackTestStep5::~CLoopbackTestStep5()

	{

	}

CLoopbackTestStep5::CLoopbackTestStep5() : CLoopbackTestStepBase(KLoopackConfigTestNumber5)

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KLoopbackTestStep5);

	}

TVerdict CLoopbackTestStep5::doTestStepL()

/**

Test filling up the read and write queues

In this test, the read and write queues are set to be 1 entry in size

*/

	{

	INFO_PRINTF1(_L("Starting Loopback test step 5"));

	TestErrorCodeL( iCommPort1.Open(iCommServer, KPortName1, ECommExclusive, ECommRoleDCE), _L("Opening comm port 1") );

	TestErrorCodeL( iCommPort2.Open(iCommServer, KPortName2, ECommExclusive, ECommRoleDCE), _L("Opening comm port 2") );

	TRequestStatus readStatus1;

	TBuf8<KRegularBufferSize> readBuf1;

	TRequestStatus writeStatus1, writeStatus2;

	// Issue 2 writes immediately after each other. Since the queue is only set to 1 entry

	// it will be full after the first write, so the second should return with KErrOverflow

	iCommPort2.Write(writeStatus1, KWriteBuf1);

	User::WaitForRequest(writeStatus1);

	TestErrorCodeL(writeStatus1.Int(), _L("Writing to comm port 2"));

	iCommPort2.Write(writeStatus2, KWriteBuf2);

	User::WaitForRequest(writeStatus2);

	TestErrorCodeL(writeStatus2.Int(), KErrOverflow, _L("Writing to comm port 2"));

	// wait until the data has the chance to be sent across the port (this delay is configured

	// to be 1s in the ini file, so we wait a bit longer)

	User::After(2*KConfiguredPortLongDelayMicroseconds);

	// After this delay, the buffer should have been 'sent' to the read queue of the loopback port

	// Again, issue 2 writes immediately after each other, the first one filling up the queue

	// meaning the second will return with KErrOverflow

	iCommPort2.Write(writeStatus2, KWriteBuf2);

	User::WaitForRequest(writeStatus2);

	TestErrorCodeL(writeStatus2.Int(), _L("Writing to comm port 2"));

	iCommPort2.Write(writeStatus2, KWriteBuf2);

	User::WaitForRequest(writeStatus2);

	TestErrorCodeL(writeStatus2.Int(), KErrOverflow, _L("Writing to comm port 2"));

	// Wait for the amount of time it should take for the data to cross the port.

	// After the delay the buffer should not be sent because the read buffer on the loopback port is full

	User::After(2*KConfiguredPortLongDelayMicroseconds);

	iCommPort2.Write(writeStatus2, KWriteBuf2);

	User::WaitForRequest(writeStatus2);

	TestErrorCodeL(writeStatus2.Int(), KErrOverflow, _L("Writing to comm port 2"));

	// Issue reads for the 2 writes that have been sent successfully

	// Since the second read has not yet been sent across the port, it should take more than the 

	// time configured to send a buffer 

	// Get the time before the reads

	TTime beforeTime;

	beforeTime.UniversalTime();

	iCommPort1.ReadOneOrMore(readStatus1, readBuf1);

	User::WaitForRequest(readStatus1);

	TestErrorCodeAndDescriptorL(readStatus1.Int(), readBuf1, KWriteBuf1, _L("Read from comm port 1"));

	iCommPort1.ReadOneOrMore(readStatus1, readBuf1);

	User::WaitForRequest(readStatus1);

	// Get the time after the read

	TTime afterTime;

	afterTime.UniversalTime();