?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.39.
[wine/gsoc-2012-control.git] / dlls / kernel32 / tests / console.c
blob2a8c467de9ed58d19c683ba60718f4d10a0ac438
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 /* DEFAULT_ATTRIB is used for all initial filling of the console.
27 * all modifications are made with TEST_ATTRIB so that we could check
28 * what has to be modified or not
29 */
30 #define TEST_ATTRIB (BACKGROUND_BLUE | FOREGROUND_GREEN)
31 #define DEFAULT_ATTRIB (FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED)
32 /* when filling the screen with non-blank chars, this macro defines
33 * what character should be at position 'c'
34 */
35 #define CONTENT(c) ('A' + (((c).Y * 17 + (c).X) % 23))
36
37 #define okCURSOR(hCon, c) do { \
38 CONSOLE_SCREEN_BUFFER_INFO __sbi; \
39 BOOL expect = GetConsoleScreenBufferInfo((hCon), &__sbi) && \
40 __sbi.dwCursorPosition.X == (c).X && __sbi.dwCursorPosition.Y == (c).Y; \
41 ok(expect, "Expected cursor at (%d,%d), got (%d,%d)\n", \
42 (c).X, (c).Y, __sbi.dwCursorPosition.X, __sbi.dwCursorPosition.Y); \
43 } while (0)
44
45 #define okCHAR(hCon, c, ch, attr) do { \
46 char __ch; WORD __attr; DWORD __len; BOOL expect; \
47 expect = ReadConsoleOutputCharacter((hCon), &__ch, 1, (c), &__len) == 1 && __len == 1 && __ch == (ch); \
48 ok(expect, "At (%d,%d): expecting char '%c'/%02x got '%c'/%02x\n", (c).X, (c).Y, (ch), (ch), __ch, __ch); \
49 expect = ReadConsoleOutputAttribute((hCon), &__attr, 1, (c), &__len) == 1 && __len == 1 && __attr == (attr); \
50 ok(expect, "At (%d,%d): expecting attr %04x got %04x\n", (c).X, (c).Y, (attr), __attr); \
51 } while (0)
52
53 /* FIXME: this could be optimized on a speed point of view */
54 static void resetContent(HANDLE hCon, COORD sbSize, BOOL content)
55 {
56 COORD c;
57 WORD attr = DEFAULT_ATTRIB;
58 char ch;
59 DWORD len;
60
61 for (c.X = 0; c.X < sbSize.X; c.X++)
62 {
63 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
64 {
65 ch = (content) ? CONTENT(c) : ' ';
66 WriteConsoleOutputAttribute(hCon, &attr, 1, c, &len);
67 WriteConsoleOutputCharacterA(hCon, &ch, 1, c, &len);
68 }
69 }
70 }
71
72 static void testCursor(HANDLE hCon, COORD sbSize)
73 {
74 COORD c;
75
76 c.X = c.Y = 0;
77 ok(SetConsoleCursorPosition(0, c) == 0, "No handle\n");
78 ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %u got %u\n",
79 ERROR_INVALID_HANDLE, GetLastError());
80
81 c.X = c.Y = 0;
82 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
83 okCURSOR(hCon, c);
84
85 c.X = sbSize.X - 1;
86 c.Y = sbSize.Y - 1;
87 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in lower-right\n");
88 okCURSOR(hCon, c);
89
90 c.X = sbSize.X;
91 c.Y = sbSize.Y - 1;
92 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
93 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
94 ERROR_INVALID_PARAMETER, GetLastError());
95
96 c.X = sbSize.X - 1;
97 c.Y = sbSize.Y;
98 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
99 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
100 ERROR_INVALID_PARAMETER, GetLastError());
101
102 c.X = -1;
103 c.Y = 0;
104 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
105 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
106 ERROR_INVALID_PARAMETER, GetLastError());
107
108 c.X = 0;
109 c.Y = -1;
110 ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
111 ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %u\n",
112 ERROR_INVALID_PARAMETER, GetLastError());
113 }
114
115 static void testWriteSimple(HANDLE hCon, COORD sbSize)
116 {
117 COORD c;
118 DWORD len;
119 const char* mytest = "abcdefg";
120 const int mylen = strlen(mytest);
121
122 /* single line write */
123 c.X = c.Y = 0;
124 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
125
126 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
127 c.Y = 0;
128 for (c.X = 0; c.X < mylen; c.X++)
129 {
130 okCHAR(hCon, c, mytest[c.X], TEST_ATTRIB);
131 }
132
133 okCURSOR(hCon, c);
134 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
135 }
136
137 static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
138 {
139 COORD c;
140 DWORD len, mode;
141 const char* mytest = "123";
142 const int mylen = strlen(mytest);
143 int ret;
144 int p;
145
146 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT)),
147 "clearing wrap at EOL & processed output\n");
148
149 /* write line, wrapping disabled, buffer exceeds sb width */
150 c.X = sbSize.X - 3; c.Y = 0;
151 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
152
153 ret = WriteConsole(hCon, mytest, mylen, &len, NULL);
154 ok(ret != 0 && len == mylen, "Couldn't write, ret = %d, len = %d\n", ret, len);
155 c.Y = 0;
156 for (p = mylen - 3; p < mylen; p++)
157 {
158 c.X = sbSize.X - 3 + p % 3;
159 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
160 }
161
162 c.X = 0; c.Y = 1;
163 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
164
165 p = sbSize.X - 3 + mylen % 3;
166 c.X = p; c.Y = 0;
167
168 /* write line, wrapping disabled, strings end on end of line */
169 c.X = sbSize.X - mylen; c.Y = 0;
170 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
171
172 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
173 }
174
175 static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize)
176 {
177 COORD c;
178 DWORD len, mode;
179 const char* mytest = "abcd\nf\tg";
180 const int mylen = strlen(mytest);
181 const int mylen2 = strchr(mytest, '\n') - mytest;
182 int p;
183
184 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, (mode | ENABLE_PROCESSED_OUTPUT) & ~ENABLE_WRAP_AT_EOL_OUTPUT),
185 "clearing wrap at EOL & setting processed output\n");
186
187 /* write line, wrapping disabled, buffer exceeds sb width */
188 c.X = sbSize.X - 5; c.Y = 0;
189 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-5\n");
190
191 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
192 c.Y = 0;
193 for (c.X = sbSize.X - 5; c.X < sbSize.X - 1; c.X++)
194 {
195 okCHAR(hCon, c, mytest[c.X - sbSize.X + 5], TEST_ATTRIB);
196 }
197 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
198
199 c.X = 0; c.Y++;
200 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
201 for (c.X = 1; c.X < 8; c.X++)
202 okCHAR(hCon, c, ' ', TEST_ATTRIB);
203 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
204 c.X++;
205 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
206
207 okCURSOR(hCon, c);
208
209 /* write line, wrapping disabled, strings end on end of line */
210 c.X = sbSize.X - 4; c.Y = 0;
211 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");
212
213 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
214 c.Y = 0;
215 for (c.X = sbSize.X - 4; c.X < sbSize.X; c.X++)
216 {
217 okCHAR(hCon, c, mytest[c.X - sbSize.X + 4], TEST_ATTRIB);
218 }
219 c.X = 0; c.Y++;
220 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
221 for (c.X = 1; c.X < 8; c.X++)
222 okCHAR(hCon, c, ' ', TEST_ATTRIB);
223 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
224 c.X++;
225 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
226
227 okCURSOR(hCon, c);
228
229 /* write line, wrapping disabled, strings end after end of line */
230 c.X = sbSize.X - 3; c.Y = 0;
231 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");
232
233 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
234 c.Y = 0;
235 for (p = mylen2 - 3; p < mylen2; p++)
236 {
237 c.X = sbSize.X - 3 + p % 3;
238 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
239 }
240 c.X = 0; c.Y = 1;
241 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
242 for (c.X = 1; c.X < 8; c.X++)
243 okCHAR(hCon, c, ' ', TEST_ATTRIB);
244 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
245 c.X++;
246 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
247
248 okCURSOR(hCon, c);
249 }
250
251 static void testWriteWrappedNotProcessed(HANDLE hCon, COORD sbSize)
252 {
253 COORD c;
254 DWORD len, mode;
255 const char* mytest = "abcd\nf\tg";
256 const int mylen = strlen(mytest);
257 int p;
258
259 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon,(mode | ENABLE_WRAP_AT_EOL_OUTPUT) & ~(ENABLE_PROCESSED_OUTPUT)),
260 "setting wrap at EOL & clearing processed output\n");
261
262 /* write line, wrapping enabled, buffer doesn't exceed sb width */
263 c.X = sbSize.X - 9; c.Y = 0;
264 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");
265
266 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
267 c.Y = 0;
268 for (p = 0; p < mylen; p++)
269 {
270 c.X = sbSize.X - 9 + p;
271 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
272 }
273 c.X = sbSize.X - 9 + mylen;
274 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
275 c.X = 0; c.Y = 1;
276 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
277
278 /* write line, wrapping enabled, buffer does exceed sb width */
279 c.X = sbSize.X - 3; c.Y = 0;
280 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
281
282 c.Y = 1;
283 c.X = mylen - 3;
284 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
285 }
286
287 static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize)
288 {
289 COORD c;
290 DWORD len, mode;
291 const char* mytest = "abcd\nf\tg";
292 const int mylen = strlen(mytest);
293 int p;
294
295 ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode | (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)),
296 "setting wrap at EOL & processed output\n");
297
298 /* write line, wrapping enabled, buffer doesn't exceed sb width */
299 c.X = sbSize.X - 9; c.Y = 0;
300 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");
301
302 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
303 for (p = 0; p < 4; p++)
304 {
305 c.X = sbSize.X - 9 + p;
306 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
307 }
308 c.X = sbSize.X - 9 + p;
309 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
310 c.X = 0; c.Y++;
311 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
312 for (c.X = 1; c.X < 8; c.X++)
313 okCHAR(hCon, c, ' ', TEST_ATTRIB);
314 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
315 c.X++;
316 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
317 okCURSOR(hCon, c);
318
319 /* write line, wrapping enabled, buffer does exceed sb width */
320 c.X = sbSize.X - 3; c.Y = 2;
321 ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
322
323 ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
324 for (p = 0; p < 3; p++)
325 {
326 c.X = sbSize.X - 3 + p;
327 okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
328 }
329 c.X = 0; c.Y++;
330 okCHAR(hCon, c, mytest[3], TEST_ATTRIB);
331 c.X++;
332 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
333
334 c.X = 0; c.Y++;
335 okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
336 for (c.X = 1; c.X < 8; c.X++)
337 okCHAR(hCon, c, ' ', TEST_ATTRIB);
338 okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
339 c.X++;
340 okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
341 okCURSOR(hCon, c);
342 }
343
344 static void testWrite(HANDLE hCon, COORD sbSize)
345 {
346 /* FIXME: should in fact insure that the sb is at least 10 character wide */
347 ok(SetConsoleTextAttribute(hCon, TEST_ATTRIB), "Setting default text color\n");
348 resetContent(hCon, sbSize, FALSE);
349 testWriteSimple(hCon, sbSize);
350 resetContent(hCon, sbSize, FALSE);
351 testWriteNotWrappedNotProcessed(hCon, sbSize);
352 resetContent(hCon, sbSize, FALSE);
353 testWriteNotWrappedProcessed(hCon, sbSize);
354 resetContent(hCon, sbSize, FALSE);
355 testWriteWrappedNotProcessed(hCon, sbSize);
356 resetContent(hCon, sbSize, FALSE);
357 testWriteWrappedProcessed(hCon, sbSize);
358 }
359
360 static void testScroll(HANDLE hCon, COORD sbSize)
361 {
362 SMALL_RECT scroll, clip;
363 COORD dst, c, tc;
364 CHAR_INFO ci;
365
366 #define W 11
367 #define H 7
368
369 #define IN_SRECT(r,c) ((r).Left <= (c).X && (c).X <= (r).Right && (r).Top <= (c).Y && (c).Y <= (r).Bottom)
370 #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)
371
372 /* no clipping, src & dst rect don't overlap */
373 resetContent(hCon, sbSize, TRUE);
374
375 scroll.Left = 0;
376 scroll.Right = W - 1;
377 scroll.Top = 0;
378 scroll.Bottom = H - 1;
379 dst.X = W + 3;
380 dst.Y = H + 3;
381 ci.Char.UnicodeChar = '#';
382 ci.Attributes = TEST_ATTRIB;
383
384 clip.Left = 0;
385 clip.Right = sbSize.X - 1;
386 clip.Top = 0;
387 clip.Bottom = sbSize.Y - 1;
388
389 ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");
390
391 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
392 {
393 for (c.X = 0; c.X < sbSize.X; c.X++)
394 {
395 if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
396 {
397 tc.X = c.X - dst.X;
398 tc.Y = c.Y - dst.Y;
399 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
400 }
401 else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
402 okCHAR(hCon, c, '#', TEST_ATTRIB);
403 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
404 }
405 }
406
407 /* no clipping, src & dst rect do overlap */
408 resetContent(hCon, sbSize, TRUE);
409
410 scroll.Left = 0;
411 scroll.Right = W - 1;
412 scroll.Top = 0;
413 scroll.Bottom = H - 1;
414 dst.X = W /2;
415 dst.Y = H / 2;
416 ci.Char.UnicodeChar = '#';
417 ci.Attributes = TEST_ATTRIB;
418
419 clip.Left = 0;
420 clip.Right = sbSize.X - 1;
421 clip.Top = 0;
422 clip.Bottom = sbSize.Y - 1;
423
424 ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");
425
426 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
427 {
428 for (c.X = 0; c.X < sbSize.X; c.X++)
429 {
430 if (dst.X <= c.X && c.X < dst.X + W && dst.Y <= c.Y && c.Y < dst.Y + H)
431 {
432 tc.X = c.X - dst.X;
433 tc.Y = c.Y - dst.Y;
434 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
435 }
436 else if (c.X < W && c.Y < H) okCHAR(hCon, c, '#', TEST_ATTRIB);
437 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
438 }
439 }
440
441 /* clipping, src & dst rect don't overlap */
442 resetContent(hCon, sbSize, TRUE);
443
444 scroll.Left = 0;
445 scroll.Right = W - 1;
446 scroll.Top = 0;
447 scroll.Bottom = H - 1;
448 dst.X = W + 3;
449 dst.Y = H + 3;
450 ci.Char.UnicodeChar = '#';
451 ci.Attributes = TEST_ATTRIB;
452
453 clip.Left = W / 2;
454 clip.Right = min(W + W / 2, sbSize.X - 1);
455 clip.Top = H / 2;
456 clip.Bottom = min(H + H / 2, sbSize.Y - 1);
457
458 ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");
459
460 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
461 {
462 for (c.X = 0; c.X < sbSize.X; c.X++)
463 {
464 if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
465 {
466 tc.X = c.X - dst.X;
467 tc.Y = c.Y - dst.Y;
468 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
469 }
470 else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
471 okCHAR(hCon, c, '#', TEST_ATTRIB);
472 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
473 }
474 }
475
476 /* clipping, src & dst rect do overlap */
477 resetContent(hCon, sbSize, TRUE);
478
479 scroll.Left = 0;
480 scroll.Right = W - 1;
481 scroll.Top = 0;
482 scroll.Bottom = H - 1;
483 dst.X = W / 2 - 3;
484 dst.Y = H / 2 - 3;
485 ci.Char.UnicodeChar = '#';
486 ci.Attributes = TEST_ATTRIB;
487
488 clip.Left = W / 2;
489 clip.Right = min(W + W / 2, sbSize.X - 1);
490 clip.Top = H / 2;
491 clip.Bottom = min(H + H / 2, sbSize.Y - 1);
492
493 ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");
494
495 for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
496 {
497 for (c.X = 0; c.X < sbSize.X; c.X++)
498 {
499 if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
500 {
501 tc.X = c.X - dst.X;
502 tc.Y = c.Y - dst.Y;
503 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
504 }
505 else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
506 okCHAR(hCon, c, '#', TEST_ATTRIB);
507 else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
508 }
509 }
510 }
511
512 static int mch_count;
513 /* we need the event as Wine console event generation isn't synchronous
514 * (ie GenerateConsoleCtrlEvent returns before all ctrl-handlers in all
515 * processes have been called).
516 */
517 static HANDLE mch_event;
518 static BOOL WINAPI mch(DWORD event)
519 {
520 mch_count++;
521 SetEvent(mch_event);
522 return TRUE;
523 }
524
525 static void testCtrlHandler(void)
526 {
527 ok(!SetConsoleCtrlHandler(mch, FALSE), "Shouldn't succeed\n");
528 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Bad error %u\n", GetLastError());
529 ok(SetConsoleCtrlHandler(mch, TRUE), "Couldn't set handler\n");
530 /* wine requires the event for the test, as we cannot insure, so far, that event
531 * are processed synchronously in GenerateConsoleCtrlEvent()
532 */
533 mch_event = CreateEventA(NULL, TRUE, FALSE, NULL);
534 mch_count = 0;
535 ok(GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0), "Couldn't send ctrl-c event\n");
536 /* FIXME: it isn't synchronous on wine but it can still happen before we test */
537 if (0) ok(mch_count == 1, "Event isn't synchronous\n");
538 ok(WaitForSingleObject(mch_event, 3000) == WAIT_OBJECT_0, "event sending didn't work\n");
539 CloseHandle(mch_event);
540
541 /* Turning off ctrl-c handling doesn't work on win9x such way ... */
542 ok(SetConsoleCtrlHandler(NULL, TRUE), "Couldn't turn off ctrl-c handling\n");
543 mch_event = CreateEventA(NULL, TRUE, FALSE, NULL);
544 mch_count = 0;
545 if(!(GetVersion() & 0x80000000))
546 /* ... and next line leads to an unhandled exception on 9x. Avoid it on 9x. */
547 ok(GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0), "Couldn't send ctrl-c event\n");
548 ok(WaitForSingleObject(mch_event, 3000) == WAIT_TIMEOUT && mch_count == 0, "Event shouldn't have been sent\n");
549 CloseHandle(mch_event);
550 ok(SetConsoleCtrlHandler(mch, FALSE), "Couldn't remove handler\n");
551 ok(!SetConsoleCtrlHandler(mch, FALSE), "Shouldn't succeed\n");
552 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Bad error %u\n", GetLastError());
553 }
554
555 /*
556 * Test console screen buffer:
557 * 1) Try to set invalid handle.
558 * 2) Try to set non-console handles.
559 * 3) Use CONOUT$ file as active SB.
560 * 4) Test cursor.
561 * 5) Test output codepage to show it is not a property of SB.
562 * 6) Test switching to old SB if we close all handles to current SB - works
563 * in Windows, TODO in wine.
564 *
565 * What is not tested but should be:
566 * 1) ScreenBufferInfo
567 */
568 static void testScreenBuffer(HANDLE hConOut)
569 {
570 HANDLE hConOutRW, hConOutRO, hConOutWT;
571 HANDLE hFileOutRW, hFileOutRO, hFileOutWT;
572 HANDLE hConOutNew;
573 char test_str1[] = "Test for SB1";
574 char test_str2[] = "Test for SB2";
575 char test_cp866[] = {0xe2, 0xa5, 0xe1, 0xe2, 0};
576 char test_cp1251[] = {0xf2, 0xe5, 0xf1, 0xf2, 0};
577 WCHAR test_unicode[] = {0x0442, 0x0435, 0x0441, 0x0442, 0};
578 WCHAR str_wbuf[20];
579 char str_buf[20];
580 DWORD len;
581 COORD c;
582 BOOL ret;
583 DWORD oldcp;
584
585 /* In the beginning set output codepage to 866 */
586 oldcp = GetConsoleOutputCP();
587 ok(SetConsoleOutputCP(866), "Cannot set output codepage to 866\n");
588
589 hConOutRW = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
590 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
591 CONSOLE_TEXTMODE_BUFFER, NULL);
592 ok(hConOutRW != INVALID_HANDLE_VALUE,
593 "Cannot create a new screen buffer for ReadWrite\n");
594 hConOutRO = CreateConsoleScreenBuffer(GENERIC_READ,
595 FILE_SHARE_READ, NULL,
596 CONSOLE_TEXTMODE_BUFFER, NULL);
597 ok(hConOutRO != INVALID_HANDLE_VALUE,
598 "Cannot create a new screen buffer for ReadOnly\n");
599 hConOutWT = CreateConsoleScreenBuffer(GENERIC_WRITE,
600 FILE_SHARE_WRITE, NULL,
601 CONSOLE_TEXTMODE_BUFFER, NULL);
602 ok(hConOutWT != INVALID_HANDLE_VALUE,
603 "Cannot create a new screen buffer for WriteOnly\n");
604
605 hFileOutRW = CreateFileA("NUL", GENERIC_READ | GENERIC_WRITE,
606 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
607 OPEN_EXISTING, 0, NULL);
608 ok(hFileOutRW != INVALID_HANDLE_VALUE, "Cannot open NUL for ReadWrite\n");
609 hFileOutRO = CreateFileA("NUL", GENERIC_READ, FILE_SHARE_READ,
610 NULL, OPEN_EXISTING, 0, NULL);
611 ok(hFileOutRO != INVALID_HANDLE_VALUE, "Cannot open NUL for ReadOnly\n");
612 hFileOutWT = CreateFileA("NUL", GENERIC_WRITE, FILE_SHARE_WRITE,
613 NULL, OPEN_EXISTING, 0, NULL);
614 ok(hFileOutWT != INVALID_HANDLE_VALUE, "Cannot open NUL for WriteOnly\n");
615
616 /* Trying to set invalid handle */
617 SetLastError(0);
618 ok(!SetConsoleActiveScreenBuffer(INVALID_HANDLE_VALUE),
619 "Shouldn't succeed\n");
620 ok(GetLastError() == ERROR_INVALID_HANDLE,
621 "GetLastError: expecting %u got %u\n",
622 ERROR_INVALID_HANDLE, GetLastError());
623
624 /* Trying to set non-console handles */
625 SetLastError(0);
626 ok(!SetConsoleActiveScreenBuffer(hFileOutRW), "Shouldn't succeed\n");
627 ok(GetLastError() == ERROR_INVALID_HANDLE,
628 "GetLastError: expecting %u got %u\n",
629 ERROR_INVALID_HANDLE, GetLastError());
630
631 SetLastError(0);
632 ok(!SetConsoleActiveScreenBuffer(hFileOutRO), "Shouldn't succeed\n");
633 ok(GetLastError() == ERROR_INVALID_HANDLE,
634 "GetLastError: expecting %u got %u\n",
635 ERROR_INVALID_HANDLE, GetLastError());
636
637 SetLastError(0);
638 ok(!SetConsoleActiveScreenBuffer(hFileOutWT), "Shouldn't succeed\n");
639 ok(GetLastError() == ERROR_INVALID_HANDLE,
640 "GetLastError: expecting %u got %u\n",
641 ERROR_INVALID_HANDLE, GetLastError());
642
643 CloseHandle(hFileOutRW);
644 CloseHandle(hFileOutRO);
645 CloseHandle(hFileOutWT);
646
647 /* Trying to set SB handles with various access modes */
648 SetLastError(0);
649 ok(!SetConsoleActiveScreenBuffer(hConOutRO), "Shouldn't succeed\n");
650 ok(GetLastError() == ERROR_INVALID_HANDLE,
651 "GetLastError: expecting %u got %u\n",
652 ERROR_INVALID_HANDLE, GetLastError());
653
654 ok(SetConsoleActiveScreenBuffer(hConOutWT), "Couldn't set new WriteOnly SB\n");
655
656 ok(SetConsoleActiveScreenBuffer(hConOutRW), "Couldn't set new ReadWrite SB\n");
657
658 CloseHandle(hConOutWT);
659 CloseHandle(hConOutRO);
660
661 /* Now we have two ReadWrite SB, active must be hConOutRW */
662 /* Open current SB via CONOUT$ */
663 hConOutNew = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0,
664 NULL, OPEN_EXISTING, 0, 0);
665 ok(hConOutNew != INVALID_HANDLE_VALUE, "CONOUT$ is not opened\n");
666
667
668 /* test cursor */
669 c.X = c.Y = 10;
670 SetConsoleCursorPosition(hConOut, c);
671 c.X = c.Y = 5;
672 SetConsoleCursorPosition(hConOutRW, c);
673 okCURSOR(hConOutNew, c);
674 c.X = c.Y = 10;
675 okCURSOR(hConOut, c);
676
677
678 c.X = c.Y = 0;
679
680 /* Write using hConOutNew... */
681 SetConsoleCursorPosition(hConOutNew, c);
682 ret = WriteConsoleA(hConOutNew, test_str2, lstrlenA(test_str2), &len, NULL);
683 ok (ret && len == lstrlenA(test_str2), "WriteConsoleA failed\n");
684 /* ... and read it back via hConOutRW */
685 ret = ReadConsoleOutputCharacterA(hConOutRW, str_buf, lstrlenA(test_str2), c, &len);
686 ok(ret && len == lstrlenA(test_str2), "ReadConsoleOutputCharacterA failed\n");
687 str_buf[lstrlenA(test_str2)] = 0;
688 ok(!lstrcmpA(str_buf, test_str2), "got '%s' expected '%s'\n", str_buf, test_str2);
689
690
691 /* Now test output codepage handling. Current is 866 as we set earlier. */
692 SetConsoleCursorPosition(hConOutRW, c);
693 ret = WriteConsoleA(hConOutRW, test_cp866, lstrlenA(test_cp866), &len, NULL);
694 ok(ret && len == lstrlenA(test_cp866), "WriteConsoleA failed\n");
695 ret = ReadConsoleOutputCharacterW(hConOutRW, str_wbuf, lstrlenA(test_cp866), c, &len);
696 ok(ret && len == lstrlenA(test_cp866), "ReadConsoleOutputCharacterW failed\n");
697 str_wbuf[lstrlenA(test_cp866)] = 0;
698 ok(!lstrcmpW(str_wbuf, test_unicode), "string does not match the pattern\n");
699
700 /*
701 * cp866 is OK, let's switch to cp1251.
702 * We expect that this codepage will be used in every SB - active and not.
703 */
704 ok(SetConsoleOutputCP(1251), "Cannot set output cp to 1251\n");
705 SetConsoleCursorPosition(hConOutRW, c);
706 ret = WriteConsoleA(hConOutRW, test_cp1251, lstrlenA(test_cp1251), &len, NULL);
707 ok(ret && len == lstrlenA(test_cp1251), "WriteConsoleA failed\n");
708 ret = ReadConsoleOutputCharacterW(hConOutRW, str_wbuf, lstrlenA(test_cp1251), c, &len);
709 ok(ret && len == lstrlenA(test_cp1251), "ReadConsoleOutputCharacterW failed\n");
710 str_wbuf[lstrlenA(test_cp1251)] = 0;
711 ok(!lstrcmpW(str_wbuf, test_unicode), "string does not match the pattern\n");
712
713 /* Check what has happened to hConOut. */
714 SetConsoleCursorPosition(hConOut, c);
715 ret = WriteConsoleA(hConOut, test_cp1251, lstrlenA(test_cp1251), &len, NULL);
716 ok(ret && len == lstrlenA(test_cp1251), "WriteConsoleA failed\n");
717 ret = ReadConsoleOutputCharacterW(hConOut, str_wbuf, lstrlenA(test_cp1251), c, &len);
718 ok(ret && len == lstrlenA(test_cp1251), "ReadConsoleOutputCharacterW failed\n");
719 str_wbuf[lstrlenA(test_cp1251)] = 0;
720 ok(!lstrcmpW(str_wbuf, test_unicode), "string does not match the pattern\n");
721
722 /* Close all handles of current console SB */
723 CloseHandle(hConOutNew);
724 CloseHandle(hConOutRW);
725
726 /* Now active SB should be hConOut */
727 hConOutNew = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0,
728 NULL, OPEN_EXISTING, 0, 0);
729 ok(hConOutNew != INVALID_HANDLE_VALUE, "CONOUT$ is not opened\n");
730
731 /* Write using hConOutNew... */
732 SetConsoleCursorPosition(hConOutNew, c);
733 ret = WriteConsoleA(hConOutNew, test_str1, lstrlenA(test_str1), &len, NULL);
734 ok (ret && len == lstrlenA(test_str1), "WriteConsoleA failed\n");
735 /* ... and read it back via hConOut */
736 ret = ReadConsoleOutputCharacterA(hConOut, str_buf, lstrlenA(test_str1), c, &len);
737 ok(ret && len == lstrlenA(test_str1), "ReadConsoleOutputCharacterA failed\n");
738 str_buf[lstrlenA(test_str1)] = 0;
739 todo_wine ok(!lstrcmpA(str_buf, test_str1), "got '%s' expected '%s'\n", str_buf, test_str1);
740 CloseHandle(hConOutNew);
741
742 /* This is not really needed under Windows */
743 SetConsoleActiveScreenBuffer(hConOut);
744
745 /* restore codepage */
746 SetConsoleOutputCP(oldcp);
747 }
748
749 START_TEST(console)
750 {
751 HANDLE hConIn, hConOut;
752 BOOL ret;
753 CONSOLE_SCREEN_BUFFER_INFO sbi;
754
755 /* be sure we have a clean console (and that's our own)
756 * FIXME: this will make the test fail (currently) if we don't run
757 * under X11
758 * Another solution would be to rerun the test under wineconsole with
759 * the curses backend
760 */
761
762 /* first, we detach and open a fresh console to play with */
763 FreeConsole();
764 ok(AllocConsole(), "Couldn't alloc console\n");
765 hConIn = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
766 hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
767
768 /* now verify everything's ok */
769 ok(hConIn != INVALID_HANDLE_VALUE, "Opening ConIn\n");
770 ok(hConOut != INVALID_HANDLE_VALUE, "Opening ConOut\n");
771
772 ok(ret = GetConsoleScreenBufferInfo(hConOut, &sbi), "Getting sb info\n");
773 if (!ret) return;
774
775 /* Non interactive tests */
776 testCursor(hConOut, sbi.dwSize);
777 /* will test wrapped (on/off) & processed (on/off) strings output */
778 testWrite(hConOut, sbi.dwSize);
779 /* will test line scrolling at the bottom of the screen */
780 /* testBottomScroll(); */
781 /* will test all the scrolling operations */
782 testScroll(hConOut, sbi.dwSize);
783 /* will test sb creation / modification / codepage handling */
784 testScreenBuffer(hConOut);
785 testCtrlHandler();
786 /* still to be done: access rights & access on objects */
787 }
GSOC 2012 project to enhance the control panel