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 } 2239