1 /* Unit test suite for comm functions
3 * Copyright 2003 Kevin Groeneveld
4 * Copyright 2005 Uwe Bonnes
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.
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.
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
24 #define WIN32_NO_STATUS
25 #include "wine/test.h"
30 #define TIMEOUT 1000 /* one second for Timeouts*/
32 #define FASTBAUD 115200
33 #define TIMEDELTA 150 /* 150 ms uncertainty allowed */
35 /* Define the appropriate LOOPBACK(s) TRUE if you have a Loopback cable with
36 * the mentioned shorts connected to your Serial port
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
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
;
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
);
70 COMMTIMEOUTS timeouts1
, timeouts2
;
73 static const TEST test
[] =
76 "baud=9600 parity=e data=5 stop=1 xon=on odsr=off octs=off dtr=on rts=on idsr=on",
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 }
84 "baud=0 parity=M data=6 stop=1.5 xon=off odsr=on octs=ON dtr=off rts=off idsr=OFF",
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 }
92 "BAUD=4000000000 parity=n data=7 stop=2 to=off",
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 }
100 "Baud=115200 Parity=O Data=8 To=On",
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 }
108 "PaRiTy=s Data=7 DTR=on",
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
268 "4000000000,O,7,1.5,X",
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
340 "COMx:baud=38400 data=8",
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 }
348 "COMx :to=on stop=1.5",
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 }
356 "COMx: baud=12345 data=7",
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 }
364 "COMx : xon=on odsr=off",
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 }
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 }
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 }
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 }
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 }
404 "COMx : 57600,S,6,2,x",
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 }
413 #define TEST_COUNT (sizeof(test) / sizeof(TEST))
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)
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",
427 pdcb->fDsrSensitivity,
428 pdcb->fTXContinueOnXoff,
442 pdcb->XonChar & 0xff,
443 pdcb->XoffChar & 0xff,
444 pdcb->ErrorChar & 0xff,
445 pdcb->EofChar & 0xff,
446 pdcb->EvtChar & 0xff,
447 pdcb->wReserved1 & 0xffff );
450 static void check_result(const char *function
, const TEST
*ptest
, int initial_value
, BOOL result
)
452 DWORD LastError
= GetLastError();
453 DWORD CorrectError
= (ptest
->result
? 0xdeadbeef : ERROR_INVALID_PARAMETER
);
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");
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); }
462 static void check_dcb(const char *function
, const TEST
*ptest
, int initial_value
, const DCB
*pdcb1
, const DCB
*pdcb2
)
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");
468 /* For old style control strings Win 9x does not set the next five members, NT does. */
469 if(ptest
->old_style
&& ptest
->result
)
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");
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");
488 /* For the idsr=xxx parameter, NT sets fDsrSensitivity, 9x sets
490 if(!ptest
->old_style
)
492 check_dcb_member2(fOutxDsrFlow
, pdcb2
->fDsrSensitivity
, "%u");
493 check_dcb_member2(fDsrSensitivity
, pdcb2
->fOutxDsrFlow
, "%u");
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");
505 check_dcb_member(fOutxDsrFlow
, "%u");
506 check_dcb_member(fDsrSensitivity
, "%u");
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");
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);
534 static void check_timeouts(const char *function
, const TEST
*ptest
, int initial_value
, const COMMTIMEOUTS
*ptimeouts1
, const COMMTIMEOUTS
*ptimeouts2
)
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
);
543 static void test_BuildCommDCBA(const char *string
, const TEST
*ptest
, int initial_value
, const DCB
*pexpected_dcb
)
548 /* set initial conditions */
549 memset(&dcb
, initial_value
, sizeof(DCB
));
550 SetLastError(0xdeadbeef);
552 result
= BuildCommDCBA(string
, &dcb
);
555 check_result("BuildCommDCBA", ptest
, initial_value
, result
);
556 check_dcb("BuildCommDCBA", ptest
, initial_value
, &dcb
, pexpected_dcb
);
559 static void test_BuildCommDCBAndTimeoutsA(const char *string
, const TEST
*ptest
, int initial_value
, const DCB
*pexpected_dcb
, const COMMTIMEOUTS
*pexpected_timeouts
)
563 COMMTIMEOUTS timeouts
;
565 /* set initial conditions */
566 memset(&dcb
, initial_value
, sizeof(DCB
));
567 memset(&timeouts
, initial_value
, sizeof(COMMTIMEOUTS
));
568 SetLastError(0xdeadbeef);
570 result
= BuildCommDCBAndTimeoutsA(string
, &dcb
, &timeouts
);
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
);
578 static void test_BuildCommDCBW(const char *string
, const TEST
*ptest
, int initial_value
, const DCB
*pexpected_dcb
)
582 WCHAR wide_string
[sizeof(ptest
->string
)];
583 static int reportedDCBW
= 0;
585 MultiByteToWideChar(CP_ACP
, 0, string
, -1, wide_string
, sizeof(wide_string
) / sizeof(WCHAR
));
587 /* set initial conditions */
588 memset(&dcb
, initial_value
, sizeof(DCB
));
589 SetLastError(0xdeadbeef);
591 result
= BuildCommDCBW(wide_string
, &dcb
);
593 if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
596 win_skip("BuildCommDCBW is not implemented\n");
601 check_result("BuildCommDCBW", ptest
, initial_value
, result
);
602 check_dcb("BuildCommDCBW", ptest
, initial_value
, &dcb
, pexpected_dcb
);
605 static void test_BuildCommDCBAndTimeoutsW(const char *string
, const TEST
*ptest
, int initial_value
, const DCB
*pexpected_dcb
, const COMMTIMEOUTS
*pexpected_timeouts
)
609 COMMTIMEOUTS timeouts
;
610 WCHAR wide_string
[sizeof(ptest
->string
)];
611 static int reportedDCBAndTW
= 0;
613 MultiByteToWideChar(CP_ACP
, 0, string
, -1, wide_string
, sizeof(wide_string
) / sizeof(WCHAR
));
615 /* set initial conditions */
616 memset(&dcb
, initial_value
, sizeof(DCB
));
617 memset(&timeouts
, initial_value
, sizeof(COMMTIMEOUTS
));
618 SetLastError(0xdeadbeef);
620 result
= BuildCommDCBAndTimeoutsW(wide_string
, &dcb
, &timeouts
);
622 if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
624 if(!reportedDCBAndTW
++)
625 win_skip("BuildCommDCBAndTimeoutsW is not implemented\n");
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
);
635 static void test_BuildCommDCB(void)
637 char port_name
[] = "COMx";
642 /* Some of these tests require a valid COM port. This loop will try to find
644 for(port_name
[3] = '1'; port_name
[3] <= '9'; port_name
[3]++)
646 COMMCONFIG commconfig
;
647 DWORD size
= sizeof(COMMCONFIG
);
649 if(GetDefaultCommConfigA(port_name
, &commconfig
, &size
))
657 trace("Could not find a valid COM port. Some tests will be skipped.\n");
659 for(i
= 0; i
< TEST_COUNT
; i
++)
661 char string
[sizeof(test
[i
].string
)];
663 strcpy(string
, test
[i
].string
);
665 /* Check if this test case needs a valid COM port. */
666 ptr
= strstr(string
, "COMx");
668 /* If required, substitute valid port number into device control string. */
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
);
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
);
689 static HANDLE
test_OpenComm(BOOL doOverlap
)
691 HANDLE hcom
= INVALID_HANDLE_VALUE
;
692 char port_name
[] = "COMx";
693 static BOOL shown
= FALSE
;
697 /* Try to find a port */
698 for(port_name
[3] = '1'; port_name
[3] <= '9'; port_name
[3]++)
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
)
707 if (hcom
== INVALID_HANDLE_VALUE
)
708 trace("Could not find a valid COM port.\n");
710 trace("Found Com port %s. Connected devices may disturb results\n", port_name
);
713 if (hcom
!= INVALID_HANDLE_VALUE
)
717 ret
= ClearCommError(hcom
, &errors
, &comstat
);
718 if (!ret
&& (GetLastError() == ERROR_NOT_READY
|| GetLastError() == ERROR_INVALID_HANDLE
))
720 if (GetLastError() == ERROR_NOT_READY
)
721 trace("%s doesn't respond, skipping the test\n", port_name
);
723 trace("%s is not a real serial port, skipping the test\n", port_name
);
725 return INVALID_HANDLE_VALUE
;
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
);
736 static void test_GetModemStatus(HANDLE hcom
)
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 ":"");
748 /* When we don't write anything, Read should time out even on a loopbacked port */
749 static void test_ReadTimeOut(void)
753 COMMTIMEOUTS timeouts
;
755 DWORD before
, after
, read
, timediff
, LastError
;
758 hcom
= test_OpenComm(FALSE
);
759 if (hcom
== INVALID_HANDLE_VALUE
) return;
761 test_GetModemStatus(hcom
);
763 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
764 dcb
.BaudRate
= FASTBAUD
;
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");
772 ZeroMemory( &timeouts
, sizeof(timeouts
));
773 timeouts
.ReadTotalTimeoutConstant
= TIMEOUT
;
774 ok(SetCommTimeouts(hcom
, &timeouts
),"SetCommTimeouts failed\n");
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
);
790 static void test_waittxempty(void)
794 COMMTIMEOUTS timeouts
;
795 char tbuf
[]="test_waittxempty";
796 DWORD before
, after
, bytes
, timediff
, evtmask
, errors
, i
;
798 DWORD baud
= SLOWBAUD
;
799 OVERLAPPED ovl_write
, ovl_wait
, ovl_wait2
;
802 hcom
= test_OpenComm(TRUE
);
803 if (hcom
== INVALID_HANDLE_VALUE
) return;
805 /* set a low baud rate to have ample time*/
806 res
= GetCommState(hcom
, &dcb
);
807 ok(res
, "GetCommState error %d\n", GetLastError());
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());
817 ZeroMemory( &timeouts
, sizeof(timeouts
));
818 timeouts
.ReadTotalTimeoutConstant
= TIMEOUT
;
819 res
= SetCommTimeouts(hcom
, &timeouts
);
820 ok(res
,"SetCommTimeouts error %d\n", GetLastError());
822 res
= SetupComm(hcom
, 1024, 1024);
823 ok(res
, "SetUpComm error %d\n", GetLastError());
825 /* calling SetCommMask after WriteFile leads to WaitCommEvent failures
826 * due to timeout (no events) under testbot VMs and VirtualBox
828 res
= SetCommMask(hcom
, EV_TXEMPTY
);
829 ok(res
, "SetCommMask error %d\n", GetLastError());
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());
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 */
850 S(U(ovl_wait
)).Offset
= 0;
851 S(U(ovl_wait
)).OffsetHigh
= 0;
852 ovl_wait
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
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
)
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
);
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());
876 res
= WaitForSingleObject(ovl_wait
.hEvent
, TIMEOUT
);
877 ok(res
== WAIT_OBJECT_0
, "WaitCommEvent failed with a timeout\n");
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
);
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
);
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
);
899 for (i
= 0; i
< 2; i
++)
901 hcom
= test_OpenComm(TRUE
);
902 if (hcom
== INVALID_HANDLE_VALUE
) return;
904 res
= SetCommMask(hcom
, EV_TXEMPTY
);
905 ok(res
, "SetCommMask error %d\n", GetLastError());
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
);
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
);
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
);
929 res
= FlushFileBuffers(hcom
);
930 ok(res
, "FlushFileBuffers error %d\n", GetLastError());
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
);
938 S(U(ovl_wait
)).Offset
= 0;
939 S(U(ovl_wait
)).OffsetHigh
= 0;
940 ovl_wait
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
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());
947 res
= WaitForSingleObject(ovl_wait
.hEvent
, TIMEOUT
);
949 ok(res
== WAIT_OBJECT_0
, "WaitCommEvent failed with a timeout\n");
951 ok(res
== WAIT_TIMEOUT
, "WaitCommEvent should fail with a timeout\n");
952 if (res
== WAIT_OBJECT_0
)
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
);
962 ok(!evtmask
, "WaitCommEvent: expected 0, got %#x\n", evtmask
);
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
);
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());
978 res
= WaitForSingleObject(ovl_wait
.hEvent
, TIMEOUT
);
979 ok(res
== WAIT_OBJECT_0
, "WaitCommEvent failed with a timeout\n");
980 CloseHandle(ovl_wait
.hEvent
);
987 /* A new open handle should not return error or have bytes in the Queues */
988 static void test_ClearCommError(void)
994 hcom
= test_OpenComm(FALSE
);
995 if (hcom
== INVALID_HANDLE_VALUE
) return;
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
);
1005 static void test_non_pending_errors(void)
1011 hcom
= test_OpenComm(FALSE
);
1012 if (hcom
== INVALID_HANDLE_VALUE
) return;
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
);
1023 static void test_LoopbackRead(void)
1027 COMMTIMEOUTS timeouts
;
1029 DWORD before
, after
, diff
, read
, read1
, written
, evtmask
=0, i
;
1031 char tbuf
[]="test_LoopbackRead";
1033 if (!loopback_txd_rxd
) return;
1035 hcom
= test_OpenComm(FALSE
);
1036 if (hcom
== INVALID_HANDLE_VALUE
) return;
1038 trace("Starting test_LoopbackRead\n");
1039 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1040 dcb
.BaudRate
= FASTBAUD
;
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");
1048 ZeroMemory( &timeouts
, sizeof(timeouts
));
1049 timeouts
.ReadTotalTimeoutConstant
= TIMEOUT
;
1050 ok(SetCommTimeouts(hcom
, &timeouts
),"SetCommTimeouts failed\n");
1052 ok(SetCommMask(hcom
, EV_TXEMPTY
), "SetCommMask failed\n");
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
;
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
);
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
);
1072 /* Now do the same with a slower Baud rate.
1073 As we request more characters than written, we will hit the timeout
1076 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1077 dcb
.BaudRate
= 9600;
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");
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
);
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
);
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
);
1104 /* now do a plain read with slow speed
1105 * This will result in several low level reads and a timeout to happen
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();
1116 res
= ReadFile(hcom
, rbuf
+read
, sizeof(rbuf
)-read
, &read1
, NULL
);
1117 ok(res
, "Readfile failed\n");
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
);
1129 static void test_LoopbackCtsRts(void)
1132 DWORD ModemStat
= 0, defaultStat
= 0;
1135 if (!loopback_rts_cts
) return;
1137 hcom
= test_OpenComm(FALSE
);
1138 if (hcom
== INVALID_HANDLE_VALUE
) return;
1140 memset (&dcb
, 0, sizeof (dcb
));
1141 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1142 if (dcb
.fRtsControl
== RTS_CONTROL_HANDSHAKE
)
1144 trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate RTS\n");
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
)
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
);
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
);
1178 static void test_LoopbackDtrDcd(void)
1181 DWORD ModemStat
= 0, defaultStat
= 0;
1184 if (!loopback_dtr_dcd
) return;
1186 hcom
= test_OpenComm(FALSE
);
1187 if (hcom
== INVALID_HANDLE_VALUE
) return;
1189 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1190 if (dcb
.fDtrControl
== DTR_CONTROL_HANDSHAKE
)
1192 trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
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
)
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
);
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
);
1226 static void test_LoopbackDtrDsr(void)
1229 DWORD ModemStat
= 0, defaultStat
= 0;
1232 if (!loopback_dtr_dsr
) return;
1234 hcom
= test_OpenComm(FALSE
);
1235 if (hcom
== INVALID_HANDLE_VALUE
) return;
1237 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1238 if (dcb
.fDtrControl
== DTR_CONTROL_DISABLE
)
1240 trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
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
)
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
);
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
);
1274 static void test_LoopbackDtrRing(void)
1277 DWORD ModemStat
= 0, defaultStat
= 0;
1280 if (!loopback_dtr_ring
) return;
1282 hcom
= test_OpenComm(FALSE
);
1283 if (hcom
== INVALID_HANDLE_VALUE
) return;
1285 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1286 if (dcb
.fDtrControl
== DTR_CONTROL_HANDSHAKE
)
1288 trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
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
)
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
);
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
);
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
1329 static void test_WaitRx(void)
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;
1336 if (!loopback_txd_rxd
) return;
1338 hcom
= test_OpenComm(TRUE
);
1339 if (hcom
== INVALID_HANDLE_VALUE
) return;
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
;
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
;
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");
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",
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
);
1373 success_write
= GetOverlappedResult(hcom
, &overlapped_w
, &written
, FALSE
);
1374 err_write
= GetLastError();
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
);
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
);
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
);
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);
1401 /* Change the controlling line after the given timeout to the given state
1402 By the loopback, this should trigger the WaitCommEvent
1404 static DWORD CALLBACK
toggle_ctlLine(LPVOID arg
)
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];
1413 trace("toggle_ctlLine timeout %d ctl 0x%08x handle %p\n", timeout
, ctl
, hcom
);
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",
1425 * Wait for a change in CTS
1426 * Needs Loopback from DTR to CTS
1428 static void test_WaitCts(void)
1431 OVERLAPPED overlapped
;
1432 HANDLE hcom
, hComPortEvent
, alarmThread
;
1434 DWORD alarmThreadId
, before
, after
, after1
, diff
, success
, err
, written
, evtmask
=0, defaultStat
= 0;
1436 if (!loopback_rts_cts
) return;
1438 hcom
= test_OpenComm(TRUE
);
1439 if (hcom
== INVALID_HANDLE_VALUE
) return;
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
)
1447 trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1451 args
[0]= TIMEOUT
>>1;
1452 ok(GetCommModemStatus(hcom
, &defaultStat
), "GetCommModemStatus failed\n");
1453 if(defaultStat
& MS_CTS_ON
)
1457 args
[2]=(DWORD_PTR
)hcom
;
1459 trace("test_WaitCts timeout %ld clt 0x%08lx handle %p\n",args
[0], args
[1], hcom
);
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 */
1468 trace("Thread created\n");
1469 ok(alarmThread
!=0 , "CreateThread Failed\n");
1471 ZeroMemory( &overlapped
, sizeof(overlapped
));
1472 overlapped
.hEvent
= hComPortEvent
;
1473 before
= GetTickCount();
1474 success
= WaitCommEvent(hcom
, &evtmask
, &overlapped
);
1475 err
= GetLastError();
1476 after
= GetTickCount();
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
);
1490 ok(evtmask
& EV_CTS
, "Failed to detect EV_CTS: 0x%08x, expected 0x%08x\n",
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");
1496 ok((evtmask
& MS_CTS_ON
), "CTS didn't change state!\n");
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);
1502 /*restore RTS Settings*/
1503 if(defaultStat
& MS_CTS_ON
)
1509 ok( !WaitForSingleObject( alarmThread
, 10000 ), "thread still running\n" );
1510 CloseHandle( alarmThread
);
1513 /* Change the Comm Mask while a Wait is going on
1514 WaitCommevent should return with a EVTMASK set to zero
1516 static DWORD CALLBACK
reset_CommMask(LPVOID arg
)
1518 DWORD_PTR
*args
= arg
;
1519 DWORD timeout
= args
[0];
1520 HANDLE hcom
= (HANDLE
) args
[1];
1522 trace(" Changing CommMask on the fly for handle %p after timeout %d\n",
1525 ok(SetCommMask(hcom
, 0),"SetCommMask %p failed\n", hcom
);
1526 trace("SetCommMask changed\n");
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
1534 static void test_AbortWaitCts(void)
1537 OVERLAPPED overlapped
;
1538 HANDLE hcom
, hComPortEvent
, alarmThread
;
1540 DWORD alarmThreadId
, before
, after
, after1
, diff
, success
, err
, written
, evtmask
=0;
1542 hcom
= test_OpenComm(TRUE
);
1543 if (hcom
== INVALID_HANDLE_VALUE
) return;
1545 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1546 if (dcb
.fDtrControl
== RTS_CONTROL_DISABLE
)
1548 trace("RTS_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1552 args
[0]= TIMEOUT
>>1;
1553 args
[1]= (DWORD_PTR
)hcom
;
1555 trace("test_AbortWaitCts timeout %ld handle %p\n",args
[0], hcom
);
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 */
1563 trace("Thread created\n");
1564 ok(alarmThread
!=0 , "CreateThread Failed\n");
1566 ZeroMemory( &overlapped
, sizeof(overlapped
));
1567 overlapped
.hEvent
= hComPortEvent
;
1568 before
= GetTickCount();
1569 success
= WaitCommEvent(hcom
, &evtmask
, &overlapped
);
1570 err
= GetLastError();
1571 after
= GetTickCount();
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
);
1585 ok(evtmask
== 0, "Incorrect EventMask 0x%08x returned on Wait aborted bu SetCommMask, expected 0x%08x\n",
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);
1593 ok( !WaitForSingleObject( alarmThread
, 10000 ), "thread still running\n" );
1594 CloseHandle( alarmThread
);
1598 * Wait for a change in DSR
1599 * Needs Loopback from DTR to DSR
1601 static void test_WaitDsr(void)
1604 OVERLAPPED overlapped
;
1605 HANDLE hcom
, hComPortEvent
, alarmThread
;
1607 DWORD alarmThreadId
, before
, after
, after1
, diff
, success
, err
, written
, evtmask
=0, defaultStat
= 0;
1609 if (!loopback_dtr_dsr
) return;
1611 hcom
= test_OpenComm(TRUE
);
1612 if (hcom
== INVALID_HANDLE_VALUE
) return;
1614 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1615 if (dcb
.fDtrControl
== DTR_CONTROL_DISABLE
)
1617 trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1621 args
[0]= TIMEOUT
>>1;
1622 ok(GetCommModemStatus(hcom
, &defaultStat
), "GetCommModemStatus failed\n");
1623 if(defaultStat
& MS_DSR_ON
)
1627 args
[2]= (DWORD_PTR
)hcom
;
1629 trace("test_WaitDsr timeout %ld clt 0x%08lx handle %p\n",args
[0], args
[1], hcom
);
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");
1637 ZeroMemory( &overlapped
, sizeof(overlapped
));
1638 overlapped
.hEvent
= hComPortEvent
;
1639 before
= GetTickCount();
1640 success
= WaitCommEvent(hcom
, &evtmask
, &overlapped
);
1641 err
= GetLastError();
1642 after
= GetTickCount();
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
);
1656 ok(evtmask
& EV_DSR
, "Failed to detect EV_DSR: 0x%08x, expected 0x%08x\n",
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");
1662 ok((evtmask
& MS_DSR_ON
), "DTR didn't change state!\n");
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);
1668 /*restore RTS Settings*/
1669 if(defaultStat
& MS_DSR_ON
)
1675 ok( !WaitForSingleObject( alarmThread
, 10000 ), "thread still running\n" );
1676 CloseHandle( alarmThread
);
1681 * Needs Loopback from DTR to RING
1683 static void test_WaitRing(void)
1686 OVERLAPPED overlapped
;
1687 HANDLE hcom
, hComPortEvent
, alarmThread
;
1689 DWORD alarmThreadId
, before
, after
, after1
, diff
, success
, err
, written
, evtmask
=0, defaultStat
;
1692 if (!loopback_dtr_ring
) return;
1694 hcom
= test_OpenComm(TRUE
);
1695 if (hcom
== INVALID_HANDLE_VALUE
) return;
1697 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1698 if (dcb
.fDtrControl
== DTR_CONTROL_DISABLE
)
1700 trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1704 args
[0]= TIMEOUT
>>1;
1705 ok((ret
= GetCommModemStatus(hcom
, &defaultStat
)), "GetCommModemStatus failed\n");
1707 skip("modem status failed -> skip.\n");
1711 if(defaultStat
& MS_RING_ON
)
1715 args
[2]=(DWORD_PTR
) hcom
;
1717 trace("test_WaitRing timeout %ld clt 0x%08lx handle %p\n",args
[0], args
[1], hcom
);
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");
1725 ZeroMemory( &overlapped
, sizeof(overlapped
));
1726 overlapped
.hEvent
= hComPortEvent
;
1727 before
= GetTickCount();
1728 success
= WaitCommEvent(hcom
, &evtmask
, &overlapped
);
1729 err
= GetLastError();
1730 after
= GetTickCount();
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
);
1744 ok(evtmask
& EV_RING
, "Failed to detect EV_RING: 0x%08x, expected 0x%08x\n",
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");
1750 ok((evtmask
& MS_RING_ON
), "DTR didn't change state!\n");
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);
1756 /*restore RTS Settings*/
1757 if(defaultStat
& MS_RING_ON
)
1763 ok( !WaitForSingleObject( alarmThread
, 10000 ), "thread still running\n" );
1764 CloseHandle( alarmThread
);
1767 * Wait for a change in DCD
1768 * Needs Loopback from DTR to DCD
1770 static void test_WaitDcd(void)
1773 OVERLAPPED overlapped
;
1774 HANDLE hcom
, hComPortEvent
, alarmThread
;
1776 DWORD alarmThreadId
, before
, after
, after1
, diff
, success
, err
, written
, evtmask
=0, defaultStat
= 0;
1778 if (!loopback_dtr_dcd
) return;
1780 hcom
= test_OpenComm(TRUE
);
1781 if (hcom
== INVALID_HANDLE_VALUE
) return;
1783 ok(GetCommState(hcom
, &dcb
), "GetCommState failed\n");
1784 if (dcb
.fDtrControl
== DTR_CONTROL_DISABLE
)
1786 trace("DTR_CONTROL_HANDSHAKE is set, so don't manipulate DTR\n");
1790 args
[0]= TIMEOUT
>>1;
1791 ok(GetCommModemStatus(hcom
, &defaultStat
), "GetCommModemStatus failed\n");
1792 if(defaultStat
& MS_RLSD_ON
)
1796 args
[2]= (DWORD_PTR
)hcom
;
1798 trace("test_WaitDcd timeout %ld clt 0x%08lx handle %p\n",args
[0], args
[1], hcom
);
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");
1806 ZeroMemory( &overlapped
, sizeof(overlapped
));
1807 overlapped
.hEvent
= hComPortEvent
;
1808 before
= GetTickCount();
1809 success
= WaitCommEvent(hcom
, &evtmask
, &overlapped
);
1810 err
= GetLastError();
1811 after
= GetTickCount();
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
);
1825 ok(evtmask
& EV_RLSD
, "Failed to detect EV_RLSD: 0x%08x, expected 0x%08x\n",
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");
1831 ok((evtmask
& MS_RLSD_ON
), "DTR didn't change state!\n");
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);
1837 /*restore RTS Settings*/
1838 if(defaultStat
& MS_RLSD_ON
)
1844 ok( !WaitForSingleObject( alarmThread
, 10000 ), "thread still running\n" );
1845 CloseHandle( alarmThread
);
1849 Set Break after timeout
1851 static DWORD CALLBACK
set_CommBreak(LPVOID arg
)
1853 DWORD_PTR
*args
= arg
;
1854 DWORD timeout
= args
[0];
1855 HANDLE hcom
= (HANDLE
) args
[1];
1857 trace("SetCommBreak for handle %p after timeout %d\n",
1860 ok(SetCommBreak(hcom
),"SetCommBreak %p failed\n", hcom
);
1861 trace("SetCommBreak done\n");
1866 Wait for the Break condition (TX resp. RX active)
1867 Needs Loopback TX-RX
1869 static void test_WaitBreak(void)
1871 OVERLAPPED overlapped
;
1872 HANDLE hcom
, hComPortEvent
, alarmThread
;
1874 DWORD alarmThreadId
, before
, after
, after1
, diff
, success
, err
, written
, evtmask
=0;
1876 if (!loopback_txd_rxd
) return;
1878 hcom
= test_OpenComm(TRUE
);
1879 if (hcom
== INVALID_HANDLE_VALUE
) return;
1881 ok(SetCommMask(hcom
, EV_BREAK
), "SetCommMask failed\n");
1882 hComPortEvent
= CreateEventW( NULL
, TRUE
, FALSE
, NULL
);
1883 ok(hComPortEvent
!= 0, "CreateEvent failed\n");
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 */
1891 trace("Thread created\n");
1892 ok(alarmThread
!=0 , "CreateThread Failed\n");
1894 ZeroMemory( &overlapped
, sizeof(overlapped
));
1895 overlapped
.hEvent
= hComPortEvent
;
1896 before
= GetTickCount();
1897 success
= WaitCommEvent(hcom
, &evtmask
, &overlapped
);
1898 err
= GetLastError();
1899 after
= GetTickCount();
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");
1905 if (!success
&& (err
== ERROR_IO_PENDING
))
1907 success
= WaitForSingleObjectEx(hComPortEvent
, TIMEOUT
, TRUE
);
1908 ok(!success
, "wait hComPortEvent res %d\n", GetLastError());
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
);
1916 ok(evtmask
& EV_BREAK
, "Failed to detect EV_BREAK: 0x%08x, expected 0x%08x\n",
1918 ok(GetCommModemStatus(hcom
, &evtmask
), "GetCommModemStatus failed\n");
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);
1924 ok(ClearCommBreak(hcom
), "ClearCommBreak failed\n");
1927 ok( !WaitForSingleObject( alarmThread
, 10000 ), "thread still running\n" );
1928 CloseHandle( alarmThread
);
1931 static void test_stdio(void)
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() );
1941 static void test_WaitCommEvent(void)
1944 DWORD evtmask
, ret
, bytes
, before
, after
, last_event_time
;
1945 OVERLAPPED ovl_wait
;
1947 hcom
= test_OpenComm(TRUE
);
1948 if (hcom
== INVALID_HANDLE_VALUE
) return;
1950 test_GetModemStatus(hcom
);
1952 ret
= SetCommMask(hcom
, 0x1fff);
1953 ok(ret
, "SetCommMask error %d\n", GetLastError());
1955 S(U(ovl_wait
)).Offset
= 0;
1956 S(U(ovl_wait
)).OffsetHigh
= 0;
1957 ovl_wait
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
1959 trace("waiting 10 secs for com port events (turn on/off the device)...\n");
1960 last_event_time
= 0;
1961 before
= GetTickCount();
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 */
1971 ret
= WaitForSingleObject(ovl_wait
.hEvent
, 500);
1972 after
= GetTickCount();
1973 if (ret
== WAIT_OBJECT_0
)
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
);
1985 if (last_event_time
|| after
- before
>= 10000) goto done
;
1988 } while (after
- before
< 10000);
1991 CloseHandle(ovl_wait
.hEvent
);
1995 static void test_FlushFileBuffers(void)
1998 DWORD ret
, bytes
, errors
;
2001 hcom
= test_OpenComm(FALSE
);
2002 if (hcom
== INVALID_HANDLE_VALUE
) return;
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
);
2008 ret
= FlushFileBuffers(hcom
);
2009 ok(ret
, "FlushFileBuffers error %d\n", GetLastError());
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
);
2020 static void test_read_write(void)
2022 static const char atz
[]="ATZ\r\n";
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
;
2033 if (!pNtReadFile
|| !pNtWriteFile
)
2035 win_skip("not running on NT, skipping test\n");
2039 hcom
= test_OpenComm(TRUE
);
2040 if (hcom
== INVALID_HANDLE_VALUE
) return;
2042 ret
= GetCommState(hcom
, &dcb
);
2043 ok(ret
, "GetCommState error %d\n", GetLastError());
2044 dcb
.BaudRate
= 9600;
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());
2053 memset(&timeouts
, 0, sizeof(timeouts
));
2054 timeouts
.ReadTotalTimeoutConstant
= TIMEOUT
;
2055 ret
= SetCommTimeouts(hcom
, &timeouts
);
2056 ok(ret
,"SetCommTimeouts error %d\n", GetLastError());
2058 ret
= SetupComm(hcom
, 1024, 1024);
2059 ok(ret
, "SetUpComm error %d\n", GetLastError());
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
);
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
);
2075 for (i
= -20; i
< 20; i
++)
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)
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
);
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
);
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.
2104 ret
= WaitForSingleObject(hcom
, TIMEOUT
);
2105 if (ret
== WAIT_TIMEOUT
)
2107 skip("Probably modem is not connected.\n");
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
);
2115 ret
= SetCommMask(hcom
, EV_RXCHAR
);
2116 ok(ret
, "SetCommMask error %d\n", GetLastError());
2118 S(U(ovl_wait
)).Offset
= 0;
2119 S(U(ovl_wait
)).OffsetHigh
= 0;
2120 ovl_wait
.hEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
2122 trace("waiting 3 secs for modem response...\n");
2123 last_event_time
= 0;
2124 before
= GetTickCount();
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 */
2134 ret
= WaitForSingleObject(ovl_wait
.hEvent
, 100);
2135 after
= GetTickCount();
2136 if (ret
== WAIT_OBJECT_0
)
2138 trace("got modem response.\n");
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");
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
);
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
);
2160 for (i
= -20; i
< 20; i
++)
2163 iob
.Information
= -1;
2164 offset
.QuadPart
= (LONGLONG
)i
;
2165 status
= pNtReadFile(hcom
, 0, NULL
, NULL
, &iob
, buf
, 0, &offset
, NULL
);
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
);
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
);
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
);
2191 if (last_event_time
|| after
- before
>= 3000) goto done
;
2194 } while (after
- before
< 3000);
2197 CloseHandle(ovl_wait
.hEvent
);
2203 HMODULE ntdll
= GetModuleHandleA("ntdll.dll");
2206 pNtReadFile
= (void *)GetProcAddress(ntdll
, "NtReadFile");
2207 pNtWriteFile
= (void *)GetProcAddress(ntdll
, "NtWriteFile");
2210 test_ClearCommError(); /* keep it the very first test */
2211 test_FlushFileBuffers();
2212 test_BuildCommDCB();
2215 test_non_pending_errors();
2216 test_LoopbackRead();
2217 test_LoopbackCtsRts();
2218 test_LoopbackDtrDsr();
2219 test_LoopbackDtrRing();
2220 test_LoopbackDtrDcd();
2223 test_AbortWaitCts();
2231 if (!winetest_interactive
)
2233 skip("interactive tests (set WINETEST_INTERACTIVE=1)\n");
2237 test_WaitCommEvent();