ace4744067da600994ac636a35ab18ecec2d003b
[reactos.git] / rostests / winetests / kernel32 / console.c
1 /*
2 * Unit tests for console API
3 *
4 * Copyright (c) 2003,2004 Eric Pouech
5 * Copyright (c) 2007 Kirill K. Smirnov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "wine/test.h"
23 #include <windows.h>
24 #include <stdio.h>
25
26 static BOOL (WINAPI *pGetConsoleInputExeNameA)(DWORD, LPSTR);
27 static DWORD (WINAPI *pGetConsoleProcessList)(LPDWORD, DWORD);
28 static BOOL (WINAPI *pSetConsoleInputExeNameA)(LPCSTR);
29
30 /* DEFAULT_ATTRIB is used for all initial filling of the console.
31 * all modifications are made with TEST_ATTRIB so that we could check
32 * what has to be modified or not
33 */
34 #define TEST_ATTRIB (BACKGROUND_BLUE | FOREGROUND_GREEN)
35 #define DEFAULT_ATTRIB (FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED)
36 /* when filling the screen with non-blank chars, this macro defines
37 * what character should be at position 'c'
38 */
39 #define CONTENT(c) ('A' + (((c).Y * 17 + (c).X) % 23))
40
41 #define okCURSOR(hCon, c) do { \
42 CONSOLE_SCREEN_BUFFER_INFO __sbi; \
43 BOOL expect = GetConsoleScreenBufferInfo((hCon), &__sbi) && \
44 __sbi.dwCursorPosition.X == (c).X && __sbi.dwCursorPosition.Y == (c).Y; \
45 ok(expect, "Expected cursor at (%d,%d), got (%d,%d)\n", \
46 (c).X, (c).Y, __sbi.dwCursorPosition.X, __sbi.dwCursorPosition.Y); \
47 } while (0)
48
49 #define okCHAR(hCon, c, ch, attr) do { \
50 char __ch; WORD __attr; DWORD __len; BOOL expect; \
51 expect = ReadConsoleOutputCharacter((hCon), &__ch, 1, (c), &__len) == 1 && __len == 1 && __ch == (ch); \
52 ok(expect, "At (%d,%d): expecting char '%c'/%02x got '%c'/%02x\n", (c).X, (c).Y, (ch), (ch), __ch, __ch); \
53 expect = ReadConsoleOutputAttribute((hCon), &__attr, 1, (c), &__len) == 1 && __len == 1 && __attr == (attr); \
54 ok(expect, "At (%d,%d): expecting attr %04x got %04x\n", (c).X, (c).Y, (attr), __attr); \
55 } while (0)
56
57 static void init_function_pointers(void)
58 {
59 HMODULE hKernel32;
60
61 #define KERNEL32_GET_PROC(func) \
62 p##func = (void *)GetProcAddress(hKernel32, #func); \
63 if(!p##func) trace("GetProcAddress(hKernel32, '%s') failed\n", #func);
64
65 hKernel32 = GetModuleHandleA("kernel32.dll");
66 KERNEL32_GET_PROC(GetConsoleInputExeNameA);
67 KERNEL32_GET_PROC(GetConsoleProcessList);
68 KERNEL32_GET_PROC(SetConsoleInputExeNameA);
69
70 #undef KERNEL32_GET_PROC
71 }
72
73 /* FIXME: this could be optimized on a speed point of view */
74 static void resetContent(HANDLE hCon, COORD sbSize, BOOL content)
75 {
76 COORD c;
77 WORD attr = DEFAULT_ATTRIB;
78 char ch;
79 DWORD len;
80
81 for (c.X = 0; c.X < sbSize.X; c.X++)
82 {
83 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
84 {
85 ch = (content) ? CONTENT(c) : ' ';
86 WriteConsoleOutputAttribute(hCon, &attr, 1, c, &len);
87 WriteConsoleOutputCharacterA(hCon, &ch, 1, c, &len);
88 }
89 }
90 }
91
92 static void testCursor(HANDLE hCon, COORD sbSize)
93 {
94 COORD c;
95
96 c.X = c.Y = 0;
97 ok(SetConsoleCursorPosition(0, c) == 0, "No handle\n");
98 ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %u got %u\n",
99 ERROR_INVALID_HANDLE, GetLastError());
100
101 c.X = c.Y = 0;
102 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
103 okCURSOR(hCon, c);
104
105 c.X = sbSize.X - 1;
106 c.Y = sbSize.Y - 1;
107 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in lower-right\n");
108 okCURSOR(hCon, c);
109
110 c.X = sbSize.X;
111 c.Y = sbSize.Y - 1;
112 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
113 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
114 ERROR_INVALID_PARAMETER, GetLastError());
115
116 c.X = sbSize.X - 1;
117 c.Y = sbSize.Y;
118 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
119 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
120 ERROR_INVALID_PARAMETER, GetLastError());
121
122 c.X = -1;
123 c.Y = 0;
124 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
125 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
126 ERROR_INVALID_PARAMETER, GetLastError());
127
128 c.X = 0;
129 c.Y = -1;
130 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
131 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
132 ERROR_INVALID_PARAMETER, GetLastError());
133 }
134
135 static void testCursorInfo(HANDLE hCon)
136 {
137 BOOL ret;
138 CONSOLE_CURSOR_INFO info;
139
140 SetLastError(0xdeadbeef);
141 ret = GetConsoleCursorInfo(NULL, NULL);
142 ok(!ret, "Expected failure\n");
143 ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %u got %u\n",
144 ERROR_INVALID_HANDLE, GetLastError());
145
146 SetLastError(0xdeadbeef);
147 info.dwSize = -1;
148 ret = GetConsoleCursorInfo(NULL, &info);
149 ok(!ret, "Expected failure\n");
150 ok(info.dwSize == -1, "Expected no change for dwSize\n");
151 ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %u got %u\n",
152 ERROR_INVALID_HANDLE, GetLastError());
153
154 /* Test the correct call first to distinguish between win9x and the rest */
155 SetLastError(0xdeadbeef);
156 ret = GetConsoleCursorInfo(hCon, &info);
157 ok(ret, "Expected success\n");
158 ok(info.dwSize == 25 ||
159 info.dwSize == 12 /* win9x */,
160 "Expected 12 or 25, got %d\n", info.dwSize);
161 ok(info.bVisible, "Expected the cursor to be visible\n");
162 ok(GetLastError() == 0xdeadbeef, "GetLastError: expecting %u got %u\n",
163 0xdeadbeef, GetLastError());
164
165 /* Don't test NULL CONSOLE_CURSOR_INFO, it crashes on win9x and win7 */
166 }
167
168 static void testEmptyWrite(HANDLE hCon)
169 {
170 COORD c;
171 DWORD len;
172 const char* mytest = "";
173
174 c.X = c.Y = 0;
175 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
176
177 len = -1;
178 ok(WriteConsole(hCon, NULL, 0, &len, NULL) != 0 && len == 0, "WriteConsole\n");
179 okCURSOR(hCon, c);
180
181 /* Passing a NULL lpBuffer with sufficiently large non-zero length succeeds
182 * on native Windows and result in memory-like contents being written to
183 * the console. Calling WriteConsoleW like this will crash on Wine. */
184 if (0)
185 {
186 len = -1;
187 ok(!WriteConsole(hCon, NULL, 16, &len, NULL) && len == -1, "WriteConsole\n");
188 okCURSOR(hCon, c);
189
190 /* Cursor advances for this call. */
191 len = -1;
192 ok(WriteConsole(hCon, NULL, 128, &len, NULL) != 0 && len == 128, "WriteConsole\n");
193 }
194
195 len = -1;
196 ok(WriteConsole(hCon, mytest, 0, &len, NULL) != 0 && len == 0, "WriteConsole\n");
197 okCURSOR(hCon, c);
198
199 /* WriteConsole does not halt on a null terminator and is happy to write
200 * memory contents beyond the actual size of the buffer. */
201 len = -1;
202 ok(WriteConsole(hCon, mytest, 16, &len, NULL) != 0 && len == 16, "WriteConsole\n");
203 c.X += 16;
204 okCURSOR(hCon, c);
205 }
206
207 static void testWriteSimple(HANDLE hCon)
208 {
209 COORD c;
210 DWORD len;
211 const char* mytest = "abcdefg";
212 const int mylen = strlen(mytest);
213
214 /* single line write */
215 c.X = c.Y = 0;
216 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
217
218 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
219 c.Y = 0;
220 for (c.X = 0; c.X < mylen; c.X++)
221 {
222 okCHAR(hCon, c, mytest[c.X], TEST_ATTRIB);
223 }
224
225 okCURSOR(hCon, c);
226 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
227 }
228
229 static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
230 {
231 COORD c;
232 DWORD len, mode;
233 const char* mytest = "123";
234 const int mylen = strlen(mytest);
235 int ret;
236 int p;
237
238 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT)),
239 "clearing wrap at EOL & processed output\n");
240
241 /* write line, wrapping disabled, buffer exceeds sb width */
242 c.X = sbSize.X - 3; c.Y = 0;
243 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
244
245 ret = WriteConsole(hCon, mytest, mylen, &len, NULL);
246 ok(ret != 0 && len == mylen, "Couldn't write, ret = %d, len = %d\n", ret, len);
247 c.Y = 0;
248 for (p = mylen - 3; p < mylen; p++)
249 {
250 c.X = sbSize.X - 3 + p % 3;
251 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
252 }
253
254 c.X = 0; c.Y = 1;
255 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
256
257 p = sbSize.X - 3 + mylen % 3;
258 c.X = p; c.Y = 0;
259
260 /* write line, wrapping disabled, strings end on end of line */
261 c.X = sbSize.X - mylen; c.Y = 0;
262 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
263
264 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
265 }
266
267 static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize)
268 {
269 COORD c;
270 DWORD len, mode;
271 const char* mytest = "abcd\nf\tg";
272 const int mylen = strlen(mytest);
273 const int mylen2 = strchr(mytest, '\n') - mytest;
274 int p;
275 WORD attr;
276
277 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, (mode | ENABLE_PROCESSED_OUTPUT) & ~ENABLE_WRAP_AT_EOL_OUTPUT),
278 "clearing wrap at EOL & setting processed output\n");
279
280 /* write line, wrapping disabled, buffer exceeds sb width */
281 c.X = sbSize.X - 5; c.Y = 0;
282 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-5\n");
283
284 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
285 c.Y = 0;
286 for (c.X = sbSize.X - 5; c.X < sbSize.X - 1; c.X++)
287 {
288 okCHAR(hCon, c, mytest[c.X - sbSize.X + 5], TEST_ATTRIB);
289 }
290
291 ReadConsoleOutputAttribute(hCon, &attr, 1, c, &len);
292 /* Win9x and WinMe change the attribs for '\n' up to 'f' */
293 if (attr == TEST_ATTRIB)
294 {
295 win_skip("Win9x/WinMe don't respect ~ENABLE_WRAP_AT_EOL_OUTPUT\n");
296 return;
297 }
298
299 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
300
301 c.X = 0; c.Y++;
302 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
303 for (c.X = 1; c.X < 8; c.X++)
304 okCHAR(hCon, c, ' ', TEST_ATTRIB);
305 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
306 c.X++;
307 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
308
309 okCURSOR(hCon, c);
310
311 /* write line, wrapping disabled, strings end on end of line */
312 c.X = sbSize.X - 4; c.Y = 0;
313 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");
314
315 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
316 c.Y = 0;
317 for (c.X = sbSize.X - 4; c.X < sbSize.X; c.X++)
318 {
319 okCHAR(hCon, c, mytest[c.X - sbSize.X + 4], TEST_ATTRIB);
320 }
321 c.X = 0; c.Y++;
322 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
323 for (c.X = 1; c.X < 8; c.X++)
324 okCHAR(hCon, c, ' ', TEST_ATTRIB);
325 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
326 c.X++;
327 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
328
329 okCURSOR(hCon, c);
330
331 /* write line, wrapping disabled, strings end after end of line */
332 c.X = sbSize.X - 3; c.Y = 0;
333 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");
334
335 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
336 c.Y = 0;
337 for (p = mylen2 - 3; p < mylen2; p++)
338 {
339 c.X = sbSize.X - 3 + p % 3;
340 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
341 }
342 c.X = 0; c.Y = 1;
343 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
344 for (c.X = 1; c.X < 8; c.X++)
345 okCHAR(hCon, c, ' ', TEST_ATTRIB);
346 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
347 c.X++;
348 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
349
350 okCURSOR(hCon, c);
351 }
352
353 static void testWriteWrappedNotProcessed(HANDLE hCon, COORD sbSize)
354 {
355 COORD c;
356 DWORD len, mode;
357 const char* mytest = "abcd\nf\tg";
358 const int mylen = strlen(mytest);
359 int p;
360
361 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon,(mode | ENABLE_WRAP_AT_EOL_OUTPUT) & ~(ENABLE_PROCESSED_OUTPUT)),
362 "setting wrap at EOL & clearing processed output\n");
363
364 /* write line, wrapping enabled, buffer doesn't exceed sb width */
365 c.X = sbSize.X - 9; c.Y = 0;
366 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");
367
368 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
369 c.Y = 0;
370 for (p = 0; p < mylen; p++)
371 {
372 c.X = sbSize.X - 9 + p;
373 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
374 }
375 c.X = sbSize.X - 9 + mylen;
376 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
377 c.X = 0; c.Y = 1;
378 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
379
380 /* write line, wrapping enabled, buffer does exceed sb width */
381 c.X = sbSize.X - 3; c.Y = 0;
382 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
383
384 c.Y = 1;
385 c.X = mylen - 3;
386 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
387 }
388
389 static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize)
390 {
391 COORD c;
392 DWORD len, mode;
393 const char* mytest = "abcd\nf\tg";
394 const int mylen = strlen(mytest);
395 int p;
396 WORD attr;
397
398 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode | (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)),
399 "setting wrap at EOL & processed output\n");
400
401 /* write line, wrapping enabled, buffer doesn't exceed sb width */
402 c.X = sbSize.X - 9; c.Y = 0;
403 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");
404
405 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
406 for (p = 0; p < 4; p++)
407 {
408 c.X = sbSize.X - 9 + p;
409 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
410 }
411 c.X = sbSize.X - 9 + p;
412 ReadConsoleOutputAttribute(hCon, &attr, 1, c, &len);
413 if (attr == TEST_ATTRIB)
414 win_skip("Win9x/WinMe changes attribs for '\\n' up to 'f'\n");
415 else
416 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
417 c.X = 0; c.Y++;
418 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
419 for (c.X = 1; c.X < 8; c.X++)
420 okCHAR(hCon, c, ' ', TEST_ATTRIB);
421 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
422 c.X++;
423 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
424 okCURSOR(hCon, c);
425
426 /* write line, wrapping enabled, buffer does exceed sb width */
427 c.X = sbSize.X - 3; c.Y = 2;
428 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
429
430 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
431 for (p = 0; p < 3; p++)
432 {
433 c.X = sbSize.X - 3 + p;
434 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
435 }
436 c.X = 0; c.Y++;
437 okCHAR(hCon, c, mytest[3], TEST_ATTRIB);
438 c.X++;
439 ReadConsoleOutputAttribute(hCon, &attr, 1, c, &len);
440 if (attr == TEST_ATTRIB)
441 win_skip("Win9x/WinMe changes attribs for '\\n' up to 'f'\n");
442 else
443 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
444
445 c.X = 0; c.Y++;
446 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
447 for (c.X = 1; c.X < 8; c.X++)
448 okCHAR(hCon, c, ' ', TEST_ATTRIB);
449 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
450 c.X++;
451 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
452 okCURSOR(hCon, c);
453 }
454
455 static void testWrite(HANDLE hCon, COORD sbSize)
456 {
457 /* FIXME: should in fact insure that the sb is at least 10 character wide */
458 ok(SetConsoleTextAttribute(hCon, TEST_ATTRIB), "Setting default text color\n");
459 resetContent(hCon, sbSize, FALSE);
460 testEmptyWrite(hCon);
461 resetContent(hCon, sbSize, FALSE);
462 testWriteSimple(hCon);
463 resetContent(hCon, sbSize, FALSE);
464 testWriteNotWrappedNotProcessed(hCon, sbSize);
465 resetContent(hCon, sbSize, FALSE);
466 testWriteNotWrappedProcessed(hCon, sbSize);
467 resetContent(hCon, sbSize, FALSE);
468 testWriteWrappedNotProcessed(hCon, sbSize);
469 resetContent(hCon, sbSize, FALSE);
470 testWriteWrappedProcessed(hCon, sbSize);
471 }
472
473 static void testScroll(HANDLE hCon, COORD sbSize)
474 {
475 SMALL_RECT scroll, clip;
476 COORD dst, c, tc;
477 CHAR_INFO ci;
478 BOOL ret;
479
480 #define W 11
481 #define H 7
482
483 #define IN_SRECT(r,c) ((r).Left <= (c).X && (c).X <= (r).Right && (r).Top <= (c).Y && (c).Y <= (r).Bottom)
484 #define IN_SRECT2(r,d,c) ((d).X <= (c).X && (c).X <= (d).X + (r).Right - (r).Left && (d).Y <= (c).Y && (c).Y <= (d).Y + (r).Bottom - (r).Top)
485
486 /* no clipping, src & dst rect don't overlap */
487 resetContent(hCon, sbSize, TRUE);
488
489 scroll.Left = 0;
490 scroll.Right = W - 1;
491 scroll.Top = 0;
492 scroll.Bottom = H - 1;
493 dst.X = W + 3;
494 dst.Y = H + 3;
495 ci.Char.UnicodeChar = '#';
496 ci.Attributes = TEST_ATTRIB;
497
498 clip.Left = 0;
499 clip.Right = sbSize.X - 1;
500 clip.Top = 0;
501 clip.Bottom = sbSize.Y - 1;
502
503 ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");
504
505 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
506 {
507 for (c.X = 0; c.X < sbSize.X; c.X++)
508 {
509 if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
510 {
511 tc.X = c.X - dst.X;
512 tc.Y = c.Y - dst.Y;
513 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
514 }
515 else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
516 okCHAR(hCon, c, '#', TEST_ATTRIB);
517 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
518 }
519 }
520
521 /* no clipping, src & dst rect do overlap */
522 resetContent(hCon, sbSize, TRUE);
523
524 scroll.Left = 0;
525 scroll.Right = W - 1;
526 scroll.Top = 0;
527 scroll.Bottom = H - 1;
528 dst.X = W /2;
529 dst.Y = H / 2;
530 ci.Char.UnicodeChar = '#';
531 ci.Attributes = TEST_ATTRIB;
532
533 clip.Left = 0;
534 clip.Right = sbSize.X - 1;
535 clip.Top = 0;
536 clip.Bottom = sbSize.Y - 1;
537
538 ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");
539
540 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
541 {
542 for (c.X = 0; c.X < sbSize.X; c.X++)
543 {
544 if (dst.X <= c.X && c.X < dst.X + W && dst.Y <= c.Y && c.Y < dst.Y + H)
545 {
546 tc.X = c.X - dst.X;
547 tc.Y = c.Y - dst.Y;
548 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
549 }
550 else if (c.X < W && c.Y < H) okCHAR(hCon, c, '#', TEST_ATTRIB);
551 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
552 }
553 }
554
555 /* clipping, src & dst rect don't overlap */
556 resetContent(hCon, sbSize, TRUE);
557
558 scroll.Left = 0;
559 scroll.Right = W - 1;
560 scroll.Top = 0;
561 scroll.Bottom = H - 1;
562 dst.X = W + 3;
563 dst.Y = H + 3;
564 ci.Char.UnicodeChar = '#';
565 ci.Attributes = TEST_ATTRIB;
566
567 clip.Left = W / 2;
568 clip.Right = min(W + W / 2, sbSize.X - 1);
569 clip.Top = H / 2;
570 clip.Bottom = min(H + H / 2, sbSize.Y - 1);
571
572 SetLastError(0xdeadbeef);
573 ret = ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci);
574 if (ret)
575 {
576 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
577 {
578 for (c.X = 0; c.X < sbSize.X; c.X++)
579 {
580 if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
581 {
582 tc.X = c.X - dst.X;
583 tc.Y = c.Y - dst.Y;
584 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
585 }
586 else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
587 okCHAR(hCon, c, '#', TEST_ATTRIB);
588 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
589 }
590 }
591 }
592 else
593 {
594 /* Win9x will fail, Only accept ERROR_NOT_ENOUGH_MEMORY */
595 ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY,
596 "Expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
597 }
598
599 /* clipping, src & dst rect do overlap */
600 resetContent(hCon, sbSize, TRUE);
601
602 scroll.Left = 0;
603 scroll.Right = W - 1;
604 scroll.Top = 0;
605 scroll.Bottom = H - 1;
606 dst.X = W / 2 - 3;
607 dst.Y = H / 2 - 3;
608 ci.Char.UnicodeChar = '#';
609 ci.Attributes = TEST_ATTRIB;
610
611 clip.Left = W / 2;
612 clip.Right = min(W + W / 2, sbSize.X - 1);
613 clip.Top = H / 2;
614 clip.Bottom = min(H + H / 2, sbSize.Y - 1);
615
616 ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");
617
618 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
619 {
620 for (c.X = 0; c.X < sbSize.X; c.X++)
621 {
622 if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
623 {
624 tc.X = c.X - dst.X;
625 tc.Y = c.Y - dst.Y;
626 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
627 }
628 else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
629 okCHAR(hCon, c, '#', TEST_ATTRIB);
630 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
631 }
632 }
633 }
634
635 static int mch_count;
636 /* we need the event as Wine console event generation isn't synchronous
637 * (ie GenerateConsoleCtrlEvent returns before all ctrl-handlers in all
638 * processes have been called).
639 */
640 static HANDLE mch_event;
641 static BOOL WINAPI mch(DWORD event)
642 {
643 mch_count++;
644 SetEvent(mch_event);
645 return TRUE;
646 }
647
648 static void testCtrlHandler(void)
649 {
650 ok(!SetConsoleCtrlHandler(mch, FALSE), "Shouldn't succeed\n");
651 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Bad error %u\n", GetLastError());
652 ok(SetConsoleCtrlHandler(mch, TRUE), "Couldn't set handler\n");
653 /* wine requires the event for the test, as we cannot insure, so far, that event
654 * are processed synchronously in GenerateConsoleCtrlEvent()
655 */
656 mch_event = CreateEventA(NULL, TRUE, FALSE, NULL);
657 mch_count = 0;
658 ok(GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0), "Couldn't send ctrl-c event\n");
659 /* FIXME: it isn't synchronous on wine but it can still happen before we test */
660 if (0) ok(mch_count == 1, "Event isn't synchronous\n");
661 ok(WaitForSingleObject(mch_event, 3000) == WAIT_OBJECT_0, "event sending didn't work\n");
662 CloseHandle(mch_event);
663
664 /* Turning off ctrl-c handling doesn't work on win9x such way ... */
665 ok(SetConsoleCtrlHandler(NULL, TRUE), "Couldn't turn off ctrl-c handling\n");
666 mch_event = CreateEventA(NULL, TRUE, FALSE, NULL);
667 mch_count = 0;
668 if(!(GetVersion() & 0x80000000))
669 /* ... and next line leads to an unhandled exception on 9x. Avoid it on 9x. */
670 ok(GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0), "Couldn't send ctrl-c event\n");
671 ok(WaitForSingleObject(mch_event, 3000) == WAIT_TIMEOUT && mch_count == 0, "Event shouldn't have been sent\n");
672 CloseHandle(mch_event);
673 ok(SetConsoleCtrlHandler(mch, FALSE), "Couldn't remove handler\n");
674 ok(!SetConsoleCtrlHandler(mch, FALSE), "Shouldn't succeed\n");
675 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Bad error %u\n", GetLastError());
676 }
677
678 /*
679 * Test console screen buffer:
680 * 1) Try to set invalid handle.
681 * 2) Try to set non-console handles.
682 * 3) Use CONOUT$ file as active SB.
683 * 4) Test cursor.
684 * 5) Test output codepage to show it is not a property of SB.
685 * 6) Test switching to old SB if we close all handles to current SB - works
686 * in Windows, TODO in wine.
687 *
688 * What is not tested but should be:
689 * 1) ScreenBufferInfo
690 */
691 static void testScreenBuffer(HANDLE hConOut)
692 {
693 HANDLE hConOutRW, hConOutRO, hConOutWT;
694 HANDLE hFileOutRW, hFileOutRO, hFileOutWT;
695 HANDLE hConOutNew;
696 char test_str1[] = "Test for SB1";
697 char test_str2[] = "Test for SB2";
698 char test_cp866[] = {0xe2, 0xa5, 0xe1, 0xe2, 0};
699 char test_cp1251[] = {0xf2, 0xe5, 0xf1, 0xf2, 0};
700 WCHAR test_unicode[] = {0x0442, 0x0435, 0x0441, 0x0442, 0};
701 WCHAR str_wbuf[20];
702 char str_buf[20];
703 DWORD len;
704 COORD c;
705 BOOL ret;
706 DWORD oldcp;
707
708 if (!IsValidCodePage(866))
709 {
710 skip("Codepage 866 not available\n");
711 return;
712 }
713
714 /* In the beginning set output codepage to 866 */
715 oldcp = GetConsoleOutputCP();
716 SetLastError(0xdeadbeef);
717 ret = SetConsoleOutputCP(866);
718 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
719 {
720 win_skip("SetConsoleOutputCP is not implemented\n");
721 return;
722 }
723 ok(ret, "Cannot set output codepage to 866\n");
724
725 hConOutRW = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
726 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
727 CONSOLE_TEXTMODE_BUFFER, NULL);
728 ok(hConOutRW != INVALID_HANDLE_VALUE,
729 "Cannot create a new screen buffer for ReadWrite\n");
730 hConOutRO = CreateConsoleScreenBuffer(GENERIC_READ,
731 FILE_SHARE_READ, NULL,
732 CONSOLE_TEXTMODE_BUFFER, NULL);
733 ok(hConOutRO != INVALID_HANDLE_VALUE,
734 "Cannot create a new screen buffer for ReadOnly\n");
735 hConOutWT = CreateConsoleScreenBuffer(GENERIC_WRITE,
736 FILE_SHARE_WRITE, NULL,
737 CONSOLE_TEXTMODE_BUFFER, NULL);
738 ok(hConOutWT != INVALID_HANDLE_VALUE,
739 "Cannot create a new screen buffer for WriteOnly\n");
740
741 hFileOutRW = CreateFileA("NUL", GENERIC_READ | GENERIC_WRITE,
742 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
743 OPEN_EXISTING, 0, NULL);
744 ok(hFileOutRW != INVALID_HANDLE_VALUE, "Cannot open NUL for ReadWrite\n");
745 hFileOutRO = CreateFileA("NUL", GENERIC_READ, FILE_SHARE_READ,
746 NULL, OPEN_EXISTING, 0, NULL);
747 ok(hFileOutRO != INVALID_HANDLE_VALUE, "Cannot open NUL for ReadOnly\n");
748 hFileOutWT = CreateFileA("NUL", GENERIC_WRITE, FILE_SHARE_WRITE,
749 NULL, OPEN_EXISTING, 0, NULL);
750 ok(hFileOutWT != INVALID_HANDLE_VALUE, "Cannot open NUL for WriteOnly\n");
751
752 /* Trying to set invalid handle */
753 SetLastError(0);
754 ok(!SetConsoleActiveScreenBuffer(INVALID_HANDLE_VALUE),
755 "Shouldn't succeed\n");
756 ok(GetLastError() == ERROR_INVALID_HANDLE,
757 "GetLastError: expecting %u got %u\n",
758 ERROR_INVALID_HANDLE, GetLastError());
759
760 /* Trying to set non-console handles */
761 SetLastError(0);
762 ok(!SetConsoleActiveScreenBuffer(hFileOutRW), "Shouldn't succeed\n");
763 ok(GetLastError() == ERROR_INVALID_HANDLE,
764 "GetLastError: expecting %u got %u\n",
765 ERROR_INVALID_HANDLE, GetLastError());
766
767 SetLastError(0);
768 ok(!SetConsoleActiveScreenBuffer(hFileOutRO), "Shouldn't succeed\n");
769 ok(GetLastError() == ERROR_INVALID_HANDLE,
770 "GetLastError: expecting %u got %u\n",
771 ERROR_INVALID_HANDLE, GetLastError());
772
773 SetLastError(0);
774 ok(!SetConsoleActiveScreenBuffer(hFileOutWT), "Shouldn't succeed\n");
775 ok(GetLastError() == ERROR_INVALID_HANDLE,
776 "GetLastError: expecting %u got %u\n",
777 ERROR_INVALID_HANDLE, GetLastError());
778
779 CloseHandle(hFileOutRW);
780 CloseHandle(hFileOutRO);
781 CloseHandle(hFileOutWT);
782
783 /* Trying to set SB handles with various access modes */
784 SetLastError(0);
785 ok(!SetConsoleActiveScreenBuffer(hConOutRO), "Shouldn't succeed\n");
786 ok(GetLastError() == ERROR_INVALID_HANDLE,
787 "GetLastError: expecting %u got %u\n",
788 ERROR_INVALID_HANDLE, GetLastError());
789
790 ok(SetConsoleActiveScreenBuffer(hConOutWT), "Couldn't set new WriteOnly SB\n");
791
792 ok(SetConsoleActiveScreenBuffer(hConOutRW), "Couldn't set new ReadWrite SB\n");
793
794 CloseHandle(hConOutWT);
795 CloseHandle(hConOutRO);
796
797 /* Now we have two ReadWrite SB, active must be hConOutRW */
798 /* Open current SB via CONOUT$ */
799 hConOutNew = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0,
800 NULL, OPEN_EXISTING, 0, 0);
801 ok(hConOutNew != INVALID_HANDLE_VALUE, "CONOUT$ is not opened\n");
802
803
804 /* test cursor */
805 c.X = c.Y = 10;
806 SetConsoleCursorPosition(hConOut, c);
807 c.X = c.Y = 5;
808 SetConsoleCursorPosition(hConOutRW, c);
809 okCURSOR(hConOutNew, c);
810 c.X = c.Y = 10;
811 okCURSOR(hConOut, c);
812
813
814 c.X = c.Y = 0;
815
816 /* Write using hConOutNew... */
817 SetConsoleCursorPosition(hConOutNew, c);
818 ret = WriteConsoleA(hConOutNew, test_str2, lstrlenA(test_str2), &len, NULL);
819 ok (ret && len == lstrlenA(test_str2), "WriteConsoleA failed\n");
820 /* ... and read it back via hConOutRW */
821 ret = ReadConsoleOutputCharacterA(hConOutRW, str_buf, lstrlenA(test_str2), c, &len);
822 ok(ret && len == lstrlenA(test_str2), "ReadConsoleOutputCharacterA failed\n");
823 str_buf[lstrlenA(test_str2)] = 0;
824 ok(!lstrcmpA(str_buf, test_str2), "got '%s' expected '%s'\n", str_buf, test_str2);
825
826
827 /* Now test output codepage handling. Current is 866 as we set earlier. */
828 SetConsoleCursorPosition(hConOutRW, c);
829 ret = WriteConsoleA(hConOutRW, test_cp866, lstrlenA(test_cp866), &len, NULL);
830 ok(ret && len == lstrlenA(test_cp866), "WriteConsoleA failed\n");
831 ret = ReadConsoleOutputCharacterW(hConOutRW, str_wbuf, lstrlenA(test_cp866), c, &len);
832 ok(ret && len == lstrlenA(test_cp866), "ReadConsoleOutputCharacterW failed\n");
833 str_wbuf[lstrlenA(test_cp866)] = 0;
834 ok(!lstrcmpW(str_wbuf, test_unicode), "string does not match the pattern\n");
835
836 /*
837 * cp866 is OK, let's switch to cp1251.
838 * We expect that this codepage will be used in every SB - active and not.
839 */
840 ok(SetConsoleOutputCP(1251), "Cannot set output cp to 1251\n");
841 SetConsoleCursorPosition(hConOutRW, c);
842 ret = WriteConsoleA(hConOutRW, test_cp1251, lstrlenA(test_cp1251), &len, NULL);
843 ok(ret && len == lstrlenA(test_cp1251), "WriteConsoleA failed\n");
844 ret = ReadConsoleOutputCharacterW(hConOutRW, str_wbuf, lstrlenA(test_cp1251), c, &len);
845 ok(ret && len == lstrlenA(test_cp1251), "ReadConsoleOutputCharacterW failed\n");
846 str_wbuf[lstrlenA(test_cp1251)] = 0;
847 ok(!lstrcmpW(str_wbuf, test_unicode), "string does not match the pattern\n");
848
849 /* Check what has happened to hConOut. */
850 SetConsoleCursorPosition(hConOut, c);
851 ret = WriteConsoleA(hConOut, test_cp1251, lstrlenA(test_cp1251), &len, NULL);
852 ok(ret && len == lstrlenA(test_cp1251), "WriteConsoleA failed\n");
853 ret = ReadConsoleOutputCharacterW(hConOut, str_wbuf, lstrlenA(test_cp1251), c, &len);
854 ok(ret && len == lstrlenA(test_cp1251), "ReadConsoleOutputCharacterW failed\n");
855 str_wbuf[lstrlenA(test_cp1251)] = 0;
856 ok(!lstrcmpW(str_wbuf, test_unicode), "string does not match the pattern\n");
857
858 /* Close all handles of current console SB */
859 CloseHandle(hConOutNew);
860 CloseHandle(hConOutRW);
861
862 /* Now active SB should be hConOut */
863 hConOutNew = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0,
864 NULL, OPEN_EXISTING, 0, 0);
865 ok(hConOutNew != INVALID_HANDLE_VALUE, "CONOUT$ is not opened\n");
866
867 /* Write using hConOutNew... */
868 SetConsoleCursorPosition(hConOutNew, c);
869 ret = WriteConsoleA(hConOutNew, test_str1, lstrlenA(test_str1), &len, NULL);
870 ok (ret && len == lstrlenA(test_str1), "WriteConsoleA failed\n");
871 /* ... and read it back via hConOut */
872 ret = ReadConsoleOutputCharacterA(hConOut, str_buf, lstrlenA(test_str1), c, &len);
873 ok(ret && len == lstrlenA(test_str1), "ReadConsoleOutputCharacterA failed\n");
874 str_buf[lstrlenA(test_str1)] = 0;
875 todo_wine ok(!lstrcmpA(str_buf, test_str1), "got '%s' expected '%s'\n", str_buf, test_str1);
876 CloseHandle(hConOutNew);
877
878 /* This is not really needed under Windows */
879 SetConsoleActiveScreenBuffer(hConOut);
880
881 /* restore codepage */
882 SetConsoleOutputCP(oldcp);
883 }
884
885 static void test_GetSetConsoleInputExeName(void)
886 {
887 BOOL ret;
888 DWORD error;
889 char buffer[MAX_PATH], module[MAX_PATH], *p;
890 static char input_exe[MAX_PATH] = "winetest.exe";
891
892 SetLastError(0xdeadbeef);
893 ret = pGetConsoleInputExeNameA(0, NULL);
894 error = GetLastError();
895 ok(ret, "GetConsoleInputExeNameA failed\n");
896 ok(error == ERROR_BUFFER_OVERFLOW, "got %u expected ERROR_BUFFER_OVERFLOW\n", error);
897
898 SetLastError(0xdeadbeef);
899 ret = pGetConsoleInputExeNameA(0, buffer);
900 error = GetLastError();
901 ok(ret, "GetConsoleInputExeNameA failed\n");
902 ok(error == ERROR_BUFFER_OVERFLOW, "got %u expected ERROR_BUFFER_OVERFLOW\n", error);
903
904 GetModuleFileNameA(GetModuleHandle(NULL), module, sizeof(module));
905 p = strrchr(module, '\\') + 1;
906
907 ret = pGetConsoleInputExeNameA(sizeof(buffer)/sizeof(buffer[0]), buffer);
908 ok(ret, "GetConsoleInputExeNameA failed\n");
909 todo_wine ok(!lstrcmpA(buffer, p), "got %s expected %s\n", buffer, p);
910
911 SetLastError(0xdeadbeef);
912 ret = pSetConsoleInputExeNameA(NULL);
913 error = GetLastError();
914 ok(!ret, "SetConsoleInputExeNameA failed\n");
915 ok(error == ERROR_INVALID_PARAMETER, "got %u expected ERROR_INVALID_PARAMETER\n", error);
916
917 SetLastError(0xdeadbeef);
918 ret = pSetConsoleInputExeNameA("");
919 error = GetLastError();
920 ok(!ret, "SetConsoleInputExeNameA failed\n");
921 ok(error == ERROR_INVALID_PARAMETER, "got %u expected ERROR_INVALID_PARAMETER\n", error);
922
923 ret = pSetConsoleInputExeNameA(input_exe);
924 ok(ret, "SetConsoleInputExeNameA failed\n");
925
926 ret = pGetConsoleInputExeNameA(sizeof(buffer)/sizeof(buffer[0]), buffer);
927 ok(ret, "GetConsoleInputExeNameA failed\n");
928 ok(!lstrcmpA(buffer, input_exe), "got %s expected %s\n", buffer, input_exe);
929 }
930
931 static void test_GetConsoleProcessList(void)
932 {
933 DWORD ret, *list = NULL;
934
935 if (!pGetConsoleProcessList)
936 {
937 win_skip("GetConsoleProcessList is not available\n");
938 return;
939 }
940
941 SetLastError(0xdeadbeef);
942 ret = pGetConsoleProcessList(NULL, 0);
943 ok(ret == 0, "Expected failure\n");
944 ok(GetLastError() == ERROR_INVALID_PARAMETER,
945 "Expected ERROR_INVALID_PARAMETER, got %d\n",
946 GetLastError());
947
948 SetLastError(0xdeadbeef);
949 ret = pGetConsoleProcessList(NULL, 1);
950 ok(ret == 0, "Expected failure\n");
951 ok(GetLastError() == ERROR_INVALID_PARAMETER,
952 "Expected ERROR_INVALID_PARAMETER, got %d\n",
953 GetLastError());
954
955 /* We should only have 1 process but only for these specific unit tests as
956 * we created our own console. An AttachConsole(ATTACH_PARENT_PROCESS) would
957 * give us two processes for example.
958 */
959 list = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD));
960
961 SetLastError(0xdeadbeef);
962 ret = pGetConsoleProcessList(list, 0);
963 ok(ret == 0, "Expected failure\n");
964 ok(GetLastError() == ERROR_INVALID_PARAMETER,
965 "Expected ERROR_INVALID_PARAMETER, got %d\n",
966 GetLastError());
967
968 SetLastError(0xdeadbeef);
969 ret = pGetConsoleProcessList(list, 1);
970 todo_wine
971 ok(ret == 1, "Expected 1, got %d\n", ret);
972
973 HeapFree(GetProcessHeap(), 0, list);
974
975 list = HeapAlloc(GetProcessHeap(), 0, ret * sizeof(DWORD));
976
977 SetLastError(0xdeadbeef);
978 ret = pGetConsoleProcessList(list, ret);
979 todo_wine
980 ok(ret == 1, "Expected 1, got %d\n", ret);
981
982 if (ret == 1)
983 {
984 DWORD pid = GetCurrentProcessId();
985 ok(list[0] == pid, "Expected %d, got %d\n", pid, list[0]);
986 }
987
988 HeapFree(GetProcessHeap(), 0, list);
989 }
990
991 START_TEST(console)
992 {
993 HANDLE hConIn, hConOut;
994 BOOL ret;
995 CONSOLE_SCREEN_BUFFER_INFO sbi;
996
997 init_function_pointers();
998
999 /* be sure we have a clean console (and that's our own)
1000 * FIXME: this will make the test fail (currently) if we don't run
1001 * under X11
1002 * Another solution would be to rerun the test under wineconsole with
1003 * the curses backend
1004 */
1005
1006 /* first, we detach and open a fresh console to play with */
1007 FreeConsole();
1008 ok(AllocConsole(), "Couldn't alloc console\n");
1009 hConIn = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
1010 hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
1011
1012 /* now verify everything's ok */
1013 ok(hConIn != INVALID_HANDLE_VALUE, "Opening ConIn\n");
1014 ok(hConOut != INVALID_HANDLE_VALUE, "Opening ConOut\n");
1015
1016 ret = GetConsoleScreenBufferInfo(hConOut, &sbi);
1017 ok(ret, "Getting sb info\n");
1018 if (!ret) return;
1019
1020 /* Non interactive tests */
1021 testCursor(hConOut, sbi.dwSize);
1022 /* test parameters (FIXME: test functionality) */
1023 testCursorInfo(hConOut);
1024 /* will test wrapped (on/off) & processed (on/off) strings output */
1025 testWrite(hConOut, sbi.dwSize);
1026 /* will test line scrolling at the bottom of the screen */
1027 /* testBottomScroll(); */
1028 /* will test all the scrolling operations */
1029 testScroll(hConOut, sbi.dwSize);
1030 /* will test sb creation / modification / codepage handling */
1031 testScreenBuffer(hConOut);
1032 testCtrlHandler();
1033 /* still to be done: access rights & access on objects */
1034
1035 if (!pGetConsoleInputExeNameA || !pSetConsoleInputExeNameA)
1036 win_skip("GetConsoleInputExeNameA and/or SetConsoleInputExeNameA is not available\n");
1037 else
1038 test_GetSetConsoleInputExeName();
1039
1040 test_GetConsoleProcessList();
1041 }