2 * Unit test suite for brushes
4 * Copyright (C) 2007 Google (Evan Stade)
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/test.h"
26 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
27 #define expectf(expected, got) ok(fabs(expected - got) < 0.0001, "Expected %.2f, got %.2f\n", expected, got)
29 static void test_constructor_destructor(void)
32 GpSolidFill
*brush
= NULL
;
34 status
= GdipCreateSolidFill((ARGB
)0xdeadbeef, &brush
);
36 ok(brush
!= NULL
, "Expected brush to be initialized\n");
38 status
= GdipDeleteBrush(NULL
);
39 expect(InvalidParameter
, status
);
41 status
= GdipDeleteBrush((GpBrush
*) brush
);
45 static void test_type(void)
49 GpSolidFill
*brush
= NULL
;
51 GdipCreateSolidFill((ARGB
)0xdeadbeef, &brush
);
53 status
= GdipGetBrushType((GpBrush
*)brush
, &bt
);
55 expect(BrushTypeSolidColor
, bt
);
57 GdipDeleteBrush((GpBrush
*) brush
);
59 static GpPointF blendcount_ptf
[] = {{0.0, 0.0},
61 static void test_gradientblendcount(void)
64 GpPathGradient
*brush
;
67 status
= GdipCreatePathGradient(blendcount_ptf
, 2, WrapModeClamp
, &brush
);
70 status
= GdipGetPathGradientBlendCount(NULL
, NULL
);
71 expect(InvalidParameter
, status
);
72 status
= GdipGetPathGradientBlendCount(NULL
, &count
);
73 expect(InvalidParameter
, status
);
74 status
= GdipGetPathGradientBlendCount(brush
, NULL
);
75 expect(InvalidParameter
, status
);
77 status
= GdipGetPathGradientBlendCount(brush
, &count
);
81 GdipDeleteBrush((GpBrush
*) brush
);
84 static GpPointF getblend_ptf
[] = {{0.0, 0.0},
86 static void test_getblend(void)
89 GpPathGradient
*brush
;
93 status
= GdipCreatePathGradient(getblend_ptf
, 2, WrapModeClamp
, &brush
);
96 /* check some invalid parameters combinations */
97 status
= GdipGetPathGradientBlend(NULL
, NULL
, NULL
, -1);
98 expect(InvalidParameter
, status
);
99 status
= GdipGetPathGradientBlend(brush
,NULL
, NULL
, -1);
100 expect(InvalidParameter
, status
);
101 status
= GdipGetPathGradientBlend(NULL
, blends
,NULL
, -1);
102 expect(InvalidParameter
, status
);
103 status
= GdipGetPathGradientBlend(NULL
, NULL
, pos
, -1);
104 expect(InvalidParameter
, status
);
105 status
= GdipGetPathGradientBlend(NULL
, NULL
, NULL
, 1);
106 expect(InvalidParameter
, status
);
108 blends
[0] = (REAL
)0xdeadbeef;
109 pos
[0] = (REAL
)0xdeadbeef;
110 status
= GdipGetPathGradientBlend(brush
, blends
, pos
, 1);
112 expectf(1.0, blends
[0]);
113 expectf((REAL
)0xdeadbeef, pos
[0]);
115 GdipDeleteBrush((GpBrush
*) brush
);
118 static GpPointF getbounds_ptf
[] = {{0.0, 20.0},
122 static void test_getbounds(void)
125 GpPathGradient
*brush
;
128 status
= GdipCreatePathGradient(getbounds_ptf
, 4, WrapModeClamp
, &brush
);
131 status
= GdipGetPathGradientRect(NULL
, NULL
);
132 expect(InvalidParameter
, status
);
133 status
= GdipGetPathGradientRect(brush
, NULL
);
134 expect(InvalidParameter
, status
);
135 status
= GdipGetPathGradientRect(NULL
, &bounds
);
136 expect(InvalidParameter
, status
);
138 status
= GdipGetPathGradientRect(brush
, &bounds
);
140 expectf(0.0, bounds
.X
);
141 expectf(20.0, bounds
.Y
);
142 expectf(50.0, bounds
.Width
);
143 expectf(30.0, bounds
.Height
);
145 GdipDeleteBrush((GpBrush
*) brush
);
148 static void test_getgamma(void)
151 GpLineGradient
*line
;
155 start
.X
= start
.Y
= 0.0;
156 end
.X
= end
.Y
= 100.0;
158 status
= GdipCreateLineBrush(&start
, &end
, (ARGB
)0xdeadbeef, 0xdeadbeef, WrapModeTile
, &line
);
162 status
= GdipGetLineGammaCorrection(NULL
, NULL
);
163 expect(InvalidParameter
, status
);
164 status
= GdipGetLineGammaCorrection(line
, NULL
);
165 expect(InvalidParameter
, status
);
166 status
= GdipGetLineGammaCorrection(NULL
, &gamma
);
167 expect(InvalidParameter
, status
);
169 GdipDeleteBrush((GpBrush
*)line
);
172 static void test_transform(void)
176 GpGraphics
*graphics
= NULL
;
182 status
= GdipCreateMatrix2(2.0, 0.0, 0.0, 0.0, 0.0, 0.0, &m
);
185 status
= GdipCreateFromHDC(hdc
, &graphics
);
187 status
= GdipCreateBitmapFromGraphics(1, 1, graphics
, &bitmap
);
190 status
= GdipCreateTexture((GpImage
*)bitmap
, WrapModeTile
, &texture
);
194 status
= GdipGetTextureTransform(NULL
, NULL
);
195 expect(InvalidParameter
, status
);
196 status
= GdipGetTextureTransform(texture
, NULL
);
197 expect(InvalidParameter
, status
);
199 /* get default value - identity matrix */
200 status
= GdipGetTextureTransform(texture
, m
);
202 status
= GdipIsMatrixIdentity(m
, &res
);
205 /* set and get then */
206 status
= GdipCreateMatrix2(2.0, 0.0, 0.0, 2.0, 0.0, 0.0, &m1
);
208 status
= GdipSetTextureTransform(texture
, m1
);
210 status
= GdipGetTextureTransform(texture
, m
);
212 status
= GdipIsMatrixEqual(m
, m1
, &res
);
216 status
= GdipResetTextureTransform(texture
);
218 status
= GdipGetTextureTransform(texture
, m
);
220 status
= GdipIsMatrixIdentity(m
, &res
);
224 status
= GdipDeleteBrush((GpBrush
*)texture
);
227 status
= GdipDeleteMatrix(m1
);
229 status
= GdipDeleteMatrix(m
);
231 status
= GdipDisposeImage((GpImage
*)bitmap
);
233 status
= GdipDeleteGraphics(graphics
);
238 static void test_texturewrap(void)
242 GpGraphics
*graphics
= NULL
;
247 status
= GdipCreateFromHDC(hdc
, &graphics
);
249 status
= GdipCreateBitmapFromGraphics(1, 1, graphics
, &bitmap
);
252 status
= GdipCreateTexture((GpImage
*)bitmap
, WrapModeTile
, &texture
);
256 status
= GdipGetTextureWrapMode(NULL
, NULL
);
257 expect(InvalidParameter
, status
);
258 status
= GdipGetTextureWrapMode(texture
, NULL
);
259 expect(InvalidParameter
, status
);
260 status
= GdipGetTextureWrapMode(NULL
, &wrap
);
261 expect(InvalidParameter
, status
);
264 wrap
= WrapModeClamp
;
265 status
= GdipGetTextureWrapMode(texture
, &wrap
);
267 expect(WrapModeTile
, wrap
);
269 wrap
= WrapModeClamp
;
270 status
= GdipSetTextureWrapMode(texture
, wrap
);
273 status
= GdipGetTextureWrapMode(texture
, &wrap
);
275 expect(WrapModeClamp
, wrap
);
277 status
= GdipDeleteBrush((GpBrush
*)texture
);
279 status
= GdipDisposeImage((GpImage
*)bitmap
);
281 status
= GdipDeleteGraphics(graphics
);
286 static void test_gradientgetrect(void)
288 GpLineGradient
*brush
;
295 status
= GdipCreateMatrix(&transform
);
299 pt2
.X
= pt2
.Y
= 100.0;
300 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
302 memset(&rectf
, 0, sizeof(GpRectF
));
303 status
= GdipGetLineRect(brush
, &rectf
);
305 expectf(1.0, rectf
.X
);
306 expectf(1.0, rectf
.Y
);
307 expectf(99.0, rectf
.Width
);
308 expectf(99.0, rectf
.Height
);
309 status
= GdipGetLineTransform(brush
, transform
);
310 todo_wine
expect(Ok
, status
);
313 status
= GdipGetMatrixElements(transform
, elements
);
315 expectf(1.0, elements
[0]);
316 expectf(1.0, elements
[1]);
317 expectf(-1.0, elements
[2]);
318 expectf(1.0, elements
[3]);
319 expectf(50.50, elements
[4]);
320 expectf(-50.50, elements
[5]);
322 status
= GdipDeleteBrush((GpBrush
*)brush
);
324 /* vertical gradient */
325 pt1
.X
= pt1
.Y
= pt2
.X
= 0.0;
327 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
329 memset(&rectf
, 0, sizeof(GpRectF
));
330 status
= GdipGetLineRect(brush
, &rectf
);
332 expectf(-5.0, rectf
.X
);
333 expectf(0.0, rectf
.Y
);
334 expectf(10.0, rectf
.Width
);
335 expectf(10.0, rectf
.Height
);
336 status
= GdipGetLineTransform(brush
, transform
);
337 todo_wine
expect(Ok
, status
);
340 status
= GdipGetMatrixElements(transform
, elements
);
342 expectf(0.0, elements
[0]);
343 expectf(1.0, elements
[1]);
344 expectf(-1.0, elements
[2]);
345 expectf(0.0, elements
[3]);
346 expectf(5.0, elements
[4]);
347 expectf(5.0, elements
[5]);
349 status
= GdipDeleteBrush((GpBrush
*)brush
);
351 /* horizontal gradient */
352 pt1
.X
= pt1
.Y
= pt2
.Y
= 0.0;
354 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
356 memset(&rectf
, 0, sizeof(GpRectF
));
357 status
= GdipGetLineRect(brush
, &rectf
);
359 expectf(0.0, rectf
.X
);
360 expectf(-5.0, rectf
.Y
);
361 expectf(10.0, rectf
.Width
);
362 expectf(10.0, rectf
.Height
);
363 status
= GdipGetLineTransform(brush
, transform
);
364 todo_wine
expect(Ok
, status
);
367 status
= GdipGetMatrixElements(transform
, elements
);
369 expectf(1.0, elements
[0]);
370 expectf(0.0, elements
[1]);
371 expectf(0.0, elements
[2]);
372 expectf(1.0, elements
[3]);
373 expectf(0.0, elements
[4]);
374 expectf(0.0, elements
[5]);
376 status
= GdipDeleteBrush((GpBrush
*)brush
);
382 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
384 memset(&rectf
, 0, sizeof(GpRectF
));
385 status
= GdipGetLineRect(brush
, &rectf
);
387 expectf(0.0, rectf
.X
);
388 expectf(-20.0, rectf
.Y
);
389 expectf(20.0, rectf
.Width
);
390 expectf(20.0, rectf
.Height
);
391 status
= GdipGetLineTransform(brush
, transform
);
392 todo_wine
expect(Ok
, status
);
395 status
= GdipGetMatrixElements(transform
, elements
);
397 expectf(1.0, elements
[0]);
398 expectf(-1.0, elements
[1]);
399 expectf(1.0, elements
[2]);
400 expectf(1.0, elements
[3]);
401 expectf(10.0, elements
[4]);
402 expectf(10.0, elements
[5]);
404 status
= GdipDeleteBrush((GpBrush
*)brush
);
410 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
412 memset(&rectf
, 0, sizeof(GpRectF
));
413 status
= GdipGetLineRect(brush
, &rectf
);
415 expectf(0.0, rectf
.X
);
416 expectf(0.0, rectf
.Y
);
417 expectf(100.0, rectf
.Width
);
418 expectf(1.0, rectf
.Height
);
419 status
= GdipGetLineTransform(brush
, transform
);
420 todo_wine
expect(Ok
, status
);
423 status
= GdipGetMatrixElements(transform
, elements
);
425 expectf(1.0, elements
[0]);
426 expectf(0.01, elements
[1]);
427 expectf(-0.02, elements
[2]);
428 /* expectf(2.0, elements[3]); */
429 expectf(0.01, elements
[4]);
430 /* expectf(-1.0, elements[5]); */
432 status
= GdipDeleteBrush((GpBrush
*)brush
);
434 /* zero height rect */
435 rectf
.X
= rectf
.Y
= 10.0;
438 status
= GdipCreateLineBrushFromRect(&rectf
, 0, 0, LinearGradientModeVertical
,
439 WrapModeTile
, &brush
);
440 expect(OutOfMemory
, status
);
441 /* zero width rect */
442 rectf
.X
= rectf
.Y
= 10.0;
444 rectf
.Height
= 100.0;
445 status
= GdipCreateLineBrushFromRect(&rectf
, 0, 0, LinearGradientModeHorizontal
,
446 WrapModeTile
, &brush
);
447 expect(OutOfMemory
, status
);
448 /* from rect with LinearGradientModeHorizontal */
449 rectf
.X
= rectf
.Y
= 10.0;
450 rectf
.Width
= rectf
.Height
= 100.0;
451 status
= GdipCreateLineBrushFromRect(&rectf
, 0, 0, LinearGradientModeHorizontal
,
452 WrapModeTile
, &brush
);
454 memset(&rectf
, 0, sizeof(GpRectF
));
455 status
= GdipGetLineRect(brush
, &rectf
);
457 expectf(10.0, rectf
.X
);
458 expectf(10.0, rectf
.Y
);
459 expectf(100.0, rectf
.Width
);
460 expectf(100.0, rectf
.Height
);
461 status
= GdipGetLineTransform(brush
, transform
);
462 todo_wine
expect(Ok
, status
);
465 status
= GdipGetMatrixElements(transform
, elements
);
467 expectf(1.0, elements
[0]);
468 expectf(0.0, elements
[1]);
469 expectf(0.0, elements
[2]);
470 expectf(1.0, elements
[3]);
471 expectf(0.0, elements
[4]);
472 expectf(0.0, elements
[5]);
474 status
= GdipDeleteBrush((GpBrush
*)brush
);
476 /* passing negative Width/Height to LinearGradientModeHorizontal */
477 rectf
.X
= rectf
.Y
= 10.0;
478 rectf
.Width
= rectf
.Height
= -100.0;
479 status
= GdipCreateLineBrushFromRect(&rectf
, 0, 0, LinearGradientModeHorizontal
,
480 WrapModeTile
, &brush
);
482 memset(&rectf
, 0, sizeof(GpRectF
));
483 status
= GdipGetLineRect(brush
, &rectf
);
485 expectf(10.0, rectf
.X
);
486 expectf(10.0, rectf
.Y
);
487 expectf(-100.0, rectf
.Width
);
488 expectf(-100.0, rectf
.Height
);
489 status
= GdipGetLineTransform(brush
, transform
);
490 todo_wine
expect(Ok
, status
);
493 status
= GdipGetMatrixElements(transform
, elements
);
495 expectf(1.0, elements
[0]);
496 expectf(0.0, elements
[1]);
497 expectf(0.0, elements
[2]);
498 expectf(1.0, elements
[3]);
499 expectf(0.0, elements
[4]);
500 expectf(0.0, elements
[5]);
502 status
= GdipDeleteBrush((GpBrush
*)brush
);
505 GdipDeleteMatrix(transform
);
508 static void test_lineblend(void)
510 GpLineGradient
*brush
;
515 const REAL factors
[5] = {0.0f
, 0.1f
, 0.5f
, 0.9f
, 1.0f
};
516 const REAL positions
[5] = {0.0f
, 0.2f
, 0.5f
, 0.8f
, 1.0f
};
517 const REAL two_positions
[2] = {0.0f
, 1.0f
};
518 const ARGB colors
[5] = {0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffffffff};
519 REAL res_factors
[6] = {0.3f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
};
520 REAL res_positions
[6] = {0.3f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
};
521 ARGB res_colors
[6] = {0xdeadbeef, 0, 0, 0, 0};
523 pt1
.X
= pt1
.Y
= pt2
.Y
= pt2
.X
= 1.0;
524 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
525 expect(OutOfMemory
, status
);
528 pt2
.X
= pt2
.Y
= 100.0;
529 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
532 status
= GdipGetLineBlendCount(NULL
, &count
);
533 expect(InvalidParameter
, status
);
535 status
= GdipGetLineBlendCount(brush
, NULL
);
536 expect(InvalidParameter
, status
);
538 status
= GdipGetLineBlendCount(brush
, &count
);
542 status
= GdipGetLineBlend(NULL
, res_factors
, res_positions
, 1);
543 expect(InvalidParameter
, status
);
545 status
= GdipGetLineBlend(brush
, NULL
, res_positions
, 1);
546 expect(InvalidParameter
, status
);
548 status
= GdipGetLineBlend(brush
, res_factors
, NULL
, 1);
549 expect(InvalidParameter
, status
);
551 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 0);
552 expect(InvalidParameter
, status
);
554 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, -1);
555 expect(InvalidParameter
, status
);
557 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 1);
560 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 2);
563 status
= GdipSetLineBlend(NULL
, factors
, positions
, 5);
564 expect(InvalidParameter
, status
);
566 status
= GdipSetLineBlend(brush
, NULL
, positions
, 5);
567 expect(InvalidParameter
, status
);
569 status
= GdipSetLineBlend(brush
, factors
, NULL
, 5);
570 expect(InvalidParameter
, status
);
572 status
= GdipSetLineBlend(brush
, factors
, positions
, 0);
573 expect(InvalidParameter
, status
);
575 status
= GdipSetLineBlend(brush
, factors
, positions
, -1);
576 expect(InvalidParameter
, status
);
578 /* leave off the 0.0 position */
579 status
= GdipSetLineBlend(brush
, &factors
[1], &positions
[1], 4);
580 expect(InvalidParameter
, status
);
582 /* leave off the 1.0 position */
583 status
= GdipSetLineBlend(brush
, factors
, positions
, 4);
584 expect(InvalidParameter
, status
);
586 status
= GdipSetLineBlend(brush
, factors
, positions
, 5);
589 status
= GdipGetLineBlendCount(brush
, &count
);
593 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 4);
594 expect(InsufficientBuffer
, status
);
596 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 5);
601 expectf(factors
[i
], res_factors
[i
]);
602 expectf(positions
[i
], res_positions
[i
]);
605 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 6);
608 status
= GdipSetLineBlend(brush
, factors
, positions
, 1);
611 status
= GdipGetLineBlendCount(brush
, &count
);
615 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 1);
618 status
= GdipGetLinePresetBlendCount(NULL
, &count
);
619 expect(InvalidParameter
, status
);
621 status
= GdipGetLinePresetBlendCount(brush
, NULL
);
622 expect(InvalidParameter
, status
);
624 status
= GdipGetLinePresetBlendCount(brush
, &count
);
628 status
= GdipGetLinePresetBlend(NULL
, res_colors
, res_positions
, 1);
629 expect(InvalidParameter
, status
);
631 status
= GdipGetLinePresetBlend(brush
, NULL
, res_positions
, 1);
632 expect(InvalidParameter
, status
);
634 status
= GdipGetLinePresetBlend(brush
, res_colors
, NULL
, 1);
635 expect(InvalidParameter
, status
);
637 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, 0);
638 expect(InvalidParameter
, status
);
640 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, -1);
641 expect(InvalidParameter
, status
);
643 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, 1);
644 expect(InvalidParameter
, status
);
646 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, 2);
647 expect(GenericError
, status
);
649 status
= GdipSetLinePresetBlend(NULL
, colors
, positions
, 5);
650 expect(InvalidParameter
, status
);
652 status
= GdipSetLinePresetBlend(brush
, NULL
, positions
, 5);
653 expect(InvalidParameter
, status
);
655 status
= GdipSetLinePresetBlend(brush
, colors
, NULL
, 5);
656 expect(InvalidParameter
, status
);
658 status
= GdipSetLinePresetBlend(brush
, colors
, positions
, 0);
659 expect(InvalidParameter
, status
);
661 status
= GdipSetLinePresetBlend(brush
, colors
, positions
, -1);
662 expect(InvalidParameter
, status
);
664 status
= GdipSetLinePresetBlend(brush
, colors
, positions
, 1);
665 expect(InvalidParameter
, status
);
667 /* leave off the 0.0 position */
668 status
= GdipSetLinePresetBlend(brush
, &colors
[1], &positions
[1], 4);
669 expect(InvalidParameter
, status
);
671 /* leave off the 1.0 position */
672 status
= GdipSetLinePresetBlend(brush
, colors
, positions
, 4);
673 expect(InvalidParameter
, status
);
675 status
= GdipSetLinePresetBlend(brush
, colors
, positions
, 5);
678 status
= GdipGetLinePresetBlendCount(brush
, &count
);
682 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, 4);
683 expect(InsufficientBuffer
, status
);
685 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, 5);
690 expect(colors
[i
], res_colors
[i
]);
691 expectf(positions
[i
], res_positions
[i
]);
694 status
= GdipGetLinePresetBlend(brush
, res_colors
, res_positions
, 6);
697 status
= GdipSetLinePresetBlend(brush
, colors
, two_positions
, 2);
700 status
= GdipDeleteBrush((GpBrush
*)brush
);
704 static void test_linelinearblend(void)
706 GpLineGradient
*brush
;
710 REAL res_factors
[3] = {0.3f
};
711 REAL res_positions
[3] = {0.3f
};
713 status
= GdipSetLineLinearBlend(NULL
, 0.6, 0.8);
714 expect(InvalidParameter
, status
);
717 pt2
.X
= pt2
.Y
= 100.0;
718 status
= GdipCreateLineBrush(&pt1
, &pt2
, 0, 0, WrapModeTile
, &brush
);
722 status
= GdipSetLineLinearBlend(brush
, 0.6, 0.8);
725 status
= GdipGetLineBlendCount(brush
, &count
);
729 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 3);
731 expectf(0.0, res_factors
[0]);
732 expectf(0.0, res_positions
[0]);
733 expectf(0.8, res_factors
[1]);
734 expectf(0.6, res_positions
[1]);
735 expectf(0.0, res_factors
[2]);
736 expectf(1.0, res_positions
[2]);
739 status
= GdipSetLineLinearBlend(brush
, 0.0, 0.8);
742 status
= GdipGetLineBlendCount(brush
, &count
);
746 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 3);
748 expectf(0.8, res_factors
[0]);
749 expectf(0.0, res_positions
[0]);
750 expectf(0.0, res_factors
[1]);
751 expectf(1.0, res_positions
[1]);
754 status
= GdipSetLineLinearBlend(brush
, 1.0, 0.8);
757 status
= GdipGetLineBlendCount(brush
, &count
);
761 status
= GdipGetLineBlend(brush
, res_factors
, res_positions
, 3);
763 expectf(0.0, res_factors
[0]);
764 expectf(0.0, res_positions
[0]);
765 expectf(0.8, res_factors
[1]);
766 expectf(1.0, res_positions
[1]);
768 status
= GdipDeleteBrush((GpBrush
*)brush
);
772 static void test_gradientsurroundcolorcount(void)
775 GpPathGradient
*grad
;
779 status
= GdipCreatePathGradient(blendcount_ptf
, 2, WrapModeClamp
, &grad
);
782 color
= GdipAlloc(sizeof(ARGB
[3]));
784 status
= GdipSetPathGradientSurroundColorsWithCount(grad
, color
, &count
);
785 expect(InvalidParameter
, status
);
790 color
= GdipAlloc(sizeof(ARGB
[2]));
792 color
[0] = 0x00ff0000;
793 color
[1] = 0x0000ff00;
795 status
= GdipSetPathGradientSurroundColorsWithCount(NULL
, color
, &count
);
796 expect(InvalidParameter
, status
);
798 status
= GdipSetPathGradientSurroundColorsWithCount(grad
, NULL
, &count
);
799 expect(InvalidParameter
, status
);
801 /* WinXP crashes on this test */
804 status
= GdipSetPathGradientSurroundColorsWithCount(grad
, color
, NULL
);
805 expect(InvalidParameter
, status
);
808 status
= GdipSetPathGradientSurroundColorsWithCount(grad
, color
, &count
);
809 todo_wine
expect(Ok
, status
);
812 status
= GdipGetPathGradientSurroundColorCount(NULL
, &count
);
813 expect(InvalidParameter
, status
);
815 status
= GdipGetPathGradientSurroundColorCount(grad
, NULL
);
816 expect(InvalidParameter
, status
);
819 status
= GdipGetPathGradientSurroundColorCount(grad
, &count
);
820 todo_wine
expect(Ok
, status
);
821 todo_wine
expect(2, count
);
824 GdipDeleteBrush((GpBrush
*)grad
);
829 struct GdiplusStartupInput gdiplusStartupInput
;
830 ULONG_PTR gdiplusToken
;
832 gdiplusStartupInput
.GdiplusVersion
= 1;
833 gdiplusStartupInput
.DebugEventCallback
= NULL
;
834 gdiplusStartupInput
.SuppressBackgroundThread
= 0;
835 gdiplusStartupInput
.SuppressExternalCodecs
= 0;
837 GdiplusStartup(&gdiplusToken
, &gdiplusStartupInput
, NULL
);
839 test_constructor_destructor();
841 test_gradientblendcount();
847 test_gradientgetrect();
849 test_linelinearblend();
850 test_gradientsurroundcolorcount();
852 GdiplusShutdown(gdiplusToken
);