ReactOS 0.4.16-dev-13-ge2fc578
Macros | Functions
pathiterator.c File Reference
#include "objbase.h"
#include "gdiplus.h"
#include "wine/test.h"
Include dependency graph for pathiterator.c:

Go to the source code of this file.

Macros

#define expect(expected, got)   ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
 

Functions

static void test_constructor_destructor (void)
 
static void test_hascurve (void)
 
static void test_nextmarker (void)
 
static void test_nextmarkerpath (void)
 
static void test_getsubpathcount (void)
 
static void test_isvalid (void)
 
static void test_nextsubpathpath (void)
 
static void test_nextsubpath (void)
 
static void test_nextpathtype (void)
 
 START_TEST (pathiterator)
 

Macro Definition Documentation

◆ expect

#define expect (   expected,
  got 
)    ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)

Definition at line 25 of file pathiterator.c.

Function Documentation

◆ START_TEST()

START_TEST ( pathiterator  )

Definition at line 563 of file pathiterator.c.

564{
565 struct GdiplusStartupInput gdiplusStartupInput;
566 ULONG_PTR gdiplusToken;
567 HMODULE hmsvcrt;
568 int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
569
570 /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
571 hmsvcrt = LoadLibraryA("msvcrt");
572 _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
573 if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
574
575 gdiplusStartupInput.GdiplusVersion = 1;
576 gdiplusStartupInput.DebugEventCallback = NULL;
577 gdiplusStartupInput.SuppressBackgroundThread = 0;
578 gdiplusStartupInput.SuppressExternalCodecs = 0;
579
580 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
581
582 test_constructor_destructor();
583 test_hascurve();
584 test_nextmarker();
585 test_nextmarkerpath();
586 test_getsubpathcount();
587 test_isvalid();
588 test_nextsubpathpath();
589 test_nextsubpath();
590 test_nextpathtype();
591
592 GdiplusShutdown(gdiplusToken);
593}
_controlfp_s
int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
Definition: _controlfp_s.c:19
NULL
#define NULL
Definition: types.h:112
CDECL
#define CDECL
Definition: compat.h:29
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
cur
FxCollectionEntry * cur
Definition: fxresourceapi.cpp:412
GdiplusStartup
Status WINAPI GdiplusStartup(ULONG_PTR *token, const struct GdiplusStartupInput *input, struct GdiplusStartupOutput *output)
Definition: gdiplus.c:81
GdiplusShutdown
void WINAPI GdiplusShutdown(ULONG_PTR)
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
test_nextsubpathpath
static void test_nextsubpathpath(void)
Definition: pathiterator.c:349
test_nextmarkerpath
static void test_nextmarkerpath(void)
Definition: pathiterator.c:179
test_nextsubpath
static void test_nextsubpath(void)
Definition: pathiterator.c:462
test_nextmarker
static void test_nextmarker(void)
Definition: pathiterator.c:97
test_hascurve
static void test_hascurve(void)
Definition: pathiterator.c:57
test_getsubpathcount
static void test_getsubpathcount(void)
Definition: pathiterator.c:262
test_isvalid
static void test_isvalid(void)
Definition: pathiterator.c:305
test_nextpathtype
static void test_nextpathtype(void)
Definition: pathiterator.c:485
test_constructor_destructor
static void test_constructor_destructor(void)
Definition: pathiterator.c:27
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65

◆ test_constructor_destructor()

static void test_constructor_destructor ( void  )
static

Definition at line 27 of file pathiterator.c.

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 iter = NULL;
40 stat = GdipCreatePathIter(&iter, NULL);
41 expect(Ok, stat);
42 ok(iter != NULL, "Expected iterator to be created\n");
43 GdipDeletePathIter(iter);
44 stat = GdipCreatePathIter(NULL, path);
45 expect(InvalidParameter, stat);
46 stat = GdipDeletePathIter(NULL);
47 expect(InvalidParameter, stat);
48
49 /* valid args */
50 stat = GdipCreatePathIter(&iter, path);
51 expect(Ok, stat);
52
53 GdipDeletePathIter(iter);
54 GdipDeletePath(path);
55}
stat
#define stat
Definition: acwin.h:99
ok
#define ok(value,...)
Definition: atltest.h:57
GdipCreatePath
GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
Definition: graphicspath.c:1197
GdipDeletePath
GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
Definition: graphicspath.c:1268
GdipAddPathRectangle
GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y, REAL width, REAL height)
Definition: graphicspath.c:2296
GdipDeletePathIter
GpStatus WINGDIPAPI GdipDeletePathIter(GpPathIterator *iter)
Definition: pathiterator.c:69
GdipCreatePathIter
GpStatus WINGDIPAPI GdipCreatePathIter(GpPathIterator **iterator, GpPath *path)
Definition: pathiterator.c:34
FillModeAlternate
@ FillModeAlternate
Definition: gdiplusenums.h:55
Status
Status
Definition: gdiplustypes.h:25
Ok
@ Ok
Definition: gdiplustypes.h:26
InvalidParameter
@ InvalidParameter
Definition: gdiplustypes.h:28
expect
#define expect(expected, got)
Definition: pathiterator.c:25
stat
Definition: stat.h:55

Referenced by START_TEST().

◆ test_getsubpathcount()

static void test_getsubpathcount ( void  )
static

Definition at line 262 of file pathiterator.c.

263{
264 GpPath *path;
265 GpPathIterator *iter;
266 GpStatus stat;
267 INT count;
268
269 /* NULL args */
270 stat = GdipPathIterGetSubpathCount(NULL, NULL);
271 expect(InvalidParameter, stat);
272 stat = GdipPathIterGetSubpathCount(NULL, &count);
273 expect(InvalidParameter, stat);
274
275 GdipCreatePath(FillModeAlternate, &path);
276
277 /* empty path */
278 GdipCreatePathIter(&iter, path);
279 stat = GdipPathIterGetSubpathCount(iter, &count);
280 expect(Ok, stat);
281 expect(0, count);
282 GdipDeletePathIter(iter);
283
284 GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
285
286 /* open figure */
287 GdipCreatePathIter(&iter, path);
288 stat = GdipPathIterGetSubpathCount(iter, &count);
289 expect(Ok, stat);
290 expect(1, count);
291 GdipDeletePathIter(iter);
292
293 /* manually start new figure */
294 GdipStartPathFigure(path);
295 GdipAddPathLine(path, 50.0, 50.0, 110.0, 40.0);
296 GdipCreatePathIter(&iter, path);
297 stat = GdipPathIterGetSubpathCount(iter, &count);
298 expect(Ok, stat);
299 expect(2, count);
300 GdipDeletePathIter(iter);
301
302 GdipDeletePath(path);
303}
GdipAddPathLine
GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
Definition: graphicspath.c:704
GdipStartPathFigure
GpStatus WINGDIPAPI GdipStartPathFigure(GpPath *path)
Definition: graphicspath.c:1744
GdipPathIterGetSubpathCount
GpStatus WINGDIPAPI GdipPathIterGetSubpathCount(GpPathIterator *iterator, INT *count)
Definition: pathiterator.c:127
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
INT
int32_t INT
Definition: typedefs.h:58

Referenced by START_TEST().

◆ test_hascurve()

static void test_hascurve ( void  )
static

Definition at line 57 of file pathiterator.c.

58{
59 GpPath *path;
60 GpPathIterator *iter;
61 GpStatus stat;
62 BOOL hasCurve;
63
64 GdipCreatePath(FillModeAlternate, &path);
65 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
66
67 stat = GdipCreatePathIter(&iter, path);
68 expect(Ok, stat);
69
70 /* NULL args
71 BOOL out argument is local in wrapper class method,
72 so it always has not-NULL address */
73 stat = GdipPathIterHasCurve(NULL, &hasCurve);
74 expect(InvalidParameter, stat);
75
76 /* valid args */
77 stat = GdipPathIterHasCurve(iter, &hasCurve);
78 expect(Ok, stat);
79 expect(FALSE, hasCurve);
80
81 GdipDeletePathIter(iter);
82
83 stat = GdipAddPathEllipse(path, 0.0, 0.0, 35.0, 70.0);
84 expect(Ok, stat);
85
86 stat = GdipCreatePathIter(&iter, path);
87 expect(Ok, stat);
88
89 stat = GdipPathIterHasCurve(iter, &hasCurve);
90 expect(Ok, stat);
91 expect(TRUE, hasCurve);
92
93 GdipDeletePathIter(iter);
94 GdipDeletePath(path);
95}
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
GdipAddPathEllipse
GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width, REAL height)
Definition: graphicspath.c:583
GdipPathIterHasCurve
GpStatus WINGDIPAPI GdipPathIterHasCurve(GpPathIterator *iterator, BOOL *hasCurve)
Definition: pathiterator.c:107
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

Referenced by START_TEST().

◆ test_isvalid()

static void test_isvalid ( void  )
static

Definition at line 305 of file pathiterator.c.

306{
307 GpPath *path;
308 GpPathIterator *iter;
309 GpStatus stat;
310 BOOL isvalid;
311 INT start, end, result;
312
313 GdipCreatePath(FillModeAlternate, &path);
314
315 /* NULL args */
316 GdipCreatePathIter(&iter, path);
317 stat = GdipPathIterIsValid(NULL, NULL);
318 expect(InvalidParameter, stat);
319 stat = GdipPathIterIsValid(iter, NULL);
320 expect(InvalidParameter, stat);
321 stat = GdipPathIterIsValid(NULL, &isvalid);
322 expect(InvalidParameter, stat);
323 GdipDeletePathIter(iter);
324
325 /* on empty path */
326 GdipCreatePathIter(&iter, path);
327 isvalid = FALSE;
328 stat = GdipPathIterIsValid(iter, &isvalid);
329 expect(Ok, stat);
330 expect(TRUE, isvalid);
331 GdipDeletePathIter(iter);
332
333 /* no markers */
334 stat = GdipAddPathLine(path, 50.0, 50.0, 110.0, 40.0);
335 expect(Ok, stat);
336 stat = GdipCreatePathIter(&iter, path);
337 expect(Ok, stat);
338 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
339 expect(Ok, stat);
340 isvalid = FALSE;
341 stat = GdipPathIterIsValid(iter, &isvalid);
342 expect(Ok, stat);
343 expect(TRUE, isvalid);
344 GdipDeletePathIter(iter);
345
346 GdipDeletePath(path);
347}
GdipPathIterIsValid
GpStatus WINGDIPAPI GdipPathIterIsValid(GpPathIterator *iterator, BOOL *valid)
Definition: pathiterator.c:283
GdipPathIterNextMarker
GpStatus WINGDIPAPI GdipPathIterNextMarker(GpPathIterator *iterator, INT *resultCount, INT *startIndex, INT *endIndex)
Definition: pathiterator.c:145
start
GLuint start
Definition: gl.h:1545
end
GLuint GLuint end
Definition: gl.h:1545
result
GLuint64EXT * result
Definition: glext.h:11304

Referenced by START_TEST().

◆ test_nextmarker()

static void test_nextmarker ( void  )
static

Definition at line 97 of file pathiterator.c.

98{
99 GpPath *path;
100 GpPathIterator *iter;
101 GpStatus stat;
102 INT start, end;
103 INT result;
104
105 /* NULL args
106 BOOL out argument is local in wrapper class method,
107 so it always has not-NULL address */
108 stat = GdipPathIterNextMarker(NULL, &result, NULL, NULL);
109 expect(InvalidParameter, stat);
110 stat = GdipPathIterNextMarker(NULL, &result, &start, NULL);
111 expect(InvalidParameter, stat);
112 stat = GdipPathIterNextMarker(NULL, &result, NULL, &end);
113 expect(InvalidParameter, stat);
114
115 GdipCreatePath(FillModeAlternate, &path);
116 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
117
118 /* no markers */
119 GdipCreatePathIter(&iter, path);
120 start = end = result = (INT)0xdeadbeef;
121 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
122 expect(Ok, stat);
123 expect(0, start);
124 expect(3, end);
125 expect(4, result);
126 start = end = result = (INT)0xdeadbeef;
127 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
128 expect(Ok, stat);
129 /* start/end remain unchanged */
130 expect((INT)0xdeadbeef, start);
131 expect((INT)0xdeadbeef, end);
132 expect(0, result);
133 GdipDeletePathIter(iter);
134
135 /* one marker */
136 GdipSetPathMarker(path);
137 GdipCreatePathIter(&iter, path);
138 start = end = result = (INT)0xdeadbeef;
139 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
140 expect(Ok, stat);
141 expect(0, start);
142 expect(3, end);
143 expect(4, result);
144 start = end = result = (INT)0xdeadbeef;
145 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
146 expect(Ok, stat);
147 expect((INT)0xdeadbeef, start);
148 expect((INT)0xdeadbeef, end);
149 expect(0, result);
150 GdipDeletePathIter(iter);
151
152 /* two markers */
153 GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
154 GdipSetPathMarker(path);
155 GdipCreatePathIter(&iter, path);
156 start = end = result = (INT)0xdeadbeef;
157 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
158 expect(Ok, stat);
159 expect(0, start);
160 expect(3, end);
161 expect(4, result);
162 start = end = result = (INT)0xdeadbeef;
163 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
164 expect(Ok, stat);
165 expect(4, start);
166 expect(5, end);
167 expect(2, result);
168 start = end = result = (INT)0xdeadbeef;
169 stat = GdipPathIterNextMarker(iter, &result, &start, &end);
170 expect(Ok, stat);
171 expect((INT)0xdeadbeef, start);
172 expect((INT)0xdeadbeef, end);
173 expect(0, result);
174 GdipDeletePathIter(iter);
175
176 GdipDeletePath(path);
177}
GdipSetPathMarker
GpStatus WINGDIPAPI GdipSetPathMarker(GpPath *path)
Definition: graphicspath.c:2421
INT
#define INT
Definition: polytest.cpp:20

Referenced by START_TEST().

◆ test_nextmarkerpath()

static void test_nextmarkerpath ( void  )
static

Definition at line 179 of file pathiterator.c.

180{
181 GpPath *path, *retpath;
182 GpPathIterator *iter;
183 GpStatus stat;
184 INT result, count;
185
186 GdipCreatePath(FillModeAlternate, &path);
187
188 /* NULL */
189 stat = GdipPathIterNextMarkerPath(NULL, NULL, NULL);
190 expect(InvalidParameter, stat);
191 stat = GdipPathIterNextMarkerPath(NULL, &result, NULL);
192 expect(InvalidParameter, stat);
193 stat = GdipPathIterNextMarkerPath(NULL, &result, path);
194 expect(InvalidParameter, stat);
195
196 GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
197
198 /* no markers */
199 GdipCreatePath(FillModeAlternate, &retpath);
200 GdipCreatePathIter(&iter, path);
201 result = -1;
202 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
203 expect(Ok, stat);
204 expect(4, result);
205 count = -1;
206 GdipGetPointCount(retpath, &count);
207 expect(4, count);
208 result = -1;
209 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
210 expect(Ok, stat);
211 expect(0, result);
212 count = -1;
213 GdipGetPointCount(retpath, &count);
214 expect(4, count);
215 GdipDeletePathIter(iter);
216 GdipDeletePath(retpath);
217
218 /* one marker */
219 GdipSetPathMarker(path);
220 GdipCreatePath(FillModeAlternate, &retpath);
221 GdipCreatePathIter(&iter, path);
222 result = -1;
223 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
224 expect(Ok, stat);
225 expect(4, result);
226 count = -1;
227 GdipGetPointCount(retpath, &count);
228 expect(4, count);
229 result = -1;
230 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
231 expect(Ok, stat);
232 expect(0, result);
233 count = -1;
234 GdipGetPointCount(retpath, &count);
235 expect(4, count);
236 GdipDeletePathIter(iter);
237 GdipDeletePath(retpath);
238
239 /* two markers */
240 GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
241 GdipSetPathMarker(path);
242 GdipCreatePath(FillModeAlternate, &retpath);
243 GdipCreatePathIter(&iter, path);
244 result = -1;
245 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
246 expect(Ok, stat);
247 expect(4, result);
248 result = -1;
249 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
250 expect(Ok, stat);
251 expect(2, result);
252 result = -1;
253 stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
254 expect(Ok, stat);
255 expect(0, result);
256 GdipDeletePathIter(iter);
257 GdipDeletePath(retpath);
258
259 GdipDeletePath(path);
260}
GdipGetPointCount
GpStatus WINGDIPAPI GdipGetPointCount(GpPath *path, INT *count)
Definition: graphicspath.c:1584
GdipPathIterNextMarkerPath
GpStatus WINGDIPAPI GdipPathIterNextMarkerPath(GpPathIterator *iterator, INT *result, GpPath *path)
Definition: pathiterator.c:173

Referenced by START_TEST().

◆ test_nextpathtype()

static void test_nextpathtype ( void  )
static

Definition at line 485 of file pathiterator.c.

486{
487 GpPath *path;
488 GpPathIterator *iter;
489 GpStatus stat;
490 INT start, end, result;
491 BYTE type;
492
493 GdipCreatePath(FillModeAlternate, &path);
494 GdipCreatePathIter(&iter, path);
495
496 /* NULL arguments */
497 stat = GdipPathIterNextPathType(NULL, NULL, NULL, NULL, NULL);
498 expect(InvalidParameter, stat);
499 stat = GdipPathIterNextPathType(iter, NULL, NULL, NULL, NULL);
500 expect(InvalidParameter, stat);
501 stat = GdipPathIterNextPathType(iter, &result, NULL, NULL, NULL);
502 expect(InvalidParameter, stat);
503 stat = GdipPathIterNextPathType(iter, NULL, &type, NULL, NULL);
504 expect(InvalidParameter, stat);
505 stat = GdipPathIterNextPathType(iter, NULL, NULL, &start, &end);
506 expect(InvalidParameter, stat);
507 stat = GdipPathIterNextPathType(iter, NULL, &type, &start, &end);
508 expect(InvalidParameter, stat);
509 stat = GdipPathIterNextPathType(iter, &result, &type, NULL, NULL);
510 expect(InvalidParameter, stat);
511
512 /* empty path */
513 start = end = result = (INT)0xdeadbeef;
514 stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
515 todo_wine expect(Ok, stat);
516 expect((INT)0xdeadbeef, start);
517 expect((INT)0xdeadbeef, end);
518 todo_wine expect(0, result);
519 GdipDeletePathIter(iter);
520
521 /* single figure */
522 GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
523 GdipCreatePathIter(&iter, path);
524 start = end = result = (INT)0xdeadbeef;
525 type = 255; /* out of range */
526 stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
527 todo_wine expect(Ok, stat);
528 expect((INT)0xdeadbeef, start);
529 expect((INT)0xdeadbeef, end);
530 expect(255, type);
531 todo_wine expect(0, result);
532 GdipDeletePathIter(iter);
533
534 stat = GdipAddPathEllipse(path, 0.0, 0.0, 35.0, 70.0);
535 expect(Ok, stat);
536 GdipCreatePathIter(&iter, path);
537 start = end = result = (INT)0xdeadbeef;
538 type = 255; /* out of range */
539 stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
540 todo_wine expect(Ok, stat);
541 expect((INT)0xdeadbeef, start);
542 expect((INT)0xdeadbeef, end);
543 expect(255, type);
544 todo_wine expect(0, result);
545 GdipDeletePathIter(iter);
546
547 /* closed */
548 GdipClosePathFigure(path);
549 GdipCreatePathIter(&iter, path);
550 start = end = result = (INT)0xdeadbeef;
551 type = 255; /* out of range */
552 stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
553 todo_wine expect(Ok, stat);
554 expect((INT)0xdeadbeef, start);
555 expect((INT)0xdeadbeef, end);
556 expect(255, type);
557 todo_wine expect(0, result);
558 GdipDeletePathIter(iter);
559
560 GdipDeletePath(path);
561}
GdipClosePathFigure
GpStatus WINGDIPAPI GdipClosePathFigure(GpPath *path)
Definition: graphicspath.c:1163
GdipPathIterNextPathType
GpStatus WINGDIPAPI GdipPathIterNextPathType(GpPathIterator *iter, INT *result, BYTE *type, INT *start, INT *end)
Definition: pathiterator.c:295
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
todo_wine
#define todo_wine
Definition: custom.c:79
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by START_TEST().

◆ test_nextsubpath()

static void test_nextsubpath ( void  )
static

Definition at line 462 of file pathiterator.c.

463{
464 GpPath *path;
465 GpPathIterator *iter;
466 GpStatus stat;
467 INT start, end, result;
468 BOOL closed;
469
470 /* empty path */
471 GdipCreatePath(FillModeAlternate, &path);
472 GdipCreatePathIter(&iter, path);
473
474 result = -2;
475 closed = TRUE;
476 stat = GdipPathIterNextSubpath(iter, &result, &start, &end, &closed);
477 expect(Ok, stat);
478 expect(0, result);
479 expect(TRUE, closed);
480
481 GdipDeletePathIter(iter);
482 GdipDeletePath(path);
483}
GdipPathIterNextSubpath
GpStatus WINGDIPAPI GdipPathIterNextSubpath(GpPathIterator *iterator, INT *resultCount, INT *startIndex, INT *endIndex, BOOL *isClosed)
Definition: pathiterator.c:199

Referenced by START_TEST().

◆ test_nextsubpathpath()

static void test_nextsubpathpath ( void  )
static

Definition at line 349 of file pathiterator.c.

350{
351 GpPath *path, *retpath;
352 GpPathIterator *iter;
353 GpStatus stat;
354 BOOL closed;
355 INT count, result;
356
357 GdipCreatePath(FillModeAlternate, &path);
358
359 /* NULL args */
360 GdipCreatePath(FillModeAlternate, &retpath);
361 GdipCreatePathIter(&iter, path);
362 stat = GdipPathIterNextSubpathPath(NULL, NULL, NULL, NULL);
363 expect(InvalidParameter, stat);
364 stat = GdipPathIterNextSubpathPath(iter, NULL, NULL, NULL);
365 expect(InvalidParameter, stat);
366 stat = GdipPathIterNextSubpathPath(NULL, &result, NULL, NULL);
367 expect(InvalidParameter, stat);
368 stat = GdipPathIterNextSubpathPath(iter, &result, NULL, &closed);
369 expect(Ok, stat);
370 stat = GdipPathIterNextSubpathPath(iter, NULL, NULL, &closed);
371 expect(InvalidParameter, stat);
372 stat = GdipPathIterNextSubpathPath(iter, NULL, retpath, NULL);
373 expect(InvalidParameter, stat);
374 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, NULL);
375 expect(InvalidParameter, stat);
376 GdipDeletePathIter(iter);
377 GdipDeletePath(retpath);
378
379 /* empty path */
380 GdipCreatePath(FillModeAlternate, &retpath);
381 GdipCreatePathIter(&iter, path);
382 result = -2;
383 closed = TRUE;
384 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
385 expect(Ok, stat);
386 expect(0, result);
387 expect(TRUE, closed);
388 count = -1;
389 GdipGetPointCount(retpath, &count);
390 expect(0, count);
391 GdipDeletePathIter(iter);
392 GdipDeletePath(retpath);
393
394 /* open figure */
395 GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
396
397 GdipCreatePath(FillModeAlternate, &retpath);
398 GdipCreatePathIter(&iter, path);
399 result = -2;
400 closed = TRUE;
401 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
402 expect(Ok, stat);
403 expect(2, result);
404 expect(FALSE, closed);
405 count = -1;
406 GdipGetPointCount(retpath, &count);
407 expect(2, count);
408 /* subsequent call */
409 result = -2;
410 closed = TRUE;
411 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
412 expect(Ok, stat);
413 expect(0, result);
414 expect(TRUE, closed);
415 count = -1;
416 GdipGetPointCount(retpath, &count);
417 expect(2, count);
418 GdipDeletePathIter(iter);
419
420 /* closed figure, check does it extend retpath or reset it */
421 GdipAddPathLine(retpath, 50.0, 55.0, 200.0, 150.0);
422
423 GdipClosePathFigure(path);
424 GdipAddPathLine(path, 50.0, 55.0, 200.0, 150.0);
425 GdipClosePathFigure(path);
426
427 GdipCreatePathIter(&iter, path);
428 result = -2;
429 closed = FALSE;
430 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
431 expect(Ok, stat);
432 expect(2, result);
433 expect(TRUE, closed);
434 count = -1;
435 GdipGetPointCount(retpath, &count);
436 expect(2, count);
437 /* subsequent call */
438 result = -2;
439 closed = FALSE;
440 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
441 expect(Ok, stat);
442 expect(2, result);
443 expect(TRUE, closed);
444 count = -1;
445 GdipGetPointCount(retpath, &count);
446 expect(2, count);
447 result = -2;
448 closed = FALSE;
449 stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
450 expect(Ok, stat);
451 expect(0, result);
452 expect(TRUE, closed);
453 count = -1;
454 GdipGetPointCount(retpath, &count);
455 expect(2, count);
456 GdipDeletePathIter(iter);
457
458 GdipDeletePath(retpath);
459 GdipDeletePath(path);
460}
GdipPathIterNextSubpathPath
GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator *iter, INT *result, GpPath *path, BOOL *closed)
Definition: pathiterator.c:306

Referenced by START_TEST().