comm.c File Reference

#include <stdio.h>
#include "ntstatus.h"
#include "wine/test.h"
#include "winternl.h"
#include "winbase.h"
#include "winnls.h"

Include dependency graph for comm.c:

Go to the source code of this file.

Classes
struct	TEST

Macros
#define	WIN32_NO_STATUS
#define	TIMEOUT   1000 /* one second for Timeouts*/
#define	SLOWBAUD   150
#define	FASTBAUD   115200
#define	TIMEDELTA   150 /* 150 ms uncertainty allowed */
#define	LOOPBACK_TXD_RXD   FALSE /* Sub-D 9: Short 2-3 */
#define	LOOPBACK_CTS_RTS   FALSE /* Sub-D 9: Short 7-8 */
#define	LOOPBACK_DTR_DSR   FALSE /* Sub-D 9: Short 4-6 */
#define	LOOPBACK_DTR_RING   FALSE /* Sub-D 9: Short 4-9 */
#define	LOOPBACK_DTR_DCD   FALSE /* Sub-D 9: Short 4-1 */
#define	TEST_COUNT   (sizeof(test) / sizeof(TEST))
#define	check_dcb_member(a, b)   ok(pdcb1->a == pdcb2->a, "%s(\"%s\"), 0x%02x: "#a" is "b", should be "b"\n", function, ptest->string, initial_value, pdcb1->a, pdcb2->a)
#define	check_dcb_member2(a, c, b)   if(pdcb2->a == c) { check_dcb_member(a,b); } else { ok(pdcb1->a == pdcb2->a || pdcb1->a == c, "%s(\"%s\"), 0x%02x: "#a" is "b", should be "b" or "b"\n", function, ptest->string, initial_value, pdcb1->a, pdcb2->a, c); }
#define	check_timeouts_member(a)   ok(ptimeouts1->a == ptimeouts2->a, "%s(\"%s\"), 0x%02x: "#a" is %u, should be %u\n", function, ptest->string, initial_value, ptimeouts1->a, ptimeouts2->a);

Functions
static	NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile
static void	check_result (const char *function, const TEST *ptest, int initial_value, BOOL result)
static void	check_dcb (const char *function, const TEST *ptest, int initial_value, const DCB *pdcb1, const DCB *pdcb2)
static void	check_timeouts (const char *function, const TEST *ptest, int initial_value, const COMMTIMEOUTS *ptimeouts1, const COMMTIMEOUTS *ptimeouts2)
static void	test_BuildCommDCBA (const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb)
static void	test_BuildCommDCBAndTimeoutsA (const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb, const COMMTIMEOUTS *pexpected_timeouts)
static void	test_BuildCommDCBW (const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb)
static void	test_BuildCommDCBAndTimeoutsW (const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb, const COMMTIMEOUTS *pexpected_timeouts)
static void	test_BuildCommDCB (void)
static HANDLE	test_OpenComm (BOOL doOverlap)
static void	test_GetModemStatus (HANDLE hcom)
static void	test_ReadTimeOut (void)
static void	test_waittxempty (void)
static void	test_ClearCommError (void)
static void	test_non_pending_errors (void)
static void	test_LoopbackRead (void)
static void	test_LoopbackCtsRts (void)
static void	test_LoopbackDtrDcd (void)
static void	test_LoopbackDtrDsr (void)
static void	test_LoopbackDtrRing (void)
static void	test_WaitRx (void)
static DWORD CALLBACK	toggle_ctlLine (LPVOID arg)
static void	test_WaitCts (void)
static DWORD CALLBACK	reset_CommMask (LPVOID arg)
static void	test_AbortWaitCts (void)
static void	test_WaitDsr (void)
static void	test_WaitRing (void)
static void	test_WaitDcd (void)
static DWORD CALLBACK	set_CommBreak (LPVOID arg)
static void	test_WaitBreak (void)
static void	test_stdio (void)
static void	test_WaitCommEvent (void)
static void	test_FlushFileBuffers (void)
static void	test_read_write (void)
	START_TEST (comm)

Variables
static BOOL	loopback_txd_rxd = LOOPBACK_TXD_RXD
static BOOL	loopback_rts_cts = LOOPBACK_CTS_RTS
static BOOL	loopback_dtr_dsr = LOOPBACK_DTR_DSR
static BOOL	loopback_dtr_ring = LOOPBACK_DTR_RING
static BOOL	loopback_dtr_dcd = LOOPBACK_DTR_DCD
static HANDLE	hEvent
static HANDLE PIO_APC_ROUTINE	apc
static HANDLE PIO_APC_ROUTINE void *	apc_user
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK	io_status
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK void *	buffer
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK void ULONG	length
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK void ULONG PLARGE_INTEGER	offset
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK void ULONG PLARGE_INTEGER PULONG	key
static const TEST	test []

Macro Definition Documentation

check_dcb_member

#define check_dcb_member	(		a,
			b
	)		ok(pdcb1->a == pdcb2->a, "%s(\"%s\"), 0x%02x: "#a" is "b", should be "b"\n", function, ptest->string, initial_value, pdcb1->a, pdcb2->a)

Definition at line 459 of file comm.c.

check_dcb_member2

#define check_dcb_member2	(		a,
			c,
			b
	)		if(pdcb2->a == c) { check_dcb_member(a,b); } else { ok(pdcb1->a == pdcb2->a || pdcb1->a == c, "%s(\"%s\"), 0x%02x: "#a" is "b", should be "b" or "b"\n", function, ptest->string, initial_value, pdcb1->a, pdcb2->a, c); }

Definition at line 460 of file comm.c.

check_timeouts_member

#define check_timeouts_member

(

a

)

ok(ptimeouts1->a == ptimeouts2->a, "%s(\"%s\"), 0x%02x: "#a" is %u, should be %u\n", function, ptest->string, initial_value, ptimeouts1->a, ptimeouts2->a);

Definition at line 532 of file comm.c.

FASTBAUD

#define FASTBAUD   115200

Definition at line 32 of file comm.c.

LOOPBACK_CTS_RTS

#define LOOPBACK_CTS_RTS   FALSE /* Sub-D 9: Short 7-8 */

Definition at line 39 of file comm.c.

LOOPBACK_DTR_DCD

#define LOOPBACK_DTR_DCD   FALSE /* Sub-D 9: Short 4-1 */

Definition at line 42 of file comm.c.

LOOPBACK_DTR_DSR

#define LOOPBACK_DTR_DSR   FALSE /* Sub-D 9: Short 4-6 */

Definition at line 40 of file comm.c.

LOOPBACK_DTR_RING

#define LOOPBACK_DTR_RING   FALSE /* Sub-D 9: Short 4-9 */

Definition at line 41 of file comm.c.

LOOPBACK_TXD_RXD

#define LOOPBACK_TXD_RXD   FALSE /* Sub-D 9: Short 2-3 */

Definition at line 38 of file comm.c.

SLOWBAUD

#define SLOWBAUD   150

Definition at line 31 of file comm.c.

TEST_COUNT

#define TEST_COUNT   (sizeof(test) / sizeof(TEST))

Definition at line 413 of file comm.c.

TIMEDELTA

#define TIMEDELTA   150 /* 150 ms uncertainty allowed */

Definition at line 33 of file comm.c.

TIMEOUT

#define TIMEOUT   1000 /* one second for Timeouts*/

Definition at line 30 of file comm.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 24 of file comm.c.

Function Documentation

check_dcb()

static void check_dcb ( const char *  function, const TEST *  ptest, int  initial_value, const DCB *  pdcb1, const DCB *  pdcb2  )

static

Definition at line 462 of file comm.c.

{
    /* DCBlength is a special case since Win 9x sets it but NT does not.
       We will accept either as correct. */
    check_dcb_member2(DCBlength, (DWORD)sizeof(DCB), "%u");
 
    /* For old style control strings Win 9x does not set the next five members, NT does. */
    if(ptest->old_style && ptest->result)
    {
        check_dcb_member2(fOutxCtsFlow, ((unsigned int)initial_value & 1), "%u");
        check_dcb_member2(fDtrControl, ((unsigned int)initial_value & 3), "%u");
        check_dcb_member2(fOutX, ((unsigned int)initial_value & 1), "%u");
        check_dcb_member2(fInX, ((unsigned)initial_value & 1), "%u");
        check_dcb_member2(fRtsControl, ((unsigned)initial_value & 3), "%u");
    }
    else
    {
        check_dcb_member(fOutxCtsFlow, "%u");
        check_dcb_member(fDtrControl, "%u");
        check_dcb_member(fOutX, "%u");
        check_dcb_member(fInX, "%u");
        check_dcb_member(fRtsControl, "%u");
    }
 
    if(ptest->result)
    {
        /* For the idsr=xxx parameter, NT sets fDsrSensitivity, 9x sets
           fOutxDsrFlow. */
        if(!ptest->old_style)
        {
            check_dcb_member2(fOutxDsrFlow, pdcb2->fDsrSensitivity, "%u");
            check_dcb_member2(fDsrSensitivity, pdcb2->fOutxDsrFlow, "%u");
        }
        else
        {
            /* For old style control strings Win 9x does not set the
               fOutxDsrFlow member, NT does. */
            check_dcb_member2(fOutxDsrFlow, ((unsigned int)initial_value & 1), "%u");
            check_dcb_member(fDsrSensitivity, "%u");
        }
    }
    else
    {
        check_dcb_member(fOutxDsrFlow, "%u");
        check_dcb_member(fDsrSensitivity, "%u");
    }
 
    /* Check the result of the DCB members. */
    check_dcb_member(BaudRate, "%u");
    check_dcb_member(fBinary, "%u");
    check_dcb_member(fParity, "%u");
    check_dcb_member(fTXContinueOnXoff, "%u");
    check_dcb_member(fErrorChar, "%u");
    check_dcb_member(fNull, "%u");
    check_dcb_member(fAbortOnError, "%u");
    check_dcb_member(fDummy2, "%u");
    check_dcb_member(wReserved, "%u");
    check_dcb_member(XonLim, "%u");
    check_dcb_member(XoffLim, "%u");
    check_dcb_member(ByteSize, "%u");
    check_dcb_member(Parity, "%u");
    check_dcb_member(StopBits, "%u");
    check_dcb_member(XonChar, "%d");
    check_dcb_member(XoffChar, "%d");
    check_dcb_member(ErrorChar, "%d");
    check_dcb_member(EofChar, "%d");
    check_dcb_member(EvtChar, "%d");
    check_dcb_member(wReserved1, "%u");
}

Referenced by test_BuildCommDCBA(), test_BuildCommDCBAndTimeoutsA(), test_BuildCommDCBAndTimeoutsW(), and test_BuildCommDCBW().

check_result()

static void check_result ( const char *  function, const TEST *  ptest, int  initial_value, BOOL  result  )

static

Definition at line 450 of file comm.c.

{
    DWORD LastError = GetLastError();
    DWORD CorrectError = (ptest->result ? 0xdeadbeef : ERROR_INVALID_PARAMETER);
 
    ok(LastError == CorrectError, "%s(\"%s\"), 0x%02x: GetLastError() returned %d, should be %d\n", function, ptest->string, initial_value, LastError, CorrectError);
    ok(result == ptest->result, "%s(\"%s\"), 0x%02x: return value should be %s\n", function, ptest->string, initial_value, ptest->result ? "TRUE" : "FALSE");
}

Referenced by test_BuildCommDCBA(), test_BuildCommDCBAndTimeoutsA(), test_BuildCommDCBAndTimeoutsW(), and test_BuildCommDCBW().

check_timeouts()

static void check_timeouts ( const char *  function, const TEST *  ptest, int  initial_value, const COMMTIMEOUTS *  ptimeouts1, const COMMTIMEOUTS *  ptimeouts2  )

static

Definition at line 534 of file comm.c.

{
    check_timeouts_member(ReadIntervalTimeout);
    check_timeouts_member(ReadTotalTimeoutMultiplier);
    check_timeouts_member(ReadTotalTimeoutConstant);
    check_timeouts_member(WriteTotalTimeoutMultiplier);
    check_timeouts_member(WriteTotalTimeoutConstant);
}

Referenced by test_BuildCommDCBAndTimeoutsA(), and test_BuildCommDCBAndTimeoutsW().

NTSTATUS()

static NTSTATUS ( WINAPI *  pNtReadFile )

static

reset_CommMask()

static DWORD CALLBACK reset_CommMask ( LPVOID  arg )

static

Definition at line 1516 of file comm.c.

{
    DWORD_PTR *args = arg;
    DWORD timeout = args[0];
    HANDLE hcom   = (HANDLE) args[1];
 
    trace(" Changing CommMask on the fly for handle %p after timeout %d\n",
      hcom, timeout);
    Sleep(timeout);
    ok(SetCommMask(hcom, 0),"SetCommMask %p failed\n", hcom);
    trace("SetCommMask changed\n");
    return 0;
}

Referenced by test_AbortWaitCts().

set_CommBreak()

static DWORD CALLBACK set_CommBreak ( LPVOID  arg )

static

Definition at line 1851 of file comm.c.

{
    DWORD_PTR *args = arg;
    DWORD timeout = args[0];
    HANDLE hcom   = (HANDLE) args[1];
 
    trace("SetCommBreak for handle %p after timeout %d\n",
      hcom, timeout);
    Sleep(timeout);
    ok(SetCommBreak(hcom),"SetCommBreak %p failed\n", hcom);
    trace("SetCommBreak done\n");
    return 0;
}

Referenced by test_WaitBreak().

START_TEST()

START_TEST

(

comm

)

Definition at line 2201 of file comm.c.

{
    HMODULE ntdll = GetModuleHandleA("ntdll.dll");
    if (ntdll)
    {
        pNtReadFile = (void *)GetProcAddress(ntdll, "NtReadFile");
        pNtWriteFile = (void *)GetProcAddress(ntdll, "NtWriteFile");
    }
 
    test_ClearCommError(); /* keep it the very first test */
    test_FlushFileBuffers();
    test_BuildCommDCB();
    test_ReadTimeOut();
    test_waittxempty();
    test_non_pending_errors();
    test_LoopbackRead();
    test_LoopbackCtsRts();
    test_LoopbackDtrDsr();
    test_LoopbackDtrRing();
    test_LoopbackDtrDcd();
    test_WaitRx();
    test_WaitCts();
    test_AbortWaitCts();
    test_WaitDsr();
    test_WaitRing();
    test_WaitDcd();
    test_WaitBreak();
    test_stdio();
    test_read_write();
 
    if (!winetest_interactive)
    {
        skip("interactive tests (set WINETEST_INTERACTIVE=1)\n");
        return;
    }
 
    test_WaitCommEvent();
}

test_AbortWaitCts()

static void test_AbortWaitCts ( void  )

static

Definition at line 1534 of file comm.c.

{
    DCB dcb;
    OVERLAPPED overlapped;
    HANDLE hcom, hComPortEvent, alarmThread;
    DWORD_PTR args[2];
    DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == RTS_CONTROL_DISABLE)
    {
    trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
        CloseHandle(hcom);
    return;
    }
    args[0]= TIMEOUT >>1;
    args[1]= (DWORD_PTR)hcom;
 
    trace("test_AbortWaitCts timeout %ld handle %p\n",args[0], hcom);
 
    ok(SetCommMask(hcom, EV_CTS), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
    alarmThread = CreateThread(NULL, 0, reset_CommMask, args, 0, &alarmThreadId);
    /* Wait a minimum to let the thread start up */
    Sleep(10);
    trace("Thread created\n");
    ok(alarmThread !=0 , "CreateThread Failed\n");
 
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
    before = GetTickCount();
    success = WaitCommEvent(hcom, &evtmask, &overlapped);
    err = GetLastError();
    after = GetTickCount();
 
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
    ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
    if (!success && (err == ERROR_IO_PENDING))
    ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
             "AbortWaitCts hComPortEvent failed\n");
    success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success, err, evtmask, after-before, after1-before);
 
    ok(evtmask == 0, "Incorrect EventMask 0x%08x returned on Wait aborted bu SetCommMask, expected 0x%08x\n",
         evtmask, 0);
    ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
                  "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    CloseHandle(hcom);
    ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
    CloseHandle( alarmThread );
}

Referenced by START_TEST().

test_BuildCommDCB()

static void test_BuildCommDCB ( void  )

static

Definition at line 635 of file comm.c.

{
    char port_name[] = "COMx";
    char port = 0;
    unsigned int i;
    char *ptr;
 
    /* Some of these tests require a valid COM port.  This loop will try to find
       a valid port. */
    for(port_name[3] = '1'; port_name[3] <= '9'; port_name[3]++)
    {
        COMMCONFIG commconfig;
        DWORD size = sizeof(COMMCONFIG);
 
        if(GetDefaultCommConfigA(port_name, &commconfig, &size))
        {
            port = port_name[3];
            break;
        }
    }
 
    if(!port)
        trace("Could not find a valid COM port.  Some tests will be skipped.\n");
 
    for(i = 0; i < TEST_COUNT; i++)
    {
                char string[sizeof(test[i].string)];
 
                strcpy(string, test[i].string);
 
        /* Check if this test case needs a valid COM port. */
        ptr = strstr(string, "COMx");
 
        /* If required, substitute valid port number into device control string. */
        if(ptr)
        {
            if(port)
                ptr[3] = port;
            else
                continue;
        }
 
        test_BuildCommDCBA(string, &test[i], 0x00, &test[i].dcb1);
        test_BuildCommDCBA(string, &test[i], 0xff, &test[i].dcb2);
        test_BuildCommDCBAndTimeoutsA(string, &test[i], 0x00, &test[i].dcb1, &test[i].timeouts1);
        test_BuildCommDCBAndTimeoutsA(string, &test[i], 0xff, &test[i].dcb2, &test[i].timeouts2);
 
        test_BuildCommDCBW(string, &test[i], 0x00, &test[i].dcb1);
        test_BuildCommDCBW(string, &test[i], 0xff, &test[i].dcb2);
        test_BuildCommDCBAndTimeoutsW(string, &test[i], 0x00, &test[i].dcb1, &test[i].timeouts1);
        test_BuildCommDCBAndTimeoutsW(string, &test[i], 0xff, &test[i].dcb2, &test[i].timeouts2);
    }
}

Referenced by START_TEST().

test_BuildCommDCBA()

static void test_BuildCommDCBA ( const char *  string, const TEST *  ptest, int  initial_value, const DCB *  pexpected_dcb  )

static

Definition at line 543 of file comm.c.

{
    BOOL result;
    DCB dcb;
 
    /* set initial conditions */
    memset(&dcb, initial_value, sizeof(DCB));
    SetLastError(0xdeadbeef);
 
    result = BuildCommDCBA(string, &dcb);
 
    /* check results */
    check_result("BuildCommDCBA", ptest, initial_value, result);
    check_dcb("BuildCommDCBA", ptest, initial_value, &dcb, pexpected_dcb);
}

Referenced by test_BuildCommDCB().

test_BuildCommDCBAndTimeoutsA()

static void test_BuildCommDCBAndTimeoutsA ( const char *  string, const TEST *  ptest, int  initial_value, const DCB *  pexpected_dcb, const COMMTIMEOUTS *  pexpected_timeouts  )

static

Definition at line 559 of file comm.c.

{
    BOOL result;
    DCB dcb;
    COMMTIMEOUTS timeouts;
 
    /* set initial conditions */
    memset(&dcb, initial_value, sizeof(DCB));
    memset(&timeouts, initial_value, sizeof(COMMTIMEOUTS));
    SetLastError(0xdeadbeef);
 
    result = BuildCommDCBAndTimeoutsA(string, &dcb, &timeouts);
 
    /* check results */
    check_result("BuildCommDCBAndTimeoutsA", ptest, initial_value, result);
    check_dcb("BuildCommDCBAndTimeoutsA", ptest, initial_value, &dcb, pexpected_dcb);
    check_timeouts("BuildCommDCBAndTimeoutsA", ptest, initial_value, &timeouts, pexpected_timeouts);
}

Referenced by test_BuildCommDCB().

test_BuildCommDCBAndTimeoutsW()

static void test_BuildCommDCBAndTimeoutsW ( const char *  string, const TEST *  ptest, int  initial_value, const DCB *  pexpected_dcb, const COMMTIMEOUTS *  pexpected_timeouts  )

static

Definition at line 605 of file comm.c.

{
    BOOL result;
    DCB dcb;
    COMMTIMEOUTS timeouts;
    WCHAR wide_string[sizeof(ptest->string)];
    static int reportedDCBAndTW = 0;
 
    MultiByteToWideChar(CP_ACP, 0, string, -1, wide_string, sizeof(wide_string) / sizeof(WCHAR));
 
    /* set initial conditions */
    memset(&dcb, initial_value, sizeof(DCB));
    memset(&timeouts, initial_value, sizeof(COMMTIMEOUTS));
    SetLastError(0xdeadbeef);
 
    result = BuildCommDCBAndTimeoutsW(wide_string, &dcb, &timeouts);
 
    if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        if(!reportedDCBAndTW++)
            win_skip("BuildCommDCBAndTimeoutsW is not implemented\n");
        return;
    }
 
    /* check results */
    check_result("BuildCommDCBAndTimeoutsW", ptest, initial_value, result);
    check_dcb("BuildCommDCBAndTimeoutsW", ptest, initial_value, &dcb, pexpected_dcb);
    check_timeouts("BuildCommDCBAndTimeoutsW", ptest, initial_value, &timeouts, pexpected_timeouts);
}

Referenced by test_BuildCommDCB().

test_BuildCommDCBW()

static void test_BuildCommDCBW ( const char *  string, const TEST *  ptest, int  initial_value, const DCB *  pexpected_dcb  )

static

Definition at line 578 of file comm.c.

{
    BOOL result;
    DCB dcb;
    WCHAR wide_string[sizeof(ptest->string)];
    static int reportedDCBW = 0;
 
    MultiByteToWideChar(CP_ACP, 0, string, -1, wide_string, sizeof(wide_string) / sizeof(WCHAR));
 
    /* set initial conditions */
    memset(&dcb, initial_value, sizeof(DCB));
    SetLastError(0xdeadbeef);
 
    result = BuildCommDCBW(wide_string, &dcb);
 
    if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        if(!reportedDCBW++)
            win_skip("BuildCommDCBW is not implemented\n");
        return;
    }
 
    /* check results */
    check_result("BuildCommDCBW", ptest, initial_value, result);
    check_dcb("BuildCommDCBW", ptest, initial_value, &dcb, pexpected_dcb);
}

Referenced by test_BuildCommDCB().

test_ClearCommError()

static void test_ClearCommError ( void  )

static

Definition at line 988 of file comm.c.

{
    HANDLE hcom;
    DWORD  errors;
    COMSTAT lpStat;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(ClearCommError(hcom, &errors, &lpStat), "ClearCommError failed\n");
    ok(lpStat.cbInQue == 0, "Unexpected %d chars in InQueue\n", lpStat.cbInQue);
    ok(lpStat.cbOutQue == 0, "Unexpected %d chars in OutQueue\n", lpStat.cbOutQue);
    ok(errors == 0, "ClearCommErrors: Unexpected error 0x%08x\n", errors);
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_FlushFileBuffers()

static void test_FlushFileBuffers ( void  )

static

Definition at line 1995 of file comm.c.

{
    HANDLE hcom;
    DWORD  ret, bytes, errors;
    COMSTAT stat;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ret = WriteFile(hcom, "\0\0\0\0\0\0\0", 7, &bytes, NULL);
    ok(ret, "WriteFile error %d\n", GetLastError());
    ok(bytes == 7, "expected 7, got %u\n", bytes);
 
    ret = FlushFileBuffers(hcom);
    ok(ret, "FlushFileBuffers error %d\n", GetLastError());
 
    ret = ClearCommError(hcom, &errors, &stat);
    ok(ret, "ClearCommError error %d\n", GetLastError());
    ok(stat.cbInQue == 0, "expected 0, got %d bytes in InQueue\n", stat.cbInQue);
    ok(stat.cbOutQue == 0, "expected 0, got %d bytes in OutQueue\n", stat.cbOutQue);
    ok(errors == 0, "expected errors 0, got %#x\n", errors);
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_GetModemStatus()

static void test_GetModemStatus ( HANDLE  hcom )

static

Definition at line 736 of file comm.c.

{
    DWORD ModemStat = 0;
 
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    trace("GetCommModemStatus returned 0x%08x->%s%s%s%s\n", ModemStat,
      (ModemStat &MS_RLSD_ON)?"MS_RLSD_ON ":"",
      (ModemStat &MS_RING_ON)?"MS_RING_ON ":"",
      (ModemStat &MS_DSR_ON)?"MS_DSR_ON ":"",
      (ModemStat &MS_CTS_ON)?"MS_CTS_ON ":"");
}

Referenced by test_ReadTimeOut(), and test_WaitCommEvent().

test_LoopbackCtsRts()

static void test_LoopbackCtsRts ( void  )

static

Definition at line 1129 of file comm.c.

{
    HANDLE hcom;
    DWORD ModemStat = 0, defaultStat = 0;
    DCB dcb;
 
    if (!loopback_rts_cts) return;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    memset (&dcb, 0, sizeof (dcb));
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fRtsControl == RTS_CONTROL_HANDSHAKE)
    {
    trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate RTS\n");
    CloseHandle(hcom);
    return;
    }
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    /* XP returns some values in the low nibble, so mask them out*/
    defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
    if(defaultStat & MS_CTS_ON)
    {
    ok(EscapeCommFunction(hcom, CLRRTS), "EscapeCommFunction failed to clear RTS\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_CTS_ON) == 0, "CTS didn't react: 0x%04x,  expected 0x%04x\n",
        ModemStat, (defaultStat & ~MS_CTS_ON));
    ok(EscapeCommFunction(hcom, SETRTS), "EscapeCommFunction failed to clear RTS\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore CTS: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
    else
    {
    ok(EscapeCommFunction(hcom, SETRTS), "EscapeCommFunction failed to set RTS\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_CTS_ON) == MS_CTS_ON,
            "CTS didn't react: 0x%04x,  expected 0x%04x\n",
        ModemStat, (defaultStat | MS_CTS_ON));
    ok(EscapeCommFunction(hcom, CLRRTS), "EscapeCommFunction failed to clear RTS\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore CTS: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_LoopbackDtrDcd()

static void test_LoopbackDtrDcd ( void  )

static

Definition at line 1178 of file comm.c.

{
    HANDLE hcom;
    DWORD ModemStat = 0, defaultStat = 0;
    DCB dcb;
 
    if (!loopback_dtr_dcd) return;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == DTR_CONTROL_HANDSHAKE)
    {
    trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
        CloseHandle(hcom);
    return;
    }
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    /* XP returns some values in the low nibble, so mask them out*/
    defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
    if(defaultStat & MS_RLSD_ON)
    {
    ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_RLSD_ON) == 0, "RLSD didn't react: 0x%04x,  expected 0x%04x\n",
        ModemStat, (defaultStat & ~MS_RLSD_ON));
    ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore RLSD: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
    else
    {
    ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_RLSD_ON) == MS_RLSD_ON,
            "RLSD didn't react: 0x%04x,  expected 0x%04x\n",
        ModemStat, (defaultStat | MS_RLSD_ON));
    ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore RLSD: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_LoopbackDtrDsr()

static void test_LoopbackDtrDsr ( void  )

static

Definition at line 1226 of file comm.c.

{
    HANDLE hcom;
    DWORD ModemStat = 0, defaultStat = 0;
    DCB dcb;
 
    if (!loopback_dtr_dsr) return;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
    {
    trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
        CloseHandle(hcom);
    return;
    }
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    /* XP returns some values in the low nibble, so mask them out*/
    defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
    if(defaultStat & MS_DSR_ON)
    {
    ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_DSR_ON) == 0, "CTS didn't react: 0x%04x,  expected 0x%04x\n",
        ModemStat, (defaultStat & ~MS_DSR_ON));
    ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore DSR: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
    else
    {
    ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_DSR_ON) == MS_DSR_ON,
            "CTS didn't react: 0x%04x,expected 0x%04x\n",
        ModemStat, (defaultStat | MS_DSR_ON));
    ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore DSR: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_LoopbackDtrRing()

static void test_LoopbackDtrRing ( void  )

static

Definition at line 1274 of file comm.c.

{
    HANDLE hcom;
    DWORD ModemStat = 0, defaultStat = 0;
    DCB dcb;
 
    if (!loopback_dtr_ring) return;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == DTR_CONTROL_HANDSHAKE)
    {
    trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
    CloseHandle(hcom);
    return;
    }
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    /* XP returns some values in the low nibble, so mask them out*/
    defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
    if(defaultStat & MS_RING_ON)
    {
    ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_RING_ON) == 0, "RING didn't react: 0x%04x,  expected 0x%04x\n",
        ModemStat, (defaultStat & ~MS_RING_ON));
    ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore RING: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
    else
    {
    ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok ((ModemStat & MS_RING_ON) == MS_RING_ON,
            "RING didn't react: 0x%04x,expected 0x%04x\n",
        ModemStat, (defaultStat | MS_RING_ON));
    ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
    ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
    ok (ModemStat ==  defaultStat, "Failed to restore RING: 0x%04x, expected 0x%04x\n",
        ModemStat, defaultStat);
    }
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_LoopbackRead()

static void test_LoopbackRead ( void  )

static

Definition at line 1023 of file comm.c.

{
    HANDLE hcom;
    DCB dcb;
    COMMTIMEOUTS timeouts;
    char rbuf[32];
    DWORD before, after, diff, read, read1, written, evtmask=0, i;
    BOOL res;
    char tbuf[]="test_LoopbackRead";
 
    if (!loopback_txd_rxd) return;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    trace("Starting test_LoopbackRead\n");
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    dcb.BaudRate = FASTBAUD;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.fRtsControl=RTS_CONTROL_ENABLE;
    dcb.fDtrControl=DTR_CONTROL_ENABLE;
    dcb.StopBits = ONESTOPBIT;
    ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
 
    ZeroMemory( &timeouts, sizeof(timeouts));
    timeouts.ReadTotalTimeoutConstant = TIMEOUT;
    ok(SetCommTimeouts(hcom, &timeouts),"SetCommTimeouts failed\n");
 
    ok(SetCommMask(hcom, EV_TXEMPTY), "SetCommMask failed\n");
 
    before = GetTickCount();
    ok(WriteFile(hcom,tbuf,sizeof(tbuf),&written, NULL), "WriteFile failed\n");
    after = GetTickCount();
    ok(written == sizeof(tbuf),"WriteFile %d bytes written\n", written);
    diff = after -before;
 
    /* make sure all bytes are written, so Readfile will succeed in one call*/
    ok(WaitCommEvent(hcom, &evtmask, NULL), "WaitCommEvent failed\n");
    before = GetTickCount();
    ok(evtmask == EV_TXEMPTY,
                 "WaitCommEvent: Unexpected EvtMask 0x%08x, expected 0x%08x\n",
         evtmask, EV_TXEMPTY);
    trace("Write %d ms WaitCommEvent EV_TXEMPTY %d ms\n", diff, before- after);
 
    read=0;
    ok(ReadFile(hcom, rbuf, sizeof(rbuf), &read, NULL), "Readfile failed\n");
    ok(read == sizeof(tbuf),"ReadFile read %d bytes, expected \"%s\"\n", read,rbuf);
 
    /* Now do the same with a slower Baud rate.
       As we request more characters than written, we will hit the timeout
    */
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    dcb.BaudRate = 9600;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.fRtsControl=RTS_CONTROL_ENABLE;
    dcb.fDtrControl=DTR_CONTROL_ENABLE;
    dcb.StopBits = ONESTOPBIT;
    ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
 
    ok(SetCommMask(hcom, EV_RXCHAR), "SetCommMask failed\n");
    ok(WriteFile(hcom,tbuf,sizeof(tbuf),&written, NULL), "WriteFile failed\n");
    ok(written == sizeof(tbuf),"WriteFile %d bytes written\n", written);
 
    trace("WaitCommEventEV_RXCHAR\n");
    ok(WaitCommEvent(hcom, &evtmask, NULL), "WaitCommEvent failed\n");
    ok(evtmask == EV_RXCHAR, "WaitCommEvent: Unexpected EvtMask 0x%08x, expected 0x%08x\n",
       evtmask, EV_RXCHAR);
 
    before = GetTickCount();
    res = ReadFile(hcom, rbuf, sizeof(rbuf), &read, NULL);
    after = GetTickCount();
    ok(res, "Readfile failed\n");
    ok(read == sizeof(tbuf),"ReadFile read %d bytes\n", read);
    diff = after - before;
    trace("Readfile for %d chars took %d ms\n", read, diff);
    ok( (diff > TIMEOUT - TIMEDELTA) && (diff < TIMEOUT + TIMEDELTA),
    "Timedout Wait took %d ms, expected around %d\n", diff, TIMEOUT);
 
    /* now do a plain read with slow speed
     * This will result in several low level reads and a timeout to happen
     */
    dcb.BaudRate = SLOWBAUD;
    ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
    ok(WriteFile(hcom,tbuf,sizeof(tbuf),&written, NULL), "WriteFile failed\n");
    before = GetTickCount();
    read = 0;
    read1 =0;
    i=0;
    do 
    {
    res = ReadFile(hcom, rbuf+read, sizeof(rbuf)-read, &read1, NULL);
    ok(res, "Readfile failed\n");
    read += read1;
    i++;
    }
    while ((read < sizeof(tbuf)) && (i <10));
    after =  GetTickCount();
    ok( read == sizeof(tbuf),"ReadFile read %d bytes\n", read);
    trace("Plain Read for %d char at %d baud took %d ms\n", read, SLOWBAUD, after-before);
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_non_pending_errors()

static void test_non_pending_errors ( void  )

static

Definition at line 1005 of file comm.c.

{
    HANDLE hcom;
    DCB dcb;
    DWORD err;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    dcb.ByteSize = 255; /* likely bogus */
    ok(!SetCommState(hcom, &dcb), "SetCommState should have failed\n");
    ok(ClearCommError(hcom, &err, NULL), "ClearCommError should succeed\n");
    ok(!(err & CE_MODE), "ClearCommError shouldn't set CE_MODE byte in this case (%x)\n", err);
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_OpenComm()

static HANDLE test_OpenComm ( BOOL  doOverlap )

static

Definition at line 689 of file comm.c.

{
    HANDLE hcom = INVALID_HANDLE_VALUE;
    char port_name[] = "COMx";
    static BOOL shown = FALSE;
    DWORD errors;
    COMSTAT comstat;
 
    /* Try to find a port */
    for(port_name[3] = '1'; port_name[3] <= '9'; port_name[3]++)
    {
    hcom = CreateFileA( port_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
               (doOverlap)?FILE_FLAG_OVERLAPPED:0, NULL );
    if (hcom != INVALID_HANDLE_VALUE)
        break;
    }
    if(!shown)
    {
    if (hcom == INVALID_HANDLE_VALUE)
        trace("Could not find a valid COM port.\n");
    else
        trace("Found Com port %s. Connected devices may disturb results\n", port_name);
    /*shown = TRUE; */
    }
    if (hcom != INVALID_HANDLE_VALUE)
    {
        BOOL ret;
 
        ret = ClearCommError(hcom, &errors, &comstat);
        if (!ret && (GetLastError() == ERROR_NOT_READY || GetLastError() == ERROR_INVALID_HANDLE))
        {
            if (GetLastError() == ERROR_NOT_READY)
                trace("%s doesn't respond, skipping the test\n", port_name);
            else
                trace("%s is not a real serial port, skipping the test\n", port_name);
            CloseHandle(hcom);
            return INVALID_HANDLE_VALUE;
        }
 
        ok(ret, "Unexpected error %u on open\n", GetLastError());
        ok(comstat.cbInQue == 0, "Unexpected %d chars in InQueue\n",comstat.cbInQue);
        ok(comstat.cbOutQue == 0, "Still pending %d charcters in OutQueue\n", comstat.cbOutQue);
        ok(errors == 0, "Unexpected errors 0x%08x\n", errors);
    }
    return hcom;
}

Referenced by test_AbortWaitCts(), test_ClearCommError(), test_FlushFileBuffers(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), test_LoopbackRead(), test_non_pending_errors(), test_read_write(), test_ReadTimeOut(), test_WaitBreak(), test_WaitCommEvent(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), test_WaitRx(), and test_waittxempty().

test_read_write()

static void test_read_write ( void  )

static

Definition at line 2020 of file comm.c.

{
    static const char atz[]="ATZ\r\n";
    char buf[256];
    HANDLE hcom;
    DCB dcb;
    COMMTIMEOUTS timeouts;
    DWORD ret, bytes, status, evtmask, before, after, last_event_time;
    OVERLAPPED ovl_wait;
    IO_STATUS_BLOCK iob;
    LARGE_INTEGER offset;
    LONG i;
 
    if (!pNtReadFile || !pNtWriteFile)
    {
        win_skip("not running on NT, skipping test\n");
        return;
    }
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ret = GetCommState(hcom, &dcb);
    ok(ret, "GetCommState error %d\n", GetLastError());
    dcb.BaudRate = 9600;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.fRtsControl = RTS_CONTROL_ENABLE;
    dcb.fDtrControl = DTR_CONTROL_ENABLE;
    dcb.StopBits = ONESTOPBIT;
    ret = SetCommState(hcom, &dcb);
    ok(ret, "SetCommState error %d\n", GetLastError());
 
    memset(&timeouts, 0, sizeof(timeouts));
    timeouts.ReadTotalTimeoutConstant = TIMEOUT;
    ret = SetCommTimeouts(hcom, &timeouts);
    ok(ret,"SetCommTimeouts error %d\n", GetLastError());
 
    ret = SetupComm(hcom, 1024, 1024);
    ok(ret, "SetUpComm error %d\n", GetLastError());
 
    bytes = 0xdeadbeef;
    SetLastError(0xdeadbeef);
    ret = WriteFile(hcom, atz, 0, &bytes, NULL);
    ok(!ret, "WriteFile should fail\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
    ok(bytes == 0, "bytes %u\n", bytes);
 
    U(iob).Status = -1;
    iob.Information = -1;
    status = pNtWriteFile(hcom, 0, NULL, NULL, &iob, atz, 0, NULL, NULL);
    ok(status == STATUS_INVALID_PARAMETER, "expected STATUS_INVALID_PARAMETER, got %#x\n", status);
    ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status);
    ok(iob.Information == -1, "expected -1, got %ld\n", iob.Information);
 
    for (i = -20; i < 20; i++)
    {
        U(iob).Status = -1;
        iob.Information = -1;
        offset.QuadPart = (LONGLONG)i;
        status = pNtWriteFile(hcom, 0, NULL, NULL, &iob, atz, 0, &offset, NULL);
        if (i >= 0 || i == -1)
        {
            ok(status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, status);
            ok(U(iob).Status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, U(iob).Status);
            ok(iob.Information == 0, "%d: expected 0, got %lu\n", i, iob.Information);
        }
        else
        {
            ok(status == STATUS_INVALID_PARAMETER, "%d: expected STATUS_INVALID_PARAMETER, got %#x\n", i, status);
            ok(U(iob).Status == -1, "%d: expected -1, got %#x\n", i, U(iob).Status);
            ok(iob.Information == -1, "%d: expected -1, got %ld\n", i, iob.Information);
        }
    }
 
    U(iob).Status = -1;
    iob.Information = -1;
    offset.QuadPart = 0;
    status = pNtWriteFile(hcom, 0, NULL, NULL, &iob, atz, sizeof(atz), &offset, NULL);
    ok(status == STATUS_PENDING || status == STATUS_SUCCESS, "expected STATUS_PENDING or STATUS_SUCCESS, got %#x\n", status);
    /* Under Windows checking IO_STATUS_BLOCK right after the call leads
     * to races, iob.Status is either -1 or STATUS_SUCCESS, which means
     * that it's set only when the operation completes.
     */
    ret = WaitForSingleObject(hcom, TIMEOUT);
    if (ret == WAIT_TIMEOUT)
    {
        skip("Probably modem is not connected.\n");
        CloseHandle(hcom);
        return;
    }
    ok(ret == WAIT_OBJECT_0, "WaitForSingleObject error %d\n", ret);
    ok(U(iob).Status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x\n", U(iob).Status);
    ok(iob.Information == sizeof(atz), "expected sizeof(atz), got %lu\n", iob.Information);
 
    ret = SetCommMask(hcom, EV_RXCHAR);
    ok(ret, "SetCommMask error %d\n", GetLastError());
 
    S(U(ovl_wait)).Offset = 0;
    S(U(ovl_wait)).OffsetHigh = 0;
    ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 
    trace("waiting 3 secs for modem response...\n");
    last_event_time = 0;
    before = GetTickCount();
    do
    {
        evtmask = 0;
        SetLastError(0xdeadbeef);
        ret = WaitCommEvent(hcom, &evtmask, &ovl_wait);
        ok(!ret && GetLastError() == ERROR_IO_PENDING, "WaitCommEvent returned %d, error %d\n", ret, GetLastError());
        if (GetLastError() != ERROR_IO_PENDING) goto done; /* no point in further testing */
        for (;;)
        {
            ret = WaitForSingleObject(ovl_wait.hEvent, 100);
            after = GetTickCount();
            if (ret == WAIT_OBJECT_0)
            {
                trace("got modem response.\n");
 
                last_event_time = after;
                ret = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
                ok(ret, "GetOverlappedResult reported error %d\n", GetLastError());
                ok(bytes == sizeof(evtmask), "expected sizeof(evtmask), got %u\n", bytes);
                ok(evtmask & EV_RXCHAR, "EV_RXCHAR should be set\n");
 
                bytes = 0xdeadbeef;
                SetLastError(0xdeadbeef);
                ret = ReadFile(hcom, buf, 0, &bytes, NULL);
                ok(!ret, "ReadFile should fail\n");
                ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
                ok(bytes == 0, "bytes %u\n", bytes);
 
                U(iob).Status = -1;
                iob.Information = -1;
                status = pNtReadFile(hcom, 0, NULL, NULL, &iob, buf, 0, NULL, NULL);
                ok(status == STATUS_INVALID_PARAMETER, "expected STATUS_INVALID_PARAMETER, got %#x\n", status);
                ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status);
                ok(iob.Information == -1, "expected -1, got %ld\n", iob.Information);
 
                for (i = -20; i < 20; i++)
                {
                    U(iob).Status = -1;
                    iob.Information = -1;
                    offset.QuadPart = (LONGLONG)i;
                    status = pNtReadFile(hcom, 0, NULL, NULL, &iob, buf, 0, &offset, NULL);
                    if (i >= 0)
                    {
                        ok(status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, status);
                        ok(U(iob).Status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, U(iob).Status);
                        ok(iob.Information == 0, "%d: expected 0, got %lu\n", i, iob.Information);
                    }
                    else
                    {
                        ok(status == STATUS_INVALID_PARAMETER, "%d: expected STATUS_INVALID_PARAMETER, got %#x\n", i, status);
                        ok(U(iob).Status == -1, "%d: expected -1, got %#x\n", i, U(iob).Status);
                        ok(iob.Information == -1, "%d: expected -1, got %ld\n", i, iob.Information);
                    }
                }
 
                U(iob).Status = -1;
                iob.Information = -1;
                offset.QuadPart = 0;
                status = pNtReadFile(hcom, 0, NULL, NULL, &iob, buf, 1, &offset, NULL);
                ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x\n", status);
                ok(U(iob).Status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x\n", U(iob).Status);
                ok(iob.Information == 1, "expected 1, got %lu\n", iob.Information);
                goto done;
            }
            else
            {
                if (last_event_time || after - before >= 3000) goto done;
            }
        }
    } while (after - before < 3000);
 
done:
    CloseHandle(ovl_wait.hEvent);
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_ReadTimeOut()

static void test_ReadTimeOut ( void  )

static

Definition at line 749 of file comm.c.

{
    HANDLE hcom;
    DCB dcb;
    COMMTIMEOUTS timeouts;
    char rbuf[32];
    DWORD before, after, read, timediff, LastError;
    BOOL res;
 
    hcom = test_OpenComm(FALSE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    test_GetModemStatus(hcom);
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    dcb.BaudRate = FASTBAUD;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.fRtsControl=RTS_CONTROL_ENABLE;
    dcb.fDtrControl=DTR_CONTROL_ENABLE;
    dcb.StopBits = ONESTOPBIT;
    ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
 
    ZeroMemory( &timeouts, sizeof(timeouts));
    timeouts.ReadTotalTimeoutConstant = TIMEOUT;
    ok(SetCommTimeouts(hcom, &timeouts),"SetCommTimeouts failed\n");
 
    before = GetTickCount();
    SetLastError(0xdeadbeef);
    res = ReadFile(hcom, rbuf, sizeof(rbuf), &read, NULL);
    LastError = GetLastError();
    after = GetTickCount();
    ok( res == TRUE, "A timed-out read should return TRUE\n");
    ok( LastError == 0xdeadbeef, "err=%d\n", LastError);
    timediff = after - before;
    ok( timediff > TIMEOUT>>2 && timediff < TIMEOUT *2,
    "Unexpected TimeOut %d, expected %d\n", timediff, TIMEOUT);
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_stdio()

static void test_stdio ( void  )

static

Definition at line 1931 of file comm.c.

{
    DCB dcb;
 
    /* cygwin tries this to determine the stdin handle type */
    ok( !GetCommState( GetStdHandle(STD_INPUT_HANDLE), &dcb ), "GetCommState succeeded on stdin\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE || GetLastError() == ERROR_INVALID_FUNCTION,
        "got error %u\n", GetLastError() );
}

Referenced by START_TEST().

test_WaitBreak()

static void test_WaitBreak ( void  )

static

Definition at line 1869 of file comm.c.

{
    OVERLAPPED overlapped;
    HANDLE hcom, hComPortEvent, alarmThread;
    DWORD_PTR args[2];
    DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0;
 
    if (!loopback_txd_rxd) return;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(SetCommMask(hcom, EV_BREAK), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
 
    trace("test_WaitBreak\n");
    args[0]= TIMEOUT >>1;
    args[1]= (DWORD_PTR)hcom;
    alarmThread = CreateThread(NULL, 0, set_CommBreak, args, 0, &alarmThreadId);
    /* Wait a minimum to let the thread start up */
    Sleep(10);
    trace("Thread created\n");
    ok(alarmThread !=0 , "CreateThread Failed\n");
 
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
    before = GetTickCount();
    success = WaitCommEvent(hcom, &evtmask, &overlapped);
    err = GetLastError();
    after = GetTickCount();
 
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
    ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
 
    if (!success && (err == ERROR_IO_PENDING))
    {
        success = WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE);
        ok(!success, "wait hComPortEvent res %d\n", GetLastError());
    }
    success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success, err, evtmask, after-before, after1-before);
 
    ok(evtmask & EV_BREAK, "Failed to detect  EV_BREAK: 0x%08x, expected 0x%08x\n",
       evtmask, EV_BREAK);
    ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
 
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
    "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    ok(ClearCommBreak(hcom), "ClearCommBreak failed\n");
 
    CloseHandle(hcom);
    ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
    CloseHandle( alarmThread );
}

Referenced by START_TEST().

test_WaitCommEvent()

static void test_WaitCommEvent ( void  )

static

Definition at line 1941 of file comm.c.

{
    HANDLE hcom;
    DWORD evtmask, ret, bytes, before, after, last_event_time;
    OVERLAPPED ovl_wait;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    test_GetModemStatus(hcom);
 
    ret = SetCommMask(hcom, 0x1fff);
    ok(ret, "SetCommMask error %d\n", GetLastError());
 
    S(U(ovl_wait)).Offset = 0;
    S(U(ovl_wait)).OffsetHigh = 0;
    ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 
    trace("waiting 10 secs for com port events (turn on/off the device)...\n");
    last_event_time = 0;
    before = GetTickCount();
    do
    {
        evtmask = 0;
        SetLastError(0xdeadbeef);
        ret = WaitCommEvent(hcom, &evtmask, &ovl_wait);
        ok(!ret && GetLastError() == ERROR_IO_PENDING, "WaitCommEvent returned %d, error %d\n", ret, GetLastError());
        if (GetLastError() != ERROR_IO_PENDING) goto done; /* no point in further testing */
        for (;;)
        {
            ret = WaitForSingleObject(ovl_wait.hEvent, 500);
            after = GetTickCount();
            if (ret == WAIT_OBJECT_0)
            {
                last_event_time = after;
                ret = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
                ok(ret, "GetOverlappedResult reported error %d\n", GetLastError());
                ok(bytes == sizeof(evtmask), "expected %u, written %u\n", (UINT)sizeof(evtmask), bytes);
                trace("WaitCommEvent: got events %#x\n", evtmask);
                test_GetModemStatus(hcom);
                break;
            }
            else
            {
                if (last_event_time || after - before >= 10000) goto done;
            }
        }
    } while (after - before < 10000);
 
done:
    CloseHandle(ovl_wait.hEvent);
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_WaitCts()

static void test_WaitCts ( void  )

static

Definition at line 1428 of file comm.c.

{
    DCB dcb;
    OVERLAPPED overlapped;
    HANDLE hcom, hComPortEvent, alarmThread;
    DWORD_PTR args[4];
    DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat = 0;
 
    if (!loopback_rts_cts) return;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    dcb.fRtsControl=RTS_CONTROL_ENABLE;
    dcb.fDtrControl=DTR_CONTROL_ENABLE;
    ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
    if (dcb.fDtrControl == RTS_CONTROL_DISABLE)
    {
    trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
        CloseHandle(hcom);
    return;
    }
    args[0]= TIMEOUT >>1;
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    if(defaultStat & MS_CTS_ON)
    args[1] = CLRRTS;
    else
    args[1] = SETRTS;
    args[2]=(DWORD_PTR)hcom;
 
    trace("test_WaitCts timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
 
    ok(SetCommMask(hcom, EV_CTS), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
    args[3] = (DWORD_PTR)hComPortEvent;
    alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
    /* Wait a minimum to let the thread start up */
    Sleep(10);
    trace("Thread created\n");
    ok(alarmThread !=0 , "CreateThread Failed\n");
 
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
    before = GetTickCount();
    success = WaitCommEvent(hcom, &evtmask, &overlapped);
    err = GetLastError();
    after = GetTickCount();
 
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
    ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
    if (!success && (err == ERROR_IO_PENDING))
    ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
             "WaitCts hComPortEvent failed\n");
    success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success, err, evtmask, after-before, after1-before);
 
    ok(evtmask & EV_CTS, "Failed to detect  EV_CTS: 0x%08x, expected 0x%08x\n",
         evtmask, EV_CTS);
    ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
    if(defaultStat & MS_CTS_ON)
    ok((evtmask & MS_CTS_ON) == 0,"CTS didn't change state!\n");
    else
    ok((evtmask & MS_CTS_ON), "CTS didn't change state!\n");
 
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
                  "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    /*restore RTS Settings*/
    if(defaultStat & MS_CTS_ON)
    args[1] = SETRTS;
    else
    args[1] = CLRRTS;
 
    CloseHandle(hcom);
    ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
    CloseHandle( alarmThread );
}

Referenced by START_TEST().

test_WaitDcd()

static void test_WaitDcd ( void  )

static

Definition at line 1770 of file comm.c.

{
    DCB dcb;
    OVERLAPPED overlapped;
    HANDLE hcom, hComPortEvent, alarmThread;
    DWORD_PTR args[3];
    DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat = 0;
 
    if (!loopback_dtr_dcd) return;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
    {
    trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
    CloseHandle(hcom);
    return;
    }
    args[0]= TIMEOUT >>1;
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    if(defaultStat & MS_RLSD_ON)
    args[1] = CLRDTR;
    else
    args[1] = SETDTR;
    args[2]= (DWORD_PTR)hcom;
 
    trace("test_WaitDcd timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
 
    ok(SetCommMask(hcom, EV_RLSD), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
    alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
    ok(alarmThread !=0 , "CreateThread Failed\n");
 
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
    before = GetTickCount();
    success = WaitCommEvent(hcom, &evtmask, &overlapped);
    err = GetLastError();
    after = GetTickCount();
 
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
    ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
    if (!success && (err == ERROR_IO_PENDING))
    ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
             "wait hComPortEvent failed\n");
    success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success, err, evtmask, after-before, after1-before);
 
    ok(evtmask & EV_RLSD, "Failed to detect  EV_RLSD: 0x%08x, expected 0x%08x\n",
         evtmask, EV_RLSD);
    ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
    if(defaultStat & MS_RLSD_ON)
    ok((evtmask & MS_RLSD_ON) == 0,"DTR didn't change state!\n");
    else
    ok((evtmask & MS_RLSD_ON), "DTR didn't change state!\n");
 
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
                  "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    /*restore RTS Settings*/
    if(defaultStat & MS_RLSD_ON)
    args[1] = SETDTR;
    else
    args[1] = CLRDTR;
 
    CloseHandle(hcom);
    ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
    CloseHandle( alarmThread );
}

Referenced by START_TEST().

test_WaitDsr()

static void test_WaitDsr ( void  )

static

Definition at line 1601 of file comm.c.

{
    DCB dcb;
    OVERLAPPED overlapped;
    HANDLE hcom, hComPortEvent, alarmThread;
    DWORD_PTR args[3];
    DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat = 0;
 
    if (!loopback_dtr_dsr) return;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
    {
    trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
        CloseHandle(hcom);
    return;
    }
    args[0]= TIMEOUT >>1;
    ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
    if(defaultStat & MS_DSR_ON)
    args[1] = CLRDTR;
    else
    args[1] = SETDTR;
    args[2]= (DWORD_PTR)hcom;
 
    trace("test_WaitDsr timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
 
    ok(SetCommMask(hcom, EV_DSR), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
    alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
    ok(alarmThread !=0 , "CreateThread Failed\n");
 
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
    before = GetTickCount();
    success = WaitCommEvent(hcom, &evtmask, &overlapped);
    err = GetLastError();
    after = GetTickCount();
 
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
    ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
    if (!success && (err == ERROR_IO_PENDING))
    ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
             "wait hComPortEvent failed\n");
    success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success, err, evtmask, after-before, after1-before);
 
    ok(evtmask & EV_DSR, "Failed to detect  EV_DSR: 0x%08x, expected 0x%08x\n",
         evtmask, EV_DSR);
    ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
    if(defaultStat & MS_DSR_ON)
    ok((evtmask & MS_DSR_ON) == 0,"DTR didn't change state!\n");
    else
    ok((evtmask & MS_DSR_ON), "DTR didn't change state!\n");
 
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
                  "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    /*restore RTS Settings*/
    if(defaultStat & MS_DSR_ON)
    args[1] = SETDTR;
    else
    args[1] = CLRDTR;
 
    CloseHandle(hcom);
    ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
    CloseHandle( alarmThread );
}

Referenced by START_TEST().

test_WaitRing()

static void test_WaitRing ( void  )

static

Definition at line 1683 of file comm.c.

{
    DCB dcb;
    OVERLAPPED overlapped;
    HANDLE hcom, hComPortEvent, alarmThread;
    DWORD_PTR args[3];
    DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat;
    BOOL ret;
 
    if (!loopback_dtr_ring) return;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
    if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
    {
    trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
        CloseHandle(hcom);
    return;
    }
    args[0]= TIMEOUT >>1;
    ok((ret = GetCommModemStatus(hcom, &defaultStat)), "GetCommModemStatus failed\n");
    if (!ret) {
    skip("modem status failed -> skip.\n");
    CloseHandle(hcom);
    return;
    }
    if(defaultStat & MS_RING_ON)
    args[1] = CLRDTR;
    else
    args[1] = SETDTR;
    args[2]=(DWORD_PTR) hcom;
 
    trace("test_WaitRing timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
 
    ok(SetCommMask(hcom, EV_RING), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
    alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
    ok(alarmThread !=0 , "CreateThread Failed\n");
 
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
    before = GetTickCount();
    success = WaitCommEvent(hcom, &evtmask, &overlapped);
    err = GetLastError();
    after = GetTickCount();
 
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
    ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
    if (!success && (err == ERROR_IO_PENDING))
    ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
             "wait hComPortEvent failed\n");
    success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success, err, evtmask, after-before, after1-before);
 
    ok(evtmask & EV_RING, "Failed to detect  EV_RING: 0x%08x, expected 0x%08x\n",
       evtmask, EV_RING);
    ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
    if(defaultStat & MS_RING_ON)
    ok((evtmask & MS_RING_ON) == 0,"DTR didn't change state!\n");
    else
    ok((evtmask & MS_RING_ON), "DTR didn't change state!\n");
 
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
                  "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    /*restore RTS Settings*/
    if(defaultStat & MS_RING_ON)
    args[1] = SETDTR;
    else
    args[1] = CLRDTR;
 
    CloseHandle(hcom);
    ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
    CloseHandle( alarmThread );
}

Referenced by START_TEST().

test_WaitRx()

static void test_WaitRx ( void  )

static

Definition at line 1329 of file comm.c.

{
    OVERLAPPED overlapped, overlapped_w;
    HANDLE hcom, hComPortEvent, hComWriteEvent;
    DWORD before, after, after1, diff, success_wait = FALSE, success_write;
    DWORD err_wait, err_write, written, evtmask=0;
 
    if (!loopback_txd_rxd) return;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    ok(SetCommMask(hcom, EV_RXCHAR), "SetCommMask failed\n");
    hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComPortEvent != 0, "CreateEvent failed\n");
    ZeroMemory( &overlapped, sizeof(overlapped));
    overlapped.hEvent = hComPortEvent;
 
    hComWriteEvent = CreateEventW( NULL, TRUE, FALSE, NULL );
    ok(hComWriteEvent != NULL, "CreateEvent res %d\n", GetLastError());
    ZeroMemory( &overlapped_w, sizeof(overlapped_w));
    overlapped_w.hEvent = hComWriteEvent;
 
    before = GetTickCount();
    success_wait = WaitCommEvent(hcom, &evtmask, &overlapped);
    err_wait = GetLastError();
    after = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x\n", success_wait, err_wait, evtmask);
    ok(success_wait || err_wait == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
    trace("overlapped WaitCommEvent returned.\n");
 
    success_write= WriteFile(hcom, "X", 1, &written, &overlapped_w);
    err_write = GetLastError();
    ok(success_write || err_write == ERROR_IO_PENDING,
       "overlapped WriteFile failed, err %d\n",
       err_write);
 
    if (!success_write && (err_write == ERROR_IO_PENDING)) {
      success_write = WaitForSingleObjectEx(hComWriteEvent, TIMEOUT, TRUE);
      err_write = GetLastError();
      ok(success_write == WAIT_OBJECT_0, "WaitForSingleObjectEx, res %d, err %d\n",
     success_write, err_write);
    }
    Sleep(TIMEOUT >>1);
    success_write = GetOverlappedResult(hcom, &overlapped_w, &written, FALSE);
    err_write = GetLastError();
 
    trace("Write after Wait res 0x%08x err %d\n",success_write, err_write);
    ok(success_write && written ==1, "Write after Wait res 0x%08x err %d\n",
       success_write, err_write);
 
    if (!success_wait && (err_wait == ERROR_IO_PENDING)) {
      success_wait = WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE);
      err_wait = GetLastError();
      ok(success_wait == WAIT_OBJECT_0, "wait hComPortEvent, res 0x%08x, err %d\n",
     success_wait, err_wait);
    }
    success_wait = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
    err_wait = GetLastError();
    after1 = GetTickCount();
    trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
      success_wait, err_wait, evtmask, after-before, after1-before);
 
    ok(evtmask & EV_RXCHAR, "Detect  EV_RXCHAR: 0x%08x, expected 0x%08x\n",
       evtmask, EV_RXCHAR);
    diff = after1 - before;
    ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
    "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
 
    CloseHandle(hcom);
}

Referenced by START_TEST().

test_waittxempty()

static void test_waittxempty ( void  )

static

Definition at line 790 of file comm.c.

{
    HANDLE hcom;
    DCB dcb;
    COMMTIMEOUTS timeouts;
    char tbuf[]="test_waittxempty";
    DWORD before, after, bytes, timediff, evtmask, errors, i;
    BOOL res;
    DWORD baud = SLOWBAUD;
    OVERLAPPED ovl_write, ovl_wait, ovl_wait2;
    COMSTAT stat;
 
    hcom = test_OpenComm(TRUE);
    if (hcom == INVALID_HANDLE_VALUE) return;
 
    /* set a low baud rate to have ample time*/
    res = GetCommState(hcom, &dcb);
    ok(res, "GetCommState error %d\n", GetLastError());
    dcb.BaudRate = baud;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.fRtsControl=RTS_CONTROL_ENABLE;
    dcb.fDtrControl=DTR_CONTROL_ENABLE;
    dcb.StopBits = ONESTOPBIT;
    res = SetCommState(hcom, &dcb);
    ok(res, "SetCommState error %d\n", GetLastError());
 
    ZeroMemory( &timeouts, sizeof(timeouts));
    timeouts.ReadTotalTimeoutConstant = TIMEOUT;
    res = SetCommTimeouts(hcom, &timeouts);
    ok(res,"SetCommTimeouts error %d\n", GetLastError());
 
    res = SetupComm(hcom, 1024, 1024);
    ok(res, "SetUpComm error %d\n", GetLastError());
 
    /* calling SetCommMask after WriteFile leads to WaitCommEvent failures
     * due to timeout (no events) under testbot VMs and VirtualBox
     */
    res = SetCommMask(hcom, EV_TXEMPTY);
    ok(res, "SetCommMask error %d\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    res = WriteFile(hcom, tbuf, sizeof(tbuf), &bytes, NULL);
    ok(!res, "WriteFile on an overlapped handle without ovl structure should fail\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 
    S(U(ovl_write)).Offset = 0;
    S(U(ovl_write)).OffsetHigh = 0;
    ovl_write.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
    before = GetTickCount();
    SetLastError(0xdeadbeef);
    res = WriteFile(hcom, tbuf, sizeof(tbuf), &bytes, &ovl_write);
    after = GetTickCount();
    ok((!res && GetLastError() == ERROR_IO_PENDING) || (res && bytes == sizeof(tbuf)),
       "WriteFile returned %d, written %u bytes, error %d\n", res, bytes, GetLastError());
    if (!res) ok(!bytes, "expected 0, got %u\n", bytes);
    ok(after - before < 30, "WriteFile took %d ms to write %d Bytes at %d Baud\n",
       after - before, bytes, baud);
    /* don't wait for WriteFile completion */
 
    S(U(ovl_wait)).Offset = 0;
    S(U(ovl_wait)).OffsetHigh = 0;
    ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
    evtmask = 0;
    before = GetTickCount();
    SetLastError(0xdeadbeef);
    res = WaitCommEvent(hcom, &evtmask, &ovl_wait);
    ok(!res && GetLastError() == ERROR_IO_PENDING, "WaitCommEvent error %d\n", GetLastError());
    after = GetTickCount();
    ok(after - before < 30, "WaitCommEvent should have returned immediately, took %d ms\n", after - before);
    res = WaitForSingleObject(ovl_wait.hEvent, 1500);
    ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
    if (res == WAIT_OBJECT_0)
    {
        res = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
        ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
        ok(bytes == sizeof(evtmask), "expected %u, written %u\n", (UINT)sizeof(evtmask), bytes);
        res = TRUE;
    }
    else
    {
        /* unblock pending wait */
        trace("recovering after WAIT_TIMEOUT...\n");
        res = SetCommMask(hcom, EV_TXEMPTY);
        ok(res, "SetCommMask error %d\n", GetLastError());
 
        res = WaitForSingleObject(ovl_wait.hEvent, TIMEOUT);
        ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
 
        res = FALSE;
    }
    after = GetTickCount();
    ok(res, "WaitCommEvent error %d\n", GetLastError());
    ok(evtmask & EV_TXEMPTY, "WaitCommEvent: expected EV_TXEMPTY, got %#x\n", evtmask);
    CloseHandle(ovl_wait.hEvent);
 
    timediff = after - before;
    trace("WaitCommEvent for EV_TXEMPTY took %d ms (timeout 1500)\n", timediff);
    ok(timediff < 1200, "WaitCommEvent used %d ms for waiting\n", timediff);
 
    res = WaitForSingleObject(ovl_write.hEvent, 0);
    ok(res == WAIT_OBJECT_0, "WriteFile failed with a timeout\n");
    res = GetOverlappedResult(hcom, &ovl_write, &bytes, FALSE);
    ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
    ok(bytes == sizeof(tbuf), "expected %u, written %u\n", (UINT)sizeof(tbuf), bytes);
    CloseHandle(ovl_write.hEvent);
 
    CloseHandle(hcom);
 
    for (i = 0; i < 2; i++)
    {
        hcom = test_OpenComm(TRUE);
        if (hcom == INVALID_HANDLE_VALUE) return;
 
        res = SetCommMask(hcom, EV_TXEMPTY);
        ok(res, "SetCommMask error %d\n", GetLastError());
 
        if (i == 0)
        {
            S(U(ovl_write)).Offset = 0;
            S(U(ovl_write)).OffsetHigh = 0;
            ovl_write.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
            before = GetTickCount();
            SetLastError(0xdeadbeef);
            res = WriteFile(hcom, tbuf, sizeof(tbuf), &bytes, &ovl_write);
            ok((!res && GetLastError() == ERROR_IO_PENDING) || (res && bytes == sizeof(tbuf)),
               "WriteFile returned %d, written %u bytes, error %d\n", res, bytes, GetLastError());
            if (!res) ok(!bytes, "expected 0, got %u\n", bytes);
 
            ClearCommError(hcom, &errors, &stat);
            ok(stat.cbInQue == 0, "InQueue should be empty, got %d bytes\n", stat.cbInQue);
            ok(stat.cbOutQue != 0 || broken(stat.cbOutQue == 0) /* VM */, "OutQueue should not be empty\n");
            ok(errors == 0, "ClearCommErrors: Unexpected error 0x%08x\n", errors);
 
            res = GetOverlappedResult(hcom, &ovl_write, &bytes, TRUE);
            ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
            ok(bytes == sizeof(tbuf), "expected %u, written %u\n", (UINT)sizeof(tbuf), bytes);
            CloseHandle(ovl_write.hEvent);
 
            res = FlushFileBuffers(hcom);
            ok(res, "FlushFileBuffers error %d\n", GetLastError());
        }
 
        ClearCommError(hcom, &errors, &stat);
        ok(stat.cbInQue == 0, "InQueue should be empty, got %d bytes\n", stat.cbInQue);
        ok(stat.cbOutQue == 0, "OutQueue should be empty, got %d bytes\n", stat.cbOutQue);
        ok(errors == 0, "ClearCommErrors: Unexpected error 0x%08x\n", errors);
 
        S(U(ovl_wait)).Offset = 0;
        S(U(ovl_wait)).OffsetHigh = 0;
        ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
        evtmask = 0;
        SetLastError(0xdeadbeef);
        res = WaitCommEvent(hcom, &evtmask, &ovl_wait);
        ok(res /* busy system */ || GetLastError() == ERROR_IO_PENDING,
           "%d: WaitCommEvent error %d\n", i, GetLastError());
 
        res = WaitForSingleObject(ovl_wait.hEvent, TIMEOUT);
        if (i == 0)
            ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
        else
            ok(res == WAIT_TIMEOUT, "WaitCommEvent should fail with a timeout\n");
        if (res == WAIT_OBJECT_0)
        {
            res = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
            ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
            ok(bytes == sizeof(evtmask), "expected %u, written %u\n", (UINT)sizeof(evtmask), bytes);
            ok(res, "WaitCommEvent error %d\n", GetLastError());
            ok(evtmask & EV_TXEMPTY, "WaitCommEvent: expected EV_TXEMPTY, got %#x\n", evtmask);
        }
        else
        {
            ok(!evtmask, "WaitCommEvent: expected 0, got %#x\n", evtmask);
 
            S(U(ovl_wait2)).Offset = 0;
            S(U(ovl_wait2)).OffsetHigh = 0;
            ovl_wait2.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
            SetLastError(0xdeadbeef);
            res = WaitCommEvent(hcom, &evtmask, &ovl_wait2);
            ok(!res, "WaitCommEvent should fail if there is a pending wait\n");
            ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
            CloseHandle(ovl_wait2.hEvent);
 
            /* unblock pending wait */
            trace("recovering after WAIT_TIMEOUT...\n");
            res = SetCommMask(hcom, EV_TXEMPTY);
            ok(res, "SetCommMask error %d\n", GetLastError());
 
            res = WaitForSingleObject(ovl_wait.hEvent, TIMEOUT);
            ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
            CloseHandle(ovl_wait.hEvent);
        }
 
        CloseHandle(hcom);
    }
}

Referenced by START_TEST().

toggle_ctlLine()

static DWORD CALLBACK toggle_ctlLine ( LPVOID  arg )

static

Definition at line 1404 of file comm.c.

{
    DWORD_PTR *args = arg;
    DWORD timeout = args[0];
    DWORD ctl     = args[1];
    HANDLE hcom   = (HANDLE) args[2];
    HANDLE hComPortEvent = (HANDLE) args[3];
    DWORD success, err;
 
    trace("toggle_ctlLine timeout %d ctl 0x%08x handle %p\n", timeout, ctl, hcom );
    Sleep(timeout);
    ok(EscapeCommFunction(hcom, ctl),"EscapeCommFunction 0x%08x failed\n", ctl);
    trace("toggle_ctline done\n");
    success = WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE);
    err = GetLastError();
    trace("toggle_ctline WaitForSingleObjectEx res 0x%08x err %d\n",
      success, err);
    return 0;
}

Referenced by test_WaitCts(), test_WaitDcd(), test_WaitDsr(), and test_WaitRing().

Variable Documentation

apc

static HANDLE PIO_APC_ROUTINE apc

Definition at line 55 of file comm.c.

apc_user

static HANDLE PIO_APC_ROUTINE void * apc_user

Definition at line 55 of file comm.c.

buffer

HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK const void* buffer

Definition at line 56 of file comm.c.

hEvent

static HANDLE hEvent

Definition at line 54 of file comm.c.

Referenced by _At_(), CKsProxy::AdviseTime(), CMP_WaitNoPendingInstallEvents(), ATL::CEvent::Create(), CreateGPEvent(), CreateMemoryResourceNotification(), DECLARE_INTERFACE_(), DelayedRegNotifyChangeKeyValue(), DispatcherThread(), DllMain(), DP_CreatePlayer(), DP_IF_CreatePlayer(), ElfChangeNotify(), execute_test(), Icmp6SendEcho2(), IcmpSendEcho(), IcmpSendEcho2(), IDirectPlay4AImpl_CreatePlayer(), IDirectPlay4Impl_CreatePlayer(), COutputPin::IoProcessRoutine(), IReferenceClockImpl_AdviseTime(), listen_pipe(), LsarStartRpcServer(), MediaEvent_GetEventHandle(), mmTaskCreate(), NotifyChangeEventLog(), ATL::CRegKey::NotifyChangeKeyValue(), NtCreateEvent(), NtGdiDvpAcquireNotification(), NtGdiDvpReleaseNotification(), NtOpenEvent(), ok_event_sequence(), ATL::CEvent::Open(), PulseEvent(), RasConnectionNotificationA(), RasConnectionNotificationW(), RasSecurityDialogReceive(), ReferenceClock_AdviseTime(), RefreshPolicy(), RefreshPolicyEx(), RegisterGPNotification(), RegNotifyChangeKeyValue(), ResetEvent(), RunTests(), ScmWaitForLsa(), serverThreadMain3(), serverThreadMain5(), SetEvent(), SetShellReadyEvent(), START_TEST(), SystemClockImpl_AdviseTime(), TerminateShell(), Test1(), Test2(), Test3(), test_alertable(), test_cancelio(), test_create(), test_CreateRemoteThread(), test_events(), test_nonalertable(), test_ntncdf(), test_ntncdf_async(), test_overlapped(), TestKM(), TestTerminateProcess(), ThunkDirectDraw2_WaitForVerticalBlank(), ThunkDirectDraw4_WaitForVerticalBlank(), ThunkDirectDraw_WaitForVerticalBlank(), CRegWatcher::Uninit(), UnregisterGPNotification(), WaitForLsass(), WaitForMachinePolicyForegroundProcessing(), WaitForSCManager(), WaitForUserPolicyForegroundProcessing(), WAVE_mciPlay(), WAVE_mciRecord(), WSACloseEvent(), WSAResetEvent(), and WSASetEvent().

io_status

static IO_STATUS_BLOCK IO_STATUS_BLOCK * io_status

Definition at line 56 of file comm.c.

Referenced by rpcrt4_conn_np_close_read(), rpcrt4_conn_np_read(), rpcrt4_conn_np_write(), VfdFormatTrack(), and VfdOpenImage().

key

HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK const void ULONG PLARGE_INTEGER PULONG key

Definition at line 57 of file comm.c.

length

HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK const void ULONG length

Definition at line 56 of file comm.c.

loopback_dtr_dcd

BOOL loopback_dtr_dcd = LOOPBACK_DTR_DCD

static

Definition at line 52 of file comm.c.

Referenced by test_LoopbackDtrDcd(), and test_WaitDcd().

loopback_dtr_dsr

BOOL loopback_dtr_dsr = LOOPBACK_DTR_DSR

static

Definition at line 50 of file comm.c.

Referenced by test_LoopbackDtrDsr(), and test_WaitDsr().

loopback_dtr_ring

BOOL loopback_dtr_ring = LOOPBACK_DTR_RING

static

Definition at line 51 of file comm.c.

Referenced by test_LoopbackDtrRing(), and test_WaitRing().

loopback_rts_cts

BOOL loopback_rts_cts = LOOPBACK_CTS_RTS

static

Definition at line 49 of file comm.c.

Referenced by test_LoopbackCtsRts(), and test_WaitCts().

loopback_txd_rxd

BOOL loopback_txd_rxd = LOOPBACK_TXD_RXD

static

Definition at line 48 of file comm.c.

Referenced by test_LoopbackRead(), test_WaitBreak(), and test_WaitRx().

offset

HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK const void ULONG PLARGE_INTEGER offset

Definition at line 57 of file comm.c.

Referenced by test_read_write().

test

const TEST test[]

static

Definition at line 73 of file comm.c.

Referenced by test_BuildCommDCB().