/*

* Copyright (c) 2002-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:

* This program executes all the tests in the ACM CSY Test Specification v 0.1

* and is to be used in conjunction with the host-side application. (t_acm_wins)

*

*/

#include <e32base.h>

#include <e32cons.h>

#include <e32math.h>

#include <c32comm.h>

#include <usbman.h>

#include <e32debug.h>

LOCAL_D CConsoleBase* console;

RCommServ TheCommServ;

RUsb TheUsb;

TCommConfig TheConfigBuf;

TCommConfigV01& TheConfig = TheConfigBuf();

const TInt KReceiveBufferLength = 4096;

const TInt KMaxAcmPortNameLength = 8;

//_LIT(KUsbCsyName, "ECACM");

_LIT(KUsbPortName, "ACM::0");

_LIT(KUsbPortNameAcm1, "ACM::1");

_LIT(KUsbLddName, "EUSBC");

#define _printf console->Printf

#define _getch console->Getch

#define LEAVE(_x) VerboseLeaveL(_x, __LINE__, TPtrC8((const TUint8*)__FILE__), _L8(#_x))

#define LEAVEIFERROR(_x) VerboseLeaveIfErrorL(_x, __LINE__, TPtrC8((const TUint8*)__FILE__), _L8(#_x))

#define CHECK(_x) if (! (_x)) VerboseLeaveL(KErrGeneral, __LINE__, TPtrC8((const TUint8*)__FILE__), _L8(#_x))

// A define for stack-based buffers

#define MAX_BUFFER_SIZE 1024

// A bigger buffer on the heap

#define MAX_HEAP_BUFFER_SIZE	(1024*8)

TBuf8<MAX_HEAP_BUFFER_SIZE> readBigBuf;

// A timer for use by several of the tests

RTimer timer;

//The random seed

TInt64 seed = 100;

void VerboseLeaveL(TInt aError, TInt aLineNum, const TDesC8& aFileName, const TDesC8& aCode)

/**

 * For bombing out usefully.

 */

	{

	TInt filenameOffset = aFileName.LocateReverse('\\') + 1;

	if (filenameOffset < 0) filenameOffset = 1;

	TPtrC8 shortFileName = aFileName.Mid(filenameOffset);

	TBuf<64> fName, code;

	fName.Copy(shortFileName.Left(64));

	code.Copy(aCode.Left(64));

	_printf(_L("\nERROR (%d) on line %d of file %S\n"), aError, aLineNum, &fName);

	_printf(_L("Code: %S\n\n"), &code);

	_printf(_L("[ press any key ]"));

	_getch();

	User::Leave(aError);

	}

void VerboseLeaveIfErrorL(TInt aError, TInt aLineNum, const TDesC8& aFileName, const TDesC8& aCode)

/**

 * For bombing out usefully if there's an error.

 */

	{

	if (aError)

		VerboseLeaveL(aError, aLineNum, aFileName, aCode);

	}

void ReadString(TDes& aDes)

/**

 * Reads user input into the start of the descriptor aDes.

 */

	{

	TChar inputKey;

	TInt count = 0;

	aDes.Zero();

	for (;;)

		{

		inputKey = (TInt) _getch();

		if ((TInt)inputKey == EKeyEnter)

			break;

		if(inputKey == EKeyBackspace)

			{

			if (count > 0)

				{

				_printf(_L("%C"), (TUint) inputKey);

				aDes.Delete(--count,1);

				}

			}

		else if(inputKey.IsPrint())

			{

			_printf(_L("%C"), (TUint) inputKey);

			aDes.Append(inputKey);

			count++;

			}

		}

	}

void FillBuffer(TDes8 &aDes)

/**

 * Fills a given buffer with incrementing numbers.

 */

{

	 aDes.Zero();

	 for (TInt i=0; i<aDes.MaxSize(); i++)

	 {

		  aDes.Append(i);

	 }

}

bool CheckBuffer(TDes8 &aDes, TInt size)

/**

 * Checks that a given buffer contains incrementing numbers.

 */

{

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

	 {

		  if (aDes[i] != i)

			   return FALSE;

	 }

	 return TRUE;

}

//////////////////////////////////////////////////////////////////////////////////////////////

/**

 *  loopback From a Port input by the user to abother port-

 *  ACM::1 KUsbPortNameAcm1 to ACM::0 KUsbPortName by default

 */

void ReadLoopbackFromPortAToPortBTestL()

	{

	TRequestStatus consoleStatus;

	TRequestStatus status;

	RComm portIN;

	RComm portOut;

	_printf(_L("Enter the packet size:"));

	TBufC<8> buf;

	TPtr ptr (buf.Des());

	ReadString(ptr);

	TLex input(buf);

	TInt pktlen = 0;

	while ((input.Peek()).IsDigit()) {

		pktlen = 10*pktlen + (input.Get()) - '0';

	}

	// Get port names

	_printf(_L("\nEnter acm port name as loopback INPUT: (ex ACM::1):"));

	TBufC<KMaxAcmPortNameLength> portINName;

	TPtr portINNamePtr (portINName.Des());

	ReadString(portINNamePtr);

	if ( portINNamePtr.Length() == 0 )

		{

		portINName= KUsbPortNameAcm1;

		}

	_printf(_L("\nEnter acm port name as loopback OUTPUT: (ex ACM::0):"));

	TBufC<KMaxAcmPortNameLength> portOutName;

	TPtr portOutNamePtr (portOutName.Des());

	ReadString(portOutNamePtr);

	if ( portOutNamePtr.Length() == 0 )

		{

		portOutName = KUsbPortName;

		}

	_printf(_L("\n----------------------------------------\n"));

	_printf(_L("This test listens for data on the ACM port: "));

	_printf(portINName);

	_printf(_L("\nwrites anything it receives on the ACM port: "));

	_printf(portOutName);

	_printf(_L("\nPress any key to quit.\n"));

	_printf(_L("----------------------------------------\n\n"));

	LEAVEIFERROR(portIN.Open(TheCommServ, portINName, ECommExclusive, ECommRoleDCE));

	CleanupClosePushL(portIN);

	LEAVEIFERROR(portOut.Open(TheCommServ, portOutName, ECommExclusive, ECommRoleDCE));

	CleanupClosePushL(portOut);

	_printf(_L("Setting handshaking & receive buffer length\n"));

	portIN.SetConfig(TheConfigBuf);

	portIN.SetReceiveBufferLength(KReceiveBufferLength);

	portOut.SetConfig(TheConfigBuf);

	portOut.SetReceiveBufferLength(KReceiveBufferLength);

	_printf(_L("loopback received data\n"));

	console->Read(consoleStatus);

	FOREVER

		{

		portIN.Read(status, readBigBuf, pktlen);

		User::WaitForRequest(status, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (status != KErrNone)

				{

				console->ReadCancel();

				LEAVE(status.Int());

				}

			}

		else

			{

			portIN.ReadCancel();

			break;

			}

		portOut.Write(status, readBigBuf);

		User::WaitForRequest(status, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (status != KErrNone)

				{

				// need to cancel the read to avoid a CBase-77 panic!

				console->ReadCancel();

				LEAVE(status.Int());

				}

			}

		else

			{

			portOut.WriteCancel();

			break;

			}

		}

	portOut.WriteCancel();

	_printf(_L("\nTest complete\n"));

	CleanupStack::PopAndDestroy(2); // portA	, portOut

	}

//////////////////////////////////////////////////////////////////////////////////////////////

/**

 *  Original loopback test - uses Read().

 */

void ReadLoopbackTestL()

	{

	TRequestStatus consoleStatus;

	TRequestStatus status;

	RComm port;

	_printf(_L("Enter the packet size:"));

	TBufC<8> buf;

	TPtr ptr (buf.Des());

	ReadString(ptr);

	TLex input(buf);

	TInt pktlen = 0;

	while ((input.Peek()).IsDigit()) {

		pktlen = 10*pktlen + (input.Get()) - '0';

	}

	_printf(_L("\n----------------------------------------\n"));

	_printf(_L("This test listens for data on the ACM\n"));

	_printf(_L("port and echoes anything it receives\n"));

	_printf(_L("back to the PC. Press any key to quit.\n"));

	_printf(_L("----------------------------------------\n\n"));

	LEAVEIFERROR(port.Open(TheCommServ, KUsbPortName, ECommExclusive, ECommRoleDCE));

	CleanupClosePushL(port);

	_printf(_L("Setting handshaking & receive buffer length\n"));

	port.SetConfig(TheConfigBuf);

	port.SetReceiveBufferLength(KReceiveBufferLength);

	_printf(_L("Echoing received data\n"));

	console->Read(consoleStatus);

	FOREVER

		{

		port.Read(status, readBigBuf, pktlen);

		User::WaitForRequest(status, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (status != KErrNone)

				{

				console->ReadCancel();

				LEAVE(status.Int());

				}

			}

		else

			{

			port.ReadCancel();

			break;

			}

		port.Write(status, readBigBuf);

		User::WaitForRequest(status, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (status != KErrNone)

				{

				// need to cancel the read to avoid a CBase-77 panic!

				console->ReadCancel();

				LEAVE(status.Int());

				}

			}

		else

			{

			port.WriteCancel();

			break;

			}

		}

	_printf(_L("\nTest complete\n"));

	CleanupStack::PopAndDestroy(); // port

	}

/**

 * Original loopback test - uses ReadOneOrMore().

 */

void LoopbackTestL()

	{

	TRequestStatus consoleStatus;

	TRequestStatus status;

	RComm port;

	_printf(_L("\n----------------------------------------\n"));

	_printf(_L("This test listens for data on the ACM\n"));

	_printf(_L("port and echoes anything it receives\n"));

	_printf(_L("back to the PC. Press any key to quit.\n"));

	_printf(_L("----------------------------------------\n\n"));

	LEAVEIFERROR(port.Open(TheCommServ, KUsbPortName, ECommExclusive, ECommRoleDCE));

	CleanupClosePushL(port);

	_printf(_L("Setting handshaking & receive buffer length\n"));

	port.SetConfig(TheConfigBuf);

	port.SetReceiveBufferLength(KReceiveBufferLength);

	_printf(_L("Echoing received data\n"));

	TBuf8<256> readBuf;

	console->Read(consoleStatus);

	FOREVER

		{

		port.ReadOneOrMore(status, readBuf);

		User::WaitForRequest(status, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (status != KErrNone)

				{

				// need to cancel the read to avoid a CBase-77 panic!

				console->ReadCancel();

				LEAVE(status.Int());

				}

			}

		else

			{

			port.ReadCancel();

			break;

			}

		port.Write(status, readBuf);

		User::WaitForRequest(status, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (status != KErrNone)

				{

				// need to cancel the read to avoid a CBase-77 panic!

				console->ReadCancel();

				LEAVE(status.Int());

				}

			}

		else

			{

			port.WriteCancel();

			break;

			}

		}

	_printf(_L("\nTest complete\n"));

	CleanupStack::PopAndDestroy(); // port

	}

/**

 * NotifydataAvailable test.

 */

void NotifyDataAvailableTestL()

	{

	TRequestStatus status;

	TRequestStatus stat2;

	RComm port;

	_printf(_L("\n----------------------------------------\n"));

	_printf(_L("This test listens for data on the ACM\n"));

	_printf(_L("port and echoes anything it receives\n"));

	_printf(_L("back to the PC. Press any key to quit.\n"));

	_printf(_L("----------------------------------------\n\n"));

	LEAVEIFERROR(port.Open(TheCommServ, KUsbPortName, ECommExclusive, ECommRoleDCE));

	CleanupClosePushL(port);

	_printf(_L("Setting handshaking & receive buffer length\n"));

	port.SetConfig(TheConfigBuf);

	port.SetReceiveBufferLength(KReceiveBufferLength);

	_printf(_L("Echoing received data\n"));

	TBuf8<256> readBuf;

	_printf(_L("*********************************\n"));

	_printf(_L("test NotifyDataAvailable\n"));

	TRequestStatus stat;

	TRequestStatus status2;

	_printf(_L("test NotifyDataAvailable, nominal test\n"));

	port.NotifyDataAvailable(status);

	User::WaitForRequest(status);	// wait until the data is available

	LEAVEIFERROR(status.Int());

	TBuf8<30> receive;

	port.ReadOneOrMore(status,receive);

	User::WaitForRequest(status);

	LEAVEIFERROR(status.Int());

	_printf(_L("test NotifyDataAvailable, nominal test succeeded\n"));

	//=========== Test the KErrInUse that should be returned when a notification of data available is posted at the same

	// time as a Read - or visa versa  ============== //

	_printf(_L("test NotifyDataAvailable, KErrInUse mode\n"));

	TBuf8<10> buf;

	port.ReadOneOrMore(status,buf);

	port.NotifyDataAvailable(status2);

	User::WaitForRequest(status2);

	if (status2.Int() != KErrInUse)

		{

		LEAVE(status2.Int());

		}

	LEAVEIFERROR(port.ReadCancel());

	User::WaitForRequest(status);

	if (status.Int() != KErrCancel)

		{

		LEAVE(status.Int());

		}

	// 2nd case

	port.NotifyDataAvailable(status);

	port.ReadOneOrMore(status2,buf);

	User::WaitForRequest(status2);

	if (status2.Int() != KErrInUse)

		{

		LEAVE(status2.Int());

		}

	// cancel

	LEAVEIFERROR(port.NotifyDataAvailableCancel());

	User::WaitForRequest(status);

	if (status.Int() != KErrCancel)

		{

		LEAVE(status.Int());

		}

	_printf(_L("test NotifyDataAvailable, KErrInUse test succeeded\n"));

	// ====== test NotifyDataAvailable, testing canceling

	_printf(_L("test NotifyDataAvailable, testing canceling\n"));

	port.NotifyDataAvailable(stat);

	User::WaitForRequest(stat);

	LEAVEIFERROR(stat.Int());

	port.ResetBuffers();

	// testing canceling

	stat2=KErrNone;