git.oblomov.eu Git - wine/blob - dlls/gdi32/tests/path.c

   1 /*
   2  * Unit test suite for paths
   3  *
   4  * Copyright 2007 Laurent Vromman
   5  * Copyright 2007 Misha Koshelev
   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 <stdarg.h>
  23 #include <stdio.h>
  24 #include <assert.h>
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28
  29 #include "wine/test.h"
  30
  31 #include "winuser.h"
  32 #include "winerror.h"
  33
  34 static void test_widenpath(void)
  35 {
  36     HDC hdc = GetDC(0);
  37     HPEN greenPen, narrowPen;
  38     HPEN oldPen;
  39     POINT pnt[6];
  40     INT nSize, ret;
  41     DWORD error;
  42
  43     /* Create a pen to be used in WidenPath */
  44     greenPen = CreatePen(PS_SOLID, 10, RGB(0,0,0));
  45     oldPen = SelectObject(hdc, greenPen);
  46
  47     /* Prepare a path */
  48     pnt[0].x = 100;
  49     pnt[0].y = 0;
  50     pnt[1].x = 200;
  51     pnt[1].y = 0;
  52     pnt[2].x = 300;
  53     pnt[2].y = 100;
  54     pnt[3].x = 300;
  55     pnt[3].y = 200;
  56     pnt[4].x = 200;
  57     pnt[4].y = 300;
  58     pnt[5].x = 100;
  59     pnt[5].y = 300;
  60
  61     /* Set a polyline path */
  62     BeginPath(hdc);
  63     Polyline(hdc, pnt, 6);
  64     EndPath(hdc);
  65
  66     /* Widen the polyline path */
  67     ok(WidenPath(hdc), "WidenPath fails while widening a poyline path.\n");
  68
  69     /* Test if WidenPath seems to have done his job */
  70     nSize = GetPath(hdc, NULL, NULL, 0);
  71     ok(nSize != -1, "GetPath fails after calling WidenPath.\n");
  72     ok(nSize > 6, "Path number of points is to low. Should be more than 6 but is %d\n", nSize);
  73
  74     AbortPath(hdc);
  75
  76     /* Test WidenPath with an open path */
  77     SetLastError(0xdeadbeef);
  78     BeginPath(hdc);
  79     ret = WidenPath(hdc);
  80     error = GetLastError();
  81     ok(ret == FALSE && GetLastError() == ERROR_CAN_NOT_COMPLETE, "WidenPath fails while widening an open path. Return value is %d, should be %d. Error is %08x, should be %08x\n", ret, FALSE, GetLastError(), ERROR_CAN_NOT_COMPLETE);
  82
  83     AbortPath(hdc);
  84
  85     /* Test when the pen width is equal to 1. The path should not change */
  86     narrowPen = CreatePen(PS_SOLID, 1, RGB(0,0,0));
  87     oldPen = SelectObject(hdc, narrowPen);
  88     BeginPath(hdc);
  89     Polyline(hdc, pnt, 6);
  90     EndPath(hdc);
  91     nSize = GetPath(hdc, NULL, NULL, 0);
  92     ok(nSize == 6, "WidenPath fails detecting 1px wide pen. Path length is %d, should be 6\n", nSize);
  93
  94     ReleaseDC(0, hdc);
  95     return;
  96 }
  97
  98 /*
  99  * Tests for GDI drawing functions in paths
 100  */
 101
 102 typedef struct
 103 {
 104     int x, y;
 105     BYTE type;
 106
 107     /* How many extra entries before this one only on wine
 108      * but not on native? */
 109     int wine_only_entries_preceding;
 110
 111     /* 0 - This entry matches on wine.
 112      * 1 - This entry corresponds to a single entry on wine that does not match the native entry.
 113      * 2 - This entry is currently skipped on wine but present on native. */
 114     int todo;
 115 } path_test_t;
 116
 117 /* Helper function to verify that the current path in the given DC matches the expected path.
 118  *
 119  * We use a "smart" matching algorithm that allows us to detect partial improvements
 120  * in conformance. Specifically, two running indices are kept, one through the actual
 121  * path and one through the expected path. The actual path index increases unless there is
 122  * no match and the todo field of the appropriate path_test_t element is 2. Similarly,
 123  * if the wine_entries_preceding field of the appropriate path_test_t element is non-zero,
 124  * the expected path index does not increase for that many elements as long as there
 125  * is no match. This allows us to todo_wine extra path elements that are present only
 126  * on wine but not on native and vice versa.
 127  *
 128  * Note that if expected_size is zero and the WINETEST_DEBUG environment variable is
 129  * greater than 2, the trace() output is a C path_test_t array structure, useful for making
 130  * new tests that use this function.
 131  */
 132 static void ok_path(HDC hdc, const char *path_name, const path_test_t *expected, int expected_size, BOOL todo_size)
 133 {
 134     static const char *type_string[8] = { "Unknown (0)", "PT_CLOSEFIGURE", "PT_LINETO",
 135                                           "PT_LINETO | PT_CLOSEFIGURE", "PT_BEZIERTO",
 136                                           "PT_BEZIERTO | PT_CLOSEFIGURE", "PT_MOVETO", "PT_MOVETO | PT_CLOSEFIGURE"};
 137     POINT *pnt = NULL;
 138     BYTE *types = NULL;
 139     int size, numskip,
 140         idx = 0, eidx = 0;
 141
 142     /* Get the path */
 143     assert(hdc != 0);
 144     size = GetPath(hdc, NULL, NULL, 0);
 145     ok(size > 0, "GetPath returned size %d, last error %d\n", size, GetLastError());
 146     if (size <= 0)
 147     {
 148         skip("Cannot perform path comparisons due to failure to retrieve path.\n");
 149         return;
 150     }
 151     pnt = HeapAlloc(GetProcessHeap(), 0, size*sizeof(POINT));
 152     assert(pnt != 0);
 153     types = HeapAlloc(GetProcessHeap(), 0, size*sizeof(BYTE));
 154     assert(types != 0);
 155     size = GetPath(hdc, pnt, types, size);
 156     assert(size > 0);
 157
 158     if (todo_size) todo_wine
 159         ok(size == expected_size, "Path size %d does not match expected size %d\n", size, expected_size);
 160     else
 161         ok(size == expected_size, "Path size %d does not match expected size %d\n", size, expected_size);
 162
 163     if (winetest_debug > 2)
 164         trace("static const path_test_t %s[] = {\n", path_name);
 165
 166     numskip = expected_size ? expected[eidx].wine_only_entries_preceding : 0;
 167     while (idx < size && eidx < expected_size)
 168     {
 169         /* We allow a few pixels fudge in matching X and Y coordinates to account for imprecision in
 170          * floating point to integer conversion */
 171         BOOL match = (types[idx] == expected[eidx].type) &&
 172             (pnt[idx].x >= expected[eidx].x-2 && pnt[idx].x <= expected[eidx].x+2) &&
 173             (pnt[idx].y >= expected[eidx].y-2 && pnt[idx].y <= expected[eidx].y+2);
 174
 175         if (expected[eidx].todo || numskip) todo_wine
 176             ok(match, "Expected #%d: %s (%d,%d) but got %s (%d,%d)\n", eidx,
 177                type_string[expected[eidx].type], expected[eidx].x, expected[eidx].y,
 178                type_string[types[idx]], pnt[idx].x, pnt[idx].y);
 179         else
 180             ok(match, "Expected #%d: %s (%d,%d) but got %s (%d,%d)\n", eidx,
 181                type_string[expected[eidx].type], expected[eidx].x, expected[eidx].y,
 182                type_string[types[idx]], pnt[idx].x, pnt[idx].y);
 183
 184         if (match || expected[eidx].todo != 2)
 185         {
 186             if (winetest_debug > 2)
 187                 trace("    {%d, %d, %s, 0, 0}%s /* %d */\n", pnt[idx].x, pnt[idx].y,
 188                       type_string[types[idx]], idx < size-1 ? "," : "};", idx);
 189             idx++;
 190         }
 191         if (match || !numskip--)
 192             numskip = expected[++eidx].wine_only_entries_preceding;
 193     }
 194
 195     /* If we are debugging and the actual path is longer than the expected path, make
 196      * sure to display the entire path */
 197     if (winetest_debug > 2 && idx < size)
 198         for (; idx < size; idx++)
 199             trace("    {%d, %d, %s, 0, 0}%s /* %d */\n", pnt[idx].x, pnt[idx].y,
 200                   type_string[types[idx]], idx < size-1 ? "," : "};", idx);
 201
 202     HeapFree(GetProcessHeap(), 0, types);
 203     HeapFree(GetProcessHeap(), 0, pnt);
 204 }
 205
 206 static const path_test_t arcto_path[] = {
 207     {0, 0, PT_MOVETO, 0, 0}, /* 0 */
 208     {229, 215, PT_LINETO, 0, 0}, /* 1 */
 209     {248, 205, PT_BEZIERTO, 0, 0}, /* 2 */
 210     {273, 200, PT_BEZIERTO, 0, 0}, /* 3 */
 211     {300, 200, PT_BEZIERTO, 0, 0}, /* 4 */
 212     {355, 200, PT_BEZIERTO, 0, 0}, /* 5 */
 213     {399, 222, PT_BEZIERTO, 0, 0}, /* 6 */
 214     {399, 250, PT_BEZIERTO, 0, 0}, /* 7 */
 215     {399, 263, PT_BEZIERTO, 0, 0}, /* 8 */
 216     {389, 275, PT_BEZIERTO, 0, 0}, /* 9 */
 217     {370, 285, PT_BEZIERTO, 0, 0}, /* 10 */
 218     {363, 277, PT_LINETO, 0, 0}, /* 11 */
 219     {380, 270, PT_BEZIERTO, 0, 0}, /* 12 */
 220     {389, 260, PT_BEZIERTO, 0, 0}, /* 13 */
 221     {389, 250, PT_BEZIERTO, 0, 0}, /* 14 */
 222     {389, 228, PT_BEZIERTO, 0, 0}, /* 15 */
 223     {349, 210, PT_BEZIERTO, 0, 0}, /* 16 */
 224     {300, 210, PT_BEZIERTO, 0, 0}, /* 17 */
 225     {276, 210, PT_BEZIERTO, 0, 0}, /* 18 */
 226     {253, 214, PT_BEZIERTO, 0, 0}, /* 19 */
 227     {236, 222, PT_BEZIERTO | PT_CLOSEFIGURE, 0, 0}}; /* 20 */
 228
 229 static void test_arcto(void)
 230 {
 231     HDC hdc = GetDC(0);
 232
 233     BeginPath(hdc);
 234     SetArcDirection(hdc, AD_CLOCKWISE);
 235     if (!ArcTo(hdc, 200, 200, 400, 300, 200, 200, 400, 300) &&
 236         GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 237     {
 238         /* ArcTo is only available on Win2k and later */
 239         skip("ArcTo is not available\n");
 240         goto done;
 241     }
 242     SetArcDirection(hdc, AD_COUNTERCLOCKWISE);
 243     ArcTo(hdc, 210, 210, 390, 290, 390, 290, 210, 210);
 244     CloseFigure(hdc);
 245     EndPath(hdc);
 246
 247     ok_path(hdc, "arcto_path", arcto_path, sizeof(arcto_path)/sizeof(path_test_t), 0);
 248 done:
 249     ReleaseDC(0, hdc);
 250 }
 251
 252 static const path_test_t anglearc_path[] = {
 253     {0, 0, PT_MOVETO, 0, 0}, /* 0 */
 254     {371, 229, PT_LINETO, 0, 0}, /* 1 */
 255     {352, 211, PT_BEZIERTO, 1, 0}, /* 2 */
 256     {327, 200, PT_BEZIERTO, 0, 0}, /* 3 */
 257     {300, 200, PT_BEZIERTO, 0, 0}, /* 4 */
 258     {245, 200, PT_BEZIERTO, 0, 0}, /* 5 */
 259     {200, 245, PT_BEZIERTO, 0, 0}, /* 6 */
 260     {200, 300, PT_BEZIERTO, 0, 0}, /* 7 */
 261     {200, 300, PT_BEZIERTO, 0, 2}, /* 8 */
 262     {200, 300, PT_BEZIERTO, 0, 2}, /* 9 */
 263     {200, 300, PT_BEZIERTO, 0, 2}, /* 10 */
 264     {231, 260, PT_LINETO, 1, 0}, /* 11 */
 265     {245, 235, PT_BEZIERTO, 1, 1}, /* 12 */
 266     {271, 220, PT_BEZIERTO, 0, 1}, /* 13 */
 267     {300, 220, PT_BEZIERTO, 0, 1}, /* 14 */
 268     {344, 220, PT_BEZIERTO, 0, 1}, /* 15 */
 269     {380, 256, PT_BEZIERTO, 0, 1}, /* 16 */
 270     {380, 300, PT_BEZIERTO, 0, 1}, /* 17 */
 271     {380, 314, PT_BEZIERTO, 0, 1}, /* 18 */
 272     {376, 328, PT_BEZIERTO, 0, 1}, /* 19 */
 273     {369, 340, PT_BEZIERTO | PT_CLOSEFIGURE, 0, 1}}; /* 20 */
 274
 275 static void test_anglearc(void)
 276 {
 277     HDC hdc = GetDC(0);
 278     BeginPath(hdc);
 279     if (!AngleArc(hdc, 300, 300, 100, 45.0, 135.0) &&
 280         GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 281     {
 282         /* AngleArc is only available on Win2k and later */
 283         skip("AngleArc is not available\n");
 284         goto done;
 285     }
 286     AngleArc(hdc, 300, 300, 80, 150.0, -180.0);
 287     CloseFigure(hdc);
 288     EndPath(hdc);
 289
 290     ok_path(hdc, "anglearc_path", anglearc_path, sizeof(anglearc_path)/sizeof(path_test_t), 0);
 291 done:
 292     ReleaseDC(0, hdc);
 293 }
 294
 295 START_TEST(path)
 296 {
 297     test_widenpath();
 298     test_arcto();
 299     test_anglearc();
 300 }