1 /* File generated automatically from tools/winapi/test.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 #define WINVER 0x0501
9 #define _WIN32_IE 0x0501
10 #define _WIN32_WINNT 0x0501
11
12 #define WINE_NOWINSOCK
13
14 #include "windows.h"
15
16 #include "wine/test.h"
17
18 /***********************************************************************
19 * Compatibility macros
20 */
21
22 #define DWORD_PTR UINT_PTR
23 #define LONG_PTR INT_PTR
24 #define ULONG_PTR UINT_PTR
25
26 /***********************************************************************
27 * Windows API extension
28 */
29
30 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
31 # define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
32 #elif defined(__GNUC__)
33 # define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
34 #else
35 /* FIXME: Not sure if is possible to do without compiler extension */
36 #endif
37
38 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
39 # define _TYPE_ALIGNMENT(type) __alignof(type)
40 #elif defined(__GNUC__)
41 # define _TYPE_ALIGNMENT(type) __alignof__(type)
42 #else
43 /*
44 * FIXME: Not sure if is possible to do without compiler extension
45 * (if type is not just a name that is, if so the normal)
46 * TYPE_ALIGNMENT can be used)
47 */
48 #endif
49
50 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
51 #pragma warning(disable:4116)
52 #endif
53
54 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
55 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
56 #endif
57
58 /***********************************************************************
59 * Test helper macros
60 */
61
62 #ifdef FIELD_ALIGNMENT
63 # define TEST_FIELD_ALIGNMENT(type, field, align) \
64 ok(FIELD_ALIGNMENT(type, field) == align, \
65 "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
66 (int)FIELD_ALIGNMENT(type, field))
67 #else
68 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
69 #endif
70
71 #define TEST_FIELD_OFFSET(type, field, offset) \
72 ok(FIELD_OFFSET(type, field) == offset, \
73 "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
74 (long int)FIELD_OFFSET(type, field))
75
76 #ifdef _TYPE_ALIGNMENT
77 #define TEST__TYPE_ALIGNMENT(type, align) \
78 ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)_TYPE_ALIGNMENT(type))
79 #else
80 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
81 #endif
82
83 #ifdef TYPE_ALIGNMENT
84 #define TEST_TYPE_ALIGNMENT(type, align) \
85 ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)TYPE_ALIGNMENT(type))
86 #else
87 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
88 #endif
89
90 #define TEST_TYPE_SIZE(type, size) \
91 ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", ((int) sizeof(type)))
92
93 /***********************************************************************
94 * Test macros
95 */
96
97 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
98 TEST_TYPE_SIZE(field_type, field_size); \
99 TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
100 TEST_FIELD_OFFSET(type, field_name, field_offset); \
101
102 #define TEST_TYPE(type, size, align) \
103 TEST_TYPE_ALIGNMENT(type, align); \
104 TEST_TYPE_SIZE(type, size)
105
106 #define TEST_TYPE_POINTER(type, size, align) \
107 TEST__TYPE_ALIGNMENT(*(type)0, align); \
108 TEST_TYPE_SIZE(*(type)0, size)
109
110 #define TEST_TYPE_SIGNED(type) \
111 ok((type) -1 < 0, "(" #type ") -1 < 0\n");
112
113 #define TEST_TYPE_UNSIGNED(type) \
114 ok((type) -1 > 0, "(" #type ") -1 > 0\n");
115
116 static void test_pack_ABC(void)
117 {
118 /* ABC (pack 4) */
119 TEST_TYPE(ABC, 12, 4);
120 TEST_FIELD(ABC, INT, abcA, 0, 4, 4);
121 TEST_FIELD(ABC, UINT, abcB, 4, 4, 4);
122 TEST_FIELD(ABC, INT, abcC, 8, 4, 4);
123 }
124
125 static void test_pack_ABCFLOAT(void)
126 {
127 /* ABCFLOAT (pack 4) */
128 TEST_TYPE(ABCFLOAT, 12, 4);
129 TEST_FIELD(ABCFLOAT, FLOAT, abcfA, 0, 4, 4);
130 TEST_FIELD(ABCFLOAT, FLOAT, abcfB, 4, 4, 4);
131 TEST_FIELD(ABCFLOAT, FLOAT, abcfC, 8, 4, 4);
132 }
133
134 static void test_pack_ABORTPROC(void)
135 {
136 /* ABORTPROC */
137 TEST_TYPE(ABORTPROC, 4, 4);
138 }
139
140 static void test_pack_BITMAP(void)
141 {
142 /* BITMAP (pack 4) */
143 TEST_TYPE(BITMAP, 24, 4);
144 TEST_FIELD(BITMAP, INT, bmType, 0, 4, 4);
145 TEST_FIELD(BITMAP, INT, bmWidth, 4, 4, 4);
146 TEST_FIELD(BITMAP, INT, bmHeight, 8, 4, 4);
147 TEST_FIELD(BITMAP, INT, bmWidthBytes, 12, 4, 4);
148 TEST_FIELD(BITMAP, WORD, bmPlanes, 16, 2, 2);
149 TEST_FIELD(BITMAP, WORD, bmBitsPixel, 18, 2, 2);
150 TEST_FIELD(BITMAP, LPVOID, bmBits, 20, 4, 4);
151 }
152
153 static void test_pack_BITMAPCOREHEADER(void)
154 {
155 /* BITMAPCOREHEADER (pack 4) */
156 TEST_TYPE(BITMAPCOREHEADER, 12, 4);
157 TEST_FIELD(BITMAPCOREHEADER, DWORD, bcSize, 0, 4, 4);
158 TEST_FIELD(BITMAPCOREHEADER, WORD, bcWidth, 4, 2, 2);
159 TEST_FIELD(BITMAPCOREHEADER, WORD, bcHeight, 6, 2, 2);
160 TEST_FIELD(BITMAPCOREHEADER, WORD, bcPlanes, 8, 2, 2);
161 TEST_FIELD(BITMAPCOREHEADER, WORD, bcBitCount, 10, 2, 2);
162 }
163
164 static void test_pack_BITMAPCOREINFO(void)
165 {
166 /* BITMAPCOREINFO (pack 4) */
167 TEST_TYPE(BITMAPCOREINFO, 16, 4);
168 TEST_FIELD(BITMAPCOREINFO, BITMAPCOREHEADER, bmciHeader, 0, 12, 4);
169 TEST_FIELD(BITMAPCOREINFO, RGBTRIPLE[1], bmciColors, 12, 3, 1);
170 }
171
172 static void test_pack_BITMAPFILEHEADER(void)
173 {
174 /* BITMAPFILEHEADER (pack 2) */
175 TEST_TYPE(BITMAPFILEHEADER, 14, 2);
176 TEST_FIELD(BITMAPFILEHEADER, WORD, bfType, 0, 2, 2);
177 TEST_FIELD(BITMAPFILEHEADER, DWORD, bfSize, 2, 4, 2);
178 TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved1, 6, 2, 2);
179 TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved2, 8, 2, 2);
180 TEST_FIELD(BITMAPFILEHEADER, DWORD, bfOffBits, 10, 4, 2);
181 }
182
183 static void test_pack_BITMAPINFO(void)
184 {
185 /* BITMAPINFO (pack 4) */
186 TEST_TYPE(BITMAPINFO, 44, 4);
187 TEST_FIELD(BITMAPINFO, BITMAPINFOHEADER, bmiHeader, 0, 40, 4);
188 TEST_FIELD(BITMAPINFO, RGBQUAD[1], bmiColors, 40, 4, 1);
189 }
190
191 static void test_pack_BITMAPINFOHEADER(void)
192 {
193 /* BITMAPINFOHEADER (pack 4) */
194 TEST_TYPE(BITMAPINFOHEADER, 40, 4);
195 TEST_FIELD(BITMAPINFOHEADER, DWORD, biSize, 0, 4, 4);
196 TEST_FIELD(BITMAPINFOHEADER, LONG, biWidth, 4, 4, 4);
197 TEST_FIELD(BITMAPINFOHEADER, LONG, biHeight, 8, 4, 4);
198 TEST_FIELD(BITMAPINFOHEADER, WORD, biPlanes, 12, 2, 2);
199 TEST_FIELD(BITMAPINFOHEADER, WORD, biBitCount, 14, 2, 2);
200 TEST_FIELD(BITMAPINFOHEADER, DWORD, biCompression, 16, 4, 4);
201 TEST_FIELD(BITMAPINFOHEADER, DWORD, biSizeImage, 20, 4, 4);
202 TEST_FIELD(BITMAPINFOHEADER, LONG, biXPelsPerMeter, 24, 4, 4);
203 TEST_FIELD(BITMAPINFOHEADER, LONG, biYPelsPerMeter, 28, 4, 4);
204 TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrUsed, 32, 4, 4);
205 TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrImportant, 36, 4, 4);
206 }
207
208 static void test_pack_BITMAPV4HEADER(void)
209 {
210 /* BITMAPV4HEADER (pack 4) */
211 TEST_TYPE(BITMAPV4HEADER, 108, 4);
212 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4Size, 0, 4, 4);
213 TEST_FIELD(BITMAPV4HEADER, LONG, bV4Width, 4, 4, 4);
214 TEST_FIELD(BITMAPV4HEADER, LONG, bV4Height, 8, 4, 4);
215 TEST_FIELD(BITMAPV4HEADER, WORD, bV4Planes, 12, 2, 2);
216 TEST_FIELD(BITMAPV4HEADER, WORD, bV4BitCount, 14, 2, 2);
217 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4V4Compression, 16, 4, 4);
218 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4SizeImage, 20, 4, 4);
219 TEST_FIELD(BITMAPV4HEADER, LONG, bV4XPelsPerMeter, 24, 4, 4);
220 TEST_FIELD(BITMAPV4HEADER, LONG, bV4YPelsPerMeter, 28, 4, 4);
221 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrUsed, 32, 4, 4);
222 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrImportant, 36, 4, 4);
223 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4RedMask, 40, 4, 4);
224 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GreenMask, 44, 4, 4);
225 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4BlueMask, 48, 4, 4);
226 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4AlphaMask, 52, 4, 4);
227 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4CSType, 56, 4, 4);
228 TEST_FIELD(BITMAPV4HEADER, CIEXYZTRIPLE, bV4Endpoints, 60, 36, 4);
229 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaRed, 96, 4, 4);
230 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaGreen, 100, 4, 4);
231 TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaBlue, 104, 4, 4);
232 }
233
234 static void test_pack_BITMAPV5HEADER(void)
235 {
236 /* BITMAPV5HEADER (pack 4) */
237 TEST_TYPE(BITMAPV5HEADER, 124, 4);
238 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Size, 0, 4, 4);
239 TEST_FIELD(BITMAPV5HEADER, LONG, bV5Width, 4, 4, 4);
240 TEST_FIELD(BITMAPV5HEADER, LONG, bV5Height, 8, 4, 4);
241 TEST_FIELD(BITMAPV5HEADER, WORD, bV5Planes, 12, 2, 2);
242 TEST_FIELD(BITMAPV5HEADER, WORD, bV5BitCount, 14, 2, 2);
243 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Compression, 16, 4, 4);
244 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5SizeImage, 20, 4, 4);
245 TEST_FIELD(BITMAPV5HEADER, LONG, bV5XPelsPerMeter, 24, 4, 4);
246 TEST_FIELD(BITMAPV5HEADER, LONG, bV5YPelsPerMeter, 28, 4, 4);
247 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrUsed, 32, 4, 4);
248 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrImportant, 36, 4, 4);
249 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5RedMask, 40, 4, 4);
250 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GreenMask, 44, 4, 4);
251 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5BlueMask, 48, 4, 4);
252 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5AlphaMask, 52, 4, 4);
253 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5CSType, 56, 4, 4);
254 TEST_FIELD(BITMAPV5HEADER, CIEXYZTRIPLE, bV5Endpoints, 60, 36, 4);
255 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaRed, 96, 4, 4);
256 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaGreen, 100, 4, 4);
257 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaBlue, 104, 4, 4);
258 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Intent, 108, 4, 4);
259 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileData, 112, 4, 4);
260 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileSize, 116, 4, 4);
261 TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Reserved, 120, 4, 4);
262 }
263
264 static void test_pack_BLENDFUNCTION(void)
265 {
266 /* BLENDFUNCTION (pack 4) */
267 TEST_TYPE(BLENDFUNCTION, 4, 1);
268 TEST_FIELD(BLENDFUNCTION, BYTE, BlendOp, 0, 1, 1);
269 TEST_FIELD(BLENDFUNCTION, BYTE, BlendFlags, 1, 1, 1);
270 TEST_FIELD(BLENDFUNCTION, BYTE, SourceConstantAlpha, 2, 1, 1);
271 TEST_FIELD(BLENDFUNCTION, BYTE, AlphaFormat, 3, 1, 1);
272 }
273
274 static void test_pack_CHARSETINFO(void)
275 {
276 /* CHARSETINFO (pack 4) */
277 TEST_TYPE(CHARSETINFO, 32, 4);
278 TEST_FIELD(CHARSETINFO, UINT, ciCharset, 0, 4, 4);
279 TEST_FIELD(CHARSETINFO, UINT, ciACP, 4, 4, 4);
280 TEST_FIELD(CHARSETINFO, FONTSIGNATURE, fs, 8, 24, 4);
281 }
282
283 static void test_pack_CIEXYZ(void)
284 {
285 /* CIEXYZ (pack 4) */
286 TEST_TYPE(CIEXYZ, 12, 4);
287 TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzX, 0, 4, 4);
288 TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzY, 4, 4, 4);
289 TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzZ, 8, 4, 4);
290 }
291
292 static void test_pack_CIEXYZTRIPLE(void)
293 {
294 /* CIEXYZTRIPLE (pack 4) */
295 TEST_TYPE(CIEXYZTRIPLE, 36, 4);
296 TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzRed, 0, 12, 4);
297 TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzGreen, 12, 12, 4);
298 TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzBlue, 24, 12, 4);
299 }
300
301 static void test_pack_COLOR16(void)
302 {
303 /* COLOR16 */
304 TEST_TYPE(COLOR16, 2, 2);
305 }
306
307 static void test_pack_COLORADJUSTMENT(void)
308 {
309 /* COLORADJUSTMENT (pack 4) */
310 TEST_TYPE(COLORADJUSTMENT, 24, 2);
311 TEST_FIELD(COLORADJUSTMENT, WORD, caSize, 0, 2, 2);
312 TEST_FIELD(COLORADJUSTMENT, WORD, caFlags, 2, 2, 2);
313 TEST_FIELD(COLORADJUSTMENT, WORD, caIlluminantIndex, 4, 2, 2);
314 TEST_FIELD(COLORADJUSTMENT, WORD, caRedGamma, 6, 2, 2);
315 TEST_FIELD(COLORADJUSTMENT, WORD, caGreenGamma, 8, 2, 2);
316 TEST_FIELD(COLORADJUSTMENT, WORD, caBlueGamma, 10, 2, 2);
317 TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceBlack, 12, 2, 2);
318 TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceWhite, 14, 2, 2);
319 TEST_FIELD(COLORADJUSTMENT, SHORT, caContrast, 16, 2, 2);
320 TEST_FIELD(COLORADJUSTMENT, SHORT, caBrightness, 18, 2, 2);
321 TEST_FIELD(COLORADJUSTMENT, SHORT, caColorfulness, 20, 2, 2);
322 TEST_FIELD(COLORADJUSTMENT, SHORT, caRedGreenTint, 22, 2, 2);
323 }
324
325 static void test_pack_DEVMODEA(void)
326 {
327 /* DEVMODEA (pack 4) */
328 TEST_FIELD(DEVMODEA, BYTE[CCHDEVICENAME], dmDeviceName, 0, 32, 1);
329 TEST_FIELD(DEVMODEA, WORD, dmSpecVersion, 32, 2, 2);
330 TEST_FIELD(DEVMODEA, WORD, dmDriverVersion, 34, 2, 2);
331 TEST_FIELD(DEVMODEA, WORD, dmSize, 36, 2, 2);
332 TEST_FIELD(DEVMODEA, WORD, dmDriverExtra, 38, 2, 2);
333 TEST_FIELD(DEVMODEA, DWORD, dmFields, 40, 4, 4);
334 }
335
336 static void test_pack_DEVMODEW(void)
337 {
338 /* DEVMODEW (pack 4) */
339 TEST_FIELD(DEVMODEW, WCHAR[CCHDEVICENAME], dmDeviceName, 0, 64, 2);
340 TEST_FIELD(DEVMODEW, WORD, dmSpecVersion, 64, 2, 2);
341 TEST_FIELD(DEVMODEW, WORD, dmDriverVersion, 66, 2, 2);
342 TEST_FIELD(DEVMODEW, WORD, dmSize, 68, 2, 2);
343 TEST_FIELD(DEVMODEW, WORD, dmDriverExtra, 70, 2, 2);
344 TEST_FIELD(DEVMODEW, DWORD, dmFields, 72, 4, 4);
345 }
346
347 static void test_pack_DIBSECTION(void)
348 {
349 /* DIBSECTION (pack 4) */
350 TEST_TYPE(DIBSECTION, 84, 4);
351 TEST_FIELD(DIBSECTION, BITMAP, dsBm, 0, 24, 4);
352 TEST_FIELD(DIBSECTION, BITMAPINFOHEADER, dsBmih, 24, 40, 4);
353 TEST_FIELD(DIBSECTION, DWORD[3], dsBitfields, 64, 12, 4);
354 TEST_FIELD(DIBSECTION, HANDLE, dshSection, 76, 4, 4);
355 TEST_FIELD(DIBSECTION, DWORD, dsOffset, 80, 4, 4);
356 }
357
358 static void test_pack_DISPLAY_DEVICEA(void)
359 {
360 /* DISPLAY_DEVICEA (pack 4) */
361 TEST_TYPE(DISPLAY_DEVICEA, 424, 4);
362 TEST_FIELD(DISPLAY_DEVICEA, DWORD, cb, 0, 4, 4);
363 TEST_FIELD(DISPLAY_DEVICEA, CHAR[32], DeviceName, 4, 32, 1);
364 TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceString, 36, 128, 1);
365 TEST_FIELD(DISPLAY_DEVICEA, DWORD, StateFlags, 164, 4, 4);
366 TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceID, 168, 128, 1);
367 TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceKey, 296, 128, 1);
368 }
369
370 static void test_pack_DISPLAY_DEVICEW(void)
371 {
372 /* DISPLAY_DEVICEW (pack 4) */
373 TEST_TYPE(DISPLAY_DEVICEW, 840, 4);
374 TEST_FIELD(DISPLAY_DEVICEW, DWORD, cb, 0, 4, 4);
375 TEST_FIELD(DISPLAY_DEVICEW, WCHAR[32], DeviceName, 4, 64, 2);
376 TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceString, 68, 256, 2);
377 TEST_FIELD(DISPLAY_DEVICEW, DWORD, StateFlags, 324, 4, 4);
378 TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceID, 328, 256, 2);
379 TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceKey, 584, 256, 2);
380 }
381
382 static void test_pack_DOCINFOA(void)
383 {
384 /* DOCINFOA (pack 4) */
385 TEST_TYPE(DOCINFOA, 20, 4);
386 TEST_FIELD(DOCINFOA, INT, cbSize, 0, 4, 4);
387 TEST_FIELD(DOCINFOA, LPCSTR, lpszDocName, 4, 4, 4);
388 TEST_FIELD(DOCINFOA, LPCSTR, lpszOutput, 8, 4, 4);
389 TEST_FIELD(DOCINFOA, LPCSTR, lpszDatatype, 12, 4, 4);
390 TEST_FIELD(DOCINFOA, DWORD, fwType, 16, 4, 4);
391 }
392
393 static void test_pack_DOCINFOW(void)
394 {
395 /* DOCINFOW (pack 4) */
396 TEST_TYPE(DOCINFOW, 20, 4);
397 TEST_FIELD(DOCINFOW, INT, cbSize, 0, 4, 4);
398 TEST_FIELD(DOCINFOW, LPCWSTR, lpszDocName, 4, 4, 4);
399 TEST_FIELD(DOCINFOW, LPCWSTR, lpszOutput, 8, 4, 4);
400 TEST_FIELD(DOCINFOW, LPCWSTR, lpszDatatype, 12, 4, 4);
401 TEST_FIELD(DOCINFOW, DWORD, fwType, 16, 4, 4);
402 }
403
404 static void test_pack_EMR(void)
405 {
406 /* EMR (pack 4) */
407 TEST_TYPE(EMR, 8, 4);
408 TEST_FIELD(EMR, DWORD, iType, 0, 4, 4);
409 TEST_FIELD(EMR, DWORD, nSize, 4, 4, 4);
410 }
411
412 static void test_pack_EMRABORTPATH(void)
413 {
414 /* EMRABORTPATH (pack 4) */
415 TEST_TYPE(EMRABORTPATH, 8, 4);
416 TEST_FIELD(EMRABORTPATH, EMR, emr, 0, 8, 4);
417 }
418
419 static void test_pack_EMRANGLEARC(void)
420 {
421 /* EMRANGLEARC (pack 4) */
422 TEST_TYPE(EMRANGLEARC, 28, 4);
423 TEST_FIELD(EMRANGLEARC, EMR, emr, 0, 8, 4);
424 TEST_FIELD(EMRANGLEARC, POINTL, ptlCenter, 8, 8, 4);
425 TEST_FIELD(EMRANGLEARC, DWORD, nRadius, 16, 4, 4);
426 TEST_FIELD(EMRANGLEARC, FLOAT, eStartAngle, 20, 4, 4);
427 TEST_FIELD(EMRANGLEARC, FLOAT, eSweepAngle, 24, 4, 4);
428 }
429
430 static void test_pack_EMRARC(void)
431 {
432 /* EMRARC (pack 4) */
433 TEST_TYPE(EMRARC, 40, 4);
434 TEST_FIELD(EMRARC, EMR, emr, 0, 8, 4);
435 TEST_FIELD(EMRARC, RECTL, rclBox, 8, 16, 4);
436 TEST_FIELD(EMRARC, POINTL, ptlStart, 24, 8, 4);
437 TEST_FIELD(EMRARC, POINTL, ptlEnd, 32, 8, 4);
438 }
439
440 static void test_pack_EMRARCTO(void)
441 {
442 /* EMRARCTO (pack 4) */
443 TEST_TYPE(EMRARCTO, 40, 4);
444 TEST_FIELD(EMRARCTO, EMR, emr, 0, 8, 4);
445 TEST_FIELD(EMRARCTO, RECTL, rclBox, 8, 16, 4);
446 TEST_FIELD(EMRARCTO, POINTL, ptlStart, 24, 8, 4);
447 TEST_FIELD(EMRARCTO, POINTL, ptlEnd, 32, 8, 4);
448 }
449
450 static void test_pack_EMRBEGINPATH(void)
451 {
452 /* EMRBEGINPATH (pack 4) */
453 TEST_TYPE(EMRBEGINPATH, 8, 4);
454 TEST_FIELD(EMRBEGINPATH, EMR, emr, 0, 8, 4);
455 }
456
457 static void test_pack_EMRBITBLT(void)
458 {
459 /* EMRBITBLT (pack 4) */
460 TEST_TYPE(EMRBITBLT, 100, 4);
461 TEST_FIELD(EMRBITBLT, EMR, emr, 0, 8, 4);
462 TEST_FIELD(EMRBITBLT, RECTL, rclBounds, 8, 16, 4);
463 TEST_FIELD(EMRBITBLT, LONG, xDest, 24, 4, 4);
464 TEST_FIELD(EMRBITBLT, LONG, yDest, 28, 4, 4);
465 TEST_FIELD(EMRBITBLT, LONG, cxDest, 32, 4, 4);
466 TEST_FIELD(EMRBITBLT, LONG, cyDest, 36, 4, 4);
467 TEST_FIELD(EMRBITBLT, DWORD, dwRop, 40, 4, 4);
468 TEST_FIELD(EMRBITBLT, LONG, xSrc, 44, 4, 4);
469 TEST_FIELD(EMRBITBLT, LONG, ySrc, 48, 4, 4);
470 TEST_FIELD(EMRBITBLT, XFORM, xformSrc, 52, 24, 4);
471 TEST_FIELD(EMRBITBLT, COLORREF, crBkColorSrc, 76, 4, 4);
472 TEST_FIELD(EMRBITBLT, DWORD, iUsageSrc, 80, 4, 4);
473 TEST_FIELD(EMRBITBLT, DWORD, offBmiSrc, 84, 4, 4);
474 TEST_FIELD(EMRBITBLT, DWORD, cbBmiSrc, 88, 4, 4);
475 TEST_FIELD(EMRBITBLT, DWORD, offBitsSrc, 92, 4, 4);
476 TEST_FIELD(EMRBITBLT, DWORD, cbBitsSrc, 96, 4, 4);
477 }
478
479 static void test_pack_EMRCHORD(void)
480 {
481 /* EMRCHORD (pack 4) */
482 TEST_TYPE(EMRCHORD, 40, 4);
483 TEST_FIELD(EMRCHORD, EMR, emr, 0, 8, 4);
484 TEST_FIELD(EMRCHORD, RECTL, rclBox, 8, 16, 4);
485 TEST_FIELD(EMRCHORD, POINTL, ptlStart, 24, 8, 4);
486 TEST_FIELD(EMRCHORD, POINTL, ptlEnd, 32, 8, 4);
487 }
488
489 static void test_pack_EMRCLOSEFIGURE(void)
490 {
491 /* EMRCLOSEFIGURE (pack 4) */
492 TEST_TYPE(EMRCLOSEFIGURE, 8, 4);
493 TEST_FIELD(EMRCLOSEFIGURE, EMR, emr, 0, 8, 4);
494 }
495
496 static void test_pack_EMRCREATEBRUSHINDIRECT(void)
497 {
498 /* EMRCREATEBRUSHINDIRECT (pack 4) */
499 TEST_TYPE(EMRCREATEBRUSHINDIRECT, 24, 4);
500 TEST_FIELD(EMRCREATEBRUSHINDIRECT, EMR, emr, 0, 8, 4);
501 TEST_FIELD(EMRCREATEBRUSHINDIRECT, DWORD, ihBrush, 8, 4, 4);
502 TEST_FIELD(EMRCREATEBRUSHINDIRECT, LOGBRUSH32, lb, 12, 12, 4);
503 }
504
505 static void test_pack_EMRCREATECOLORSPACE(void)
506 {
507 /* EMRCREATECOLORSPACE (pack 4) */
508 TEST_TYPE(EMRCREATECOLORSPACE, 340, 4);
509 TEST_FIELD(EMRCREATECOLORSPACE, EMR, emr, 0, 8, 4);
510 TEST_FIELD(EMRCREATECOLORSPACE, DWORD, ihCS, 8, 4, 4);
511 TEST_FIELD(EMRCREATECOLORSPACE, LOGCOLORSPACEA, lcs, 12, 328, 4);
512 }
513
514 static void test_pack_EMRCREATECOLORSPACEW(void)
515 {
516 /* EMRCREATECOLORSPACEW (pack 4) */
517 TEST_TYPE(EMRCREATECOLORSPACEW, 612, 4);
518 TEST_FIELD(EMRCREATECOLORSPACEW, EMR, emr, 0, 8, 4);
519 TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, ihCS, 8, 4, 4);
520 TEST_FIELD(EMRCREATECOLORSPACEW, LOGCOLORSPACEW, lcs, 12, 588, 4);
521 TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, dwFlags, 600, 4, 4);
522 TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, cbData, 604, 4, 4);
523 TEST_FIELD(EMRCREATECOLORSPACEW, BYTE[1], Data, 608, 1, 1);
524 }
525
526 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
527 {
528 /* EMRCREATEDIBPATTERNBRUSHPT (pack 4) */
529 TEST_TYPE(EMRCREATEDIBPATTERNBRUSHPT, 32, 4);
530 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, EMR, emr, 0, 8, 4);
531 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, ihBrush, 8, 4, 4);
532 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, iUsage, 12, 4, 4);
533 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBmi, 16, 4, 4);
534 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBmi, 20, 4, 4);
535 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBits, 24, 4, 4);
536 TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBits, 28, 4, 4);
537 }
538
539 static void test_pack_EMRCREATEMONOBRUSH(void)
540 {
541 /* EMRCREATEMONOBRUSH (pack 4) */
542 TEST_TYPE(EMRCREATEMONOBRUSH, 32, 4);
543 TEST_FIELD(EMRCREATEMONOBRUSH, EMR, emr, 0, 8, 4);
544 TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, ihBrush, 8, 4, 4);
545 TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, iUsage, 12, 4, 4);
546 TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBmi, 16, 4, 4);
547 TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBmi, 20, 4, 4);
548 TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBits, 24, 4, 4);
549 TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBits, 28, 4, 4);
550 }
551
552 static void test_pack_EMRCREATEPEN(void)
553 {
554 /* EMRCREATEPEN (pack 4) */
555 TEST_TYPE(EMRCREATEPEN, 28, 4);
556 TEST_FIELD(EMRCREATEPEN, EMR, emr, 0, 8, 4);
557 TEST_FIELD(EMRCREATEPEN, DWORD, ihPen, 8, 4, 4);
558 TEST_FIELD(EMRCREATEPEN, LOGPEN, lopn, 12, 16, 4);
559 }
560
561 static void test_pack_EMRDELETECOLORSPACE(void)
562 {
563 /* EMRDELETECOLORSPACE (pack 4) */
564 TEST_TYPE(EMRDELETECOLORSPACE, 12, 4);
565 TEST_FIELD(EMRDELETECOLORSPACE, EMR, emr, 0, 8, 4);
566 TEST_FIELD(EMRDELETECOLORSPACE, DWORD, ihCS, 8, 4, 4);
567 }
568
569 static void test_pack_EMRDELETEOBJECT(void)
570 {
571 /* EMRDELETEOBJECT (pack 4) */
572 TEST_TYPE(EMRDELETEOBJECT, 12, 4);
573 TEST_FIELD(EMRDELETEOBJECT, EMR, emr, 0, 8, 4);
574 TEST_FIELD(EMRDELETEOBJECT, DWORD, ihObject, 8, 4, 4);
575 }
576
577 static void test_pack_EMRELLIPSE(void)
578 {
579 /* EMRELLIPSE (pack 4) */
580 TEST_TYPE(EMRELLIPSE, 24, 4);
581 TEST_FIELD(EMRELLIPSE, EMR, emr, 0, 8, 4);
582 TEST_FIELD(EMRELLIPSE, RECTL, rclBox, 8, 16, 4);
583 }
584
585 static void test_pack_EMRENDPATH(void)
586 {
587 /* EMRENDPATH (pack 4) */
588 TEST_TYPE(EMRENDPATH, 8, 4);
589 TEST_FIELD(EMRENDPATH, EMR, emr, 0, 8, 4);
590 }
591
592 static void test_pack_EMREOF(void)
593 {
594 /* EMREOF (pack 4) */
595 TEST_TYPE(EMREOF, 20, 4);
596 TEST_FIELD(EMREOF, EMR, emr, 0, 8, 4);
597 TEST_FIELD(EMREOF, DWORD, nPalEntries, 8, 4, 4);
598 TEST_FIELD(EMREOF, DWORD, offPalEntries, 12, 4, 4);
599 TEST_FIELD(EMREOF, DWORD, nSizeLast, 16, 4, 4);
600 }
601
602 static void test_pack_EMREXCLUDECLIPRECT(void)
603 {
604 /* EMREXCLUDECLIPRECT (pack 4) */
605 TEST_TYPE(EMREXCLUDECLIPRECT, 24, 4);
606 TEST_FIELD(EMREXCLUDECLIPRECT, EMR, emr, 0, 8, 4);
607 TEST_FIELD(EMREXCLUDECLIPRECT, RECTL, rclClip, 8, 16, 4);
608 }
609
610 static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
611 {
612 /* EMREXTCREATEFONTINDIRECTW (pack 4) */
613 TEST_TYPE(EMREXTCREATEFONTINDIRECTW, 332, 4);
614 TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EMR, emr, 0, 8, 4);
615 TEST_FIELD(EMREXTCREATEFONTINDIRECTW, DWORD, ihFont, 8, 4, 4);
616 TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EXTLOGFONTW, elfw, 12, 320, 4);
617 }
618
619 static void test_pack_EMREXTCREATEPEN(void)
620 {
621 /* EMREXTCREATEPEN (pack 4) */
622 TEST_TYPE(EMREXTCREATEPEN, 56, 4);
623 TEST_FIELD(EMREXTCREATEPEN, EMR, emr, 0, 8, 4);
624 TEST_FIELD(EMREXTCREATEPEN, DWORD, ihPen, 8, 4, 4);
625 TEST_FIELD(EMREXTCREATEPEN, DWORD, offBmi, 12, 4, 4);
626 TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBmi, 16, 4, 4);
627 TEST_FIELD(EMREXTCREATEPEN, DWORD, offBits, 20, 4, 4);
628 TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBits, 24, 4, 4);
629 TEST_FIELD(EMREXTCREATEPEN, EXTLOGPEN, elp, 28, 28, 4);
630 }
631
632 static void test_pack_EMREXTFLOODFILL(void)
633 {
634 /* EMREXTFLOODFILL (pack 4) */
635 TEST_TYPE(EMREXTFLOODFILL, 24, 4);
636 TEST_FIELD(EMREXTFLOODFILL, EMR, emr, 0, 8, 4);
637 TEST_FIELD(EMREXTFLOODFILL, POINTL, ptlStart, 8, 8, 4);
638 TEST_FIELD(EMREXTFLOODFILL, COLORREF, crColor, 16, 4, 4);
639 TEST_FIELD(EMREXTFLOODFILL, DWORD, iMode, 20, 4, 4);
640 }
641
642 static void test_pack_EMREXTSELECTCLIPRGN(void)
643 {
644 /* EMREXTSELECTCLIPRGN (pack 4) */
645 TEST_TYPE(EMREXTSELECTCLIPRGN, 20, 4);
646 TEST_FIELD(EMREXTSELECTCLIPRGN, EMR, emr, 0, 8, 4);
647 TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, cbRgnData, 8, 4, 4);
648 TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, iMode, 12, 4, 4);
649 TEST_FIELD(EMREXTSELECTCLIPRGN, BYTE[1], RgnData, 16, 1, 1);
650 }
651
652 static void test_pack_EMREXTTEXTOUTA(void)
653 {
654 /* EMREXTTEXTOUTA (pack 4) */
655 TEST_TYPE(EMREXTTEXTOUTA, 76, 4);
656 TEST_FIELD(EMREXTTEXTOUTA, EMR, emr, 0, 8, 4);
657 TEST_FIELD(EMREXTTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
658 TEST_FIELD(EMREXTTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
659 TEST_FIELD(EMREXTTEXTOUTA, FLOAT, exScale, 28, 4, 4);
660 TEST_FIELD(EMREXTTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
661 TEST_FIELD(EMREXTTEXTOUTA, EMRTEXT, emrtext, 36, 40, 4);
662 }
663
664 static void test_pack_EMREXTTEXTOUTW(void)
665 {
666 /* EMREXTTEXTOUTW (pack 4) */
667 TEST_TYPE(EMREXTTEXTOUTW, 76, 4);
668 TEST_FIELD(EMREXTTEXTOUTW, EMR, emr, 0, 8, 4);
669 TEST_FIELD(EMREXTTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
670 TEST_FIELD(EMREXTTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
671 TEST_FIELD(EMREXTTEXTOUTW, FLOAT, exScale, 28, 4, 4);
672 TEST_FIELD(EMREXTTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
673 TEST_FIELD(EMREXTTEXTOUTW, EMRTEXT, emrtext, 36, 40, 4);
674 }
675
676 static void test_pack_EMRFILLPATH(void)
677 {
678 /* EMRFILLPATH (pack 4) */
679 TEST_TYPE(EMRFILLPATH, 24, 4);
680 TEST_FIELD(EMRFILLPATH, EMR, emr, 0, 8, 4);
681 TEST_FIELD(EMRFILLPATH, RECTL, rclBounds, 8, 16, 4);
682 }
683
684 static void test_pack_EMRFILLRGN(void)
685 {
686 /* EMRFILLRGN (pack 4) */
687 TEST_TYPE(EMRFILLRGN, 36, 4);
688 TEST_FIELD(EMRFILLRGN, EMR, emr, 0, 8, 4);
689 TEST_FIELD(EMRFILLRGN, RECTL, rclBounds, 8, 16, 4);
690 TEST_FIELD(EMRFILLRGN, DWORD, cbRgnData, 24, 4, 4);
691 TEST_FIELD(EMRFILLRGN, DWORD, ihBrush, 28, 4, 4);
692 TEST_FIELD(EMRFILLRGN, BYTE[1], RgnData, 32, 1, 1);
693 }
694
695 static void test_pack_EMRFLATTENPATH(void)
696 {
697 /* EMRFLATTENPATH (pack 4) */
698 TEST_TYPE(EMRFLATTENPATH, 8, 4);
699 TEST_FIELD(EMRFLATTENPATH, EMR, emr, 0, 8, 4);
700 }
701
702 static void test_pack_EMRFORMAT(void)
703 {
704 /* EMRFORMAT (pack 4) */
705 TEST_TYPE(EMRFORMAT, 16, 4);
706 TEST_FIELD(EMRFORMAT, DWORD, dSignature, 0, 4, 4);
707 TEST_FIELD(EMRFORMAT, DWORD, nVersion, 4, 4, 4);
708 TEST_FIELD(EMRFORMAT, DWORD, cbData, 8, 4, 4);
709 TEST_FIELD(EMRFORMAT, DWORD, offData, 12, 4, 4);
710 }
711
712 static void test_pack_EMRFRAMERGN(void)
713 {
714 /* EMRFRAMERGN (pack 4) */
715 TEST_TYPE(EMRFRAMERGN, 44, 4);
716 TEST_FIELD(EMRFRAMERGN, EMR, emr, 0, 8, 4);
717 TEST_FIELD(EMRFRAMERGN, RECTL, rclBounds, 8, 16, 4);
718 TEST_FIELD(EMRFRAMERGN, DWORD, cbRgnData, 24, 4, 4);
719 TEST_FIELD(EMRFRAMERGN, DWORD, ihBrush, 28, 4, 4);
720 TEST_FIELD(EMRFRAMERGN, SIZEL, szlStroke, 32, 8, 4);
721 TEST_FIELD(EMRFRAMERGN, BYTE[1], RgnData, 40, 1, 1);
722 }
723
724 static void test_pack_EMRGDICOMMENT(void)
725 {
726 /* EMRGDICOMMENT (pack 4) */
727 TEST_TYPE(EMRGDICOMMENT, 16, 4);
728 TEST_FIELD(EMRGDICOMMENT, EMR, emr, 0, 8, 4);
729 TEST_FIELD(EMRGDICOMMENT, DWORD, cbData, 8, 4, 4);
730 TEST_FIELD(EMRGDICOMMENT, BYTE[1], Data, 12, 1, 1);
731 }
732
733 static void test_pack_EMRGLSBOUNDEDRECORD(void)
734 {
735 /* EMRGLSBOUNDEDRECORD (pack 4) */
736 TEST_TYPE(EMRGLSBOUNDEDRECORD, 32, 4);
737 TEST_FIELD(EMRGLSBOUNDEDRECORD, EMR, emr, 0, 8, 4);
738 TEST_FIELD(EMRGLSBOUNDEDRECORD, RECTL, rclBounds, 8, 16, 4);
739 TEST_FIELD(EMRGLSBOUNDEDRECORD, DWORD, cbData, 24, 4, 4);
740 TEST_FIELD(EMRGLSBOUNDEDRECORD, BYTE[1], Data, 28, 1, 1);
741 }
742
743 static void test_pack_EMRGLSRECORD(void)
744 {
745 /* EMRGLSRECORD (pack 4) */
746 TEST_TYPE(EMRGLSRECORD, 16, 4);
747 TEST_FIELD(EMRGLSRECORD, EMR, emr, 0, 8, 4);
748 TEST_FIELD(EMRGLSRECORD, DWORD, cbData, 8, 4, 4);
749 TEST_FIELD(EMRGLSRECORD, BYTE[1], Data, 12, 1, 1);
750 }
751
752 static void test_pack_EMRINTERSECTCLIPRECT(void)
753 {
754 /* EMRINTERSECTCLIPRECT (pack 4) */
755 TEST_TYPE(EMRINTERSECTCLIPRECT, 24, 4);
756 TEST_FIELD(EMRINTERSECTCLIPRECT, EMR, emr, 0, 8, 4);
757 TEST_FIELD(EMRINTERSECTCLIPRECT, RECTL, rclClip, 8, 16, 4);
758 }
759
760 static void test_pack_EMRINVERTRGN(void)
761 {
762 /* EMRINVERTRGN (pack 4) */
763 TEST_TYPE(EMRINVERTRGN, 32, 4);
764 TEST_FIELD(EMRINVERTRGN, EMR, emr, 0, 8, 4);
765 TEST_FIELD(EMRINVERTRGN, RECTL, rclBounds, 8, 16, 4);
766 TEST_FIELD(EMRINVERTRGN, DWORD, cbRgnData, 24, 4, 4);
767 TEST_FIELD(EMRINVERTRGN, BYTE[1], RgnData, 28, 1, 1);
768 }
769
770 static void test_pack_EMRLINETO(void)
771 {
772 /* EMRLINETO (pack 4) */
773 TEST_TYPE(EMRLINETO, 16, 4);
774 TEST_FIELD(EMRLINETO, EMR, emr, 0, 8, 4);
775 TEST_FIELD(EMRLINETO, POINTL, ptl, 8, 8, 4);
776 }
777
778 static void test_pack_EMRMASKBLT(void)
779 {
780 /* EMRMASKBLT (pack 4) */
781 TEST_TYPE(EMRMASKBLT, 128, 4);
782 TEST_FIELD(EMRMASKBLT, EMR, emr, 0, 8, 4);
783 TEST_FIELD(EMRMASKBLT, RECTL, rclBounds, 8, 16, 4);
784 TEST_FIELD(EMRMASKBLT, LONG, xDest, 24, 4, 4);
785 TEST_FIELD(EMRMASKBLT, LONG, yDest, 28, 4, 4);
786 TEST_FIELD(EMRMASKBLT, LONG, cxDest, 32, 4, 4);
787 TEST_FIELD(EMRMASKBLT, LONG, cyDest, 36, 4, 4);
788 TEST_FIELD(EMRMASKBLT, DWORD, dwRop, 40, 4, 4);
789 TEST_FIELD(EMRMASKBLT, LONG, xSrc, 44, 4, 4);
790 TEST_FIELD(EMRMASKBLT, LONG, ySrc, 48, 4, 4);
791 TEST_FIELD(EMRMASKBLT, XFORM, xformSrc, 52, 24, 4);
792 TEST_FIELD(EMRMASKBLT, COLORREF, crBkColorSrc, 76, 4, 4);
793 TEST_FIELD(EMRMASKBLT, DWORD, iUsageSrc, 80, 4, 4);
794 TEST_FIELD(EMRMASKBLT, DWORD, offBmiSrc, 84, 4, 4);
795 TEST_FIELD(EMRMASKBLT, DWORD, cbBmiSrc, 88, 4, 4);
796 TEST_FIELD(EMRMASKBLT, DWORD, offBitsSrc, 92, 4, 4);
797 TEST_FIELD(EMRMASKBLT, DWORD, cbBitsSrc, 96, 4, 4);
798 TEST_FIELD(EMRMASKBLT, LONG, xMask, 100, 4, 4);
799 TEST_FIELD(EMRMASKBLT, LONG, yMask, 104, 4, 4);
800 TEST_FIELD(EMRMASKBLT, DWORD, iUsageMask, 108, 4, 4);
801 TEST_FIELD(EMRMASKBLT, DWORD, offBmiMask, 112, 4, 4);
802 TEST_FIELD(EMRMASKBLT, DWORD, cbBmiMask, 116, 4, 4);
803 TEST_FIELD(EMRMASKBLT, DWORD, offBitsMask, 120, 4, 4);
804 TEST_FIELD(EMRMASKBLT, DWORD, cbBitsMask, 124, 4, 4);
805 }
806
807 static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
808 {
809 /* EMRMODIFYWORLDTRANSFORM (pack 4) */
810 TEST_TYPE(EMRMODIFYWORLDTRANSFORM, 36, 4);
811 TEST_FIELD(EMRMODIFYWORLDTRANSFORM, EMR, emr, 0, 8, 4);
812 TEST_FIELD(EMRMODIFYWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
813 TEST_FIELD(EMRMODIFYWORLDTRANSFORM, DWORD, iMode, 32, 4, 4);
814 }
815
816 static void test_pack_EMRMOVETOEX(void)
817 {
818 /* EMRMOVETOEX (pack 4) */
819 TEST_TYPE(EMRMOVETOEX, 16, 4);
820 TEST_FIELD(EMRMOVETOEX, EMR, emr, 0, 8, 4);
821 TEST_FIELD(EMRMOVETOEX, POINTL, ptl, 8, 8, 4);
822 }
823
824 static void test_pack_EMROFFSETCLIPRGN(void)
825 {
826 /* EMROFFSETCLIPRGN (pack 4) */
827 TEST_TYPE(EMROFFSETCLIPRGN, 16, 4);
828 TEST_FIELD(EMROFFSETCLIPRGN, EMR, emr, 0, 8, 4);
829 TEST_FIELD(EMROFFSETCLIPRGN, POINTL, ptlOffset, 8, 8, 4);
830 }
831
832 static void test_pack_EMRPAINTRGN(void)
833 {
834 /* EMRPAINTRGN (pack 4) */
835 TEST_TYPE(EMRPAINTRGN, 32, 4);
836 TEST_FIELD(EMRPAINTRGN, EMR, emr, 0, 8, 4);
837 TEST_FIELD(EMRPAINTRGN, RECTL, rclBounds, 8, 16, 4);
838 TEST_FIELD(EMRPAINTRGN, DWORD, cbRgnData, 24, 4, 4);
839 TEST_FIELD(EMRPAINTRGN, BYTE[1], RgnData, 28, 1, 1);
840 }
841
842 static void test_pack_EMRPIE(void)
843 {
844 /* EMRPIE (pack 4) */
845 TEST_TYPE(EMRPIE, 40, 4);
846 TEST_FIELD(EMRPIE, EMR, emr, 0, 8, 4);
847 TEST_FIELD(EMRPIE, RECTL, rclBox, 8, 16, 4);
848 TEST_FIELD(EMRPIE, POINTL, ptlStart, 24, 8, 4);
849 TEST_FIELD(EMRPIE, POINTL, ptlEnd, 32, 8, 4);
850 }
851
852 static void test_pack_EMRPIXELFORMAT(void)
853 {
854 /* EMRPIXELFORMAT (pack 4) */
855 TEST_TYPE(EMRPIXELFORMAT, 48, 4);
856 TEST_FIELD(EMRPIXELFORMAT, EMR, emr, 0, 8, 4);
857 TEST_FIELD(EMRPIXELFORMAT, PIXELFORMATDESCRIPT