1 #ifdef WIN32
2 #ifndef __cplusplus
3 #error Please compile with a C++ compiler.
4 #endif
5 #endif
6
7 #if defined(USE_WINDOWS_GDIPLUS)
8 #include <Windows.h>
9 #include <GdiPlus.h>
10
11 #pragma comment(lib, "gdiplus.lib")
12 #else
13 #include <GdiPlusFlat.h>
14 #endif
15
16 #if defined(USE_WINDOWS_GDIPLUS)
17 using namespace Gdiplus;
18 using namespace DllExports;
19 #endif
20
21 #include <assert.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include "testhelpers.h"
25
getImage()26 static GpImage * getImage ()
27 {
28 GpStatus status;
29 GpBitmap *image;
30 status = GdipCreateBitmapFromScan0 (100, 68, 0, PixelFormat32bppRGB, NULL, &image);
31 assertEqualInt (status, Ok);
32
33 return (GpImage *)image;
34 }
35
verifyPen(GpPen * pen,REAL expectedWidth,Unit expectedUnit,PenType expectedType)36 static void verifyPen (GpPen *pen, REAL expectedWidth, Unit expectedUnit, PenType expectedType)
37 {
38 assert (pen && "Expected the pen to be initalized.");
39
40 GpStatus status;
41 REAL width;
42 GpUnit unit;
43 PenType type;
44 LineJoin lineJoin;
45 PenAlignment mode;
46 GpBrush *brush;
47 BrushType brushType;
48 LineCap startCap;
49 LineCap endCap;
50 DashCap dashCap;
51 DashStyle dashStyle;
52 GpCustomLineCap *customStartCap;
53 GpCustomLineCap *customEndCap;
54 REAL miterLimit;
55 GpMatrix *transform;
56 INT dashCount;
57 REAL dashOffset;
58 INT compoundCount;
59
60 GdipCreateMatrix (&transform);
61
62 status = GdipGetPenWidth (pen, &width);
63 assertEqualInt (status, Ok);
64 assertEqualFloat (width, expectedWidth);
65
66 status = GdipGetPenUnit (pen, &unit);
67 assertEqualInt (status, Ok);
68 assertEqualInt (unit, expectedUnit);
69
70 status = GdipGetPenFillType (pen, &type);
71 assertEqualInt (status, Ok);
72 assertEqualInt (type, expectedType);
73
74 status = GdipGetPenLineJoin (pen, &lineJoin);
75 assertEqualInt (status, Ok);
76 assertEqualInt (lineJoin, LineJoinMiter);
77
78 status = GdipGetPenMode (pen, &mode);
79 assertEqualInt (status, Ok);
80 assertEqualInt (mode, PenAlignmentCenter);
81
82 status = GdipGetPenBrushFill (pen, &brush);
83 assertEqualInt (status, Ok);
84
85 status = GdipGetBrushType (brush, &brushType);
86 assertEqualInt (status, Ok);
87 assertEqualInt (brushType, (BrushType)expectedType);
88
89 status = GdipGetPenStartCap (pen, &startCap);
90 assertEqualInt (status, Ok);
91 assertEqualInt (startCap, LineCapFlat);
92
93 status = GdipGetPenEndCap (pen, &endCap);
94 assertEqualInt (status, Ok);
95 assertEqualInt (endCap, LineCapFlat);
96
97 status = GdipGetPenDashCap197819 (pen, &dashCap);
98 assertEqualInt (status, Ok);
99 assertEqualInt (dashCap, DashCapFlat);
100
101 status = GdipGetPenDashStyle (pen, &dashStyle);
102 assertEqualInt (status, Ok);
103 assertEqualInt (dashStyle, DashStyleSolid);
104
105 status = GdipGetPenCustomStartCap (pen, &customStartCap);
106 assertEqualInt (status, Ok);
107 assert (!customStartCap);
108
109 status = GdipGetPenCustomEndCap (pen, &customEndCap);
110 assertEqualInt (status, Ok);
111 assert (!customEndCap);
112
113 status = GdipGetPenMiterLimit (pen, &miterLimit);
114 assertEqualInt (status, Ok);
115 assertEqualFloat (miterLimit, 10);
116
117 status = GdipGetPenTransform (pen, transform);
118 assertEqualInt (status, Ok);
119 verifyMatrix (transform, 1, 0, 0, 1, 0, 0);
120
121 status = GdipGetPenDashCount (pen, &dashCount);
122 assertEqualInt (status, Ok);
123 assertEqualInt (dashCount, 0);
124
125 status = GdipGetPenDashOffset (pen, &dashOffset);
126 assertEqualInt (status, Ok);
127 assertEqualFloat (dashOffset, 0);
128
129 status = GdipGetPenCompoundCount (pen, &compoundCount);
130 assertEqualInt (status, Ok);
131 assertEqualInt (compoundCount, 0);
132
133 GdipDeleteMatrix (transform);
134 GdipDeleteBrush (brush);
135 }
136
verifySolidBrushPen(GpPen * pen,ARGB expectedColor,REAL expectedWidth,Unit expectedUnit)137 static void verifySolidBrushPen (GpPen *pen, ARGB expectedColor, REAL expectedWidth, Unit expectedUnit)
138 {
139 GpStatus status;
140 ARGB color;
141
142 verifyPen (pen, expectedWidth, expectedUnit, PenTypeSolidColor);
143
144 status = GdipGetPenColor (pen, &color);
145 assertEqualInt (status, Ok);
146 assertEqualInt (color, expectedColor);
147 }
148
verifyNonSolidBrushPen(GpPen * pen,REAL expectedWidth,Unit expectedUnit,PenType expectedType)149 static void verifyNonSolidBrushPen (GpPen *pen, REAL expectedWidth, Unit expectedUnit, PenType expectedType)
150 {
151 GpStatus status;
152 ARGB color;
153
154 verifyPen (pen, expectedWidth, expectedUnit, expectedType);
155
156 status = GdipGetPenColor (pen, &color);
157 assertEqualInt (status, InvalidParameter);
158 }
159
test_createPen1()160 static void test_createPen1 ()
161 {
162 GpStatus status;
163 GpPen *pen;
164
165 status = GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
166 assertEqualInt (status, Ok);
167 verifySolidBrushPen (pen, 1, 10, UnitWorld);
168 GdipDeletePen (pen);
169
170 status = GdipCreatePen1 (0x00000001, 0, UnitPixel, &pen);
171 assertEqualInt (status, Ok);
172 verifySolidBrushPen (pen, 1, 0, UnitPixel);
173 GdipDeletePen (pen);
174
175 status = GdipCreatePen1 (0x00000001, -1, UnitPoint, &pen);
176 assertEqualInt (status, Ok);
177 verifySolidBrushPen (pen, 1, -1, UnitPoint);
178 GdipDeletePen (pen);
179
180 status = GdipCreatePen1 (0x00000001, 10, UnitInch, &pen);
181 assertEqualInt (status, Ok);
182 verifySolidBrushPen (pen, 1, 10, UnitInch);
183 GdipDeletePen (pen);
184
185 status = GdipCreatePen1 (0x00000001, 10, UnitDocument, &pen);
186 assertEqualInt (status, Ok);
187 verifySolidBrushPen (pen, 1, 10, UnitDocument);
188 GdipDeletePen (pen);
189
190 status = GdipCreatePen1 (0x00000001, 10, UnitMillimeter, &pen);
191 assertEqualInt (status, Ok);
192 verifySolidBrushPen (pen, 1, 10, UnitMillimeter);
193 GdipDeletePen (pen);
194
195 #if !defined(USE_WINDOWS_GDIPLUS)
196 status = GdipCreatePen1 (0x00000001, 10, UnitCairoPoint, &pen);
197 assertEqualInt (status, Ok);
198 verifySolidBrushPen (pen, 1, 10, UnitCairoPoint);
199 GdipDeletePen (pen);
200 #endif
201
202 // Negative tests.
203 pen = (GpPen *) 0xCC;
204 status = GdipCreatePen1 (0x00000001, 10, (Unit)(UnitWorld - 1), &pen);
205 assertEqualInt (status, InvalidParameter);
206 assert (pen == (GpPen *) 0xCC);
207
208 pen = (GpPen *) 0xCC;
209 status = GdipCreatePen1 (0x00000001, 10, UnitDisplay, &pen);
210 assertEqualInt (status, InvalidParameter);
211 assert (pen == (GpPen *) 0xCC);
212
213 #if defined(USE_WINDOWS_GDIPLUS)
214 pen = (GpPen *) 0xCC;
215 status = GdipCreatePen1 (0x00000001, 10, (Unit)(UnitMillimeter + 1), &pen);
216 assertEqualInt (status, InvalidParameter);
217 assert (pen == (GpPen *) 0xCC);
218 #else
219 pen = (GpPen *) 0xCC;
220 status = GdipCreatePen1 (0x00000001, 10, (Unit)(UnitCairoPoint + 1), &pen);
221 assertEqualInt (status, InvalidParameter);
222 assert (pen == (GpPen *) 0xCC);
223 #endif
224
225 pen = (GpPen *) 0xCC;
226 status = GdipCreatePen1 (0x00000001, 10, UnitWorld, NULL);
227 assertEqualInt (status, InvalidParameter);
228 assert (pen == (GpPen *) 0xCC);
229 }
230
231 static GpPointF threePoints[3] =
232 {
233 {3, 13},
234 {1, 2},
235 {5, 6}
236 };
237
test_createPen2()238 static void test_createPen2 ()
239 {
240 GpStatus status;
241 GpSolidFill *solidBrush;
242 GpHatch *hatchBrush;
243 GpImage *image;
244 GpTexture *textureBrush;
245 GpPathGradient *pathGradientBrush;
246 GpRectF rect = {1, 2, 3, 4};
247 GpLineGradient *lineGradientBrush;
248
249 GpPen *pen;
250
251 GdipCreateSolidFill (1, &solidBrush);
252 GdipCreateHatchBrush (HatchStyle05Percent, 1, 2, &hatchBrush);
253 image = getImage ();
254 GdipCreateTexture (image, WrapModeTile, &textureBrush);
255 GdipCreatePathGradient (threePoints, 3, WrapModeTileFlipX, &pathGradientBrush);
256 GdipCreateLineBrushFromRect (&rect, 1, 2, LinearGradientModeBackwardDiagonal, WrapModeTileFlipX, &lineGradientBrush);
257
258 // SolidBrush/UnitWorld.
259 status = GdipCreatePen2 (solidBrush, 10, UnitWorld, &pen);
260 assertEqualInt (status, Ok);
261 verifySolidBrushPen (pen, 1, 10, UnitWorld);
262 GdipDeletePen (pen);
263
264 // HatchFill/UnitPixel
265 status = GdipCreatePen2 (hatchBrush, 0, UnitPixel, &pen);
266 assertEqualInt (status, Ok);
267 verifyNonSolidBrushPen (pen, 0, UnitPixel, PenTypeHatchFill);
268 GdipDeletePen (pen);
269
270 // TextureFill/UnitPoint
271 status = GdipCreatePen2 (textureBrush, -1, UnitPoint, &pen);
272 assertEqualInt (status, Ok);
273 verifyNonSolidBrushPen (pen, -1, UnitPoint, PenTypeTextureFill);
274 GdipDeletePen (pen);
275
276 // PathGradient/UnitInch.
277 status = GdipCreatePen2 (pathGradientBrush, 10, UnitInch, &pen);
278 assertEqualInt (status, Ok);
279 verifyNonSolidBrushPen (pen, 10, UnitInch, PenTypePathGradient);
280 GdipDeletePen (pen);
281
282 // LineGradient/UnitDocument.
283 status = GdipCreatePen2 (lineGradientBrush, 10, UnitDocument, &pen);
284 assertEqualInt (status, Ok);
285 verifyNonSolidBrushPen (pen, 10, UnitDocument, PenTypeLinearGradient);
286 GdipDeletePen (pen);
287
288 // LinearGradient/UnitDocument.
289 status = GdipCreatePen2 (lineGradientBrush, 10, UnitMillimeter, &pen);
290 assertEqualInt (status, Ok);
291 verifyNonSolidBrushPen (pen, 10, UnitMillimeter, PenTypeLinearGradient);
292 GdipDeletePen (pen);
293
294 #if !defined(USE_WINDOWS_GDIPLUS)
295 // LinearGradient/UnitCairoPoint.
296 status = GdipCreatePen2 (lineGradientBrush, 10, UnitCairoPoint, &pen);
297 assertEqualInt (status, Ok);
298 verifyNonSolidBrushPen (pen, 10, UnitCairoPoint, PenTypeLinearGradient);
299 GdipDeletePen (pen);
300 #endif
301
302 // Negative tests.
303 status = GdipCreatePen2 (NULL, 10, UnitPixel, &pen);
304 assertEqualInt (status, InvalidParameter);
305
306 status = GdipCreatePen2 (solidBrush, 10, UnitDisplay, &pen);
307 assertEqualInt (status, InvalidParameter);
308
309 #if defined(USE_WINDOWS_GDIPLUS)
310 status = GdipCreatePen2 (solidBrush, 10, (Unit)(UnitMillimeter + 1), &pen);
311 assertEqualInt (status, InvalidParameter);
312 #else
313 status = GdipCreatePen2 (solidBrush, 10, (Unit)(UnitCairoPoint + 1), &pen);
314 assertEqualInt (status, InvalidParameter);
315 #endif
316
317 status = GdipCreatePen2 (solidBrush, 10, UnitPixel, NULL);
318 assertEqualInt (status, InvalidParameter);
319
320 GdipDeleteBrush ((GpBrush *) solidBrush);
321 GdipDeleteBrush ((GpBrush *) hatchBrush);
322 GdipDisposeImage (image);
323 GdipDeleteBrush ((GpBrush *) textureBrush);
324 GdipDeleteBrush ((GpBrush *) pathGradientBrush);
325 GdipDeleteBrush ((GpBrush *) lineGradientBrush);
326 }
327
test_clone()328 static void test_clone ()
329 {
330 GpStatus status;
331 GpPen *pen;
332 GpPen *clone;
333
334 GdipCreatePen1 (0x00000001, 10, UnitDocument, &pen);
335
336 status = GdipClonePen (pen, &clone);
337 assertEqualInt (status, Ok);
338 verifySolidBrushPen (clone, 1, 10, UnitDocument);
339
340 // Negative tests.
341 status = GdipClonePen (NULL, &clone);
342 assertEqualInt (status, InvalidParameter);
343
344 status = GdipClonePen (pen, NULL);
345 assertEqualInt (status, InvalidParameter);
346
347 GdipDeletePen (pen);
348 GdipDeletePen (clone);
349 }
350
test_getPenWidth()351 static void test_getPenWidth ()
352 {
353 GpStatus status;
354 GpPen *pen;
355 REAL width;
356
357 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
358
359 // Negative tests.
360 status = GdipGetPenWidth (NULL, &width);
361 assertEqualInt (status, InvalidParameter);
362
363 status = GdipGetPenWidth (pen, NULL);
364 assertEqualInt (status, InvalidParameter);
365
366 GdipDeletePen (pen);
367 }
368
test_setPenWidth()369 static void test_setPenWidth ()
370 {
371 GpStatus status;
372 GpPen *pen;
373 REAL width;
374
375 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
376
377 // Positive value.
378 status = GdipSetPenWidth (pen, 10);
379 assertEqualInt (status, Ok);
380
381 status = GdipGetPenWidth (pen, &width);
382 assertEqualInt (status, Ok);
383 assertEqualFloat (width, 10);
384
385 // Same value.
386 status = GdipSetPenWidth (pen, 10);
387 assertEqualInt (status, Ok);
388
389 status = GdipGetPenWidth (pen, &width);
390 assertEqualInt (status, Ok);
391 assertEqualFloat (width, 10);
392
393 // Zero value.
394 status = GdipSetPenWidth (pen, 0);
395 assertEqualInt (status, Ok);
396
397 status = GdipGetPenWidth (pen, &width);
398 assertEqualInt (status, Ok);
399 assertEqualFloat (width, 0);
400
401 // Negative value.
402 status = GdipSetPenWidth (pen, -1);
403 assertEqualInt (status, Ok);
404
405 status = GdipGetPenWidth (pen, &width);
406 assertEqualInt (status, Ok);
407 assertEqualFloat (width, -1);
408
409 // Negative tests.
410 status = GdipSetPenWidth (NULL, 10);
411 assertEqualInt (status, InvalidParameter);
412
413 GdipDeletePen (pen);
414 }
415
test_getPenUnit()416 static void test_getPenUnit ()
417 {
418 GpStatus status;
419 GpPen *pen;
420 Unit unit;
421
422 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
423
424 // Negative tests.
425 status = GdipGetPenUnit (NULL, &unit);
426 assertEqualInt (status, InvalidParameter);
427
428 status = GdipGetPenUnit (pen, NULL);
429 assertEqualInt (status, InvalidParameter);
430
431 GdipDeletePen (pen);
432 }
433
test_setPenUnit()434 static void test_setPenUnit ()
435 {
436 GpStatus status;
437 GpPen *pen;
438 Unit unit;
439
440 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
441
442 // UnitWorld.
443 status = GdipSetPenUnit (pen, UnitWorld);
444 assertEqualInt (status, Ok);
445
446 status = GdipGetPenUnit (pen, &unit);
447 assertEqualInt (status, Ok);
448 assertEqualInt (unit, UnitWorld);
449
450 // Same unit.
451 status = GdipSetPenUnit (pen, UnitWorld);
452 assertEqualInt (status, Ok);
453
454 status = GdipGetPenUnit (pen, &unit);
455 assertEqualInt (status, Ok);
456 assertEqualInt (unit, UnitWorld);
457
458 // UnitPixel.
459 status = GdipSetPenUnit (pen, UnitPixel);
460 assertEqualInt (status, Ok);
461
462 status = GdipGetPenUnit (pen, &unit);
463 assertEqualInt (status, Ok);
464 assertEqualInt (unit, UnitPixel);
465
466 // UnitPoint.
467 status = GdipSetPenUnit (pen, UnitPoint);
468 assertEqualInt (status, Ok);
469
470 status = GdipGetPenUnit (pen, &unit);
471 assertEqualInt (status, Ok);
472 assertEqualInt (unit, UnitPoint);
473
474 // UnitInch.
475 status = GdipSetPenUnit (pen, UnitInch);
476 assertEqualInt (status, Ok);
477
478 status = GdipGetPenUnit (pen, &unit);
479 assertEqualInt (status, Ok);
480 assertEqualInt (unit, UnitInch);
481
482 // UnitDocument.
483 status = GdipSetPenUnit (pen, UnitDocument);
484 assertEqualInt (status, Ok);
485
486 status = GdipGetPenUnit (pen, &unit);
487 assertEqualInt (status, Ok);
488 assertEqualInt (unit, UnitDocument);
489
490 // UnitMillimeter.
491 status = GdipSetPenUnit (pen, UnitMillimeter);
492 assertEqualInt (status, Ok);
493
494 status = GdipGetPenUnit (pen, &unit);
495 assertEqualInt (status, Ok);
496 assertEqualInt (unit, UnitMillimeter);
497
498 #if !defined(USE_WINDOWS_GDIPLUS)
499 // UnitCairoPoint.
500 status = GdipSetPenUnit (pen, UnitCairoPoint);
501 assertEqualInt (status, Ok);
502
503 status = GdipGetPenUnit (pen, &unit);
504 assertEqualInt (status, Ok);
505 assertEqualInt (unit, UnitCairoPoint);
506 #endif
507
508 // Negative tests.
509 status = GdipSetPenUnit (NULL, UnitWorld);
510 assertEqualInt (status, InvalidParameter);
511
512 status = GdipSetPenUnit (pen, (Unit)(UnitWorld -1));
513 assertEqualInt (status, InvalidParameter);
514
515 status = GdipSetPenUnit (pen, UnitDisplay);
516 assertEqualInt (status, InvalidParameter);
517
518 #if defined(USE_WINDOWS_GDIPLUS)
519 status = GdipSetPenUnit (pen, (Unit)(UnitMillimeter + 1));
520 assertEqualInt (status, InvalidParameter);
521 #else
522 status = GdipSetPenUnit (pen, (Unit)(UnitCairoPoint + 1));
523 assertEqualInt (status, InvalidParameter);
524 #endif
525
526 GdipDeletePen (pen);
527 }
528
test_setPenLineCap197819()529 static void test_setPenLineCap197819 ()
530 {
531 GpStatus status;
532 GpPen *pen;
533 LineCap startCap;
534 LineCap endCap;
535 DashCap dashCap;
536 GpPath *path;
537 GpCustomLineCap *penCustomLineCap;
538 GpCustomLineCap *customStartCap;
539 REAL startCapBaseInset;
540 GpCustomLineCap *customEndCap;
541 REAL endCapBaseInset;
542
543 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
544 GdipCreatePath (FillModeAlternate, &path);
545 GdipCreateCustomLineCap (path, NULL, LineCapDiamondAnchor, 10, &penCustomLineCap);
546
547 // Valid values.
548 status = GdipSetPenLineCap197819 (pen, LineCapArrowAnchor, LineCapDiamondAnchor, DashCapRound);
549 assertEqualInt (status, Ok);
550
551 GdipGetPenStartCap (pen, &startCap);
552 assertEqualInt (startCap, LineCapArrowAnchor);
553
554 GdipGetPenEndCap (pen, &endCap);
555 assertEqualInt (endCap, LineCapDiamondAnchor);
556
557 GdipGetPenDashCap197819 (pen, &dashCap);
558 assertEqualInt (dashCap, DashCapRound);
559
560 // Custom values.
561 status = GdipSetPenLineCap197819 (pen, LineCapCustom, LineCapCustom, DashCapTriangle);
562 assertEqualInt (status, Ok);
563
564 GdipGetPenStartCap (pen, &startCap);
565 assertEqualInt (startCap, LineCapCustom);
566
567 GdipGetPenEndCap (pen, &endCap);
568 assertEqualInt (endCap, LineCapCustom);
569
570 GdipGetPenDashCap197819 (pen, &dashCap);
571 assertEqualInt (dashCap, DashCapTriangle);
572
573 // Invalid values - negative.
574 status = GdipSetPenLineCap197819 (pen, (LineCap)(LineCapFlat - 1), (LineCap)(LineCapFlat - 1), (DashCap)(DashCapFlat - 1));
575 assertEqualInt (status, Ok);
576
577 GdipGetPenStartCap (pen, &startCap);
578 assertEqualInt (startCap, (LineCap)(LineCapFlat - 1));
579
580 GdipGetPenEndCap (pen, &endCap);
581 assertEqualInt (endCap, (LineCap)(LineCapFlat - 1));
582
583 GdipGetPenDashCap197819 (pen, &dashCap);
584 assertEqualInt (dashCap, DashCapFlat);
585
586 // Invalid values - positive.
587 status = GdipSetPenLineCap197819 (pen, (LineCap)(LineCapCustom + 1), (LineCap)(LineCapCustom + 1), (DashCap)(DashCapTriangle + 1));
588 assertEqualInt (status, Ok);
589
590 GdipGetPenStartCap (pen, &startCap);
591 assertEqualInt (startCap, (LineCap)(LineCapCustom + 1));
592
593 GdipGetPenEndCap (pen, &endCap);
594 assertEqualInt (endCap, (LineCap)(LineCapCustom + 1));
595
596 GdipGetPenDashCap197819 (pen, &dashCap);
597 assertEqualInt (dashCap, DashCapFlat);
598
599 // Invalid values - one.
600 status = GdipSetPenLineCap197819 (pen, (LineCap)(LineCapCustom + 1), (LineCap)(LineCapCustom + 1), (DashCap)(1));
601 assertEqualInt (status, Ok);
602
603 GdipGetPenStartCap (pen, &startCap);
604 assertEqualInt (startCap, (LineCap)(LineCapCustom + 1));
605
606 GdipGetPenEndCap (pen, &endCap);
607 assertEqualInt (endCap, (LineCap)(LineCapCustom + 1));
608
609 GdipGetPenDashCap197819 (pen, &dashCap);
610 assertEqualInt (dashCap, DashCapFlat);
611
612 // Set when there is already a custom cap.
613 GdipSetPenCustomStartCap (pen, penCustomLineCap);
614 GdipSetPenCustomEndCap (pen, penCustomLineCap);
615
616 status = GdipSetPenLineCap197819 (pen, LineCapNoAnchor, LineCapFlat, DashCapRound);
617 assertEqualInt (status, Ok);
618
619 status = GdipGetPenCustomStartCap (pen, &customStartCap);
620 assertEqualInt (status, Ok);
621
622 status = GdipGetCustomLineCapBaseInset (customStartCap, &startCapBaseInset);
623 assertEqualInt (status, Ok);
624 assertEqualFloat (startCapBaseInset, 10);
625
626 status = GdipGetPenCustomEndCap (pen, &customEndCap);
627 assertEqualInt (status, Ok);
628
629 status = GdipGetCustomLineCapBaseInset (customEndCap, &endCapBaseInset);
630 assertEqualInt (status, Ok);
631 assertEqualFloat (startCapBaseInset, 10);
632
633 // Negative tests.
634 status = GdipSetPenLineCap197819 (NULL, LineCapArrowAnchor, LineCapDiamondAnchor, DashCapFlat);
635 assertEqualInt (status, InvalidParameter);
636
637 GdipDeletePen (pen);
638 GdipDeletePath (path);
639 GdipDeleteCustomLineCap (penCustomLineCap);
640 GdipDeleteCustomLineCap (customStartCap);
641 GdipDeleteCustomLineCap (customEndCap);
642 }
643
test_setPenStartCap()644 static void test_setPenStartCap ()
645 {
646 GpStatus status;
647 GpPen *pen;
648 LineCap startCap;
649 GpPath *path;
650 GpCustomLineCap *penCustomLineCap;
651 GpCustomLineCap *customStartCap;
652
653 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
654 GdipCreatePath (FillModeAlternate, &path);
655 GdipCreateCustomLineCap (path, NULL, LineCapDiamondAnchor, 10, &penCustomLineCap);
656
657 // Valid values.
658 status = GdipSetPenStartCap (pen, LineCapArrowAnchor);
659 assertEqualInt (status, Ok);
660
661 GdipGetPenStartCap (pen, &startCap);
662 assertEqualInt (startCap, LineCapArrowAnchor);
663
664 // Same value.
665 status = GdipSetPenStartCap (pen, LineCapArrowAnchor);
666 assertEqualInt (status, Ok);
667
668 GdipGetPenStartCap (pen, &startCap);
669 assertEqualInt (startCap, LineCapArrowAnchor);
670
671 // Custom values.
672 status = GdipSetPenStartCap (pen, LineCapCustom);
673 assertEqualInt (status, Ok);
674
675 GdipGetPenStartCap (pen, &startCap);
676 assertEqualInt (startCap, LineCapCustom);
677
678 // Set when there is already a custom cap.
679 GdipSetPenCustomStartCap (pen, penCustomLineCap);
680 assertEqualInt (status, Ok);
681
682 status = GdipSetPenStartCap (pen, LineCapNoAnchor);
683 assertEqualInt (status, Ok);
684
685 status = GdipGetPenCustomStartCap (pen, &customStartCap);
686 assertEqualInt (status, Ok);
687 assert (!customStartCap && "Expected the pen's custom start cap to be cleared.");
688
689 // Invalid values - negative.
690 status = GdipSetPenStartCap (pen, (LineCap)(LineCapFlat - 1));
691 assertEqualInt (status, Ok);
692
693 GdipGetPenStartCap (pen, &startCap);
694 assertEqualInt (startCap, (LineCap)(LineCapFlat - 1));
695
696 // Invalid values - positive.
697 status = GdipSetPenStartCap (pen, (LineCap)(LineCapCustom + 1));
698 assertEqualInt (status, Ok);
699
700 GdipGetPenStartCap (pen, &startCap);
701 assertEqualInt (startCap, (LineCap)(LineCapCustom + 1));
702
703 // Negative tests.
704 status = GdipSetPenStartCap (NULL, LineCapArrowAnchor);
705 assertEqualInt (status, InvalidParameter);
706
707 GdipDeletePen (pen);
708 GdipDeleteCustomLineCap (penCustomLineCap);
709 GdipDeleteCustomLineCap (customStartCap);
710 }
711
test_setPenEndCap()712 static void test_setPenEndCap ()
713 {
714 GpStatus status;
715 GpPen *pen;
716 LineCap endCap;
717 GpPath *path;
718 GpCustomLineCap *penCustomLineCap;
719 GpCustomLineCap *customEndCap;
720
721 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
722 GdipCreatePath (FillModeAlternate, &path);
723 GdipCreateCustomLineCap (path, NULL, LineCapDiamondAnchor, 10, &penCustomLineCap);
724
725 // Valid values.
726 status = GdipSetPenEndCap (pen, LineCapArrowAnchor);
727 assertEqualInt (status, Ok);
728
729 GdipGetPenEndCap (pen, &endCap);
730 assertEqualInt (endCap, LineCapArrowAnchor);
731
732 // Same value.
733 status = GdipSetPenEndCap (pen, LineCapArrowAnchor);
734 assertEqualInt (status, Ok);
735
736 GdipGetPenEndCap (pen, &endCap);
737 assertEqualInt (endCap, LineCapArrowAnchor);
738
739 // Custom values.
740 status = GdipSetPenEndCap (pen, LineCapCustom);
741 assertEqualInt (status, Ok);
742
743 GdipGetPenEndCap (pen, &endCap);
744 assertEqualInt (endCap, LineCapCustom);
745
746 // Set when there is already a custom cap.
747 GdipSetPenCustomEndCap (pen, penCustomLineCap);
748
749 status = GdipSetPenEndCap (pen, LineCapNoAnchor);
750 assertEqualInt (status, Ok);
751
752 status = GdipGetPenCustomEndCap (pen, &customEndCap);
753 assertEqualInt (status, Ok);
754 assert (!customEndCap && "Expected the pen's custom end cap to be cleared.");
755
756 // Invalid values - negative.
757 status = GdipSetPenEndCap (pen, (LineCap)(LineCapFlat - 1));
758 assertEqualInt (status, Ok);
759
760 GdipGetPenEndCap (pen, &endCap);
761 assertEqualInt (endCap, (LineCap)(LineCapFlat - 1));
762
763 // Invalid values - positive.
764 status = GdipSetPenEndCap (pen, (LineCap)(LineCapCustom + 1));
765 assertEqualInt (status, Ok);
766
767 GdipGetPenEndCap (pen, &endCap);
768 assertEqualInt (endCap, (LineCap)(LineCapCustom + 1));
769
770 // Negative tests.
771 status = GdipSetPenEndCap (NULL, LineCapArrowAnchor);
772 assertEqualInt (status, InvalidParameter);
773
774 GdipDeletePen (pen);
775 GdipDeleteCustomLineCap (penCustomLineCap);
776 GdipDeleteCustomLineCap (customEndCap);
777 }
778
test_setPenDashCap197819()779 static void test_setPenDashCap197819 ()
780 {
781 GpStatus status;
782 GpPen *pen;
783 DashCap dashCap;
784
785 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
786
787 // Round.
788 status = GdipSetPenDashCap197819 (pen, DashCapRound);
789 assertEqualInt (status, Ok);
790
791 GdipGetPenDashCap197819 (pen, &dashCap);
792 assertEqualInt (dashCap, DashCapRound);
793
794 // Same value.
795 status = GdipSetPenDashCap197819 (pen, DashCapRound);
796 assertEqualInt (status, Ok);
797
798 GdipGetPenDashCap197819 (pen, &dashCap);
799 assertEqualInt (dashCap, DashCapRound);
800
801 // Triangle.
802 status = GdipSetPenDashCap197819 (pen, DashCapTriangle);
803 assertEqualInt (status, Ok);
804
805 GdipGetPenDashCap197819 (pen, &dashCap);
806 assertEqualInt (dashCap, DashCapTriangle);
807
808 // Flat.
809 status = GdipSetPenDashCap197819 (pen, DashCapFlat);
810 assertEqualInt (status, Ok);
811
812 GdipGetPenDashCap197819 (pen, &dashCap);
813 assertEqualInt (dashCap, DashCapFlat);
814
815 // Invalid values - negative.
816 status = GdipSetPenDashCap197819 (pen, (DashCap)(DashCapFlat - 1));
817 assertEqualInt (status, Ok);
818
819 GdipGetPenDashCap197819 (pen, &dashCap);
820 assertEqualInt (dashCap, DashCapFlat);
821
822 // Invalid values - positive.
823 status = GdipSetPenDashCap197819 (pen, (DashCap)(DashCapTriangle + 1));
824 assertEqualInt (status, Ok);
825
826 GdipGetPenDashCap197819 (pen, &dashCap);
827 assertEqualInt (dashCap, DashCapFlat);
828
829 // Invalid values - one.
830 status = GdipSetPenDashCap197819 (pen, (DashCap)(1));
831 assertEqualInt (status, Ok);
832
833 GdipGetPenDashCap197819 (pen, &dashCap);
834 assertEqualInt (dashCap, DashCapFlat);
835
836 // Negative tests.
837 status = GdipSetPenDashCap197819 (NULL, DashCapFlat);
838 assertEqualInt (status, InvalidParameter);
839
840 GdipDeletePen (pen);
841 }
842
test_getPenStartCap()843 static void test_getPenStartCap ()
844 {
845 GpStatus status;
846 GpPen *pen;
847 LineCap startCap;
848
849 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
850
851 // Negative tests.
852 status = GdipGetPenStartCap (NULL, &startCap);
853 assertEqualInt (status, InvalidParameter);
854
855 status = GdipGetPenStartCap (pen, NULL);
856 assertEqualInt (status, InvalidParameter);
857
858 GdipDeletePen (pen);
859 }
860
test_getPenEndCap()861 static void test_getPenEndCap ()
862 {
863 GpStatus status;
864 GpPen *pen;
865 LineCap endCap;
866
867 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
868
869 // Negative tests.
870 status = GdipGetPenEndCap (NULL, &endCap);
871 assertEqualInt (status, InvalidParameter);
872
873 status = GdipGetPenEndCap (pen, NULL);
874 assertEqualInt (status, InvalidParameter);
875
876 GdipDeletePen (pen);
877 }
878
test_getPenDashCap197819()879 static void test_getPenDashCap197819 ()
880 {
881 GpStatus status;
882 GpPen *pen;
883 DashCap dashCap;
884
885 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
886
887 // Negative tests.
888 status = GdipGetPenDashCap197819 (NULL, &dashCap);
889 assertEqualInt (status, InvalidParameter);
890
891 status = GdipGetPenDashCap197819 (pen, NULL);
892 assertEqualInt (status, InvalidParameter);
893
894 GdipDeletePen (pen);
895 }
896
test_setPenLineJoin()897 static void test_setPenLineJoin ()
898 {
899 GpStatus status;
900 GpPen *pen;
901 LineJoin lineJoin;
902
903 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
904
905 // LineJoinBevel.
906 status = GdipSetPenLineJoin (pen, LineJoinBevel);
907 assertEqualInt (status, Ok);
908
909 status = GdipGetPenLineJoin (pen, &lineJoin);
910 assertEqualInt (status, Ok);
911 assertEqualInt (lineJoin, LineJoinBevel);
912
913 // Same value.
914 status = GdipSetPenLineJoin (pen, LineJoinBevel);
915 assertEqualInt (status, Ok);
916
917 status = GdipGetPenLineJoin (pen, &lineJoin);
918 assertEqualInt (status, Ok);
919 assertEqualInt (lineJoin, LineJoinBevel);
920
921 // Invalid value - negative.
922 status = GdipSetPenLineJoin (pen, (LineJoin)(LineJoinMiter - 1));
923 assertEqualInt (status, Ok);
924
925 status = GdipGetPenLineJoin (pen, &lineJoin);
926 assertEqualInt (status, Ok);
927 assertEqualInt (lineJoin, (LineJoin)(LineJoinMiter - 1));
928
929 // Invalid value - positive.
930 status = GdipSetPenLineJoin (pen, (LineJoin)(LineJoinMiterClipped + 1));
931 assertEqualInt (status, Ok);
932
933 status = GdipGetPenLineJoin (pen, &lineJoin);
934 assertEqualInt (status, Ok);
935 assertEqualInt (lineJoin, (LineJoin)(LineJoinMiterClipped + 1));
936
937 // Negative tests.
938 status = GdipSetPenLineJoin (NULL, LineJoinBevel);
939 assertEqualInt (status, InvalidParameter);
940
941 GdipDeletePen (pen);
942 }
943
test_getPenLineJoin()944 static void test_getPenLineJoin ()
945 {
946 GpStatus status;
947 GpPen *pen;
948 LineJoin lineJoin;
949
950 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
951
952 // Negative tests.
953 status = GdipGetPenLineJoin (NULL, &lineJoin);
954 assertEqualInt (status, InvalidParameter);
955
956 status = GdipGetPenLineJoin (pen, NULL);
957 assertEqualInt (status, InvalidParameter);
958
959 GdipDeletePen (pen);
960 }
961
test_setPenCustomStartCap()962 static void test_setPenCustomStartCap ()
963 {
964 GpStatus status;
965 GpPen *pen;
966 GpPath *path;
967 GpCustomLineCap *penCustomLineCap;
968 GpCustomLineCap *customStartCap;
969 REAL baseInset;
970 LineCap startCap;
971
972 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
973 GdipCreatePath (FillModeAlternate, &path);
974 GdipCreateCustomLineCap (path, NULL, LineCapDiamondAnchor, 10, &penCustomLineCap);
975
976 status = GdipSetPenCustomStartCap (pen, penCustomLineCap);
977 assertEqualInt (status, Ok);
978
979 status = GdipGetPenStartCap (pen, &startCap);
980 assertEqualInt (status, Ok);
981 assertEqualInt (startCap, LineCapCustom);
982
983 status = GdipGetPenCustomStartCap (pen, &customStartCap);
984 assertEqualInt (status, Ok);
985 assert (customStartCap && customStartCap != penCustomLineCap);
986
987 status = GdipGetCustomLineCapBaseInset (customStartCap, &baseInset);
988 assertEqualInt (status, Ok);
989 assertEqualFloat (baseInset, 10);
990
991 // Negative tests.
992 status = GdipSetPenCustomStartCap (NULL, penCustomLineCap);
993 assertEqualInt (status, InvalidParameter);
994
995 status = GdipSetPenCustomStartCap (pen, NULL);
996 assertEqualInt (status, InvalidParameter);
997
998 GdipDeletePen (pen);
999 GdipDeleteCustomLineCap (penCustomLineCap);
1000 GdipDeleteCustomLineCap (customStartCap);
1001 }
1002
test_getPenCustomStartCap()1003 static void test_getPenCustomStartCap ()
1004 {
1005 GpStatus status;
1006 GpPen *pen;
1007 GpCustomLineCap *customStartCap;
1008
1009 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1010
1011 // Negative tests.
1012 status = GdipGetPenCustomStartCap (NULL, &customStartCap);
1013 assertEqualInt (status, InvalidParameter);
1014
1015 status = GdipGetPenCustomStartCap (pen, NULL);
1016 assertEqualInt (status, InvalidParameter);
1017
1018 GdipDeletePen (pen);
1019 }
1020
test_setPenCustomEndCap()1021 static void test_setPenCustomEndCap ()
1022 {
1023 GpStatus status;
1024 GpPen *pen;
1025 GpPath *path;
1026 GpCustomLineCap *penCustomLineCap;
1027 GpCustomLineCap *customEndCap;
1028 REAL baseInset;
1029 LineCap endCap;
1030
1031 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1032 GdipCreatePath (FillModeAlternate, &path);
1033 GdipCreateCustomLineCap (path, NULL, LineCapDiamondAnchor, 10, &penCustomLineCap);
1034
1035 status = GdipSetPenCustomEndCap (pen, penCustomLineCap);
1036 assertEqualInt (status, Ok);
1037
1038 status = GdipGetPenEndCap (pen, &endCap);
1039 assertEqualInt (status, Ok);
1040 assertEqualInt (endCap, LineCapCustom);
1041
1042 status = GdipGetPenCustomEndCap (pen, &customEndCap);
1043 assertEqualInt (status, Ok);
1044 assert (customEndCap && customEndCap != penCustomLineCap);
1045
1046 status = GdipGetCustomLineCapBaseInset (customEndCap, &baseInset);
1047 assertEqualInt (status, Ok);
1048 assertEqualFloat (baseInset, 10);
1049
1050 // Negative tests.
1051 status = GdipSetPenCustomEndCap (NULL, penCustomLineCap);
1052 assertEqualInt (status, InvalidParameter);
1053
1054 status = GdipSetPenCustomEndCap (pen, NULL);
1055 assertEqualInt (status, InvalidParameter);
1056
1057 GdipDeletePen (pen);
1058 GdipDeleteCustomLineCap (penCustomLineCap);
1059 GdipDeleteCustomLineCap (customEndCap);
1060 }
1061
test_getPenCustomEndCap()1062 static void test_getPenCustomEndCap ()
1063 {
1064 GpStatus status;
1065 GpPen *pen;
1066 GpCustomLineCap *customEndCap;
1067
1068 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1069
1070 // Negative tests.
1071 status = GdipGetPenCustomEndCap (NULL, &customEndCap);
1072 assertEqualInt (status, InvalidParameter);
1073
1074 status = GdipGetPenCustomEndCap (pen, NULL);
1075 assertEqualInt (status, InvalidParameter);
1076
1077 GdipDeletePen (pen);
1078 }
1079
test_setPenMiterLimit()1080 static void test_setPenMiterLimit ()
1081 {
1082 GpStatus status;
1083 GpPen *pen;
1084 REAL miterLimit;
1085
1086 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1087
1088 // Positive.
1089 status = GdipSetPenMiterLimit (pen, 100);
1090 assertEqualInt (status, Ok);
1091
1092 status = GdipGetPenMiterLimit (pen, &miterLimit);
1093 assertEqualInt (status, Ok);
1094 assertEqualFloat (miterLimit, 100);
1095
1096 // Same value.
1097 status = GdipSetPenMiterLimit (pen, 100);
1098 assertEqualInt (status, Ok);
1099
1100 status = GdipGetPenMiterLimit (pen, &miterLimit);
1101 assertEqualInt (status, Ok);
1102 assertEqualFloat (miterLimit, 100);
1103
1104 // Zero.
1105 status = GdipSetPenMiterLimit (pen, 0);
1106 assertEqualInt (status, Ok);
1107
1108 status = GdipGetPenMiterLimit (pen, &miterLimit);
1109 assertEqualInt (status, Ok);
1110 assertEqualFloat (miterLimit, 1);
1111
1112 // Negative.
1113 status = GdipSetPenMiterLimit (pen, -100);
1114 assertEqualInt (status, Ok);
1115
1116 status = GdipGetPenMiterLimit (pen, &miterLimit);
1117 assertEqualInt (status, Ok);
1118 assertEqualFloat (miterLimit, 1);
1119
1120 // Negative tests.
1121 status = GdipSetPenMiterLimit (NULL, 10);
1122 assertEqualInt (status, InvalidParameter);
1123
1124 GdipDeletePen (pen);
1125 }
1126
test_getPenMiterLimit()1127 static void test_getPenMiterLimit ()
1128 {
1129 GpStatus status;
1130 GpPen *pen;
1131 REAL miterLimit;
1132
1133 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1134
1135 // Negative tests.
1136 status = GdipGetPenMiterLimit (NULL, &miterLimit);
1137 assertEqualInt (status, InvalidParameter);
1138
1139 status = GdipGetPenMiterLimit (pen, NULL);
1140 assertEqualInt (status, InvalidParameter);
1141
1142 GdipDeletePen (pen);
1143 }
1144
test_getPenTransform()1145 static void test_getPenTransform ()
1146 {
1147 GpStatus status;
1148 GpPen *pen;
1149 GpMatrix *transform;
1150
1151 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1152 GdipCreateMatrix (&transform);
1153
1154 // Negative tests.
1155 status = GdipGetPenTransform (NULL, transform);
1156 assertEqualInt (status, InvalidParameter);
1157
1158 status = GdipGetPenTransform (pen, NULL);
1159 assertEqualInt (status, InvalidParameter);
1160
1161 GdipDeletePen (pen);
1162 GdipDeleteMatrix (transform);
1163 }
1164
test_setPenTransform()1165 static void test_setPenTransform ()
1166 {
1167 GpStatus status;
1168 GpPen *pen;
1169 GpMatrix *matrix;
1170 GpMatrix *transform;
1171
1172 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1173 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &matrix);
1174 GdipCreateMatrix (&transform);
1175
1176 status = GdipSetPenTransform (pen, matrix);
1177 assertEqualInt (status, Ok);
1178
1179 GdipGetPenTransform (pen, transform);
1180 assert (transform != matrix && "Expected new matrix to be a clone.");
1181 verifyMatrix (transform, 1, 2, 3, 4, 5, 6);
1182
1183 // Changing the original transform should not modify the pen's transform.
1184 GdipSetMatrixElements (matrix, 2, 3, 4, 5, 6, 7);
1185 GdipGetPenTransform (pen, transform);
1186 verifyMatrix (transform, 1, 2, 3, 4, 5, 6);
1187
1188 // Negative tests.
1189 status = GdipSetPenTransform (NULL, transform);
1190 assertEqualInt (status, InvalidParameter);
1191
1192 status = GdipSetPenTransform (pen, NULL);
1193 assertEqualInt (status, InvalidParameter);
1194
1195 GdipDeletePen (pen);
1196 GdipDeleteMatrix (matrix);
1197 GdipDeleteMatrix (transform);
1198 }
1199
test_multiplyPenTransform()1200 static void test_multiplyPenTransform ()
1201 {
1202 GpStatus status;
1203 GpPen *pen;
1204 GpMatrix *originalTransform;
1205 GpMatrix *matrix;
1206 GpMatrix *nonInvertibleMatrix;
1207 GpMatrix *transform;
1208
1209 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1210 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &originalTransform);
1211 GdipCreateMatrix2 (2, 3, 4, 5, 6, 7, &matrix);
1212 GdipCreateMatrix2 (123, 24, 82, 16, 47, 30, &nonInvertibleMatrix);
1213 GdipCreateMatrix (&transform);
1214
1215 // MatrixOrderAppend.
1216 GdipSetPenTransform (pen, originalTransform);
1217
1218 status = GdipMultiplyPenTransform (pen, matrix, MatrixOrderAppend);
1219 assertEqualInt (status, Ok);
1220
1221 GdipGetPenTransform (pen, transform);
1222 verifyMatrix (transform, 10, 13, 22, 29, 40, 52);
1223
1224 // MatrixOrderPrepend.
1225 GdipSetPenTransform (pen, originalTransform);
1226
1227 status = GdipMultiplyPenTransform (pen, matrix, MatrixOrderPrepend);
1228 assertEqualInt (status, Ok);
1229
1230 GdipGetPenTransform (pen, transform);
1231 verifyMatrix (transform, 11, 16, 19, 28, 32, 46);
1232
1233 // Null matrix.
1234 status = GdipMultiplyPenTransform (pen, NULL, MatrixOrderAppend);
1235 assertEqualInt (status, Ok);
1236
1237 GdipGetPenTransform (pen, transform);
1238 verifyMatrix (transform, 11, 16, 19, 28, 32, 46);
1239
1240 // Invalid MatrixOrder - negative.
1241 GdipSetPenTransform (pen, originalTransform);
1242
1243 status = GdipMultiplyPenTransform (pen, matrix, (MatrixOrder)(MatrixOrderPrepend - 1));
1244 assertEqualInt (status, Ok);
1245
1246 GdipGetPenTransform (pen, transform);
1247 verifyMatrix (transform, 10, 13, 22, 29, 40, 52);
1248
1249 // Invalid MatrixOrder - positive.
1250 GdipSetPenTransform (pen, originalTransform);
1251
1252 status = GdipMultiplyPenTransform (pen, matrix, (MatrixOrder)(MatrixOrderAppend + 1));
1253 assertEqualInt (status, Ok);
1254
1255 GdipGetPenTransform (pen, transform);
1256 verifyMatrix (transform, 10, 13, 22, 29, 40, 52);
1257
1258 // Negative tests.
1259 status = GdipMultiplyPenTransform (NULL, matrix, MatrixOrderAppend);
1260 assertEqualInt (status, InvalidParameter);
1261
1262 status = GdipMultiplyPenTransform (pen, nonInvertibleMatrix, MatrixOrderAppend);
1263 assertEqualInt (status, InvalidParameter);
1264
1265 GdipDeletePen (pen);
1266 GdipDeleteMatrix (originalTransform);
1267 GdipDeleteMatrix (matrix);
1268 GdipDeleteMatrix (nonInvertibleMatrix);
1269 GdipDeleteMatrix (transform);
1270 }
1271
test_translatePenTransform()1272 static void test_translatePenTransform ()
1273 {
1274 GpStatus status;
1275 GpPen *pen;
1276 GpMatrix *originalTransform;
1277 GpMatrix *transform;
1278
1279 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1280 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &originalTransform);
1281 GdipCreateMatrix (&transform);
1282
1283 // MatrixOrderAppend.
1284 GdipSetPenTransform (pen, originalTransform);
1285
1286 status = GdipTranslatePenTransform (pen, 5, 6, MatrixOrderAppend);
1287 assertEqualInt (status, Ok);
1288
1289 GdipGetPenTransform (pen, transform);
1290 verifyMatrix (transform, 1, 2, 3, 4, 10, 12);
1291
1292 // MatrixOrderPrepend.
1293 GdipSetPenTransform (pen, originalTransform);
1294
1295 status = GdipTranslatePenTransform (pen, 5, 6, MatrixOrderPrepend);
1296 assertEqualInt (status, Ok);
1297
1298 GdipGetPenTransform (pen, transform);
1299 verifyMatrix (transform, 1, 2, 3, 4, 28, 40);
1300
1301 // Negative tests.
1302 status = GdipTranslatePenTransform (NULL, 1, 1, MatrixOrderAppend);
1303 assertEqualInt (status, InvalidParameter);
1304
1305 status = GdipTranslatePenTransform (pen, 1, 1, (MatrixOrder)(MatrixOrderPrepend - 1));
1306 assertEqualInt (status, InvalidParameter);
1307
1308 status = GdipTranslatePenTransform (pen, 1, 1, (MatrixOrder)(MatrixOrderAppend + 1));
1309 assertEqualInt (status, InvalidParameter);
1310
1311 GdipDeletePen (pen);
1312 GdipDeleteMatrix (originalTransform);
1313 GdipDeleteMatrix (transform);
1314 }
1315
test_scalePenTransform()1316 static void test_scalePenTransform ()
1317 {
1318 GpStatus status;
1319 GpPen *pen;
1320 GpMatrix *originalTransform;
1321 GpMatrix *transform;
1322
1323 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1324 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &originalTransform);
1325 GdipCreateMatrix (&transform);
1326
1327 // MatrixOrderAppend.
1328 GdipSetPenTransform (pen, originalTransform);
1329
1330 status = GdipScalePenTransform (pen, 0.5, 0.75, MatrixOrderAppend);
1331 assertEqualInt (status, Ok);
1332
1333 GdipGetPenTransform (pen, transform);
1334 verifyMatrix (transform, 0.5, 1.5, 1.5, 3, 2.5, 4.5);
1335
1336 // MatrixOrderPrepend.
1337 GdipSetPenTransform (pen, originalTransform);
1338
1339 status = GdipScalePenTransform (pen, 0.5, 0.75, MatrixOrderPrepend);
1340 assertEqualInt (status, Ok);
1341
1342 GdipGetPenTransform (pen, transform);
1343 verifyMatrix (transform, 0.5, 1, 2.25, 3, 5, 6);
1344
1345 // Negative tests.
1346 status = GdipScalePenTransform (NULL, 1, 1, MatrixOrderAppend);
1347 assertEqualInt (status, InvalidParameter);
1348
1349 status = GdipScalePenTransform (pen, 1, 1, (MatrixOrder)(MatrixOrderPrepend - 1));
1350 assertEqualInt (status, InvalidParameter);
1351
1352 status = GdipScalePenTransform (pen, 1, 1, (MatrixOrder)(MatrixOrderAppend + 1));
1353 assertEqualInt (status, InvalidParameter);
1354
1355 GdipDeletePen (pen);
1356 GdipDeleteMatrix (originalTransform);
1357 GdipDeleteMatrix (transform);
1358 }
1359
test_rotatePenTransform()1360 static void test_rotatePenTransform ()
1361 {
1362 GpStatus status;
1363 GpPen *pen;
1364 GpMatrix *originalTransform;
1365 GpMatrix *transform;
1366
1367 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1368 GdipCreateMatrix2 (1, 2, 3, 4, 5, 6, &originalTransform);
1369 GdipCreateMatrix (&transform);
1370
1371 // MatrixOrderAppend.
1372 GdipSetPenTransform (pen, originalTransform);
1373
1374 status = GdipRotatePenTransform (pen, 90, MatrixOrderAppend);
1375 assertEqualInt (status, Ok);
1376
1377 GdipGetPenTransform (pen, transform);
1378 verifyMatrix (transform, -2, 1, -4, 3, -6, 5);
1379
1380 // MatrixOrderPrepend.
1381 GdipSetPenTransform (pen, originalTransform);
1382
1383 status = GdipRotatePenTransform (pen, 90, MatrixOrderPrepend);
1384 assertEqualInt (status, Ok);
1385
1386 GdipGetPenTransform (pen, transform);
1387 verifyMatrix (transform, 3, 4, -1, -2, 5, 6);
1388
1389 // Negative tests.
1390 status = GdipRotatePenTransform (NULL, 90, MatrixOrderAppend);
1391 assertEqualInt (status, InvalidParameter);
1392
1393 status = GdipRotatePenTransform (pen, 90, (MatrixOrder)(MatrixOrderPrepend - 1));
1394 assertEqualInt (status, InvalidParameter);
1395
1396 status = GdipRotatePenTransform (pen, 90, (MatrixOrder)(MatrixOrderAppend + 1));
1397 assertEqualInt (status, InvalidParameter);
1398
1399 GdipDeletePen (pen);
1400 GdipDeleteMatrix (originalTransform);
1401 GdipDeleteMatrix (transform);
1402 }
1403
test_setPenMode()1404 static void test_setPenMode ()
1405 {
1406 GpStatus status;
1407 GpPen *pen;
1408 GpPen *compoundArrayPen;
1409 REAL twoCompounds[2] = {1, 1};
1410 PenAlignment mode;
1411
1412 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1413 GdipCreatePen1 (0x00000001, 10, UnitWorld, &compoundArrayPen);
1414 GdipSetPenCompoundArray (compoundArrayPen, twoCompounds, 2);
1415
1416 // Normal pen - PenAlignmentInset.
1417 status = GdipSetPenMode (pen, PenAlignmentInset);
1418 assertEqualInt (status, Ok);
1419
1420 status = GdipGetPenMode (pen, &mode);
1421 assertEqualInt (status, Ok);
1422 assertEqualInt (mode, PenAlignmentInset);
1423
1424 // Normal pen - same mode.
1425 status = GdipSetPenMode (pen, PenAlignmentInset);
1426 assertEqualInt (status, Ok);
1427
1428 status = GdipGetPenMode (pen, &mode);
1429 assertEqualInt (status, Ok);
1430 assertEqualInt (mode, PenAlignmentInset);
1431
1432 // Normal pen - PenAlignmentCenter.
1433 status = GdipSetPenMode (pen, PenAlignmentCenter);
1434 assertEqualInt (status, Ok);
1435
1436 status = GdipGetPenMode (pen, &mode);
1437 assertEqualInt (status, Ok);
1438 assertEqualInt (mode, PenAlignmentCenter);
1439
1440 // Normal pen - negative.
1441 status = GdipSetPenMode (pen, (PenAlignment)(PenAlignmentCenter - 1));
1442 assertEqualInt (status, Ok);
1443
1444 status = GdipGetPenMode (pen, &mode);
1445 assertEqualInt (status, Ok);
1446 assertEqualInt (mode, (PenAlignment)(PenAlignmentCenter - 1));
1447
1448 // Normal pen - positive.
1449 status = GdipSetPenMode (pen, (PenAlignment)(PenAlignmentInset + 1));
1450 assertEqualInt (status, Ok);
1451
1452 status = GdipGetPenMode (pen, &mode);
1453 assertEqualInt (status, Ok);
1454 assertEqualInt (mode, (PenAlignment)(PenAlignmentInset + 1));
1455
1456 // Compound array pen - PenAlignmentCenter.
1457 status = GdipSetPenMode (compoundArrayPen, PenAlignmentCenter);
1458 assertEqualInt (status, Ok);
1459
1460 status = GdipGetPenMode (compoundArrayPen, &mode);
1461 assertEqualInt (status, Ok);
1462 assertEqualInt (mode, PenAlignmentCenter);
1463
1464 // Compound array pen - same mode.
1465 status = GdipSetPenMode (compoundArrayPen, PenAlignmentCenter);
1466 assertEqualInt (status, Ok);
1467
1468 status = GdipGetPenMode (compoundArrayPen, &mode);
1469 assertEqualInt (status, Ok);
1470 assertEqualInt (mode, PenAlignmentCenter);
1471
1472 // Compound array pen - negative.
1473 status = GdipSetPenMode (compoundArrayPen, (PenAlignment)(PenAlignmentCenter - 1));
1474 assertEqualInt (status, Ok);
1475
1476 status = GdipGetPenMode (compoundArrayPen, &mode);
1477 assertEqualInt (status, Ok);
1478 assertEqualInt (mode, (PenAlignment)(PenAlignmentCenter - 1));
1479
1480 // Compound array pen - positive.
1481 status = GdipSetPenMode (compoundArrayPen, (PenAlignment)(PenAlignmentInset + 1));
1482 assertEqualInt (status, Ok);
1483
1484 status = GdipGetPenMode (compoundArrayPen, &mode);
1485 assertEqualInt (status, Ok);
1486 assertEqualInt (mode, (PenAlignment)(PenAlignmentInset + 1));
1487
1488 // Negative tests.
1489 status = GdipSetPenMode (NULL, PenAlignmentCenter);
1490 assertEqualInt (status, InvalidParameter);
1491
1492 status = GdipSetPenMode (compoundArrayPen, PenAlignmentInset);
1493 assertEqualInt (status, NotImplemented);
1494
1495 GdipDeletePen (pen);
1496 GdipDeletePen (compoundArrayPen);
1497 }
1498
test_getPenMode()1499 static void test_getPenMode ()
1500 {
1501 GpStatus status;
1502 GpPen *pen;
1503 PenAlignment mode;
1504
1505 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1506
1507 // Negative tests.
1508 status = GdipGetPenMode (NULL, &mode);
1509 assertEqualInt (status, InvalidParameter);
1510
1511 status = GdipGetPenMode (pen, NULL);
1512 assertEqualInt (status, InvalidParameter);
1513
1514 GdipDeletePen (pen);
1515 }
1516
test_setPenColor()1517 static void test_setPenColor ()
1518 {
1519 GpStatus status;
1520 GpPen *pen;
1521 ARGB color;
1522 GpBrush *brush;
1523 GpBrushType brushType;
1524 GpBrush *hatchBrush;
1525
1526 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1527 GdipCreateHatchBrush (HatchStyle05Percent, 0x00000011, 0x00000022, (GpHatch **) &hatchBrush);
1528
1529 // Solid fill.
1530 status = GdipSetPenColor (pen, 0x01020304);
1531 assertEqualInt (status, Ok);
1532
1533 status = GdipGetPenColor (pen, &color);
1534 assertEqualInt (status, Ok);
1535 assertEqualInt (color, 0x01020304);
1536
1537 status = GdipGetPenBrushFill (pen, &brush);
1538 assertEqualInt (status, Ok);
1539
1540 status = GdipGetBrushType (brush, &brushType);
1541 assertEqualInt (status, Ok);
1542 assertEqualInt (brushType, BrushTypeSolidColor);
1543
1544 status = GdipGetSolidFillColor ((GpSolidFill *) brush, &color);
1545 assertEqualInt (status, Ok);
1546 assertEqualInt (color, 0x01020304);
1547
1548 GdipDeleteBrush (brush);
1549
1550 // Same color.
1551 status = GdipSetPenColor (pen, 0x01020304);
1552 assertEqualInt (status, Ok);
1553
1554 status = GdipGetPenColor (pen, &color);
1555 assertEqualInt (status, Ok);
1556 assertEqualInt (color, 0x01020304);
1557
1558 status = GdipGetPenBrushFill (pen, &brush);
1559 assertEqualInt (status, Ok);
1560
1561 status = GdipGetBrushType (brush, &brushType);
1562 assertEqualInt (status, Ok);
1563 assertEqualInt (brushType, BrushTypeSolidColor);
1564
1565 status = GdipGetSolidFillColor ((GpSolidFill *) brush, &color);
1566 assertEqualInt (status, Ok);
1567 assertEqualInt (color, 0x01020304);
1568
1569 GdipDeleteBrush (brush);
1570
1571 // Different color.
1572 status = GdipSetPenColor (pen, 0x12345678);
1573 assertEqualInt (status, Ok);
1574
1575 status = GdipGetPenColor (pen, &color);
1576 assertEqualInt (status, Ok);
1577 assertEqualInt (color, 0x12345678);
1578
1579 status = GdipGetPenBrushFill (pen, &brush);
1580 assertEqualInt (status, Ok);
1581
1582 status = GdipGetBrushType (brush, &brushType);
1583 assertEqualInt (status, Ok);
1584 assertEqualInt (brushType, BrushTypeSolidColor);
1585
1586 status = GdipGetSolidFillColor ((GpSolidFill *) brush, &color);
1587 assertEqualInt (status, Ok);
1588 assertEqualInt (color, 0x12345678);
1589
1590 GdipDeleteBrush (brush);
1591
1592 // Custom brush - different color.
1593 status = GdipSetPenBrushFill (pen, hatchBrush);
1594 assertEqualInt (status, Ok);
1595
1596 status = GdipSetPenColor (pen, 0x12345678);
1597 assertEqualInt (status, Ok);
1598
1599 status = GdipGetPenColor (pen, &color);
1600 assertEqualInt (status, Ok);
1601 assertEqualInt (color, 0x12345678);
1602
1603 status = GdipGetPenBrushFill (pen, &brush);
1604 assertEqualInt (status, Ok);
1605
1606 status = GdipGetBrushType (brush, &brushType);
1607 assertEqualInt (status, Ok);
1608 assertEqualInt (brushType, BrushTypeSolidColor);
1609
1610 status = GdipGetSolidFillColor ((GpSolidFill *) brush, &color);
1611 assertEqualInt (status, Ok);
1612 assertEqualInt (color, 0x12345678);
1613
1614 GdipDeleteBrush (brush);
1615
1616 // Custom brush - same color.
1617 status = GdipSetPenBrushFill (pen, hatchBrush);
1618 assertEqualInt (status, Ok);
1619
1620 status = GdipSetPenColor (pen, 0x00000011);
1621 assertEqualInt (status, Ok);
1622
1623 status = GdipGetPenColor (pen, &color);
1624 assertEqualInt (status, Ok);
1625 assertEqualInt (color, 0x00000011);
1626
1627 status = GdipGetPenBrushFill (pen, &brush);
1628 assertEqualInt (status, Ok);
1629
1630 status = GdipGetBrushType (brush, &brushType);
1631 assertEqualInt (status, Ok);
1632 assertEqualInt (brushType, BrushTypeSolidColor);
1633
1634 status = GdipGetSolidFillColor ((GpSolidFill *) brush, &color);
1635 assertEqualInt (status, Ok);
1636 assertEqualInt (color, 0x00000011);
1637
1638 GdipDeleteBrush (brush);
1639
1640 // Negative tests.
1641 status = GdipSetPenColor (NULL, 0x01020304);
1642 assertEqualInt (status, InvalidParameter);
1643
1644 GdipDeletePen (pen);
1645 GdipDeleteBrush ((GpBrush *) hatchBrush);
1646 }
1647
test_getPenColor()1648 static void test_getPenColor ()
1649 {
1650 GpStatus status;
1651 GpPen *pen;
1652 ARGB color;
1653
1654 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1655
1656 // Negative tests.
1657 status = GdipGetPenColor (NULL, &color);
1658 assertEqualInt (status, InvalidParameter);
1659
1660 status = GdipGetPenColor (pen, NULL);
1661 assertEqualInt (status, InvalidParameter);
1662
1663 GdipDeletePen (pen);
1664 }
1665
test_getPenFillType()1666 static void test_getPenFillType ()
1667 {
1668 GpStatus status;
1669 GpPen *pen;
1670 PenType type;
1671
1672 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1673
1674 // Negative tests.
1675 status = GdipGetPenFillType (NULL, &type);
1676 assertEqualInt (status, InvalidParameter);
1677
1678 status = GdipGetPenFillType (pen, NULL);
1679 assertEqualInt (status, InvalidParameter);
1680
1681 GdipDeletePen (pen);
1682 }
1683
test_setPenBrushFill()1684 static void test_setPenBrushFill ()
1685 {
1686 GpStatus status;
1687 GpPen *pen;
1688 GpSolidFill *solidBrush;
1689 GpImage *image;
1690 GpTexture *textureBrush;
1691 GpBrush *brush;
1692 ARGB penColor;
1693 ARGB brushColor;
1694 WrapMode brushWrapMode;
1695
1696 image = getImage ();
1697 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1698 GdipCreateSolidFill (100, &solidBrush);
1699 GdipCreateTexture (image, WrapModeTileFlipX, &textureBrush);
1700
1701 // SolidFill.
1702 status = GdipSetPenBrushFill (pen, solidBrush);
1703 assertEqualInt (status, Ok);
1704
1705 status = GdipGetPenBrushFill (pen, &brush);
1706 assertEqualInt (status, Ok);
1707 assert (brush && brush != solidBrush && "Expected new brush to be a clone.");
1708
1709 status = GdipGetPenColor (pen, &penColor);
1710 assertEqualInt (status, Ok);
1711 assertEqualInt (penColor, 100);
1712
1713 status = GdipGetSolidFillColor ((GpSolidFill *) brush, &brushColor);
1714 assertEqualInt (status, Ok);
1715 assertEqualInt (brushColor, 100);
1716 GdipDeleteBrush (brush);
1717
1718 // Non SolidFill.
1719 status = GdipSetPenBrushFill (pen, textureBrush);
1720 assertEqualInt (status, Ok);
1721
1722 status = GdipGetPenBrushFill (pen, &brush);
1723 assertEqualInt (status, Ok);
1724 assert (brush && brush != textureBrush && "Expected new brush to be a clone.");
1725
1726 status = GdipGetTextureWrapMode ((GpTexture *) brush, &brushWrapMode);
1727 assertEqualInt (status, Ok);
1728 assertEqualInt (brushWrapMode, WrapModeTileFlipX);
1729
1730 // Negative tests.
1731 status = GdipSetPenBrushFill (NULL, solidBrush);
1732 assertEqualInt (status, InvalidParameter);
1733
1734 status = GdipSetPenBrushFill (pen, NULL);
1735 assertEqualInt (status, InvalidParameter);
1736
1737 GdipDeletePen (pen);
1738 GdipDeleteBrush ((GpBrush *) solidBrush);
1739 GdipDisposeImage (image);
1740 GdipDeleteBrush ((GpBrush *) textureBrush);
1741 }
1742
test_getPenBrushFill()1743 static void test_getPenBrushFill ()
1744 {
1745 GpStatus status;
1746 GpPen *pen;
1747 GpBrush *brush;
1748
1749 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1750
1751 // Negative tests.
1752 status = GdipGetPenBrushFill (NULL, &brush);
1753 assertEqualInt (status, InvalidParameter);
1754
1755 status = GdipGetPenBrushFill (pen, NULL);
1756 assertEqualInt (status, InvalidParameter);
1757
1758 GdipDeletePen (pen);
1759 }
1760
test_getPenDashStyle()1761 static void test_getPenDashStyle ()
1762 {
1763 GpStatus status;
1764 GpPen *pen;
1765 DashStyle dashStyle;
1766
1767 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1768
1769 // Negative tests.
1770 status = GdipGetPenDashStyle (NULL, &dashStyle);
1771 assertEqualInt (status, InvalidParameter);
1772
1773 status = GdipGetPenDashStyle (pen, NULL);
1774 assertEqualInt (status, InvalidParameter);
1775
1776 GdipDeletePen (pen);
1777 }
1778
test_setPenDashStyle()1779 static void test_setPenDashStyle ()
1780 {
1781 GpStatus status;
1782 GpPen *pen;
1783 DashStyle dashStyle;
1784 REAL dashArray[6];
1785 INT dashCount;
1786
1787 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1788
1789 // DashStyleDashDot.
1790 status = GdipSetPenDashStyle (pen, DashStyleDashDot);
1791 assertEqualInt (status, Ok);
1792
1793 status = GdipGetPenDashStyle (pen, &dashStyle);
1794 assertEqualInt (status, Ok);
1795 assertEqualInt (dashStyle, DashStyleDashDot);
1796
1797 status = GdipGetPenDashCount (pen, &dashCount);
1798 assertEqualInt (status, Ok);
1799 assertEqualInt (dashCount, 4);
1800
1801 status = GdipGetPenDashArray (pen, dashArray, dashCount);
1802 assertEqualInt (status, Ok);
1803 assertEqualFloat (dashArray[0], 3);
1804 assertEqualFloat (dashArray[1], 1);
1805 assertEqualFloat (dashArray[2], 1);
1806 assertEqualFloat (dashArray[3], 1);
1807
1808 // DashStyleSolid.
1809 status = GdipSetPenDashStyle (pen, DashStyleSolid);
1810 assertEqualInt (status, Ok);
1811
1812 status = GdipGetPenDashStyle (pen, &dashStyle);
1813 assertEqualInt (status, Ok);
1814 assertEqualInt (dashStyle, DashStyleSolid);
1815
1816 status = GdipGetPenDashCount (pen, &dashCount);
1817 assertEqualInt (status, Ok);
1818 assertEqualInt (dashCount, 0);
1819
1820 // DashStyleDashDotDot.
1821 status = GdipSetPenDashStyle (pen, DashStyleDashDotDot);
1822 assertEqualInt (status, Ok);
1823
1824 status = GdipGetPenDashStyle (pen, &dashStyle);
1825 assertEqualInt (status, Ok);
1826 assertEqualInt (dashStyle, DashStyleDashDotDot);
1827
1828 status = GdipGetPenDashCount (pen, &dashCount);
1829 assertEqualInt (status, Ok);
1830 assertEqualInt (dashCount, 6);
1831
1832 status = GdipGetPenDashArray (pen, dashArray, dashCount);
1833 assertEqualInt (status, Ok);
1834 assertEqualFloat (dashArray[0], 3);
1835 assertEqualFloat (dashArray[1], 1);
1836 assertEqualFloat (dashArray[2], 1);
1837 assertEqualFloat (dashArray[3], 1);
1838 assertEqualFloat (dashArray[4], 1);
1839 assertEqualFloat (dashArray[5], 1);
1840
1841 // DashStyleDot.
1842 status = GdipSetPenDashStyle (pen, DashStyleDot);
1843 assertEqualInt (status, Ok);
1844
1845 status = GdipGetPenDashStyle (pen, &dashStyle);
1846 assertEqualInt (status, Ok);
1847 assertEqualInt (dashStyle, DashStyleDot);
1848
1849 status = GdipGetPenDashCount (pen, &dashCount);
1850 assertEqualInt (status, Ok);
1851 assertEqualInt (dashCount, 2);
1852
1853 status = GdipGetPenDashArray (pen, dashArray, dashCount);
1854 assertEqualInt (status, Ok);
1855 assertEqualFloat (dashArray[0], 1);
1856 assertEqualFloat (dashArray[1], 1);
1857
1858 // DashStyleDash.
1859 status = GdipSetPenDashStyle (pen, DashStyleDash);
1860 assertEqualInt (status, Ok);
1861
1862 status = GdipGetPenDashStyle (pen, &dashStyle);
1863 assertEqualInt (status, Ok);
1864 assertEqualInt (dashStyle, DashStyleDash);
1865
1866 status = GdipGetPenDashCount (pen, &dashCount);
1867 assertEqualInt (status, Ok);
1868 assertEqualInt (dashCount, 2);
1869
1870 status = GdipGetPenDashArray (pen, dashArray, dashCount);
1871 assertEqualInt (status, Ok);
1872 assertEqualFloat (dashArray[0], 3);
1873 assertEqualFloat (dashArray[1], 1);
1874
1875 // DashStyleCustom.
1876 status = GdipSetPenDashStyle (pen, DashStyleCustom);
1877 assertEqualInt (status, Ok);
1878
1879 status = GdipGetPenDashStyle (pen, &dashStyle);
1880 assertEqualInt (status, Ok);
1881 assertEqualInt (dashStyle, DashStyleCustom);
1882
1883 status = GdipGetPenDashCount (pen, &dashCount);
1884 assertEqualInt (status, Ok);
1885 assertEqualInt (dashCount, 2);
1886
1887 status = GdipGetPenDashArray (pen, dashArray, dashCount);
1888 assertEqualInt (status, Ok);
1889 assertEqualFloat (dashArray[0], 3);
1890 assertEqualFloat (dashArray[1], 1);
1891
1892 // Invalid value - negative.
1893 status = GdipSetPenDashStyle (pen, (DashStyle)(DashStyleSolid - 1));
1894 assertEqualInt (status, Ok);
1895
1896 status = GdipGetPenDashStyle (pen, &dashStyle);
1897 assertEqualInt (status, Ok);
1898 assertEqualInt (dashStyle, DashStyleCustom);
1899
1900 // Invalid value - positive.
1901 status = GdipSetPenDashStyle (pen, (DashStyle)(DashStyleCustom + 1));
1902 assertEqualInt (status, Ok);
1903
1904 status = GdipGetPenDashStyle (pen, &dashStyle);
1905 assertEqualInt (status, Ok);
1906 assertEqualInt (dashStyle, DashStyleCustom);
1907
1908 // Negative tests.
1909 status = GdipSetPenDashStyle (NULL, DashStyleDash);
1910 assertEqualInt (status, InvalidParameter);
1911
1912 GdipDeletePen (pen);
1913 }
1914
test_getPenDashOffset()1915 static void test_getPenDashOffset ()
1916 {
1917 GpStatus status;
1918 GpPen *pen;
1919 REAL dashOffset;
1920
1921 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1922
1923 // Negative tests.
1924 status = GdipGetPenDashOffset (NULL, &dashOffset);
1925 assertEqualInt (status, InvalidParameter);
1926
1927 status = GdipGetPenDashOffset (pen, NULL);
1928 assertEqualInt (status, InvalidParameter);
1929
1930 GdipDeletePen (pen);
1931 }
1932
test_setPenDashOffset()1933 static void test_setPenDashOffset ()
1934 {
1935 GpStatus status;
1936 GpPen *pen;
1937 REAL dashOffset;
1938
1939 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1940
1941 // Positive.
1942 status = GdipSetPenDashOffset (pen, 100);
1943 assertEqualInt (status, Ok);
1944
1945 status = GdipGetPenDashOffset (pen, &dashOffset);
1946 assertEqualInt (status, Ok);
1947 assertEqualFloat (dashOffset, 100);
1948
1949 // Same value.
1950 status = GdipSetPenDashOffset (pen, 100);
1951 assertEqualInt (status, Ok);
1952
1953 status = GdipGetPenDashOffset (pen, &dashOffset);
1954 assertEqualInt (status, Ok);
1955 assertEqualFloat (dashOffset, 100);
1956
1957 // Zero.
1958 status = GdipSetPenDashOffset (pen, 0);
1959 assertEqualInt (status, Ok);
1960
1961 status = GdipGetPenDashOffset (pen, &dashOffset);
1962 assertEqualInt (status, Ok);
1963 assertEqualFloat (dashOffset, 0);
1964
1965 // Negative.
1966 status = GdipSetPenDashOffset (pen, -100);
1967 assertEqualInt (status, Ok);
1968
1969 status = GdipGetPenDashOffset (pen, &dashOffset);
1970 assertEqualInt (status, Ok);
1971 assertEqualFloat (dashOffset, -100);
1972
1973 // Negative tests.
1974 status = GdipSetPenDashOffset (NULL, 100);
1975 assertEqualInt (status, InvalidParameter);
1976
1977 GdipDeletePen (pen);
1978 }
1979
test_getPenDashCount()1980 static void test_getPenDashCount ()
1981 {
1982 GpStatus status;
1983 GpPen *pen;
1984 INT dashCount;
1985
1986 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
1987
1988 // Negative tests.
1989 status = GdipGetPenDashCount (NULL, &dashCount);
1990 assertEqualInt (status, InvalidParameter);
1991
1992 status = GdipGetPenDashCount (pen, NULL);
1993 assertEqualInt (status, InvalidParameter);
1994
1995 GdipDeletePen (pen);
1996 }
1997
test_setPenDashArray()1998 static void test_setPenDashArray ()
1999 {
2000 GpStatus status;
2001 GpPen *pen;
2002 REAL twoDashes[2] = {1, 2};
2003 REAL allZero[2] = {0, 0};
2004 REAL negative[2] = {2, -1};
2005 INT dashCount;
2006 REAL dashes[3];
2007
2008 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
2009
2010 // One dash.
2011 status = GdipSetPenDashArray (pen, twoDashes, 1);
2012 assertEqualInt (status, Ok);
2013
2014 status = GdipGetPenDashCount (pen, &dashCount);
2015 assertEqualInt (status, Ok);
2016 assertEqualInt (dashCount, 1);
2017
2018 status = GdipGetPenDashArray (pen, dashes, dashCount);
2019 assertEqualInt (status, Ok);
2020 assertEqualFloat (dashes[0], 1);
2021
2022 // Two dashes.
2023 status = GdipSetPenDashArray (pen, twoDashes, 2);
2024 assertEqualInt (status, Ok);
2025
2026 status = GdipGetPenDashCount (pen, &dashCount);
2027 assertEqualInt (status, Ok);
2028 assertEqualInt (dashCount, 2);
2029
2030 status = GdipGetPenDashArray (pen, dashes, dashCount);
2031 assertEqualInt (status, Ok);
2032 assertEqualFloat (dashes[0], 1);
2033 assertEqualFloat (dashes[1], 2);
2034
2035 // Negative tests.
2036 status = GdipSetPenDashArray (NULL, twoDashes, 2);
2037 assertEqualInt (status, InvalidParameter);
2038
2039 status = GdipSetPenDashArray (pen, NULL, 2);
2040 assertEqualInt (status, InvalidParameter);
2041
2042 status = GdipSetPenDashArray (pen, allZero, 2);
2043 assertEqualInt (status, InvalidParameter);
2044
2045 status = GdipSetPenDashArray (pen, negative, 2);
2046 assertEqualInt (status, InvalidParameter);
2047
2048 status = GdipSetPenDashArray (pen, dashes, 0);
2049 assertEqualInt (status, InvalidParameter);
2050
2051 status = GdipSetPenDashArray (pen, dashes, -1);
2052 assertEqualInt (status, InvalidParameter);
2053
2054 GdipDeletePen (pen);
2055 }
2056
test_getPenDashArray()2057 static void test_getPenDashArray ()
2058 {
2059 GpStatus status;
2060 GpPen *penWithNoDashes;
2061 GpPen *penWithDashes;
2062 REAL dashes[3] = {0, -1, -2};
2063 REAL penDashes[2] = {1, 2};
2064
2065 GdipCreatePen1 (0x00000001, 10, UnitWorld, &penWithNoDashes);
2066 GdipCreatePen1 (0x00000001, 10, UnitWorld, &penWithDashes);
2067 GdipSetPenDashArray (penWithDashes, penDashes, 2);
2068
2069 // Zero count.
2070 status = GdipGetPenDashArray (penWithDashes, dashes, 0);
2071 assertEqualInt (status, Ok);
2072
2073 // Small count.
2074 status = GdipGetPenDashArray (penWithDashes, dashes, 1);
2075 assertEqualInt (status, Ok);
2076 assertEqualFloat (dashes[0], 1);
2077 assertEqualFloat (dashes[1], -1);
2078 assertEqualFloat (dashes[2], -2);
2079
2080 // Negative tests.
2081 status = GdipGetPenDashArray (NULL, dashes, 2);
2082 assertEqualInt (status, InvalidParameter);
2083
2084 // Negative tests - no dashes.
2085 status = GdipGetPenDashArray (penWithNoDashes, NULL, 2);
2086 assertEqualInt (status, InvalidParameter);
2087
2088 status = GdipGetPenDashArray (penWithNoDashes, NULL, 0);
2089 assertEqualInt (status, InvalidParameter);
2090
2091 status = GdipGetPenDashArray (penWithNoDashes, NULL, -1);
2092 assertEqualInt (status, InvalidParameter);
2093
2094 status = GdipGetPenDashArray (penWithNoDashes, dashes, 0);
2095 assertEqualInt (status, OutOfMemory);
2096
2097 status = GdipGetPenDashArray (penWithNoDashes, dashes, -1);
2098 assertEqualInt (status, OutOfMemory);
2099
2100 status = GdipGetPenDashArray (penWithNoDashes, dashes, 1);
2101 assertEqualInt (status, InvalidParameter);
2102
2103 // Negative tests - has dashes.
2104 status = GdipGetPenDashArray (NULL, dashes, 2);
2105 assertEqualInt (status, InvalidParameter);
2106
2107 status = GdipGetPenDashArray (penWithDashes, dashes, 3);
2108 assertEqualInt (status, InvalidParameter);
2109
2110 // This causes GDI+ to crash.
2111 #if !defined(USE_WINDOWS_GDIPLUS)
2112 status = GdipGetPenDashArray (penWithDashes, dashes, -1);
2113 assertEqualInt (status, OutOfMemory);
2114 #endif
2115
2116 GdipDeletePen (penWithNoDashes);
2117 GdipDeletePen (penWithDashes);
2118 }
2119
test_getPenCompoundCount()2120 static void test_getPenCompoundCount ()
2121 {
2122 GpStatus status;
2123 GpPen *pen;
2124 INT compoundCount;
2125
2126 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
2127
2128 // Negative tests.
2129 status = GdipGetPenCompoundCount (NULL, &compoundCount);
2130 assertEqualInt (status, InvalidParameter);
2131
2132 status = GdipGetPenCompoundCount (pen, NULL);
2133 assertEqualInt (status, InvalidParameter);
2134
2135 GdipDeletePen (pen);
2136 }
2137
test_setPenCompoundArray()2138 static void test_setPenCompoundArray ()
2139 {
2140 GpStatus status;
2141 GpPen *pen;
2142 GpPen *insetPen;
2143 REAL fourCompounds[4] = {1, 1, 1, 1};
2144 REAL allZero[2] = {0, 0};
2145 INT compoundCount;
2146 REAL compounds[6] = {0, 0, 0, 0};
2147 REAL ascendingOrderZeroToOne[6] = {0, 0.2f, 0.2f, 0.4f, 0.5f, 1};
2148 REAL ascendingOrderGreaterThanZeroToLessThanOne[4] = {0.2f, 0.2f, 0.4f, 0.5f};
2149 REAL firstLessThanZero[2] = {-0.01f, 0};
2150 REAL firstGreaterThanOne[2] = {1.01f, 0};
2151 REAL secondLessThanZero[2] = {0, -0.01f};
2152 REAL secondGreaterThanOne[2] = {0, 1.01f};
2153 REAL secondLessThanFirst[2] = {0.5f, 0.4f};
2154 REAL thirdLessThanSecond[4] = {0.5f, 0.6f, 0.5f, 0.7f};
2155
2156 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
2157 GdipCreatePen1 (0x00000001, 10, UnitWorld, &insetPen);
2158 GdipSetPenMode (insetPen, PenAlignmentInset);
2159
2160 // Two compounds - all 1.
2161 status = GdipSetPenCompoundArray (pen, fourCompounds, 2);
2162 assertEqualInt (status, Ok);
2163
2164 status = GdipGetPenCompoundCount (pen, &compoundCount);
2165 assertEqualInt (status, Ok);
2166 assertEqualInt (compoundCount, 2);
2167
2168 status = GdipGetPenCompoundArray (pen, compounds, compoundCount - 1);
2169 assertEqualInt (status, Ok);
2170 assertEqualFloat (compounds[0], 1);
2171 assertEqualFloat (compounds[1], 0);
2172
2173 status = GdipGetPenCompoundArray (pen, compounds, compoundCount);
2174 assertEqualInt (status, Ok);
2175 assertEqualFloat (compounds[0], 1);
2176 assertEqualFloat (compounds[1], 1);
2177
2178 // Two compounds - all 0.
2179 status = GdipSetPenCompoundArray (pen, allZero, 2);
2180 assertEqualInt (status, Ok);
2181
2182 status = GdipGetPenCompoundCount (pen, &compoundCount);
2183 assertEqualInt (status, Ok);
2184 assertEqualInt (compoundCount, 2);
2185
2186 status = GdipGetPenCompoundArray (pen, compounds, compoundCount);
2187 assertEqualInt (status, Ok);
2188 assertEqualFloat (compounds[0], 0);
2189 assertEqualFloat (compounds[1], 0);
2190
2191 // Four compounds - all one.
2192 status = GdipSetPenCompoundArray (pen, fourCompounds, 4);
2193 assertEqualInt (status, Ok);
2194
2195 status = GdipGetPenCompoundCount (pen, &compoundCount);
2196 assertEqualInt (status, Ok);
2197 assertEqualInt (compoundCount, 4);
2198
2199 status = GdipGetPenCompoundArray (pen, compounds, compoundCount);
2200 assertEqualInt (status, Ok);
2201 assertEqualFloat (compounds[0], 1);
2202 assertEqualFloat (compounds[1], 1);
2203 assertEqualFloat (compounds[2], 1);
2204 assertEqualFloat (compounds[3], 1);
2205
2206 // Ascending order from 0 to 1.
2207 status = GdipSetPenCompoundArray (pen, ascendingOrderZeroToOne, 6);
2208 assertEqualInt (status, Ok);
2209
2210 status = GdipGetPenCompoundCount (pen, &compoundCount);
2211 assertEqualInt (status, Ok);
2212 assertEqualInt (compoundCount, 6);
2213
2214 status = GdipGetPenCompoundArray (pen, compounds, compoundCount);
2215 assertEqualInt (status, Ok);
2216 assertEqualFloat (compounds[0], 0);
2217 assertEqualFloat (compounds[1], 0.2f);
2218 assertEqualFloat (compounds[2], 0.2f);
2219 assertEqualFloat (compounds[3], 0.4f);
2220 assertEqualFloat (compounds[4], 0.5f);
2221 assertEqualFloat (compounds[5], 1);
2222
2223 // Ascending order from greater than 0 to less than 1.
2224 status = GdipSetPenCompoundArray (pen, ascendingOrderGreaterThanZeroToLessThanOne, 4);
2225 assertEqualInt (status, Ok);
2226
2227 status = GdipGetPenCompoundCount (pen, &compoundCount);
2228 assertEqualInt (status, Ok);
2229 assertEqualInt (compoundCount, 4);
2230
2231 status = GdipGetPenCompoundArray (pen, compounds, compoundCount);
2232 assertEqualInt (status, Ok);
2233 assertEqualFloat (compounds[0], 0.2f);
2234 assertEqualFloat (compounds[1], 0.2f);
2235 assertEqualFloat (compounds[2], 0.4f);
2236 assertEqualFloat (compounds[3], 0.5f);
2237
2238 // Negative tests.
2239 status = GdipSetPenCompoundArray (NULL, fourCompounds, 2);
2240 assertEqualInt (status, InvalidParameter);
2241
2242 status = GdipSetPenCompoundArray (pen, NULL, 2);
2243 assertEqualInt (status, InvalidParameter);
2244
2245 status = GdipSetPenCompoundArray (pen, fourCompounds, 3);
2246 assertEqualInt (status, InvalidParameter);
2247
2248 status = GdipSetPenCompoundArray (pen, fourCompounds, 1);
2249 assertEqualInt (status, InvalidParameter);
2250
2251 status = GdipSetPenCompoundArray (pen, fourCompounds, 0);
2252 assertEqualInt (status, InvalidParameter);
2253
2254 status = GdipSetPenCompoundArray (pen, fourCompounds, -1);
2255 assertEqualInt (status, InvalidParameter);
2256
2257 status = GdipSetPenCompoundArray (pen, firstLessThanZero, 2);
2258 assertEqualInt (status, InvalidParameter);
2259
2260 status = GdipSetPenCompoundArray (pen, firstGreaterThanOne, 2);
2261 assertEqualInt (status, InvalidParameter);
2262
2263 status = GdipSetPenCompoundArray (pen, secondLessThanZero, 2);
2264 assertEqualInt (status, InvalidParameter);
2265
2266 status = GdipSetPenCompoundArray (pen, secondGreaterThanOne, 2);
2267 assertEqualInt (status, InvalidParameter);
2268
2269 status = GdipSetPenCompoundArray (pen, secondLessThanFirst, 2);
2270 assertEqualInt (status, InvalidParameter);
2271
2272 status = GdipSetPenCompoundArray (pen, thirdLessThanSecond, 4);
2273 assertEqualInt (status, InvalidParameter);
2274
2275 status = GdipSetPenCompoundArray (insetPen, fourCompounds, 2);
2276 assertEqualInt (status, NotImplemented);
2277
2278 status = GdipSetPenCompoundArray (insetPen, firstLessThanZero, 2);
2279 assertEqualInt (status, NotImplemented);
2280
2281 status = GdipSetPenCompoundArray (insetPen, NULL, 2);
2282 assertEqualInt (status, InvalidParameter);
2283
2284 status = GdipSetPenCompoundArray (insetPen, fourCompounds, 0);
2285 assertEqualInt (status, InvalidParameter);
2286
2287 status = GdipSetPenCompoundArray (insetPen, fourCompounds, 1);
2288 assertEqualInt (status, InvalidParameter);
2289
2290 GdipDeletePen (pen);
2291 GdipDeletePen (insetPen);
2292 }
2293
test_getPenCompoundArray()2294 static void test_getPenCompoundArray ()
2295 {
2296 GpStatus status;
2297 GpPen *pen;
2298 REAL compounds[3];
2299 REAL twoCompounds[2] = {1, 1};
2300
2301 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
2302
2303 // Empty compounds.
2304 status = GdipGetPenCompoundArray (pen, compounds, 1);
2305 assertEqualInt (status, InvalidParameter);
2306
2307 status = GdipGetPenCompoundArray (pen, compounds, 0);
2308 assertEqualInt (status, Ok);
2309
2310 status = GdipGetPenCompoundArray (pen, compounds, -1);
2311 assertEqualInt (status, Ok);
2312
2313 // Non-empty compounds.
2314 status = GdipSetPenCompoundArray (pen, twoCompounds, 2);
2315 assertEqualInt (status, Ok);
2316
2317 status = GdipGetPenCompoundArray (pen, compounds, 3);
2318 assertEqualInt (status, InvalidParameter);
2319
2320 status = GdipGetPenCompoundArray (pen, compounds, 0);
2321 assertEqualInt (status, Ok);
2322
2323 status = GdipGetPenCompoundArray (pen, compounds, -1);
2324 assertEqualInt (status, Ok);
2325
2326 GdipDeletePen (pen);
2327
2328 // Negative tests.
2329 GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
2330
2331 status = GdipGetPenCompoundArray (NULL, compounds, 2);
2332 assertEqualInt (status, InvalidParameter);
2333
2334 status = GdipGetPenCompoundArray (NULL, compounds, -1);
2335 assertEqualInt (status, InvalidParameter);
2336
2337 status = GdipGetPenCompoundArray (pen, NULL, 2);
2338 assertEqualInt (status, InvalidParameter);
2339
2340 status = GdipGetPenCompoundArray (pen, NULL, -1);
2341 assertEqualInt (status, InvalidParameter);
2342
2343 status = GdipGetPenCompoundArray (pen, compounds, 1);
2344 assertEqualInt (status, InvalidParameter);
2345 }
2346
test_deletePen()2347 static void test_deletePen ()
2348 {
2349 GpStatus status;
2350 GpPen *pen;
2351
2352 status = GdipCreatePen1 (0x00000001, 10, UnitWorld, &pen);
2353 assertEqualInt (status, Ok);
2354
2355 status = GdipDeletePen (pen);
2356 assertEqualInt (status, Ok);
2357 assert (pen);
2358
2359 // Negative tests.
2360 status = GdipDeletePen (NULL);
2361 assertEqualInt (status, InvalidParameter);
2362 }
2363
2364 int
main(int argc,char ** argv)2365 main (int argc, char**argv)
2366 {
2367 STARTUP;
2368
2369 test_createPen1 ();
2370 test_createPen2 ();
2371 test_clone ();
2372 test_getPenWidth ();
2373 test_setPenWidth ();
2374 test_setPenUnit ();
2375 test_getPenUnit ();
2376 test_setPenLineCap197819 ();
2377 test_setPenStartCap ();
2378 test_setPenEndCap ();
2379 test_setPenDashCap197819 ();
2380 test_getPenStartCap ();
2381 test_getPenEndCap ();
2382 test_getPenDashCap197819 ();
2383 test_setPenLineJoin ();
2384 test_getPenLineJoin ();
2385 test_setPenCustomStartCap ();
2386 test_getPenCustomStartCap ();
2387 test_setPenCustomEndCap ();
2388 test_getPenCustomEndCap ();
2389 test_setPenMiterLimit ();
2390 test_getPenMiterLimit ();
2391 test_setPenMode ();
2392 test_getPenMode ();
2393 test_getPenTransform ();
2394 test_setPenTransform ();
2395 test_multiplyPenTransform ();
2396 test_translatePenTransform ();
2397 test_scalePenTransform ();
2398 test_rotatePenTransform ();
2399 test_setPenColor ();
2400 test_getPenColor ();
2401 test_getPenFillType ();
2402 test_setPenBrushFill ();
2403 test_getPenBrushFill ();
2404 test_getPenDashStyle ();
2405 test_setPenDashStyle ();
2406 test_getPenDashOffset ();
2407 test_setPenDashOffset ();
2408 test_getPenDashCount ();
2409 test_setPenDashArray ();
2410 test_getPenDashArray ();
2411 test_getPenCompoundCount ();
2412 test_setPenCompoundArray ();
2413 test_getPenCompoundArray ();
2414 test_deletePen ();
2415
2416 SHUTDOWN;
2417 return 0;
2418 }
2419