dlls/kernel/tests/console.c - wine - Git at Google

 /*
  * Unit tests for console API
  *
  * Copyright (c) 2003 Eric Pouech
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 #include "wine/test.h"
 #include <windows.h>
 #include <stdio.h>

 /* DEFAULT_ATTRIB is used for all initial filling of the console.
  * all modifications are made with TEST_ATTRIB so that we could check
  * what has to be modified or not
  */
 #define TEST_ATTRIB    (BACKGROUND_BLUE | FOREGROUND_GREEN)
 #define DEFAULT_ATTRIB (FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED)
 /* when filling the screen with non-blank chars, this macro defines
  * what character should be at position 'c'
  */
 #define CONTENT(c)    ('A' + (((c).Y * 17 + (c).X) % 23))

 #define	okCURSOR(hCon, c) do { \
   CONSOLE_SCREEN_BUFFER_INFO __sbi; \
   BOOL expect = GetConsoleScreenBufferInfo((hCon), &__sbi) && \
                 __sbi.dwCursorPosition.X == (c).X && __sbi.dwCursorPosition.Y == (c).Y; \
   ok(expect, "Expected cursor at (%d,%d), got (%d,%d)\n", \
      (c).X, (c).Y, __sbi.dwCursorPosition.X, __sbi.dwCursorPosition.Y); \
 } while (0)

 #define okCHAR(hCon, c, ch, attr) do { \
   char __ch; WORD __attr; DWORD __len; BOOL expect; \
   expect = ReadConsoleOutputCharacter((hCon), &__ch, 1, (c), &__len) == 1 && __len == 1 && __ch == (ch); \
   ok(expect, "At (%d,%d): expecting char '%c'/%02x got '%c'/%02x\n", (c).X, (c).Y, (ch), (ch), __ch, __ch); \
   expect = ReadConsoleOutputAttribute((hCon), &__attr, 1, (c), &__len) == 1 && __len == 1 && __attr == (attr); \
   ok(expect, "At (%d,%d): expecting attr %04x got %04x\n", (c).X, (c).Y, (attr), __attr); \
 } while (0)

 /* FIXME: this could be optimized on a speed point of view */
 static void resetContent(HANDLE hCon, COORD sbSize, BOOL content)
 {
     COORD       c;
     WORD        attr = DEFAULT_ATTRIB;
     char        ch;
     DWORD       len;

     for (c.X = 0; c.X < sbSize.X; c.X++)
     {
         for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
         {
             ch = (content) ? CONTENT(c) : ' ';
             WriteConsoleOutputAttribute(hCon, &attr, 1, c, &len);
             WriteConsoleOutputCharacterA(hCon, &ch, 1, c, &len);
         }
     }
 }

 static void testCursor(HANDLE hCon, COORD sbSize)
 {
     COORD		c;

     c.X = c.Y = 0;
     ok(SetConsoleCursorPosition(0, c) == 0, "No handle\n");
     ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %u got %lu\n",
        ERROR_INVALID_HANDLE, GetLastError());

     c.X = c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
     okCURSOR(hCon, c);

     c.X = sbSize.X - 1;
     c.Y = sbSize.Y - 1;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in lower-right\n");
     okCURSOR(hCon, c);

     c.X = sbSize.X;
     c.Y = sbSize.Y - 1;
     ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
     ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
        ERROR_INVALID_PARAMETER, GetLastError());

     c.X = sbSize.X - 1;
     c.Y = sbSize.Y;
     ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
     ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
        ERROR_INVALID_PARAMETER, GetLastError());

     c.X = -1;
     c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
     ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
        ERROR_INVALID_PARAMETER, GetLastError());

     c.X = 0;
     c.Y = -1;
     ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
     ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
        ERROR_INVALID_PARAMETER, GetLastError());
 }

 static void testWriteSimple(HANDLE hCon, COORD sbSize)
 {
     COORD		c;
     DWORD		len;
     const char*		mytest = "abcdefg";
     const int	mylen = strlen(mytest);

     /* single line write */
     c.X = c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     c.Y = 0;
     for (c.X = 0; c.X < mylen; c.X++)
     {
         okCHAR(hCon, c, mytest[c.X], TEST_ATTRIB);
     }

     okCURSOR(hCon, c);
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
 }

 static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
 {
     COORD		c;
     DWORD		len, mode;
     char*		mytest;
     int                 mylen;
     int                 ret;
     int			p;

     ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT)),
        "clearing wrap at EOL & processed output\n");

     /* write line, wrapping disabled, buffer exceeds sb width */
     c.X = sbSize.X - 3; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

     mytest = "123";

     mylen = strlen(mytest);

     ret = WriteConsole(hCon, mytest, mylen, &len, NULL);
     ok(ret != 0 && len == mylen, "Couldn't write, ret = %d, len = %ld\n", ret, len);
     c.Y = 0;
     for (p = mylen - 3; p < mylen; p++)
     {
         c.X = sbSize.X - 3 + p % 3;
         okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
     }

     c.X = 0; c.Y = 1;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     p = sbSize.X - 3 + mylen % 3;
     c.X = p; c.Y = 0;

     /* write line, wrapping disabled, strings end on end of line */
     c.X = sbSize.X - mylen; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
 }

 static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize)
 {
     COORD		c;
     DWORD		len, mode;
     const char*		mytest = "abcd\nf\tg";
     const int	mylen = strlen(mytest);
     const int	mylen2 = strchr(mytest, '\n') - mytest;
     int			p;

     ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, (mode | ENABLE_PROCESSED_OUTPUT) & ~ENABLE_WRAP_AT_EOL_OUTPUT),
        "clearing wrap at EOL & setting processed output\n");

     /* write line, wrapping disabled, buffer exceeds sb width */
     c.X = sbSize.X - 5; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-5\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     c.Y = 0;
     for (c.X = sbSize.X - 5; c.X < sbSize.X - 1; c.X++)
     {
         okCHAR(hCon, c, mytest[c.X - sbSize.X + 5], TEST_ATTRIB);
     }
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     c.X = 0; c.Y++;
     okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
     for (c.X = 1; c.X < 8; c.X++)
         okCHAR(hCon, c, ' ', TEST_ATTRIB);
     okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
     c.X++;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     okCURSOR(hCon, c);

     /* write line, wrapping disabled, strings end on end of line */
     c.X = sbSize.X - 4; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     c.Y = 0;
     for (c.X = sbSize.X - 4; c.X < sbSize.X; c.X++)
     {
         okCHAR(hCon, c, mytest[c.X - sbSize.X + 4], TEST_ATTRIB);
     }
     c.X = 0; c.Y++;
     okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
     for (c.X = 1; c.X < 8; c.X++)
         okCHAR(hCon, c, ' ', TEST_ATTRIB);
     okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
     c.X++;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     okCURSOR(hCon, c);

     /* write line, wrapping disabled, strings end after end of line */
     c.X = sbSize.X - 3; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     c.Y = 0;
     for (p = mylen2 - 3; p < mylen2; p++)
     {
         c.X = sbSize.X - 3 + p % 3;
         okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
     }
     c.X = 0; c.Y = 1;
     okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
     for (c.X = 1; c.X < 8; c.X++)
         okCHAR(hCon, c, ' ', TEST_ATTRIB);
     okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
     c.X++;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     okCURSOR(hCon, c);
 }

 static void testWriteWrappedNotProcessed(HANDLE hCon, COORD sbSize)
 {
     COORD		c;
     DWORD		len, mode;
     const char*		mytest = "abcd\nf\tg";
     const int	mylen = strlen(mytest);
     int			p;

     ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon,(mode | ENABLE_WRAP_AT_EOL_OUTPUT) & ~(ENABLE_PROCESSED_OUTPUT)),
        "setting wrap at EOL & clearing processed output\n");

     /* write line, wrapping enabled, buffer doesn't exceed sb width */
     c.X = sbSize.X - 9; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     c.Y = 0;
     for (p = 0; p < mylen; p++)
     {
         c.X = sbSize.X - 9 + p;
         okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
     }
     c.X = sbSize.X - 9 + mylen;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
     c.X = 0; c.Y = 1;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     /* write line, wrapping enabled, buffer does exceed sb width */
     c.X = sbSize.X - 3; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

     c.Y = 1;
     c.X = mylen - 3;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
 }

 static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize)
 {
     COORD		c;
     DWORD		len, mode;
     const char*		mytest = "abcd\nf\tg";
     const int	mylen = strlen(mytest);
     int			p;

     ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode | (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)),
        "setting wrap at EOL & processed output\n");

     /* write line, wrapping enabled, buffer doesn't exceed sb width */
     c.X = sbSize.X - 9; c.Y = 0;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     for (p = 0; p < 4; p++)
     {
         c.X = sbSize.X - 9 + p;
         okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
     }
     c.X = sbSize.X - 9 + p;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
     c.X = 0; c.Y++;
     okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
     for (c.X = 1; c.X < 8; c.X++)
         okCHAR(hCon, c, ' ', TEST_ATTRIB);
     okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
     c.X++;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
     okCURSOR(hCon, c);

     /* write line, wrapping enabled, buffer does exceed sb width */
     c.X = sbSize.X - 3; c.Y = 2;
     ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

     ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
     for (p = 0; p < 3; p++)
     {
         c.X = sbSize.X - 3 + p;
         okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
     }
     c.X = 0; c.Y++;
     okCHAR(hCon, c, mytest[3], TEST_ATTRIB);
     c.X++;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

     c.X = 0; c.Y++;
     okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
     for (c.X = 1; c.X < 8; c.X++)
         okCHAR(hCon, c, ' ', TEST_ATTRIB);
     okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
     c.X++;
     okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
     okCURSOR(hCon, c);
 }

 static void testWrite(HANDLE hCon, COORD sbSize)
 {
     /* FIXME: should in fact insure that the sb is at least 10 character wide */
     ok(SetConsoleTextAttribute(hCon, TEST_ATTRIB), "Setting default text color\n");
     resetContent(hCon, sbSize, FALSE);
     testWriteSimple(hCon, sbSize);
     resetContent(hCon, sbSize, FALSE);
     testWriteNotWrappedNotProcessed(hCon, sbSize);
     resetContent(hCon, sbSize, FALSE);
     testWriteNotWrappedProcessed(hCon, sbSize);
     resetContent(hCon, sbSize, FALSE);
     testWriteWrappedNotProcessed(hCon, sbSize);
     resetContent(hCon, sbSize, FALSE);
     testWriteWrappedProcessed(hCon, sbSize);
 }

 #if 0
 static void testScroll(HANDLE hCon, COORD sbSize)
 {
     SMALL_RECT  scroll, clip;
     COORD       dst, c, tc;
     CHAR_INFO   ci;

 #define W 11
 #define H 7

     /* no clipping, src & dst rect don't overlap */
     resetContent(hCon, sbSize, TRUE);

 #define IN_SRECT(r,c) ((r).Left <= (c).X && (c).X <= (r).Right && (r).Top <= (c).Y && (c).Y <= (r).Bottom)
 #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)

     scroll.Left = 0;
     scroll.Right = W - 1;
     scroll.Top = 0;
     scroll.Bottom = H - 1;
     dst.X = W + 3;
     dst.Y = H + 3;
     ci.Char.UnicodeChar = '#';
     ci.Attributes = TEST_ATTRIB;

     clip.Left = 0;
     clip.Right = sbSize.X - 1;
     clip.Top = 0;
     clip.Bottom = sbSize.Y - 1;

     ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");

     for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
     {
         for (c.X = 0; c.X < sbSize.X; c.X++)
         {
             if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
             {
                 tc.X = c.X - dst.X;
                 tc.Y = c.Y - dst.Y;
                 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
             }
             else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
                 okCHAR(hCon, c, '#', TEST_ATTRIB);
             else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
         }
     }

     /* no clipping, src & dst rect do overlap */
     resetContent(hCon, sbSize, TRUE);

     scroll.Left = 0;
     scroll.Right = W - 1;
     scroll.Top = 0;
     scroll.Bottom = H - 1;
     dst.X = W /2;
     dst.Y = H / 2;
     ci.Char.UnicodeChar = '#';
     ci.Attributes = TEST_ATTRIB;

     clip.Left = 0;
     clip.Right = sbSize.X - 1;
     clip.Top = 0;
     clip.Bottom = sbSize.Y - 1;

     ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");

     for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
     {
         for (c.X = 0; c.X < sbSize.X; c.X++)
         {
             if (dst.X <= c.X && c.X < dst.X + W && dst.Y <= c.Y && c.Y < dst.Y + H)
             {
                 tc.X = c.X - dst.X;
                 tc.Y = c.Y - dst.Y;
                 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
             }
             else if (c.X < W && c.Y < H) okCHAR(hCon, c, '#', TEST_ATTRIB);
             else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
         }
     }

     /* clipping, src & dst rect don't overlap */
     resetContent(hCon, sbSize, TRUE);

     scroll.Left = 0;
     scroll.Right = W - 1;
     scroll.Top = 0;
     scroll.Bottom = H - 1;
     dst.X = W + 3;
     dst.Y = H + 3;
     ci.Char.UnicodeChar = '#';
     ci.Attributes = TEST_ATTRIB;

     clip.Left = W / 2;
     clip.Right = min(W + W / 2, sbSize.X - 1);
     clip.Top = H / 2;
     clip.Bottom = min(H + H / 2, sbSize.Y - 1);

     ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");

     for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
     {
         for (c.X = 0; c.X < sbSize.X; c.X++)
         {
             if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
             {
                 tc.X = c.X - dst.X;
                 tc.Y = c.Y - dst.Y;
                 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
             }
             else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
                 okCHAR(hCon, c, '#', TEST_ATTRIB);
             else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
         }
     }

     /* clipping, src & dst rect do overlap */
     resetContent(hCon, sbSize, TRUE);

     scroll.Left = 0;
     scroll.Right = W - 1;
     scroll.Top = 0;
     scroll.Bottom = H - 1;
     dst.X = W / 2 - 3;
     dst.Y = H / 2 - 3;
     ci.Char.UnicodeChar = '#';
     ci.Attributes = TEST_ATTRIB;

     clip.Left = W / 2;
     clip.Right = min(W + W / 2, sbSize.X - 1);
     clip.Top = H / 2;
     clip.Bottom = min(H + H / 2, sbSize.Y - 1);

     ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");

     for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
     {
         for (c.X = 0; c.X < sbSize.X; c.X++)
         {
             if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
             {
                 tc.X = c.X - dst.X;
                 tc.Y = c.Y - dst.Y;
                 okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
             }
             else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
                 okCHAR(hCon, c, '#', TEST_ATTRIB);
             else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
         }
     }
 }
 #endif

 START_TEST(console)
 {
     HANDLE hConIn, hConOut;
     BOOL ret;
     CONSOLE_SCREEN_BUFFER_INFO	sbi;

     /* be sure we have a clean console (and that's our own)
      * FIXME: this will make the test fail (currently) if we don't run
      * under X11
      * Another solution would be to rerun the test under wineconsole with
      * the curses backend
      */

     hConIn = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
     hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);

     /* first, we need to be sure we're attached to a console */
     if (hConIn == INVALID_HANDLE_VALUE || hConOut == INVALID_HANDLE_VALUE)
     {
         /* we're not attached to a console, let's do it */
         AllocConsole();
         hConIn = CreateFileA("CONIN$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
         hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
     }
     /* now verify everything's ok */
     ok(hConIn != INVALID_HANDLE_VALUE, "Opening ConIn\n");
     ok(hConOut != INVALID_HANDLE_VALUE, "Opening ConOut\n");

     ok(ret = GetConsoleScreenBufferInfo(hConOut, &sbi), "Getting sb info\n");
     if (!ret) return;

     /* Non interactive tests */
     testCursor(hConOut, sbi.dwSize);
     /* will test wrapped (on/off) & processed (on/off) strings output */
     testWrite(hConOut, sbi.dwSize);
     /* will test line scrolling at the bottom of the screen */
     /* testBottomScroll(); */
     /* will test all the scrolling operations */
     /* this one is disabled for now, Wine's result are way too bad */
     /* testScroll(hCon, sbi.dwSize); */
     /* will test sb creation / modification... */
     /* testScreenBuffer() */

     /* still to be done: events generation, access rights & access on objects */
 }
	/*
	* Unit tests for console API
	*
	* Copyright (c) 2003 Eric Pouech
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include "wine/test.h"
	#include <windows.h>
	#include <stdio.h>

	/* DEFAULT_ATTRIB is used for all initial filling of the console.
	* all modifications are made with TEST_ATTRIB so that we could check
	* what has to be modified or not
	*/
	#define TEST_ATTRIB (BACKGROUND_BLUE \| FOREGROUND_GREEN)
	#define DEFAULT_ATTRIB (FOREGROUND_GREEN \| FOREGROUND_BLUE \| FOREGROUND_RED)
	/* when filling the screen with non-blank chars, this macro defines
	* what character should be at position 'c'
	*/
	#define CONTENT(c) ('A' + (((c).Y * 17 + (c).X) % 23))

	#define okCURSOR(hCon, c) do { \
	CONSOLE_SCREEN_BUFFER_INFO __sbi; \
	BOOL expect = GetConsoleScreenBufferInfo((hCon), &__sbi) && \
	__sbi.dwCursorPosition.X == (c).X && __sbi.dwCursorPosition.Y == (c).Y; \
	ok(expect, "Expected cursor at (%d,%d), got (%d,%d)\n", \
	(c).X, (c).Y, __sbi.dwCursorPosition.X, __sbi.dwCursorPosition.Y); \
	} while (0)

	#define okCHAR(hCon, c, ch, attr) do { \
	char __ch; WORD __attr; DWORD __len; BOOL expect; \
	expect = ReadConsoleOutputCharacter((hCon), &__ch, 1, (c), &__len) == 1 && __len == 1 && __ch == (ch); \
	ok(expect, "At (%d,%d): expecting char '%c'/%02x got '%c'/%02x\n", (c).X, (c).Y, (ch), (ch), __ch, __ch); \
	expect = ReadConsoleOutputAttribute((hCon), &__attr, 1, (c), &__len) == 1 && __len == 1 && __attr == (attr); \
	ok(expect, "At (%d,%d): expecting attr %04x got %04x\n", (c).X, (c).Y, (attr), __attr); \
	} while (0)

	/* FIXME: this could be optimized on a speed point of view */
	static void resetContent(HANDLE hCon, COORD sbSize, BOOL content)
	{
	COORD c;
	WORD attr = DEFAULT_ATTRIB;
	char ch;
	DWORD len;

	for (c.X = 0; c.X < sbSize.X; c.X++)
	{
	for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
	{
	ch = (content) ? CONTENT(c) : ' ';
	WriteConsoleOutputAttribute(hCon, &attr, 1, c, &len);
	WriteConsoleOutputCharacterA(hCon, &ch, 1, c, &len);
	}
	}
	}

	static void testCursor(HANDLE hCon, COORD sbSize)
	{
	COORD c;

	c.X = c.Y = 0;
	ok(SetConsoleCursorPosition(0, c) == 0, "No handle\n");
	ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %u got %lu\n",
	ERROR_INVALID_HANDLE, GetLastError());

	c.X = c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");
	okCURSOR(hCon, c);

	c.X = sbSize.X - 1;
	c.Y = sbSize.Y - 1;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in lower-right\n");
	okCURSOR(hCon, c);

	c.X = sbSize.X;
	c.Y = sbSize.Y - 1;
	ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
	ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
	ERROR_INVALID_PARAMETER, GetLastError());

	c.X = sbSize.X - 1;
	c.Y = sbSize.Y;
	ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
	ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
	ERROR_INVALID_PARAMETER, GetLastError());

	c.X = -1;
	c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
	ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
	ERROR_INVALID_PARAMETER, GetLastError());

	c.X = 0;
	c.Y = -1;
	ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside\n");
	ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %u got %lu\n",
	ERROR_INVALID_PARAMETER, GetLastError());
	}

	static void testWriteSimple(HANDLE hCon, COORD sbSize)
	{
	COORD c;
	DWORD len;
	const char* mytest = "abcdefg";
	const int mylen = strlen(mytest);

	/* single line write */
	c.X = c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	c.Y = 0;
	for (c.X = 0; c.X < mylen; c.X++)
	{
	okCHAR(hCon, c, mytest[c.X], TEST_ATTRIB);
	}

	okCURSOR(hCon, c);
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
	}

	static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
	{
	COORD c;
	DWORD len, mode;
	char* mytest;
	int mylen;
	int ret;
	int p;

	ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT\|ENABLE_WRAP_AT_EOL_OUTPUT)),
	"clearing wrap at EOL & processed output\n");

	/* write line, wrapping disabled, buffer exceeds sb width */
	c.X = sbSize.X - 3; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

	mytest = "123";

	mylen = strlen(mytest);

	ret = WriteConsole(hCon, mytest, mylen, &len, NULL);
	ok(ret != 0 && len == mylen, "Couldn't write, ret = %d, len = %ld\n", ret, len);
	c.Y = 0;
	for (p = mylen - 3; p < mylen; p++)
	{
	c.X = sbSize.X - 3 + p % 3;
	okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
	}

	c.X = 0; c.Y = 1;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	p = sbSize.X - 3 + mylen % 3;
	c.X = p; c.Y = 0;

	/* write line, wrapping disabled, strings end on end of line */
	c.X = sbSize.X - mylen; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	}

	static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize)
	{
	COORD c;
	DWORD len, mode;
	const char* mytest = "abcd\nf\tg";
	const int mylen = strlen(mytest);
	const int mylen2 = strchr(mytest, '\n') - mytest;
	int p;

	ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, (mode \| ENABLE_PROCESSED_OUTPUT) & ~ENABLE_WRAP_AT_EOL_OUTPUT),
	"clearing wrap at EOL & setting processed output\n");

	/* write line, wrapping disabled, buffer exceeds sb width */
	c.X = sbSize.X - 5; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-5\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	c.Y = 0;
	for (c.X = sbSize.X - 5; c.X < sbSize.X - 1; c.X++)
	{
	okCHAR(hCon, c, mytest[c.X - sbSize.X + 5], TEST_ATTRIB);
	}
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	c.X = 0; c.Y++;
	okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
	for (c.X = 1; c.X < 8; c.X++)
	okCHAR(hCon, c, ' ', TEST_ATTRIB);
	okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
	c.X++;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	okCURSOR(hCon, c);

	/* write line, wrapping disabled, strings end on end of line */
	c.X = sbSize.X - 4; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	c.Y = 0;
	for (c.X = sbSize.X - 4; c.X < sbSize.X; c.X++)
	{
	okCHAR(hCon, c, mytest[c.X - sbSize.X + 4], TEST_ATTRIB);
	}
	c.X = 0; c.Y++;
	okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
	for (c.X = 1; c.X < 8; c.X++)
	okCHAR(hCon, c, ' ', TEST_ATTRIB);
	okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
	c.X++;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	okCURSOR(hCon, c);

	/* write line, wrapping disabled, strings end after end of line */
	c.X = sbSize.X - 3; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-4\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	c.Y = 0;
	for (p = mylen2 - 3; p < mylen2; p++)
	{
	c.X = sbSize.X - 3 + p % 3;
	okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
	}
	c.X = 0; c.Y = 1;
	okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
	for (c.X = 1; c.X < 8; c.X++)
	okCHAR(hCon, c, ' ', TEST_ATTRIB);
	okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
	c.X++;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	okCURSOR(hCon, c);
	}

	static void testWriteWrappedNotProcessed(HANDLE hCon, COORD sbSize)
	{
	COORD c;
	DWORD len, mode;
	const char* mytest = "abcd\nf\tg";
	const int mylen = strlen(mytest);
	int p;

	ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon,(mode \| ENABLE_WRAP_AT_EOL_OUTPUT) & ~(ENABLE_PROCESSED_OUTPUT)),
	"setting wrap at EOL & clearing processed output\n");

	/* write line, wrapping enabled, buffer doesn't exceed sb width */
	c.X = sbSize.X - 9; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	c.Y = 0;
	for (p = 0; p < mylen; p++)
	{
	c.X = sbSize.X - 9 + p;
	okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
	}
	c.X = sbSize.X - 9 + mylen;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
	c.X = 0; c.Y = 1;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	/* write line, wrapping enabled, buffer does exceed sb width */
	c.X = sbSize.X - 3; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

	c.Y = 1;
	c.X = mylen - 3;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
	}

	static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize)
	{
	COORD c;
	DWORD len, mode;
	const char* mytest = "abcd\nf\tg";
	const int mylen = strlen(mytest);
	int p;

	ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode \| (ENABLE_WRAP_AT_EOL_OUTPUT\|ENABLE_PROCESSED_OUTPUT)),
	"setting wrap at EOL & processed output\n");

	/* write line, wrapping enabled, buffer doesn't exceed sb width */
	c.X = sbSize.X - 9; c.Y = 0;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-9\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	for (p = 0; p < 4; p++)
	{
	c.X = sbSize.X - 9 + p;
	okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
	}
	c.X = sbSize.X - 9 + p;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
	c.X = 0; c.Y++;
	okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
	for (c.X = 1; c.X < 8; c.X++)
	okCHAR(hCon, c, ' ', TEST_ATTRIB);
	okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
	c.X++;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
	okCURSOR(hCon, c);

	/* write line, wrapping enabled, buffer does exceed sb width */
	c.X = sbSize.X - 3; c.Y = 2;
	ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");

	ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
	for (p = 0; p < 3; p++)
	{
	c.X = sbSize.X - 3 + p;
	okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
	}
	c.X = 0; c.Y++;
	okCHAR(hCon, c, mytest[3], TEST_ATTRIB);
	c.X++;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);

	c.X = 0; c.Y++;
	okCHAR(hCon, c, mytest[5], TEST_ATTRIB);
	for (c.X = 1; c.X < 8; c.X++)
	okCHAR(hCon, c, ' ', TEST_ATTRIB);
	okCHAR(hCon, c, mytest[7], TEST_ATTRIB);
	c.X++;
	okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
	okCURSOR(hCon, c);
	}

	static void testWrite(HANDLE hCon, COORD sbSize)
	{
	/* FIXME: should in fact insure that the sb is at least 10 character wide */
	ok(SetConsoleTextAttribute(hCon, TEST_ATTRIB), "Setting default text color\n");
	resetContent(hCon, sbSize, FALSE);
	testWriteSimple(hCon, sbSize);
	resetContent(hCon, sbSize, FALSE);
	testWriteNotWrappedNotProcessed(hCon, sbSize);
	resetContent(hCon, sbSize, FALSE);
	testWriteNotWrappedProcessed(hCon, sbSize);
	resetContent(hCon, sbSize, FALSE);
	testWriteWrappedNotProcessed(hCon, sbSize);
	resetContent(hCon, sbSize, FALSE);
	testWriteWrappedProcessed(hCon, sbSize);
	}

	#if 0
	static void testScroll(HANDLE hCon, COORD sbSize)
	{
	SMALL_RECT scroll, clip;
	COORD dst, c, tc;
	CHAR_INFO ci;

	#define W 11
	#define H 7

	/* no clipping, src & dst rect don't overlap */
	resetContent(hCon, sbSize, TRUE);

	#define IN_SRECT(r,c) ((r).Left <= (c).X && (c).X <= (r).Right && (r).Top <= (c).Y && (c).Y <= (r).Bottom)
	#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)

	scroll.Left = 0;
	scroll.Right = W - 1;
	scroll.Top = 0;
	scroll.Bottom = H - 1;
	dst.X = W + 3;
	dst.Y = H + 3;
	ci.Char.UnicodeChar = '#';
	ci.Attributes = TEST_ATTRIB;

	clip.Left = 0;
	clip.Right = sbSize.X - 1;
	clip.Top = 0;
	clip.Bottom = sbSize.Y - 1;

	ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");

	for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
	{
	for (c.X = 0; c.X < sbSize.X; c.X++)
	{
	if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
	{
	tc.X = c.X - dst.X;
	tc.Y = c.Y - dst.Y;
	okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
	}
	else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
	okCHAR(hCon, c, '#', TEST_ATTRIB);
	else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
	}
	}

	/* no clipping, src & dst rect do overlap */
	resetContent(hCon, sbSize, TRUE);

	scroll.Left = 0;
	scroll.Right = W - 1;
	scroll.Top = 0;
	scroll.Bottom = H - 1;
	dst.X = W /2;
	dst.Y = H / 2;
	ci.Char.UnicodeChar = '#';
	ci.Attributes = TEST_ATTRIB;

	clip.Left = 0;
	clip.Right = sbSize.X - 1;
	clip.Top = 0;
	clip.Bottom = sbSize.Y - 1;

	ok(ScrollConsoleScreenBuffer(hCon, &scroll, NULL, dst, &ci), "Scrolling SB\n");

	for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
	{
	for (c.X = 0; c.X < sbSize.X; c.X++)
	{
	if (dst.X <= c.X && c.X < dst.X + W && dst.Y <= c.Y && c.Y < dst.Y + H)
	{
	tc.X = c.X - dst.X;
	tc.Y = c.Y - dst.Y;
	okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
	}
	else if (c.X < W && c.Y < H) okCHAR(hCon, c, '#', TEST_ATTRIB);
	else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
	}
	}

	/* clipping, src & dst rect don't overlap */
	resetContent(hCon, sbSize, TRUE);

	scroll.Left = 0;
	scroll.Right = W - 1;
	scroll.Top = 0;
	scroll.Bottom = H - 1;
	dst.X = W + 3;
	dst.Y = H + 3;
	ci.Char.UnicodeChar = '#';
	ci.Attributes = TEST_ATTRIB;

	clip.Left = W / 2;
	clip.Right = min(W + W / 2, sbSize.X - 1);
	clip.Top = H / 2;
	clip.Bottom = min(H + H / 2, sbSize.Y - 1);

	ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");

	for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
	{
	for (c.X = 0; c.X < sbSize.X; c.X++)
	{
	if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
	{
	tc.X = c.X - dst.X;
	tc.Y = c.Y - dst.Y;
	okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
	}
	else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
	okCHAR(hCon, c, '#', TEST_ATTRIB);
	else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
	}
	}

	/* clipping, src & dst rect do overlap */
	resetContent(hCon, sbSize, TRUE);

	scroll.Left = 0;
	scroll.Right = W - 1;
	scroll.Top = 0;
	scroll.Bottom = H - 1;
	dst.X = W / 2 - 3;
	dst.Y = H / 2 - 3;
	ci.Char.UnicodeChar = '#';
	ci.Attributes = TEST_ATTRIB;

	clip.Left = W / 2;
	clip.Right = min(W + W / 2, sbSize.X - 1);
	clip.Top = H / 2;
	clip.Bottom = min(H + H / 2, sbSize.Y - 1);

	ok(ScrollConsoleScreenBuffer(hCon, &scroll, &clip, dst, &ci), "Scrolling SB\n");

	for (c.Y = 0; c.Y < sbSize.Y; c.Y++)
	{
	for (c.X = 0; c.X < sbSize.X; c.X++)
	{
	if (IN_SRECT2(scroll, dst, c) && IN_SRECT(clip, c))
	{
	tc.X = c.X - dst.X;
	tc.Y = c.Y - dst.Y;
	okCHAR(hCon, c, CONTENT(tc), DEFAULT_ATTRIB);
	}
	else if (IN_SRECT(scroll, c) && IN_SRECT(clip, c))
	okCHAR(hCon, c, '#', TEST_ATTRIB);
	else okCHAR(hCon, c, CONTENT(c), DEFAULT_ATTRIB);
	}
	}
	}
	#endif

	START_TEST(console)
	{
	HANDLE hConIn, hConOut;
	BOOL ret;
	CONSOLE_SCREEN_BUFFER_INFO sbi;

	/* be sure we have a clean console (and that's our own)
	* FIXME: this will make the test fail (currently) if we don't run
	* under X11
	* Another solution would be to rerun the test under wineconsole with
	* the curses backend
	*/

	hConIn = CreateFileA("CONIN$", GENERIC_READ\|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
	hConOut = CreateFileA("CONOUT$", GENERIC_READ\|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);

	/* first, we need to be sure we're attached to a console */
	if (hConIn == INVALID_HANDLE_VALUE \|\| hConOut == INVALID_HANDLE_VALUE)
	{
	/* we're not attached to a console, let's do it */
	AllocConsole();
	hConIn = CreateFileA("CONIN$", GENERIC_READ\|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
	hConOut = CreateFileA("CONOUT$", GENERIC_READ\|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
	}
	/* now verify everything's ok */
	ok(hConIn != INVALID_HANDLE_VALUE, "Opening ConIn\n");
	ok(hConOut != INVALID_HANDLE_VALUE, "Opening ConOut\n");

	ok(ret = GetConsoleScreenBufferInfo(hConOut, &sbi), "Getting sb info\n");
	if (!ret) return;

	/* Non interactive tests */
	testCursor(hConOut, sbi.dwSize);
	/* will test wrapped (on/off) & processed (on/off) strings output */
	testWrite(hConOut, sbi.dwSize);
	/* will test line scrolling at the bottom of the screen */
	/* testBottomScroll(); */
	/* will test all the scrolling operations */
	/* this one is disabled for now, Wine's result are way too bad */
	/* testScroll(hCon, sbi.dwSize); */
	/* will test sb creation / modification... */
	/* testScreenBuffer() */

	/* still to be done: events generation, access rights & access on objects */
	}