1 /*
2 * Unit test suite for pathiterator
3 *
4 * Copyright (C) 2008 Nikolay Sivov
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "windows.h"
22 #include "gdiplus.h"
23 #include "wine/test.h"
24
25 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
26
27 static void test_constructor_destructor(void)
28 {
29 GpPath *path;
30 GpPathIterator *iter;
31 GpStatus stat;
32
33 GdipCreatePath(FillModeAlternate, &path);
34 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
35
36 /* NULL args */
37 stat = GdipCreatePathIter(NULL, NULL);
38 expect(InvalidParameter, stat);
39 stat = GdipCreatePathIter(&iter, NULL);
40 expect(Ok, stat);
41 stat = GdipCreatePathIter(NULL, path);
42 expect(InvalidParameter, stat);
43 stat = GdipDeletePathIter(NULL);
44 expect(InvalidParameter, stat);
45
46 /* valid args */
47 stat = GdipCreatePathIter(&iter, path);
48 expect(Ok, stat);
49
50 GdipDeletePathIter(iter);
51 GdipDeletePath(path);
52 }
53
54 static void test_hascurve(void)
55 {
56 GpPath *path;
57 GpPathIterator *iter;
58 GpStatus stat;
59 BOOL hasCurve;
60
61 GdipCreatePath(FillModeAlternate, &path);
62 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
63
64 stat = GdipCreatePathIter(&iter, path);
65 expect(Ok, stat);
66
67 /* NULL args
68 BOOL out argument is local in wrapper class method,
69 so it always has not-NULL address */
70 stat = GdipPathIterHasCurve(NULL, &hasCurve);
71 expect(InvalidParameter, stat);
72
73 /* valid args */
74 stat = GdipPathIterHasCurve(iter, &hasCurve);
75 expect(Ok, stat);
76 expect(FALSE, hasCurve);
77
78 GdipDeletePathIter(iter);
79
80 GdipAddPathEllipse(path, 0.0, 0.0, 35.0, 70.0);
81
82 stat = GdipCreatePathIter(&iter, path);
83 expect(Ok, stat);
84
85 stat = GdipPathIterHasCurve(iter, &hasCurve);
86 expect(Ok, stat);
87 expect(TRUE, hasCurve);
88
89 GdipDeletePathIter(iter);
90 GdipDeletePath(path);
91 }
92
93 static void test_nextmarker(void)
94 {
95 GpPath *path;
96 GpPathIterator *iter;
97 GpStatus stat;
98 INT start, end;
99 INT result;
100
101 /* NULL args
102 BOOL out argument is local in wrapper class method,
103 so it always has not-NULL address */
104 stat = GdipPathIterNextMarker(NULL, &result, NULL, NULL);
105 expect(InvalidParameter, stat);
106 stat = GdipPathIterNextMarker(NULL, &result, &start, NULL);
107 expect(InvalidParameter, stat);
108 stat = GdipPathIterNextMarker(NULL, &result, NULL, &end);
109 expect(InvalidParameter, stat);
110
111 GdipCreatePath(FillModeAlternate, &path);
112 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
113
114 /* no markers */
115 GdipCreatePathIter(&iter, path);
116 start = end = result = (INT)0xdeadbeef;
117 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
118 expect(Ok, stat);
119 expect(0, start);
120 expect(3, end);
121 expect(4, result);
122 start = end = result = (INT)0xdeadbeef;
123 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
124 /* start/end remain unchanged */
125 expect((INT)0xdeadbeef, start);
126 expect((INT)0xdeadbeef, end);
127 expect(0, result);
128 GdipDeletePathIter(iter);
129
130 /* one marker */
131 GdipSetPathMarker(path);
132 GdipCreatePathIter(&iter, path);
133 start = end = result = (INT)0xdeadbeef;
134 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
135 expect(Ok, stat);
136 expect(0, start);
137 expect(3, end);
138 expect(4, result);
139 start = end = result = (INT)0xdeadbeef;
140 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
141 expect(Ok, stat);
142 expect((INT)0xdeadbeef, start);
143 expect((INT)0xdeadbeef, end);
144 expect(0, result);
145 GdipDeletePathIter(iter);
146
147 /* two markers */
148 GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
149 GdipSetPathMarker(path);
150 GdipCreatePathIter(&iter, path);
151 start = end = result = (INT)0xdeadbeef;
152 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
153 expect(Ok, stat);
154 expect(0, start);
155 expect(3, end);
156 expect(4, result);
157 start = end = result = (INT)0xdeadbeef;
158 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
159 expect(Ok, stat);
160 expect(4, start);
161 expect(5, end);
162 expect(2, result);
163 start = end = result = (INT)0xdeadbeef;
164 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
165 expect(Ok, stat);
166 expect((INT)0xdeadbeef, start);
167 expect((INT)0xdeadbeef, end);
168 expect(0, result);
169 GdipDeletePathIter(iter);
170
171 GdipDeletePath(path);
172 }
173
174 static void test_nextmarkerpath(void)
175 {
176 GpPath *path, *retpath;
177 GpPathIterator *iter;
178 GpStatus stat;
179 INT result, count;
180
181 GdipCreatePath(FillModeAlternate, &path);
182
183 /* NULL */
184 stat = GdipPathIterNextMarkerPath(NULL, NULL, NULL);
185 expect(InvalidParameter, stat);
186 stat = GdipPathIterNextMarkerPath(NULL, &result, NULL);
187 expect(InvalidParameter, stat);
188 stat = GdipPathIterNextMarkerPath(NULL, &result, path);
189 expect(InvalidParameter, stat);
190
191 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
192
193 /* no markers */
194 GdipCreatePath(FillModeAlternate, &retpath);
195 GdipCreatePathIter(&iter, path);
196 result = -1;
197 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
198 expect(Ok, stat);
199 expect(4, result);
200 count = -1;
201 GdipGetPointCount(retpath, &count);
202 expect(4, count);
203 result = -1;
204 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
205 expect(Ok, stat);
206 expect(0, result);
207 count = -1;
208 GdipGetPointCount(retpath, &count);
209 expect(4, count);
210 GdipDeletePathIter(iter);
211 GdipDeletePath(retpath);
212
213 /* one marker */
214 GdipSetPathMarker(path);
215 GdipCreatePath(FillModeAlternate, &retpath);
216 GdipCreatePathIter(&iter, path);
217 result = -1;
218 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
219 expect(Ok, stat);
220 expect(4, result);
221 count = -1;
222 GdipGetPointCount(retpath, &count);
223 expect(4, count);
224 result = -1;
225 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
226 expect(Ok, stat);
227 expect(0, result);
228 count = -1;
229 GdipGetPointCount(retpath, &count);
230 expect(4, count);
231 GdipDeletePathIter(iter);
232 GdipDeletePath(retpath);
233
234 /* two markers */
235 GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
236 GdipSetPathMarker(path);
237 GdipCreatePath(FillModeAlternate, &retpath);
238 GdipCreatePathIter(&iter, path);
239 result = -1;
240 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
241 expect(Ok, stat);
242 expect(4, result);
243 result = -1;
244 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
245 expect(Ok, stat);
246 expect(2, result);
247 result = -1;
248 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
249 expect(Ok, stat);
250 expect(0, result);
251 GdipDeletePathIter(iter);
252 GdipDeletePath(retpath);
253
254 GdipDeletePath(path);
255 }
256
257 static void test_getsubpathcount(void)
258 {
259 GpPath *path;
260 GpPathIterator *iter;
261 GpStatus stat;
262 INT count;
263
264 /* NULL args */
265 stat = GdipPathIterGetSubpathCount(NULL, NULL);
266 expect(InvalidParameter, stat);
267 stat = GdipPathIterGetSubpathCount(NULL, &count);
268 expect(InvalidParameter, stat);
269
270 GdipCreatePath(FillModeAlternate, &path);
271
272 /* empty path */
273 GdipCreatePathIter(&iter, path);
274 stat = GdipPathIterGetSubpathCount(iter, &count);
275 expect(Ok, stat);
276 expect(0, count);
277 GdipDeletePathIter(iter);
278
279 GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
280
281 /* open figure */
282 GdipCreatePathIter(&iter, path);
283 stat = GdipPathIterGetSubpathCount(iter, &count);
284 expect(Ok, stat);
285 expect(1, count);
286 GdipDeletePathIter(iter);
287
288 /* manually start new figure */
289 GdipStartPathFigure(path);
290 GdipAddPathLine(path, 50.0, 50.0, 110.0, 40.0);
291 GdipCreatePathIter(&iter, path);
292 stat = GdipPathIterGetSubpathCount(iter, &count);
293 expect(Ok, stat);
294 expect(2, count);
295 GdipDeletePathIter(iter);
296
297 GdipDeletePath(path);
298 }
299
300 static void test_isvalid(void)
301 {
302 GpPath *path;
303 GpPathIterator *iter;
304 GpStatus stat;
305 BOOL isvalid;
306 INT start, end, result;
307
308 GdipCreatePath(FillModeAlternate, &path);
309
310 /* NULL args */
311 GdipCreatePathIter(&iter, path);
312 stat = GdipPathIterIsValid(NULL, NULL);
313 expect(InvalidParameter, stat);
314 stat = GdipPathIterIsValid(iter, NULL);
315 expect(InvalidParameter, stat);
316 stat = GdipPathIterIsValid(NULL, &isvalid);
317 expect(InvalidParameter, stat);
318 GdipDeletePathIter(iter);
319
320 /* on empty path */
321 GdipCreatePathIter(&iter, path);
322 isvalid = FALSE;
323 stat = GdipPathIterIsValid(iter, &isvalid);
324 expect(Ok, stat);
325 expect(TRUE, isvalid);
326 GdipDeletePathIter(iter);
327
328 /* no markers */
329 GdipAddPathLine(path, 50.0, 50.0, 110.0, 40.0);
330 GdipCreatePathIter(&iter, path);
331 GdipPathIterNextMarker(iter, &result, &start, &end);
332 isvalid = FALSE;
333 stat = GdipPathIterIsValid(iter, &isvalid);
334 expect(Ok, stat);
335 expect(TRUE, isvalid);
336 GdipDeletePathIter(iter);
337
338 GdipDeletePath(path);
339 }
340
341 static void test_nextsubpathpath(void)
342 {
343 GpPath *path, *retpath;
344 GpPathIterator *iter;
345 GpStatus stat;
346 BOOL closed;
347 INT count, result;
348
349 GdipCreatePath(FillModeAlternate, &path);
350
351 /* NULL args */
352 GdipCreatePath(FillModeAlternate, &retpath);
353 GdipCreatePathIter(&iter, path);
354 stat = GdipPathIterNextSubpathPath(NULL, NULL, NULL, NULL);
355 expect(InvalidParameter, stat);
356 stat = GdipPathIterNextSubpathPath(iter, NULL, NULL, NULL);
357 expect(InvalidParameter, stat);
358 stat = GdipPathIterNextSubpathPath(NULL, &result, NULL, NULL);
359 expect(InvalidParameter, stat);
360 stat = GdipPathIterNextSubpathPath(iter, &result, NULL, &closed);
361 expect(Ok, stat);
362 stat = GdipPathIterNextSubpathPath(iter, NULL, NULL, &closed);
363 expect(InvalidParameter, stat);
364 stat = GdipPathIterNextSubpathPath(iter, NULL, retpath, NULL);
365 expect(InvalidParameter, stat);
366 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, NULL);
367 expect(InvalidParameter, stat);
368 GdipDeletePathIter(iter);
369 GdipDeletePath(retpath);
370
371 /* empty path */
372 GdipCreatePath(FillModeAlternate, &retpath);
373 GdipCreatePathIter(&iter, path);
374 result = -2;
375 closed = TRUE;
376 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
377 expect(Ok, stat);
378 expect(0, result);
379 expect(TRUE, closed);
380 count = -1;
381 GdipGetPointCount(retpath, &count);
382 expect(0, count);
383 GdipDeletePathIter(iter);
384 GdipDeletePath(retpath);
385
386 /* open figure */
387 GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
388
389 GdipCreatePath(FillModeAlternate, &retpath);
390 GdipCreatePathIter(&iter, path);
391 result = -2;
392 closed = TRUE;
393 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
394 expect(Ok, stat);
395 expect(2, result);
396 expect(FALSE, closed);
397 count = -1;
398 GdipGetPointCount(retpath, &count);
399 expect(2, count);
400 /* subsequent call */
401 result = -2;
402 closed = TRUE;
403 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
404 expect(Ok, stat);
405 expect(0, result);
406 expect(TRUE, closed);
407 count = -1;
408 GdipGetPointCount(retpath, &count);
409 expect(2, count);
410 GdipDeletePathIter(iter);
411
412 /* closed figure, check does it extend retpath or reset it */
413 GdipAddPathLine(retpath, 50.0, 55.0, 200.0, 150.0);
414
415 GdipClosePathFigure(path);
416 GdipAddPathLine(path, 50.0, 55.0, 200.0, 150.0);
417 GdipClosePathFigure(path);
418
419 GdipCreatePathIter(&iter, path);
420 result = -2;
421 closed = FALSE;
422 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
423 expect(Ok, stat);
424 expect(2, result);
425 expect(TRUE, closed);
426 count = -1;
427 GdipGetPointCount(retpath, &count);
428 expect(2, count);
429 /* subsequent call */
430 result = -2;
431 closed = FALSE;
432 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
433 expect(Ok, stat);
434 expect(2, result);
435 expect(TRUE, closed);
436 count = -1;
437 GdipGetPointCount(retpath, &count);
438 expect(2, count);
439 result = -2;
440 closed = FALSE;
441 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
442 expect(Ok, stat);
443 expect(0, result);
444 expect(TRUE, closed);
445 count = -1;
446 GdipGetPointCount(retpath, &count);
447 expect(2, count);
448 GdipDeletePathIter(iter);
449
450 GdipDeletePath(retpath);
451 GdipDeletePath(path);
452 }
453
454 static void test_nextsubpath(void)
455 {
456 GpPath *path;
457 GpPathIterator *iter;
458 GpStatus stat;
459 INT start, end, result;
460 BOOL closed;
461
462 GdipCreatePath(FillModeAlternate, &path);
463
464 /* empty path */
465 GdipCreatePath(FillModeAlternate, &path);
466 GdipCreatePathIter(&iter, path);
467
468 result = -2;
469 closed = TRUE;
470 stat = GdipPathIterNextSubpath(iter, &result, &start, &end, &closed);
471 expect(Ok, stat);
472 expect(0, result);
473 expect(TRUE, closed);
474 GdipCreatePathIter(&iter, path);
475
476 GdipDeletePath(path);
477 }
478
479 START_TEST(pathiterator)
480 {
481 struct GdiplusStartupInput gdiplusStartupInput;
482 ULONG_PTR gdiplusToken;
483
484 gdiplusStartupInput.GdiplusVersion = 1;
485 gdiplusStartupInput.DebugEventCallback = NULL;
486 gdiplusStartupInput.SuppressBackgroundThread = 0;
487 gdiplusStartupInput.SuppressExternalCodecs = 0;
488
489 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
490
491 test_constructor_destructor();
492 test_hascurve();
493 test_nextmarker();
494 test_nextmarkerpath();
495 test_getsubpathcount();
496 test_isvalid();
497 test_nextsubpathpath();
498 test_nextsubpath();
499
500 GdiplusShutdown(gdiplusToken);
501 }
502
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.