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