[GDI32_WINETEST] Sync everything except dib.c with Wine Staging 3.3. CORE-14434
[reactos.git] / modules / rostests / winetests / gdi32 / generated.c
1 /* File generated automatically from tools/winapi/tests.dat; do not edit! */
2 /* This file can be copied, modified and distributed without restriction. */
3
4 /*
5 * Unit tests for data structure packing
6 */
7
8 #ifndef __REACTOS__
9 #define WINVER 0x0501
10 #define _WIN32_IE 0x0501
11 #define _WIN32_WINNT 0x0501
12 #endif
13
14 #define WINE_NOWINSOCK
15
16 #include "windows.h"
17
18 #include "wine/test.h"
19
20 /***********************************************************************
21 * Compatibility macros
22 */
23
24 #define DWORD_PTR UINT_PTR
25 #define LONG_PTR INT_PTR
26 #define ULONG_PTR UINT_PTR
27
28 /***********************************************************************
29 * Windows API extension
30 */
31
32 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
33 # define _TYPE_ALIGNMENT(type) __alignof(type)
34 #elif defined(__GNUC__)
35 # define _TYPE_ALIGNMENT(type) __alignof__(type)
36 #else
37 /*
38 * FIXME: May not be possible without a compiler extension
39 * (if type is not just a name that is, otherwise the normal
40 * TYPE_ALIGNMENT can be used)
41 */
42 #endif
43
44 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
45 #pragma warning(disable:4116)
46 #endif
47
48 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
49 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
50 #endif
51
52 /***********************************************************************
53 * Test helper macros
54 */
55
56 #define TEST_TYPE_SIZE(type, size) C_ASSERT(sizeof(type) == size);
57
58 #ifdef TYPE_ALIGNMENT
59 # define TEST_TYPE_ALIGN(type, align) C_ASSERT(TYPE_ALIGNMENT(type) == align);
60 #else
61 # define TEST_TYPE_ALIGN(type, align)
62 #endif
63
64 #ifdef _TYPE_ALIGNMENT
65 # define TEST_TARGET_ALIGN(type, align) C_ASSERT(_TYPE_ALIGNMENT(*(type)0) == align);
66 # define TEST_FIELD_ALIGN(type, field, align) C_ASSERT(_TYPE_ALIGNMENT(((type*)0)->field) == align);
67 #else
68 # define TEST_TARGET_ALIGN(type, align)
69 # define TEST_FIELD_ALIGN(type, field, align)
70 #endif
71
72 #define TEST_FIELD_OFFSET(type, field, offset) C_ASSERT(FIELD_OFFSET(type, field) == offset);
73
74 #define TEST_TARGET_SIZE(type, size) TEST_TYPE_SIZE(*(type)0, size)
75 #define TEST_FIELD_SIZE(type, field, size) TEST_TYPE_SIZE((((type*)0)->field), size)
76 #define TEST_TYPE_SIGNED(type) C_ASSERT((type) -1 < 0);
77 #define TEST_TYPE_UNSIGNED(type) C_ASSERT((type) -1 > 0);
78
79
80 #ifdef _WIN64
81
82 static void test_pack_ABC(void)
83 {
84 /* ABC */
85 TEST_TYPE_SIZE (ABC, 12)
86 TEST_TYPE_ALIGN (ABC, 4)
87 TEST_FIELD_SIZE (ABC, abcA, 4)
88 TEST_FIELD_ALIGN (ABC, abcA, 4)
89 TEST_FIELD_OFFSET(ABC, abcA, 0)
90 TEST_FIELD_SIZE (ABC, abcB, 4)
91 TEST_FIELD_ALIGN (ABC, abcB, 4)
92 TEST_FIELD_OFFSET(ABC, abcB, 4)
93 TEST_FIELD_SIZE (ABC, abcC, 4)
94 TEST_FIELD_ALIGN (ABC, abcC, 4)
95 TEST_FIELD_OFFSET(ABC, abcC, 8)
96 }
97
98 static void test_pack_ABCFLOAT(void)
99 {
100 /* ABCFLOAT */
101 TEST_TYPE_SIZE (ABCFLOAT, 12)
102 TEST_TYPE_ALIGN (ABCFLOAT, 4)
103 TEST_FIELD_SIZE (ABCFLOAT, abcfA, 4)
104 TEST_FIELD_ALIGN (ABCFLOAT, abcfA, 4)
105 TEST_FIELD_OFFSET(ABCFLOAT, abcfA, 0)
106 TEST_FIELD_SIZE (ABCFLOAT, abcfB, 4)
107 TEST_FIELD_ALIGN (ABCFLOAT, abcfB, 4)
108 TEST_FIELD_OFFSET(ABCFLOAT, abcfB, 4)
109 TEST_FIELD_SIZE (ABCFLOAT, abcfC, 4)
110 TEST_FIELD_ALIGN (ABCFLOAT, abcfC, 4)
111 TEST_FIELD_OFFSET(ABCFLOAT, abcfC, 8)
112 }
113
114 static void test_pack_ABORTPROC(void)
115 {
116 /* ABORTPROC */
117 TEST_TYPE_SIZE (ABORTPROC, 8)
118 TEST_TYPE_ALIGN (ABORTPROC, 8)
119 }
120
121 static void test_pack_BITMAP(void)
122 {
123 /* BITMAP */
124 TEST_TYPE_SIZE (BITMAP, 32)
125 TEST_TYPE_ALIGN (BITMAP, 8)
126 TEST_FIELD_SIZE (BITMAP, bmType, 4)
127 TEST_FIELD_ALIGN (BITMAP, bmType, 4)
128 TEST_FIELD_OFFSET(BITMAP, bmType, 0)
129 TEST_FIELD_SIZE (BITMAP, bmWidth, 4)
130 TEST_FIELD_ALIGN (BITMAP, bmWidth, 4)
131 TEST_FIELD_OFFSET(BITMAP, bmWidth, 4)
132 TEST_FIELD_SIZE (BITMAP, bmHeight, 4)
133 TEST_FIELD_ALIGN (BITMAP, bmHeight, 4)
134 TEST_FIELD_OFFSET(BITMAP, bmHeight, 8)
135 TEST_FIELD_SIZE (BITMAP, bmWidthBytes, 4)
136 TEST_FIELD_ALIGN (BITMAP, bmWidthBytes, 4)
137 TEST_FIELD_OFFSET(BITMAP, bmWidthBytes, 12)
138 TEST_FIELD_SIZE (BITMAP, bmPlanes, 2)
139 TEST_FIELD_ALIGN (BITMAP, bmPlanes, 2)
140 TEST_FIELD_OFFSET(BITMAP, bmPlanes, 16)
141 TEST_FIELD_SIZE (BITMAP, bmBitsPixel, 2)
142 TEST_FIELD_ALIGN (BITMAP, bmBitsPixel, 2)
143 TEST_FIELD_OFFSET(BITMAP, bmBitsPixel, 18)
144 TEST_FIELD_SIZE (BITMAP, bmBits, 8)
145 TEST_FIELD_ALIGN (BITMAP, bmBits, 8)
146 TEST_FIELD_OFFSET(BITMAP, bmBits, 24)
147 }
148
149 static void test_pack_BITMAPCOREHEADER(void)
150 {
151 /* BITMAPCOREHEADER */
152 TEST_TYPE_SIZE (BITMAPCOREHEADER, 12)
153 TEST_TYPE_ALIGN (BITMAPCOREHEADER, 4)
154 TEST_FIELD_SIZE (BITMAPCOREHEADER, bcSize, 4)
155 TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcSize, 4)
156 TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcSize, 0)
157 TEST_FIELD_SIZE (BITMAPCOREHEADER, bcWidth, 2)
158 TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcWidth, 2)
159 TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcWidth, 4)
160 TEST_FIELD_SIZE (BITMAPCOREHEADER, bcHeight, 2)
161 TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcHeight, 2)
162 TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcHeight, 6)
163 TEST_FIELD_SIZE (BITMAPCOREHEADER, bcPlanes, 2)
164 TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcPlanes, 2)
165 TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcPlanes, 8)
166 TEST_FIELD_SIZE (BITMAPCOREHEADER, bcBitCount, 2)
167 TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcBitCount, 2)
168 TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcBitCount, 10)
169 }
170
171 static void test_pack_BITMAPCOREINFO(void)
172 {
173 /* BITMAPCOREINFO */
174 TEST_TYPE_SIZE (BITMAPCOREINFO, 16)
175 TEST_TYPE_ALIGN (BITMAPCOREINFO, 4)
176 TEST_FIELD_SIZE (BITMAPCOREINFO, bmciHeader, 12)
177 TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciHeader, 4)
178 TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciHeader, 0)
179 TEST_FIELD_SIZE (BITMAPCOREINFO, bmciColors, 3)
180 TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciColors, 1)
181 TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciColors, 12)
182 }
183
184 static void test_pack_BITMAPFILEHEADER(void)
185 {
186 /* BITMAPFILEHEADER (pack 2) */
187 TEST_TYPE_SIZE (BITMAPFILEHEADER, 14)
188 TEST_TYPE_ALIGN (BITMAPFILEHEADER, 2)
189 TEST_FIELD_SIZE (BITMAPFILEHEADER, bfType, 2)
190 TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfType, 2)
191 TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfType, 0)
192 TEST_FIELD_SIZE (BITMAPFILEHEADER, bfSize, 4)
193 TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfSize, 2)
194 TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfSize, 2)
195 TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved1, 2)
196 TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved1, 2)
197 TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved1, 6)
198 TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved2, 2)
199 TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved2, 2)
200 TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved2, 8)
201 TEST_FIELD_SIZE (BITMAPFILEHEADER, bfOffBits, 4)
202 TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfOffBits, 2)
203 TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfOffBits, 10)
204 }
205
206 static void test_pack_BITMAPINFO(void)
207 {
208 /* BITMAPINFO */
209 TEST_TYPE_SIZE (BITMAPINFO, 44)
210 TEST_TYPE_ALIGN (BITMAPINFO, 4)
211 TEST_FIELD_SIZE (BITMAPINFO, bmiHeader, 40)
212 TEST_FIELD_ALIGN (BITMAPINFO, bmiHeader, 4)
213 TEST_FIELD_OFFSET(BITMAPINFO, bmiHeader, 0)
214 TEST_FIELD_SIZE (BITMAPINFO, bmiColors, 4)
215 TEST_FIELD_ALIGN (BITMAPINFO, bmiColors, 1)
216 TEST_FIELD_OFFSET(BITMAPINFO, bmiColors, 40)
217 }
218
219 static void test_pack_BITMAPINFOHEADER(void)
220 {
221 /* BITMAPINFOHEADER */
222 TEST_TYPE_SIZE (BITMAPINFOHEADER, 40)
223 TEST_TYPE_ALIGN (BITMAPINFOHEADER, 4)
224 TEST_FIELD_SIZE (BITMAPINFOHEADER, biSize, 4)
225 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSize, 4)
226 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSize, 0)
227 TEST_FIELD_SIZE (BITMAPINFOHEADER, biWidth, 4)
228 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biWidth, 4)
229 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biWidth, 4)
230 TEST_FIELD_SIZE (BITMAPINFOHEADER, biHeight, 4)
231 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biHeight, 4)
232 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biHeight, 8)
233 TEST_FIELD_SIZE (BITMAPINFOHEADER, biPlanes, 2)
234 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biPlanes, 2)
235 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biPlanes, 12)
236 TEST_FIELD_SIZE (BITMAPINFOHEADER, biBitCount, 2)
237 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biBitCount, 2)
238 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biBitCount, 14)
239 TEST_FIELD_SIZE (BITMAPINFOHEADER, biCompression, 4)
240 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biCompression, 4)
241 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biCompression, 16)
242 TEST_FIELD_SIZE (BITMAPINFOHEADER, biSizeImage, 4)
243 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSizeImage, 4)
244 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSizeImage, 20)
245 TEST_FIELD_SIZE (BITMAPINFOHEADER, biXPelsPerMeter, 4)
246 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biXPelsPerMeter, 4)
247 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biXPelsPerMeter, 24)
248 TEST_FIELD_SIZE (BITMAPINFOHEADER, biYPelsPerMeter, 4)
249 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biYPelsPerMeter, 4)
250 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biYPelsPerMeter, 28)
251 TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrUsed, 4)
252 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrUsed, 4)
253 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrUsed, 32)
254 TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrImportant, 4)
255 TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrImportant, 4)
256 TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrImportant, 36)
257 }
258
259 static void test_pack_BITMAPV4HEADER(void)
260 {
261 /* BITMAPV4HEADER */
262 TEST_TYPE_SIZE (BITMAPV4HEADER, 108)
263 TEST_TYPE_ALIGN (BITMAPV4HEADER, 4)
264 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Size, 4)
265 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Size, 4)
266 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Size, 0)
267 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Width, 4)
268 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Width, 4)
269 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Width, 4)
270 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Height, 4)
271 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Height, 4)
272 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Height, 8)
273 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Planes, 2)
274 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Planes, 2)
275 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Planes, 12)
276 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BitCount, 2)
277 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BitCount, 2)
278 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BitCount, 14)
279 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4V4Compression, 4)
280 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4V4Compression, 4)
281 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4V4Compression, 16)
282 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4SizeImage, 4)
283 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4SizeImage, 4)
284 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4SizeImage, 20)
285 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4XPelsPerMeter, 4)
286 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4XPelsPerMeter, 4)
287 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4XPelsPerMeter, 24)
288 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4YPelsPerMeter, 4)
289 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4YPelsPerMeter, 4)
290 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4YPelsPerMeter, 28)
291 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrUsed, 4)
292 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrUsed, 4)
293 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrUsed, 32)
294 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrImportant, 4)
295 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrImportant, 4)
296 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrImportant, 36)
297 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4RedMask, 4)
298 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4RedMask, 4)
299 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4RedMask, 40)
300 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GreenMask, 4)
301 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GreenMask, 4)
302 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GreenMask, 44)
303 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BlueMask, 4)
304 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BlueMask, 4)
305 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BlueMask, 48)
306 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4AlphaMask, 4)
307 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4AlphaMask, 4)
308 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4AlphaMask, 52)
309 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4CSType, 4)
310 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4CSType, 4)
311 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4CSType, 56)
312 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Endpoints, 36)
313 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Endpoints, 4)
314 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Endpoints, 60)
315 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaRed, 4)
316 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaRed, 4)
317 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaRed, 96)
318 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaGreen, 4)
319 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaGreen, 4)
320 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaGreen, 100)
321 TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaBlue, 4)
322 TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaBlue, 4)
323 TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaBlue, 104)
324 }
325
326 static void test_pack_BITMAPV5HEADER(void)
327 {
328 /* BITMAPV5HEADER */
329 TEST_TYPE_SIZE (BITMAPV5HEADER, 124)
330 TEST_TYPE_ALIGN (BITMAPV5HEADER, 4)
331 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Size, 4)
332 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Size, 4)
333 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Size, 0)
334 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Width, 4)
335 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Width, 4)
336 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Width, 4)
337 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Height, 4)
338 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Height, 4)
339 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Height, 8)
340 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Planes, 2)
341 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Planes, 2)
342 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Planes, 12)
343 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BitCount, 2)
344 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BitCount, 2)
345 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BitCount, 14)
346 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Compression, 4)
347 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Compression, 4)
348 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Compression, 16)
349 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5SizeImage, 4)
350 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5SizeImage, 4)
351 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5SizeImage, 20)
352 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5XPelsPerMeter, 4)
353 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5XPelsPerMeter, 4)
354 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5XPelsPerMeter, 24)
355 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5YPelsPerMeter, 4)
356 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5YPelsPerMeter, 4)
357 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5YPelsPerMeter, 28)
358 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrUsed, 4)
359 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrUsed, 4)
360 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrUsed, 32)
361 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrImportant, 4)
362 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrImportant, 4)
363 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrImportant, 36)
364 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5RedMask, 4)
365 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5RedMask, 4)
366 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5RedMask, 40)
367 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GreenMask, 4)
368 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GreenMask, 4)
369 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GreenMask, 44)
370 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BlueMask, 4)
371 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BlueMask, 4)
372 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BlueMask, 48)
373 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5AlphaMask, 4)
374 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5AlphaMask, 4)
375 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5AlphaMask, 52)
376 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5CSType, 4)
377 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5CSType, 4)
378 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5CSType, 56)
379 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Endpoints, 36)
380 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Endpoints, 4)
381 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Endpoints, 60)
382 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaRed, 4)
383 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaRed, 4)
384 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaRed, 96)
385 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaGreen, 4)
386 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaGreen, 4)
387 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaGreen, 100)
388 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaBlue, 4)
389 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaBlue, 4)
390 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaBlue, 104)
391 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Intent, 4)
392 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Intent, 4)
393 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Intent, 108)
394 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileData, 4)
395 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileData, 4)
396 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileData, 112)
397 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileSize, 4)
398 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileSize, 4)
399 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileSize, 116)
400 TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Reserved, 4)
401 TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Reserved, 4)
402 TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Reserved, 120)
403 }
404
405 static void test_pack_BLENDFUNCTION(void)
406 {
407 /* BLENDFUNCTION */
408 TEST_TYPE_SIZE (BLENDFUNCTION, 4)
409 TEST_TYPE_ALIGN (BLENDFUNCTION, 1)
410 TEST_FIELD_SIZE (BLENDFUNCTION, BlendOp, 1)
411 TEST_FIELD_ALIGN (BLENDFUNCTION, BlendOp, 1)
412 TEST_FIELD_OFFSET(BLENDFUNCTION, BlendOp, 0)
413 TEST_FIELD_SIZE (BLENDFUNCTION, BlendFlags, 1)
414 TEST_FIELD_ALIGN (BLENDFUNCTION, BlendFlags, 1)
415 TEST_FIELD_OFFSET(BLENDFUNCTION, BlendFlags, 1)
416 TEST_FIELD_SIZE (BLENDFUNCTION, SourceConstantAlpha, 1)
417 TEST_FIELD_ALIGN (BLENDFUNCTION, SourceConstantAlpha, 1)
418 TEST_FIELD_OFFSET(BLENDFUNCTION, SourceConstantAlpha, 2)
419 TEST_FIELD_SIZE (BLENDFUNCTION, AlphaFormat, 1)
420 TEST_FIELD_ALIGN (BLENDFUNCTION, AlphaFormat, 1)
421 TEST_FIELD_OFFSET(BLENDFUNCTION, AlphaFormat, 3)
422 }
423
424 static void test_pack_CHARSETINFO(void)
425 {
426 /* CHARSETINFO */
427 TEST_TYPE_SIZE (CHARSETINFO, 32)
428 TEST_TYPE_ALIGN (CHARSETINFO, 4)
429 TEST_FIELD_SIZE (CHARSETINFO, ciCharset, 4)
430 TEST_FIELD_ALIGN (CHARSETINFO, ciCharset, 4)
431 TEST_FIELD_OFFSET(CHARSETINFO, ciCharset, 0)
432 TEST_FIELD_SIZE (CHARSETINFO, ciACP, 4)
433 TEST_FIELD_ALIGN (CHARSETINFO, ciACP, 4)
434 TEST_FIELD_OFFSET(CHARSETINFO, ciACP, 4)
435 TEST_FIELD_SIZE (CHARSETINFO, fs, 24)
436 TEST_FIELD_ALIGN (CHARSETINFO, fs, 4)
437 TEST_FIELD_OFFSET(CHARSETINFO, fs, 8)
438 }
439
440 static void test_pack_CIEXYZ(void)
441 {
442 /* CIEXYZ */
443 TEST_TYPE_SIZE (CIEXYZ, 12)
444 TEST_TYPE_ALIGN (CIEXYZ, 4)
445 TEST_FIELD_SIZE (CIEXYZ, ciexyzX, 4)
446 TEST_FIELD_ALIGN (CIEXYZ, ciexyzX, 4)
447 TEST_FIELD_OFFSET(CIEXYZ, ciexyzX, 0)
448 TEST_FIELD_SIZE (CIEXYZ, ciexyzY, 4)
449 TEST_FIELD_ALIGN (CIEXYZ, ciexyzY, 4)
450 TEST_FIELD_OFFSET(CIEXYZ, ciexyzY, 4)
451 TEST_FIELD_SIZE (CIEXYZ, ciexyzZ, 4)
452 TEST_FIELD_ALIGN (CIEXYZ, ciexyzZ, 4)
453 TEST_FIELD_OFFSET(CIEXYZ, ciexyzZ, 8)
454 }
455
456 static void test_pack_CIEXYZTRIPLE(void)
457 {
458 /* CIEXYZTRIPLE */
459 TEST_TYPE_SIZE (CIEXYZTRIPLE, 36)
460 TEST_TYPE_ALIGN (CIEXYZTRIPLE, 4)
461 TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzRed, 12)
462 TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzRed, 4)
463 TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzRed, 0)
464 TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzGreen, 12)
465 TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzGreen, 4)
466 TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzGreen, 12)
467 TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzBlue, 12)
468 TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzBlue, 4)
469 TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzBlue, 24)
470 }
471
472 static void test_pack_COLOR16(void)
473 {
474 /* COLOR16 */
475 TEST_TYPE_SIZE (COLOR16, 2)
476 TEST_TYPE_ALIGN (COLOR16, 2)
477 }
478
479 static void test_pack_COLORADJUSTMENT(void)
480 {
481 /* COLORADJUSTMENT */
482 TEST_TYPE_SIZE (COLORADJUSTMENT, 24)
483 TEST_TYPE_ALIGN (COLORADJUSTMENT, 2)
484 TEST_FIELD_SIZE (COLORADJUSTMENT, caSize, 2)
485 TEST_FIELD_ALIGN (COLORADJUSTMENT, caSize, 2)
486 TEST_FIELD_OFFSET(COLORADJUSTMENT, caSize, 0)
487 TEST_FIELD_SIZE (COLORADJUSTMENT, caFlags, 2)
488 TEST_FIELD_ALIGN (COLORADJUSTMENT, caFlags, 2)
489 TEST_FIELD_OFFSET(COLORADJUSTMENT, caFlags, 2)
490 TEST_FIELD_SIZE (COLORADJUSTMENT, caIlluminantIndex, 2)
491 TEST_FIELD_ALIGN (COLORADJUSTMENT, caIlluminantIndex, 2)
492 TEST_FIELD_OFFSET(COLORADJUSTMENT, caIlluminantIndex, 4)
493 TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGamma, 2)
494 TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGamma, 2)
495 TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGamma, 6)
496 TEST_FIELD_SIZE (COLORADJUSTMENT, caGreenGamma, 2)
497 TEST_FIELD_ALIGN (COLORADJUSTMENT, caGreenGamma, 2)
498 TEST_FIELD_OFFSET(COLORADJUSTMENT, caGreenGamma, 8)
499 TEST_FIELD_SIZE (COLORADJUSTMENT, caBlueGamma, 2)
500 TEST_FIELD_ALIGN (COLORADJUSTMENT, caBlueGamma, 2)
501 TEST_FIELD_OFFSET(COLORADJUSTMENT, caBlueGamma, 10)
502 TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceBlack, 2)
503 TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceBlack, 2)
504 TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceBlack, 12)
505 TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceWhite, 2)
506 TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceWhite, 2)
507 TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceWhite, 14)
508 TEST_FIELD_SIZE (COLORADJUSTMENT, caContrast, 2)
509 TEST_FIELD_ALIGN (COLORADJUSTMENT, caContrast, 2)
510 TEST_FIELD_OFFSET(COLORADJUSTMENT, caContrast, 16)
511 TEST_FIELD_SIZE (COLORADJUSTMENT, caBrightness, 2)
512 TEST_FIELD_ALIGN (COLORADJUSTMENT, caBrightness, 2)
513 TEST_FIELD_OFFSET(COLORADJUSTMENT, caBrightness, 18)
514 TEST_FIELD_SIZE (COLORADJUSTMENT, caColorfulness, 2)
515 TEST_FIELD_ALIGN (COLORADJUSTMENT, caColorfulness, 2)
516 TEST_FIELD_OFFSET(COLORADJUSTMENT, caColorfulness, 20)
517 TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGreenTint, 2)
518 TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGreenTint, 2)
519 TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGreenTint, 22)
520 }
521
522 static void test_pack_DEVMODEA(void)
523 {
524 /* DEVMODEA */
525 TEST_FIELD_SIZE (DEVMODEA, dmDeviceName, 32)
526 TEST_FIELD_ALIGN (DEVMODEA, dmDeviceName, 1)
527 TEST_FIELD_OFFSET(DEVMODEA, dmDeviceName, 0)
528 TEST_FIELD_SIZE (DEVMODEA, dmSpecVersion, 2)
529 TEST_FIELD_ALIGN (DEVMODEA, dmSpecVersion, 2)
530 TEST_FIELD_OFFSET(DEVMODEA, dmSpecVersion, 32)
531 TEST_FIELD_SIZE (DEVMODEA, dmDriverVersion, 2)
532 TEST_FIELD_ALIGN (DEVMODEA, dmDriverVersion, 2)
533 TEST_FIELD_OFFSET(DEVMODEA, dmDriverVersion, 34)
534 TEST_FIELD_SIZE (DEVMODEA, dmSize, 2)
535 TEST_FIELD_ALIGN (DEVMODEA, dmSize, 2)
536 TEST_FIELD_OFFSET(DEVMODEA, dmSize, 36)
537 TEST_FIELD_SIZE (DEVMODEA, dmDriverExtra, 2)
538 TEST_FIELD_ALIGN (DEVMODEA, dmDriverExtra, 2)
539 TEST_FIELD_OFFSET(DEVMODEA, dmDriverExtra, 38)
540 TEST_FIELD_SIZE (DEVMODEA, dmFields, 4)
541 TEST_FIELD_ALIGN (DEVMODEA, dmFields, 4)
542 TEST_FIELD_OFFSET(DEVMODEA, dmFields, 40)
543 }
544
545 static void test_pack_DEVMODEW(void)
546 {
547 /* DEVMODEW */
548 TEST_FIELD_SIZE (DEVMODEW, dmDeviceName, 64)
549 TEST_FIELD_ALIGN (DEVMODEW, dmDeviceName, 2)
550 TEST_FIELD_OFFSET(DEVMODEW, dmDeviceName, 0)
551 TEST_FIELD_SIZE (DEVMODEW, dmSpecVersion, 2)
552 TEST_FIELD_ALIGN (DEVMODEW, dmSpecVersion, 2)
553 TEST_FIELD_OFFSET(DEVMODEW, dmSpecVersion, 64)
554 TEST_FIELD_SIZE (DEVMODEW, dmDriverVersion, 2)
555 TEST_FIELD_ALIGN (DEVMODEW, dmDriverVersion, 2)
556 TEST_FIELD_OFFSET(DEVMODEW, dmDriverVersion, 66)
557 TEST_FIELD_SIZE (DEVMODEW, dmSize, 2)
558 TEST_FIELD_ALIGN (DEVMODEW, dmSize, 2)
559 TEST_FIELD_OFFSET(DEVMODEW, dmSize, 68)
560 TEST_FIELD_SIZE (DEVMODEW, dmDriverExtra, 2)
561 TEST_FIELD_ALIGN (DEVMODEW, dmDriverExtra, 2)
562 TEST_FIELD_OFFSET(DEVMODEW, dmDriverExtra, 70)
563 TEST_FIELD_SIZE (DEVMODEW, dmFields, 4)
564 TEST_FIELD_ALIGN (DEVMODEW, dmFields, 4)
565 TEST_FIELD_OFFSET(DEVMODEW, dmFields, 72)
566 }
567
568 static void test_pack_DIBSECTION(void)
569 {
570 /* DIBSECTION */
571 TEST_TYPE_SIZE (DIBSECTION, 104)
572 TEST_TYPE_ALIGN (DIBSECTION, 8)
573 TEST_FIELD_SIZE (DIBSECTION, dsBm, 32)
574 TEST_FIELD_ALIGN (DIBSECTION, dsBm, 8)
575 TEST_FIELD_OFFSET(DIBSECTION, dsBm, 0)
576 TEST_FIELD_SIZE (DIBSECTION, dsBmih, 40)
577 TEST_FIELD_ALIGN (DIBSECTION, dsBmih, 4)
578 TEST_FIELD_OFFSET(DIBSECTION, dsBmih, 32)
579 TEST_FIELD_SIZE (DIBSECTION, dsBitfields, 12)
580 TEST_FIELD_ALIGN (DIBSECTION, dsBitfields, 4)
581 TEST_FIELD_OFFSET(DIBSECTION, dsBitfields, 72)
582 TEST_FIELD_SIZE (DIBSECTION, dshSection, 8)
583 TEST_FIELD_ALIGN (DIBSECTION, dshSection, 8)
584 TEST_FIELD_OFFSET(DIBSECTION, dshSection, 88)
585 TEST_FIELD_SIZE (DIBSECTION, dsOffset, 4)
586 TEST_FIELD_ALIGN (DIBSECTION, dsOffset, 4)
587 TEST_FIELD_OFFSET(DIBSECTION, dsOffset, 96)
588 }
589
590 static void test_pack_DISPLAY_DEVICEA(void)
591 {
592 /* DISPLAY_DEVICEA */
593 TEST_TYPE_SIZE (DISPLAY_DEVICEA, 424)
594 TEST_TYPE_ALIGN (DISPLAY_DEVICEA, 4)
595 TEST_FIELD_SIZE (DISPLAY_DEVICEA, cb, 4)
596 TEST_FIELD_ALIGN (DISPLAY_DEVICEA, cb, 4)
597 TEST_FIELD_OFFSET(DISPLAY_DEVICEA, cb, 0)
598 TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceName, 32)
599 TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceName, 1)
600 TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceName, 4)
601 TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceString, 128)
602 TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceString, 1)
603 TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceString, 36)
604 TEST_FIELD_SIZE (DISPLAY_DEVICEA, StateFlags, 4)
605 TEST_FIELD_ALIGN (DISPLAY_DEVICEA, StateFlags, 4)
606 TEST_FIELD_OFFSET(DISPLAY_DEVICEA, StateFlags, 164)
607 TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceID, 128)
608 TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceID, 1)
609 TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceID, 168)
610 TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceKey, 128)
611 TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceKey, 1)
612 TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceKey, 296)
613 }
614
615 static void test_pack_DISPLAY_DEVICEW(void)
616 {
617 /* DISPLAY_DEVICEW */
618 TEST_TYPE_SIZE (DISPLAY_DEVICEW, 840)
619 TEST_TYPE_ALIGN (DISPLAY_DEVICEW, 4)
620 TEST_FIELD_SIZE (DISPLAY_DEVICEW, cb, 4)
621 TEST_FIELD_ALIGN (DISPLAY_DEVICEW, cb, 4)
622 TEST_FIELD_OFFSET(DISPLAY_DEVICEW, cb, 0)
623 TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceName, 64)
624 TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceName, 2)
625 TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceName, 4)
626 TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceString, 256)
627 TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceString, 2)
628 TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceString, 68)
629 TEST_FIELD_SIZE (DISPLAY_DEVICEW, StateFlags, 4)
630 TEST_FIELD_ALIGN (DISPLAY_DEVICEW, StateFlags, 4)
631 TEST_FIELD_OFFSET(DISPLAY_DEVICEW, StateFlags, 324)
632 TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceID, 256)
633 TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceID, 2)
634 TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceID, 328)
635 TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceKey, 256)
636 TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceKey, 2)
637 TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceKey, 584)
638 }
639
640 static void test_pack_DOCINFOA(void)
641 {
642 /* DOCINFOA */
643 TEST_TYPE_SIZE (DOCINFOA, 40)
644 TEST_TYPE_ALIGN (DOCINFOA, 8)
645 TEST_FIELD_SIZE (DOCINFOA, cbSize, 4)
646 TEST_FIELD_ALIGN (DOCINFOA, cbSize, 4)
647 TEST_FIELD_OFFSET(DOCINFOA, cbSize, 0)
648 TEST_FIELD_SIZE (DOCINFOA, lpszDocName, 8)
649 TEST_FIELD_ALIGN (DOCINFOA, lpszDocName, 8)
650 TEST_FIELD_OFFSET(DOCINFOA, lpszDocName, 8)
651 TEST_FIELD_SIZE (DOCINFOA, lpszOutput, 8)
652 TEST_FIELD_ALIGN (DOCINFOA, lpszOutput, 8)
653 TEST_FIELD_OFFSET(DOCINFOA, lpszOutput, 16)
654 TEST_FIELD_SIZE (DOCINFOA, lpszDatatype, 8)
655 TEST_FIELD_ALIGN (DOCINFOA, lpszDatatype, 8)
656 TEST_FIELD_OFFSET(DOCINFOA, lpszDatatype, 24)
657 TEST_FIELD_SIZE (DOCINFOA, fwType, 4)
658 TEST_FIELD_ALIGN (DOCINFOA, fwType, 4)
659 TEST_FIELD_OFFSET(DOCINFOA, fwType, 32)
660 }
661
662 static void test_pack_DOCINFOW(void)
663 {
664 /* DOCINFOW */
665 TEST_TYPE_SIZE (DOCINFOW, 40)
666 TEST_TYPE_ALIGN (DOCINFOW, 8)
667 TEST_FIELD_SIZE (DOCINFOW, cbSize, 4)
668 TEST_FIELD_ALIGN (DOCINFOW, cbSize, 4)
669 TEST_FIELD_OFFSET(DOCINFOW, cbSize, 0)
670 TEST_FIELD_SIZE (DOCINFOW, lpszDocName, 8)
671 TEST_FIELD_ALIGN (DOCINFOW, lpszDocName, 8)
672 TEST_FIELD_OFFSET(DOCINFOW, lpszDocName, 8)
673 TEST_FIELD_SIZE (DOCINFOW, lpszOutput, 8)
674 TEST_FIELD_ALIGN (DOCINFOW, lpszOutput, 8)
675 TEST_FIELD_OFFSET(DOCINFOW, lpszOutput, 16)
676 TEST_FIELD_SIZE (DOCINFOW, lpszDatatype, 8)
677 TEST_FIELD_ALIGN (DOCINFOW, lpszDatatype, 8)
678 TEST_FIELD_OFFSET(DOCINFOW, lpszDatatype, 24)
679 TEST_FIELD_SIZE (DOCINFOW, fwType, 4)
680 TEST_FIELD_ALIGN (DOCINFOW, fwType, 4)
681 TEST_FIELD_OFFSET(DOCINFOW, fwType, 32)
682 }
683
684 static void test_pack_EMR(void)
685 {
686 /* EMR */
687 TEST_TYPE_SIZE (EMR, 8)
688 TEST_TYPE_ALIGN (EMR, 4)
689 TEST_FIELD_SIZE (EMR, iType, 4)
690 TEST_FIELD_ALIGN (EMR, iType, 4)
691 TEST_FIELD_OFFSET(EMR, iType, 0)
692 TEST_FIELD_SIZE (EMR, nSize, 4)
693 TEST_FIELD_ALIGN (EMR, nSize, 4)
694 TEST_FIELD_OFFSET(EMR, nSize, 4)
695 }
696
697 static void test_pack_EMRABORTPATH(void)
698 {
699 /* EMRABORTPATH */
700 TEST_TYPE_SIZE (EMRABORTPATH, 8)
701 TEST_TYPE_ALIGN (EMRABORTPATH, 4)
702 TEST_FIELD_SIZE (EMRABORTPATH, emr, 8)
703 TEST_FIELD_ALIGN (EMRABORTPATH, emr, 4)
704 TEST_FIELD_OFFSET(EMRABORTPATH, emr, 0)
705 }
706
707 static void test_pack_EMRANGLEARC(void)
708 {
709 /* EMRANGLEARC */
710 TEST_TYPE_SIZE (EMRANGLEARC, 28)
711 TEST_TYPE_ALIGN (EMRANGLEARC, 4)
712 TEST_FIELD_SIZE (EMRANGLEARC, emr, 8)
713 TEST_FIELD_ALIGN (EMRANGLEARC, emr, 4)
714 TEST_FIELD_OFFSET(EMRANGLEARC, emr, 0)
715 TEST_FIELD_SIZE (EMRANGLEARC, ptlCenter, 8)
716 TEST_FIELD_ALIGN (EMRANGLEARC, ptlCenter, 4)
717 TEST_FIELD_OFFSET(EMRANGLEARC, ptlCenter, 8)
718 TEST_FIELD_SIZE (EMRANGLEARC, nRadius, 4)
719 TEST_FIELD_ALIGN (EMRANGLEARC, nRadius, 4)
720 TEST_FIELD_OFFSET(EMRANGLEARC, nRadius, 16)
721 TEST_FIELD_SIZE (EMRANGLEARC, eStartAngle, 4)
722 TEST_FIELD_ALIGN (EMRANGLEARC, eStartAngle, 4)
723 TEST_FIELD_OFFSET(EMRANGLEARC, eStartAngle, 20)
724 TEST_FIELD_SIZE (EMRANGLEARC, eSweepAngle, 4)
725 TEST_FIELD_ALIGN (EMRANGLEARC, eSweepAngle, 4)
726 TEST_FIELD_OFFSET(EMRANGLEARC, eSweepAngle, 24)
727 }
728
729 static void test_pack_EMRARC(void)
730 {
731 /* EMRARC */
732 TEST_TYPE_SIZE (EMRARC, 40)
733 TEST_TYPE_ALIGN (EMRARC, 4)
734 TEST_FIELD_SIZE (EMRARC, emr, 8)
735 TEST_FIELD_ALIGN (EMRARC, emr, 4)
736 TEST_FIELD_OFFSET(EMRARC, emr, 0)
737 TEST_FIELD_SIZE (EMRARC, rclBox, 16)
738 TEST_FIELD_ALIGN (EMRARC, rclBox, 4)
739 TEST_FIELD_OFFSET(EMRARC, rclBox, 8)
740 TEST_FIELD_SIZE (EMRARC, ptlStart, 8)
741 TEST_FIELD_ALIGN (EMRARC, ptlStart, 4)
742 TEST_FIELD_OFFSET(EMRARC, ptlStart, 24)
743 TEST_FIELD_SIZE (EMRARC, ptlEnd, 8)
744 TEST_FIELD_ALIGN (EMRARC, ptlEnd, 4)
745 TEST_FIELD_OFFSET(EMRARC, ptlEnd, 32)
746 }
747
748 static void test_pack_EMRARCTO(void)
749 {
750 /* EMRARCTO */
751 TEST_TYPE_SIZE (EMRARCTO, 40)
752 TEST_TYPE_ALIGN (EMRARCTO, 4)
753 TEST_FIELD_SIZE (EMRARCTO, emr, 8)
754 TEST_FIELD_ALIGN (EMRARCTO, emr, 4)
755 TEST_FIELD_OFFSET(EMRARCTO, emr, 0)
756 TEST_FIELD_SIZE (EMRARCTO, rclBox, 16)
757 TEST_FIELD_ALIGN (EMRARCTO, rclBox, 4)
758 TEST_FIELD_OFFSET(EMRARCTO, rclBox, 8)
759 TEST_FIELD_SIZE (EMRARCTO, ptlStart, 8)
760 TEST_FIELD_ALIGN (EMRARCTO, ptlStart, 4)
761 TEST_FIELD_OFFSET(EMRARCTO, ptlStart, 24)
762 TEST_FIELD_SIZE (EMRARCTO, ptlEnd, 8)
763 TEST_FIELD_ALIGN (EMRARCTO, ptlEnd, 4)
764 TEST_FIELD_OFFSET(EMRARCTO, ptlEnd, 32)
765 }
766
767 static void test_pack_EMRBEGINPATH(void)
768 {
769 /* EMRBEGINPATH */
770 TEST_TYPE_SIZE (EMRBEGINPATH, 8)
771 TEST_TYPE_ALIGN (EMRBEGINPATH, 4)
772 TEST_FIELD_SIZE (EMRBEGINPATH, emr, 8)
773 TEST_FIELD_ALIGN (EMRBEGINPATH, emr, 4)
774 TEST_FIELD_OFFSET(EMRBEGINPATH, emr, 0)
775 }
776
777 static void test_pack_EMRBITBLT(void)
778 {
779 /* EMRBITBLT */
780 TEST_TYPE_SIZE (EMRBITBLT, 100)
781 TEST_TYPE_ALIGN (EMRBITBLT, 4)
782 TEST_FIELD_SIZE (EMRBITBLT, emr, 8)
783 TEST_FIELD_ALIGN (EMRBITBLT, emr, 4)
784 TEST_FIELD_OFFSET(EMRBITBLT, emr, 0)
785 TEST_FIELD_SIZE (EMRBITBLT, rclBounds, 16)
786 TEST_FIELD_ALIGN (EMRBITBLT, rclBounds, 4)
787 TEST_FIELD_OFFSET(EMRBITBLT, rclBounds, 8)
788 TEST_FIELD_SIZE (EMRBITBLT, xDest, 4)
789 TEST_FIELD_ALIGN (EMRBITBLT, xDest, 4)
790 TEST_FIELD_OFFSET(EMRBITBLT, xDest, 24)
791 TEST_FIELD_SIZE (EMRBITBLT, yDest, 4)
792 TEST_FIELD_ALIGN (EMRBITBLT, yDest, 4)
793 TEST_FIELD_OFFSET(EMRBITBLT, yDest, 28)
794 TEST_FIELD_SIZE (EMRBITBLT, cxDest, 4)
795 TEST_FIELD_ALIGN (EMRBITBLT, cxDest, 4)
796 TEST_FIELD_OFFSET(EMRBITBLT, cxDest, 32)
797 TEST_FIELD_SIZE (EMRBITBLT, cyDest, 4)
798 TEST_FIELD_ALIGN (EMRBITBLT, cyDest, 4)
799 TEST_FIELD_OFFSET(EMRBITBLT, cyDest, 36)
800 TEST_FIELD_SIZE (EMRBITBLT, dwRop, 4)
801 TEST_FIELD_ALIGN (EMRBITBLT, dwRop, 4)
802 TEST_FIELD_OFFSET(EMRBITBLT, dwRop, 40)
803 TEST_FIELD_SIZE (EMRBITBLT, xSrc, 4)
804 TEST_FIELD_ALIGN (EMRBITBLT, xSrc, 4)
805 TEST_FIELD_OFFSET(EMRBITBLT, xSrc, 44)
806 TEST_FIELD_SIZE (EMRBITBLT, ySrc, 4)
807 TEST_FIELD_ALIGN (EMRBITBLT, ySrc, 4)
808 TEST_FIELD_OFFSET(EMRBITBLT, ySrc, 48)
809 TEST_FIELD_SIZE (EMRBITBLT, xformSrc, 24)
810 TEST_FIELD_ALIGN (EMRBITBLT, xformSrc, 4)
811 TEST_FIELD_OFFSET(EMRBITBLT, xformSrc, 52)
812 TEST_FIELD_SIZE (EMRBITBLT, crBkColorSrc, 4)
813 TEST_FIELD_ALIGN (EMRBITBLT, crBkColorSrc, 4)
814 TEST_FIELD_OFFSET(EMRBITBLT, crBkColorSrc, 76)
815 TEST_FIELD_SIZE (EMRBITBLT, iUsageSrc, 4)
816 TEST_FIELD_ALIGN (EMRBITBLT, iUsageSrc, 4)
817 TEST_FIELD_OFFSET(EMRBITBLT, iUsageSrc, 80)
818 TEST_FIELD_SIZE (EMRBITBLT, offBmiSrc, 4)
819 TEST_FIELD_ALIGN (EMRBITBLT, offBmiSrc, 4)
820 TEST_FIELD_OFFSET(EMRBITBLT, offBmiSrc, 84)
821 TEST_FIELD_SIZE (EMRBITBLT, cbBmiSrc, 4)
822 TEST_FIELD_ALIGN (EMRBITBLT, cbBmiSrc, 4)
823 TEST_FIELD_OFFSET(EMRBITBLT, cbBmiSrc, 88)
824 TEST_FIELD_SIZE (EMRBITBLT, offBitsSrc, 4)
825 TEST_FIELD_ALIGN (EMRBITBLT, offBitsSrc, 4)
826 TEST_FIELD_OFFSET(EMRBITBLT, offBitsSrc, 92)
827 TEST_FIELD_SIZE (EMRBITBLT, cbBitsSrc, 4)
828 TEST_FIELD_ALIGN (EMRBITBLT, cbBitsSrc, 4)
829 TEST_FIELD_OFFSET(EMRBITBLT, cbBitsSrc, 96)
830 }
831
832 static void test_pack_EMRCHORD(void)
833 {
834 /* EMRCHORD */
835 TEST_TYPE_SIZE (EMRCHORD, 40)
836 TEST_TYPE_ALIGN (EMRCHORD, 4)
837 TEST_FIELD_SIZE (EMRCHORD, emr, 8)
838 TEST_FIELD_ALIGN (EMRCHORD, emr, 4)
839 TEST_FIELD_OFFSET(EMRCHORD, emr, 0)
840 TEST_FIELD_SIZE (EMRCHORD, rclBox, 16)
841 TEST_FIELD_ALIGN (EMRCHORD, rclBox, 4)
842 TEST_FIELD_OFFSET(EMRCHORD, rclBox, 8)
843 TEST_FIELD_SIZE (EMRCHORD, ptlStart, 8)
844 TEST_FIELD_ALIGN (EMRCHORD, ptlStart, 4)
845 TEST_FIELD_OFFSET(EMRCHORD, ptlStart, 24)
846 TEST_FIELD_SIZE (EMRCHORD, ptlEnd, 8)
847 TEST_FIELD_ALIGN (EMRCHORD, ptlEnd, 4)
848 TEST_FIELD_OFFSET(EMRCHORD, ptlEnd, 32)
849 }
850
851 static void test_pack_EMRCLOSEFIGURE(void)
852 {
853 /* EMRCLOSEFIGURE */
854 TEST_TYPE_SIZE (EMRCLOSEFIGURE, 8)
855 TEST_TYPE_ALIGN (EMRCLOSEFIGURE, 4)
856 TEST_FIELD_SIZE (EMRCLOSEFIGURE, emr, 8)
857 TEST_FIELD_ALIGN (EMRCLOSEFIGURE, emr, 4)
858 TEST_FIELD_OFFSET(EMRCLOSEFIGURE, emr, 0)
859 }
860
861 static void test_pack_EMRCREATEBRUSHINDIRECT(void)
862 {
863 /* EMRCREATEBRUSHINDIRECT */
864 TEST_TYPE_SIZE (EMRCREATEBRUSHINDIRECT, 24)
865 TEST_TYPE_ALIGN (EMRCREATEBRUSHINDIRECT, 4)
866 TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, emr, 8)
867 TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, emr, 4)
868 TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, emr, 0)
869 TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, ihBrush, 4)
870 TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, ihBrush, 4)
871 TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, ihBrush, 8)
872 TEST_FIELD_SIZE (EMRCREATEBRUSHINDIRECT, lb, 12)
873 TEST_FIELD_ALIGN (EMRCREATEBRUSHINDIRECT, lb, 4)
874 TEST_FIELD_OFFSET(EMRCREATEBRUSHINDIRECT, lb, 12)
875 }
876
877 static void test_pack_EMRCREATECOLORSPACE(void)
878 {
879 /* EMRCREATECOLORSPACE */
880 TEST_TYPE_SIZE (EMRCREATECOLORSPACE, 340)
881 TEST_TYPE_ALIGN (EMRCREATECOLORSPACE, 4)
882 TEST_FIELD_SIZE (EMRCREATECOLORSPACE, emr, 8)
883 TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, emr, 4)
884 TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, emr, 0)
885 TEST_FIELD_SIZE (EMRCREATECOLORSPACE, ihCS, 4)
886 TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, ihCS, 4)
887 TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, ihCS, 8)
888 TEST_FIELD_SIZE (EMRCREATECOLORSPACE, lcs, 328)
889 TEST_FIELD_ALIGN (EMRCREATECOLORSPACE, lcs, 4)
890 TEST_FIELD_OFFSET(EMRCREATECOLORSPACE, lcs, 12)
891 }
892
893 static void test_pack_EMRCREATECOLORSPACEW(void)
894 {
895 /* EMRCREATECOLORSPACEW */
896 TEST_TYPE_SIZE (EMRCREATECOLORSPACEW, 612)
897 TEST_TYPE_ALIGN (EMRCREATECOLORSPACEW, 4)
898 TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, emr, 8)
899 TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, emr, 4)
900 TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, emr, 0)
901 TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, ihCS, 4)
902 TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, ihCS, 4)
903 TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, ihCS, 8)
904 TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, lcs, 588)
905 TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, lcs, 4)
906 TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, lcs, 12)
907 TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, dwFlags, 4)
908 TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, dwFlags, 4)
909 TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, dwFlags, 600)
910 TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, cbData, 4)
911 TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, cbData, 4)
912 TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, cbData, 604)
913 TEST_FIELD_SIZE (EMRCREATECOLORSPACEW, Data, 1)
914 TEST_FIELD_ALIGN (EMRCREATECOLORSPACEW, Data, 1)
915 TEST_FIELD_OFFSET(EMRCREATECOLORSPACEW, Data, 608)
916 }
917
918 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
919 {
920 /* EMRCREATEDIBPATTERNBRUSHPT */
921 TEST_TYPE_SIZE (EMRCREATEDIBPATTERNBRUSHPT, 32)
922 TEST_TYPE_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, 4)
923 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, emr, 8)
924 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, emr, 4)
925 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, emr, 0)
926 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4)
927 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 4)
928 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 8)
929 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4)
930 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, iUsage, 4)
931 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, iUsage, 12)
932 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4)
933 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBmi, 4)
934 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBmi, 16)
935 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4)
936 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 4)
937 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 20)
938 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4)
939 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, offBits, 4)
940 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, offBits, 24)
941 TEST_FIELD_SIZE (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4)
942 TEST_FIELD_ALIGN (EMRCREATEDIBPATTERNBRUSHPT, cbBits, 4)
943 TEST_FIELD_OFFSET(EMRCREATEDIBPATTERNBRUSHPT, cbBits, 28)
944 }
945
946 static void test_pack_EMRCREATEMONOBRUSH(void)
947 {
948 /* EMRCREATEMONOBRUSH */
949 TEST_TYPE_SIZE (EMRCREATEMONOBRUSH, 32)
950 TEST_TYPE_ALIGN (EMRCREATEMONOBRUSH, 4)
951 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, emr, 8)
952 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, emr, 4)
953 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, emr, 0)
954 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, ihBrush, 4)
955 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, ihBrush, 4)
956 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, ihBrush, 8)
957 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, iUsage, 4)
958 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, iUsage, 4)
959 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, iUsage, 12)
960 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBmi, 4)
961 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBmi, 4)
962 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBmi, 16)
963 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, cbBmi, 4)
964 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBmi, 4)
965 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBmi, 20)
966 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBits, 4)
967 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, offBits, 4)
968 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, offBits, 24)
969 TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, cbBits, 4)
970 TEST_FIELD_ALIGN (EMRCREATEMONOBRUSH, cbBits, 4)
971 TEST_FIELD_OFFSET(EMRCREATEMONOBRUSH, cbBits, 28)
972 }
973
974 static void test_pack_EMRCREATEPEN(void)
975 {
976 /* EMRCREATEPEN */
977 TEST_TYPE_SIZE (EMRCREATEPEN, 28)
978 TEST_TYPE_ALIGN (EMRCREATEPEN, 4)
979 TEST_FIELD_SIZE (EMRCREATEPEN, emr, 8)
980 TEST_FIELD_ALIGN (EMRCREATEPEN, emr, 4)
981 TEST_FIELD_OFFSET(EMRCREATEPEN, emr, 0)
982 TEST_FIELD_SIZE (EMRCREATEPEN, ihPen, 4)
983 TEST_FIELD_ALIGN (EMRCREATEPEN, ihPen, 4)
984 TEST_FIELD_OFFSET(EMRCREATEPEN, ihPen, 8)
985 TEST_FIELD_SIZE (EMRCREATEPEN, lopn, 16)
986 TEST_FIELD_ALIGN (EMRCREATEPEN, lopn, 4)
987 TEST_FIELD_OFFSET(EMRCREATEPEN, lopn, 12)
988 }
989
990 static void test_pack_EMRDELETECOLORSPACE(void)
991 {
992 /* EMRDELETECOLORSPACE */
993 TEST_TYPE_SIZE (EMRDELETECOLORSPACE, 12)
994 TEST_TYPE_ALIGN (EMRDELETECOLORSPACE, 4)
995 TEST_FIELD_SIZE (EMRDELETECOLORSPACE, emr, 8)
996 TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, emr, 4)
997 TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, emr, 0)
998 TEST_FIELD_SIZE (EMRDELETECOLORSPACE, ihCS, 4)
999 TEST_FIELD_ALIGN (EMRDELETECOLORSPACE, ihCS, 4)
1000 TEST_FIELD_OFFSET(EMRDELETECOLORSPACE, ihCS, 8)
1001 }
1002
1003 static void test_pack_EMRDELETEOBJECT(void)
1004 {
1005 /* EMRDELETEOBJECT */
1006 TEST_TYPE_SIZE (EMRDELETEOBJECT, 12)
1007 TEST_TYPE_ALIGN (EMRDELETEOBJECT, 4)
1008 TEST_FIELD_SIZE (EMRDELETEOBJECT, emr, 8)
1009 TEST_FIELD_ALIGN (EMRDELETEOBJECT, emr, 4)
1010 TEST_FIELD_OFFSET(EMRDELETEOBJECT, emr, 0)
1011 TEST_FIELD_SIZE (EMRDELETEOBJECT, ihObject, 4)
1012 TEST_FIELD_ALIGN (EMRDELETEOBJECT, ihObject, 4)
1013 TEST_FIELD_OFFSET(EMRDELETEOBJECT, ihObject, 8)
1014 }
1015
1016 static void test_pack_EMRELLIPSE(void)
1017 {
1018 /* EMRELLIPSE */
1019 TEST_TYPE_SIZE (EMRELLIPSE, 24)
1020 TEST_TYPE_ALIGN (EMRELLIPSE, 4)
1021 TEST_FIELD_SIZE (EMRELLIPSE, emr, 8)
1022 TEST_FIELD_ALIGN (EMRELLIPSE, emr, 4)
1023 TEST_FIELD_OFFSET(EMRELLIPSE, emr, 0)
1024 TEST_FIELD_SIZE (EMRELLIPSE, rclBox, 16)
1025 TEST_FIELD_ALIGN (EMRELLIPSE, rclBox, 4)
1026 TEST_FIELD_OFFSET(EMRELLIPSE, rclBox, 8)
1027 }
1028
1029 static void test_pack_EMRENDPATH(void)
1030 {
1031 /* EMRENDPATH */
1032 TEST_TYPE_SIZE (EMRENDPATH, 8)
1033 TEST_TYPE_ALIGN (EMRENDPATH, 4)
1034 TEST_FIELD_SIZE (EMRENDPATH, emr, 8)
1035 TEST_FIELD_ALIGN (EMRENDPATH, emr, 4)
1036 TEST_FIELD_OFFSET(EMRENDPATH, emr, 0)
1037 }
1038
1039 static void test_pack_EMREOF(void)
1040 {
1041 /* EMREOF */
1042 TEST_TYPE_SIZE (EMREOF, 20)
1043 TEST_TYPE_ALIGN (EMREOF, 4)
1044 TEST_FIELD_SIZE (EMREOF, emr, 8)
1045 TEST_FIELD_ALIGN (EMREOF, emr, 4)
1046 TEST_FIELD_OFFSET(EMREOF, emr, 0)
1047 TEST_FIELD_SIZE (EMREOF, nPalEntries, 4)
1048 TEST_FIELD_ALIGN (EMREOF, nPalEntries, 4)
1049 TEST_FIELD_OFFSET(EMREOF, nPalEntries, 8)
1050 TEST_FIELD_SIZE (EMREOF, offPalEntries, 4)
1051 TEST_FIELD_ALIGN (EMREOF, offPalEntries, 4)
1052 TEST_FIELD_OFFSET(EMREOF, offPalEntries, 12)
1053 TEST_FIELD_SIZE (EMREOF, nSizeLast, 4)
1054 TEST_FIELD_ALIGN (EMREOF, nSizeLast, 4)
1055 TEST_FIELD_OFFSET(EMREOF, nSizeLast, 16)
1056 }
1057
1058 static void test_pack_EMREXCLUDECLIPRECT(void)
1059 {
1060 /* EMREXCLUDECLIPRECT */
1061 TEST_TYPE_SIZE (EMREXCLUDECLIPRECT, 24)
1062 TEST_TYPE_ALIGN (EMREXCLUDECLIPRECT, 4)
1063 TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, emr, 8)
1064 TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, emr, 4)
1065 TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, emr, 0)
1066 TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, rclClip, 16)
1067 TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, rclClip, 4)
1068 TEST_FIELD_OFFSET(EMREXCLUDECLIPRECT, rclClip, 8)
1069 }
1070
1071 static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
1072 {
1073 /* EMREXTCREATEFONTINDIRECTW */
1074 TEST_TYPE_SIZE (EMREXTCREATEFONTINDIRECTW, 332)
1075 TEST_TYPE_ALIGN (EMREXTCREATEFONTINDIRECTW, 4)
1076 TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, emr, 8)
1077 TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, emr, 4)
1078 TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, emr, 0)
1079 TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, ihFont, 4)
1080 TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, ihFont, 4)
1081 TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, ihFont, 8)
1082 TEST_FIELD_SIZE (EMREXTCREATEFONTINDIRECTW, elfw, 320)
1083 TEST_FIELD_ALIGN (EMREXTCREATEFONTINDIRECTW, elfw, 4)
1084 TEST_FIELD_OFFSET(EMREXTCREATEFONTINDIRECTW, elfw, 12)
1085 }
1086
1087 static void test_pack_EMREXTCREATEPEN(void)
1088 {
1089 /* EMREXTCREATEPEN */
1090 TEST_TYPE_SIZE (EMREXTCREATEPEN, 64)
1091 TEST_TYPE_ALIGN (EMREXTCREATEPEN, 8)
1092 TEST_FIELD_SIZE (EMREXTCREATEPEN, emr, 8)
1093 TEST_FIELD_ALIGN (EMREXTCREATEPEN, emr, 4)
1094 TEST_FIELD_OFFSET(EMREXTCREATEPEN, emr, 0)
1095 TEST_FIELD_SIZE (EMREXTCREATEPEN, ihPen, 4)
1096 TEST_FIELD_ALIGN (EMREXTCREATEPEN, ihPen, 4)
1097 TEST_FIELD_OFFSET(EMREXTCREATEPEN, ihPen, 8)
1098 TEST_FIELD_SIZE (EMREXTCREATEPEN, offBmi, 4)
1099 TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBmi, 4)
1100 TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBmi, 12)
1101 TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBmi, 4)
1102 TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBmi, 4)
1103 TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBmi, 16)
1104 TEST_FIELD_SIZE (EMREXTCREATEPEN, offBits, 4)
1105 TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBits, 4)
1106 TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBits, 20)
1107 TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBits, 4)
1108 TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBits, 4)
1109 TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBits, 24)
1110 TEST_FIELD_SIZE (EMREXTCREATEPEN, elp, 32)
1111 TEST_FIELD_ALIGN (EMREXTCREATEPEN, elp, 8)
1112 TEST_FIELD_OFFSET(EMREXTCREATEPEN, elp, 32)
1113 }
1114
1115 static void test_pack_EMREXTFLOODFILL(void)
1116 {
1117 /* EMREXTFLOODFILL */
1118 TEST_TYPE_SIZE (EMREXTFLOODFILL, 24)
1119 TEST_TYPE_ALIGN (EMREXTFLOODFILL, 4)
1120 TEST_FIELD_SIZE (EMREXTFLOODFILL, emr, 8)
1121 TEST_FIELD_ALIGN (EMREXTFLOODFILL, emr, 4)
1122 TEST_FIELD_OFFSET(EMREXTFLOODFILL, emr, 0)
1123 TEST_FIELD_SIZE (EMREXTFLOODFILL, ptlStart, 8)
1124 TEST_FIELD_ALIGN (EMREXTFLOODFILL, ptlStart, 4)
1125 TEST_FIELD_OFFSET(EMREXTFLOODFILL, ptlStart, 8)
1126 TEST_FIELD_SIZE (EMREXTFLOODFILL, crColor, 4)
1127 TEST_FIELD_ALIGN (EMREXTFLOODFILL, crColor, 4)
1128 TEST_FIELD_OFFSET(EMREXTFLOODFILL, crColor, 16)
1129 TEST_FIELD_SIZE (EMREXTFLOODFILL, iMode, 4)
1130 TEST_FIELD_ALIGN (EMREXTFLOODFILL, iMode, 4)
1131 TEST_FIELD_OFFSET(EMREXTFLOODFILL, iMode, 20)
1132 }
1133
1134 static void test_pack_EMREXTSELECTCLIPRGN(void)
1135 {
1136 /* EMREXTSELECTCLIPRGN */
1137 TEST_TYPE_SIZE (EMREXTSELECTCLIPRGN, 20)
1138 TEST_TYPE_ALIGN (EMREXTSELECTCLIPRGN, 4)
1139 TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, emr, 8)
1140 TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, emr, 4)
1141 TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, emr, 0)
1142 TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1143 TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1144 TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, cbRgnData, 8)
1145 TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, iMode, 4)
1146 TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, iMode, 4)
1147 TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, iMode, 12)
1148 TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, RgnData, 1)
1149 TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, RgnData, 1)
1150 TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, RgnData, 16)
1151 }
1152
1153 static void test_pack_EMREXTTEXTOUTA(void)
1154 {
1155 /* EMREXTTEXTOUTA */
1156 TEST_TYPE_SIZE (EMREXTTEXTOUTA, 76)
1157 TEST_TYPE_ALIGN (EMREXTTEXTOUTA, 4)
1158 TEST_FIELD_SIZE (EMREXTTEXTOUTA, emr, 8)
1159 TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emr, 4)
1160 TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emr, 0)
1161 TEST_FIELD_SIZE (EMREXTTEXTOUTA, rclBounds, 16)
1162 TEST_FIELD_ALIGN (EMREXTTEXTOUTA, rclBounds, 4)
1163 TEST_FIELD_OFFSET(EMREXTTEXTOUTA, rclBounds, 8)
1164 TEST_FIELD_SIZE (EMREXTTEXTOUTA, iGraphicsMode, 4)
1165 TEST_FIELD_ALIGN (EMREXTTEXTOUTA, iGraphicsMode, 4)
1166 TEST_FIELD_OFFSET(EMREXTTEXTOUTA, iGraphicsMode, 24)
1167 TEST_FIELD_SIZE (EMREXTTEXTOUTA, exScale, 4)
1168 TEST_FIELD_ALIGN (EMREXTTEXTOUTA, exScale, 4)
1169 TEST_FIELD_OFFSET(EMREXTTEXTOUTA, exScale, 28)
1170 TEST_FIELD_SIZE (EMREXTTEXTOUTA, eyScale, 4)
1171 TEST_FIELD_ALIGN (EMREXTTEXTOUTA, eyScale, 4)
1172 TEST_FIELD_OFFSET(EMREXTTEXTOUTA, eyScale, 32)
1173 TEST_FIELD_SIZE (EMREXTTEXTOUTA, emrtext, 40)
1174 TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emrtext, 4)
1175 TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emrtext, 36)
1176 }
1177
1178 static void test_pack_EMREXTTEXTOUTW(void)
1179 {
1180 /* EMREXTTEXTOUTW */
1181 TEST_TYPE_SIZE (EMREXTTEXTOUTW, 76)
1182 TEST_TYPE_ALIGN (EMREXTTEXTOUTW, 4)
1183 TEST_FIELD_SIZE (EMREXTTEXTOUTW, emr, 8)
1184 TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emr, 4)
1185 TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emr, 0)
1186 TEST_FIELD_SIZE (EMREXTTEXTOUTW, rclBounds, 16)
1187 TEST_FIELD_ALIGN (EMREXTTEXTOUTW, rclBounds, 4)
1188 TEST_FIELD_OFFSET(EMREXTTEXTOUTW, rclBounds, 8)
1189 TEST_FIELD_SIZE (EMREXTTEXTOUTW, iGraphicsMode, 4)
1190 TEST_FIELD_ALIGN (EMREXTTEXTOUTW, iGraphicsMode, 4)
1191 TEST_FIELD_OFFSET(EMREXTTEXTOUTW, iGraphicsMode, 24)
1192 TEST_FIELD_SIZE (EMREXTTEXTOUTW, exScale, 4)
1193 TEST_FIELD_ALIGN (EMREXTTEXTOUTW, exScale, 4)
1194 TEST_FIELD_OFFSET(EMREXTTEXTOUTW, exScale, 28)
1195 TEST_FIELD_SIZE (EMREXTTEXTOUTW, eyScale, 4)
1196 TEST_FIELD_ALIGN (EMREXTTEXTOUTW, eyScale, 4)
1197 TEST_FIELD_OFFSET(EMREXTTEXTOUTW, eyScale, 32)
1198 TEST_FIELD_SIZE (EMREXTTEXTOUTW, emrtext, 40)
1199 TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emrtext, 4)
1200 TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emrtext, 36)
1201 }
1202
1203 static void test_pack_EMRFILLPATH(void)
1204 {
1205 /* EMRFILLPATH */
1206 TEST_TYPE_SIZE (EMRFILLPATH, 24)
1207 TEST_TYPE_ALIGN (EMRFILLPATH, 4)
1208 TEST_FIELD_SIZE (EMRFILLPATH, emr, 8)
1209 TEST_FIELD_ALIGN (EMRFILLPATH, emr, 4)
1210 TEST_FIELD_OFFSET(EMRFILLPATH, emr, 0)
1211 TEST_FIELD_SIZE (EMRFILLPATH, rclBounds, 16)
1212 TEST_FIELD_ALIGN (EMRFILLPATH, rclBounds, 4)
1213 TEST_FIELD_OFFSET(EMRFILLPATH, rclBounds, 8)
1214 }
1215
1216 static void test_pack_EMRFILLRGN(void)
1217 {
1218 /* EMRFILLRGN */
1219 TEST_TYPE_SIZE (EMRFILLRGN, 36)
1220 TEST_TYPE_ALIGN (EMRFILLRGN, 4)
1221 TEST_FIELD_SIZE (EMRFILLRGN, emr, 8)
1222 TEST_FIELD_ALIGN (EMRFILLRGN, emr, 4)
1223 TEST_FIELD_OFFSET(EMRFILLRGN, emr, 0)
1224 TEST_FIELD_SIZE (EMRFILLRGN, rclBounds, 16)
1225 TEST_FIELD_ALIGN (EMRFILLRGN, rclBounds, 4)
1226 TEST_FIELD_OFFSET(EMRFILLRGN, rclBounds, 8)
1227 TEST_FIELD_SIZE (EMRFILLRGN, cbRgnData, 4)
1228 TEST_FIELD_ALIGN (EMRFILLRGN, cbRgnData, 4)
1229 TEST_FIELD_OFFSET(EMRFILLRGN, cbRgnData, 24)
1230 TEST_FIELD_SIZE (EMRFILLRGN, ihBrush, 4)
1231 TEST_FIELD_ALIGN (EMRFILLRGN, ihBrush, 4)
1232 TEST_FIELD_OFFSET(EMRFILLRGN, ihBrush, 28)
1233 TEST_FIELD_SIZE (EMRFILLRGN, RgnData, 1)
1234 TEST_FIELD_ALIGN (EMRFILLRGN, RgnData, 1)
1235 TEST_FIELD_OFFSET(EMRFILLRGN, RgnData, 32)
1236 }
1237
1238 static void test_pack_EMRFLATTENPATH(void)
1239 {
1240 /* EMRFLATTENPATH */
1241 TEST_TYPE_SIZE (EMRFLATTENPATH, 8)
1242 TEST_TYPE_ALIGN (EMRFLATTENPATH, 4)
1243 TEST_FIELD_SIZE (EMRFLATTENPATH, emr, 8)
1244 TEST_FIELD_ALIGN (EMRFLATTENPATH, emr, 4)
1245 TEST_FIELD_OFFSET(EMRFLATTENPATH, emr, 0)
1246 }
1247
1248 static void test_pack_EMRFORMAT(void)
1249 {
1250 /* EMRFORMAT */
1251 TEST_TYPE_SIZE (EMRFORMAT, 16)
1252 TEST_TYPE_ALIGN (EMRFORMAT, 4)
1253 TEST_FIELD_SIZE (EMRFORMAT, dSignature, 4)
1254 TEST_FIELD_ALIGN (EMRFORMAT, dSignature, 4)
1255 TEST_FIELD_OFFSET(EMRFORMAT, dSignature, 0)
1256 TEST_FIELD_SIZE (EMRFORMAT, nVersion, 4)
1257 TEST_FIELD_ALIGN (EMRFORMAT, nVersion, 4)
1258 TEST_FIELD_OFFSET(EMRFORMAT, nVersion, 4)
1259 TEST_FIELD_SIZE (EMRFORMAT, cbData, 4)
1260 TEST_FIELD_ALIGN (EMRFORMAT, cbData, 4)
1261 TEST_FIELD_OFFSET(EMRFORMAT, cbData, 8)
1262 TEST_FIELD_SIZE (EMRFORMAT, offData, 4)
1263 TEST_FIELD_ALIGN (EMRFORMAT, offData, 4)
1264 TEST_FIELD_OFFSET(EMRFORMAT, offData, 12)
1265 }
1266
1267 static void test_pack_EMRFRAMERGN(void)
1268 {
1269 /* EMRFRAMERGN */
1270 TEST_TYPE_SIZE (EMRFRAMERGN, 44)
1271 TEST_TYPE_ALIGN (EMRFRAMERGN, 4)
1272 TEST_FIELD_SIZE (EMRFRAMERGN, emr, 8)
1273 TEST_FIELD_ALIGN (EMRFRAMERGN, emr, 4)
1274 TEST_FIELD_OFFSET(EMRFRAMERGN, emr, 0)
1275 TEST_FIELD_SIZE (EMRFRAMERGN, rclBounds, 16)
1276 TEST_FIELD_ALIGN (EMRFRAMERGN, rclBounds, 4)
1277 TEST_FIELD_OFFSET(EMRFRAMERGN, rclBounds, 8)
1278 TEST_FIELD_SIZE (EMRFRAMERGN, cbRgnData, 4)
1279 TEST_FIELD_ALIGN (EMRFRAMERGN, cbRgnData, 4)
1280 TEST_FIELD_OFFSET(EMRFRAMERGN, cbRgnData, 24)
1281 TEST_FIELD_SIZE (EMRFRAMERGN, ihBrush, 4)
1282 TEST_FIELD_ALIGN (EMRFRAMERGN, ihBrush, 4)
1283 TEST_FIELD_OFFSET(EMRFRAMERGN, ihBrush, 28)
1284 TEST_FIELD_SIZE (EMRFRAMERGN, szlStroke, 8)
1285 TEST_FIELD_ALIGN (EMRFRAMERGN, szlStroke, 4)
1286 TEST_FIELD_OFFSET(EMRFRAMERGN, szlStroke, 32)
1287 TEST_FIELD_SIZE (EMRFRAMERGN, RgnData, 1)
1288 TEST_FIELD_ALIGN (EMRFRAMERGN, RgnData, 1)
1289 TEST_FIELD_OFFSET(EMRFRAMERGN, RgnData, 40)
1290 }
1291
1292 static void test_pack_EMRGDICOMMENT(void)
1293 {
1294 /* EMRGDICOMMENT */
1295 TEST_TYPE_SIZE (EMRGDICOMMENT, 16)
1296 TEST_TYPE_ALIGN (EMRGDICOMMENT, 4)
1297 TEST_FIELD_SIZE (EMRGDICOMMENT, emr, 8)
1298 TEST_FIELD_ALIGN (EMRGDICOMMENT, emr, 4)
1299 TEST_FIELD_OFFSET(EMRGDICOMMENT, emr, 0)
1300 TEST_FIELD_SIZE (EMRGDICOMMENT, cbData, 4)
1301 TEST_FIELD_ALIGN (EMRGDICOMMENT, cbData, 4)
1302 TEST_FIELD_OFFSET(EMRGDICOMMENT, cbData, 8)
1303 TEST_FIELD_SIZE (EMRGDICOMMENT, Data, 1)
1304 TEST_FIELD_ALIGN (EMRGDICOMMENT, Data, 1)
1305 TEST_FIELD_OFFSET(EMRGDICOMMENT, Data, 12)
1306 }
1307
1308 static void test_pack_EMRGLSBOUNDEDRECORD(void)
1309 {
1310 /* EMRGLSBOUNDEDRECORD */
1311 TEST_TYPE_SIZE (EMRGLSBOUNDEDRECORD, 32)
1312 TEST_TYPE_ALIGN (EMRGLSBOUNDEDRECORD, 4)
1313 TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, emr, 8)
1314 TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, emr, 4)
1315 TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, emr, 0)
1316 TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, rclBounds, 16)
1317 TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, rclBounds, 4)
1318 TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, rclBounds, 8)
1319 TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, cbData, 4)
1320 TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, cbData, 4)
1321 TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, cbData, 24)
1322 TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, Data, 1)
1323 TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, Data, 1)
1324 TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, Data, 28)
1325 }
1326
1327 static void test_pack_EMRGLSRECORD(void)
1328 {
1329 /* EMRGLSRECORD */
1330 TEST_TYPE_SIZE (EMRGLSRECORD, 16)
1331 TEST_TYPE_ALIGN (EMRGLSRECORD, 4)
1332 TEST_FIELD_SIZE (EMRGLSRECORD, emr, 8)
1333 TEST_FIELD_ALIGN (EMRGLSRECORD, emr, 4)
1334 TEST_FIELD_OFFSET(EMRGLSRECORD, emr, 0)
1335 TEST_FIELD_SIZE (EMRGLSRECORD, cbData, 4)
1336 TEST_FIELD_ALIGN (EMRGLSRECORD, cbData, 4)
1337 TEST_FIELD_OFFSET(EMRGLSRECORD, cbData, 8)
1338 TEST_FIELD_SIZE (EMRGLSRECORD, Data, 1)
1339 TEST_FIELD_ALIGN (EMRGLSRECORD, Data, 1)
1340 TEST_FIELD_OFFSET(EMRGLSRECORD, Data, 12)
1341 }
1342
1343 static void test_pack_EMRINTERSECTCLIPRECT(void)
1344 {
1345 /* EMRINTERSECTCLIPRECT */
1346 TEST_TYPE_SIZE (EMRINTERSECTCLIPRECT, 24)
1347 TEST_TYPE_ALIGN (EMRINTERSECTCLIPRECT, 4)
1348 TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, emr, 8)
1349 TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, emr, 4)
1350 TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, emr, 0)
1351 TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, rclClip, 16)
1352 TEST_FIELD_ALIGN (EMRINTERSECTCLIPRECT, rclClip, 4)
1353 TEST_FIELD_OFFSET(EMRINTERSECTCLIPRECT, rclClip, 8)
1354 }
1355
1356 static void test_pack_EMRINVERTRGN(void)
1357 {
1358 /* EMRINVERTRGN */
1359 TEST_TYPE_SIZE (EMRINVERTRGN, 32)
1360 TEST_TYPE_ALIGN (EMRINVERTRGN, 4)
1361 TEST_FIELD_SIZE (EMRINVERTRGN, emr, 8)
1362 TEST_FIELD_ALIGN (EMRINVERTRGN, emr, 4)
1363 TEST_FIELD_OFFSET(EMRINVERTRGN, emr, 0)
1364 TEST_FIELD_SIZE (EMRINVERTRGN, rclBounds, 16)
1365 TEST_FIELD_ALIGN (EMRINVERTRGN, rclBounds, 4)
1366 TEST_FIELD_OFFSET(EMRINVERTRGN, rclBounds, 8)
1367 TEST_FIELD_SIZE (EMRINVERTRGN, cbRgnData, 4)
1368 TEST_FIELD_ALIGN (EMRINVERTRGN, cbRgnData, 4)
1369 TEST_FIELD_OFFSET(EMRINVERTRGN, cbRgnData, 24)
1370 TEST_FIELD_SIZE (EMRINVERTRGN, RgnData, 1)
1371 TEST_FIELD_ALIGN (EMRINVERTRGN, RgnData, 1)
1372 TEST_FIELD_OFFSET(EMRINVERTRGN, RgnData, 28)
1373 }
1374
1375 static void test_pack_EMRLINETO(void)
1376 {
1377 /* EMRLINETO */
1378 TEST_TYPE_SIZE (EMRLINETO, 16)
1379 TEST_TYPE_ALIGN (EMRLINETO, 4)
1380 TEST_FIELD_SIZE (EMRLINETO, emr, 8)
1381 TEST_FIELD_ALIGN (EMRLINETO, emr, 4)
1382 TEST_FIELD_OFFSET(EMRLINETO, emr, 0)
1383 TEST_FIELD_SIZE (EMRLINETO, ptl, 8)
1384 TEST_FIELD_ALIGN (EMRLINETO, ptl, 4)
1385 TEST_FIELD_OFFSET(EMRLINETO, ptl, 8)
1386 }
1387
1388 static void test_pack_EMRMASKBLT(void)
1389 {
1390 /* EMRMASKBLT */
1391 TEST_TYPE_SIZE (EMRMASKBLT, 128)
1392 TEST_TYPE_ALIGN (EMRMASKBLT, 4)
1393 TEST_FIELD_SIZE (EMRMASKBLT, emr, 8)
1394 TEST_FIELD_ALIGN (EMRMASKBLT, emr, 4)
1395 TEST_FIELD_OFFSET(EMRMASKBLT, emr, 0)
1396 TEST_FIELD_SIZE (EMRMASKBLT, rclBounds, 16)
1397 TEST_FIELD_ALIGN (EMRMASKBLT, rclBounds, 4)
1398 TEST_FIELD_OFFSET(EMRMASKBLT, rclBounds, 8)
1399 TEST_FIELD_SIZE (EMRMASKBLT, xDest, 4)
1400 TEST_FIELD_ALIGN (EMRMASKBLT, xDest, 4)
1401 TEST_FIELD_OFFSET(EMRMASKBLT, xDest, 24)
1402 TEST_FIELD_SIZE (EMRMASKBLT, yDest, 4)
1403 TEST_FIELD_ALIGN (EMRMASKBLT, yDest, 4)
1404 TEST_FIELD_OFFSET(EMRMASKBLT, yDest, 28)
1405 TEST_FIELD_SIZE (EMRMASKBLT, cxDest, 4)
1406 TEST_FIELD_ALIGN (EMRMASKBLT, cxDest, 4)
1407 TEST_FIELD_OFFSET(EMRMASKBLT, cxDest, 32)
1408 TEST_FIELD_SIZE (EMRMASKBLT, cyDest, 4)
1409 TEST_FIELD_ALIGN (EMRMASKBLT, cyDest, 4)
1410 TEST_FIELD_OFFSET(EMRMASKBLT, cyDest, 36)
1411 TEST_FIELD_SIZE (EMRMASKBLT, dwRop, 4)
1412 TEST_FIELD_ALIGN (EMRMASKBLT, dwRop, 4)
1413 TEST_FIELD_OFFSET(EMRMASKBLT, dwRop, 40)
1414 TEST_FIELD_SIZE (EMRMASKBLT, xSrc, 4)
1415 TEST_FIELD_ALIGN (EMRMASKBLT, xSrc, 4)
1416 TEST_FIELD_OFFSET(EMRMASKBLT, xSrc, 44)
1417 TEST_FIELD_SIZE (EMRMASKBLT, ySrc, 4)
1418 TEST_FIELD_ALIGN (EMRMASKBLT, ySrc, 4)
1419 TEST_FIELD_OFFSET(EMRMASKBLT, ySrc, 48)
1420 TEST_FIELD_SIZE (EMRMASKBLT, xformSrc, 24)
1421 TEST_FIELD_ALIGN (EMRMASKBLT, xformSrc, 4)
1422 TEST_FIELD_OFFSET(EMRMASKBLT, xformSrc, 52)
1423 TEST_FIELD_SIZE (EMRMASKBLT, crBkColorSrc, 4)
1424 TEST_FIELD_ALIGN (EMRMASKBLT, crBkColorSrc, 4)
1425 TEST_FIELD_OFFSET(EMRMASKBLT, crBkColorSrc, 76)
1426 TEST_FIELD_SIZE (EMRMASKBLT, iUsageSrc, 4)
1427 TEST_FIELD_ALIGN (EMRMASKBLT, iUsageSrc, 4)
1428 TEST_FIELD_OFFSET(EMRMASKBLT, iUsageSrc, 80)
1429 TEST_FIELD_SIZE (EMRMASKBLT, offBmiSrc, 4)
1430 TEST_FIELD_ALIGN (EMRMASKBLT, offBmiSrc, 4)
1431 TEST_FIELD_OFFSET(EMRMASKBLT, offBmiSrc, 84)
1432 TEST_FIELD_SIZE (EMRMASKBLT, cbBmiSrc, 4)
1433 TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiSrc, 4)
1434 TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiSrc, 88)
1435 TEST_FIELD_SIZE (EMRMASKBLT, offBitsSrc, 4)
1436 TEST_FIELD_ALIGN (EMRMASKBLT, offBitsSrc, 4)
1437 TEST_FIELD_OFFSET(EMRMASKBLT, offBitsSrc, 92)
1438 TEST_FIELD_SIZE (EMRMASKBLT, cbBitsSrc, 4)
1439 TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsSrc, 4)
1440 TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsSrc, 96)
1441 TEST_FIELD_SIZE (EMRMASKBLT, xMask, 4)
1442 TEST_FIELD_ALIGN (EMRMASKBLT, xMask, 4)
1443 TEST_FIELD_OFFSET(EMRMASKBLT, xMask, 100)
1444 TEST_FIELD_SIZE (EMRMASKBLT, yMask, 4)
1445 TEST_FIELD_ALIGN (EMRMASKBLT, yMask, 4)
1446 TEST_FIELD_OFFSET(EMRMASKBLT, yMask, 104)
1447 TEST_FIELD_SIZE (EMRMASKBLT, iUsageMask, 4)
1448 TEST_FIELD_ALIGN (EMRMASKBLT, iUsageMask, 4)
1449 TEST_FIELD_OFFSET(EMRMASKBLT, iUsageMask, 108)
1450 TEST_FIELD_SIZE (EMRMASKBLT, offBmiMask, 4)
1451 TEST_FIELD_ALIGN (EMRMASKBLT, offBmiMask, 4)
1452 TEST_FIELD_OFFSET(EMRMASKBLT, offBmiMask, 112)
1453 TEST_FIELD_SIZE (EMRMASKBLT, cbBmiMask, 4)
1454 TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiMask, 4)
1455 TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiMask, 116)
1456 TEST_FIELD_SIZE (EMRMASKBLT, offBitsMask, 4)
1457 TEST_FIELD_ALIGN (EMRMASKBLT, offBitsMask, 4)
1458 TEST_FIELD_OFFSET(EMRMASKBLT, offBitsMask, 120)
1459 TEST_FIELD_SIZE (EMRMASKBLT, cbBitsMask, 4)
1460 TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsMask, 4)
1461 TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsMask, 124)
1462 }
1463
1464 static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
1465 {
1466 /* EMRMODIFYWORLDTRANSFORM */
1467 TEST_TYPE_SIZE (EMRMODIFYWORLDTRANSFORM, 36)
1468 TEST_TYPE_ALIGN (EMRMODIFYWORLDTRANSFORM, 4)
1469 TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, emr, 8)
1470 TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, emr, 4)
1471 TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, emr, 0)
1472 TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, xform, 24)
1473 TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, xform, 4)
1474 TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, xform, 8)
1475 TEST_FIELD_SIZE (EMRMODIFYWORLDTRANSFORM, iMode, 4)
1476 TEST_FIELD_ALIGN (EMRMODIFYWORLDTRANSFORM, iMode, 4)
1477 TEST_FIELD_OFFSET(EMRMODIFYWORLDTRANSFORM, iMode, 32)
1478 }
1479
1480 static void test_pack_EMRMOVETOEX(void)
1481 {
1482 /* EMRMOVETOEX */
1483 TEST_TYPE_SIZE (EMRMOVETOEX, 16)
1484 TEST_TYPE_ALIGN (EMRMOVETOEX, 4)
1485 TEST_FIELD_SIZE (EMRMOVETOEX, emr, 8)
1486 TEST_FIELD_ALIGN (EMRMOVETOEX, emr, 4)
1487 TEST_FIELD_OFFSET(EMRMOVETOEX, emr, 0)
1488 TEST_FIELD_SIZE (EMRMOVETOEX, ptl, 8)
1489 TEST_FIELD_ALIGN (EMRMOVETOEX, ptl, 4)
1490 TEST_FIELD_OFFSET(EMRMOVETOEX, ptl, 8)
1491 }
1492
1493 static void test_pack_EMROFFSETCLIPRGN(void)
1494 {
1495 /* EMROFFSETCLIPRGN */
1496 TEST_TYPE_SIZE (EMROFFSETCLIPRGN, 16)
1497 TEST_TYPE_ALIGN (EMROFFSETCLIPRGN, 4)
1498 TEST_FIELD_SIZE (EMROFFSETCLIPRGN, emr, 8)
1499 TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, emr, 4)
1500 TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, emr, 0)
1501 TEST_FIELD_SIZE (EMROFFSETCLIPRGN, ptlOffset, 8)
1502 TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, ptlOffset, 4)
1503 TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, ptlOffset, 8)
1504 }
1505
1506 static void test_pack_EMRPAINTRGN(void)
1507 {
1508 /* EMRPAINTRGN */
1509 TEST_TYPE_SIZE (EMRPAINTRGN, 32)
1510 TEST_TYPE_ALIGN (EMRPAINTRGN, 4)
1511 TEST_FIELD_SIZE (EMRPAINTRGN, emr, 8)
1512 TEST_FIELD_ALIGN (EMRPAINTRGN, emr, 4)
1513 TEST_FIELD_OFFSET(EMRPAINTRGN, emr, 0)
1514 TEST_FIELD_SIZE (EMRPAINTRGN, rclBounds, 16)
1515 TEST_FIELD_ALIGN (EMRPAINTRGN, rclBounds, 4)
1516 TEST_FIELD_OFFSET(EMRPAINTRGN, rclBounds, 8)
1517 TEST_FIELD_SIZE (EMRPAINTRGN, cbRgnData, 4)
1518 TEST_FIELD_ALIGN (EMRPAINTRGN, cbRgnData, 4)
1519 TEST_FIELD_OFFSET(EMRPAINTRGN, cbRgnData, 24)
1520 TEST_FIELD_SIZE (EMRPAINTRGN, RgnData, 1)
1521 TEST_FIELD_ALIGN (EMRPAINTRGN, RgnData, 1)
1522 TEST_FIELD_OFFSET(EMRPAINTRGN, RgnData, 28)
1523 }
1524
1525 static void test_pack_EMRPIE(void)
1526 {
1527 /* EMRPIE */
1528 TEST_TYPE_SIZE (EMRPIE, 40)
1529 TEST_TYPE_ALIGN (EMRPIE, 4)
1530 TEST_FIELD_SIZE (EMRPIE, emr, 8)
1531 TEST_FIELD_ALIGN (EMRPIE, emr, 4)
1532 TEST_FIELD_OFFSET(EMRPIE, emr, 0)
1533 TEST_FIELD_SIZE (EMRPIE, rclBox, 16)
1534 TEST_FIELD_ALIGN (EMRPIE, rclBox, 4)
1535 TEST_FIELD_OFFSET(EMRPIE, rclBox, 8)
1536 TEST_FIELD_SIZE (EMRPIE, ptlStart, 8)
1537 TEST_FIELD_ALIGN (EMRPIE, ptlStart, 4)
1538 TEST_FIELD_OFFSET(EMRPIE, ptlStart, 24)
1539 TEST_FIELD_SIZE (EMRPIE, ptlEnd, 8)
1540 TEST_FIELD_ALIGN (EMRPIE, ptlEnd, 4)
1541 TEST_FIELD_OFFSET(EMRPIE, ptlEnd, 32)
1542 }
1543
1544 static void test_pack_EMRPIXELFORMAT(void)
1545 {
1546 /* EMRPIXELFORMAT */
1547 TEST_TYPE_SIZE (EMRPIXELFORMAT, 48)
1548 TEST_TYPE_ALIGN (EMRPIXELFORMAT, 4)
1549 TEST_FIELD_SIZE (EMRPIXELFORMAT, emr, 8)
1550 TEST_FIELD_ALIGN (EMRPIXELFORMAT, emr, 4)
1551 TEST_FIELD_OFFSET(EMRPIXELFORMAT, emr, 0)
1552 TEST_FIELD_SIZE (EMRPIXELFORMAT, pfd, 40)
1553 TEST_FIELD_ALIGN (EMRPIXELFORMAT, pfd, 4)
1554 TEST_FIELD_OFFSET(EMRPIXELFORMAT, pfd, 8)
1555 }
1556
1557 static void test_pack_EMRPLGBLT(void)
1558 {
1559 /* EMRPLGBLT */
1560 TEST_TYPE_SIZE (EMRPLGBLT, 140)
1561 TEST_TYPE_ALIGN (EMRPLGBLT, 4)
1562 TEST_FIELD_SIZE (EMRPLGBLT, emr, 8)
1563 TEST_FIELD_ALIGN (EMRPLGBLT, emr, 4)
1564 TEST_FIELD_OFFSET(EMRPLGBLT, emr, 0)
1565 TEST_FIELD_SIZE (EMRPLGBLT, rclBounds, 16)
1566 TEST_FIELD_ALIGN (EMRPLGBLT, rclBounds, 4)
1567 TEST_FIELD_OFFSET(EMRPLGBLT, rclBounds, 8)
1568 TEST_FIELD_SIZE (EMRPLGBLT, aptlDest, 24)
1569 TEST_FIELD_ALIGN (EMRPLGBLT, aptlDest, 4)
1570 TEST_FIELD_OFFSET(EMRPLGBLT, aptlDest, 24)
1571 TEST_FIELD_SIZE (EMRPLGBLT, xSrc, 4)
1572 TEST_FIELD_ALIGN (EMRPLGBLT, xSrc, 4)
1573 TEST_FIELD_OFFSET(EMRPLGBLT, xSrc, 48)
1574 TEST_FIELD_SIZE (EMRPLGBLT, ySrc, 4)
1575 TEST_FIELD_ALIGN (EMRPLGBLT, ySrc, 4)
1576 TEST_FIELD_OFFSET(EMRPLGBLT, ySrc, 52)
1577 TEST_FIELD_SIZE (EMRPLGBLT, cxSrc, 4)
1578 TEST_FIELD_ALIGN (EMRPLGBLT, cxSrc, 4)
1579 TEST_FIELD_OFFSET(EMRPLGBLT, cxSrc, 56)
1580 TEST_FIELD_SIZE (EMRPLGBLT, cySrc, 4)
1581 TEST_FIELD_ALIGN (EMRPLGBLT, cySrc, 4)
1582 TEST_FIELD_OFFSET(EMRPLGBLT, cySrc, 60)
1583 TEST_FIELD_SIZE (EMRPLGBLT, xformSrc, 24)
1584 TEST_FIELD_ALIGN (EMRPLGBLT, xformSrc, 4)
1585 TEST_FIELD_OFFSET(EMRPLGBLT, xformSrc, 64)
1586 TEST_FIELD_SIZE (EMRPLGBLT, crBkColorSrc, 4)
1587 TEST_FIELD_ALIGN (EMRPLGBLT, crBkColorSrc, 4)
1588 TEST_FIELD_OFFSET(EMRPLGBLT, crBkColorSrc, 88)
1589 TEST_FIELD_SIZE (EMRPLGBLT, iUsageSrc, 4)
1590 TEST_FIELD_ALIGN (EMRPLGBLT, iUsageSrc, 4)
1591 TEST_FIELD_OFFSET(EMRPLGBLT, iUsageSrc, 92)
1592 TEST_FIELD_SIZE (EMRPLGBLT, offBmiSrc, 4)
1593 TEST_FIELD_ALIGN (EMRPLGBLT, offBmiSrc, 4)
1594 TEST_FIELD_OFFSET(EMRPLGBLT, offBmiSrc, 96)
1595 TEST_FIELD_SIZE (EMRPLGBLT, cbBmiSrc, 4)
1596 TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiSrc, 4)
1597 TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiSrc, 100)
1598 TEST_FIELD_SIZE (EMRPLGBLT, offBitsSrc, 4)
1599 TEST_FIELD_ALIGN (EMRPLGBLT, offBitsSrc, 4)
1600 TEST_FIELD_OFFSET(EMRPLGBLT, offBitsSrc, 104)
1601 TEST_FIELD_SIZE (EMRPLGBLT, cbBitsSrc, 4)
1602 TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsSrc, 4)
1603 TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsSrc, 108)
1604 TEST_FIELD_SIZE (EMRPLGBLT, xMask, 4)
1605 TEST_FIELD_ALIGN (EMRPLGBLT, xMask, 4)
1606 TEST_FIELD_OFFSET(EMRPLGBLT, xMask, 112)
1607 TEST_FIELD_SIZE (EMRPLGBLT, yMask, 4)
1608 TEST_FIELD_ALIGN (EMRPLGBLT, yMask, 4)
1609 TEST_FIELD_OFFSET(EMRPLGBLT, yMask, 116)
1610 TEST_FIELD_SIZE (EMRPLGBLT, iUsageMask, 4)
1611 TEST_FIELD_ALIGN (EMRPLGBLT, iUsageMask, 4)
1612 TEST_FIELD_OFFSET(EMRPLGBLT, iUsageMask, 120)
1613 TEST_FIELD_SIZE (EMRPLGBLT, offBmiMask, 4)
1614 TEST_FIELD_ALIGN (EMRPLGBLT, offBmiMask, 4)
1615 TEST_FIELD_OFFSET(EMRPLGBLT, offBmiMask, 124)
1616 TEST_FIELD_SIZE (EMRPLGBLT, cbBmiMask, 4)
1617 TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiMask, 4)
1618 TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiMask, 128)
1619 TEST_FIELD_SIZE (EMRPLGBLT, offBitsMask, 4)
1620 TEST_FIELD_ALIGN (EMRPLGBLT, offBitsMask, 4)
1621 TEST_FIELD_OFFSET(EMRPLGBLT, offBitsMask, 132)
1622 TEST_FIELD_SIZE (EMRPLGBLT, cbBitsMask, 4)
1623 TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsMask, 4)
1624 TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsMask, 136)
1625 }
1626
1627 static void test_pack_EMRPOLYBEZIER(void)
1628 {
1629 /* EMRPOLYBEZIER */
1630 TEST_TYPE_SIZE (EMRPOLYBEZIER, 36)
1631 TEST_TYPE_ALIGN (EMRPOLYBEZIER, 4)
1632 TEST_FIELD_SIZE (EMRPOLYBEZIER, emr, 8)
1633 TEST_FIELD_ALIGN (EMRPOLYBEZIER, emr, 4)
1634 TEST_FIELD_OFFSET(EMRPOLYBEZIER, emr, 0)
1635 TEST_FIELD_SIZE (EMRPOLYBEZIER, rclBounds, 16)
1636 TEST_FIELD_ALIGN (EMRPOLYBEZIER, rclBounds, 4)
1637 TEST_FIELD_OFFSET(EMRPOLYBEZIER, rclBounds, 8)
1638 TEST_FIELD_SIZE (EMRPOLYBEZIER, cptl, 4)
1639 TEST_FIELD_ALIGN (EMRPOLYBEZIER, cptl, 4)
1640 TEST_FIELD_OFFSET(EMRPOLYBEZIER, cptl, 24)
1641 TEST_FIELD_SIZE (EMRPOLYBEZIER, aptl, 8)
1642 TEST_FIELD_ALIGN (EMRPOLYBEZIER, aptl, 4)
1643 TEST_FIELD_OFFSET(EMRPOLYBEZIER, aptl, 28)
1644 }
1645
1646 static void test_pack_EMRPOLYBEZIER16(void)
1647 {
1648 /* EMRPOLYBEZIER16 */
1649 TEST_TYPE_SIZE (EMRPOLYBEZIER16, 32)
1650 TEST_TYPE_ALIGN (EMRPOLYBEZIER16, 4)
1651 TEST_FIELD_SIZE (EMRPOLYBEZIER16, emr, 8)
1652 TEST_FIELD_ALIGN (EMRPOLYBEZIER16, emr, 4)
1653 TEST_FIELD_OFFSET(EMRPOLYBEZIER16, emr, 0)
1654 TEST_FIELD_SIZE (EMRPOLYBEZIER16, rclBounds, 16)
1655 TEST_FIELD_ALIGN (EMRPOLYBEZIER16, rclBounds, 4)
1656 TEST_FIELD_OFFSET(EMRPOLYBEZIER16, rclBounds, 8)
1657 TEST_FIELD_SIZE (EMRPOLYBEZIER16, cpts, 4)
1658 TEST_FIELD_ALIGN (EMRPOLYBEZIER16, cpts, 4)
1659 TEST_FIELD_OFFSET(EMRPOLYBEZIER16, cpts, 24)
1660 TEST_FIELD_SIZE (EMRPOLYBEZIER16, apts, 4)
1661 TEST_FIELD_ALIGN (EMRPOLYBEZIER16, apts, 2)
1662 TEST_FIELD_OFFSET(EMRPOLYBEZIER16, apts, 28)
1663 }
1664
1665 static void test_pack_EMRPOLYBEZIERTO(void)
1666 {
1667 /* EMRPOLYBEZIERTO */
1668 TEST_TYPE_SIZE (EMRPOLYBEZIERTO, 36)
1669 TEST_TYPE_ALIGN (EMRPOLYBEZIERTO, 4)
1670 TEST_FIELD_SIZE (EMRPOLYBEZIERTO, emr, 8)
1671 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, emr, 4)
1672 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, emr, 0)
1673 TEST_FIELD_SIZE (EMRPOLYBEZIERTO, rclBounds, 16)
1674 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, rclBounds, 4)
1675 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, rclBounds, 8)
1676 TEST_FIELD_SIZE (EMRPOLYBEZIERTO, cptl, 4)
1677 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, cptl, 4)
1678 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, cptl, 24)
1679 TEST_FIELD_SIZE (EMRPOLYBEZIERTO, aptl, 8)
1680 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, aptl, 4)
1681 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, aptl, 28)
1682 }
1683
1684 static void test_pack_EMRPOLYBEZIERTO16(void)
1685 {
1686 /* EMRPOLYBEZIERTO16 */
1687 TEST_TYPE_SIZE (EMRPOLYBEZIERTO16, 32)
1688 TEST_TYPE_ALIGN (EMRPOLYBEZIERTO16, 4)
1689 TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, emr, 8)
1690 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, emr, 4)
1691 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, emr, 0)
1692 TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, rclBounds, 16)
1693 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, rclBounds, 4)
1694 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, rclBounds, 8)
1695 TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, cpts, 4)
1696 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, cpts, 4)
1697 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, cpts, 24)
1698 TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, apts, 4)
1699 TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, apts, 2)
1700 TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, apts, 28)
1701 }
1702
1703 static void test_pack_EMRPOLYDRAW(void)
1704 {
1705 /* EMRPOLYDRAW */
1706 TEST_TYPE_SIZE (EMRPOLYDRAW, 40)
1707 TEST_TYPE_ALIGN (EMRPOLYDRAW, 4)
1708 TEST_FIELD_SIZE (EMRPOLYDRAW, emr, 8)
1709 TEST_FIELD_ALIGN (EMRPOLYDRAW, emr, 4)
1710 TEST_FIELD_OFFSET(EMRPOLYDRAW, emr, 0)
1711 TEST_FIELD_SIZE (EMRPOLYDRAW, rclBounds, 16)
1712 TEST_FIELD_ALIGN (EMRPOLYDRAW, rclBounds, 4)
1713 TEST_FIELD_OFFSET(EMRPOLYDRAW, rclBounds, 8)
1714 TEST_FIELD_SIZE (EMRPOLYDRAW, cptl, 4)
1715 TEST_FIELD_ALIGN (EMRPOLYDRAW, cptl, 4)
1716 TEST_FIELD_OFFSET(EMRPOLYDRAW, cptl, 24)
1717 TEST_FIELD_SIZE (EMRPOLYDRAW, aptl, 8)
1718 TEST_FIELD_ALIGN (EMRPOLYDRAW, aptl, 4)
1719 TEST_FIELD_OFFSET(EMRPOLYDRAW, aptl, 28)
1720 TEST_FIELD_SIZE (EMRPOLYDRAW, abTypes, 1)
1721 TEST_FIELD_ALIGN (EMRPOLYDRAW, abTypes, 1)
1722 TEST_FIELD_OFFSET(EMRPOLYDRAW, abTypes, 36)
1723 }
1724
1725 static void test_pack_EMRPOLYDRAW16(void)
1726 {
1727 /* EMRPOLYDRAW16 */
1728 TEST_TYPE_SIZE (EMRPOLYDRAW16, 36)
1729 TEST_TYPE_ALIGN (EMRPOLYDRAW16, 4)
1730 TEST_FIELD_SIZE (EMRPOLYDRAW16, emr, 8)
1731 TEST_FIELD_ALIGN (EMRPOLYDRAW16, emr, 4)
1732 TEST_FIELD_OFFSET(EMRPOLYDRAW16, emr, 0)
1733 TEST_FIELD_SIZE (EMRPOLYDRAW16, rclBounds, 16)
1734 TEST_FIELD_ALIGN (EMRPOLYDRAW16, rclBounds, 4)
1735 TEST_FIELD_OFFSET(EMRPOLYDRAW16, rclBounds, 8)
1736 TEST_FIELD_SIZE (EMRPOLYDRAW16, cpts, 4)
1737 TEST_FIELD_ALIGN (EMRPOLYDRAW16, cpts, 4)
1738 TEST_FIELD_OFFSET(EMRPOLYDRAW16, cpts, 24)
1739 TEST_FIELD_SIZE (EMRPOLYDRAW16, apts, 4)
1740 TEST_FIELD_ALIGN (EMRPOLYDRAW16, apts, 2)
1741 TEST_FIELD_OFFSET(EMRPOLYDRAW16, apts, 28)
1742 TEST_FIELD_SIZE (EMRPOLYDRAW16, abTypes, 1)
1743 TEST_FIELD_ALIGN (EMRPOLYDRAW16, abTypes, 1)
1744 TEST_FIELD_OFFSET(EMRPOLYDRAW16, abTypes, 32)
1745 }
1746
1747 static void test_pack_EMRPOLYGON(void)
1748 {
1749 /* EMRPOLYGON */
1750 TEST_TYPE_SIZE (EMRPOLYGON, 36)
1751 TEST_TYPE_ALIGN (EMRPOLYGON, 4)
1752 TEST_FIELD_SIZE (EMRPOLYGON, emr, 8)
1753 TEST_FIELD_ALIGN (EMRPOLYGON, emr, 4)
1754 TEST_FIELD_OFFSET(EMRPOLYGON, emr, 0)
1755 TEST_FIELD_SIZE (EMRPOLYGON, rclBounds, 16)
1756 TEST_FIELD_ALIGN (EMRPOLYGON, rclBounds, 4)
1757 TEST_FIELD_OFFSET(EMRPOLYGON, rclBounds, 8)
1758 TEST_FIELD_SIZE (EMRPOLYGON, cptl, 4)
1759 TEST_FIELD_ALIGN (EMRPOLYGON, cptl, 4)
1760 TEST_FIELD_OFFSET(EMRPOLYGON, cptl, 24)
1761 TEST_FIELD_SIZE (EMRPOLYGON, aptl, 8)
1762 TEST_FIELD_ALIGN (EMRPOLYGON, aptl, 4)
1763 TEST_FIELD_OFFSET(EMRPOLYGON, aptl, 28)
1764 }
1765
1766 static void test_pack_EMRPOLYGON16(void)
1767 {
1768 /* EMRPOLYGON16 */
1769 TEST_TYPE_SIZE (EMRPOLYGON16, 32)
1770 TEST_TYPE_ALIGN (EMRPOLYGON16, 4)
1771 TEST_FIELD_SIZE (EMRPOLYGON16, emr, 8)
1772 TEST_FIELD_ALIGN (EMRPOLYGON16, emr, 4)
1773 TEST_FIELD_OFFSET(EMRPOLYGON16, emr, 0)
1774 TEST_FIELD_SIZE (EMRPOLYGON16, rclBounds, 16)
1775 TEST_FIELD_ALIGN (EMRPOLYGON16, rclBounds, 4)
1776 TEST_FIELD_OFFSET(EMRPOLYGON16, rclBounds, 8)
1777 TEST_FIELD_SIZE (EMRPOLYGON16, cpts, 4)
1778 TEST_FIELD_ALIGN (EMRPOLYGON16, cpts, 4)
1779 TEST_FIELD_OFFSET(EMRPOLYGON16, cpts, 24)
1780 TEST_FIELD_SIZE (EMRPOLYGON16, apts, 4)
1781 TEST_FIELD_ALIGN (EMRPOLYGON16, apts, 2)
1782 TEST_FIELD_OFFSET(EMRPOLYGON16, apts, 28)
1783 }
1784
1785 static void test_pack_EMRPOLYLINE(void)
1786 {
1787 /* EMRPOLYLINE */
1788 TEST_TYPE_SIZE (EMRPOLYLINE, 36)
1789 TEST_TYPE_ALIGN (EMRPOLYLINE, 4)
1790 TEST_FIELD_SIZE (EMRPOLYLINE, emr, 8)
1791 TEST_FIELD_ALIGN (EMRPOLYLINE, emr, 4)
1792 TEST_FIELD_OFFSET(EMRPOLYLINE, emr, 0)
1793 TEST_FIELD_SIZE (EMRPOLYLINE, rclBounds, 16)
1794 TEST_FIELD_ALIGN (EMRPOLYLINE, rclBounds, 4)
1795 TEST_FIELD_OFFSET(EMRPOLYLINE, rclBounds, 8)
1796 TEST_FIELD_SIZE (EMRPOLYLINE, cptl, 4)
1797 TEST_FIELD_ALIGN (EMRPOLYLINE, cptl, 4)
1798 TEST_FIELD_OFFSET(EMRPOLYLINE, cptl, 24)
1799 TEST_FIELD_SIZE (EMRPOLYLINE, aptl, 8)
1800 TEST_FIELD_ALIGN (EMRPOLYLINE, aptl, 4)
1801 TEST_FIELD_OFFSET(EMRPOLYLINE, aptl, 28)
1802 }
1803
1804 static void test_pack_EMRPOLYLINE16(void)
1805 {
1806 /* EMRPOLYLINE16 */
1807 TEST_TYPE_SIZE (EMRPOLYLINE16, 32)
1808 TEST_TYPE_ALIGN (EMRPOLYLINE16, 4)
1809 TEST_FIELD_SIZE (EMRPOLYLINE16, emr, 8)
1810 TEST_FIELD_ALIGN (EMRPOLYLINE16, emr, 4)
1811 TEST_FIELD_OFFSET(EMRPOLYLINE16, emr, 0)
1812 TEST_FIELD_SIZE (EMRPOLYLINE16, rclBounds, 16)
1813 TEST_FIELD_ALIGN (EMRPOLYLINE16, rclBounds, 4)
1814 TEST_FIELD_OFFSET(EMRPOLYLINE16, rclBounds, 8)
1815 TEST_FIELD_SIZE (EMRPOLYLINE16, cpts, 4)
1816 TEST_FIELD_ALIGN (EMRPOLYLINE16, cpts, 4)
1817 TEST_FIELD_OFFSET(EMRPOLYLINE16, cpts, 24)
1818 TEST_FIELD_SIZE (EMRPOLYLINE16, apts, 4)
1819 TEST_FIELD_ALIGN (EMRPOLYLINE16, apts, 2)
1820 TEST_FIELD_OFFSET(EMRPOLYLINE16, apts, 28)
1821 }
1822
1823 static void test_pack_EMRPOLYLINETO(void)
1824 {
1825 /* EMRPOLYLINETO */
1826 TEST_TYPE_SIZE (EMRPOLYLINETO, 36)
1827 TEST_TYPE_ALIGN (EMRPOLYLINETO, 4)
1828 TEST_FIELD_SIZE (EMRPOLYLINETO, emr, 8)
1829 TEST_FIELD_ALIGN (EMRPOLYLINETO, emr, 4)
1830 TEST_FIELD_OFFSET(EMRPOLYLINETO, emr, 0)
1831 TEST_FIELD_SIZE (EMRPOLYLINETO, rclBounds, 16)
1832 TEST_FIELD_ALIGN (EMRPOLYLINETO, rclBounds, 4)
1833 TEST_FIELD_OFFSET(EMRPOLYLINETO, rclBounds, 8)
1834 TEST_FIELD_SIZE (EMRPOLYLINETO, cptl, 4)
1835 TEST_FIELD_ALIGN (EMRPOLYLINETO, cptl, 4)
1836 TEST_FIELD_OFFSET(EMRPOLYLINETO, cptl, 24)
1837 TEST_FIELD_SIZE (EMRPOLYLINETO, aptl, 8)
1838 TEST_FIELD_ALIGN (EMRPOLYLINETO, aptl, 4)
1839 TEST_FIELD_OFFSET(EMRPOLYLINETO, aptl, 28)
1840 }
1841
1842 static void test_pack_EMRPOLYLINETO16(void)
1843 {
1844 /* EMRPOLYLINETO16 */
1845 TEST_TYPE_SIZE (EMRPOLYLINETO16, 32)
1846 TEST_TYPE_ALIGN (EMRPOLYLINETO16, 4)
1847 TEST_FIELD_SIZE (EMRPOLYLINETO16, emr, 8)
1848 TEST_FIELD_ALIGN (EMRPOLYLINETO16, emr, 4)
1849 TEST_FIELD_OFFSET(EMRPOLYLINETO16, emr, 0)
1850 TEST_FIELD_SIZE (EMRPOLYLINETO16, rclBounds, 16)
1851 TEST_FIELD_ALIGN (EMRPOLYLINETO16, rclBounds, 4)
1852 TEST_FIELD_OFFSET(EMRPOLYLINETO16, rclBounds, 8)
1853 TEST_FIELD_SIZE (EMRPOLYLINETO16, cpts, 4)
1854 TEST_FIELD_ALIGN (EMRPOLYLINETO16, cpts, 4)
1855 TEST_FIELD_OFFSET(EMRPOLYLINETO16, cpts, 24)
1856 TEST_FIELD_SIZE (EMRPOLYLINETO16, apts, 4)
1857 TEST_FIELD_ALIGN (EMRPOLYLINETO16, apts, 2)
1858 TEST_FIELD_OFFSET(EMRPOLYLINETO16, apts, 28)
1859 }
1860
1861 static void test_pack_EMRPOLYPOLYGON(void)
1862 {
1863 /* EMRPOLYPOLYGON */
1864 TEST_TYPE_SIZE (EMRPOLYPOLYGON, 44)
1865 TEST_TYPE_ALIGN (EMRPOLYPOLYGON, 4)
1866 TEST_FIELD_SIZE (EMRPOLYPOLYGON, emr, 8)
1867 TEST_FIELD_ALIGN (EMRPOLYPOLYGON, emr, 4)
1868 TEST_FIELD_OFFSET(EMRPOLYPOLYGON, emr, 0)
1869 TEST_FIELD_SIZE (EMRPOLYPOLYGON, rclBounds, 16)
1870 TEST_FIELD_ALIGN (EMRPOLYPOLYGON, rclBounds, 4)
1871 TEST_FIELD_OFFSET(EMRPOLYPOLYGON, rclBounds, 8)
1872 TEST_FIELD_SIZE (EMRPOLYPOLYGON, nPolys, 4)
1873 TEST_FIELD_ALIGN (EMRPOLYPOLYGON, nPolys, 4)
1874 TEST_FIELD_OFFSET(EMRPOLYPOLYGON, nPolys, 24)
1875 TEST_FIELD_SIZE (EMRPOLYPOLYGON, cptl, 4)
1876 TEST_FIELD_ALIGN (EMRPOLYPOLYGON, cptl, 4)
1877 TEST_FIELD_OFFSET(EMRPOLYPOLYGON, cptl, 28)
1878 TEST_FIELD_SIZE (EMRPOLYPOLYGON, aPolyCounts, 4)
1879 TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aPolyCounts, 4)
1880 TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aPolyCounts, 32)
1881 TEST_FIELD_SIZE (EMRPOLYPOLYGON, aptl, 8)
1882 TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aptl, 4)
1883 TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aptl, 36)
1884 }
1885
1886 static void test_pack_EMRPOLYPOLYGON16(void)
1887 {
1888 /* EMRPOLYPOLYGON16 */
1889 TEST_TYPE_SIZE (EMRPOLYPOLYGON16, 40)
1890 TEST_TYPE_ALIGN (EMRPOLYPOLYGON16, 4)
1891 TEST_FIELD_SIZE (EMRPOLYPOLYGON16, emr, 8)
1892 TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, emr, 4)
1893 TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, emr, 0)
1894 TEST_FIELD_SIZE (EMRPOLYPOLYGON16, rclBounds, 16)
1895 TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, rclBounds, 4)
1896 TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, rclBounds, 8)
1897 TEST_FIELD_SIZE (EMRPOLYPOLYGON16, nPolys, 4)
1898 TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, nPolys, 4)
1899 TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, nPolys, 24)
1900 TEST_FIELD_SIZE (EMRPOLYPOLYGON16, cpts, 4)
1901 TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, cpts, 4)
1902 TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, cpts, 28)
1903 TEST_FIELD_SIZE (EMRPOLYPOLYGON16, aPolyCounts, 4)
1904 TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, aPolyCounts, 4)
1905 TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts, 32)
1906 TEST_FIELD_SIZE (EMRPOLYPOLYGON16, apts, 4)
1907 TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, apts, 2)
1908 TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, apts, 36)
1909 }
1910
1911 static void test_pack_EMRPOLYPOLYLINE(void)
1912 {
1913 /* EMRPOLYPOLYLINE */
1914 TEST_TYPE_SIZE (EMRPOLYPOLYLINE, 44)
1915 TEST_TYPE_ALIGN (EMRPOLYPOLYLINE, 4)
1916 TEST_FIELD_SIZE (EMRPOLYPOLYLINE, emr, 8)
1917 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, emr, 4)
1918 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, emr, 0)
1919 TEST_FIELD_SIZE (EMRPOLYPOLYLINE, rclBounds, 16)
1920 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, rclBounds, 4)
1921 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, rclBounds, 8)
1922 TEST_FIELD_SIZE (EMRPOLYPOLYLINE, nPolys, 4)
1923 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, nPolys, 4)
1924 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, nPolys, 24)
1925 TEST_FIELD_SIZE (EMRPOLYPOLYLINE, cptl, 4)
1926 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, cptl, 4)
1927 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, cptl, 28)
1928 TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aPolyCounts, 4)
1929 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aPolyCounts, 4)
1930 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts, 32)
1931 TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aptl, 8)
1932 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aptl, 4)
1933 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aptl, 36)
1934 }
1935
1936 static void test_pack_EMRPOLYPOLYLINE16(void)
1937 {
1938 /* EMRPOLYPOLYLINE16 */
1939 TEST_TYPE_SIZE (EMRPOLYPOLYLINE16, 40)
1940 TEST_TYPE_ALIGN (EMRPOLYPOLYLINE16, 4)
1941 TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, emr, 8)
1942 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, emr, 4)
1943 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, emr, 0)
1944 TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, rclBounds, 16)
1945 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, rclBounds, 4)
1946 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, rclBounds, 8)
1947 TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, nPolys, 4)
1948 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, nPolys, 4)
1949 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, nPolys, 24)
1950 TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, cpts, 4)
1951 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, cpts, 4)
1952 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, cpts, 28)
1953 TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1954 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1955 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, aPolyCounts, 32)
1956 TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, apts, 4)
1957 TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, apts, 2)
1958 TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, apts, 36)
1959 }
1960
1961 static void test_pack_EMRPOLYTEXTOUTA(void)
1962 {
1963 /* EMRPOLYTEXTOUTA */
1964 TEST_TYPE_SIZE (EMRPOLYTEXTOUTA, 80)
1965 TEST_TYPE_ALIGN (EMRPOLYTEXTOUTA, 4)
1966 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, emr, 8)
1967 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, emr, 4)
1968 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, emr, 0)
1969 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, rclBounds, 16)
1970 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, rclBounds, 4)
1971 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, rclBounds, 8)
1972 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, iGraphicsMode, 4)
1973 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, iGraphicsMode, 4)
1974 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, iGraphicsMode, 24)
1975 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, exScale, 4)
1976 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, exScale, 4)
1977 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, exScale, 28)
1978 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, eyScale, 4)
1979 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, eyScale, 4)
1980 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, eyScale, 32)
1981 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, cStrings, 4)
1982 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, cStrings, 4)
1983 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, cStrings, 36)
1984 TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, aemrtext, 40)
1985 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, aemrtext, 4)
1986 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, aemrtext, 40)
1987 }
1988
1989 static void test_pack_EMRPOLYTEXTOUTW(void)
1990 {
1991 /* EMRPOLYTEXTOUTW */
1992 TEST_TYPE_SIZE (EMRPOLYTEXTOUTW, 80)
1993 TEST_TYPE_ALIGN (EMRPOLYTEXTOUTW, 4)
1994 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, emr, 8)
1995 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, emr, 4)
1996 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, emr, 0)
1997 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, rclBounds, 16)
1998 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, rclBounds, 4)
1999 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, rclBounds, 8)
2000 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, iGraphicsMode, 4)
2001 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, iGraphicsMode, 4)
2002 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, iGraphicsMode, 24)
2003 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, exScale, 4)
2004 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, exScale, 4)
2005 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, exScale, 28)
2006 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, eyScale, 4)
2007 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, eyScale, 4)
2008 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, eyScale, 32)
2009 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, cStrings, 4)
2010 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, cStrings, 4)
2011 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, cStrings, 36)
2012 TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, aemrtext, 40)
2013 TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, aemrtext, 4)
2014 TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, aemrtext, 40)
2015 }
2016
2017 static void test_pack_EMRREALIZEPALETTE(void)
2018 {
2019 /* EMRREALIZEPALETTE */
2020 TEST_TYPE_SIZE (EMRREALIZEPALETTE, 8)
2021 TEST_TYPE_ALIGN (EMRREALIZEPALETTE, 4)
2022 TEST_FIELD_SIZE (EMRREALIZEPALETTE, emr, 8)
2023 TEST_FIELD_ALIGN (EMRREALIZEPALETTE, emr, 4)
2024 TEST_FIELD_OFFSET(EMRREALIZEPALETTE, emr, 0)
2025 }
2026
2027 static void test_pack_EMRRECTANGLE(void)
2028 {
2029 /* EMRRECTANGLE */
2030 TEST_TYPE_SIZE (EMRRECTANGLE, 24)
2031 TEST_TYPE_ALIGN (EMRRECTANGLE, 4)
2032 TEST_FIELD_SIZE (EMRRECTANGLE, emr, 8)
2033 TEST_FIELD_ALIGN (EMRRECTANGLE, emr, 4)
2034 TEST_FIELD_OFFSET(EMRRECTANGLE, emr, 0)
2035 TEST_FIELD_SIZE (EMRRECTANGLE, rclBox, 16)
2036 TEST_FIELD_ALIGN (EMRRECTANGLE, rclBox, 4)
2037 TEST_FIELD_OFFSET(EMRRECTANGLE, rclBox, 8)
2038 }
2039
2040 static void test_pack_EMRRESIZEPALETTE(void)
2041 {
2042 /* EMRRESIZEPALETTE */
2043 TEST_TYPE_SIZE (EMRRESIZEPALETTE, 16)
2044 TEST_TYPE_ALIGN (EMRRESIZEPALETTE, 4)
2045 TEST_FIELD_SIZE (EMRRESIZEPALETTE, emr, 8)
2046 TEST_FIELD_ALIGN (EMRRESIZEPALETTE, emr, 4)
2047 TEST_FIELD_OFFSET(EMRRESIZEPALETTE, emr, 0)
2048 TEST_FIELD_SIZE (EMRRESIZEPALETTE, ihPal, 4)
2049 TEST_FIELD_ALIGN (EMRRESIZEPALETTE, ihPal, 4)
2050 TEST_FIELD_OFFSET(EMRRESIZEPALETTE, ihPal, 8)
2051 TEST_FIELD_SIZE (EMRRESIZEPALETTE, cEntries, 4)
2052 TEST_FIELD_ALIGN (EMRRESIZEPALETTE, cEntries, 4)
2053 TEST_FIELD_OFFSET(EMRRESIZEPALETTE, cEntries, 12)
2054 }
2055
2056 static void test_pack_EMRRESTOREDC(void)
2057 {
2058 /* EMRRESTOREDC */
2059 TEST_TYPE_SIZE (EMRRESTOREDC, 12)
2060 TEST_TYPE_ALIGN (EMRRESTOREDC, 4)
2061 TEST_FIELD_SIZE (EMRRESTOREDC, emr, 8)
2062 TEST_FIELD_ALIGN (EMRRESTOREDC, emr, 4)
2063 TEST_FIELD_OFFSET(EMRRESTOREDC, emr, 0)
2064 TEST_FIELD_SIZE (EMRRESTOREDC, iRelative, 4)
2065 TEST_FIELD_ALIGN (EMRRESTOREDC, iRelative, 4)
2066 TEST_FIELD_OFFSET(EMRRESTOREDC, iRelative, 8)
2067 }
2068
2069 static void test_pack_EMRROUNDRECT(void)
2070 {
2071 /* EMRROUNDRECT */
2072 TEST_TYPE_SIZE (EMRROUNDRECT, 32)
2073 TEST_TYPE_ALIGN (EMRROUNDRECT, 4)
2074 TEST_FIELD_SIZE (EMRROUNDRECT, emr, 8)
2075 TEST_FIELD_ALIGN (EMRROUNDRECT, emr, 4)
2076 TEST_FIELD_OFFSET(EMRROUNDRECT, emr, 0)
2077 TEST_FIELD_SIZE (EMRROUNDRECT, rclBox, 16)
2078 TEST_FIELD_ALIGN (EMRROUNDRECT, rclBox, 4)
2079 TEST_FIELD_OFFSET(EMRROUNDRECT, rclBox, 8)
2080 TEST_FIELD_SIZE (EMRROUNDRECT, szlCorner, 8)
2081 TEST_FIELD_ALIGN (EMRROUNDRECT, szlCorner, 4)
2082 TEST_FIELD_OFFSET(EMRROUNDRECT, szlCorner, 24)
2083 }
2084
2085 static void test_pack_EMRSAVEDC(void)
2086 {
2087 /* EMRSAVEDC */
2088 TEST_TYPE_SIZE (EMRSAVEDC, 8)
2089 TEST_TYPE_ALIGN (EMRSAVEDC, 4)
2090 TEST_FIELD_SIZE (EMRSAVEDC, emr, 8)
2091 TEST_FIELD_ALIGN (EMRSAVEDC, emr, 4)
2092 TEST_FIELD_OFFSET(EMRSAVEDC, emr, 0)
2093 }
2094
2095 static void test_pack_EMRSCALEVIEWPORTEXTEX(void)
2096 {
2097 /* EMRSCALEVIEWPORTEXTEX */
2098 TEST_TYPE_SIZE (EMRSCALEVIEWPORTEXTEX, 24)
2099 TEST_TYPE_ALIGN (EMRSCALEVIEWPORTEXTEX, 4)
2100 TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, emr, 8)
2101 TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, emr, 4)
2102 TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, emr, 0)
2103 TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, xNum, 4)
2104 TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xNum, 4)
2105 TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xNum, 8)
2106 TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, xDenom, 4)
2107 TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, xDenom, 4)
2108 TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, xDenom, 12)
2109 TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, yNum, 4)
2110 TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yNum, 4)
2111 TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yNum, 16)
2112 TEST_FIELD_SIZE (EMRSCALEVIEWPORTEXTEX, yDenom, 4)
2113 TEST_FIELD_ALIGN (EMRSCALEVIEWPORTEXTEX, yDenom, 4)
2114 TEST_FIELD_OFFSET(EMRSCALEVIEWPORTEXTEX, yDenom, 20)
2115 }
2116
2117 static void test_pack_EMRSCALEWINDOWEXTEX(void)
2118 {
2119 /* EMRSCALEWINDOWEXTEX */
2120 TEST_TYPE_SIZE (EMRSCALEWINDOWEXTEX, 24)
2121 TEST_TYPE_ALIGN (EMRSCALEWINDOWEXTEX, 4)
2122 TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, emr, 8)
2123 TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, emr, 4)
2124 TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, emr, 0)
2125 TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, xNum, 4)
2126 TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xNum, 4)
2127 TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xNum, 8)
2128 TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, xDenom, 4)
2129 TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, xDenom, 4)
2130 TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, xDenom, 12)
2131 TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, yNum, 4)
2132 TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yNum, 4)
2133 TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yNum, 16)
2134 TEST_FIELD_SIZE (EMRSCALEWINDOWEXTEX, yDenom, 4)
2135 TEST_FIELD_ALIGN (EMRSCALEWINDOWEXTEX, yDenom, 4)
2136 TEST_FIELD_OFFSET(EMRSCALEWINDOWEXTEX, yDenom, 20)
2137 }
2138
2139 static void test_pack_EMRSELECTCLIPPATH(void)
2140 {
2141 /* EMRSELECTCLIPPATH */
2142 TEST_TYPE_SIZE (EMRSELECTCLIPPATH, 12)
2143 TEST_TYPE_ALIGN (EMRSELECTCLIPPATH, 4)
2144 TEST_FIELD_SIZE (EMRSELECTCLIPPATH, emr, 8)
2145 TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, emr, 4)
2146 TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, emr, 0)
2147 TEST_FIELD_SIZE (EMRSELECTCLIPPATH, iMode, 4)
2148 TEST_FIELD_ALIGN (EMRSELECTCLIPPATH, iMode, 4)
2149 TEST_FIELD_OFFSET(EMRSELECTCLIPPATH, iMode, 8)
2150 }
2151
2152 static void test_pack_EMRSELECTCOLORSPACE(void)
2153 {
2154 /* EMRSELECTCOLORSPACE */
2155 TEST_TYPE_SIZE (EMRSELECTCOLORSPACE, 12)
2156 TEST_TYPE_ALIGN (EMRSELECTCOLORSPACE, 4)
2157 TEST_FIELD_SIZE (EMRSELECTCOLORSPACE, emr, 8)
2158 TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, emr, 4)
2159 TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, emr, 0)
2160 TEST_FIELD_SIZE (EMRSELECTCOLORSPACE, ihCS, 4)
2161 TEST_FIELD_ALIGN (EMRSELECTCOLORSPACE, ihCS, 4)
2162 TEST_FIELD_OFFSET(EMRSELECTCOLORSPACE, ihCS, 8)
2163 }
2164
2165 static void test_pack_EMRSELECTOBJECT(void)
2166 {
2167 /* EMRSELECTOBJECT */
2168 TEST_TYPE_SIZE (EMRSELECTOBJECT, 12)
2169 TEST_TYPE_ALIGN (EMRSELECTOBJECT, 4)
2170 TEST_FIELD_SIZE (EMRSELECTOBJECT, emr, 8)
2171 TEST_FIELD_ALIGN (EMRSELECTOBJECT, emr, 4)
2172 TEST_FIELD_OFFSET(EMRSELECTOBJECT, emr, 0)
2173 TEST_FIELD_SIZE (EMRSELECTOBJECT, ihObject, 4)
2174 TEST_FIELD_ALIGN (EMRSELECTOBJECT, ihObject, 4)
2175 TEST_FIELD_OFFSET(EMRSELECTOBJECT, ihObject, 8)
2176 }
2177
2178 static void test_pack_EMRSELECTPALETTE(void)
2179 {
2180 /* EMRSELECTPALETTE */
2181 TEST_TYPE_SIZE (EMRSELECTPALETTE, 12)
2182 TEST_TYPE_ALIGN (EMRSELECTPALETTE, 4)
2183 TEST_FIELD_SIZE (EMRSELECTPALETTE, emr, 8)
2184 TEST_FIELD_ALIGN (EMRSELECTPALETTE, emr, 4)
2185 TEST_FIELD_OFFSET(EMRSELECTPALETTE, emr, 0)
2186 TEST_FIELD_SIZE (EMRSELECTPALETTE, ihPal, 4)
2187 TEST_FIELD_ALIGN (EMRSELECTPALETTE, ihPal, 4)
2188 TEST_FIELD_OFFSET(EMRSELECTPALETTE, ihPal, 8)
2189 }
2190
2191 static void test_pack_EMRSETARCDIRECTION(void)
2192 {
2193 /* EMRSETARCDIRECTION */
2194 TEST_TYPE_SIZE (EMRSETARCDIRECTION, 12)
2195 TEST_TYPE_ALIGN (EMRSETARCDIRECTION, 4)
2196 TEST_FIELD_SIZE (EMRSETARCDIRECTION, emr, 8)
2197 TEST_FIELD_ALIGN (EMRSETARCDIRECTION, emr, 4)
2198 TEST_FIELD_OFFSET(EMRSETARCDIRECTION, emr, 0)
2199 TEST_FIELD_SIZE (EMRSETARCDIRECTION, iArcDirection, 4)
2200 TEST_FIELD_ALIGN (EMRSETARCDIRECTION, iArcDirection, 4)
2201 TEST_FIELD_OFFSET(EMRSETARCDIRECTION, iArcDirection, 8)
2202 }
2203
2204 static void test_pack_EMRSETBKCOLOR(void)
2205 {
2206 /* EMRSETBKCOLOR */
2207 TEST_TYPE_SIZE (EMRSETBKCOLOR, 12)
2208 TEST_TYPE_ALIGN (EMRSETBKCOLOR, 4)
2209 TEST_FIELD_SIZE (EMRSETBKCOLOR, emr, 8)
2210 TEST_FIELD_ALIGN (EMRSETBKCOLOR, emr, 4)
2211 TEST_FIELD_OFFSET(EMRSETBKCOLOR, emr, 0)
2212 TEST_FIELD_SIZE (EMRSETBKCOLOR, crColor, 4)
2213 TEST_FIELD_ALIGN (EMRSETBKCOLOR, crColor, 4)
2214 TEST_FIELD_OFFSET(EMRSETBKCOLOR, crColor, 8)
2215 }
2216
2217 static void test_pack_EMRSETBKMODE(void)
2218 {
2219 /* EMRSETBKMODE */
2220 TEST_TYPE_SIZE (EMRSETBKMODE, 12)
2221 TEST_TYPE_ALIGN (EMRSETBKMODE, 4)
2222 TEST_FIELD_SIZE (EMRSETBKMODE, emr, 8)
2223 TEST_FIELD_ALIGN (EMRSETBKMODE, emr, 4)
2224 TEST_FIELD_OFFSET(EMRSETBKMODE, emr, 0)
2225 TEST_FIELD_SIZE (EMRSETBKMODE, iMode, 4)
2226 TEST_FIELD_ALIGN (EMRSETBKMODE, iMode, 4)
2227 TEST_FIELD_OFFSET(EMRSETBKMODE, iMode, 8)
2228 }
2229
2230 static void test_pack_EMRSETBRUSHORGEX(void)
2231 {
2232 /* EMRSETBRUSHORGEX */
2233 TEST_TYPE_SIZE (EMRSETBRUSHORGEX, 16)
2234 TEST_TYPE_ALIGN (EMRSETBRUSHORGEX, 4)
2235 TEST_FIELD_SIZE (EMRSETBRUSHORGEX, emr, 8)
2236 TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, emr, 4)
2237 TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, emr, 0)
2238 TEST_FIELD_SIZE (EMRSETBRUSHORGEX, ptlOrigin, 8)
2239 TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, ptlOrigin, 4)
2240 TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, ptlOrigin, 8)
2241 }
2242
2243 static void test_pack_EMRSETCOLORADJUSTMENT(void)
2244 {
2245 /* EMRSETCOLORADJUSTMENT */
2246 TEST_TYPE_SIZE (EMRSETCOLORADJUSTMENT, 32)
2247 TEST_TYPE_ALIGN (EMRSETCOLORADJUSTMENT, 4)
2248 TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, emr, 8)
2249 TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, emr, 4)
2250 TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, emr, 0)
2251 TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, ColorAdjustment, 24)
2252 TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, ColorAdjustment, 2)
2253 TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, ColorAdjustment, 8)
2254 }
2255
2256 static void test_pack_EMRSETCOLORSPACE(void)
2257 {
2258 /* EMRSETCOLORSPACE */
2259 TEST_TYPE_SIZE (EMRSETCOLORSPACE, 12)
2260 TEST_TYPE_ALIGN (EMRSETCOLORSPACE, 4)
2261 TEST_FIELD_SIZE (EMRSETCOLORSPACE, emr, 8)
2262 TEST_FIELD_ALIGN (EMRSETCOLORSPACE, emr, 4)
2263 TEST_FIELD_OFFSET(EMRSETCOLORSPACE, emr, 0)
2264 TEST_FIELD_SIZE (EMRSETCOLORSPACE, ihCS, 4)
2265 TEST_FIELD_ALIGN (EMRSETCOLORSPACE, ihCS, 4)
2266 TEST_FIELD_OFFSET(EMRSETCOLORSPACE, ihCS, 8)
2267 }
2268
2269 static void test_pack_EMRSETDIBITSTODEVICE(void)
2270 {
2271 /* EMRSETDIBITSTODEVICE */
2272 TEST_TYPE_SIZE (EMRSETDIBITSTODEVICE, 76)
2273 TEST_TYPE_ALIGN (EMRSETDIBITSTODEVICE, 4)
2274 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, emr, 8)
2275 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, emr, 4)
2276 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, emr, 0)
2277 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, rclBounds, 16)
2278 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, rclBounds, 4)
2279 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, rclBounds, 8)
2280 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, xDest, 4)
2281 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xDest, 4)
2282 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xDest, 24)
2283 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, yDest, 4)
2284 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, yDest, 4)
2285 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, yDest, 28)
2286 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, xSrc, 4)
2287 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, xSrc, 4)
2288 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, xSrc, 32)
2289 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, ySrc, 4)
2290 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, ySrc, 4)
2291 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, ySrc, 36)
2292 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cxSrc, 4)
2293 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cxSrc, 4)
2294 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cxSrc, 40)
2295 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cySrc, 4)
2296 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cySrc, 4)
2297 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cySrc, 44)
2298 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBmiSrc, 4)
2299 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBmiSrc, 4)
2300 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBmiSrc, 48)
2301 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBmiSrc, 4)
2302 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBmiSrc, 4)
2303 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBmiSrc, 52)
2304 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBitsSrc, 4)
2305 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBitsSrc, 4)
2306 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBitsSrc, 56)
2307 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBitsSrc, 4)
2308 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBitsSrc, 4)
2309 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBitsSrc, 60)
2310 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iUsageSrc, 4)
2311 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iUsageSrc, 4)
2312 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iUsageSrc, 64)
2313 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iStartScan, 4)
2314 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iStartScan, 4)
2315 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iStartScan, 68)
2316 TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cScans, 4)
2317 TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cScans, 4)
2318 TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cScans, 72)
2319 }
2320
2321 static void test_pack_EMRSETICMMODE(void)
2322 {
2323 /* EMRSETICMMODE */
2324 TEST_TYPE_SIZE (EMRSETICMMODE, 12)
2325 TEST_TYPE_ALIGN (EMRSETICMMODE, 4)
2326 TEST_FIELD_SIZE (EMRSETICMMODE, emr, 8)
2327 TEST_FIELD_ALIGN (EMRSETICMMODE, emr, 4)
2328 TEST_FIELD_OFFSET(EMRSETICMMODE, emr, 0)
2329 TEST_FIELD_SIZE (EMRSETICMMODE, iMode, 4)
2330 TEST_FIELD_ALIGN (EMRSETICMMODE, iMode, 4)
2331 TEST_FIELD_OFFSET(EMRSETICMMODE, iMode, 8)
2332 }
2333
2334 static void test_pack_EMRSETLAYOUT(void)
2335 {
2336 /* EMRSETLAYOUT */
2337 TEST_TYPE_SIZE (EMRSETLAYOUT, 12)
2338 TEST_TYPE_ALIGN (EMRSETLAYOUT, 4)
2339 TEST_FIELD_SIZE (EMRSETLAYOUT, emr, 8)
2340 TEST_FIELD_ALIGN (EMRSETLAYOUT, emr, 4)
2341 TEST_FIELD_OFFSET(EMRSETLAYOUT, emr, 0)
2342 TEST_FIELD_SIZE (EMRSETLAYOUT, iMode, 4)
2343 TEST_FIELD_ALIGN (EMRSETLAYOUT, iMode, 4)
2344 TEST_FIELD_OFFSET(EMRSETLAYOUT, iMode, 8)
2345 }
2346
2347 static void test_pack_EMRSETMAPMODE(void)
2348 {
2349 /* EMRSETMAPMODE */
2350 TEST_TYPE_SIZE (EMRSETMAPMODE, 12)
2351 TEST_TYPE_ALIGN (EMRSETMAPMODE, 4)
2352 TEST_FIELD_SIZE (EMRSETMAPMODE, emr, 8)
2353 TEST_FIELD_ALIGN (EMRSETMAPMODE, emr, 4)
2354 TEST_FIELD_OFFSET(EMRSETMAPMODE, emr, 0)
2355 TEST_FIELD_SIZE (EMRSETMAPMODE, iMode, 4)
2356 TEST_FIELD_ALIGN (EMRSETMAPMODE, iMode, 4)
2357 TEST_FIELD_OFFSET(EMRSETMAPMODE, iMode, 8)
2358 }
2359
2360 static void test_pack_EMRSETMAPPERFLAGS(void)
2361 {
2362 /* EMRSETMAPPERFLAGS */
2363 TEST_TYPE_SIZE (EMRSETMAPPERFLAGS, 12)
2364 TEST_TYPE_ALIGN (EMRSETMAPPERFLAGS, 4)
2365 TEST_FIELD_SIZE (EMRSETMAPPERFLAGS, emr, 8)
2366 TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, emr, 4)
2367 TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, emr, 0)
2368 TEST_FIELD_SIZE (EMRSETMAPPERFLAGS, dwFlags, 4)
2369 TEST_FIELD_ALIGN (EMRSETMAPPERFLAGS, dwFlags, 4)
2370 TEST_FIELD_OFFSET(EMRSETMAPPERFLAGS, dwFlags, 8)
2371 }
2372
2373 static void test_pack_EMRSETMETARGN(void)
2374 {
2375 /* EMRSETMETARGN */
2376 TEST_TYPE_SIZE (EMRSETMETARGN, 8)
2377 TEST_TYPE_ALIGN (EMRSETMETARGN, 4)
2378 TEST_FIELD_SIZE (EMRSETMETARGN, emr, 8)
2379 TEST_FIELD_ALIGN (EMRSETMETARGN, emr, 4)
2380 TEST_FIELD_OFFSET(EMRSETMETARGN, emr, 0)
2381 }
2382
2383 static void test_pack_EMRSETMITERLIMIT(void)
2384 {
2385 /* EMRSETMITERLIMIT */
2386 TEST_TYPE_SIZE (EMRSETMITERLIMIT, 12)
2387 TEST_TYPE_ALIGN (EMRSETMITERLIMIT, 4)
2388 TEST_FIELD_SIZE (EMRSETMITERLIMIT, emr, 8)
2389 TEST_FIELD_ALIGN (EMRSETMITERLIMIT, emr, 4)
2390 TEST_FIELD_OFFSET(EMRSETMITERLIMIT, emr, 0)
2391 TEST_FIELD_SIZE (EMRSETMITERLIMIT, eMiterLimit, 4)
2392 TEST_FIELD_ALIGN (EMRSETMITERLIMIT, eMiterLimit, 4)
2393 TEST_FIELD_OFFSET(EMRSETMITERLIMIT, eMiterLimit, 8)
2394 }
2395
2396 static void test_pack_EMRSETPIXELV(void)
2397 {
2398 /* EMRSETPIXELV */
2399 TEST_TYPE_SIZE (EMRSETPIXELV, 20)
2400 TEST_TYPE_ALIGN (EMRSETPIXELV, 4)
2401 TEST_FIELD_SIZE (EMRSETPIXELV, emr, 8)
2402 TEST_FIELD_ALIGN (EMRSETPIXELV, emr, 4)
2403 TEST_FIELD_OFFSET(EMRSETPIXELV, emr, 0)
2404 TEST_FIELD_SIZE (EMRSETPIXELV, ptlPixel, 8)
2405 TEST_FIELD_ALIGN (EMRSETPIXELV, ptlPixel, 4)
2406 TEST_FIELD_OFFSET(EMRSETPIXELV, ptlPixel, 8)
2407 TEST_FIELD_SIZE (EMRSETPIXELV, crColor, 4)
2408 TEST_FIELD_ALIGN (EMRSETPIXELV, crColor, 4)
2409 TEST_FIELD_OFFSET(EMRSETPIXELV, crColor, 16)
2410 }
2411
2412 static void test_pack_EMRSETPOLYFILLMODE(void)
2413 {
2414 /* EMRSETPOLYFILLMODE */
2415 TEST_TYPE_SIZE (EMRSETPOLYFILLMODE, 12)
2416 TEST_TYPE_ALIGN (EMRSETPOLYFILLMODE, 4)
2417 TEST_FIELD_SIZE (EMRSETPOLYFILLMODE, emr, 8)
2418 TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, emr, 4)
2419 TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, emr, 0)
2420 TEST_FIELD_SIZE (EMRSETPOLYFILLMODE, iMode, 4)
2421 TEST_FIELD_ALIGN (EMRSETPOLYFILLMODE, iMode, 4)
2422 TEST_FIELD_OFFSET(EMRSETPOLYFILLMODE, iMode, 8)
2423 }
2424
2425 static void test_pack_EMRSETROP2(void)
2426 {
2427 /* EMRSETROP2 */
2428 TEST_TYPE_SIZE (EMRSETROP2, 12)
2429 TEST_TYPE_ALIGN (EMRSETROP2, 4)
2430 TEST_FIELD_SIZE (EMRSETROP2, emr, 8)
2431 TEST_FIELD_ALIGN (EMRSETROP2, emr, 4)
2432 TEST_FIELD_OFFSET(EMRSETROP2, emr, 0)
2433 TEST_FIELD_SIZE (EMRSETROP2, iMode, 4)
2434 TEST_FIELD_ALIGN (EMRSETROP2, iMode, 4)
2435 TEST_FIELD_OFFSET(EMRSETROP2, iMode, 8)
2436 }
2437
2438 static void test_pack_EMRSETSTRETCHBLTMODE(void)
2439 {
2440 /* EMRSETSTRETCHBLTMODE */
2441 TEST_TYPE_SIZE (EMRSETSTRETCHBLTMODE, 12)
2442 TEST_TYPE_ALIGN (EMRSETSTRETCHBLTMODE, 4)
2443 TEST_FIELD_SIZE (EMRSETSTRETCHBLTMODE, emr, 8)
2444 TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, emr, 4)
2445 TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, emr, 0)
2446 TEST_FIELD_SIZE (EMRSETSTRETCHBLTMODE, iMode, 4)
2447 TEST_FIELD_ALIGN (EMRSETSTRETCHBLTMODE, iMode, 4)
2448 TEST_FIELD_OFFSET(EMRSETSTRETCHBLTMODE, iMode, 8)
2449 }
2450
2451 static void test_pack_EMRSETTEXTALIGN(void)
2452 {
2453 /* EMRSETTEXTALIGN */
2454 TEST_TYPE_SIZE (EMRSETTEXTALIGN, 12)
2455 TEST_TYPE_ALIGN (EMRSETTEXTALIGN, 4)
2456 TEST_FIELD_SIZE (EMRSETTEXTALIGN, emr, 8)
2457 TEST_FIELD_ALIGN (EMRSETTEXTALIGN, emr, 4)
2458 TEST_FIELD_OFFSET(EMRSETTEXTALIGN, emr, 0)
2459 TEST_FIELD_SIZE (EMRSETTEXTALIGN, iMode, 4)
2460 TEST_FIELD_ALIGN (EMRSETTEXTALIGN, iMode, 4)
2461 TEST_FIELD_OFFSET(EMRSETTEXTALIGN, iMode, 8)
2462 }
2463
2464 static void test_pack_EMRSETTEXTCOLOR(void)
2465 {
2466 /* EMRSETTEXTCOLOR */
2467 TEST_TYPE_SIZE (EMRSETTEXTCOLOR, 12)
2468 TEST_TYPE_ALIGN (EMRSETTEXTCOLOR, 4)
2469 TEST_FIELD_SIZE (EMRSETTEXTCOLOR, emr, 8)
2470 TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, emr, 4)
2471 TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, emr, 0)
2472 TEST_FIELD_SIZE (EMRSETTEXTCOLOR, crColor, 4)
2473 TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, crColor, 4)
2474 TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, crColor, 8)
2475 }
2476
2477 static void test_pack_EMRSETVIEWPORTEXTEX(void)
2478 {
2479 /* EMRSETVIEWPORTEXTEX */
2480 TEST_TYPE_SIZE (EMRSETVIEWPORTEXTEX, 16)
2481 TEST_TYPE_ALIGN (EMRSETVIEWPORTEXTEX, 4)
2482 TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, emr, 8)
2483 TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, emr, 4)
2484 TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, emr, 0)
2485 TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, szlExtent, 8)
2486 TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, szlExtent, 4)
2487 TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, szlExtent, 8)
2488 }
2489
2490 static void test_pack_EMRSETVIEWPORTORGEX(void)
2491 {
2492 /* EMRSETVIEWPORTORGEX */
2493 TEST_TYPE_SIZE (EMRSETVIEWPORTORGEX, 16)
2494 TEST_TYPE_ALIGN (EMRSETVIEWPORTORGEX, 4)
2495 TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, emr, 8)
2496 TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, emr, 4)
2497 TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, emr, 0)
2498 TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, ptlOrigin, 8)
2499 TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, ptlOrigin, 4)
2500 TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, ptlOrigin, 8)
2501 }
2502
2503 static void test_pack_EMRSETWINDOWEXTEX(void)
2504 {
2505 /* EMRSETWINDOWEXTEX */
2506 TEST_TYPE_SIZE (EMRSETWINDOWEXTEX, 16)
2507 TEST_TYPE_ALIGN (EMRSETWINDOWEXTEX, 4)
2508 TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, emr, 8)
2509 TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, emr, 4)
2510 TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, emr, 0)
2511 TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, szlExtent, 8)
2512 TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, szlExtent, 4)
2513 TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, szlExtent, 8)
2514 }
2515
2516 static void test_pack_EMRSETWINDOWORGEX(void)
2517 {
2518 /* EMRSETWINDOWORGEX */
2519 TEST_TYPE_SIZE (EMRSETWINDOWORGEX, 16)
2520 TEST_TYPE_ALIGN (EMRSETWINDOWORGEX, 4)
2521 TEST_FIELD_SIZE (EMRSETWINDOWORGEX, emr, 8)
2522 TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, emr, 4)
2523 TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, emr, 0)
2524 TEST_FIELD_SIZE (EMRSETWINDOWORGEX, ptlOrigin, 8)
2525 TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, ptlOrigin, 4)
2526 TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, ptlOrigin, 8)
2527 }
2528
2529 static void test_pack_EMRSETWORLDTRANSFORM(void)
2530 {
2531 /* EMRSETWORLDTRANSFORM */
2532 TEST_TYPE_SIZE (EMRSETWORLDTRANSFORM, 32)
2533 TEST_TYPE_ALIGN (EMRSETWORLDTRANSFORM, 4)
2534 TEST_FIELD_SIZE (EMRSETWORLDTRANSFORM, emr, 8)
2535 TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, emr, 4)
2536 TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, emr, 0)
2537 TEST_FIELD_SIZE (EMRSETWORLDTRANSFORM, xform, 24)
2538 TEST_FIELD_ALIGN (EMRSETWORLDTRANSFORM, xform, 4)
2539 TEST_FIELD_OFFSET(EMRSETWORLDTRANSFORM, xform, 8)
2540 }
2541
2542 static void test_pack_EMRSTRETCHBLT(void)
2543 {
2544 /* EMRSTRETCHBLT */
2545 TEST_TYPE_SIZE (EMRSTRETCHBLT, 108)
2546 TEST_TYPE_ALIGN (EMRSTRETCHBLT, 4)
2547 TEST_FIELD_SIZE (EMRSTRETCHBLT, emr, 8)
2548 TEST_FIELD_ALIGN (EMRSTRETCHBLT, emr, 4)
2549 TEST_FIELD_OFFSET(EMRSTRETCHBLT, emr, 0)
2550 TEST_FIELD_SIZE (EMRSTRETCHBLT, rclBounds, 16)
2551 TEST_FIELD_ALIGN (EMRSTRETCHBLT, rclBounds, 4)
2552 TEST_FIELD_OFFSET(EMRSTRETCHBLT, rclBounds, 8)
2553 TEST_FIELD_SIZE (EMRSTRETCHBLT, xDest, 4)
2554 TEST_FIELD_ALIGN (EMRSTRETCHBLT, xDest, 4)
2555 TEST_FIELD_OFFSET(EMRSTRETCHBLT, xDest, 24)
2556 TEST_FIELD_SIZE (EMRSTRETCHBLT, yDest, 4)
2557 TEST_FIELD_ALIGN (EMRSTRETCHBLT, yDest, 4)
2558 TEST_FIELD_OFFSET(EMRSTRETCHBLT, yDest, 28)
2559 TEST_FIELD_SIZE (EMRSTRETCHBLT, cxDest, 4)
2560 TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxDest, 4)
2561 TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxDest, 32)
2562 TEST_FIELD_SIZE (EMRSTRETCHBLT, cyDest, 4)
2563 TEST_FIELD_ALIGN (EMRSTRETCHBLT, cyDest, 4)
2564 TEST_FIELD_OFFSET(EMRSTRETCHBLT, cyDest, 36)
2565 TEST_FIELD_SIZE (EMRSTRETCHBLT, dwRop, 4)
2566 TEST_FIELD_ALIGN (EMRSTRETCHBLT, dwRop, 4)
2567 TEST_FIELD_OFFSET(EMRSTRETCHBLT, dwRop, 40)
2568 TEST_FIELD_SIZE (EMRSTRETCHBLT, xSrc, 4)
2569 TEST_FIELD_ALIGN (EMRSTRETCHBLT, xSrc, 4)
2570 TEST_FIELD_OFFSET(EMRSTRETCHBLT, xSrc, 44)
2571 TEST_FIELD_SIZE (EMRSTRETCHBLT, ySrc, 4)
2572 TEST_FIELD_ALIGN (EMRSTRETCHBLT, ySrc, 4)
2573 TEST_FIELD_OFFSET(EMRSTRETCHBLT, ySrc, 48)
2574 TEST_FIELD_SIZE (EMRSTRETCHBLT, xformSrc, 24)
2575 TEST_FIELD_ALIGN (EMRSTRETCHBLT, xformSrc, 4)
2576 TEST_FIELD_OFFSET(EMRSTRETCHBLT, xformSrc, 52)
2577 TEST_FIELD_SIZE (EMRSTRETCHBLT, crBkColorSrc, 4)
2578 TEST_FIELD_ALIGN (EMRSTRETCHBLT, crBkColorSrc, 4)
2579 TEST_FIELD_OFFSET(EMRSTRETCHBLT, crBkColorSrc, 76)
2580 TEST_FIELD_SIZE (EMRSTRETCHBLT, iUsageSrc, 4)
2581 TEST_FIELD_ALIGN (EMRSTRETCHBLT, iUsageSrc, 4)
2582 TEST_FIELD_OFFSET(EMRSTRETCHBLT, iUsageSrc, 80)
2583 TEST_FIELD_SIZE (EMRSTRETCHBLT, offBmiSrc, 4)
2584 TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBmiSrc, 4)
2585 TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBmiSrc, 84)
2586 TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBmiSrc, 4)
2587 TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBmiSrc, 4)
2588 TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBmiSrc, 88)
2589 TEST_FIELD_SIZE (EMRSTRETCHBLT, offBitsSrc, 4)
2590 TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBitsSrc, 4)
2591 TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBitsSrc, 92)
2592 TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBitsSrc, 4)
2593 TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBitsSrc, 4)
2594 TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBitsSrc, 96)
2595 TEST_FIELD_SIZE (EMRSTRETCHBLT, cxSrc, 4)
2596 TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxSrc, 4)
2597 TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxSrc, 100)
2598 TEST_FIELD_SIZE (EMRSTRETCHBLT, cySrc, 4)
2599 TEST_FIELD_ALIGN (EMRSTRETCHBLT, cySrc, 4)
2600 TEST_FIELD_OFFSET(EMRSTRETCHBLT, cySrc, 104)