diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgrtest/t_acm_wins/src/t_acm_wins.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usbmgmt/usbmgrtest/t_acm_wins/src/t_acm_wins.cpp	Tue Feb 02 02:02:59 2010 +0200
@@ -0,0 +1,920 @@
+/*
+* 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
+* on the host, and is to be used in conjunction with the device-side application (t_acm).
+*
+*/
+
+// Includes ////////////////////////////////////////////////////////////////////
+
+/* Symbian OS includes */
+#include <e32base.h>
+#include <e32cons.h>
+#include <e32math.h>
+
+#define WIN32_LEAN_AND_MEAN
+
+/* Windows i/o for serial device */
+#include <windows.h>
+#include <wchar.h>
+
+// Defines and enumerations /////////////////////////////////////////////////////
+
+#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))
+
+#define MAX_BUFFER_SIZE 1024
+
+// Flow control constants
+enum	FlowControl_Modes {KFLOW_NONE, KFLOW_RTSCTS, KFLOW_DTRDSR};
+
+// Global Variables /////////////////////////////////////////////////////////////
+
+HANDLE	hSerial;	// An MS Windows handle for the serial port
+DCB		OldDcb;		// for storing the original serial device context
+DCB		newDcb;
+
+// For holding our new serial port parameteres
+struct SerialParameters
+	{
+	char			*comport;					// which port
+	unsigned long	pktsize, pktcount, maxwait;	// packet config
+	unsigned long	baud, bits, stop;			// serial parameters
+	unsigned char	parity;
+	enum	FlowControl_Modes	flowcontrol;	// flow control handshaking
+} SerialParams;
+
+LOCAL_D CConsoleBase* console;	// A Symbian command console
+
+_LIT(KPortName, "COM3");		// Windows serial port name
+
+RTimer timer;	// A timer for use by several of the tests
+
+// Some buffers allocated on the heap for functions with large
+// stack usage so we don't get a __chkstk error.
+char writeBufbig[MAX_BUFFER_SIZE];
+char readBufbig[MAX_BUFFER_SIZE];
+
+// Functions //////////////////////////////////////////////////////////////////
+
+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("ERROR (%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 SetWindowsSerialParams()
+/**
+ * Set up the new serial parameters with which to run the tests.
+ */
+{
+	// parameter 1 is port name
+	// read in COM port name (this parameter must be specified!)
+	SerialParams.comport = new char[10];
+	strcpy(SerialParams.comport, "COM3");
+
+	// default packet size
+	SerialParams.pktsize = 1024;
+
+	// default no of packets
+	SerialParams.pktcount = 1;
+
+	// default wait for data return
+	SerialParams.maxwait = 30;
+
+	// default flow control
+	SerialParams.flowcontrol = KFLOW_RTSCTS;
+
+	// default data rate
+	// baud rate 0 (port's default) standard rates 300 -> 115200
+	SerialParams.baud = 0;
+
+	// default bits per char
+	SerialParams.bits = 8;
+
+	// default parity
+	SerialParams.parity = 'N';
+
+	// default 9 is stop bits
+	SerialParams.stop = 1;
+}
+
+static int	InitializePort()
+/**
+ * Store the old state of the serial port and set it up for our tests.
+ */
+{
+	DCB				dcb;
+	COMMTIMEOUTS	CommsTimeouts;
+
+	// Setup comms device receive & transmit buffers
+	if(SetupComm(hSerial, 16384, 16384) == 0)
+	{
+		LEAVE(-1);
+	}
+
+	// Purge all characters from the output and input buffers
+	// and terminate any pending read or write operations 
+	if(PurgeComm(hSerial, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR) == 0)
+	{
+		LEAVE(-1);
+	}
+
+	dcb.DCBlength = sizeof(DCB);
+	if(GetCommState(hSerial, &dcb) == 0)
+	{
+		// not a serial device
+		LEAVE(-1);
+	}
+
+    memcpy(&OldDcb, &dcb, sizeof(DCB));
+
+	// General initialization for both transmitted and received bytes
+	// using port's default baud rate etc..., so read it
+	SerialParams.baud = dcb.BaudRate;		// Get baud rate 
+	SerialParams.bits = dcb.ByteSize;		// Get number of bits 
+	if(dcb.StopBits == 2)					// Get number of stop bits to be used
+		SerialParams.stop = 2;
+	else
+		SerialParams.stop = 1;
+
+	// Get parity scheme
+	if((dcb.fParity == FALSE) || (dcb.Parity == 0))
+	{
+		SerialParams.parity = 'N';
+	}
+	else
+	{
+		switch(dcb.Parity)
+		{
+		case 1:	SerialParams.parity = 'O'; break;
+		case 2:	SerialParams.parity = 'E'; break;
+		case 3:	SerialParams.parity = 'M'; break;
+		case 4:	SerialParams.parity = 'S'; break;
+		default:	SerialParams.parity = 'N'; break;  // shouldn't happen
+		}
+	}
+	dcb.fBinary = TRUE;				// Set binary mode 
+
+	// Setup hardware flow control
+	if(SerialParams.flowcontrol == KFLOW_RTSCTS)
+	{
+		dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;	// Specify the type of RTS flow control
+		dcb.fOutxCtsFlow = 1;						// Specify whether the CTS signal is monitored
+
+		dcb.fDtrControl = DTR_CONTROL_ENABLE;	// Specify the type of DTR flow control
+		dcb.fOutxDsrFlow = 0;					// Specify whether the DSR signal is monitored
+	}
+	else if(SerialParams.flowcontrol == KFLOW_DTRDSR)
+	{
+		dcb.fRtsControl = RTS_CONTROL_ENABLE;	// Specify the type of RTS flow control
+		dcb.fOutxCtsFlow = 0;						// Specify whether the CTS signal is monitored
+
+		dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;// Specify the type of DTR flow control
+		dcb.fOutxDsrFlow = 1;					// Specify whether the DSR signal is monitored
+	}
+	else // KFLOW_NONE
+	{
+		dcb.fRtsControl = RTS_CONTROL_ENABLE;	// Specify the type of RTS flow control
+		dcb.fOutxCtsFlow = 0;					// Specify whether the CTS signal is monitored
+
+		dcb.fDtrControl = DTR_CONTROL_ENABLE;	// Specify the type of DTR flow control
+		dcb.fOutxDsrFlow = 0;					// Specify whether the DSR signal is monitored
+	}
+
+	dcb.fInX = dcb.fOutX = 0;
+	dcb.fDsrSensitivity = 0;
+	dcb.fErrorChar = 0;
+	dcb.fNull = 0;
+	dcb.fAbortOnError = 1;
+
+	// Configure the communications device according 
+	// to the specifications in the device-control block
+	// The function reinitializes all hardware and control settings, 
+	// but does not empty output or input queues
+	if(SetCommState(hSerial, &dcb) == 0)
+	{
+		LEAVE(-1);
+	}
+
+	// Set timeout parameters for comms device
+	/* A value of MAXDWORD, combined with zero values for both the 
+	 * ReadTotalTimeoutConstant and ReadTotalTimeoutMultiplier members, 
+	 * specifies that the read operation is to return immediately with 
+	 * the characters that have already been received, even if no characters 
+	 * have been received.
+	 */
+
+	CommsTimeouts.ReadIntervalTimeout = 0xFFFFFFFF;
+	CommsTimeouts.ReadTotalTimeoutMultiplier = 0;
+	CommsTimeouts.ReadTotalTimeoutConstant = 1000;
+
+	// CBR_9600 is approximately 1byte/ms. For our purposes be generous 
+	// & allow double the expected time per character
+	if(SerialParams.maxwait > 1)
+	{
+		CommsTimeouts.WriteTotalTimeoutMultiplier = 0;
+		CommsTimeouts.WriteTotalTimeoutConstant = (SerialParams.maxwait - 1) * 1000;
+	}
+	else
+	{
+		CommsTimeouts.WriteTotalTimeoutMultiplier = 2*CBR_9600/dcb.BaudRate;
+		CommsTimeouts.WriteTotalTimeoutConstant = 1000;
+	}
+
+	if(0 == SetCommTimeouts(hSerial, &CommsTimeouts))
+	{
+		LEAVE(-1);
+	}
+
+	if(0 == SetCommMask(hSerial, EV_RXCHAR | EV_ERR /* | EV_TXEMPTY */))
+	{
+		LEAVE(-1);
+	}
+
+	return 0;
+}
+
+void OpenComPort()
+/**
+ * Create a Windows com port for our serial device.
+ */
+{
+	hSerial = INVALID_HANDLE_VALUE;
+	wchar_t  *fullname = new wchar_t[50];
+    
+	// Open comms device
+	wcscpy(fullname, L"\\\\.\\com3");
+	hSerial = CreateFile(fullname,
+						 GENERIC_READ | GENERIC_WRITE,
+						 0,                    // exclusive access
+						 NULL,                 // no security attrs
+						 OPEN_EXISTING,
+						 FILE_ATTRIBUTE_NORMAL,
+						 NULL ) ;
+
+	// return if handle for comms device is invalid
+	if (hSerial == INVALID_HANDLE_VALUE)
+	{
+		delete[] fullname;
+		LEAVE(GetLastError());
+	}
+	else 
+	{
+		if(InitializePort())
+		{
+			// Close comms device and event handles for overlapped read and write
+			CloseHandle(hSerial);
+			hSerial = INVALID_HANDLE_VALUE;
+		}
+	}
+	delete[] fullname;
+}
+
+void FillBuffer(char *buffer, int size)
+/**
+ * Fills the buffer with incrementing data
+ */
+	{
+	for (TInt i=0; i<size; i++)
+		{
+		// Need the & 0xff to remove the truncation warning
+		buffer[i] = (char)((i%256) & 0xff);
+		}
+	}
+
+bool CheckBuffer(char *buffer, int size)
+/**
+ * Checks the buffer is filled with incrementing data
+ */
+	{
+	for (TInt i=0; i<size; i++)
+		{
+		if (buffer[i] != i%256)
+		return FALSE;
+		}
+
+	return TRUE;
+	}
+
+void ReadData(char *RxBuffer, int size)
+/**
+ * Read the given amount of data into a buffer from the serial port.
+ */
+{
+	unsigned long Count;
+	long total = 0;
+
+	while (total < size) {
+	  if(ReadFile(hSerial, RxBuffer, size, &Count, NULL) == 0)
+	  {
+		_printf(_L("ReadFile() returned error code: %d.\n"), GetLastError());
+	  }
+	  else
+	  {
+		total += Count;
+	  }
+	}
+
+}
+
+void WriteData(char *TxBuffer, int size)
+/**
+ * Write the given data over the serial port.
+ */
+{
+	unsigned long TxCount;
+
+	if(WriteFile(hSerial, TxBuffer, size, &TxCount, NULL) == 0)
+	{
+		_printf(_L("WriteFile() returned error code: %d.\n"), GetLastError());
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+void DataStress_SizeVary_TestL()
+/**
+ * Perform a single test.
+ */
+	{
+	_printf(_L("\n----------------------------------\n"));
+	_printf(_L("This test performs varying size read\n"));
+	_printf(_L("and writes to and from the device.\n"));
+	_printf(_L("------------------------------------\n\n"));
+
+	// Purge all characters from the output and input buffers
+	// and terminate any pending read or write operations 
+	if(PurgeComm(hSerial, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR) == 0)
+		{
+		CloseHandle(hSerial);
+		LEAVE(-1);
+		}
+
+	_printf(_L("Writing data\n"));
+	for (int i = 1; i<MAX_BUFFER_SIZE; i*=2)
+		{
+		FillBuffer(writeBufbig, i);
+		WriteData(writeBufbig, i);
+		}
+
+	_printf(_L("Writing more data\n"));
+	for (int i = 1; i<MAX_BUFFER_SIZE; i*=2)
+		{	
+		FillBuffer(writeBufbig, i);
+		WriteData(writeBufbig, i);
+		}
+
+	_printf(_L("Reading data\n"));
+	for (int i = 1; i<MAX_BUFFER_SIZE; i*=2)
+		{
+		memset(readBufbig, 0, MAX_BUFFER_SIZE);
+		ReadData(readBufbig, i);
+		_printf(_L("%d "), i);
+		}
+
+	_printf(_L("\nTest complete.\n"));
+	}
+
+
+void DataStress_RateVary_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	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("Press any key to quit.\n"));
+	_printf(_L("------------------------------------\n\n"));
+
+	_printf(_L("Setting handshaking & receive buffer length\n"));
+
+	_printf(_L("Writing data\n"));
+	for (i = 1; i<100; i++)
+		{
+		FillBuffer(writeBufbig, MAX_BUFFER_SIZE);
+		WriteData(writeBufbig, MAX_BUFFER_SIZE);
+		}
+
+	_printf(_L("Writing more data\n"));
+	for (i = 1; i<20; i++)
+		{
+		FillBuffer(writeBufbig, MAX_BUFFER_SIZE);
+		WriteData(writeBufbig, MAX_BUFFER_SIZE);
+		}
+
+	_printf(_L("Reading data\n"));
+	for (i = 1; i<100; i++)
+		{
+		memset(readBufbig, 0, MAX_BUFFER_SIZE);
+		ReadData(readBufbig, MAX_BUFFER_SIZE);
+		CheckBuffer(readBufbig, MAX_BUFFER_SIZE);
+
+		}
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void TimeOut_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n---------------------------\n"));
+	_printf(_L("This test exercises the read\n"));
+	_printf(_L("and write timeouts on the device.\n"));
+	_printf(_L("Press any key to quit.\n"));
+	_printf(_L("-----------------------------\n\n"));
+
+
+	_printf(_L("In this test the host sits around while the device times out.\n"));
+	_printf(_L("Press a key when finished.\n"));
+	_getch();
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void CancelTx_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n----------------------------------------\n"));
+	_printf(_L("This tests the read/write cancel feature\n"));
+	_printf(_L("Press any key to quit.\n"));
+	_printf(_L("------------------------------------------\n\n"));
+
+	_printf(_L("In this test the host sits around while the device cancels.\n"));
+	_printf(_L("Press a key when finished.\n"));
+	_getch();
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void InterruptTx_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_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"));
+
+	// Close the handle. If we don't do this before the device operator starts 
+	// pulling the cable out and plugging it in again then we'll never be able 
+	// to open it again afterwards. (This is also seen in HyperTerminal- 
+	// solution: reboot HyperTerminal.)
+	CloseHandle(hSerial);
+
+	// The device will attempt to read, then the cable will be pulled.
+	_printf(_L("Press any key when the device reports\n"));
+	_printf(_L("that the test is complete.\n"));
+	_getch();
+
+	// restart the serial device
+	OpenComPort();
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void Shutdown_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n-----------------------------------\n"));
+	_printf(_L("This tests the USB Manager shutdown\n"));
+	_printf(_L("during reads and writes.\n"));
+	_printf(_L("Press any key to quit.\n"));
+	_printf(_L("-------------------------------------\n\n"));
+
+	_printf(_L("In this test the host sits around while\n"));
+	_printf(_L(" the device shuts down the USB manager.\n"));
+	_printf(_L("Press a key when finished.\n"));
+	_getch();
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void BufferOverrun_TestL()
+/**
+ * Test updated from that in the ACM unit test specification to
+ * read/write messages bigger than the receive and transmit buffers.
+ * Changed as previous test was no longer valid.
+ */
+{
+	#define MAX_BIG_BUFFER_SIZE	(1024*8)
+	char bigBuf[MAX_BIG_BUFFER_SIZE];
+
+	_printf(_L("\n--------------------------------\n"));
+	_printf(_L("This tests read/writes which are\n"));
+	_printf(_L("bigger than the buffer length.\n"));
+	_printf(_L("----------------------------------\n\n"));
+
+	_printf(_L("Writing data.\nBuffer length: %d"), MAX_BIG_BUFFER_SIZE);
+	FillBuffer(bigBuf, MAX_BIG_BUFFER_SIZE);
+	WriteData(bigBuf, MAX_BIG_BUFFER_SIZE);
+
+	_printf(_L("done.\nReading data\nBuffer length: %d"), MAX_BIG_BUFFER_SIZE);
+	ReadData(bigBuf, MAX_BIG_BUFFER_SIZE);
+
+	_printf(_L(" done.\nTest complete\n"));
+}
+
+void Break_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n--------------------------------\n"));
+	_printf(_L("This tests break and break cancel.\n"));
+	_printf(_L("----------------------------------\n\n"));
+
+	_printf(_L("In this test the host sits around while\n"));
+	_printf(_L("the device issues some breaks.\n"));
+	_printf(_L("Press a key when finished.\n"));
+	_getch();
+
+	// TODO: should also do host-requested breaks. And NotifyBreaks.
+	_printf(_L("\nTest complete\n"));
+}
+
+void SignalChange_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n---------------------------------------\n"));
+	_printf(_L("This tests signal change notifications.\n"));
+	_printf(_L("---------------------------------------\n\n"));
+
+
+	_printf(_L("Press any key to send a signal change.\n"));
+	_getch();
+
+	newDcb.DCBlength = sizeof(DCB);
+    memcpy(&OldDcb, &newDcb, sizeof(DCB));
+
+	newDcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
+	
+	(void) SetCommState(hSerial, &newDcb);
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void FlowControl_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n-------------------------------------------\n"));
+	_printf(_L("This tests flow control change notifications.\n"));
+	_printf(_L("---------------------------------------------\n\n"));
+
+	_printf(_L("Host side does nothing in this test. Press any key.\n"));
+	_getch();
+
+	_printf(_L("\nTest complete\n"));
+}
+
+void ConfigChange_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	DCB		dcb;
+
+	_printf(_L("\n------------------------------- -----\n"));
+	_printf(_L("This tests config change notifications.\n"));
+	_printf(_L("---------------------------------------\n\n"));
+
+	
+	_printf(_L("Press any key to send a new configuration.\n"));
+	_getch();
+
+	dcb.DCBlength = sizeof(DCB);
+    memcpy(&OldDcb, &dcb, sizeof(DCB));
+	dcb.BaudRate=38400;
+
+	(void) SetCommState(hSerial, &dcb);
+	
+	_printf(_L("\nTest complete\n"));
+}
+
+
+void SecondClient_TestL()
+/**
+ * Perform a single test.
+ */
+{
+	_printf(_L("\n---------------------------------------\n"));
+	_printf(_L("This tests that we can have a second\n"));
+	_printf(_L("client with non-exclusive access.\n"));
+	_printf(_L("Press any key to quit.\n"));
+	_printf(_L("---------------------------------------\n\n"));
+
+	_printf(_L("Writing data\n"));
+	FillBuffer(writeBufbig, MAX_BUFFER_SIZE);
+	WriteData(writeBufbig, MAX_BUFFER_SIZE);
+	WriteData(writeBufbig, MAX_BUFFER_SIZE);
+
+	_printf(_L("Reading data\n"));
+	memset(readBufbig, 0, 256);
+	ReadData(readBufbig, 256);
+	CheckBuffer(readBufbig, 256);
+
+	_printf(_L("\nTest complete\n"));
+}
+
+
+// ******************************************************************
+// The following are placholders for the ACMRq tests.
+// These tests need no support on the platform end, as yet.
+// The functions are left here incase someday some support is needed.
+// ******************************************************************
+
+void ACMRq_EncapCommand_TestL()
+{
+	 // Not needed to support this here
+}
+
+void ACMRq_Break_TestL()
+{
+	 // TODO: can we check for break status here ?
+}
+
+void ACMRq_SetFeature_TestL()
+{
+	 // TODO: Test doesn't make sense.
+}
+
+void ACMRq_ClearFeature_TestL()
+{
+	 // TODO: Test doesn't make sense.
+}
+
+void ACMRq_SetCoding_TestL()
+{
+	 // TODO: Can we check the line codeing here ?
+}
+
+void ACMRq_CtrlState_TestL()
+{
+	 // TODO: Test doesn't make sense.
+}
+
+void ACMRq_EncapResp_TestL()
+{
+	 // Not needed to support this here.
+}
+
+void ACMRq_CommsFeature_TestL()
+{
+	 // Not needed to support this here.
+}
+
+void ACMRq_GetCoding_TestL()
+{
+	 // Not needed to support this here.
+}
+
+
+void ACMNtf_SendState_TestL()
+{
+	 // TODO: SendSerialState() ???
+}
+
+void ACMNtf_Status_TestL()
+{
+	 // TODO: SendNetworkConnection() ???
+}
+
+void ACMNtf_RespAvail_TestL()
+{
+	 // Test not supported.
+}
+
+void Loopback_TestL()
+/**
+ * Perform a single test.
+ */
+	{
+	_printf(_L("\n---------------------------------------------\n"));
+	_printf(_L("This test writes data out of the USB ACM port\n"));
+	_printf(_L("and check that it is correctly echoed back.\n"));
+	_printf(_L("---------------------------------------------\n\n"));
+
+	// Purge all characters from the output and input buffers
+	// and terminate any pending read or write operations 
+	if(PurgeComm(hSerial, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR) == 0)
+		{
+		LEAVE(GetLastError());
+		}
+
+	for (char i=0; i<100; i++)
+		{
+		memset(readBufbig, 0, MAX_BUFFER_SIZE);	// clear the read buffer
+		memset(writeBufbig, i, MAX_BUFFER_SIZE);	// fill the write buffer with known data
+		_printf(_L("%d: "), (TInt)i);
+		WriteData(writeBufbig, 64);
+		//FlushFileBuffers(hSerial);
+		ReadData(readBufbig, 64);
+		for (int j=0; j<64; j++)
+			{
+			if (readBufbig[j] != i)
+				{
+				_printf(_L("Buffer contents error.\n"));
+				for (int k=0; k<64; k++)
+					{
+					_printf(_L("%d "), readBufbig[k]);
+					}
+				_printf(_L("\n"));
+				return;
+				}
+			}
+		}
+	}
+
+void mainL()
+/**
+ * This function controls test execution as directed by the user.
+ */
+	{
+	TRequestStatus status;
+
+	memset(&SerialParams, 0, sizeof(struct SerialParameters));
+	SetWindowsSerialParams();
+
+	OpenComPort();
+
+	_printf(_L("Opened com port. [press any key]")); _getch();
+
+	TBool noExit = ETrue;
+	while (noExit)
+		{
+			_printf(_L("\nAvailable tests:\n\n"));
+			_printf(_L("1. Data stress, size varies (test 2.1.1)\n"));
+			_printf(_L("2. Data stress, rate varies (test 2.1.2)\n"));
+			_printf(_L("3. Timeout (test 2.2)\n"));
+			_printf(_L("4. Cancel Transfer (test 2.3)\n"));
+			_printf(_L("5. Interrupt Transfer (test 2.4)\n"));
+			_printf(_L("6. Shutdown (test 2.5)\n"));
+			_printf(_L("7. Buffer overrun (test 2.6)\n"));
+			_printf(_L("8. Break (test 2.7)\n"));
+			_printf(_L("9. Event notification, signal change (test 2.8.1)\n"));
+			_printf(_L("a. Event notification, flow control (test 2.8.2)\n"));
+			_printf(_L("b. Event notification, config change (test 2.8.3)\n"));
+			_printf(_L("c. Second client (test 2.9)\n"));
+/*			_printf(_L("d. ACM request, encapsulated command (test 2.10.1)\n"));
+			_printf(_L("e. ACM request, break (test 2.10.2)\n"));
+			_printf(_L("f. ACM request, setting feature (test 2.10.3)\n"));
+			_printf(_L("g. ACM request, clearing feature (test 2.10.4)\n"));
+			_printf(_L("h. ACM request, setting line coding (test 2.10.5)\n"));
+			_printf(_L("i. ACM request, control line state (test 2.10.6)\n"));
+			_printf(_L("j. ACM request, encapsualted response (test 2.10.7)\n"));
+			_printf(_L("k. ACM request, comms feature (test 2.10.8)\n"));
+			_printf(_L("l. ACM request, getting line coding (test 2.10.9)\n"));
+			_printf(_L("m. ACM Notifications, send serial state (test 2.11.1)\n"));
+			_printf(_L("n. ACM Notifications, network status (test 2.11.2)\n"));
+			_printf(_L("o. ACM Notifications, response available (test 2.11.3)\n"));
+*/			_printf(_L("p. Loopback test (test 2.12)\n"));
+			_printf(_L("\n"));
+			_printf(_L("\nSelection (x to exit): "));
+
+			char ch = (char) _getch();
+			_printf(_L("\n"));
+			switch (ch)
+				{
+			case '1': DataStress_SizeVary_TestL();	break;
+			case '2': DataStress_RateVary_TestL();	break;
+			case '3': TimeOut_TestL();	break;
+			case '4': CancelTx_TestL();	break;
+			case '5': InterruptTx_TestL();	break;
+			case '6': Shutdown_TestL();	break;
+			case '7': BufferOverrun_TestL();	break;
+			case '8': Break_TestL();	break;
+			case '9': SignalChange_TestL();	break;
+			case 'A':
+			case 'a': FlowControl_TestL();	break;
+			case 'B':
+			case 'b': ConfigChange_TestL();	break;
+			case 'C':
+			case 'c': SecondClient_TestL();	break;
+			case 'D':
+			case 'd': ACMRq_EncapCommand_TestL();	break;
+			case 'E':
+			case 'e': ACMRq_Break_TestL();	break;
+			case 'F':
+			case 'f': ACMRq_SetFeature_TestL();	break;
+			case 'G':
+			case 'g': ACMRq_ClearFeature_TestL();	break;
+			case 'H':
+			case 'h': ACMRq_SetCoding_TestL();	break;
+			case 'I':
+			case 'i': ACMRq_CtrlState_TestL();	break;
+			case 'J':
+			case 'j': ACMRq_EncapResp_TestL();	break;
+			case 'K':
+			case 'k': ACMRq_CommsFeature_TestL();	break;
+			case 'L':
+			case 'l': ACMRq_GetCoding_TestL();	break;
+			case 'M':
+			case 'm': ACMNtf_SendState_TestL();	break;
+			case 'N':
+			case 'n': ACMNtf_Status_TestL();	break;
+			case 'O':
+			case 'o': ACMNtf_RespAvail_TestL();	break;
+			case 'P':
+			case 'p': Loopback_TestL(); break;
+			case 'x':
+			case 'X':
+				noExit = EFalse;
+				break;
+			default:
+				_printf(_L("\nInvalid key\n"));
+				break;
+				}
+
+			if (noExit)
+				{
+				_printf(_L("Test Complete. Press a key.\n"));
+				_getch();
+				}
+		}
+
+		(void) SetCommState(hSerial, &OldDcb);
+		CloseHandle(hSerial);
+		delete[] SerialParams.comport;
+	}
+
+void consoleMainL()
+/**
+ * Create a console and run mainL().
+ */
+	{
+	console=Console::NewL(_L("T_ACM"),TSize(KConsFullScreen,KConsFullScreen));
+	CleanupStack::PushL(console);
+	mainL();
+	CleanupStack::PopAndDestroy();
+	}
+
+GLDEF_C TInt E32Main()
+/**
+ * Standard Symbian entry point. Sets stuff up and deals with the cleanup stack.
+ */
+	{
+	__UHEAP_MARK;
+	CTrapCleanup* cleanupStack=CTrapCleanup::New();
+
+	// create the timer for use during some of the tests
+	timer.CreateLocal();
+
+	TRAP_IGNORE(consoleMainL());
+	delete cleanupStack;
+	timer.Close();
+	__UHEAP_MARKEND;
+	return 0;
+	}
+
+