// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\device\t_dce.cpp

// 

//

// Cogent uses two port loopback, Linda doesn't

#define _TWO_PORT_LOOPBACK_ 

#include <e32base.h>

#include <e32base_private.h>

#include <e32test.h>

#include <e32cons.h>

#include <e32svr.h>

#include <e32hal.h>

#include <d32comm.h>

#include <e32uid.h>

const TInt KUnit0=0;

const TInt KUnit1=1;

const TInt KUnit2=2;

#ifdef _TWO_PORT_LOOPBACK_

#define NOTIFY_TIMEOUT 2000000 // 2 seconds

#else

#define NOTIFY_TIMEOUT 10000000 // 10 seconds

#endif

const TInt KTestPatternSize=250;

#if defined (__WINS__)

// Running this test in WINS is fairly pointless since WINS uses the DTE driver.

// The WINS version was just to get the basic test program working - i.e. to 

// speed up the debug process.

#define PDD_NAME _L("ECDRV.PDD")

#define LDD_NAME _L("ECOMM.LDD")

const TInt KTestUnitDte=KUnit0;

const TInt KTestUnitDce=KUnit1;

const TInt KChangeSigIn=KSignalCTS; // DTE driver used on WINS so read DSR rather than RTS

const TInt KOtherSigIn=KSignalDCD; // DTE driver used on WINS so read DCD rather than DTR

const TInt KChangeSigOut=KSignalRTS;

#else

#define DTEPDD_NAME _L("EUART3")

//#define DCEPDD_NAME _L("EUART1DCE") // Linda

#define DCEPDD_NAME _L("EUART1") // Cogent

#define DTELDD_NAME _L("ECOMM")

#define DCELDD_NAME _L("ECOMMDCE")

const TInt KTestUnitDte=KUnit2;

const TInt KTestUnitDce=KUnit0;

const TInt KChangeSigIn=KSignalRTS; // DCE input - Cogent

const TInt KOtherSigIn=KSignalDTR; // DCE input - Cogent

const TInt KChangeSigOut=KSignalRTS; // DTE output - Cogent

//const TInt KChangeSigIn=KSignalDTR; // DCE input - Linda

//const TInt KOtherSigIn=KSignalRTS; // DCE input - Linda

//const TInt KChangeSigOut=KSignalDTR; // DTE output - Linda

#endif

//	Our own comms object with synchronous writes

class RComm : public RBusDevComm

	{

public:

	TInt WriteS(const TDesC8& aDes);

	TInt WriteS(const TDesC8& aDes,TInt aLength);

	};

LOCAL_D RTest test(_L("T_DCE"));

RComm* TheDteSerialPort;

#if defined (__WINS__)

RBusDevComm* TheDceSerialPort;

#else

RBusDevCommDCE* TheDceSerialPort;

#endif

TCommConfig TheConfigDceBuf;

TCommConfigV01& TheConfigDce=TheConfigDceBuf();

TCommConfig TheConfigDteBuf;

TCommConfigV01& TheConfigDte=TheConfigDteBuf();

TCommCaps2 TheCapsDceBuf;

TCommCapsV02& TheCapsDce=TheCapsDceBuf();

TInt RComm::WriteS(const TDesC8& aDes)

//	Syncronous write

	{

	return(WriteS(aDes,aDes.Length()));

	}

TInt RComm::WriteS(const TDesC8& aDes,TInt aLength)

//	Syncronous write

	{

	TRequestStatus s;

	Write(s,aDes,aLength);

	User::WaitForRequest(s);

	return(s.Int());

	}

LOCAL_C void StripeMem(TDes8& aBuf,TUint aStartChar,TUint anEndChar)

//

// Mark a buffer with repeating byte pattern

//

	{

	if (aStartChar==anEndChar)

		{

		aBuf.Fill(aStartChar);

		return;

		}

	TUint character=aStartChar;

	for (TInt i=0;i<aBuf.Length();i++)

		{

		aBuf[i]=(TText8)character;

		if(++character>anEndChar)

			character=aStartChar;

		}

	}

#define COLUMN_HEADER _L("            RxBuf            |          Expected       \r\n")

LOCAL_C void DumpDescriptors(TDes8 &aLeft,TDes8 &aRight)

//

//

//

	{

	TBuf<80> b;

	test.Printf(_L("Compare failed:\r\n"));

	TInt minLen=Min(aLeft.Length(),aRight.Length());

	test.Printf(COLUMN_HEADER);

	TInt i=0;

	TInt j=0;

	while (i<=minLen)

		{

		b.Format(_L("%02x: "),i);

		for (j=0;j<8;j++)

			{

			if ((i+j)<minLen)

				{

				TInt v=aLeft[i+j];

				b.AppendFormat(_L("%02x "),v);

				}

			else

				b.Append(_L("   "));

			}

		b.Append(_L(" | "));

		for (j=0;j<8;j++)

			{

			if ((i+j)<minLen)

				{

				TInt v=aRight[i+j];

				b.AppendFormat(_L("%02x "),v);

				}

			else

				b.Append(_L("   "));

			}

		b.Append(_L("\r\n"));

		test.Printf(b);

		i+=8;

		if ((i%64)==0)

			test.Getch();

		}

	}

LOCAL_C TInt CheckedWrite(TInt aBufSize)

// 

// Write/Read loopback test - requires either a loopback connector or a

// connected device looping back the data (running T_DCEUTL).

//

	{

	TUint8* inBuf=new TUint8[aBufSize];

	test(inBuf!=NULL); 

	TUint8* outBuf=new TUint8[aBufSize];

	test(outBuf!=NULL); 

	TPtr8 outDes(outBuf,aBufSize,aBufSize);

	TPtr8 inDes(inBuf,aBufSize,aBufSize);

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus readStatus;

	TRequestStatus timeStatus;

	StripeMem(outDes,'A','Z');

	inDes.FillZ();

	TheDceSerialPort->Read(readStatus,inDes,aBufSize+1);

	test(readStatus==KErrGeneral);

	TheDceSerialPort->Read(readStatus,inDes);

	test(readStatus==KRequestPending);

    TInt ret;

#if defined (_TWO_PORT_LOOPBACK_)

	ret=TheDteSerialPort->WriteS(outDes,aBufSize);

#else

	TRequestStatus ws;

	TheDceSerialPort->Write(ws,outDes,aBufSize);

	User::WaitForRequest(ws);

	ret=ws.Int();

#endif

	test(ret==KErrNone);

	const TUint KTimeOut=6000000;

	tim.After(timeStatus,KTimeOut);

	test(timeStatus==KRequestPending);

	User::WaitForRequest(readStatus,timeStatus);

	if (timeStatus==KErrNone)

		{

		TheDceSerialPort->ReadCancel();

		User::WaitForRequest(readStatus);

		test.Printf(_L("Timed Out!\n\r"));

		test.Getch();

		test(FALSE);

		}

	else

		{

		tim.Cancel();

		User::WaitForRequest(timeStatus);

		if (readStatus!=KErrNone)

			{

			test.Printf(_L("Read Failed! (%d)\n\r"),readStatus.Int());

			test.Getch();

			test(FALSE);

			}

		test(readStatus==KErrNone);

		test.Printf(_L("Read %d of %d\n\r"),inDes.Length(),outDes.Length());

		ret=outDes.Compare(inDes);

		if (ret!=0)

			DumpDescriptors(inDes,outDes);

  		test(ret==0);

		}

	tim.Close();

	delete inBuf;

	delete outBuf;

	return inDes.Length();

	}

LOCAL_C TInt TestingNotifySignalChange(TUint aChangeSignal)

//

// Test NotifySignalChange()

//

	{

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus notifStatus;

	TRequestStatus timeStatus;

	if (!(TheCapsDce.iNotificationCaps & KNotifySignalsChangeSupported))

        test.Printf(_L("Signal change notification not supported on this platform"));

    else

        {

		test.Next(_L("Testing NotifySignalChange() with no mask set"));

#if defined (_TWO_PORT_LOOPBACK_)

	    TheDteSerialPort->SetSignals(0,KChangeSigOut); // Clear

#else

		test.Printf(_L("Make sure DTR negated(??D) - hit a key to start\n\r"));

		test.Getch();

		test.Printf(_L("10 seconds to assert DTR(D)\n\r"));

#endif

	    TUint signals=0;

	    TheDceSerialPort->NotifySignalChange(notifStatus,signals);

	    test(notifStatus==KRequestPending);

	    const TUint KTimeOut=NOTIFY_TIMEOUT;

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

#if defined (_TWO_PORT_LOOPBACK_)

	    TheDteSerialPort->SetSignals(KChangeSigOut,0); // Set

#endif

 	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

#ifndef __WINS__

			TUint sigmask=((aChangeSignal*KSignalChanged)|aChangeSignal);

		    test((signals&sigmask)==sigmask);

#endif

		    }

	    else

		    {

		    TheDceSerialPort->NotifySignalChangeCancel();

			User::WaitForRequest(notifStatus);

		    test.Printf(_L("Timed Out!\n\r"));

			test.Getch();

		    test(FALSE);

		    }

	    TUint rdSignals=TheDceSerialPort->Signals();

		test(rdSignals&aChangeSignal);

		test.Next(_L("Testing NotifySignalChange() when not expected"));

        // Test notification doesn't happen with mask set to some other signal

	    signals=0;

	    TheDceSerialPort->NotifySignalChange(notifStatus,signals,KOtherSigIn);

	    test(notifStatus==KRequestPending);

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

#if defined (_TWO_PORT_LOOPBACK_)

	    TheDteSerialPort->SetSignals(0,KChangeSigOut); // Clear

#else

		test.Printf(_L("10 seconds to negate DTR(D)\n\r"));

#endif

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

		    test(FALSE);

		    }

	    else

			{

		    test(timeStatus==KErrNone); // Success

		    TheDceSerialPort->NotifySignalChangeCancel(); // Tests cancel 

			User::WaitForRequest(notifStatus);

			}

#ifndef __WINS__

	    rdSignals=TheDceSerialPort->Signals();

		test(!(rdSignals&aChangeSignal));

#endif

		test.Next(_L("Testing NotifySignalChange() with mask set"));

        // Test notification happens with mask set to this signal

	    signals=0;

	    TheDceSerialPort->NotifySignalChange(notifStatus,signals,aChangeSignal);

	    test(notifStatus==KRequestPending);

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

#if defined (_TWO_PORT_LOOPBACK_)

	    TheDteSerialPort->SetSignals(KChangeSigOut,0); // Set

#else

		test.Printf(_L("10 seconds to assert DTR(D)\n\r"));

#endif

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

		    test(signals==((aChangeSignal*KSignalChanged)|aChangeSignal));

		    }

	    else

		    {

		    TheDceSerialPort->NotifySignalChangeCancel();

			User::WaitForRequest(notifStatus);

		    test.Printf(_L("Timed Out!\n\r"));

			test.Getch();

		    test(FALSE);

		    }

	    rdSignals=TheDceSerialPort->Signals();

		test(rdSignals&aChangeSignal);

        }

	return(KErrNone);

	}

LOCAL_C TInt TestingNotifyReceiveDataAvailable()

//

// Test NotifyReceiveDataAvailable()

//

	{

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus notifStatus;

	TRequestStatus timeStatus;

	if (!(TheCapsDce.iNotificationCaps & KNotifyDataAvailableSupported))

        test.Printf(_L("Data available notification not supported on this platform"));

    else

        {

		test.Next(_L("Testing NotifyReceiveDataAvailable()"));

#if !defined (_TWO_PORT_LOOPBACK_)

		test.Printf(_L("Hit a key to start\n\r"));

		test.Getch();

#endif

		TPtrC8 buf1(_S8("AT&f\r"));

	    TBuf8<0x10> buf2(0x10);

        TheDceSerialPort->ResetBuffers();

	    TheDceSerialPort->NotifyReceiveDataAvailable(notifStatus);

	    test(notifStatus==KRequestPending);

	    const TUint KTimeOut=NOTIFY_TIMEOUT;

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

#if defined (_TWO_PORT_LOOPBACK_)

        test(TheDteSerialPort->WriteS(buf1)==KErrNone);

#else

		test.Printf(_L("10 seconds to send hayes command(H)\n\r"));

#endif

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

		    }

	    else

		    {

	        TheDceSerialPort->NotifyReceiveDataAvailableCancel();

		    test.Printf(_L("Timed Out!\n\r"));

			test.Getch();

		    test(FALSE);

		    }

		User::After(500000);

		TInt len=TheDceSerialPort->QueryReceiveBuffer();

//        test(len==buf1.Length());

	    buf2.FillZ();

	    TheDceSerialPort->Read(notifStatus,buf2,len);

		User::WaitForRequest(notifStatus);

		TInt ret=buf2.Compare(buf1);

  	    if (ret!=0)

			{

			test.Printf(_L("Compare error\r\n"));

			test.Getch();

			}

		test(ret==0);

        }

	return(KErrNone);

	}

#if !defined (__WINS__)

LOCAL_C TInt TestingFlowControlChange()

//

// Test NotifyFlowControlChange()

//

	{

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus notifStatus;

	TRequestStatus timeStatus;

	if (!(TheCapsDce.iNotificationCaps & KNotifyFlowControlChangeSupported))

        test.Printf(_L("Flow Control change notification not supported on this platform"));

    else

        {

#if !defined (_TWO_PORT_LOOPBACK_)

		test.Printf(_L("Hit a key to start\n\r"));

		test.Getch();

#endif

		test.Next(_L("Testing GetFlowControlStatus()"));

		TheConfigDce.iHandshake=KConfigObeyXoff;

		test(TheDceSerialPort->SetConfig(TheConfigDceBuf)==KErrNone);

		TFlowControl fc;

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOff);

		test.Next(_L("Testing NotifyFlowControlChange() with s/w flow control"));

	    TheDceSerialPort->NotifyFlowControlChange(notifStatus);

	    test(notifStatus==KRequestPending);

	    const TUint KTimeOut=NOTIFY_TIMEOUT;

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

#if defined (_TWO_PORT_LOOPBACK_)

        test(TheDteSerialPort->WriteS(_L8("\x13"))==KErrNone); // XOFF

#else

		test.Printf(_L("10 seconds to send XOFF(O)\n\r"));

#endif

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

		    }

	    else

		    {

	        TheDceSerialPort->NotifyFlowControlChangeCancel();

		    test.Printf(_L("Timed Out!\n\r"));

			test.Getch();

		    test(FALSE);

		    }

		test.Next(_L("Testing GetFlowControlStatus() again"));

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOn);

#if defined (_TWO_PORT_LOOPBACK_)

        test(TheDteSerialPort->WriteS(_L8("\x11"))==KErrNone); // XON

#else

		test.Printf(_L("Send XON(X)\n\r"));

#endif

		User::After(1000000);		  // 1Sec

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOff);

		TheConfigDce.iHandshake=0;

		test(TheDceSerialPort->SetConfig(TheConfigDceBuf)==KErrNone);

#if defined (_TWO_PORT_LOOPBACK_)

		test.Next(_L("Testing NotifyFlowControlChange() with h/w flow control"));

		TheConfigDce.iHandshake=KConfigObeyRTS;

		test(TheDceSerialPort->SetConfig(TheConfigDceBuf)==KErrNone);

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOff);

	    TheDceSerialPort->NotifyFlowControlChange(notifStatus);

	    test(notifStatus==KRequestPending);

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

		TheDteSerialPort->SetSignals(0,KChangeSigOut); // Clear

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

		    }

	    else

		    {

	        TheDceSerialPort->NotifyFlowControlChangeCancel();

		    test.Printf(_L("Timed Out!\n\r"));

			test.Getch();

		    test(FALSE);

		    }

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOn);

		TheDteSerialPort->SetSignals(KChangeSigOut,0); // Set

		User::After(1000000);		  // 1Sec

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOff);

		test.Next(_L("Testing NotifyFlowControlChange() when not expected"));

        // Test notification doesn't happen when s/w flow control happens

	    TheDceSerialPort->NotifyFlowControlChange(notifStatus);

	    test(notifStatus==KRequestPending);

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

        test(TheDteSerialPort->WriteS(_L8("\x13"))==KErrNone); // XOFF

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

		    test(FALSE);

		    }

	    else

		    {

		    test(timeStatus==KErrNone); // Success

	        TheDceSerialPort->NotifyFlowControlChangeCancel(); // Tests cancel

			User::WaitForRequest(notifStatus);

		    }

        test(TheDteSerialPort->WriteS(_L8("\x11"))==KErrNone); // XON

		TheDceSerialPort->GetFlowControlStatus(fc);

		test(fc==EFlowControlOff);

		TheConfigDce.iHandshake=0;

		test(TheDceSerialPort->SetConfig(TheConfigDceBuf)==KErrNone);

#endif

        }

	return(KErrNone);

	}

LOCAL_C TInt TestingNotifyConfigChange()

//

// Test NotifyConfigChange()

//

	{

	RTimer tim;

	tim.CreateLocal();

	TRequestStatus notifStatus;

	TRequestStatus timeStatus;

	if (!(TheCapsDce.iNotificationCaps & KNotifyRateChangeSupported))

        test.Printf(_L("Rate change notification not supported on this platform"));

    else

        {

		test.Next(_L("Testing NotifyConfigChange()"));

#if defined (_TWO_PORT_LOOPBACK_)

	    TheConfigDte.iRate=EBps9600;

	    test(TheDteSerialPort->SetConfig(TheConfigDteBuf)==KErrNone);

#else

		test.Printf(_L("Change baudrate to 9600(BB)\n\r"));

		test.Printf(_L("Hit a key to start\n\r"));

		test.Getch();

#endif

		TCommNotificationPckg cmBuf;

		TCommNotificationV01& cm=cmBuf();

		// Test requesting before autobauding is enabled

	    TheDceSerialPort->NotifyConfigChange(notifStatus,cmBuf);

	    User::WaitForRequest(notifStatus);

	    test(notifStatus==KErrGeneral);

		// Enable autobauding

		TheConfigDce.iRate=EBpsAutobaud;  

		test(TheDceSerialPort->SetConfig(TheConfigDceBuf)==KErrNone);

		cm.iChangedMembers=0;

		cm.iRate=EBps50;

	    TheDceSerialPort->NotifyConfigChange(notifStatus,cmBuf);

	    test(notifStatus==KRequestPending);

	    const TUint KTimeOut=NOTIFY_TIMEOUT;

	    tim.After(timeStatus,KTimeOut);

	    test(timeStatus==KRequestPending);

#if defined (_TWO_PORT_LOOPBACK_)

        test(TheDteSerialPort->WriteS(_L8("AT&f\r"))==KErrNone);

#else

		test.Printf(_L("10 seconds to send hayes command(H)\n\r"));

#endif

	    User::WaitForRequest(notifStatus,timeStatus);

	    if (notifStatus==KErrNone)

		    {

		    tim.Cancel();

			User::WaitForRequest(timeStatus);

			test(cm.iChangedMembers==KRateChanged);

			test(cm.iRate==EBps9600);

		    }

	    else

		    {

	        TheDceSerialPort->NotifyConfigChangeCancel();

		    test.Printf(_L("Timed Out!\n\r"));

			test.Getch();

		    test(FALSE);

		    }

        }

	return(KErrNone);

	}

#endif

GLDEF_C TInt E32Main()

//

// Test DCE serial driver

//

    {

	test.Title();

	test.Start(_L("Turn off logging"));

	test.SetLogged(EFalse);//turn off serial port debugging!

	TInt r;

	test.Next(_L("Load drivers"));

#if defined (__WINS__)

	r=User::LoadPhysicalDevice(PDD_NAME);

	test.Printf(_L("Load EUART Return %d\n\r"),r);

	r=User::LoadLogicalDevice(LDD_NAME);

	test.Printf(_L("Load ECOMM Return %d\n\r"),r);

	TheDceSerialPort=new RBusDevComm;

#else

	r=User::LoadPhysicalDevice(DTEPDD_NAME);

	test.Printf(_L("Load DTE EUART Return %d\n\r"),r);

	r=User::LoadPhysicalDevice(DCEPDD_NAME);

	test.Printf(_L("Load DCE EUART Return %d\n\r"),r);

	r=User::LoadLogicalDevice(DTELDD_NAME);

	test.Printf(_L("Load DTE ECOMM Return %d\n\r"),r);

	r=User::LoadLogicalDevice(DCELDD_NAME);

	test.Printf(_L("Load DCE ECOMM Return %d\n\r"),r);

	TheDceSerialPort=new RBusDevCommDCE;

#endif

	test(TheDceSerialPort!=NULL);

	TheDteSerialPort=new RComm;

	test(TheDteSerialPort!=NULL);

//

	test.Next(_L("Open:"));

	r=TheDceSerialPort->Open(KTestUnitDce);

	test.Printf(_L("Open(DCE)=%d\n\r"),r);

	test(r==KErrNone);

	r=TheDteSerialPort->Open(KTestUnitDte);

	test.Printf(_L("Open(DTE)=%d\n\r"),r);

	test(r==KErrNone);

	// Setup serial ports

	test.Next(_L("Setup serial port"));

	TheDceSerialPort->Config(TheConfigDceBuf);

	TheConfigDce.iRate=EBps9600;

	TheConfigDce.iDataBits=EData8;

	TheConfigDce.iStopBits=EStop1;

	TheConfigDce.iParity=EParityNone;

	TheConfigDce.iHandshake=0;

	r=TheDceSerialPort->SetConfig(TheConfigDceBuf);

	test(r==KErrNone);

	TheDteSerialPort->Config(TheConfigDteBuf);

	TheConfigDte.iRate=EBps9600;

	TheConfigDte.iDataBits=EData8;

	TheConfigDte.iStopBits=EStop1;

	TheConfigDte.iParity=EParityNone;

	TheConfigDte.iHandshake=0;

	r=TheDteSerialPort->SetConfig(TheConfigDteBuf);

	test(r==KErrNone);

	test.Next(_L("Get DCE caps"));

	TheDceSerialPort->Caps(TheCapsDceBuf);

	test(r==KErrNone);

#ifndef __WINS__

	test.Next(_L("I/p signals"));

#if defined (_TWO_PORT_LOOPBACK_)

	TheDteSerialPort->SetSignals(0,KChangeSigOut); // Clear

#else

	test.Printf(_L("Negate DTR(D) - hit a key\n\r"));

	test.Getch();

#endif

	TUint sig=TheDceSerialPort->Signals();

	test.Printf(_L("Check (%x) is negated: %x\n\r"),KChangeSigIn,sig);

	test(!(sig&KChangeSigIn));

#if defined (_TWO_PORT_LOOPBACK_)

	TheDteSerialPort->SetSignals(KChangeSigOut,0); // Set

#else

	test.Printf(_L("Assert DTR(D) - hit a key\n\r"));

	test.Getch();

#endif

	sig=TheDceSerialPort->Signals();

	test.Printf(_L("Check (%x) is asserted: %x\n\r"),KChangeSigIn,sig);

	test(sig&KChangeSigIn);

#if defined (_TWO_PORT_LOOPBACK_)

	test.Next(_L("O/p signals"));

	TheDceSerialPort->SetSignals(0,KSignalCTS); // Clear

	sig=TheDteSerialPort->Signals();

	test.Printf(_L("Check (%x) is negated: %x\n\r"),KSignalCTS,sig);

	test(!(sig&KSignalCTS));

	TheDceSerialPort->SetSignals(KSignalCTS,0); // Set

	sig=TheDteSerialPort->Signals();

	test.Printf(_L("Check (%x) is asserted: %x\n\r"),KSignalCTS,sig);

	test(sig&KSignalCTS);

#endif

#endif

	test.Next(_L("Loopback test at 9600"));

#if !defined (_TWO_PORT_LOOPBACK_)

	test.Printf(_L("Start loopback at 9600(L) - hit a key when ready\n\r"));

	test.Getch();

#endif

	test(CheckedWrite(KTestPatternSize)==KTestPatternSize);

	test.Next(_L("Loopback test at 115200"));

	TheConfigDce.iRate=EBps115200;

	r=TheDceSerialPort->SetConfig(TheConfigDceBuf);

	test(r==KErrNone);

#if defined (_TWO_PORT_LOOPBACK_)

	TheConfigDte.iRate=EBps115200;

	r=TheDteSerialPort->SetConfig(TheConfigDteBuf);

	test(r==KErrNone);

#else

	test.Printf(_L("Start loopback at 115200(??BFL) - hit a key when ready\n\r"));

	test.Getch();

#endif

	test(CheckedWrite(KTestPatternSize)==KTestPatternSize);

	test.Next(_L("Test signal change notification"));

	TestingNotifySignalChange(KChangeSigIn);

	test.Next(_L("Test receive data available notification"));

	TestingNotifyReceiveDataAvailable();

#if !defined (__WINS__)

	test.Next(_L("Test flow control change"));

	TestingFlowControlChange();

	test.Next(_L("Test config change notification"));

	TestingNotifyConfigChange();

#endif

	TheDceSerialPort->Close();

	TheDteSerialPort->Close();

	test.Printf(_L("Hit a key"));

	test.Getch();

	test.End();

	return(KErrNone);

	}