{

:     iStateWatcher(NULL), 

    iCurrentState(EUsbcDeviceStateUndefined), 

    iDeviceEp0(NULL), 

    iConnectTimer(NULL), iWakeupTimer(NULL),

    iAuxBuffer(NULL)

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_RUSBTESTDEVICE_ENTRY, this );

    OstTraceFunctionExit1( RUSBTESTDEVICE_RUSBTESTDEVICE_EXIT, this );

    }

:     iStateWatcher(NULL), 

    iCurrentState(EUsbcDeviceStateUndefined), 

    iDeviceEp0(NULL), 

    iConnectTimer(NULL), iWakeupTimer(NULL),

    iAuxBuffer(NULL)

    {

    OstTraceFunctionEntryExt( RUSBTESTDEVICE_RUSBTESTDEVICE_ENTRY_DUP01, this );

    iTestCase = aTestCase;

    OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_RUSBTESTDEVICE, "iTestCase = %d", iTestCase);

    OstTraceFunctionExit1( RUSBTESTDEVICE_RUSBTESTDEVICE_EXIT_DUP01, this );

    }

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_RESETSTATE_ENTRY, this );

    iCurrentState = EUsbcDeviceStateUndefined;

    OstTraceFunctionExit1( RUSBTESTDEVICE_RESETSTATE_EXIT, this );

    }

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_RUSBTESTDEVICE_ENTRY_DUP02, this );

    OstTraceFunctionExit1( RUSBTESTDEVICE_RUSBTESTDEVICE_EXIT_DUP02, this );

    }

    {

    delete iWakeupTimer;

    delete iConnectTimer;

    delete iDeviceEp0;

    delete iStateWatcher;

    iInterfaces.ResetAndDestroy();

    iClientDriver.Close(); 

    if(!iTestCase->IsHost()) // process only started in client rom

        {

        OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_CLOSE_DUP01, "killing t_usbhost_usbman.exe");

        }

    OstTraceFunctionExit1( RUSBTESTDEVICE_CLOSE_EXIT, this );

    }

    {

    OstTraceFunctionEntryExt( RUSBTESTDEVICE_SUBSCRIBETOREPORTS_ENTRY, this );

    // Signal the request as pending

    iObserverStatus = &aObserverStatus;

    *iObserverStatus = KRequestPending;

    OstTraceFunctionExit1( RUSBTESTDEVICE_SUBSCRIBETOREPORTS_EXIT, this );

    }

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_CANCELSUBSCRIPTIONTOREPORTS_ENTRY, this );

    // Signal the request as cancelled

    User::RequestComplete(iObserverStatus,KErrCancel);

    OstTraceFunctionExit1( RUSBTESTDEVICE_CANCELSUBSCRIPTIONTOREPORTS_EXIT, this );

    }

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_OPENL_ENTRY, this );

    TInt err = KErrNone;

    OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_OPENL, "starting t_usbhost_usbman.exe");

    TInt r = iOtgUsbMan.Create(_L("t_usbhost_usbman.exe"), _L("client"));

    gtest(r == KErrNone);

    iOtgUsbMan.Resume();    

    User::After(1500000);

    // Open channel to driver

    err = iClientDriver.Open(0);

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP01, "<Error %d> Unable to open a channel to USB client driver",err);

        User::Leave(err);

        }

    // Hide bus from host while interfaces are being set up

    err = iClientDriver.DeviceDisconnectFromHost();

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP02, "<Error %d> unable to disconnect device from host",err);

        User::Leave(err);

        }

    // Create the client usb state watcher

    iStateWatcher = CUsbClientStateWatcher::NewL(iClientDriver,*this);

    // Create the Ep0 reader

    iDeviceEp0 = CDeviceEndpoint0::NewL(*this);

    // Create the timer for software connection/disconnection

    iConnectTimer = CSoftwareConnectTimer::NewL(*this);

    // Create the timer for remote wakeup events

    iWakeupTimer = CRemoteWakeupTimer::NewL(*this);

    User::LeaveIfError(iClientDriver.DeviceCaps(iDeviceCaps));

#ifdef OST_TRACE_COMPILER_IN_USE

    _LIT8(KYes, "yes");

    _LIT8(KNo, "no");

#endif

     OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP03, "------ USB device capabilities -------");

    OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP04, "Number of endpoints:                %d",iDeviceCaps().iTotalEndpoints);    

    OstTraceExt1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP05, "Supports Software-Connect:          %s",iDeviceCaps().iConnect ? KYes() : KNo());

    OstTraceExt1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP06, "Device is Self-Powered:             %S",iDeviceCaps().iSelfPowered ? KYes() : KNo());

    OstTraceExt1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP07, "Supports Remote-Wakeup:             %S",iDeviceCaps().iRemoteWakeup ? KYes() : KNo());

    OstTraceExt1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP08, "Supports High-speed:                %S",iDeviceCaps().iHighSpeed ? KYes() : KNo());

    OstTraceExt1(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP09, "Supports unpowered cable detection: %S",(iDeviceCaps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower) ? KYes() : KNo());

    OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_OPENL_DUP10, "--------------------------------------");

    OstTraceFunctionExit1( RUSBTESTDEVICE_OPENL_EXIT, this );

    }

    {

    // Get Device descriptor

    TBuf8<KUsbDescSize_Device> deviceDescriptor;

    TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETCLASSCODE, "<Error %d> Unable to obtain device descriptor",err);

        }

    else

        {

        deviceDescriptor[KDevDescOffset_bDeviceClass] = aClassCode;

        deviceDescriptor[KDevDescOffset_bDeviceSubClass] = aSubClassCode;

        deviceDescriptor[KDevDescOffset_bDeviceProtocol] = aDeviceProtocol;    

        err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETCLASSCODE_DUP01, "<Error %d> Unable to set the device dsecriptor",err);

            }

        }

    OstTraceFunctionExitExt( RUSBTESTDEVICE_SETCLASSCODE_EXIT, this, err );

    return err;

    }

    {

    // Get Device descriptor

    TBuf8<KUsbDescSize_Device> deviceDescriptor;

    TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETUSBSPECIFICATION, "<Error %d> Unable to obtain device descriptor",err);

        }

    else

        {

        // Set bcdUSB

        TUint8* p = reinterpret_cast<TUint8*>(&aSpecification);

        deviceDescriptor[KDevDescOffset_bcdUSB] = *p;

        deviceDescriptor[KDevDescOffset_bcdUSB+1] = *(p+1);

        // Symbian currently supports only devices with one configuration by selecting the configurations

        // that has the lowest power consumption

        deviceDescriptor[KDevDescOffset_bNumConfigurations] = 0x01;

        err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETUSBSPECIFICATION_DUP01, "<Error %d> Unable to set the device dsecriptor",err);

            }

        }

    OstTraceFunctionExitExt( RUSBTESTDEVICE_SETUSBSPECIFICATION_EXIT, this, err );

    return err;

    }

    {

    // Get Device descriptor

    TBuf8<KUsbDescSize_Device> deviceDescriptor;

    TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETVENDOR, "<Error %d> Unable to obtain device descriptor",err);

        }

    else

        {

        // Set VID

        TUint8* p = reinterpret_cast<TUint8*>(&aVendorId);

        deviceDescriptor[KDevDescOffset_idVendor] = *p;

        deviceDescriptor[KDevDescOffset_idVendor+1] = *(p+1);

        err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETVENDOR_DUP01, "<Error %d> Unable to set the device descriptor",err);

            }

        }

    OstTraceFunctionExitExt( RUSBTESTDEVICE_SETVENDOR_EXIT, this, err );

    return err;

    }

                const TDesC16& aManufacturerString,const TDesC16& aSerialNumberString)

    {

    // Get Device descriptor

    TBuf8<KUsbDescSize_Device> deviceDescriptor;

    TInt err(iClientDriver.GetDeviceDescriptor(deviceDescriptor));

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETPRODUCT, "<Error %d> Unable to obtain device descriptor",err);

        }

    else

        {

        // Set PID

        TUint8* p = reinterpret_cast<TUint8*>(&aProductId);

        deviceDescriptor[KDevDescOffset_idProduct] = *p;

        deviceDescriptor[KDevDescOffset_idProduct+1] = *(p+1);

        err = iClientDriver.SetDeviceDescriptor(deviceDescriptor);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETPRODUCT_DUP01, "<Error %d> Unable to set the device dsecriptor",err);

            OstTraceFunctionExitExt( RUSBTESTDEVICE_SETPRODUCT_EXIT, this, err );

            return err;

            }

        OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_SETPRODUCT_DUP02, "Product Identity set");

        // Product string

        err = iClientDriver.SetProductStringDescriptor(aProductString);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETPRODUCT_DUP03, "<Error %d> Unable to set product string descriptor",err);

            OstTraceFunctionExitExt( RUSBTESTDEVICE_SETPRODUCT_EXIT_DUP01, this, err );

            return err;

            }

        // Manufacturer string

        err = iClientDriver.SetManufacturerStringDescriptor(aManufacturerString);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETPRODUCT_DUP04, "<Error %d> Unable to set the manufacturer string descriptor",err);

            OstTraceFunctionExitExt( RUSBTESTDEVICE_SETPRODUCT_EXIT_DUP02, this, err );

            return err;

            }

        // Serial number string

        err = iClientDriver.SetSerialNumberStringDescriptor(aSerialNumberString);

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETPRODUCT_DUP05, "<Error %d> Unable to set the serial number string descriptor",err);

            OstTraceFunctionExitExt( RUSBTESTDEVICE_SETPRODUCT_EXIT_DUP03, this, err );

            return err;

            }

        }

    OstTraceFunctionExitExt( RUSBTESTDEVICE_SETPRODUCT_EXIT_DUP04, this, KErrNone );

    return KErrNone;

    }

    {

    TInt err(iClientDriver.SetConfigurationStringDescriptor(aConfigString));

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SETCONFIGURATIONSTRING, "<Error %d> Unable to set configuration string descriptor",err);

        }

    OstTraceFunctionExitExt( RUSBTESTDEVICE_SETCONFIGURATIONSTRING_EXIT, this, err );

    return err;

    }

    {

    OstTraceFunctionEntryExt( RUSBTESTDEVICE_ADDINTERFACE_ENTRY, this );

    // Add the interface to the device

    TInt err = iInterfaces.Append(aInterface);

    if(err != KErrNone)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_ADDINTERFACE, "<Error %d> Unable to add interface",err);

        return ReportError(err);

        }

    OstTraceFunctionExit1( RUSBTESTDEVICE_ADDINTERFACE_EXIT, this );

    }

    {

    OstTraceFunctionEntryExt( RUSBTESTDEVICE_INTERFACE_ENTRY, this );

    OstTraceFunctionExit1( RUSBTESTDEVICE_INTERFACE_EXIT, this );

    return *iInterfaces[aIndex];

    }

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_SOFTWARECONNECT_ENTRY, this );

    TInt err(iClientDriver.PowerUpUdc());

    if((err != KErrNone) && (err != KErrNotReady))

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SOFTWARECONNECT, "<Error %d> Power Up Udc",err);

        ReportError(err);

        }

    if(iDeviceCaps().iConnect) 

        {

        err = iClientDriver.DeviceConnectToHost();

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SOFTWARECONNECT_DUP01, "<Error %d> Unable to connect to the host",err);

            ReportError(err);

            }

        }

    else

        {

        OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_SOFTWARECONNECT_DUP02, "Please connect device to Host");

        }    

    OstTraceFunctionExit1( RUSBTESTDEVICE_SOFTWARECONNECT_EXIT, this );

    }       

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_SOFTWAREDISCONNECT_ENTRY, this );

    if(iDeviceCaps().iConnect) 

        {

        TInt err(iClientDriver.DeviceDisconnectFromHost());

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_SOFTWAREDISCONNECT, "<Error %d> Unable to disconnect from the host",err);

            ReportError(err);

            }

        }

    else

        {

        OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_SOFTWAREDISCONNECT_DUP01, "Please disconnect device from Host");

        }

    OstTraceFunctionExit1( RUSBTESTDEVICE_SOFTWAREDISCONNECT_EXIT, this );

    }       

    {

    OstTraceFunctionEntry1( RUSBTESTDEVICE_REMOTEWAKEUP_ENTRY, this );

    if(iDeviceCaps().iConnect) 

        {

        TInt err(iClientDriver.SignalRemoteWakeup());

        if(err != KErrNone)

            {

            OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_REMOTEWAKEUP, "<Error %d> Unable to perform a remote wakeup",err);

            ReportError(err);

            }

        }

    else

        {

        OstTrace0(TRACE_NORMAL, RUSBTESTDEVICE_REMOTEWAKEUP_DUP01, "remote wakeup not supported");

        }

    OstTraceFunctionExit1( RUSBTESTDEVICE_REMOTEWAKEUP_EXIT, this );

    }

    TUint16 aDataReqLength,const TDesC8& aPayload)

    {

    OstTraceFunctionEntryExt( RUSBTESTDEVICE_PROCESSREQUESTL_ENTRY, this );

    if(aRequest == KVendorEmptyRequest)

        {

        // Handle an empty request (i.e. do nothing)

        AcknowledgeRequestReceived();

        }

    else if(aRequest == KVendorReconnectRequest)

        {

        // Handle a reconnect requests from the host

        AcknowledgeRequestReceived();

        iConnectTimer->SoftwareReConnect(aValue);

        }

    else if(aRequest == KVendorDisconnectDeviceAThenConnectDeviceCRequest)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_PROCESSREQUESTL, "**aRequest == KVendorDisconnectDeviceAThenConnectDeviceCRequest, this = 0x%08x", this);

        // Handle a reconnect requests from the host        

        AcknowledgeRequestReceived();            

        SoftwareDisconnect();    

        User::After(1000000);

        //    connect device C now    

        CUT_PBASE_T_USBDI_0486* iTestCaseT_USBDI_0486 = reinterpret_cast<CUT_PBASE_T_USBDI_0486*>(iTestCase);

        Close();         

        User::After(3000000);

        iTestCaseT_USBDI_0486->TestDeviceC()->OpenL(KTestDeviceC_SN);        

        // Connect the device to the host    

        iTestCaseT_USBDI_0486->TestDeviceC()->SoftwareConnect();

        OstTraceFunctionExitExt( RUSBTESTDEVICE_PROCESSREQUESTL_EXIT, this, KErrAbort );

        return KErrAbort;

        }

    else if(aRequest == KVendorDisconnectDeviceCThenConnectDeviceARequest)

        {

        OstTrace1(TRACE_NORMAL, RUSBTESTDEVICE_PROCESSREQUESTL_DUP01, "**aRequest == KVendorDisconnectDeviceCThenConnectDeviceARequest, this = 0x%08x", this);

        // Handle a reconnect requests from the host        

        AcknowledgeRequestReceived();        

        SoftwareDisconnect();    

        User::After(1000000); 

        //    connect device A now    

        CUT_PBASE_T_USBDI_0486* iTestCaseT_USBDI_0486 = reinterpret_cast<CUT_PBASE_T_USBDI_0486*>(iTestCase);