modules/rostests/winetests/kernel32/comm.c

   1 /* Unit test suite for comm functions
   2  *
   3  * Copyright 2003 Kevin Groeneveld
   4  * Copyright 2005 Uwe Bonnes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "wine/test.h"
  26 #include "winternl.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29
  30 #define TIMEOUT 1000   /* one second for Timeouts*/
  31 #define SLOWBAUD 150
  32 #define FASTBAUD 115200
  33 #define TIMEDELTA 150  /* 150 ms uncertainty allowed */
  34
  35 /* Define the appropriate LOOPBACK(s) TRUE if you have a Loopback cable with
  36  * the mentioned shorts connected to your Serial port
  37  */
  38 #define LOOPBACK_TXD_RXD  FALSE /* Sub-D 9: Short 2-3 */
  39 #define LOOPBACK_CTS_RTS  FALSE /* Sub-D 9: Short 7-8 */
  40 #define LOOPBACK_DTR_DSR  FALSE /* Sub-D 9: Short 4-6 */
  41 #define LOOPBACK_DTR_RING FALSE /* Sub-D 9: Short 4-9 */
  42 #define LOOPBACK_DTR_DCD  FALSE /* Sub-D 9: Short 4-1 */
  43 /* Many Linux serial drivers have the TIOCM_LOOP flag in the TIOCM_SET ioctl
  44  * available. For the 8250 this is equivalent to TXD->RXD, OUT2->DCD,
  45  * OUT1->RI, RTS->CTS and DTR->DSR
  46  */
  47 /* use variables and not #define to compile the code */
  48 static BOOL loopback_txd_rxd  = LOOPBACK_TXD_RXD;
  49 static BOOL loopback_rts_cts  = LOOPBACK_CTS_RTS;
  50 static BOOL loopback_dtr_dsr  = LOOPBACK_DTR_DSR;
  51 static BOOL loopback_dtr_ring = LOOPBACK_DTR_RING;
  52 static BOOL loopback_dtr_dcd  = LOOPBACK_DTR_DCD;
  53
  54 static NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile, HANDLE hEvent,
  55                                       PIO_APC_ROUTINE apc, void* apc_user,
  56                                       PIO_STATUS_BLOCK io_status, void* buffer, ULONG length,
  57                                       PLARGE_INTEGER offset, PULONG key);
  58 static NTSTATUS (WINAPI *pNtWriteFile)(HANDLE hFile, HANDLE hEvent,
  59                                        PIO_APC_ROUTINE apc, void* apc_user,
  60                                        PIO_STATUS_BLOCK io_status,
  61                                        const void* buffer, ULONG length,
  62                                        PLARGE_INTEGER offset, PULONG key);
  63
  64 typedef struct
  65 {
  66         char string[100];
  67         BOOL result;
  68         BOOL old_style;
  69         DCB dcb1, dcb2;
  70         COMMTIMEOUTS timeouts1, timeouts2;
  71 } TEST;
  72
  73 static const TEST test[] =
  74 {
  75         {
  76                 "baud=9600 parity=e data=5 stop=1 xon=on odsr=off octs=off dtr=on rts=on idsr=on",
  77                 TRUE, FALSE,
  78                 { 0x00000000, 0x00002580, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
  79                 { 0xffffffff, 0x00002580, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x05, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
  80                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
  81                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
  82         },
  83         {
  84                 "baud=0 parity=M data=6 stop=1.5 xon=off odsr=on octs=ON dtr=off rts=off idsr=OFF",
  85                 TRUE, FALSE,
  86                 { 0x00000000, 0x00000000, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x06, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
  87                 { 0xffffffff, 0x00000000, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x06, 0x03, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
  88                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
  89                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
  90         },
  91         {
  92                 "BAUD=4000000000 parity=n data=7 stop=2 to=off",
  93                 TRUE, FALSE,
  94                 { 0x00000000, 0xee6b2800, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
  95                 { 0xffffffff, 0xee6b2800, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
  96                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
  97                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 }
  98         },
  99         {
 100                 "Baud=115200 Parity=O Data=8 To=On",
 101                 TRUE, FALSE,
 102                 { 0x00000000, 0x0001c200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 103                 { 0xffffffff, 0x0001c200, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 104                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000EA60 },
 105                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000EA60 }
 106         },
 107         {
 108                 "PaRiTy=s           Data=7          DTR=on",
 109                 TRUE, FALSE,
 110                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 111                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x04, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 112                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 113                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 114         },
 115         {
 116                 "data=4",
 117                 FALSE, FALSE,
 118                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 119                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 120                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 121                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 122         },
 123         {
 124                 "data=9",
 125                 FALSE, FALSE,
 126                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 127                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 128                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 129                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 130         },
 131         {
 132                 "parity=no",
 133                 FALSE, FALSE,
 134                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 135                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 136                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 137                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 138         },
 139         {
 140                 "stop=0",
 141                 FALSE, FALSE,
 142                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 143                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 144                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 145                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 146         },
 147         {
 148                 "stop=1.501",
 149                 FALSE, FALSE,
 150                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 151                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 152                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 153                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 154         },
 155         {
 156                 "stop=3",
 157                 FALSE, FALSE,
 158                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 159                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 160                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 161                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 162         },
 163         {
 164                 "to=foobar",
 165                 FALSE, FALSE,
 166                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 167                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 168                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 169                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 170         },
 171         {
 172                 " baud=9600",
 173                 FALSE, FALSE,
 174                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 175                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 176                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 177                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 178         },
 179         {
 180                 "baud= 9600",
 181                 FALSE, FALSE,
 182                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 183                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 184                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 185                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 186         },
 187         {
 188                 "baud=9600,data=8",
 189                 FALSE, FALSE,
 190                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 191                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 192                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 193                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 194         },
 195         {
 196                 "11,n,8,1",
 197                 TRUE, TRUE,
 198                 { 0x00000000, 0x0000006e, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 199                 { 0xffffffff, 0x0000006e, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 200                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 201                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 202         },
 203         {
 204                 "30 ,E, 5,1.5",
 205                 TRUE, TRUE,
 206                 { 0x00000000, 0x0000012c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x05, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 207                 { 0xffffffff, 0x0000012c, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x05, 0x02, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 208                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 209                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 210         },
 211         {
 212                 "60, m, 6, 2 ",
 213                 TRUE, TRUE,
 214                 { 0x00000000, 0x00000258, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x06, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 215                 { 0xffffffff, 0x00000258, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x06, 0x03, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 216                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 217                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 218         },
 219         {
 220                 "12 , o , 7 , 1",
 221                 TRUE, TRUE,
 222                 { 0x00000000, 0x000004b0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 223                 { 0xffffffff, 0x000004b0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 224                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 225                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 226         },
 227         {
 228                 "24,s,8,1.5",
 229                 TRUE, TRUE,
 230                 { 0x00000000, 0x00000960, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 231                 { 0xffffffff, 0x00000960, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0x04, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 232                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 233                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 234         },
 235         {
 236                 "48,n,8,1,p",
 237                 TRUE, TRUE,
 238                 { 0x00000000, 0x000012c0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 239                 { 0xffffffff, 0x000012c0, 1, 1, 1, 1, 2, 1, 1, 0, 0, 1, 1, 2, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 240                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 241                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 242         },
 243         {
 244                 "96,N,8,1 , x ",
 245                 TRUE, TRUE,
 246                 { 0x00000000, 0x00002580, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 247                 { 0xffffffff, 0x00002580, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 248                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 249                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 250         },
 251         {
 252                 "19, e, 7, 1, x",
 253                 TRUE, TRUE,
 254                 { 0x00000000, 0x00004b00, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 255                 { 0xffffffff, 0x00004b00, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 256                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 257                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 258         },
 259         {
 260                 "0,M,7,1,P",
 261                 TRUE, TRUE,
 262                 { 0x00000000, 0x00000000, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 263                 { 0xffffffff, 0x00000000, 1, 1, 1, 1, 2, 1, 1, 0, 0, 1, 1, 2, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x03, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 264                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 265                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 266         },
 267         {
 268                 "4000000000,O,7,1.5,X",
 269                 TRUE, TRUE,
 270                 { 0x00000000, 0xee6b2800, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 271                 { 0xffffffff, 0xee6b2800, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 272                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 273                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 274         },
 275         {
 276                 "96,N,8,1 to=on",
 277                 FALSE, TRUE,
 278                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 279                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 280                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 281                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 282         },
 283         {
 284                 "96,NO,8,1",
 285                 FALSE, TRUE,
 286                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 287                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 288                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 289                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 290         },
 291         {
 292                 "96,N,4,1",
 293                 FALSE, TRUE,
 294                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 295                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 296                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 297                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 298         },
 299         {
 300                 "96,N,9,1",
 301                 FALSE, TRUE,
 302                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 303                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 304                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 305                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 306         },
 307         {
 308                 "96,N,8,0",
 309                 FALSE, TRUE,
 310                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 311                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 312                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 313                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 314         },
 315         {
 316                 "96,N,8,3",
 317                 FALSE, TRUE,
 318                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 319                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 320                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 321                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 322         },
 323         {
 324                 "96,N,8,1,K",
 325                 FALSE, TRUE,
 326                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 327                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 328                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 329                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 330         },
 331         {
 332                 "COM0:baud=115200",
 333                 FALSE, FALSE,
 334                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 335                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 336                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 337                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 338         },
 339         {
 340                 "COMx:baud=38400 data=8",
 341                 TRUE, FALSE,
 342                 { 0x00000000, 0x00009600, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 343                 { 0xffffffff, 0x00009600, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 344                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 345                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 346         },
 347         {
 348                 "COMx  :to=on stop=1.5",
 349                 TRUE, FALSE,
 350                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 351                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 352                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000EA60 },
 353                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000EA60 }
 354         },
 355         {
 356                 "COMx:               baud=12345     data=7",
 357                 TRUE, FALSE,
 358                 { 0x00000000, 0x00003039, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 359                 { 0xffffffff, 0x00003039, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 360                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 361                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 362         },
 363         {
 364                 "COMx : xon=on odsr=off",
 365                 TRUE, FALSE,
 366                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 367                 { 0xffffffff, 0xffffffff, 1, 1, 1, 0, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 368                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 369                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 370         },
 371         {
 372                 "COM0:9600,N,8,1",
 373                 FALSE, TRUE,
 374                 { 0x00000000, 0x00000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 375                 { 0xffffffff, 0xffffffff, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 376                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 377                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 378         },
 379         {
 380                 "COMx:9600,N,8,1",
 381                 TRUE, TRUE,
 382                 { 0x00000000, 0x00002580, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 383                 { 0xffffffff, 0x00002580, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 384                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 385                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 386         },
 387         {
 388                 "COMx:  11,E,7,2",
 389                 TRUE, TRUE,
 390                 { 0x00000000, 0x0000006e, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x07, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 391                 { 0xffffffff, 0x0000006e, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x07, 0x02, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 392                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 393                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 394         },
 395         {
 396                 "COMx  :19,M,5,1",
 397                 TRUE, TRUE,
 398                 { 0x00000000, 0x00004b00, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x05, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 399                 { 0xffffffff, 0x00004b00, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x05, 0x03, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 400                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 401                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 402         },
 403         {
 404                 "COMx  :    57600,S,6,2,x",
 405                 TRUE, TRUE,
 406                 { 0x00000000, 0x0000e100, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0x00000, 0x0000, 0x0000, 0x0000, 0x06, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0000 },
 407                 { 0xffffffff, 0x0000e100, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0x1ffff, 0xffff, 0xffff, 0xffff, 0x06, 0x04, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xffff },
 408                 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
 409                 { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }
 410         },
 411 };
 412
 413 #define TEST_COUNT (sizeof(test) / sizeof(TEST))
 414
 415 /* This function can be useful if you are modifying the test cases and want to
 416    output the contents of a DCB structure. */
 417 /*static print_dcb(DCB *pdcb)
 418 {
 419         printf("0x%08x, 0x%08x, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, 0x%05x, 0x%04x, 0x%04x, 0x%04x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%04x\n",
 420                 pdcb->DCBlength,
 421                 pdcb->BaudRate,
 422                 pdcb->fBinary,
 423                 pdcb->fParity,
 424                 pdcb->fOutxCtsFlow,
 425                 pdcb->fOutxDsrFlow,
 426                 pdcb->fDtrControl,
 427                 pdcb->fDsrSensitivity,
 428                 pdcb->fTXContinueOnXoff,
 429                 pdcb->fOutX,
 430                 pdcb->fInX,
 431                 pdcb->fErrorChar,
 432                 pdcb->fNull,
 433                 pdcb->fRtsControl,
 434                 pdcb->fAbortOnError,
 435                 pdcb->fDummy2,
 436                 pdcb->wReserved,
 437                 pdcb->XonLim,
 438                 pdcb->XoffLim,
 439                 pdcb->ByteSize,
 440                 pdcb->Parity,
 441                 pdcb->StopBits,
 442                 pdcb->XonChar & 0xff,
 443                 pdcb->XoffChar & 0xff,
 444                 pdcb->ErrorChar & 0xff,
 445                 pdcb->EofChar & 0xff,
 446                 pdcb->EvtChar & 0xff,
 447                 pdcb->wReserved1 & 0xffff );
 448 } */
 449
 450 static void check_result(const char *function, const TEST *ptest, int initial_value, BOOL result)
 451 {
 452         DWORD LastError = GetLastError();
 453         DWORD CorrectError = (ptest->result ? 0xdeadbeef : ERROR_INVALID_PARAMETER);
 454
 455         ok(LastError == CorrectError, "%s(\"%s\"), 0x%02x: GetLastError() returned %d, should be %d\n", function, ptest->string, initial_value, LastError, CorrectError);
 456         ok(result == ptest->result, "%s(\"%s\"), 0x%02x: return value should be %s\n", function, ptest->string, initial_value, ptest->result ? "TRUE" : "FALSE");
 457 }
 458
 459 #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)
 460 #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); }
 461
 462 static void check_dcb(const char *function, const TEST *ptest, int initial_value, const DCB *pdcb1, const DCB *pdcb2)
 463 {
 464         /* DCBlength is a special case since Win 9x sets it but NT does not.
 465            We will accept either as correct. */
 466         check_dcb_member2(DCBlength, (DWORD)sizeof(DCB), "%u");
 467
 468         /* For old style control strings Win 9x does not set the next five members, NT does. */
 469         if(ptest->old_style && ptest->result)
 470         {
 471                 check_dcb_member2(fOutxCtsFlow, ((unsigned int)initial_value & 1), "%u");
 472                 check_dcb_member2(fDtrControl, ((unsigned int)initial_value & 3), "%u");
 473                 check_dcb_member2(fOutX, ((unsigned int)initial_value & 1), "%u");
 474                 check_dcb_member2(fInX, ((unsigned)initial_value & 1), "%u");
 475                 check_dcb_member2(fRtsControl, ((unsigned)initial_value & 3), "%u");
 476         }
 477         else
 478         {
 479                 check_dcb_member(fOutxCtsFlow, "%u");
 480                 check_dcb_member(fDtrControl, "%u");
 481                 check_dcb_member(fOutX, "%u");
 482                 check_dcb_member(fInX, "%u");
 483                 check_dcb_member(fRtsControl, "%u");
 484         }
 485
 486         if(ptest->result)
 487         {
 488                 /* For the idsr=xxx parameter, NT sets fDsrSensitivity, 9x sets
 489                    fOutxDsrFlow. */
 490                 if(!ptest->old_style)
 491                 {
 492                         check_dcb_member2(fOutxDsrFlow, pdcb2->fDsrSensitivity, "%u");
 493                         check_dcb_member2(fDsrSensitivity, pdcb2->fOutxDsrFlow, "%u");
 494                 }
 495                 else
 496                 {
 497                         /* For old style control strings Win 9x does not set the
 498                            fOutxDsrFlow member, NT does. */
 499                         check_dcb_member2(fOutxDsrFlow, ((unsigned int)initial_value & 1), "%u");
 500                         check_dcb_member(fDsrSensitivity, "%u");
 501                 }
 502         }
 503         else
 504         {
 505                 check_dcb_member(fOutxDsrFlow, "%u");
 506                 check_dcb_member(fDsrSensitivity, "%u");
 507         }
 508
 509         /* Check the result of the DCB members. */
 510         check_dcb_member(BaudRate, "%u");
 511         check_dcb_member(fBinary, "%u");
 512         check_dcb_member(fParity, "%u");
 513         check_dcb_member(fTXContinueOnXoff, "%u");
 514         check_dcb_member(fErrorChar, "%u");
 515         check_dcb_member(fNull, "%u");
 516         check_dcb_member(fAbortOnError, "%u");
 517         check_dcb_member(fDummy2, "%u");
 518         check_dcb_member(wReserved, "%u");
 519         check_dcb_member(XonLim, "%u");
 520         check_dcb_member(XoffLim, "%u");
 521         check_dcb_member(ByteSize, "%u");
 522         check_dcb_member(Parity, "%u");
 523         check_dcb_member(StopBits, "%u");
 524         check_dcb_member(XonChar, "%d");
 525         check_dcb_member(XoffChar, "%d");
 526         check_dcb_member(ErrorChar, "%d");
 527         check_dcb_member(EofChar, "%d");
 528         check_dcb_member(EvtChar, "%d");
 529         check_dcb_member(wReserved1, "%u");
 530 }
 531
 532 #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);
 533
 534 static void check_timeouts(const char *function, const TEST *ptest, int initial_value, const COMMTIMEOUTS *ptimeouts1, const COMMTIMEOUTS *ptimeouts2)
 535 {
 536         check_timeouts_member(ReadIntervalTimeout);
 537         check_timeouts_member(ReadTotalTimeoutMultiplier);
 538         check_timeouts_member(ReadTotalTimeoutConstant);
 539         check_timeouts_member(WriteTotalTimeoutMultiplier);
 540         check_timeouts_member(WriteTotalTimeoutConstant);
 541 }
 542
 543 static void test_BuildCommDCBA(const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb)
 544 {
 545         BOOL result;
 546         DCB dcb;
 547
 548         /* set initial conditions */
 549         memset(&dcb, initial_value, sizeof(DCB));
 550         SetLastError(0xdeadbeef);
 551
 552         result = BuildCommDCBA(string, &dcb);
 553
 554         /* check results */
 555         check_result("BuildCommDCBA", ptest, initial_value, result);
 556         check_dcb("BuildCommDCBA", ptest, initial_value, &dcb, pexpected_dcb);
 557 }
 558
 559 static void test_BuildCommDCBAndTimeoutsA(const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb, const COMMTIMEOUTS *pexpected_timeouts)
 560 {
 561         BOOL result;
 562         DCB dcb;
 563         COMMTIMEOUTS timeouts;
 564
 565         /* set initial conditions */
 566         memset(&dcb, initial_value, sizeof(DCB));
 567         memset(&timeouts, initial_value, sizeof(COMMTIMEOUTS));
 568         SetLastError(0xdeadbeef);
 569
 570         result = BuildCommDCBAndTimeoutsA(string, &dcb, &timeouts);
 571
 572         /* check results */
 573         check_result("BuildCommDCBAndTimeoutsA", ptest, initial_value, result);
 574         check_dcb("BuildCommDCBAndTimeoutsA", ptest, initial_value, &dcb, pexpected_dcb);
 575         check_timeouts("BuildCommDCBAndTimeoutsA", ptest, initial_value, &timeouts, pexpected_timeouts);
 576 }
 577
 578 static void test_BuildCommDCBW(const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb)
 579 {
 580         BOOL result;
 581         DCB dcb;
 582         WCHAR wide_string[sizeof(ptest->string)];
 583         static int reportedDCBW = 0;
 584
 585         MultiByteToWideChar(CP_ACP, 0, string, -1, wide_string, sizeof(wide_string) / sizeof(WCHAR));
 586
 587         /* set initial conditions */
 588         memset(&dcb, initial_value, sizeof(DCB));
 589         SetLastError(0xdeadbeef);
 590
 591         result = BuildCommDCBW(wide_string, &dcb);
 592
 593         if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 594         {
 595                 if(!reportedDCBW++)
 596                         win_skip("BuildCommDCBW is not implemented\n");
 597                 return;
 598         }
 599
 600         /* check results */
 601         check_result("BuildCommDCBW", ptest, initial_value, result);
 602         check_dcb("BuildCommDCBW", ptest, initial_value, &dcb, pexpected_dcb);
 603 }
 604
 605 static void test_BuildCommDCBAndTimeoutsW(const char *string, const TEST *ptest, int initial_value, const DCB *pexpected_dcb, const COMMTIMEOUTS *pexpected_timeouts)
 606 {
 607         BOOL result;
 608         DCB dcb;
 609         COMMTIMEOUTS timeouts;
 610         WCHAR wide_string[sizeof(ptest->string)];
 611         static int reportedDCBAndTW = 0;
 612
 613         MultiByteToWideChar(CP_ACP, 0, string, -1, wide_string, sizeof(wide_string) / sizeof(WCHAR));
 614
 615         /* set initial conditions */
 616         memset(&dcb, initial_value, sizeof(DCB));
 617         memset(&timeouts, initial_value, sizeof(COMMTIMEOUTS));
 618         SetLastError(0xdeadbeef);
 619
 620         result = BuildCommDCBAndTimeoutsW(wide_string, &dcb, &timeouts);
 621
 622         if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 623         {
 624                 if(!reportedDCBAndTW++)
 625                         win_skip("BuildCommDCBAndTimeoutsW is not implemented\n");
 626                 return;
 627         }
 628
 629         /* check results */
 630         check_result("BuildCommDCBAndTimeoutsW", ptest, initial_value, result);
 631         check_dcb("BuildCommDCBAndTimeoutsW", ptest, initial_value, &dcb, pexpected_dcb);
 632         check_timeouts("BuildCommDCBAndTimeoutsW", ptest, initial_value, &timeouts, pexpected_timeouts);
 633 }
 634
 635 static void test_BuildCommDCB(void)
 636 {
 637         char port_name[] = "COMx";
 638         char port = 0;
 639         unsigned int i;
 640         char *ptr;
 641
 642         /* Some of these tests require a valid COM port.  This loop will try to find
 643            a valid port. */
 644         for(port_name[3] = '1'; port_name[3] <= '9'; port_name[3]++)
 645         {
 646                 COMMCONFIG commconfig;
 647                 DWORD size = sizeof(COMMCONFIG);
 648
 649                 if(GetDefaultCommConfigA(port_name, &commconfig, &size))
 650                 {
 651                         port = port_name[3];
 652                         break;
 653                 }
 654         }
 655
 656         if(!port)
 657                 trace("Could not find a valid COM port.  Some tests will be skipped.\n");
 658
 659         for(i = 0; i < TEST_COUNT; i++)
 660         {
 661                 char string[sizeof(test[i].string)];
 662
 663                 strcpy(string, test[i].string);
 664
 665                 /* Check if this test case needs a valid COM port. */
 666                 ptr = strstr(string, "COMx");
 667
 668                 /* If required, substitute valid port number into device control string. */
 669                 if(ptr)
 670                 {
 671                         if(port)
 672                                 ptr[3] = port;
 673                         else
 674                                 continue;
 675                 }
 676
 677                 test_BuildCommDCBA(string, &test[i], 0x00, &test[i].dcb1);
 678                 test_BuildCommDCBA(string, &test[i], 0xff, &test[i].dcb2);
 679                 test_BuildCommDCBAndTimeoutsA(string, &test[i], 0x00, &test[i].dcb1, &test[i].timeouts1);
 680                 test_BuildCommDCBAndTimeoutsA(string, &test[i], 0xff, &test[i].dcb2, &test[i].timeouts2);
 681
 682                 test_BuildCommDCBW(string, &test[i], 0x00, &test[i].dcb1);
 683                 test_BuildCommDCBW(string, &test[i], 0xff, &test[i].dcb2);
 684                 test_BuildCommDCBAndTimeoutsW(string, &test[i], 0x00, &test[i].dcb1, &test[i].timeouts1);
 685                 test_BuildCommDCBAndTimeoutsW(string, &test[i], 0xff, &test[i].dcb2, &test[i].timeouts2);
 686         }
 687 }
 688
 689 static HANDLE test_OpenComm(BOOL doOverlap)
 690 {
 691     HANDLE hcom = INVALID_HANDLE_VALUE;
 692     char port_name[] = "COMx";
 693     static BOOL shown = FALSE;
 694     DWORD errors;
 695     COMSTAT comstat;
 696
 697     /* Try to find a port */
 698     for(port_name[3] = '1'; port_name[3] <= '9'; port_name[3]++)
 699     {
 700         hcom = CreateFileA( port_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
 701                            (doOverlap)?FILE_FLAG_OVERLAPPED:0, NULL );
 702         if (hcom != INVALID_HANDLE_VALUE)
 703             break;
 704     }
 705     if(!shown)
 706     {
 707         if (hcom == INVALID_HANDLE_VALUE)
 708             trace("Could not find a valid COM port.\n");
 709         else
 710             trace("Found Com port %s. Connected devices may disturb results\n", port_name);
 711         /*shown = TRUE; */
 712     }
 713     if (hcom != INVALID_HANDLE_VALUE)
 714     {
 715         BOOL ret;
 716
 717         ret = ClearCommError(hcom, &errors, &comstat);
 718         if (!ret && (GetLastError() == ERROR_NOT_READY || GetLastError() == ERROR_INVALID_HANDLE))
 719         {
 720             if (GetLastError() == ERROR_NOT_READY)
 721                 trace("%s doesn't respond, skipping the test\n", port_name);
 722             else
 723                 trace("%s is not a real serial port, skipping the test\n", port_name);
 724             CloseHandle(hcom);
 725             return INVALID_HANDLE_VALUE;
 726         }
 727
 728         ok(ret, "Unexpected error %u on open\n", GetLastError());
 729         ok(comstat.cbInQue == 0, "Unexpected %d chars in InQueue\n",comstat.cbInQue);
 730         ok(comstat.cbOutQue == 0, "Still pending %d charcters in OutQueue\n", comstat.cbOutQue);
 731         ok(errors == 0, "Unexpected errors 0x%08x\n", errors);
 732     }
 733     return hcom;
 734 }
 735
 736 static void test_GetModemStatus(HANDLE hcom)
 737 {
 738     DWORD ModemStat = 0;
 739
 740     ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
 741     trace("GetCommModemStatus returned 0x%08x->%s%s%s%s\n", ModemStat,
 742           (ModemStat &MS_RLSD_ON)?"MS_RLSD_ON ":"",
 743           (ModemStat &MS_RING_ON)?"MS_RING_ON ":"",
 744           (ModemStat &MS_DSR_ON)?"MS_DSR_ON ":"",
 745           (ModemStat &MS_CTS_ON)?"MS_CTS_ON ":"");
 746 }
 747
 748 /* When we don't write anything, Read should time out even on a loopbacked port */
 749 static void test_ReadTimeOut(void)
 750 {
 751     HANDLE hcom;
 752     DCB dcb;
 753     COMMTIMEOUTS timeouts;
 754     char rbuf[32];
 755     DWORD before, after, read, timediff, LastError;
 756     BOOL res;
 757
 758     hcom = test_OpenComm(FALSE);
 759     if (hcom == INVALID_HANDLE_VALUE) return;
 760
 761     test_GetModemStatus(hcom);
 762
 763     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
 764     dcb.BaudRate = FASTBAUD;
 765     dcb.ByteSize = 8;
 766     dcb.Parity = NOPARITY;
 767     dcb.fRtsControl=RTS_CONTROL_ENABLE;
 768     dcb.fDtrControl=DTR_CONTROL_ENABLE;
 769     dcb.StopBits = ONESTOPBIT;
 770     ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
 771
 772     ZeroMemory( &timeouts, sizeof(timeouts));
 773     timeouts.ReadTotalTimeoutConstant = TIMEOUT;
 774     ok(SetCommTimeouts(hcom, &timeouts),"SetCommTimeouts failed\n");
 775
 776     before = GetTickCount();
 777     SetLastError(0xdeadbeef);
 778     res = ReadFile(hcom, rbuf, sizeof(rbuf), &read, NULL);
 779     LastError = GetLastError();
 780     after = GetTickCount();
 781     ok( res == TRUE, "A timed-out read should return TRUE\n");
 782     ok( LastError == 0xdeadbeef, "err=%d\n", LastError);
 783     timediff = after - before;
 784     ok( timediff > TIMEOUT>>2 && timediff < TIMEOUT *2,
 785         "Unexpected TimeOut %d, expected %d\n", timediff, TIMEOUT);
 786
 787     CloseHandle(hcom);
 788 }
 789
 790 static void test_waittxempty(void)
 791 {
 792     HANDLE hcom;
 793     DCB dcb;
 794     COMMTIMEOUTS timeouts;
 795     char tbuf[]="test_waittxempty";
 796     DWORD before, after, bytes, timediff, evtmask, errors, i;
 797     BOOL res;
 798     DWORD baud = SLOWBAUD;
 799     OVERLAPPED ovl_write, ovl_wait, ovl_wait2;
 800     COMSTAT stat;
 801
 802     hcom = test_OpenComm(TRUE);
 803     if (hcom == INVALID_HANDLE_VALUE) return;
 804
 805     /* set a low baud rate to have ample time*/
 806     res = GetCommState(hcom, &dcb);
 807     ok(res, "GetCommState error %d\n", GetLastError());
 808     dcb.BaudRate = baud;
 809     dcb.ByteSize = 8;
 810     dcb.Parity = NOPARITY;
 811     dcb.fRtsControl=RTS_CONTROL_ENABLE;
 812     dcb.fDtrControl=DTR_CONTROL_ENABLE;
 813     dcb.StopBits = ONESTOPBIT;
 814     res = SetCommState(hcom, &dcb);
 815     ok(res, "SetCommState error %d\n", GetLastError());
 816
 817     ZeroMemory( &timeouts, sizeof(timeouts));
 818     timeouts.ReadTotalTimeoutConstant = TIMEOUT;
 819     res = SetCommTimeouts(hcom, &timeouts);
 820     ok(res,"SetCommTimeouts error %d\n", GetLastError());
 821
 822     res = SetupComm(hcom, 1024, 1024);
 823     ok(res, "SetUpComm error %d\n", GetLastError());
 824
 825     /* calling SetCommMask after WriteFile leads to WaitCommEvent failures
 826      * due to timeout (no events) under testbot VMs and VirtualBox
 827      */
 828     res = SetCommMask(hcom, EV_TXEMPTY);
 829     ok(res, "SetCommMask error %d\n", GetLastError());
 830
 831     SetLastError(0xdeadbeef);
 832     res = WriteFile(hcom, tbuf, sizeof(tbuf), &bytes, NULL);
 833     ok(!res, "WriteFile on an overlapped handle without ovl structure should fail\n");
 834     ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 835
 836     S(U(ovl_write)).Offset = 0;
 837     S(U(ovl_write)).OffsetHigh = 0;
 838     ovl_write.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 839     before = GetTickCount();
 840     SetLastError(0xdeadbeef);
 841     res = WriteFile(hcom, tbuf, sizeof(tbuf), &bytes, &ovl_write);
 842     after = GetTickCount();
 843     ok((!res && GetLastError() == ERROR_IO_PENDING) || (res && bytes == sizeof(tbuf)),
 844        "WriteFile returned %d, written %u bytes, error %d\n", res, bytes, GetLastError());
 845     if (!res) ok(!bytes, "expected 0, got %u\n", bytes);
 846     ok(after - before < 30, "WriteFile took %d ms to write %d Bytes at %d Baud\n",
 847        after - before, bytes, baud);
 848     /* don't wait for WriteFile completion */
 849
 850     S(U(ovl_wait)).Offset = 0;
 851     S(U(ovl_wait)).OffsetHigh = 0;
 852     ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 853     evtmask = 0;
 854     before = GetTickCount();
 855     SetLastError(0xdeadbeef);
 856     res = WaitCommEvent(hcom, &evtmask, &ovl_wait);
 857     ok(!res && GetLastError() == ERROR_IO_PENDING, "WaitCommEvent error %d\n", GetLastError());
 858     after = GetTickCount();
 859     ok(after - before < 30, "WaitCommEvent should have returned immediately, took %d ms\n", after - before);
 860     res = WaitForSingleObject(ovl_wait.hEvent, 1500);
 861     ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
 862     if (res == WAIT_OBJECT_0)
 863     {
 864         res = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
 865         ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
 866         ok(bytes == sizeof(evtmask), "expected %u, written %u\n", (UINT)sizeof(evtmask), bytes);
 867         res = TRUE;
 868     }
 869     else
 870     {
 871         /* unblock pending wait */
 872         trace("recovering after WAIT_TIMEOUT...\n");
 873         res = SetCommMask(hcom, EV_TXEMPTY);
 874         ok(res, "SetCommMask error %d\n", GetLastError());
 875
 876         res = WaitForSingleObject(ovl_wait.hEvent, TIMEOUT);
 877         ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
 878
 879         res = FALSE;
 880     }
 881     after = GetTickCount();
 882     ok(res, "WaitCommEvent error %d\n", GetLastError());
 883     ok(evtmask & EV_TXEMPTY, "WaitCommEvent: expected EV_TXEMPTY, got %#x\n", evtmask);
 884     CloseHandle(ovl_wait.hEvent);
 885
 886     timediff = after - before;
 887     trace("WaitCommEvent for EV_TXEMPTY took %d ms (timeout 1500)\n", timediff);
 888     ok(timediff < 1200, "WaitCommEvent used %d ms for waiting\n", timediff);
 889
 890     res = WaitForSingleObject(ovl_write.hEvent, 0);
 891     ok(res == WAIT_OBJECT_0, "WriteFile failed with a timeout\n");
 892     res = GetOverlappedResult(hcom, &ovl_write, &bytes, FALSE);
 893     ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
 894     ok(bytes == sizeof(tbuf), "expected %u, written %u\n", (UINT)sizeof(tbuf), bytes);
 895     CloseHandle(ovl_write.hEvent);
 896
 897     CloseHandle(hcom);
 898
 899     for (i = 0; i < 2; i++)
 900     {
 901         hcom = test_OpenComm(TRUE);
 902         if (hcom == INVALID_HANDLE_VALUE) return;
 903
 904         res = SetCommMask(hcom, EV_TXEMPTY);
 905         ok(res, "SetCommMask error %d\n", GetLastError());
 906
 907         if (i == 0)
 908         {
 909             S(U(ovl_write)).Offset = 0;
 910             S(U(ovl_write)).OffsetHigh = 0;
 911             ovl_write.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 912             before = GetTickCount();
 913             SetLastError(0xdeadbeef);
 914             res = WriteFile(hcom, tbuf, sizeof(tbuf), &bytes, &ovl_write);
 915             ok((!res && GetLastError() == ERROR_IO_PENDING) || (res && bytes == sizeof(tbuf)),
 916                "WriteFile returned %d, written %u bytes, error %d\n", res, bytes, GetLastError());
 917             if (!res) ok(!bytes, "expected 0, got %u\n", bytes);
 918
 919             ClearCommError(hcom, &errors, &stat);
 920             ok(stat.cbInQue == 0, "InQueue should be empty, got %d bytes\n", stat.cbInQue);
 921             ok(stat.cbOutQue != 0 || broken(stat.cbOutQue == 0) /* VM */, "OutQueue should not be empty\n");
 922             ok(errors == 0, "ClearCommErrors: Unexpected error 0x%08x\n", errors);
 923
 924             res = GetOverlappedResult(hcom, &ovl_write, &bytes, TRUE);
 925             ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
 926             ok(bytes == sizeof(tbuf), "expected %u, written %u\n", (UINT)sizeof(tbuf), bytes);
 927             CloseHandle(ovl_write.hEvent);
 928
 929             res = FlushFileBuffers(hcom);
 930             ok(res, "FlushFileBuffers error %d\n", GetLastError());
 931         }
 932
 933         ClearCommError(hcom, &errors, &stat);
 934         ok(stat.cbInQue == 0, "InQueue should be empty, got %d bytes\n", stat.cbInQue);
 935         ok(stat.cbOutQue == 0, "OutQueue should be empty, got %d bytes\n", stat.cbOutQue);
 936         ok(errors == 0, "ClearCommErrors: Unexpected error 0x%08x\n", errors);
 937
 938         S(U(ovl_wait)).Offset = 0;
 939         S(U(ovl_wait)).OffsetHigh = 0;
 940         ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 941         evtmask = 0;
 942         SetLastError(0xdeadbeef);
 943         res = WaitCommEvent(hcom, &evtmask, &ovl_wait);
 944         ok(res /* busy system */ || GetLastError() == ERROR_IO_PENDING,
 945            "%d: WaitCommEvent error %d\n", i, GetLastError());
 946
 947         res = WaitForSingleObject(ovl_wait.hEvent, TIMEOUT);
 948         if (i == 0)
 949             ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
 950         else
 951             ok(res == WAIT_TIMEOUT, "WaitCommEvent should fail with a timeout\n");
 952         if (res == WAIT_OBJECT_0)
 953         {
 954             res = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
 955             ok(res, "GetOverlappedResult reported error %d\n", GetLastError());
 956             ok(bytes == sizeof(evtmask), "expected %u, written %u\n", (UINT)sizeof(evtmask), bytes);
 957             ok(res, "WaitCommEvent error %d\n", GetLastError());
 958             ok(evtmask & EV_TXEMPTY, "WaitCommEvent: expected EV_TXEMPTY, got %#x\n", evtmask);
 959         }
 960         else
 961         {
 962             ok(!evtmask, "WaitCommEvent: expected 0, got %#x\n", evtmask);
 963
 964             S(U(ovl_wait2)).Offset = 0;
 965             S(U(ovl_wait2)).OffsetHigh = 0;
 966             ovl_wait2.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 967             SetLastError(0xdeadbeef);
 968             res = WaitCommEvent(hcom, &evtmask, &ovl_wait2);
 969             ok(!res, "WaitCommEvent should fail if there is a pending wait\n");
 970             ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 971             CloseHandle(ovl_wait2.hEvent);
 972
 973             /* unblock pending wait */
 974             trace("recovering after WAIT_TIMEOUT...\n");
 975             res = SetCommMask(hcom, EV_TXEMPTY);
 976             ok(res, "SetCommMask error %d\n", GetLastError());
 977
 978             res = WaitForSingleObject(ovl_wait.hEvent, TIMEOUT);
 979             ok(res == WAIT_OBJECT_0, "WaitCommEvent failed with a timeout\n");
 980             CloseHandle(ovl_wait.hEvent);
 981         }
 982
 983         CloseHandle(hcom);
 984     }
 985 }
 986
 987 /* A new open handle should not return error or have bytes in the Queues */
 988 static void test_ClearCommError(void)
 989 {
 990     HANDLE hcom;
 991     DWORD  errors;
 992     COMSTAT lpStat;
 993
 994     hcom = test_OpenComm(FALSE);
 995     if (hcom == INVALID_HANDLE_VALUE) return;
 996
 997     ok(ClearCommError(hcom, &errors, &lpStat), "ClearCommError failed\n");
 998     ok(lpStat.cbInQue == 0, "Unexpected %d chars in InQueue\n", lpStat.cbInQue);
 999     ok(lpStat.cbOutQue == 0, "Unexpected %d chars in OutQueue\n", lpStat.cbOutQue);
1000     ok(errors == 0, "ClearCommErrors: Unexpected error 0x%08x\n", errors);
1001
1002     CloseHandle(hcom);
1003 }
1004
1005 static void test_non_pending_errors(void)
1006 {
1007     HANDLE hcom;
1008     DCB dcb;
1009     DWORD err;
1010
1011     hcom = test_OpenComm(FALSE);
1012     if (hcom == INVALID_HANDLE_VALUE) return;
1013
1014     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1015     dcb.ByteSize = 255; /* likely bogus */
1016     ok(!SetCommState(hcom, &dcb), "SetCommState should have failed\n");
1017     ok(ClearCommError(hcom, &err, NULL), "ClearCommError should succeed\n");
1018     ok(!(err & CE_MODE), "ClearCommError shouldn't set CE_MODE byte in this case (%x)\n", err);
1019
1020     CloseHandle(hcom);
1021 }
1022
1023 static void test_LoopbackRead(void)
1024 {
1025     HANDLE hcom;
1026     DCB dcb;
1027     COMMTIMEOUTS timeouts;
1028     char rbuf[32];
1029     DWORD before, after, diff, read, read1, written, evtmask=0, i;
1030     BOOL res;
1031     char tbuf[]="test_LoopbackRead";
1032
1033     if (!loopback_txd_rxd) return;
1034
1035     hcom = test_OpenComm(FALSE);
1036     if (hcom == INVALID_HANDLE_VALUE) return;
1037
1038     trace("Starting test_LoopbackRead\n");
1039     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1040     dcb.BaudRate = FASTBAUD;
1041     dcb.ByteSize = 8;
1042     dcb.Parity = NOPARITY;
1043     dcb.fRtsControl=RTS_CONTROL_ENABLE;
1044     dcb.fDtrControl=DTR_CONTROL_ENABLE;
1045     dcb.StopBits = ONESTOPBIT;
1046     ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
1047
1048     ZeroMemory( &timeouts, sizeof(timeouts));
1049     timeouts.ReadTotalTimeoutConstant = TIMEOUT;
1050     ok(SetCommTimeouts(hcom, &timeouts),"SetCommTimeouts failed\n");
1051
1052     ok(SetCommMask(hcom, EV_TXEMPTY), "SetCommMask failed\n");
1053
1054     before = GetTickCount();
1055     ok(WriteFile(hcom,tbuf,sizeof(tbuf),&written, NULL), "WriteFile failed\n");
1056     after = GetTickCount();
1057     ok(written == sizeof(tbuf),"WriteFile %d bytes written\n", written);
1058     diff = after -before;
1059
1060     /* make sure all bytes are written, so Readfile will succeed in one call*/
1061     ok(WaitCommEvent(hcom, &evtmask, NULL), "WaitCommEvent failed\n");
1062     before = GetTickCount();
1063     ok(evtmask == EV_TXEMPTY,
1064                  "WaitCommEvent: Unexpected EvtMask 0x%08x, expected 0x%08x\n",
1065                  evtmask, EV_TXEMPTY);
1066     trace("Write %d ms WaitCommEvent EV_TXEMPTY %d ms\n", diff, before- after);
1067
1068     read=0;
1069     ok(ReadFile(hcom, rbuf, sizeof(rbuf), &read, NULL), "Readfile failed\n");
1070     ok(read == sizeof(tbuf),"ReadFile read %d bytes, expected \"%s\"\n", read,rbuf);
1071
1072     /* Now do the same with a slower Baud rate.
1073        As we request more characters than written, we will hit the timeout
1074     */
1075
1076     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1077     dcb.BaudRate = 9600;
1078     dcb.ByteSize = 8;
1079     dcb.Parity = NOPARITY;
1080     dcb.fRtsControl=RTS_CONTROL_ENABLE;
1081     dcb.fDtrControl=DTR_CONTROL_ENABLE;
1082     dcb.StopBits = ONESTOPBIT;
1083     ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
1084
1085     ok(SetCommMask(hcom, EV_RXCHAR), "SetCommMask failed\n");
1086     ok(WriteFile(hcom,tbuf,sizeof(tbuf),&written, NULL), "WriteFile failed\n");
1087     ok(written == sizeof(tbuf),"WriteFile %d bytes written\n", written);
1088
1089     trace("WaitCommEventEV_RXCHAR\n");
1090     ok(WaitCommEvent(hcom, &evtmask, NULL), "WaitCommEvent failed\n");
1091     ok(evtmask == EV_RXCHAR, "WaitCommEvent: Unexpected EvtMask 0x%08x, expected 0x%08x\n",
1092        evtmask, EV_RXCHAR);
1093
1094     before = GetTickCount();
1095     res = ReadFile(hcom, rbuf, sizeof(rbuf), &read, NULL);
1096     after = GetTickCount();
1097     ok(res, "Readfile failed\n");
1098     ok(read == sizeof(tbuf),"ReadFile read %d bytes\n", read);
1099     diff = after - before;
1100     trace("Readfile for %d chars took %d ms\n", read, diff);
1101     ok( (diff > TIMEOUT - TIMEDELTA) && (diff < TIMEOUT + TIMEDELTA),
1102         "Timedout Wait took %d ms, expected around %d\n", diff, TIMEOUT);
1103
1104     /* now do a plain read with slow speed
1105      * This will result in several low level reads and a timeout to happen
1106      */
1107     dcb.BaudRate = SLOWBAUD;
1108     ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
1109     ok(WriteFile(hcom,tbuf,sizeof(tbuf),&written, NULL), "WriteFile failed\n");
1110     before = GetTickCount();
1111     read = 0;
1112     read1 =0;
1113     i=0;
1114     do
1115     {
1116         res = ReadFile(hcom, rbuf+read, sizeof(rbuf)-read, &read1, NULL);
1117         ok(res, "Readfile failed\n");
1118         read += read1;
1119         i++;
1120     }
1121     while ((read < sizeof(tbuf)) && (i <10));
1122     after =  GetTickCount();
1123     ok( read == sizeof(tbuf),"ReadFile read %d bytes\n", read);
1124     trace("Plain Read for %d char at %d baud took %d ms\n", read, SLOWBAUD, after-before);
1125
1126     CloseHandle(hcom);
1127 }
1128
1129 static void test_LoopbackCtsRts(void)
1130 {
1131     HANDLE hcom;
1132     DWORD ModemStat = 0, defaultStat = 0;
1133     DCB dcb;
1134
1135     if (!loopback_rts_cts) return;
1136
1137     hcom = test_OpenComm(FALSE);
1138     if (hcom == INVALID_HANDLE_VALUE) return;
1139
1140     memset (&dcb, 0, sizeof (dcb));
1141     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1142     if (dcb.fRtsControl == RTS_CONTROL_HANDSHAKE)
1143     {
1144         trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate RTS\n");
1145         CloseHandle(hcom);
1146         return;
1147     }
1148     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1149     /* XP returns some values in the low nibble, so mask them out*/
1150     defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
1151     if(defaultStat & MS_CTS_ON)
1152     {
1153         ok(EscapeCommFunction(hcom, CLRRTS), "EscapeCommFunction failed to clear RTS\n");
1154         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1155         ok ((ModemStat & MS_CTS_ON) == 0, "CTS didn't react: 0x%04x,  expected 0x%04x\n",
1156             ModemStat, (defaultStat & ~MS_CTS_ON));
1157         ok(EscapeCommFunction(hcom, SETRTS), "EscapeCommFunction failed to clear RTS\n");
1158         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1159         ok (ModemStat ==  defaultStat, "Failed to restore CTS: 0x%04x, expected 0x%04x\n",
1160             ModemStat, defaultStat);
1161     }
1162     else
1163     {
1164         ok(EscapeCommFunction(hcom, SETRTS), "EscapeCommFunction failed to set RTS\n");
1165         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1166         ok ((ModemStat & MS_CTS_ON) == MS_CTS_ON,
1167             "CTS didn't react: 0x%04x,  expected 0x%04x\n",
1168             ModemStat, (defaultStat | MS_CTS_ON));
1169         ok(EscapeCommFunction(hcom, CLRRTS), "EscapeCommFunction failed to clear RTS\n");
1170         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1171         ok (ModemStat ==  defaultStat, "Failed to restore CTS: 0x%04x, expected 0x%04x\n",
1172             ModemStat, defaultStat);
1173     }
1174
1175     CloseHandle(hcom);
1176 }
1177
1178 static void test_LoopbackDtrDcd(void)
1179 {
1180     HANDLE hcom;
1181     DWORD ModemStat = 0, defaultStat = 0;
1182     DCB dcb;
1183
1184     if (!loopback_dtr_dcd) return;
1185
1186     hcom = test_OpenComm(FALSE);
1187     if (hcom == INVALID_HANDLE_VALUE) return;
1188
1189     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1190     if (dcb.fDtrControl == DTR_CONTROL_HANDSHAKE)
1191     {
1192         trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1193         CloseHandle(hcom);
1194         return;
1195     }
1196     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1197     /* XP returns some values in the low nibble, so mask them out*/
1198     defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
1199     if(defaultStat & MS_RLSD_ON)
1200     {
1201         ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
1202         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1203         ok ((ModemStat & MS_RLSD_ON) == 0, "RLSD didn't react: 0x%04x,  expected 0x%04x\n",
1204             ModemStat, (defaultStat & ~MS_RLSD_ON));
1205         ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
1206         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1207         ok (ModemStat ==  defaultStat, "Failed to restore RLSD: 0x%04x, expected 0x%04x\n",
1208             ModemStat, defaultStat);
1209     }
1210     else
1211     {
1212         ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
1213         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1214         ok ((ModemStat & MS_RLSD_ON) == MS_RLSD_ON,
1215             "RLSD didn't react: 0x%04x,  expected 0x%04x\n",
1216             ModemStat, (defaultStat | MS_RLSD_ON));
1217         ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
1218         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1219         ok (ModemStat ==  defaultStat, "Failed to restore RLSD: 0x%04x, expected 0x%04x\n",
1220             ModemStat, defaultStat);
1221     }
1222
1223     CloseHandle(hcom);
1224 }
1225
1226 static void test_LoopbackDtrDsr(void)
1227 {
1228     HANDLE hcom;
1229     DWORD ModemStat = 0, defaultStat = 0;
1230     DCB dcb;
1231
1232     if (!loopback_dtr_dsr) return;
1233
1234     hcom = test_OpenComm(FALSE);
1235     if (hcom == INVALID_HANDLE_VALUE) return;
1236
1237     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1238     if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
1239     {
1240         trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1241         CloseHandle(hcom);
1242         return;
1243     }
1244     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1245     /* XP returns some values in the low nibble, so mask them out*/
1246     defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
1247     if(defaultStat & MS_DSR_ON)
1248     {
1249         ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
1250         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1251         ok ((ModemStat & MS_DSR_ON) == 0, "CTS didn't react: 0x%04x,  expected 0x%04x\n",
1252             ModemStat, (defaultStat & ~MS_DSR_ON));
1253         ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to clear DTR\n");
1254         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1255         ok (ModemStat ==  defaultStat, "Failed to restore DSR: 0x%04x, expected 0x%04x\n",
1256             ModemStat, defaultStat);
1257     }
1258     else
1259     {
1260         ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
1261         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1262         ok ((ModemStat & MS_DSR_ON) == MS_DSR_ON,
1263             "CTS didn't react: 0x%04x,expected 0x%04x\n",
1264             ModemStat, (defaultStat | MS_DSR_ON));
1265         ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
1266         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1267         ok (ModemStat ==  defaultStat, "Failed to restore DSR: 0x%04x, expected 0x%04x\n",
1268             ModemStat, defaultStat);
1269     }
1270
1271     CloseHandle(hcom);
1272 }
1273
1274 static void test_LoopbackDtrRing(void)
1275 {
1276     HANDLE hcom;
1277     DWORD ModemStat = 0, defaultStat = 0;
1278     DCB dcb;
1279
1280     if (!loopback_dtr_ring) return;
1281
1282     hcom = test_OpenComm(FALSE);
1283     if (hcom == INVALID_HANDLE_VALUE) return;
1284
1285     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1286     if (dcb.fDtrControl == DTR_CONTROL_HANDSHAKE)
1287     {
1288         trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1289         CloseHandle(hcom);
1290         return;
1291     }
1292     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1293     /* XP returns some values in the low nibble, so mask them out*/
1294     defaultStat &= MS_CTS_ON|MS_DSR_ON|MS_RING_ON|MS_RLSD_ON;
1295     if(defaultStat & MS_RING_ON)
1296     {
1297         ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
1298         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1299         ok ((ModemStat & MS_RING_ON) == 0, "RING didn't react: 0x%04x,  expected 0x%04x\n",
1300             ModemStat, (defaultStat & ~MS_RING_ON));
1301         ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
1302         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1303         ok (ModemStat ==  defaultStat, "Failed to restore RING: 0x%04x, expected 0x%04x\n",
1304             ModemStat, defaultStat);
1305     }
1306     else
1307     {
1308         ok(EscapeCommFunction(hcom, SETDTR), "EscapeCommFunction failed to set DTR\n");
1309         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1310         ok ((ModemStat & MS_RING_ON) == MS_RING_ON,
1311             "RING didn't react: 0x%04x,expected 0x%04x\n",
1312             ModemStat, (defaultStat | MS_RING_ON));
1313         ok(EscapeCommFunction(hcom, CLRDTR), "EscapeCommFunction failed to clear DTR\n");
1314         ok(GetCommModemStatus(hcom, &ModemStat), "GetCommModemStatus failed\n");
1315         ok (ModemStat ==  defaultStat, "Failed to restore RING: 0x%04x, expected 0x%04x\n",
1316             ModemStat, defaultStat);
1317     }
1318
1319     CloseHandle(hcom);
1320 }
1321
1322 /*
1323  * Set up a WaitCommEvent for anything in the receive buffer,
1324  * then write to TX to put a character
1325  * into the RX buffer
1326  * Need Loopback TX->RX
1327 */
1328
1329 static void test_WaitRx(void)
1330 {
1331     OVERLAPPED overlapped, overlapped_w;
1332     HANDLE hcom, hComPortEvent, hComWriteEvent;
1333     DWORD before, after, after1, diff, success_wait = FALSE, success_write;
1334     DWORD err_wait, err_write, written, evtmask=0;
1335
1336     if (!loopback_txd_rxd) return;
1337
1338     hcom = test_OpenComm(TRUE);
1339     if (hcom == INVALID_HANDLE_VALUE) return;
1340
1341     ok(SetCommMask(hcom, EV_RXCHAR), "SetCommMask failed\n");
1342     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1343     ok(hComPortEvent != 0, "CreateEvent failed\n");
1344     ZeroMemory( &overlapped, sizeof(overlapped));
1345     overlapped.hEvent = hComPortEvent;
1346
1347     hComWriteEvent = CreateEventW( NULL, TRUE, FALSE, NULL );
1348     ok(hComWriteEvent != NULL, "CreateEvent res %d\n", GetLastError());
1349     ZeroMemory( &overlapped_w, sizeof(overlapped_w));
1350     overlapped_w.hEvent = hComWriteEvent;
1351
1352     before = GetTickCount();
1353     success_wait = WaitCommEvent(hcom, &evtmask, &overlapped);
1354     err_wait = GetLastError();
1355     after = GetTickCount();
1356     trace("Success 0x%08x err %d evtmask 0x%08x\n", success_wait, err_wait, evtmask);
1357     ok(success_wait || err_wait == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1358     trace("overlapped WaitCommEvent returned.\n");
1359
1360     success_write= WriteFile(hcom, "X", 1, &written, &overlapped_w);
1361     err_write = GetLastError();
1362     ok(success_write || err_write == ERROR_IO_PENDING,
1363        "overlapped WriteFile failed, err %d\n",
1364        err_write);
1365
1366     if (!success_write && (err_write == ERROR_IO_PENDING)) {
1367       success_write = WaitForSingleObjectEx(hComWriteEvent, TIMEOUT, TRUE);
1368       err_write = GetLastError();
1369       ok(success_write == WAIT_OBJECT_0, "WaitForSingleObjectEx, res %d, err %d\n",
1370          success_write, err_write);
1371     }
1372     Sleep(TIMEOUT >>1);
1373     success_write = GetOverlappedResult(hcom, &overlapped_w, &written, FALSE);
1374     err_write = GetLastError();
1375
1376     trace("Write after Wait res 0x%08x err %d\n",success_write, err_write);
1377     ok(success_write && written ==1, "Write after Wait res 0x%08x err %d\n",
1378        success_write, err_write);
1379
1380     if (!success_wait && (err_wait == ERROR_IO_PENDING)) {
1381       success_wait = WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE);
1382       err_wait = GetLastError();
1383       ok(success_wait == WAIT_OBJECT_0, "wait hComPortEvent, res 0x%08x, err %d\n",
1384          success_wait, err_wait);
1385     }
1386     success_wait = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1387     err_wait = GetLastError();
1388     after1 = GetTickCount();
1389     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1390           success_wait, err_wait, evtmask, after-before, after1-before);
1391
1392     ok(evtmask & EV_RXCHAR, "Detect  EV_RXCHAR: 0x%08x, expected 0x%08x\n",
1393        evtmask, EV_RXCHAR);
1394     diff = after1 - before;
1395     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1396         "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1397
1398     CloseHandle(hcom);
1399 }
1400
1401 /* Change the controlling line after the given timeout to the given state
1402    By the loopback, this should trigger the WaitCommEvent
1403 */
1404 static DWORD CALLBACK toggle_ctlLine(LPVOID arg)
1405 {
1406     DWORD_PTR *args = arg;
1407     DWORD timeout = args[0];
1408     DWORD ctl     = args[1];
1409     HANDLE hcom   = (HANDLE) args[2];
1410     HANDLE hComPortEvent = (HANDLE) args[3];
1411     DWORD success, err;
1412
1413     trace("toggle_ctlLine timeout %d ctl 0x%08x handle %p\n", timeout, ctl, hcom );
1414     Sleep(timeout);
1415     ok(EscapeCommFunction(hcom, ctl),"EscapeCommFunction 0x%08x failed\n", ctl);
1416     trace("toggle_ctline done\n");
1417     success = WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE);
1418     err = GetLastError();
1419     trace("toggle_ctline WaitForSingleObjectEx res 0x%08x err %d\n",
1420           success, err);
1421     return 0;
1422 }
1423
1424 /*
1425  * Wait for a change in CTS
1426  * Needs Loopback from DTR to CTS
1427  */
1428 static void test_WaitCts(void)
1429 {
1430     DCB dcb;
1431     OVERLAPPED overlapped;
1432     HANDLE hcom, hComPortEvent, alarmThread;
1433     DWORD_PTR args[4];
1434     DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat = 0;
1435
1436     if (!loopback_rts_cts) return;
1437
1438     hcom = test_OpenComm(TRUE);
1439     if (hcom == INVALID_HANDLE_VALUE) return;
1440
1441     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1442     dcb.fRtsControl=RTS_CONTROL_ENABLE;
1443     dcb.fDtrControl=DTR_CONTROL_ENABLE;
1444     ok(SetCommState(hcom, &dcb), "SetCommState failed\n");
1445     if (dcb.fDtrControl == RTS_CONTROL_DISABLE)
1446     {
1447         trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1448         CloseHandle(hcom);
1449         return;
1450     }
1451     args[0]= TIMEOUT >>1;
1452     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1453     if(defaultStat & MS_CTS_ON)
1454         args[1] = CLRRTS;
1455     else
1456         args[1] = SETRTS;
1457     args[2]=(DWORD_PTR)hcom;
1458
1459     trace("test_WaitCts timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
1460
1461     ok(SetCommMask(hcom, EV_CTS), "SetCommMask failed\n");
1462     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1463     ok(hComPortEvent != 0, "CreateEvent failed\n");
1464     args[3] = (DWORD_PTR)hComPortEvent;
1465     alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
1466     /* Wait a minimum to let the thread start up */
1467     Sleep(10);
1468     trace("Thread created\n");
1469     ok(alarmThread !=0 , "CreateThread Failed\n");
1470
1471     ZeroMemory( &overlapped, sizeof(overlapped));
1472     overlapped.hEvent = hComPortEvent;
1473     before = GetTickCount();
1474     success = WaitCommEvent(hcom, &evtmask, &overlapped);
1475     err = GetLastError();
1476     after = GetTickCount();
1477
1478     trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
1479     ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1480     trace("overlapped WaitCommEvent returned.\n");
1481     if (!success && (err == ERROR_IO_PENDING))
1482         ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
1483                      "WaitCts hComPortEvent failed\n");
1484     success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1485     err = GetLastError();
1486     after1 = GetTickCount();
1487     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1488           success, err, evtmask, after-before, after1-before);
1489
1490     ok(evtmask & EV_CTS, "Failed to detect  EV_CTS: 0x%08x, expected 0x%08x\n",
1491                  evtmask, EV_CTS);
1492     ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
1493     if(defaultStat & MS_CTS_ON)
1494         ok((evtmask & MS_CTS_ON) == 0,"CTS didn't change state!\n");
1495     else
1496         ok((evtmask & MS_CTS_ON), "CTS didn't change state!\n");
1497
1498     diff = after1 - before;
1499     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1500                   "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1501
1502     /*restore RTS Settings*/
1503     if(defaultStat & MS_CTS_ON)
1504         args[1] = SETRTS;
1505     else
1506         args[1] = CLRRTS;
1507
1508     CloseHandle(hcom);
1509     ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
1510     CloseHandle( alarmThread );
1511 }
1512
1513 /* Change the  Comm Mask while a Wait is going on
1514    WaitCommevent should return with a EVTMASK set to zero
1515 */
1516 static DWORD CALLBACK reset_CommMask(LPVOID arg)
1517 {
1518     DWORD_PTR *args = arg;
1519     DWORD timeout = args[0];
1520     HANDLE hcom   = (HANDLE) args[1];
1521
1522     trace(" Changing CommMask on the fly for handle %p after timeout %d\n",
1523           hcom, timeout);
1524     Sleep(timeout);
1525     ok(SetCommMask(hcom, 0),"SetCommMask %p failed\n", hcom);
1526     trace("SetCommMask changed\n");
1527     return 0;
1528 }
1529
1530 /* Set up a Wait for a change on CTS. We don't toggle any line, but we
1531    reset the CommMask and expect the wait to return with a mask of 0
1532    No special port connections needed
1533 */
1534 static void test_AbortWaitCts(void)
1535 {
1536     DCB dcb;
1537     OVERLAPPED overlapped;
1538     HANDLE hcom, hComPortEvent, alarmThread;
1539     DWORD_PTR args[2];
1540     DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0;
1541
1542     hcom = test_OpenComm(TRUE);
1543     if (hcom == INVALID_HANDLE_VALUE) return;
1544
1545     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1546     if (dcb.fDtrControl == RTS_CONTROL_DISABLE)
1547     {
1548         trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1549         CloseHandle(hcom);
1550         return;
1551     }
1552     args[0]= TIMEOUT >>1;
1553     args[1]= (DWORD_PTR)hcom;
1554
1555     trace("test_AbortWaitCts timeout %ld handle %p\n",args[0], hcom);
1556
1557     ok(SetCommMask(hcom, EV_CTS), "SetCommMask failed\n");
1558     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1559     ok(hComPortEvent != 0, "CreateEvent failed\n");
1560     alarmThread = CreateThread(NULL, 0, reset_CommMask, args, 0, &alarmThreadId);
1561     /* Wait a minimum to let the thread start up */
1562     Sleep(10);
1563     trace("Thread created\n");
1564     ok(alarmThread !=0 , "CreateThread Failed\n");
1565
1566     ZeroMemory( &overlapped, sizeof(overlapped));
1567     overlapped.hEvent = hComPortEvent;
1568     before = GetTickCount();
1569     success = WaitCommEvent(hcom, &evtmask, &overlapped);
1570     err = GetLastError();
1571     after = GetTickCount();
1572
1573     trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
1574     ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1575     trace("overlapped WaitCommEvent returned.\n");
1576     if (!success && (err == ERROR_IO_PENDING))
1577         ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
1578                      "AbortWaitCts hComPortEvent failed\n");
1579     success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1580     err = GetLastError();
1581     after1 = GetTickCount();
1582     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1583           success, err, evtmask, after-before, after1-before);
1584
1585     ok(evtmask == 0, "Incorrect EventMask 0x%08x returned on Wait aborted bu SetCommMask, expected 0x%08x\n",
1586                  evtmask, 0);
1587     ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
1588     diff = after1 - before;
1589     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1590                   "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1591
1592     CloseHandle(hcom);
1593     ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
1594     CloseHandle( alarmThread );
1595 }
1596
1597 /*
1598  * Wait for a change in DSR
1599  * Needs Loopback from DTR to DSR
1600  */
1601 static void test_WaitDsr(void)
1602 {
1603     DCB dcb;
1604     OVERLAPPED overlapped;
1605     HANDLE hcom, hComPortEvent, alarmThread;
1606     DWORD_PTR args[3];
1607     DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat = 0;
1608
1609     if (!loopback_dtr_dsr) return;
1610
1611     hcom = test_OpenComm(TRUE);
1612     if (hcom == INVALID_HANDLE_VALUE) return;
1613
1614     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1615     if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
1616     {
1617         trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1618         CloseHandle(hcom);
1619         return;
1620     }
1621     args[0]= TIMEOUT >>1;
1622     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1623     if(defaultStat & MS_DSR_ON)
1624         args[1] = CLRDTR;
1625     else
1626         args[1] = SETDTR;
1627     args[2]= (DWORD_PTR)hcom;
1628
1629     trace("test_WaitDsr timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
1630
1631     ok(SetCommMask(hcom, EV_DSR), "SetCommMask failed\n");
1632     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1633     ok(hComPortEvent != 0, "CreateEvent failed\n");
1634     alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
1635     ok(alarmThread !=0 , "CreateThread Failed\n");
1636
1637     ZeroMemory( &overlapped, sizeof(overlapped));
1638     overlapped.hEvent = hComPortEvent;
1639     before = GetTickCount();
1640     success = WaitCommEvent(hcom, &evtmask, &overlapped);
1641     err = GetLastError();
1642     after = GetTickCount();
1643
1644     trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
1645     ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1646     trace("overlapped WaitCommEvent returned.\n");
1647     if (!success && (err == ERROR_IO_PENDING))
1648         ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
1649                      "wait hComPortEvent failed\n");
1650     success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1651     err = GetLastError();
1652     after1 = GetTickCount();
1653     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1654           success, err, evtmask, after-before, after1-before);
1655
1656     ok(evtmask & EV_DSR, "Failed to detect  EV_DSR: 0x%08x, expected 0x%08x\n",
1657                  evtmask, EV_DSR);
1658     ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
1659     if(defaultStat & MS_DSR_ON)
1660         ok((evtmask & MS_DSR_ON) == 0,"DTR didn't change state!\n");
1661     else
1662         ok((evtmask & MS_DSR_ON), "DTR didn't change state!\n");
1663
1664     diff = after1 - before;
1665     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1666                   "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1667
1668     /*restore RTS Settings*/
1669     if(defaultStat & MS_DSR_ON)
1670         args[1] = SETDTR;
1671     else
1672         args[1] = CLRDTR;
1673
1674     CloseHandle(hcom);
1675     ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
1676     CloseHandle( alarmThread );
1677 }
1678
1679 /*
1680  * Wait for a Ring
1681  * Needs Loopback from DTR to RING
1682  */
1683 static void test_WaitRing(void)
1684 {
1685     DCB dcb;
1686     OVERLAPPED overlapped;
1687     HANDLE hcom, hComPortEvent, alarmThread;
1688     DWORD_PTR args[3];
1689     DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat;
1690     BOOL ret;
1691
1692     if (!loopback_dtr_ring) return;
1693
1694     hcom = test_OpenComm(TRUE);
1695     if (hcom == INVALID_HANDLE_VALUE) return;
1696
1697     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1698     if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
1699     {
1700         trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1701         CloseHandle(hcom);
1702         return;
1703     }
1704     args[0]= TIMEOUT >>1;
1705     ok((ret = GetCommModemStatus(hcom, &defaultStat)), "GetCommModemStatus failed\n");
1706     if (!ret) {
1707         skip("modem status failed -> skip.\n");
1708         CloseHandle(hcom);
1709         return;
1710     }
1711     if(defaultStat & MS_RING_ON)
1712         args[1] = CLRDTR;
1713     else
1714         args[1] = SETDTR;
1715     args[2]=(DWORD_PTR) hcom;
1716
1717     trace("test_WaitRing timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
1718
1719     ok(SetCommMask(hcom, EV_RING), "SetCommMask failed\n");
1720     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1721     ok(hComPortEvent != 0, "CreateEvent failed\n");
1722     alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
1723     ok(alarmThread !=0 , "CreateThread Failed\n");
1724
1725     ZeroMemory( &overlapped, sizeof(overlapped));
1726     overlapped.hEvent = hComPortEvent;
1727     before = GetTickCount();
1728     success = WaitCommEvent(hcom, &evtmask, &overlapped);
1729     err = GetLastError();
1730     after = GetTickCount();
1731
1732     trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
1733     ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1734     trace("overlapped WaitCommEvent returned.\n");
1735     if (!success && (err == ERROR_IO_PENDING))
1736         ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
1737                      "wait hComPortEvent failed\n");
1738     success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1739     err = GetLastError();
1740     after1 = GetTickCount();
1741     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1742           success, err, evtmask, after-before, after1-before);
1743
1744     ok(evtmask & EV_RING, "Failed to detect  EV_RING: 0x%08x, expected 0x%08x\n",
1745        evtmask, EV_RING);
1746     ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
1747     if(defaultStat & MS_RING_ON)
1748         ok((evtmask & MS_RING_ON) == 0,"DTR didn't change state!\n");
1749     else
1750         ok((evtmask & MS_RING_ON), "DTR didn't change state!\n");
1751
1752     diff = after1 - before;
1753     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1754                   "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1755
1756     /*restore RTS Settings*/
1757     if(defaultStat & MS_RING_ON)
1758         args[1] = SETDTR;
1759     else
1760         args[1] = CLRDTR;
1761
1762     CloseHandle(hcom);
1763     ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
1764     CloseHandle( alarmThread );
1765 }
1766 /*
1767  * Wait for a change in DCD
1768  * Needs Loopback from DTR to DCD
1769  */
1770 static void test_WaitDcd(void)
1771 {
1772     DCB dcb;
1773     OVERLAPPED overlapped;
1774     HANDLE hcom, hComPortEvent, alarmThread;
1775     DWORD_PTR args[3];
1776     DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0, defaultStat = 0;
1777
1778     if (!loopback_dtr_dcd) return;
1779
1780     hcom = test_OpenComm(TRUE);
1781     if (hcom == INVALID_HANDLE_VALUE) return;
1782
1783     ok(GetCommState(hcom, &dcb), "GetCommState failed\n");
1784     if (dcb.fDtrControl == DTR_CONTROL_DISABLE)
1785     {
1786         trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1787         CloseHandle(hcom);
1788         return;
1789     }
1790     args[0]= TIMEOUT >>1;
1791     ok(GetCommModemStatus(hcom, &defaultStat), "GetCommModemStatus failed\n");
1792     if(defaultStat & MS_RLSD_ON)
1793         args[1] = CLRDTR;
1794     else
1795         args[1] = SETDTR;
1796     args[2]= (DWORD_PTR)hcom;
1797
1798     trace("test_WaitDcd timeout %ld clt 0x%08lx handle %p\n",args[0], args[1], hcom);
1799
1800     ok(SetCommMask(hcom, EV_RLSD), "SetCommMask failed\n");
1801     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1802     ok(hComPortEvent != 0, "CreateEvent failed\n");
1803     alarmThread = CreateThread(NULL, 0, toggle_ctlLine, args, 0, &alarmThreadId);
1804     ok(alarmThread !=0 , "CreateThread Failed\n");
1805
1806     ZeroMemory( &overlapped, sizeof(overlapped));
1807     overlapped.hEvent = hComPortEvent;
1808     before = GetTickCount();
1809     success = WaitCommEvent(hcom, &evtmask, &overlapped);
1810     err = GetLastError();
1811     after = GetTickCount();
1812
1813     trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
1814     ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1815     trace("overlapped WaitCommEvent returned.\n");
1816     if (!success && (err == ERROR_IO_PENDING))
1817         ok(WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE) == 0,
1818                      "wait hComPortEvent failed\n");
1819     success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1820     err = GetLastError();
1821     after1 = GetTickCount();
1822     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1823           success, err, evtmask, after-before, after1-before);
1824
1825     ok(evtmask & EV_RLSD, "Failed to detect  EV_RLSD: 0x%08x, expected 0x%08x\n",
1826                  evtmask, EV_RLSD);
1827     ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
1828     if(defaultStat & MS_RLSD_ON)
1829         ok((evtmask & MS_RLSD_ON) == 0,"DTR didn't change state!\n");
1830     else
1831         ok((evtmask & MS_RLSD_ON), "DTR didn't change state!\n");
1832
1833     diff = after1 - before;
1834     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1835                   "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1836
1837     /*restore RTS Settings*/
1838     if(defaultStat & MS_RLSD_ON)
1839         args[1] = SETDTR;
1840     else
1841         args[1] = CLRDTR;
1842
1843     CloseHandle(hcom);
1844     ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
1845     CloseHandle( alarmThread );
1846 }
1847
1848 /*
1849    Set Break after timeout
1850 */
1851 static DWORD CALLBACK set_CommBreak(LPVOID arg)
1852 {
1853     DWORD_PTR *args = arg;
1854     DWORD timeout = args[0];
1855     HANDLE hcom   = (HANDLE) args[1];
1856
1857     trace("SetCommBreak for handle %p after timeout %d\n",
1858           hcom, timeout);
1859     Sleep(timeout);
1860     ok(SetCommBreak(hcom),"SetCommBreak %p failed\n", hcom);
1861     trace("SetCommBreak done\n");
1862     return 0;
1863 }
1864
1865 /*
1866    Wait for the Break condition (TX resp. RX active)
1867    Needs Loopback TX-RX
1868 */
1869 static void test_WaitBreak(void)
1870 {
1871     OVERLAPPED overlapped;
1872     HANDLE hcom, hComPortEvent, alarmThread;
1873     DWORD_PTR args[2];
1874     DWORD alarmThreadId, before, after, after1, diff, success, err, written, evtmask=0;
1875
1876     if (!loopback_txd_rxd) return;
1877
1878     hcom = test_OpenComm(TRUE);
1879     if (hcom == INVALID_HANDLE_VALUE) return;
1880
1881     ok(SetCommMask(hcom, EV_BREAK), "SetCommMask failed\n");
1882     hComPortEvent =  CreateEventW( NULL, TRUE, FALSE, NULL );
1883     ok(hComPortEvent != 0, "CreateEvent failed\n");
1884
1885     trace("test_WaitBreak\n");
1886     args[0]= TIMEOUT >>1;
1887     args[1]= (DWORD_PTR)hcom;
1888     alarmThread = CreateThread(NULL, 0, set_CommBreak, args, 0, &alarmThreadId);
1889     /* Wait a minimum to let the thread start up */
1890     Sleep(10);
1891     trace("Thread created\n");
1892     ok(alarmThread !=0 , "CreateThread Failed\n");
1893
1894     ZeroMemory( &overlapped, sizeof(overlapped));
1895     overlapped.hEvent = hComPortEvent;
1896     before = GetTickCount();
1897     success = WaitCommEvent(hcom, &evtmask, &overlapped);
1898     err = GetLastError();
1899     after = GetTickCount();
1900
1901     trace("Success 0x%08x err %d evtmask 0x%08x\n", success, err, evtmask);
1902     ok(success || err == ERROR_IO_PENDING, "overlapped WaitCommEvent failed\n");
1903     trace("overlapped WaitCommEvent returned.\n");
1904
1905     if (!success && (err == ERROR_IO_PENDING))
1906     {
1907         success = WaitForSingleObjectEx(hComPortEvent, TIMEOUT, TRUE);
1908         ok(!success, "wait hComPortEvent res %d\n", GetLastError());
1909     }
1910     success = GetOverlappedResult(hcom, &overlapped, &written, FALSE);
1911     err = GetLastError();
1912     after1 = GetTickCount();
1913     trace("Success 0x%08x err %d evtmask 0x%08x diff1 %d, diff2 %d\n",
1914           success, err, evtmask, after-before, after1-before);
1915
1916     ok(evtmask & EV_BREAK, "Failed to detect  EV_BREAK: 0x%08x, expected 0x%08x\n",
1917        evtmask, EV_BREAK);
1918     ok(GetCommModemStatus(hcom, &evtmask), "GetCommModemStatus failed\n");
1919
1920     diff = after1 - before;
1921     ok ((diff > (TIMEOUT>>1) -TIMEDELTA) && (diff < (TIMEOUT>>1) + TIMEDELTA),
1922         "Unexpected time %d, expected around %d\n", diff, TIMEOUT>>1);
1923
1924     ok(ClearCommBreak(hcom), "ClearCommBreak failed\n");
1925
1926     CloseHandle(hcom);
1927     ok( !WaitForSingleObject( alarmThread, 10000 ), "thread still running\n" );
1928     CloseHandle( alarmThread );
1929 }
1930
1931 static void test_stdio(void)
1932 {
1933     DCB dcb;
1934
1935     /* cygwin tries this to determine the stdin handle type */
1936     ok( !GetCommState( GetStdHandle(STD_INPUT_HANDLE), &dcb ), "GetCommState succeeded on stdin\n" );
1937     ok( GetLastError() == ERROR_INVALID_HANDLE || GetLastError() == ERROR_INVALID_FUNCTION,
1938         "got error %u\n", GetLastError() );
1939 }
1940
1941 static void test_WaitCommEvent(void)
1942 {
1943     HANDLE hcom;
1944     DWORD evtmask, ret, bytes, before, after, last_event_time;
1945     OVERLAPPED ovl_wait;
1946
1947     hcom = test_OpenComm(TRUE);
1948     if (hcom == INVALID_HANDLE_VALUE) return;
1949
1950     test_GetModemStatus(hcom);
1951
1952     ret = SetCommMask(hcom, 0x1fff);
1953     ok(ret, "SetCommMask error %d\n", GetLastError());
1954
1955     S(U(ovl_wait)).Offset = 0;
1956     S(U(ovl_wait)).OffsetHigh = 0;
1957     ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
1958
1959     trace("waiting 10 secs for com port events (turn on/off the device)...\n");
1960     last_event_time = 0;
1961     before = GetTickCount();
1962     do
1963     {
1964         evtmask = 0;
1965         SetLastError(0xdeadbeef);
1966         ret = WaitCommEvent(hcom, &evtmask, &ovl_wait);
1967         ok(!ret && GetLastError() == ERROR_IO_PENDING, "WaitCommEvent returned %d, error %d\n", ret, GetLastError());
1968         if (GetLastError() != ERROR_IO_PENDING) goto done; /* no point in further testing */
1969         for (;;)
1970         {
1971             ret = WaitForSingleObject(ovl_wait.hEvent, 500);
1972             after = GetTickCount();
1973             if (ret == WAIT_OBJECT_0)
1974             {
1975                 last_event_time = after;
1976                 ret = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
1977                 ok(ret, "GetOverlappedResult reported error %d\n", GetLastError());
1978                 ok(bytes == sizeof(evtmask), "expected %u, written %u\n", (UINT)sizeof(evtmask), bytes);
1979                 trace("WaitCommEvent: got events %#x\n", evtmask);
1980                 test_GetModemStatus(hcom);
1981                 break;
1982             }
1983             else
1984             {
1985                 if (last_event_time || after - before >= 10000) goto done;
1986             }
1987         }
1988     } while (after - before < 10000);
1989
1990 done:
1991     CloseHandle(ovl_wait.hEvent);
1992     CloseHandle(hcom);
1993 }
1994
1995 static void test_FlushFileBuffers(void)
1996 {
1997     HANDLE hcom;
1998     DWORD  ret, bytes, errors;
1999     COMSTAT stat;
2000
2001     hcom = test_OpenComm(FALSE);
2002     if (hcom == INVALID_HANDLE_VALUE) return;
2003
2004     ret = WriteFile(hcom, "\0\0\0\0\0\0\0", 7, &bytes, NULL);
2005     ok(ret, "WriteFile error %d\n", GetLastError());
2006     ok(bytes == 7, "expected 7, got %u\n", bytes);
2007
2008     ret = FlushFileBuffers(hcom);
2009     ok(ret, "FlushFileBuffers error %d\n", GetLastError());
2010
2011     ret = ClearCommError(hcom, &errors, &stat);
2012     ok(ret, "ClearCommError error %d\n", GetLastError());
2013     ok(stat.cbInQue == 0, "expected 0, got %d bytes in InQueue\n", stat.cbInQue);
2014     ok(stat.cbOutQue == 0, "expected 0, got %d bytes in OutQueue\n", stat.cbOutQue);
2015     ok(errors == 0, "expected errors 0, got %#x\n", errors);
2016
2017     CloseHandle(hcom);
2018 }
2019
2020 static void test_read_write(void)
2021 {
2022     static const char atz[]="ATZ\r\n";
2023     char buf[256];
2024     HANDLE hcom;
2025     DCB dcb;
2026     COMMTIMEOUTS timeouts;
2027     DWORD ret, bytes, status, evtmask, before, after, last_event_time;
2028     OVERLAPPED ovl_wait;
2029     IO_STATUS_BLOCK iob;
2030     LARGE_INTEGER offset;
2031     LONG i;
2032
2033     if (!pNtReadFile || !pNtWriteFile)
2034     {
2035         win_skip("not running on NT, skipping test\n");
2036         return;
2037     }
2038
2039     hcom = test_OpenComm(TRUE);
2040     if (hcom == INVALID_HANDLE_VALUE) return;
2041
2042     ret = GetCommState(hcom, &dcb);
2043     ok(ret, "GetCommState error %d\n", GetLastError());
2044     dcb.BaudRate = 9600;
2045     dcb.ByteSize = 8;
2046     dcb.Parity = NOPARITY;
2047     dcb.fRtsControl = RTS_CONTROL_ENABLE;
2048     dcb.fDtrControl = DTR_CONTROL_ENABLE;
2049     dcb.StopBits = ONESTOPBIT;
2050     ret = SetCommState(hcom, &dcb);
2051     ok(ret, "SetCommState error %d\n", GetLastError());
2052
2053     memset(&timeouts, 0, sizeof(timeouts));
2054     timeouts.ReadTotalTimeoutConstant = TIMEOUT;
2055     ret = SetCommTimeouts(hcom, &timeouts);
2056     ok(ret,"SetCommTimeouts error %d\n", GetLastError());
2057
2058     ret = SetupComm(hcom, 1024, 1024);
2059     ok(ret, "SetUpComm error %d\n", GetLastError());
2060
2061     bytes = 0xdeadbeef;
2062     SetLastError(0xdeadbeef);
2063     ret = WriteFile(hcom, atz, 0, &bytes, NULL);
2064     ok(!ret, "WriteFile should fail\n");
2065     ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2066     ok(bytes == 0, "bytes %u\n", bytes);
2067
2068     U(iob).Status = -1;
2069     iob.Information = -1;
2070     status = pNtWriteFile(hcom, 0, NULL, NULL, &iob, atz, 0, NULL, NULL);
2071     ok(status == STATUS_INVALID_PARAMETER, "expected STATUS_INVALID_PARAMETER, got %#x\n", status);
2072     ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status);
2073     ok(iob.Information == -1, "expected -1, got %ld\n", iob.Information);
2074
2075     for (i = -20; i < 20; i++)
2076     {
2077         U(iob).Status = -1;
2078         iob.Information = -1;
2079         offset.QuadPart = (LONGLONG)i;
2080         status = pNtWriteFile(hcom, 0, NULL, NULL, &iob, atz, 0, &offset, NULL);
2081         if (i >= 0 || i == -1)
2082         {
2083             ok(status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, status);
2084             ok(U(iob).Status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, U(iob).Status);
2085             ok(iob.Information == 0, "%d: expected 0, got %lu\n", i, iob.Information);
2086         }
2087         else
2088         {
2089             ok(status == STATUS_INVALID_PARAMETER, "%d: expected STATUS_INVALID_PARAMETER, got %#x\n", i, status);
2090             ok(U(iob).Status == -1, "%d: expected -1, got %#x\n", i, U(iob).Status);
2091             ok(iob.Information == -1, "%d: expected -1, got %ld\n", i, iob.Information);
2092         }
2093     }
2094
2095     U(iob).Status = -1;
2096     iob.Information = -1;
2097     offset.QuadPart = 0;
2098     status = pNtWriteFile(hcom, 0, NULL, NULL, &iob, atz, sizeof(atz), &offset, NULL);
2099     ok(status == STATUS_PENDING || status == STATUS_SUCCESS, "expected STATUS_PENDING or STATUS_SUCCESS, got %#x\n", status);
2100     /* Under Windows checking IO_STATUS_BLOCK right after the call leads
2101      * to races, iob.Status is either -1 or STATUS_SUCCESS, which means
2102      * that it's set only when the operation completes.
2103      */
2104     ret = WaitForSingleObject(hcom, TIMEOUT);
2105     if (ret == WAIT_TIMEOUT)
2106     {
2107         skip("Probably modem is not connected.\n");
2108         CloseHandle(hcom);
2109         return;
2110     }
2111     ok(ret == WAIT_OBJECT_0, "WaitForSingleObject error %d\n", ret);
2112     ok(U(iob).Status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x\n", U(iob).Status);
2113     ok(iob.Information == sizeof(atz), "expected sizeof(atz), got %lu\n", iob.Information);
2114
2115     ret = SetCommMask(hcom, EV_RXCHAR);
2116     ok(ret, "SetCommMask error %d\n", GetLastError());
2117
2118     S(U(ovl_wait)).Offset = 0;
2119     S(U(ovl_wait)).OffsetHigh = 0;
2120     ovl_wait.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
2121
2122     trace("waiting 3 secs for modem response...\n");
2123     last_event_time = 0;
2124     before = GetTickCount();
2125     do
2126     {
2127         evtmask = 0;
2128         SetLastError(0xdeadbeef);
2129         ret = WaitCommEvent(hcom, &evtmask, &ovl_wait);
2130         ok(!ret && GetLastError() == ERROR_IO_PENDING, "WaitCommEvent returned %d, error %d\n", ret, GetLastError());
2131         if (GetLastError() != ERROR_IO_PENDING) goto done; /* no point in further testing */
2132         for (;;)
2133         {
2134             ret = WaitForSingleObject(ovl_wait.hEvent, 100);
2135             after = GetTickCount();
2136             if (ret == WAIT_OBJECT_0)
2137             {
2138                 trace("got modem response.\n");
2139
2140                 last_event_time = after;
2141                 ret = GetOverlappedResult(hcom, &ovl_wait, &bytes, FALSE);
2142                 ok(ret, "GetOverlappedResult reported error %d\n", GetLastError());
2143                 ok(bytes == sizeof(evtmask), "expected sizeof(evtmask), got %u\n", bytes);
2144                 ok(evtmask & EV_RXCHAR, "EV_RXCHAR should be set\n");
2145
2146                 bytes = 0xdeadbeef;
2147                 SetLastError(0xdeadbeef);
2148                 ret = ReadFile(hcom, buf, 0, &bytes, NULL);
2149                 ok(!ret, "ReadFile should fail\n");
2150                 ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2151                 ok(bytes == 0, "bytes %u\n", bytes);
2152
2153                 U(iob).Status = -1;
2154                 iob.Information = -1;
2155                 status = pNtReadFile(hcom, 0, NULL, NULL, &iob, buf, 0, NULL, NULL);
2156                 ok(status == STATUS_INVALID_PARAMETER, "expected STATUS_INVALID_PARAMETER, got %#x\n", status);
2157                 ok(U(iob).Status == -1, "expected -1, got %#x\n", U(iob).Status);
2158                 ok(iob.Information == -1, "expected -1, got %ld\n", iob.Information);
2159
2160                 for (i = -20; i < 20; i++)
2161                 {
2162                     U(iob).Status = -1;
2163                     iob.Information = -1;
2164                     offset.QuadPart = (LONGLONG)i;
2165                     status = pNtReadFile(hcom, 0, NULL, NULL, &iob, buf, 0, &offset, NULL);
2166                     if (i >= 0)
2167                     {
2168                         ok(status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, status);
2169                         ok(U(iob).Status == STATUS_SUCCESS, "%d: expected STATUS_SUCCESS, got %#x\n", i, U(iob).Status);
2170                         ok(iob.Information == 0, "%d: expected 0, got %lu\n", i, iob.Information);
2171                     }
2172                     else
2173                     {
2174                         ok(status == STATUS_INVALID_PARAMETER, "%d: expected STATUS_INVALID_PARAMETER, got %#x\n", i, status);
2175                         ok(U(iob).Status == -1, "%d: expected -1, got %#x\n", i, U(iob).Status);
2176                         ok(iob.Information == -1, "%d: expected -1, got %ld\n", i, iob.Information);
2177                     }
2178                 }
2179
2180                 U(iob).Status = -1;
2181                 iob.Information = -1;
2182                 offset.QuadPart = 0;
2183                 status = pNtReadFile(hcom, 0, NULL, NULL, &iob, buf, 1, &offset, NULL);
2184                 ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x\n", status);
2185                 ok(U(iob).Status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %#x\n", U(iob).Status);
2186                 ok(iob.Information == 1, "expected 1, got %lu\n", iob.Information);
2187                 goto done;
2188             }
2189             else
2190             {
2191                 if (last_event_time || after - before >= 3000) goto done;
2192             }
2193         }
2194     } while (after - before < 3000);
2195
2196 done:
2197     CloseHandle(ovl_wait.hEvent);
2198     CloseHandle(hcom);
2199 }
2200
2201 START_TEST(comm)
2202 {
2203     HMODULE ntdll = GetModuleHandleA("ntdll.dll");
2204     if (ntdll)
2205     {
2206         pNtReadFile = (void *)GetProcAddress(ntdll, "NtReadFile");
2207         pNtWriteFile = (void *)GetProcAddress(ntdll, "NtWriteFile");
2208     }
2209
2210     test_ClearCommError(); /* keep it the very first test */
2211     test_FlushFileBuffers();
2212     test_BuildCommDCB();
2213     test_ReadTimeOut();
2214     test_waittxempty();
2215     test_non_pending_errors();
2216     test_LoopbackRead();
2217     test_LoopbackCtsRts();
2218     test_LoopbackDtrDsr();
2219     test_LoopbackDtrRing();
2220     test_LoopbackDtrDcd();
2221     test_WaitRx();
2222     test_WaitCts();
2223     test_AbortWaitCts();
2224     test_WaitDsr();
2225     test_WaitRing();
2226     test_WaitDcd();
2227     test_WaitBreak();
2228     test_stdio();
2229     test_read_write();
2230
2231     if (!winetest_interactive)
2232     {
2233         skip("interactive tests (set WINETEST_INTERACTIVE=1)\n");
2234         return;
2235     }
2236
2237     test_WaitCommEvent();
2238 }