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