/*

* 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:

* t_acm.cpp

* 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.

*

*/

#include <e32base.h>

#include <e32cons.h>

#include <e32math.h>

#include <badesca.h>

#include <c32comm.h>

#include <usbman.h>

LOCAL_D CConsoleBase* console;

RCommServ TheCommServ;

RUsb TheUsb;

TCommConfig TheConfigBuf;

TCommConfigV01& TheConfig = TheConfigBuf();

const TInt KReceiveBufferLength = 8192;

//_LIT(KUsbCsyName, "ECACM");

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

_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;

}

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

void DataStress_SizeVary_TestL()

/**

 * Runs the test as specified in the ACM unit test specification.

 */

{

	TRequestStatus status;

	RComm port;

	TInt i;

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

	_printf(_L("This test performs varying size read\n"));

	_printf(_L("and writes to and from the host.\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);

	TBuf8<MAX_BUFFER_SIZE> readBuf;

	_printf(_L("Reading data.\nLengths:"));

	for (i = 1; i<MAX_BUFFER_SIZE; i*=2)

		{

		_printf(_L(" %d"), i);

		port.Read(status, readBuf, i);

		User::WaitForRequest(status);

		if (status != KErrNone)

			{

			LEAVE(status.Int());

			}

		CheckBuffer(readBuf, i);

		}

	_printf(_L(" done.\nReadOneOrMore()-ing data.\n"));

	for (i = 1; i<MAX_BUFFER_SIZE; i*=2)

		{

		int transferSize = 0;

		while (transferSize != i)

			{

			port.ReadOneOrMore(status, readBuf);

			User::WaitForRequest(status);

			if (status != KErrNone)

				{

					_printf(_L("Read error"));

					LEAVE(status.Int());

				}

			else

				{

					transferSize += readBuf.Length();

				}

			}

			_printf(_L(" %d "), transferSize);

		}

	_printf(_L(" done.\nWriting data "));

	FillBuffer(readBuf);

	for (i = 1; i<MAX_BUFFER_SIZE; i*=2)

		{

		port.Write(status, readBuf, i);

		User::WaitForRequest(status);

		if (status != KErrNone)

			{

			_printf(_L("write error\n"));

			LEAVE(status.Int());

			}

		_printf(_L(" %d"), i);

		}

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

	 CleanupStack::PopAndDestroy(); //port

}

void DataStress_RateVary_TestL()

/**

 * Runs the test as specified in the ACM unit test specification.

 */

{

	TRequestStatus status;

	RComm port;

	TInt i;

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

	_printf(_L("This test performs varying speed read\n"));

	_printf(_L("and writes to and from the host.\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);

	TBuf8<MAX_BUFFER_SIZE> readBuf;

	_printf(_L("Reading data.\nLengths:"));

	for (i = 1; i<100; i++)

		{

		_printf(_L(" %d"), i);

		port.Read(status, readBuf);

		User::WaitForRequest(status);

		if (status != KErrNone)

			{

			_printf(_L("Error reading"));

			LEAVE(status.Int());

			}

		CheckBuffer(readBuf, readBuf.MaxSize());

		}

	_printf(_L("done.\nReadOneOrMore()-ing data.\n Lengths: "));

	for (i = 1; i< 20; i++)

		{

		int transferSize = 0;

		while (transferSize != MAX_BUFFER_SIZE) {

			port.ReadOneOrMore(status, readBuf);

			User::WaitForRequest(status);

			if (status != KErrNone)

				{

				LEAVE(status.Int());

				}

			else

				{

				transferSize += readBuf.Length();

				}

		}

		_printf(_L(" %d "), i);

	}

	_printf(_L(" done.\nWriting data\nLengths:"));

	FillBuffer(readBuf);

	for (i = 1; i< 100; i++)

		{

		_printf(_L(" %d "), i);

		port.Write(status, readBuf, 1024);

		User::WaitForRequest(status);

		if (status != KErrNone)

			{

			_printf(_L("Write failed"));

			LEAVE(status.Int());

			}

		// Wait for random time

		timer.After(status, (Math::Rand(seed) % 1001));//1001 to get a value within [0-1000]

		User::WaitForRequest(status);

		}

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

	CleanupStack::PopAndDestroy(); // port

}

void TimeOut_TestL()

/**

 * Runs the test as specified in the ACM unit test specification.

 */

{

	TRequestStatus status;

	RComm port;

	TInt timeout;

	TBuf8<MAX_BUFFER_SIZE> readBuf;

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

	_printf(_L("This test exercises the read\n"));

	_printf(_L("and write timeouts.\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("Reading data\nTimeouts (ms):"));

	for (timeout = 10; timeout<100; timeout+=10)

		{

		 // Clean buffers

		 port.ResetBuffers();

		_printf(_L(" %d"), timeout);

		port.Read(status, timeout, readBuf, MAX_BUFFER_SIZE);

		User::WaitForRequest(status);

		if (status != KErrTimedOut)

		    {

				LEAVE(status.Int());

			}

		}

	_printf(_L(" done.\nWriting data\nTimeouts (ms):"));

	for (timeout = 10; timeout<100; timeout+=10)

		{

		 // Clean buffers

		 port.ResetBuffers();

		_printf(_L(" %d"), timeout);

		port.Write(status, timeout, readBuf, MAX_BUFFER_SIZE);

		User::WaitForRequest(status);

		if (status != KErrTimedOut)

		    {

				LEAVE(status.Int());

			}

		}

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

	CleanupStack::PopAndDestroy(); // port

}

void CancelTx_TestL()

/**

 * Runs the test as specified in the ACM unit test specification.

 */

{

	TRequestStatus status;

	RComm port;

	TInt timeout;

	TBuf8<MAX_BUFFER_SIZE> readBuf;

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

	_printf(_L("This tests the read/write cancel feature\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("Reading data\n"));

	for (timeout = 10; timeout<100; timeout++)

		{

		port.Read(status, readBuf);

		// Wait before cancelling

		timer.After(status, timeout);

		User::WaitForRequest(status);

		port.ReadCancel();

		User::WaitForRequest(status);

		if ( (status != KErrNone) && (status !=KErrCancel) )

			{

			LEAVE(status.Int());

			}

		}

	_printf(_L("Writing data\n"));

	for (timeout = 10; timeout<100; timeout++)

		{

//		FillBuffer(readBuf);

		port.Write(status, readBuf);

		// Wait before cancelling

		timer.After(status, timeout);

		User::WaitForRequest(status);

		port.WriteCancel();

		User::WaitForRequest(status);

		if ( (status != KErrNone) && (status !=KErrCancel) )

			{

			LEAVE(status.Int());

			}

		}

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

	CleanupStack::PopAndDestroy(); // port

}

void InterruptTx_TestL()

/**

 * Runs the test as specified in the ACM unit test specification.

 */

{

	TRequestStatus status;

	RComm port;

	TBuf8<MAX_BUFFER_SIZE> readBuf;

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

	_printf(_L("This tests the read/write cancel\n"));

	_printf(_L("when the USB cable is pulled\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("Reading data\n"));

	port.Read(status, readBuf);

	_printf(_L("Pull cable now\n"));

	User::WaitForRequest(status);

	_printf(_L("Received error code: %d\n"),status.Int());

	_printf(_L("Expect -29(KErrCommsLineFail) or range -6702 to -6712 (USB driver errors)\n\n"));

	_printf(_L("Plug in cable and press any key\n"));

	_getch();

	_printf(_L("Writing data\n"));

	_printf(_L("Pull cable now\n"));

	do

	{

		 port.Write(status, readBuf);

		 User::WaitForRequest(status);

	} while (status == KErrNone);

	_printf(_L("Received error code: %d\n"),status.Int());

	_printf(_L("Expect -29(KErrCommsLineFail) or range -6702 to -6712 (USB driver errors)\n\n"));

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

	CleanupStack::PopAndDestroy(); // port

}

void Shutdown_TestL()

/**

 * Runs the test as specified in the ACM unit test specification.

 */

{

	TRequestStatus status;

	RComm port;

	TBuf8<MAX_BUFFER_SIZE> readBuf;

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

	_printf(_L("This tests the USB Manager shutdown\n"));

	_printf(_L("during reads and writes.\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("Reading data\n"));

	port.Read(status, readBuf);

	_printf(_L("Shutting down USB Manager.\n"));

	TheUsb.Stop();

	_printf(_L("Shutdown complete.\nWaiting for read to terminate."));

	User::WaitForRequest(status);

	if (status != KErrNone)	// Error code ? TODO