diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kerneltest/e32test/device/t_dce.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kerneltest/e32test/device/t_dce.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,777 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include + +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;ianEndChar) + 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)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); + } + +