tests for console

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



a few tests for the console buffer operation
A+
--
Eric Pouech
Name:          krnl_tst_con
ChangeLog:     added a set of tests for console API
License:       X11
GenDate:       2003/05/08 18:58:59 UTC
ModifiedFiles: dlls/kernel/tests/Makefile.in
AddedFiles:    dlls/kernel/tests/console.c
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/kernel/tests/Makefile.in,v
retrieving revision 1.8
diff -u -u -r1.8 Makefile.in
--- dlls/kernel/tests/Makefile.in	4 Mar 2003 04:34:57 -0000	1.8
+++ dlls/kernel/tests/Makefile.in	15 Mar 2003 12:24:01 -0000
@@ -9,6 +9,7 @@
 	alloc.c \
 	atom.c \
 	codepage.c \
+	console.c \
 	directory.c \
 	drive.c \
 	environ.c \
@@ -16,6 +17,7 @@
 	format_msg.c \
 	generated.c \
 	locale.c \
+	module.c \
 	path.c \
 	pipe.c \
 	process.c \
--- /dev/null	1970-01-01 01:00:00.000000000 +0100
+++ dlls/kernel/tests/console.c	2003-05-02 20:43:21.000000000 +0200
@@ -0,0 +1,570 @@
+/*
+ * 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)", \
+     (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", (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", (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;
+    
+    ok(SetConsoleCursorPosition(0, c) == 0, "No handle");
+    ok(GetLastError() == ERROR_INVALID_HANDLE, "GetLastError: expecting %lu got %lu", 
+       ERROR_INVALID_HANDLE, GetLastError());
+    
+    c.X = c.Y = 0;
+    ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left");
+    okCURSOR(hCon, c);
+    
+    c.X = sbSize.X - 1;
+    c.Y = sbSize.Y - 1;
+    ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in lower-right");
+    okCURSOR(hCon, c);
+    
+    c.X = sbSize.X;
+    c.Y = sbSize.Y - 1;
+    ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside");
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %lu got %lu", 
+       ERROR_INVALID_PARAMETER, GetLastError());
+    
+    c.X = sbSize.X - 1;
+    c.Y = sbSize.Y;
+    ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside");
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %lu got %lu", 
+       ERROR_INVALID_PARAMETER, GetLastError());
+
+    c.X = -1;
+    c.Y = 0;
+    ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside");
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %lu got %lu", 
+       ERROR_INVALID_PARAMETER, GetLastError());
+
+    c.X = 0;
+    c.Y = -1;
+    ok(SetConsoleCursorPosition(hCon, c) == 0, "Cursor is outside");
+    ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetLastError: expecting %lu got %lu", 
+       ERROR_INVALID_PARAMETER, GetLastError());
+}
+
+static void testWriteSimple(HANDLE hCon, COORD sbSize)
+{
+    COORD		c;
+    DWORD		len;
+    const char*		mytest = "abcdefg";
+    const size_t	mylen = strlen(mytest);
+    
+    /* single line write */
+    c.X = c.Y = 0;
+    ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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;
+    const char*		mytest = "abcd\nf\tg";
+    const size_t	mylen = strlen(mytest);
+    int			p;
+    
+    ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT)), 
+       "clearing wrap at EOL & processed output");
+    
+    /* 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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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;
+    okCURSOR(hCon, c);
+    
+    /* 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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    c.Y = 0;
+    for (p = 0; p < mylen; p++)
+    {
+        c.X = sbSize.X - mylen + p;
+        okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
+    }
+    
+    c.X = 0; c.Y = 1;
+    okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
+    
+    p = sbSize.X - mylen;
+    c.X = p; c.Y = 0;
+    okCURSOR(hCon, c);
+}
+
+static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize)
+{
+    COORD		c;
+    DWORD		len, mode;
+    const char*		mytest = "abcd\nf\tg";
+    const size_t	mylen = strlen(mytest);
+    const size_t	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");
+    
+    /* 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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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 size_t	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");
+    
+    /* 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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    c.Y = 0;
+    for (p = 0; p < 3; p++)
+    {
+        c.X = sbSize.X - 3 + p;
+        okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
+    }
+    
+    c.Y = 1;
+    for (p = 0; p < mylen - 3; p++)
+    {
+        c.X = p;
+        okCHAR(hCon, c, mytest[p + 3], TEST_ATTRIB);
+    }
+    c.X = mylen - 3;
+    okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
+    
+    okCURSOR(hCon, c);
+}
+
+static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize)
+{
+    COORD		c;
+    DWORD		len, mode;
+    const char*		mytest = "abcd\nf\tg";
+    const size_t	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");
+    
+    /* 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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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");
+    
+    ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole");
+    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");
+    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");
+
+    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");
+
+    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");
+
+    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");
+
+    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 hCon;
+    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
+     */
+    FreeConsole();
+    AllocConsole();
+    hCon = GetStdHandle(STD_OUTPUT_HANDLE);
+    ok(ret = GetConsoleScreenBufferInfo(hCon, &sbi), "Getting sb info");
+    if (!ret) return;
+
+    /* Non interactive tests */
+    testCursor(hCon, sbi.dwSize);
+    /* will test wrapped (on/off) & processed (on/off) strings output */
+    testWrite(hCon, 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 */
+}

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux