shell32: Fix shlexec crashing on Vista.
[wine] / dlls / gdiplus / tests / brush.c
1 /*
2  * Unit test suite for brushes
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 "windows.h"
22 #include "gdiplus.h"
23 #include "wine/test.h"
24 #include <math.h>
25
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)
28
29 static void test_constructor_destructor(void)
30 {
31     GpStatus status;
32     GpSolidFill *brush = NULL;
33
34     status = GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
35     expect(Ok, status);
36     ok(brush != NULL, "Expected brush to be initialized\n");
37
38     status = GdipDeleteBrush(NULL);
39     expect(InvalidParameter, status);
40
41     status = GdipDeleteBrush((GpBrush*) brush);
42     expect(Ok, status);
43 }
44
45 static void test_type(void)
46 {
47     GpStatus status;
48     GpBrushType bt;
49     GpSolidFill *brush = NULL;
50
51     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
52
53     status = GdipGetBrushType((GpBrush*)brush, &bt);
54     expect(Ok, status);
55     expect(BrushTypeSolidColor, bt);
56
57     GdipDeleteBrush((GpBrush*) brush);
58 }
59 static GpPointF blendcount_ptf[] = {{0.0, 0.0},
60                                     {50.0, 50.0}};
61 static void test_gradientblendcount(void)
62 {
63     GpStatus status;
64     GpPathGradient *brush;
65     INT count;
66
67     status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &brush);
68     expect(Ok, status);
69
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);
76
77     status = GdipGetPathGradientBlendCount(brush, &count);
78     expect(Ok, status);
79     expect(1, count);
80
81     GdipDeleteBrush((GpBrush*) brush);
82 }
83
84 static GpPointF getblend_ptf[] = {{0.0, 0.0},
85                                   {50.0, 50.0}};
86 static void test_getblend(void)
87 {
88     GpStatus status;
89     GpPathGradient *brush;
90     REAL blends[4];
91     REAL pos[4];
92
93     status = GdipCreatePathGradient(getblend_ptf, 2, WrapModeClamp, &brush);
94     expect(Ok, status);
95
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);
107
108     blends[0] = (REAL)0xdeadbeef;
109     pos[0]    = (REAL)0xdeadbeef;
110     status = GdipGetPathGradientBlend(brush, blends, pos, 1);
111     expect(Ok, status);
112     expectf(1.0, blends[0]);
113     expectf((REAL)0xdeadbeef, pos[0]);
114
115     GdipDeleteBrush((GpBrush*) brush);
116 }
117
118 static GpPointF getbounds_ptf[] = {{0.0, 20.0},
119                                    {50.0, 50.0},
120                                    {21.0, 25.0},
121                                    {25.0, 46.0}};
122 static void test_getbounds(void)
123 {
124     GpStatus status;
125     GpPathGradient *brush;
126     GpRectF bounds;
127
128     status = GdipCreatePathGradient(getbounds_ptf, 4, WrapModeClamp, &brush);
129     expect(Ok, status);
130
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);
137
138     status = GdipGetPathGradientRect(brush, &bounds);
139     expect(Ok, status);
140     expectf(0.0, bounds.X);
141     expectf(20.0, bounds.Y);
142     expectf(50.0, bounds.Width);
143     expectf(30.0, bounds.Height);
144
145     GdipDeleteBrush((GpBrush*) brush);
146 }
147
148 START_TEST(brush)
149 {
150     struct GdiplusStartupInput gdiplusStartupInput;
151     ULONG_PTR gdiplusToken;
152
153     gdiplusStartupInput.GdiplusVersion              = 1;
154     gdiplusStartupInput.DebugEventCallback          = NULL;
155     gdiplusStartupInput.SuppressBackgroundThread    = 0;
156     gdiplusStartupInput.SuppressExternalCodecs      = 0;
157
158     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
159
160     test_constructor_destructor();
161     test_type();
162     test_gradientblendcount();
163     test_getblend();
164     test_getbounds();
165
166     GdiplusShutdown(gdiplusToken);
167 }