1 /*
2 * Unit test suite for matrices
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 <stdio.h>
25 #include "gdiplus.h"
26 #include "wine/test.h"
27
28 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
29
30 static void test_constructor_destructor(void)
31 {
32 GpStatus status;
33 GpMatrix *matrix = NULL;
34
35 status = GdipCreateMatrix2(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, &matrix);
36 expect(Ok, status);
37 ok(matrix != NULL, "Expected matrix to be initialized\n");
38
39 status = GdipDeleteMatrix(NULL);
40 expect(InvalidParameter, status);
41
42 status = GdipDeleteMatrix(matrix);
43 expect(Ok, status);
44 }
45
46 typedef struct{
47 REAL X;
48 REAL Y;
49 } real_point;
50
51 static real_point transform_points[] = {
52 {1000.00, 2600.00}, /**/
53 {855.00, 2390.00}, /*1*/
54 {700.00, 2200.00}, /*2*/
55 {565.00, 1970.00}, /*3*/
56 {400.00, 1800.00}, /*4*/
57 {275.00, 1550.00}, /*5*/
58 {100.00, 1400.00}, /*6*/
59 {-15.00, 1130.00}, /*7*/
60 {-200.00, 1000.00}, /*8*/
61 {-305.00, 710.00} /*9*/
62 };
63
64 static void test_transform(void)
65 {
66 GpStatus status;
67 GpMatrix *matrix = NULL;
68 GpPointF pts[10];
69 INT i;
70 BOOL match;
71
72 for(i = 0; i < 10; i ++){
73 pts[i].X = i * 5.0 * (REAL)(i % 2);
74 pts[i].Y = 50.0 - i * 5.0;
75 }
76
77 GdipCreateMatrix2(1.0, -2.0, 30.0, 40.0, -500.0, 600.0, &matrix);
78
79 status = GdipTransformMatrixPoints(matrix, pts, 10);
80 expect(Ok, status);
81
82 for(i = 0; i < 10; i ++){
83 match = fabs(transform_points[i].X - pts[i].X) < 2.0
84 && fabs(transform_points[i].Y - pts[i].Y) < 2.0;
85
86 ok(match, "Expected #%d to be (%.2f, %.2f) but got (%.2f, %.2f)\n", i,
87 transform_points[i].X, transform_points[i].Y, pts[i].X, pts[i].Y);
88 }
89
90 GdipDeleteMatrix(matrix);
91 }
92
93 static void test_isinvertible(void)
94 {
95 GpStatus status;
96 GpMatrix *matrix = NULL;
97 BOOL result;
98
99 /* NULL arguments */
100 status = GdipIsMatrixInvertible(NULL, &result);
101 expect(InvalidParameter, status);
102 status = GdipIsMatrixInvertible((GpMatrix*)0xdeadbeef, NULL);
103 expect(InvalidParameter, status);
104 status = GdipIsMatrixInvertible(NULL, NULL);
105 expect(InvalidParameter, status);
106
107 /* invertible */
108 GdipCreateMatrix2(1.0, 1.2, 2.3, -1.0, 2.0, 3.0, &matrix);
109 status = GdipIsMatrixInvertible(matrix, &result);
110 expect(Ok, status);
111 expect(TRUE, result);
112 GdipDeleteMatrix(matrix);
113
114 /* noninvertible */
115 GdipCreateMatrix2(2.0, -1.0, 6.0, -3.0, 2.2, 3.0, &matrix);
116 status = GdipIsMatrixInvertible(matrix, &result);
117 expect(Ok, status);
118 expect(FALSE, result);
119 GdipDeleteMatrix(matrix);
120 }
121
122 static void test_invert(void)
123 {
124 GpStatus status;
125 GpMatrix *matrix = NULL;
126 GpMatrix *inverted = NULL;
127 BOOL equal = FALSE;
128
129 /* NULL */
130 status = GdipInvertMatrix(NULL);
131 expect(InvalidParameter, status);
132
133 /* noninvertible */
134 GdipCreateMatrix2(2.0, -1.0, 6.0, -3.0, 2.2, 3.0, &matrix);
135 status = GdipInvertMatrix(matrix);
136 expect(InvalidParameter, status);
137 GdipDeleteMatrix(matrix);
138
139 /* invertible */
140 GdipCreateMatrix2(3.0, -2.0, 5.0, 2.0, 6.0, 3.0, &matrix);
141 status = GdipInvertMatrix(matrix);
142 expect(Ok, status);
143 GdipCreateMatrix2(2.0/16.0, 2.0/16.0, -5.0/16.0, 3.0/16.0, 3.0/16.0, -21.0/16.0, &inverted);
144 GdipIsMatrixEqual(matrix, inverted, &equal);
145 expect(TRUE, equal);
146
147 GdipDeleteMatrix(inverted);
148 GdipDeleteMatrix(matrix);
149 }
150
151 static void test_shear(void)
152 {
153 GpStatus status;
154 GpMatrix *matrix = NULL;
155 GpMatrix *sheared = NULL;
156 BOOL equal;
157
158 /* NULL */
159 status = GdipShearMatrix(NULL, 0.0, 0.0, MatrixOrderPrepend);
160 expect(InvalidParameter, status);
161
162 /* X only shearing, MatrixOrderPrepend */
163 GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
164 status = GdipShearMatrix(matrix, 1.5, 0.0, MatrixOrderPrepend);
165 expect(Ok, status);
166 GdipCreateMatrix2(1.0, 2.0, 5.5, 2.0, 6.0, 3.0, &sheared);
167 GdipIsMatrixEqual(matrix, sheared, &equal);
168 expect(TRUE, equal);
169 GdipDeleteMatrix(sheared);
170 GdipDeleteMatrix(matrix);
171
172 /* X only shearing, MatrixOrderAppend */
173 GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
174 status = GdipShearMatrix(matrix, 1.5, 0.0, MatrixOrderAppend);
175 expect(Ok, status);
176 GdipCreateMatrix2(4.0, 2.0, 2.5, -1.0, 10.5, 3.0, &sheared);
177 GdipIsMatrixEqual(matrix, sheared, &equal);
178 expect(TRUE, equal);
179 GdipDeleteMatrix(sheared);
180 GdipDeleteMatrix(matrix);
181
182 /* Y only shearing, MatrixOrderPrepend */
183 GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
184 status = GdipShearMatrix(matrix, 0.0, 1.5, MatrixOrderPrepend);
185 expect(Ok, status);
186 GdipCreateMatrix2(7.0, 0.5, 4.0, -1.0, 6.0, 3.0, &sheared);
187 GdipIsMatrixEqual(matrix, sheared, &equal);
188 expect(TRUE, equal);
189 GdipDeleteMatrix(sheared);
190 GdipDeleteMatrix(matrix);
191
192 /* Y only shearing, MatrixOrderAppend */
193 GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
194 status = GdipShearMatrix(matrix, 0.0, 1.5, MatrixOrderAppend);
195 expect(Ok, status);
196 GdipCreateMatrix2(1.0, 3.5, 4.0, 5.0, 6.0, 12.0, &sheared);
197 GdipIsMatrixEqual(matrix, sheared, &equal);
198 expect(TRUE, equal);
199 GdipDeleteMatrix(sheared);
200 GdipDeleteMatrix(matrix);
201
202 /* X,Y shearing, MatrixOrderPrepend */
203 GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
204 status = GdipShearMatrix(matrix, 4.0, 1.5, MatrixOrderPrepend);
205 expect(Ok, status);
206 GdipCreateMatrix2(7.0, 0.5, 8.0, 7.0, 6.0, 3.0, &sheared);
207 GdipIsMatrixEqual(matrix, sheared, &equal);
208 expect(TRUE, equal);
209 GdipDeleteMatrix(sheared);
210 GdipDeleteMatrix(matrix);
211
212 /* X,Y shearing, MatrixOrderAppend */
213 GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
214 status = GdipShearMatrix(matrix, 4.0, 1.5, MatrixOrderAppend);
215 expect(Ok, status);
216 GdipCreateMatrix2(9.0, 3.5, 0.0, 5.0, 18.0, 12.0, &sheared);
217 GdipIsMatrixEqual(matrix, sheared, &equal);
218 expect(TRUE, equal);
219 GdipDeleteMatrix(sheared);
220 GdipDeleteMatrix(matrix);
221 }
222
223 START_TEST(matrix)
224 {
225 struct GdiplusStartupInput gdiplusStartupInput;
226 ULONG_PTR gdiplusToken;
227
228 gdiplusStartupInput.GdiplusVersion = 1;
229 gdiplusStartupInput.DebugEventCallback = NULL;
230 gdiplusStartupInput.SuppressBackgroundThread = 0;
231 gdiplusStartupInput.SuppressExternalCodecs = 0;
232
233 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
234
235 test_constructor_destructor();
236 test_transform();
237 test_isinvertible();
238 test_invert();
239 test_shear();
240
241 GdiplusShutdown(gdiplusToken);
242 }
243
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.