1 /*
2 * Unit test suite for pens (and init)
3 *
4 * Copyright (C) 2007 Google (Evan Stade)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <math.h>
22
23 #include "windows.h"
24 #include "gdiplus.h"
25 #include "wine/test.h"
26
27 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
28 #define expectf(expected, got) ok(fabs(got - expected) < 0.1, "Expected %.2f, got %.2f\n", expected, got)
29
30 static void test_startup(void)
31 {
32 GpPen *pen = NULL;
33 Status status;
34 struct GdiplusStartupInput gdiplusStartupInput;
35 ULONG_PTR gdiplusToken;
36 int gpversion;
37
38 gdiplusStartupInput.DebugEventCallback = NULL;
39 gdiplusStartupInput.SuppressBackgroundThread = 0;
40 gdiplusStartupInput.SuppressExternalCodecs = 0;
41
42 for (gpversion=1; gpversion<256; gpversion++)
43 {
44 gdiplusStartupInput.GdiplusVersion = gpversion;
45 status = GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
46 ok(status == Ok || status == UnsupportedGdiplusVersion,
47 "GdiplusStartup returned %x\n", status);
48 GdiplusShutdown(gdiplusToken);
49 if (status != Ok)
50 {
51 gpversion--;
52 break;
53 }
54 }
55
56 ok(gpversion > 0 && gpversion <= 2, "unexpected gdiplus version %i\n", gpversion);
57 trace("gdiplus version is %i\n", gpversion);
58
59 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
60
61 todo_wine
62 expect(GdiplusNotInitialized, status);
63
64 GdipDeletePen(pen);
65 }
66
67 static void test_constructor_destructor(void)
68 {
69 GpStatus status;
70 GpPen *pen = NULL;
71
72 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, NULL);
73 expect(InvalidParameter, status);
74 ok(pen == NULL, "Expected pen to be NULL\n");
75
76 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
77 expect(Ok, status);
78 ok(pen != NULL, "Expected pen to be initialized\n");
79
80 status = GdipDeletePen(NULL);
81 expect(InvalidParameter, status);
82
83 status = GdipDeletePen(pen);
84 expect(Ok, status);
85 }
86
87 static void test_constructor_destructor2(void)
88 {
89 GpStatus status;
90 GpPen *pen = NULL;
91 GpBrush *brush = NULL;
92 GpPointF points[2];
93
94 status = GdipCreatePen2(NULL, 10.0f, UnitPixel, &pen);
95 expect(InvalidParameter, status);
96 ok(pen == NULL, "Expected pen to be NULL\n");
97
98 points[0].X = 7.0;
99 points[0].Y = 11.0;
100 points[1].X = 13.0;
101 points[1].Y = 17.0;
102
103 status = GdipCreateLineBrush(&points[0], &points[1], (ARGB)0xffff00ff,
104 (ARGB)0xff0000ff, WrapModeTile, (GpLineGradient **)&brush);
105 expect(Ok, status);
106 ok(brush != NULL, "Expected brush to be initialized\n");
107
108 status = GdipCreatePen2(brush, 10.0f, UnitPixel, &pen);
109 expect(Ok, status);
110 ok(pen != NULL, "Expected pen to be initialized\n");
111
112 status = GdipDeletePen(pen);
113 expect(Ok, status);
114
115 status = GdipDeleteBrush(brush);
116 expect(Ok, status);
117 }
118
119 static void test_brushfill(void)
120 {
121 GpStatus status;
122 GpPen *pen;
123 GpBrush *brush, *brush2;
124 GpBrushType type;
125 ARGB color = 0;
126
127 /* default solid */
128 GdipCreatePen1(0xdeadbeef, 4.5, UnitWorld, &pen);
129 status = GdipGetPenBrushFill(pen, &brush);
130 expect(Ok, status);
131 GdipGetBrushType(brush, &type);
132 expect(BrushTypeSolidColor, type);
133 GdipGetPenColor(pen, &color);
134 expect(0xdeadbeef, color);
135 GdipDeleteBrush(brush);
136
137 /* color controlled by brush */
138 GdipCreateSolidFill(0xabaddeed, (GpSolidFill**)&brush);
139 status = GdipSetPenBrushFill(pen, brush);
140 expect(Ok, status);
141 GdipGetPenColor(pen, &color);
142 expect(0xabaddeed, color);
143 GdipDeleteBrush(brush);
144 color = 0;
145
146 /* get returns a clone, not a reference */
147 GdipGetPenBrushFill(pen, &brush);
148 GdipSetSolidFillColor((GpSolidFill*)brush, 0xbeadfeed);
149 GdipGetPenBrushFill(pen, &brush2);
150 ok(brush != brush2, "Expected to get a clone, not a copy of the reference\n");
151 GdipGetSolidFillColor((GpSolidFill*)brush2, &color);
152 expect(0xabaddeed, color);
153 GdipDeleteBrush(brush);
154 GdipDeleteBrush(brush2);
155
156 /* brush cannot be NULL */
157 status = GdipSetPenBrushFill(pen, NULL);
158 expect(InvalidParameter, status);
159
160 GdipDeletePen(pen);
161 }
162
163 static void test_dasharray(void)
164 {
165 GpPen *pen;
166 GpDashStyle style;
167 GpStatus status;
168 REAL dashes[12];
169
170 GdipCreatePen1(0xdeadbeef, 10.0, UnitWorld, &pen);
171 dashes[0] = 10.0;
172 dashes[1] = 11.0;
173 dashes[2] = 12.0;
174 dashes[3] = 13.0;
175 dashes[4] = 14.0;
176 dashes[5] = -100.0;
177 dashes[6] = -100.0;
178 dashes[7] = dashes[8] = dashes[9] = dashes[10] = dashes[11] = 0.0;
179
180 /* setting the array sets the type to custom */
181 GdipGetPenDashStyle(pen, &style);
182 expect(DashStyleSolid, style);
183 status = GdipSetPenDashArray(pen, dashes, 2);
184 expect(Ok, status);
185 GdipGetPenDashStyle(pen, &style);
186 expect(DashStyleCustom, style);
187
188 /* Getting the array on a non-custom pen returns invalid parameter (unless
189 * you are getting 0 elements).*/
190 GdipSetPenDashStyle(pen, DashStyleSolid);
191 status = GdipGetPenDashArray(pen, &dashes[5], 2);
192 expect(InvalidParameter, status);
193 status = GdipGetPenDashArray(pen, &dashes[5], 0);
194 expect(Ok, status);
195
196 /* What does setting DashStyleCustom do to the array length? */
197 GdipSetPenDashArray(pen, dashes, 2);
198 GdipSetPenDashStyle(pen, DashStyleCustom);
199 status = GdipGetPenDashArray(pen, &dashes[5], 2);
200 expect(Ok, status);
201 expectf(10.0, dashes[5]);
202 expectf(11.0, dashes[6]);
203
204 /* Set the array, then get with different sized buffers. */
205 status = GdipSetPenDashArray(pen, dashes, 5);
206 expect(Ok, status);
207 dashes[5] = -100.0;
208 dashes[6] = -100.0;
209 status = GdipGetPenDashArray(pen, &dashes[5], 1);
210 expect(Ok, status); /* not InsufficientBuffer! */
211 expectf(10.0, dashes[5]);
212 expectf(-100.0, dashes[6]);
213 dashes[5] = -100.0;
214 status = GdipGetPenDashArray(pen, &dashes[5], 6);
215 expect(InvalidParameter, status); /* not Ok! */
216 expectf(-100.0, dashes[5]);
217 expectf(-100.0, dashes[6]);
218
219 /* Some invalid array values. */
220 status = GdipSetPenDashArray(pen, &dashes[7], 5);
221 expect(InvalidParameter, status);
222 dashes[9] = -1.0;
223 status = GdipSetPenDashArray(pen, &dashes[7], 5);
224 expect(InvalidParameter, status);
225
226 /* Try to set with count = 0. */
227 GdipSetPenDashStyle(pen, DashStyleDot);
228 status = GdipSetPenDashArray(pen, dashes, 0);
229 ok(status == OutOfMemory || status == InvalidParameter,
230 "Expected OutOfMemory or InvalidParameter, got %.8x\n", status);
231 GdipGetPenDashStyle(pen, &style);
232 expect(DashStyleDot, style);
233
234 GdipDeletePen(pen);
235 }
236
237 static void test_customcap(void)
238 {
239 GpPen *pen;
240 GpStatus status;
241 GpCustomLineCap *custom;
242
243 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
244 expect(Ok, status);
245
246 /* NULL args */
247 status = GdipGetPenCustomStartCap(NULL, NULL);
248 expect(InvalidParameter, status);
249 status = GdipGetPenCustomStartCap(pen, NULL);
250 expect(InvalidParameter, status);
251 status = GdipGetPenCustomStartCap(NULL, &custom);
252 expect(InvalidParameter, status);
253
254 status = GdipGetPenCustomEndCap(NULL, NULL);
255 expect(InvalidParameter, status);
256 status = GdipGetPenCustomEndCap(pen, NULL);
257 expect(InvalidParameter, status);
258 status = GdipGetPenCustomEndCap(NULL, &custom);
259 expect(InvalidParameter, status);
260
261 /* native crashes on pen == NULL, custom != NULL */
262 status = GdipSetPenCustomStartCap(NULL, NULL);
263 expect(InvalidParameter, status);
264 status = GdipSetPenCustomStartCap(pen, NULL);
265 expect(InvalidParameter, status);
266
267 status = GdipSetPenCustomEndCap(NULL, NULL);
268 expect(InvalidParameter, status);
269 status = GdipSetPenCustomEndCap(pen, NULL);
270 expect(InvalidParameter, status);
271
272 /* get without setting previously */
273 custom = (GpCustomLineCap*)0xdeadbeef;
274 status = GdipGetPenCustomEndCap(pen, &custom);
275 expect(Ok, status);
276 ok(custom == NULL,"Expect CustomCap == NULL\n");
277
278 custom = (GpCustomLineCap*)0xdeadbeef;
279 status = GdipGetPenCustomStartCap(pen, &custom);
280 expect(Ok, status);
281 ok(custom == NULL,"Expect CustomCap == NULL\n");
282
283 GdipDeletePen(pen);
284 }
285
286 static void test_penfilltype(void)
287 {
288 GpPen *pen;
289 GpSolidFill *solid;
290 GpLineGradient *line;
291 GpPointF a, b;
292 GpStatus status;
293 GpPenType type;
294
295 /* NULL */
296 status = GdipGetPenFillType(NULL, NULL);
297 expect(InvalidParameter, status);
298
299 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
300 expect(Ok, status);
301 status = GdipGetPenFillType(pen, NULL);
302 expect(InvalidParameter, status);
303
304 /* created with GdipCreatePen1() */
305 status = GdipGetPenFillType(pen, &type);
306 expect(Ok, status);
307 expect(PenTypeSolidColor, type);
308 GdipDeletePen(pen);
309
310 /* based on SolidBrush */
311 status = GdipCreateSolidFill((ARGB)0xffff00ff, &solid);
312 expect(Ok, status);
313 status = GdipCreatePen2((GpBrush*)solid, 10.0f, UnitPixel, &pen);
314 expect(Ok, status);
315 status = GdipGetPenFillType(pen, &type);
316 expect(Ok, status);
317 expect(PenTypeSolidColor, type);
318 GdipDeletePen(pen);
319 GdipDeleteBrush((GpBrush*)solid);
320
321 /* based on LinearGradientBrush */
322 a.X = a.Y = 0.0;
323 b.X = b.Y = 10.0;
324 status = GdipCreateLineBrush(&a, &b, (ARGB)0xffff00ff, (ARGB)0xffff0000,
325 WrapModeTile, &line);
326 expect(Ok, status);
327 status = GdipCreatePen2((GpBrush*)line, 10.0f, UnitPixel, &pen);
328 expect(Ok, status);
329 status = GdipGetPenFillType(pen, &type);
330 expect(Ok, status);
331 expect(PenTypeLinearGradient, type);
332 GdipDeletePen(pen);
333 GdipDeleteBrush((GpBrush*)line);
334 }
335
336 static void test_compoundarray(void)
337 {
338 GpStatus status;
339 GpPen *pen;
340 static const REAL testvalues[] = {0.2, 0.4, 0.6, 0.8};
341
342 status = GdipSetPenCompoundArray(NULL, testvalues, 4);
343 expect(InvalidParameter, status);
344
345 status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
346 expect(Ok, status);
347
348 status = GdipSetPenCompoundArray(pen, NULL, 4);
349 expect(InvalidParameter, status);
350 status = GdipSetPenCompoundArray(pen, testvalues, 3);
351 expect(InvalidParameter, status);
352 status = GdipSetPenCompoundArray(pen, testvalues, 0);
353 expect(InvalidParameter, status);
354 status = GdipSetPenCompoundArray(pen, testvalues, -2);
355 expect(InvalidParameter, status);
356
357 status = GdipSetPenCompoundArray(pen, testvalues, 4);
358 todo_wine expect(Ok, status);
359
360 GdipDeletePen(pen);
361 }
362
363 START_TEST(pen)
364 {
365 struct GdiplusStartupInput gdiplusStartupInput;
366 ULONG_PTR gdiplusToken;
367
368 test_startup();
369
370 gdiplusStartupInput.GdiplusVersion = 1;
371 gdiplusStartupInput.DebugEventCallback = NULL;
372 gdiplusStartupInput.SuppressBackgroundThread = 0;
373 gdiplusStartupInput.SuppressExternalCodecs = 0;
374
375 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
376
377 test_constructor_destructor();
378 test_constructor_destructor2();
379 test_brushfill();
380 test_dasharray();
381 test_customcap();
382 test_penfilltype();
383 test_compoundarray();
384
385 GdiplusShutdown(gdiplusToken);
386 }
387
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.