ReactOS  0.4.14-dev-854-gb9426a3
generated.c
Go to the documentation of this file.
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 */
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 */
119 }
120 
121 static void test_pack_BITMAP(void)
122 {
123  /* BITMAP */
124  TEST_TYPE_SIZE (BITMAP, 32)
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 */
154  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcSize, 4)
157  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcWidth, 2)
158  TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcWidth, 2)
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 */
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) */
189  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfType, 2)
192  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfSize, 4)
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 */
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 */
224  TEST_FIELD_SIZE (BITMAPINFOHEADER, biSize, 4)
227  TEST_FIELD_SIZE (BITMAPINFOHEADER, biWidth, 4)
228  TEST_FIELD_ALIGN (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 */
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 */
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 */
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)
438 }
439 
440 static void test_pack_CIEXYZ(void)
441 {
442  /* CIEXYZ */
443  TEST_TYPE_SIZE (CIEXYZ, 12)
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 */
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 */
477 }
478 
479 static void test_pack_COLORADJUSTMENT(void)
480 {
481  /* COLORADJUSTMENT */
484  TEST_FIELD_SIZE (COLORADJUSTMENT, caSize, 2)
485  TEST_FIELD_ALIGN (COLORADJUSTMENT, caSize, 2)
487  TEST_FIELD_SIZE (COLORADJUSTMENT, caFlags, 2)
488  TEST_FIELD_ALIGN (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 */
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 */
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)
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 */
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)
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 */
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 */
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)
695 }
696 
697 static void test_pack_EMRABORTPATH(void)
698 {
699  /* EMRABORTPATH */
702  TEST_FIELD_SIZE (EMRABORTPATH, emr, 8)
705 }
706 
707 static void test_pack_EMRANGLEARC(void)
708 {
709  /* EMRANGLEARC */
712  TEST_FIELD_SIZE (EMRANGLEARC, emr, 8)
713  TEST_FIELD_ALIGN (EMRANGLEARC, emr, 4)
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)
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 */
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 */
772  TEST_FIELD_SIZE (EMRBEGINPATH, emr, 8)
775 }
776 
777 static void test_pack_EMRBITBLT(void)
778 {
779  /* EMRBITBLT */
782  TEST_FIELD_SIZE (EMRBITBLT, emr, 8)
783  TEST_FIELD_ALIGN (EMRBITBLT, emr, 4)
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 */
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 */
859 }
860 
861 static void test_pack_EMRCREATEBRUSHINDIRECT(void)
862 {
863  /* EMRCREATEBRUSHINDIRECT */
875 }
876 
877 static void test_pack_EMRCREATECOLORSPACE(void)
878 {
879  /* EMRCREATECOLORSPACE */
891 }
892 
893 static void test_pack_EMRCREATECOLORSPACEW(void)
894 {
895  /* EMRCREATECOLORSPACEW */
916 }
917 
918 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
919 {
920  /* EMRCREATEDIBPATTERNBRUSHPT */
944 }
945 
946 static void test_pack_EMRCREATEMONOBRUSH(void)
947 {
948  /* EMRCREATEMONOBRUSH */
954  TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, ihBrush, 4)
966  TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBits, 4)
972 }
973 
974 static void test_pack_EMRCREATEPEN(void)
975 {
976  /* EMRCREATEPEN */
979  TEST_FIELD_SIZE (EMRCREATEPEN, emr, 8)
982  TEST_FIELD_SIZE (EMRCREATEPEN, ihPen, 4)
983  TEST_FIELD_ALIGN (EMRCREATEPEN, ihPen, 4)
985  TEST_FIELD_SIZE (EMRCREATEPEN, lopn, 16)
986  TEST_FIELD_ALIGN (EMRCREATEPEN, lopn, 4)
988 }
989 
990 static void test_pack_EMRDELETECOLORSPACE(void)
991 {
992  /* EMRDELETECOLORSPACE */
1001 }
1002 
1003 static void test_pack_EMRDELETEOBJECT(void)
1004 {
1005  /* EMRDELETEOBJECT */
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 */
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 */
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 */
1066  TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, rclClip, 16)
1067  TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, rclClip, 4)
1069 }
1070 
1071 static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
1072 {
1073  /* EMREXTCREATEFONTINDIRECTW */
1085 }
1086 
1087 static void test_pack_EMREXTCREATEPEN(void)
1088 {
1089  /* EMREXTCREATEPEN */
1095  TEST_FIELD_SIZE (EMREXTCREATEPEN, ihPen, 4)
1096  TEST_FIELD_ALIGN (EMREXTCREATEPEN, ihPen, 4)
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)
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)
1113 }
1114 
1115 static void test_pack_EMREXTFLOODFILL(void)
1116 {
1117  /* EMREXTFLOODFILL */
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)
1132 }
1133 
1134 static void test_pack_EMREXTSELECTCLIPRGN(void)
1135 {
1136  /* EMREXTSELECTCLIPRGN */
1142  TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1143  TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1144  TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, cbRgnData, 8)
1148  TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, RgnData, 1)
1151 }
1152 
1153 static void test_pack_EMREXTTEXTOUTA(void)
1154 {
1155  /* EMREXTTEXTOUTA */
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 */
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 */
1208  TEST_FIELD_SIZE (EMRFILLPATH, emr, 8)
1209  TEST_FIELD_ALIGN (EMRFILLPATH, emr, 4)
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 */
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 */
1246 }
1247 
1248 static void test_pack_EMRFORMAT(void)
1249 {
1250  /* EMRFORMAT */
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 */
1272  TEST_FIELD_SIZE (EMRFRAMERGN, emr, 8)
1273  TEST_FIELD_ALIGN (EMRFRAMERGN, emr, 4)
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 */
1297  TEST_FIELD_SIZE (EMRGDICOMMENT, emr, 8)
1300  TEST_FIELD_SIZE (EMRGDICOMMENT, cbData, 4)
1301  TEST_FIELD_ALIGN (EMRGDICOMMENT, cbData, 4)
1302  TEST_FIELD_OFFSET(EMRGDICOMMENT, cbData, 8)
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 */
1351  TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, rclClip, 16)
1354 }
1355 
1356 static void test_pack_EMRINVERTRGN(void)
1357 {
1358  /* EMRINVERTRGN */
1361  TEST_FIELD_SIZE (EMRINVERTRGN, emr, 8)
1362  TEST_FIELD_ALIGN (EMRINVERTRGN, emr, 4)
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 */
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)
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 */
1478 }
1479 
1480 static void test_pack_EMRMOVETOEX(void)
1481 {
1482  /* EMRMOVETOEX */
1485  TEST_FIELD_SIZE (EMRMOVETOEX, emr, 8)
1486  TEST_FIELD_ALIGN (EMRMOVETOEX, emr, 4)
1488  TEST_FIELD_SIZE (EMRMOVETOEX, ptl, 8)
1489  TEST_FIELD_ALIGN (EMRMOVETOEX, ptl, 4)
1491 }
1492 
1493 static void test_pack_EMROFFSETCLIPRGN(void)
1494 {
1495  /* EMROFFSETCLIPRGN */
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 */
1511  TEST_FIELD_SIZE (EMRPAINTRGN, emr, 8)
1512  TEST_FIELD_ALIGN (EMRPAINTRGN, emr, 4)
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 */
1555 }
1556 
1557 static void test_pack_EMRPLGBLT(void)
1558 {
1559  /* EMRPLGBLT */
1560  TEST_TYPE_SIZE (EMRPLGBLT, 140)
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 */
1632  TEST_FIELD_SIZE (EMRPOLYBEZIER, emr, 8)
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 */
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)
1663 }
1664 
1665 static void test_pack_EMRPOLYBEZIERTO(void)
1666 {
1667  /* EMRPOLYBEZIERTO */
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)
1679  TEST_FIELD_SIZE (EMRPOLYBEZIERTO, aptl, 8)
1682 }
1683 
1684 static void test_pack_EMRPOLYBEZIERTO16(void)
1685 {
1686  /* EMRPOLYBEZIERTO16 */
1692  TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, rclBounds, 16)
1693  TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, rclBounds, 4)
1694  TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, rclBounds, 8)
1701 }
1702 
1703 static void test_pack_EMRPOLYDRAW(void)
1704 {
1705  /* EMRPOLYDRAW */
1708  TEST_FIELD_SIZE (EMRPOLYDRAW, emr, 8)
1709  TEST_FIELD_ALIGN (EMRPOLYDRAW, emr, 4)
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 */
1730  TEST_FIELD_SIZE (EMRPOLYDRAW16, emr, 8)
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)
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 */
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 */
1771  TEST_FIELD_SIZE (EMRPOLYGON16, emr, 8)
1772  TEST_FIELD_ALIGN (EMRPOLYGON16, emr, 4)
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)
1783 }
1784 
1785 static void test_pack_EMRPOLYLINE(void)
1786 {
1787  /* EMRPOLYLINE */
1790  TEST_FIELD_SIZE (EMRPOLYLINE, emr, 8)
1791  TEST_FIELD_ALIGN (EMRPOLYLINE, emr, 4)
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 */
1809  TEST_FIELD_SIZE (EMRPOLYLINE16, emr, 8)
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)
1821 }
1822 
1823 static void test_pack_EMRPOLYLINETO(void)
1824 {
1825  /* EMRPOLYLINETO */
1828  TEST_FIELD_SIZE (EMRPOLYLINETO, emr, 8)
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 */
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)
1859 }
1860 
1861 static void test_pack_EMRPOLYPOLYGON(void)
1862 {
1863  /* EMRPOLYPOLYGON */
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)
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)
1884 }
1885 
1886 static void test_pack_EMRPOLYPOLYGON16(void)
1887 {
1888  /* EMRPOLYPOLYGON16 */
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)
1903  TEST_FIELD_SIZE (EMRPOLYPOLYGON16, aPolyCounts, 4)
1904  TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, aPolyCounts, 4)
1905  TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts, 32)
1909 }
1910 
1911 static void test_pack_EMRPOLYPOLYLINE(void)
1912 {
1913  /* EMRPOLYPOLYLINE */
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)
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)
1934 }
1935 
1936 static void test_pack_EMRPOLYPOLYLINE16(void)
1937 {
1938  /* EMRPOLYPOLYLINE16 */
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)
1953  TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1954  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1955  TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, aPolyCounts, 32)
1959 }
1960 
1961 static void test_pack_EMRPOLYTEXTOUTA(void)
1962 {
1963  /* EMRPOLYTEXTOUTA */
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 */
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 */
2025 }
2026 
2027 static void test_pack_EMRRECTANGLE(void)
2028 {
2029  /* EMRRECTANGLE */
2032  TEST_FIELD_SIZE (EMRRECTANGLE, emr, 8)
2033  TEST_FIELD_ALIGN (EMRRECTANGLE, emr, 4)
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 */
2048  TEST_FIELD_SIZE (EMRRESIZEPALETTE, ihPal, 4)
2054 }
2055 
2056 static void test_pack_EMRRESTOREDC(void)
2057 {
2058  /* EMRRESTOREDC */
2061  TEST_FIELD_SIZE (EMRRESTOREDC, emr, 8)
2062  TEST_FIELD_ALIGN (EMRRESTOREDC, emr, 4)
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 */
2074  TEST_FIELD_SIZE (EMRROUNDRECT, emr, 8)
2075  TEST_FIELD_ALIGN (EMRROUNDRECT, emr, 4)
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 */
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 */
2115 }
2116 
2117 static void test_pack_EMRSCALEWINDOWEXTEX(void)
2118 {
2119  /* EMRSCALEWINDOWEXTEX */
2137 }
2138 
2139 static void test_pack_EMRSELECTCLIPPATH(void)
2140 {
2141  /* EMRSELECTCLIPPATH */
2150 }
2151 
2152 static void test_pack_EMRSELECTCOLORSPACE(void)
2153 {
2154  /* EMRSELECTCOLORSPACE */
2163 }
2164 
2165 static void test_pack_EMRSELECTOBJECT(void)
2166 {
2167  /* EMRSELECTOBJECT */
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 */
2186  TEST_FIELD_SIZE (EMRSELECTPALETTE, ihPal, 4)
2189 }
2190 
2191 static void test_pack_EMRSETARCDIRECTION(void)
2192 {
2193  /* EMRSETARCDIRECTION */
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 */
2209  TEST_FIELD_SIZE (EMRSETBKCOLOR, emr, 8)
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 */
2222  TEST_FIELD_SIZE (EMRSETBKMODE, emr, 8)
2223  TEST_FIELD_ALIGN (EMRSETBKMODE, emr, 4)
2228 }
2229 
2230 static void test_pack_EMRSETBRUSHORGEX(void)
2231 {
2232  /* EMRSETBRUSHORGEX */
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 */
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 */
2267 }
2268 
2269 static void test_pack_EMRSETDIBITSTODEVICE(void)
2270 {
2271  /* EMRSETDIBITSTODEVICE */
2277  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, rclBounds, 16)
2278  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, rclBounds, 4)
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)
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)
2319 }
2320 
2321 static void test_pack_EMRSETICMMODE(void)
2322 {
2323  /* EMRSETICMMODE */
2326  TEST_FIELD_SIZE (EMRSETICMMODE, emr, 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 */
2352  TEST_FIELD_SIZE (EMRSETMAPMODE, emr, 8)
2358 }
2359 
2360 static void test_pack_EMRSETMAPPERFLAGS(void)
2361 {
2362  /* EMRSETMAPPERFLAGS */
2371 }
2372 
2373 static void test_pack_EMRSETMETARGN(void)
2374 {
2375  /* EMRSETMETARGN */
2378  TEST_FIELD_SIZE (EMRSETMETARGN, emr, 8)
2381 }
2382 
2383 static void test_pack_EMRSETMITERLIMIT(void)
2384 {
2385  /* EMRSETMITERLIMIT */
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 */
2401  TEST_FIELD_SIZE (EMRSETPIXELV, emr, 8)
2402  TEST_FIELD_ALIGN (EMRSETPIXELV, emr, 4)
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 */
2423 }
2424 
2425 static void test_pack_EMRSETROP2(void)
2426 {
2427  /* EMRSETROP2 */
2430  TEST_FIELD_SIZE (EMRSETROP2, emr, 8)
2431  TEST_FIELD_ALIGN (EMRSETROP2, emr, 4)
2432  TEST_FIELD_OFFSET(EMRSETROP2, emr, 0)
2436 }
2437 
2438 static void test_pack_EMRSETSTRETCHBLTMODE(void)
2439 {
2440  /* EMRSETSTRETCHBLTMODE */
2449 }
2450 
2451 static void test_pack_EMRSETTEXTALIGN(void)
2452 {
2453  /* EMRSETTEXTALIGN */
2462 }
2463 
2464 static void test_pack_EMRSETTEXTCOLOR(void)
2465 {
2466  /* EMRSETTEXTCOLOR */
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 */
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 */
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 */
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 */
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 */
2540 }
2541 
2542 static void test_pack_EMRSTRETCHBLT(void)
2543 {
2544  /* EMRSTRETCHBLT */
2547  TEST_FIELD_SIZE (EMRSTRETCHBLT, emr, 8)
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)
2601 }
2602 
2603 static void test_pack_EMRSTRETCHDIBITS(void)
2604 {
2605  /* EMRSTRETCHDIBITS */
2611  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, rclBounds, 16)
2612  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, rclBounds, 4)
2613  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, rclBounds, 8)
2614  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, xDest, 4)
2617  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, yDest, 4)
2626  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxSrc, 4)
2629  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cySrc, 4)
2632  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBmiSrc, 4)
2633  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBmiSrc, 4)
2634  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBmiSrc, 48)
2635  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBmiSrc, 4)
2636  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBmiSrc, 4)
2637  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBmiSrc, 52)
2638  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBitsSrc, 4)
2639  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBitsSrc, 4)
2640  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBitsSrc, 56)
2641  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBitsSrc, 4)
2642  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBitsSrc, 4)
2643  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBitsSrc, 60)
2644  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, iUsageSrc, 4)
2645  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, iUsageSrc, 4)
2646  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, iUsageSrc, 64)
2647  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, dwRop, 4)
2650  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxDest, 4)
2651  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxDest, 4)
2652  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxDest, 72)
2653  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cyDest, 4)
2654  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cyDest, 4)
2655  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cyDest, 76)
2656 }
2657 
2658 static void test_pack_EMRSTROKEANDFILLPATH(void)
2659 {
2660  /* EMRSTROKEANDFILLPATH */
2666  TEST_FIELD_SIZE (EMRSTROKEANDFILLPATH, rclBounds, 16)
2667  TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, rclBounds, 4)
2669 }
2670 
2671 static void test_pack_EMRSTROKEPATH(void)
2672 {
2673  /* EMRSTROKEPATH */
2676  TEST_FIELD_SIZE (EMRSTROKEPATH, emr, 8)
2679  TEST_FIELD_SIZE (EMRSTROKEPATH, rclBounds, 16)
2680  TEST_FIELD_ALIGN (EMRSTROKEPATH, rclBounds, 4)
2681  TEST_FIELD_OFFSET(EMRSTROKEPATH, rclBounds, 8)
2682 }
2683 
2684 static void test_pack_EMRTEXT(void)
2685 {
2686  /* EMRTEXT */
2687  TEST_TYPE_SIZE (EMRTEXT, 40)
2689  TEST_FIELD_SIZE (EMRTEXT, ptlReference, 8)
2690  TEST_FIELD_ALIGN (EMRTEXT, ptlReference, 4)
2691  TEST_FIELD_OFFSET(EMRTEXT, ptlReference, 0)
2692  TEST_FIELD_SIZE (EMRTEXT, nChars, 4)
2693  TEST_FIELD_ALIGN (EMRTEXT, nChars, 4)
2694  TEST_FIELD_OFFSET(EMRTEXT, nChars, 8)
2695  TEST_FIELD_SIZE (EMRTEXT, offString, 4)
2696  TEST_FIELD_ALIGN (EMRTEXT, offString, 4)
2697  TEST_FIELD_OFFSET(EMRTEXT, offString, 12)
2698  TEST_FIELD_SIZE (EMRTEXT, fOptions, 4)
2699  TEST_FIELD_ALIGN (EMRTEXT, fOptions, 4)
2700  TEST_FIELD_OFFSET(EMRTEXT, fOptions, 16)
2701  TEST_FIELD_SIZE (EMRTEXT, rcl, 16)
2702  TEST_FIELD_ALIGN (EMRTEXT, rcl, 4)
2703  TEST_FIELD_OFFSET(EMRTEXT, rcl, 20)
2704  TEST_FIELD_SIZE (EMRTEXT, offDx, 4)
2705  TEST_FIELD_ALIGN (EMRTEXT, offDx, 4)
2706  TEST_FIELD_OFFSET(EMRTEXT, offDx, 36)
2707 }
2708 
2709 static void test_pack_EMRWIDENPATH(void)
2710 {
2711  /* EMRWIDENPATH */
2714  TEST_FIELD_SIZE (EMRWIDENPATH, emr, 8)
2715  TEST_FIELD_ALIGN (EMRWIDENPATH, emr, 4)
2717 }
2718 
2719 static void test_pack_ENHMETAHEADER(void)
2720 {
2721  /* ENHMETAHEADER */
2730  TEST_FIELD_SIZE (ENHMETAHEADER, rclBounds, 16)
2731  TEST_FIELD_ALIGN (ENHMETAHEADER, rclBounds, 4)
2732  TEST_FIELD_OFFSET(ENHMETAHEADER, rclBounds, 8)
2733  TEST_FIELD_SIZE (ENHMETAHEADER, rclFrame, 16)
2734  TEST_FIELD_ALIGN (ENHMETAHEADER, rclFrame, 4)
2735  TEST_FIELD_OFFSET(ENHMETAHEADER, rclFrame, 24)
2736  TEST_FIELD_SIZE (ENHMETAHEADER, dSignature, 4)
2737  TEST_FIELD_ALIGN (ENHMETAHEADER, dSignature, 4)
2738  TEST_FIELD_OFFSET(ENHMETAHEADER, dSignature, 40)
2739  TEST_FIELD_SIZE (ENHMETAHEADER, nVersion, 4)
2740  TEST_FIELD_ALIGN (ENHMETAHEADER, nVersion, 4)
2741  TEST_FIELD_OFFSET(ENHMETAHEADER, nVersion, 44)
2742  TEST_FIELD_SIZE (ENHMETAHEADER, nBytes, 4)
2743  TEST_FIELD_ALIGN (ENHMETAHEADER, nBytes, 4)
2744  TEST_FIELD_OFFSET(ENHMETAHEADER, nBytes, 48)
2745  TEST_FIELD_SIZE (ENHMETAHEADER, nRecords, 4)
2746  TEST_FIELD_ALIGN (ENHMETAHEADER, nRecords, 4)
2747  TEST_FIELD_OFFSET(ENHMETAHEADER, nRecords, 52)
2748  TEST_FIELD_SIZE (ENHMETAHEADER, nHandles, 2)
2749  TEST_FIELD_ALIGN (ENHMETAHEADER, nHandles, 2)
2750  TEST_FIELD_OFFSET(ENHMETAHEADER, nHandles, 56)
2751  TEST_FIELD_SIZE (ENHMETAHEADER, sReserved, 2)
2752  TEST_FIELD_ALIGN (ENHMETAHEADER, sReserved, 2)
2753  TEST_FIELD_OFFSET(ENHMETAHEADER, sReserved, 58)
2754  TEST_FIELD_SIZE (ENHMETAHEADER, nDescription, 4)
2755  TEST_FIELD_ALIGN (ENHMETAHEADER, nDescription, 4)
2756  TEST_FIELD_OFFSET(ENHMETAHEADER, nDescription, 60)
2757  TEST_FIELD_SIZE (ENHMETAHEADER, offDescription, 4)
2758  TEST_FIELD_ALIGN (ENHMETAHEADER, offDescription, 4)
2759  TEST_FIELD_OFFSET(ENHMETAHEADER, offDescription, 64)
2760  TEST_FIELD_SIZE (ENHMETAHEADER, nPalEntries, 4)
2761  TEST_FIELD_ALIGN (ENHMETAHEADER, nPalEntries, 4)
2762  TEST_FIELD_OFFSET(ENHMETAHEADER, nPalEntries, 68)
2763  TEST_FIELD_SIZE (ENHMETAHEADER, szlDevice, 8)
2764  TEST_FIELD_ALIGN (ENHMETAHEADER, szlDevice, 4)
2765  TEST_FIELD_OFFSET(ENHMETAHEADER, szlDevice, 72)
2766  TEST_FIELD_SIZE (ENHMETAHEADER, szlMillimeters, 8)
2767  TEST_FIELD_ALIGN (ENHMETAHEADER, szlMillimeters, 4)
2768  TEST_FIELD_OFFSET(ENHMETAHEADER, szlMillimeters, 80)
2769  TEST_FIELD_SIZE (ENHMETAHEADER, cbPixelFormat, 4)
2770  TEST_FIELD_ALIGN (ENHMETAHEADER, cbPixelFormat, 4)
2771  TEST_FIELD_OFFSET(ENHMETAHEADER, cbPixelFormat, 88)
2772  TEST_FIELD_SIZE (ENHMETAHEADER, offPixelFormat, 4)
2773  TEST_FIELD_ALIGN (ENHMETAHEADER, offPixelFormat, 4)
2774  TEST_FIELD_OFFSET(ENHMETAHEADER, offPixelFormat, 92)
2775  TEST_FIELD_SIZE (ENHMETAHEADER, bOpenGL, 4)
2776  TEST_FIELD_ALIGN (ENHMETAHEADER, bOpenGL, 4)
2777  TEST_FIELD_OFFSET(ENHMETAHEADER, bOpenGL, 96)
2778  TEST_FIELD_SIZE (ENHMETAHEADER, szlMicrometers, 8)
2779  TEST_FIELD_ALIGN (ENHMETAHEADER, szlMicrometers, 4)
2780  TEST_FIELD_OFFSET(ENHMETAHEADER, szlMicrometers, 100)
2781 }
2782 
2783 static void test_pack_ENHMETARECORD(void)
2784 {
2785  /* ENHMETARECORD */
2794  TEST_FIELD_SIZE (ENHMETARECORD, dParm, 4)
2795  TEST_FIELD_ALIGN (ENHMETARECORD, dParm, 4)
2796  TEST_FIELD_OFFSET(ENHMETARECORD, dParm, 8)
2797 }
2798 
2799 static void test_pack_ENHMFENUMPROC(void)
2800 {
2801  /* ENHMFENUMPROC */
2804 }
2805 
2806 static void test_pack_ENUMLOGFONTA(void)
2807 {
2808  /* ENUMLOGFONTA */
2811  TEST_FIELD_SIZE (ENUMLOGFONTA, elfLogFont, 60)
2812  TEST_FIELD_ALIGN (ENUMLOGFONTA, elfLogFont, 4)
2813  TEST_FIELD_OFFSET(ENUMLOGFONTA, elfLogFont, 0)
2814  TEST_FIELD_SIZE (ENUMLOGFONTA, elfFullName, 64)
2815  TEST_FIELD_ALIGN (ENUMLOGFONTA, elfFullName, 1)
2816  TEST_FIELD_OFFSET(ENUMLOGFONTA, elfFullName, 60)
2817  TEST_FIELD_SIZE (ENUMLOGFONTA, elfStyle, 32)
2818  TEST_FIELD_ALIGN (ENUMLOGFONTA, elfStyle, 1)
2819  TEST_FIELD_OFFSET(ENUMLOGFONTA, elfStyle, 124)
2820 }
2821 
2822 static void test_pack_ENUMLOGFONTEXA(void)
2823 {
2824  /* ENUMLOGFONTEXA */
2827  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfLogFont, 60)
2828  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfLogFont, 4)
2829  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfLogFont, 0)
2830  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfFullName, 64)
2831  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfFullName, 1)
2832  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfFullName, 60)
2833  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfStyle, 32)
2834  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfStyle, 1)
2835  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfStyle, 124)
2836  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfScript, 32)
2837  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfScript, 1)
2838  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfScript, 156)
2839 }
2840 
2841 static void test_pack_ENUMLOGFONTEXW(void)
2842 {
2843  /* ENUMLOGFONTEXW */
2846  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfLogFont, 92)
2847  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfLogFont, 4)
2848  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfLogFont, 0)
2849  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfFullName, 128)
2850  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfFullName, 2)
2851  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfFullName, 92)
2852  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfStyle, 64)
2853  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfStyle, 2)
2854  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfStyle, 220)
2855  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfScript, 64)
2856  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfScript, 2)
2857  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfScript, 284)
2858 }
2859 
2860 static void test_pack_ENUMLOGFONTW(void)
2861 {
2862  /* ENUMLOGFONTW */
2865  TEST_FIELD_SIZE (ENUMLOGFONTW, elfLogFont, 92)
2866  TEST_FIELD_ALIGN (ENUMLOGFONTW, elfLogFont, 4)
2867  TEST_FIELD_OFFSET(ENUMLOGFONTW, elfLogFont, 0)
2868  TEST_FIELD_SIZE (ENUMLOGFONTW, elfFullName, 128)
2869  TEST_FIELD_ALIGN (ENUMLOGFONTW, elfFullName, 2)
2870  TEST_FIELD_OFFSET(ENUMLOGFONTW, elfFullName, 92)
2871  TEST_FIELD_SIZE (ENUMLOGFONTW, elfStyle, 64)
2872  TEST_FIELD_ALIGN (ENUMLOGFONTW, elfStyle, 2)
2873  TEST_FIELD_OFFSET(ENUMLOGFONTW, elfStyle, 220)
2874 }
2875 
2876 static void test_pack_EXTLOGFONTA(void)
2877 {
2878  /* EXTLOGFONTA */
2881  TEST_FIELD_SIZE (EXTLOGFONTA, elfLogFont, 60)
2882  TEST_FIELD_ALIGN (EXTLOGFONTA, elfLogFont, 4)
2883  TEST_FIELD_OFFSET(EXTLOGFONTA, elfLogFont, 0)
2884  TEST_FIELD_SIZE (EXTLOGFONTA, elfFullName, 64)
2885  TEST_FIELD_ALIGN (EXTLOGFONTA, elfFullName, 1)
2886  TEST_FIELD_OFFSET(EXTLOGFONTA, elfFullName, 60)
2887  TEST_FIELD_SIZE (EXTLOGFONTA, elfStyle, 32)
2888  TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyle, 1)
2889  TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyle, 124)
2890  TEST_FIELD_SIZE (EXTLOGFONTA, elfVersion, 4)
2891  TEST_FIELD_ALIGN (EXTLOGFONTA, elfVersion, 4)
2892  TEST_FIELD_OFFSET(EXTLOGFONTA, elfVersion, 156)
2893  TEST_FIELD_SIZE (EXTLOGFONTA, elfStyleSize, 4)
2894  TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyleSize, 4)
2895  TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyleSize, 160)
2896  TEST_FIELD_SIZE (EXTLOGFONTA, elfMatch, 4)
2897  TEST_FIELD_ALIGN (EXTLOGFONTA, elfMatch, 4)
2898  TEST_FIELD_OFFSET(EXTLOGFONTA, elfMatch, 164)
2899  TEST_FIELD_SIZE (EXTLOGFONTA, elfReserved, 4)
2900  TEST_FIELD_ALIGN (EXTLOGFONTA, elfReserved, 4)
2901  TEST_FIELD_OFFSET(EXTLOGFONTA, elfReserved, 168)
2902  TEST_FIELD_SIZE (EXTLOGFONTA, elfVendorId, 4)
2903  TEST_FIELD_ALIGN (EXTLOGFONTA, elfVendorId, 1)
2904  TEST_FIELD_OFFSET(EXTLOGFONTA, elfVendorId, 172)
2905  TEST_FIELD_SIZE (EXTLOGFONTA, elfCulture, 4)
2906  TEST_FIELD_ALIGN (EXTLOGFONTA, elfCulture, 4)
2907  TEST_FIELD_OFFSET(EXTLOGFONTA, elfCulture, 176)
2908  TEST_FIELD_SIZE (EXTLOGFONTA, elfPanose, 10)
2909  TEST_FIELD_ALIGN (EXTLOGFONTA, elfPanose, 1)
2910  TEST_FIELD_OFFSET(EXTLOGFONTA, elfPanose, 180)
2911 }
2912 
2913 static void test_pack_EXTLOGFONTW(void)
2914 {
2915  /* EXTLOGFONTW */
2918  TEST_FIELD_SIZE (EXTLOGFONTW, elfLogFont, 92)
2919  TEST_FIELD_ALIGN (EXTLOGFONTW, elfLogFont, 4)
2920  TEST_FIELD_OFFSET(EXTLOGFONTW, elfLogFont, 0)
2921  TEST_FIELD_SIZE (EXTLOGFONTW, elfFullName, 128)
2922  TEST_FIELD_ALIGN (EXTLOGFONTW, elfFullName, 2)
2923  TEST_FIELD_OFFSET(EXTLOGFONTW, elfFullName, 92)
2924  TEST_FIELD_SIZE (EXTLOGFONTW, elfStyle, 64)
2925  TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyle, 2)
2926  TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyle, 220)
2927  TEST_FIELD_SIZE (EXTLOGFONTW, elfVersion, 4)
2928  TEST_FIELD_ALIGN (EXTLOGFONTW, elfVersion, 4)
2929  TEST_FIELD_OFFSET(EXTLOGFONTW, elfVersion, 284)
2930  TEST_FIELD_SIZE (EXTLOGFONTW, elfStyleSize, 4)
2931  TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyleSize, 4)
2932  TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyleSize, 288)
2933  TEST_FIELD_SIZE (EXTLOGFONTW, elfMatch, 4)
2934  TEST_FIELD_ALIGN (EXTLOGFONTW, elfMatch, 4)
2935  TEST_FIELD_OFFSET(EXTLOGFONTW, elfMatch, 292)
2936  TEST_FIELD_SIZE (EXTLOGFONTW, elfReserved, 4)
2937  TEST_FIELD_ALIGN (EXTLOGFONTW, elfReserved, 4)
2938  TEST_FIELD_OFFSET(EXTLOGFONTW, elfReserved, 296)
2939  TEST_FIELD_SIZE (EXTLOGFONTW, elfVendorId, 4)
2940  TEST_FIELD_ALIGN (EXTLOGFONTW, elfVendorId, 1)
2941  TEST_FIELD_OFFSET(EXTLOGFONTW, elfVendorId, 300)
2942  TEST_FIELD_SIZE (EXTLOGFONTW, elfCulture, 4)
2943  TEST_FIELD_ALIGN (EXTLOGFONTW, elfCulture, 4)
2944  TEST_FIELD_OFFSET(EXTLOGFONTW, elfCulture, 304)
2945  TEST_FIELD_SIZE (EXTLOGFONTW, elfPanose, 10)
2946  TEST_FIELD_ALIGN (EXTLOGFONTW, elfPanose, 1)
2947  TEST_FIELD_OFFSET(EXTLOGFONTW, elfPanose, 308)
2948 }
2949 
2950 static void test_pack_EXTLOGPEN(void)
2951 {
2952  /* EXTLOGPEN */
2955  TEST_FIELD_SIZE (EXTLOGPEN, elpPenStyle, 4)
2956  TEST_FIELD_ALIGN (EXTLOGPEN, elpPenStyle, 4)
2957  TEST_FIELD_OFFSET(EXTLOGPEN, elpPenStyle, 0)
2958  TEST_FIELD_SIZE (EXTLOGPEN, elpWidth, 4)
2959  TEST_FIELD_ALIGN (EXTLOGPEN, elpWidth, 4)
2960  TEST_FIELD_OFFSET(EXTLOGPEN, elpWidth, 4)
2961  TEST_FIELD_SIZE (EXTLOGPEN, elpBrushStyle, 4)
2962  TEST_FIELD_ALIGN (EXTLOGPEN, elpBrushStyle, 4)
2963  TEST_FIELD_OFFSET(EXTLOGPEN, elpBrushStyle, 8)
2964  TEST_FIELD_SIZE (EXTLOGPEN, elpColor, 4)
2965  TEST_FIELD_ALIGN (EXTLOGPEN, elpColor, 4)
2966  TEST_FIELD_OFFSET(EXTLOGPEN, elpColor, 12)
2967  TEST_FIELD_SIZE (EXTLOGPEN, elpHatch, 8)
2968  TEST_FIELD_ALIGN (EXTLOGPEN, elpHatch, 8)
2969  TEST_FIELD_OFFSET(EXTLOGPEN, elpHatch, 16)
2970  TEST_FIELD_SIZE (EXTLOGPEN, elpNumEntries, 4)
2971  TEST_FIELD_ALIGN (EXTLOGPEN, elpNumEntries, 4)
2972  TEST_FIELD_OFFSET(EXTLOGPEN, elpNumEntries, 24)
2973  TEST_FIELD_SIZE (EXTLOGPEN, elpStyleEntry, 4)
2974  TEST_FIELD_ALIGN (EXTLOGPEN, elpStyleEntry, 4)
2975  TEST_FIELD_OFFSET(EXTLOGPEN, elpStyleEntry, 28)
2976 }
2977 
2978 static void test_pack_FIXED(void)
2979 {
2980  /* FIXED */
2981  TEST_TYPE_SIZE (FIXED, 4)
2982  TEST_TYPE_ALIGN (FIXED, 2)
2983  TEST_FIELD_SIZE (FIXED, fract, 2)
2984  TEST_FIELD_ALIGN (FIXED, fract, 2)
2985  TEST_FIELD_OFFSET(FIXED, fract, 0)
2989 }
2990 
2991 static void test_pack_FONTENUMPROCA(void)
2992 {
2993  /* FONTENUMPROCA */
2996 }
2997 
2998 static void test_pack_FONTENUMPROCW(void)
2999 {
3000  /* FONTENUMPROCW */
3003 }
3004 
3005 static void test_pack_FONTSIGNATURE(void)
3006 {
3007  /* FONTSIGNATURE */
3010  TEST_FIELD_SIZE (FONTSIGNATURE, fsUsb, 16)
3011  TEST_FIELD_ALIGN (FONTSIGNATURE, fsUsb, 4)
3012  TEST_FIELD_OFFSET(FONTSIGNATURE, fsUsb, 0)
3013  TEST_FIELD_SIZE (FONTSIGNATURE, fsCsb, 8)
3014  TEST_FIELD_ALIGN (FONTSIGNATURE, fsCsb, 4)
3015  TEST_FIELD_OFFSET(FONTSIGNATURE, fsCsb, 16)
3016 }
3017 
3018 static void test_pack_FXPT16DOT16(void)
3019 {
3020  /* FXPT16DOT16 */
3023 }
3024 
3025 static void test_pack_FXPT2DOT30(void)
3026 {
3027  /* FXPT2DOT30 */
3030 }
3031 
3032 static void test_pack_GCP_RESULTSA(void)
3033 {
3034  /* GCP_RESULTSA */
3037  TEST_FIELD_SIZE (GCP_RESULTSA, lStructSize, 4)
3038  TEST_FIELD_ALIGN (GCP_RESULTSA, lStructSize, 4)
3039  TEST_FIELD_OFFSET(GCP_RESULTSA, lStructSize, 0)
3040  TEST_FIELD_SIZE (GCP_RESULTSA, lpOutString, 8)
3041  TEST_FIELD_ALIGN (GCP_RESULTSA, lpOutString, 8)
3042  TEST_FIELD_OFFSET(GCP_RESULTSA, lpOutString, 8)
3043  TEST_FIELD_SIZE (GCP_RESULTSA, lpOrder, 8)
3044  TEST_FIELD_ALIGN (GCP_RESULTSA, lpOrder, 8)
3045  TEST_FIELD_OFFSET(GCP_RESULTSA, lpOrder, 16)
3046  TEST_FIELD_SIZE (GCP_RESULTSA, lpDx, 8)
3047  TEST_FIELD_ALIGN (GCP_RESULTSA, lpDx, 8)
3048  TEST_FIELD_OFFSET(GCP_RESULTSA, lpDx, 24)
3049  TEST_FIELD_SIZE (GCP_RESULTSA, lpCaretPos, 8)
3050  TEST_FIELD_ALIGN (GCP_RESULTSA, lpCaretPos, 8)
3051  TEST_FIELD_OFFSET(GCP_RESULTSA, lpCaretPos, 32)
3052  TEST_FIELD_SIZE (GCP_RESULTSA, lpClass, 8)
3053  TEST_FIELD_ALIGN (GCP_RESULTSA, lpClass, 8)
3054  TEST_FIELD_OFFSET(GCP_RESULTSA, lpClass, 40)
3055  TEST_FIELD_SIZE (GCP_RESULTSA, lpGlyphs, 8)
3056  TEST_FIELD_ALIGN (GCP_RESULTSA, lpGlyphs, 8)
3057  TEST_FIELD_OFFSET(GCP_RESULTSA, lpGlyphs, 48)
3058  TEST_FIELD_SIZE (GCP_RESULTSA, nGlyphs, 4)
3059  TEST_FIELD_ALIGN (GCP_RESULTSA, nGlyphs, 4)
3060  TEST_FIELD_OFFSET(GCP_RESULTSA, nGlyphs, 56)
3061  TEST_FIELD_SIZE (GCP_RESULTSA, nMaxFit, 4)
3062  TEST_FIELD_ALIGN (GCP_RESULTSA, nMaxFit, 4)
3063  TEST_FIELD_OFFSET(GCP_RESULTSA, nMaxFit, 60)
3064 }
3065 
3066 static void test_pack_GCP_RESULTSW(void)
3067 {
3068  /* GCP_RESULTSW */
3071  TEST_FIELD_SIZE (GCP_RESULTSW, lStructSize, 4)
3072  TEST_FIELD_ALIGN (GCP_RESULTSW, lStructSize, 4)
3073  TEST_FIELD_OFFSET(GCP_RESULTSW, lStructSize, 0)
3074  TEST_FIELD_SIZE (GCP_RESULTSW, lpOutString, 8)
3075  TEST_FIELD_ALIGN (GCP_RESULTSW, lpOutString, 8)
3076  TEST_FIELD_OFFSET(GCP_RESULTSW, lpOutString, 8)
3077  TEST_FIELD_SIZE (GCP_RESULTSW, lpOrder, 8)
3078  TEST_FIELD_ALIGN (GCP_RESULTSW, lpOrder, 8)
3079  TEST_FIELD_OFFSET(GCP_RESULTSW, lpOrder, 16)
3080  TEST_FIELD_SIZE (GCP_RESULTSW, lpDx, 8)
3081  TEST_FIELD_ALIGN (GCP_RESULTSW, lpDx, 8)
3082  TEST_FIELD_OFFSET(GCP_RESULTSW, lpDx, 24)
3083  TEST_FIELD_SIZE (GCP_RESULTSW, lpCaretPos, 8)
3084  TEST_FIELD_ALIGN (GCP_RESULTSW, lpCaretPos, 8)
3085  TEST_FIELD_OFFSET(GCP_RESULTSW, lpCaretPos, 32)
3086  TEST_FIELD_SIZE (GCP_RESULTSW, lpClass, 8)
3087  TEST_FIELD_ALIGN (GCP_RESULTSW, lpClass, 8)
3088  TEST_FIELD_OFFSET(GCP_RESULTSW, lpClass, 40)
3089  TEST_FIELD_SIZE (GCP_RESULTSW, lpGlyphs, 8)
3090  TEST_FIELD_ALIGN (GCP_RESULTSW, lpGlyphs, 8)
3091  TEST_FIELD_OFFSET(GCP_RESULTSW, lpGlyphs, 48)
3092  TEST_FIELD_SIZE (GCP_RESULTSW, nGlyphs, 4)
3093  TEST_FIELD_ALIGN (GCP_RESULTSW, nGlyphs, 4)
3094  TEST_FIELD_OFFSET(GCP_RESULTSW, nGlyphs, 56)
3095  TEST_FIELD_SIZE (GCP_RESULTSW, nMaxFit, 4)
3096  TEST_FIELD_ALIGN (GCP_RESULTSW, nMaxFit, 4)
3097  TEST_FIELD_OFFSET(GCP_RESULTSW, nMaxFit, 60)
3098 }
3099 
3100 static void test_pack_GLYPHMETRICS(void)
3101 {
3102  /* GLYPHMETRICS */
3105  TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxX, 4)
3106  TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxX, 4)
3107  TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxX, 0)
3108  TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxY, 4)
3109  TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxY, 4)
3110  TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxY, 4)
3111  TEST_FIELD_SIZE (GLYPHMETRICS, gmptGlyphOrigin, 8)
3112  TEST_FIELD_ALIGN (GLYPHMETRICS, gmptGlyphOrigin, 4)
3113  TEST_FIELD_OFFSET(GLYPHMETRICS, gmptGlyphOrigin, 8)
3114  TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncX, 2)
3115  TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncX, 2)
3116  TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncX, 16)
3117  TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncY, 2)
3118  TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncY, 2)
3119  TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncY, 18)
3120 }
3121 
3122 static void test_pack_GLYPHMETRICSFLOAT(void)
3123 {
3124  /* GLYPHMETRICSFLOAT */
3127  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4)
3128  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4)
3129  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxX, 0)
3130  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4)
3131  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4)
3132  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxY, 4)
3133  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8)
3134  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 4)
3135  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8)
3136  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncX, 4)
3137  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncX, 4)
3138  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncX, 16)
3139  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncY, 4)
3140  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncY, 4)
3141  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncY, 20)
3142 }
3143 
3144 static void test_pack_GOBJENUMPROC(void)
3145 {
3146  /* GOBJENUMPROC */
3149 }
3150 
3151 static void test_pack_GRADIENT_RECT(void)
3152 {
3153  /* GRADIENT_RECT */
3156  TEST_FIELD_SIZE (GRADIENT_RECT, UpperLeft, 4)
3157  TEST_FIELD_ALIGN (GRADIENT_RECT, UpperLeft, 4)
3158  TEST_FIELD_OFFSET(GRADIENT_RECT, UpperLeft, 0)
3159  TEST_FIELD_SIZE (GRADIENT_RECT, LowerRight, 4)
3160  TEST_FIELD_ALIGN (GRADIENT_RECT, LowerRight, 4)
3161  TEST_FIELD_OFFSET(GRADIENT_RECT, LowerRight, 4)
3162 }
3163 
3164 static void test_pack_GRADIENT_TRIANGLE(void)
3165 {
3166  /* GRADIENT_TRIANGLE */
3169  TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex1, 4)
3170  TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex1, 4)
3172  TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex2, 4)
3173  TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex2, 4)
3175  TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex3, 4)
3176  TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex3, 4)
3178 }
3179 
3180 static void test_pack_HANDLETABLE(void)
3181 {
3182  /* HANDLETABLE */
3185  TEST_FIELD_SIZE (HANDLETABLE, objectHandle, 8)
3186  TEST_FIELD_ALIGN (HANDLETABLE, objectHandle, 8)
3187  TEST_FIELD_OFFSET(HANDLETABLE, objectHandle, 0)
3188 }
3189 
3190 static void test_pack_ICMENUMPROCA(void)
3191 {
3192  /* ICMENUMPROCA */
3195 }
3196 
3197 static void test_pack_ICMENUMPROCW(void)
3198 {
3199  /* ICMENUMPROCW */
3202 }
3203 
3204 static void test_pack_KERNINGPAIR(void)
3205 {
3206  /* KERNINGPAIR */
3209  TEST_FIELD_SIZE (KERNINGPAIR, wFirst, 2)
3210  TEST_FIELD_ALIGN (KERNINGPAIR, wFirst, 2)
3211  TEST_FIELD_OFFSET(KERNINGPAIR, wFirst, 0)
3212  TEST_FIELD_SIZE (KERNINGPAIR, wSecond, 2)
3213  TEST_FIELD_ALIGN (KERNINGPAIR, wSecond, 2)
3214  TEST_FIELD_OFFSET(KERNINGPAIR, wSecond, 2)
3215  TEST_FIELD_SIZE (KERNINGPAIR, iKernAmount, 4)
3216  TEST_FIELD_ALIGN (KERNINGPAIR, iKernAmount, 4)
3217  TEST_FIELD_OFFSET(KERNINGPAIR, iKernAmount, 4)
3218 }
3219 
3220 static void test_pack_LAYERPLANEDESCRIPTOR(void)
3221 {
3222  /* LAYERPLANEDESCRIPTOR */
3228  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, nVersion, 2)
3229  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, nVersion, 2)
3234  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iPixelType, 1)
3235  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iPixelType, 1)
3236  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iPixelType, 8)
3237  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cColorBits, 1)
3238  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cColorBits, 1)
3239  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cColorBits, 9)
3240  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedBits, 1)
3241  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedBits, 1)
3243  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedShift, 1)
3244  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedShift, 1)
3245  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cRedShift, 11)
3246  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenBits, 1)
3247  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenBits, 1)
3248  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenBits, 12)
3249  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenShift, 1)
3250  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenShift, 1)
3251  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenShift, 13)
3252  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueBits, 1)
3253  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueBits, 1)
3254  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueBits, 14)
3255  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueShift, 1)
3256  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueShift, 1)
3257  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueShift, 15)
3258  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaBits, 1)
3259  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaBits, 1)
3260  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaBits, 16)
3261  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaShift, 1)
3262  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaShift, 1)
3263  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaShift, 17)
3264  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBits, 1)
3265  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBits, 1)
3266  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBits, 18)
3267  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1)
3268  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1)
3269  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumRedBits, 19)
3270  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1)
3271  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1)
3272  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumGreenBits, 20)
3273  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1)
3274  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1)
3275  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBlueBits, 21)
3276  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1)
3277  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1)
3278  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 22)
3279  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cDepthBits, 1)
3280  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cDepthBits, 1)
3281  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cDepthBits, 23)
3282  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cStencilBits, 1)
3283  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cStencilBits, 1)
3284  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cStencilBits, 24)
3285  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1)
3286  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1)
3287  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAuxBuffers, 25)
3288  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iLayerPlane, 1)
3289  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iLayerPlane, 1)
3290  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iLayerPlane, 26)
3291  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, bReserved, 1)
3292  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, bReserved, 1)
3293  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, bReserved, 27)
3294  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, crTransparent, 4)
3295  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, crTransparent, 4)
3296  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, crTransparent, 28)
3297 }
3298 
3299 static void test_pack_LCSCSTYPE(void)
3300 {
3301  /* LCSCSTYPE */
3304 }
3305 
3306 static void test_pack_LCSGAMUTMATCH(void)
3307 {
3308  /* LCSGAMUTMATCH */
3311 }
3312 
3313 static void test_pack_LINEDDAPROC(void)
3314 {
3315  /* LINEDDAPROC */
3318 }
3319 
3320 static void test_pack_LOCALESIGNATURE(void)
3321 {
3322  /* LOCALESIGNATURE */
3325  TEST_FIELD_SIZE (LOCALESIGNATURE, lsUsb, 16)
3326  TEST_FIELD_ALIGN (LOCALESIGNATURE, lsUsb, 4)
3328  TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbDefault, 8)
3329  TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbDefault, 4)
3330  TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbDefault, 16)
3331  TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbSupported, 8)
3332  TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbSupported, 4)
3333  TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbSupported, 24)
3334 }
3335 
3336 static void test_pack_LOGBRUSH(void)
3337 {
3338  /* LOGBRUSH */
3339  TEST_TYPE_SIZE (LOGBRUSH, 16)
3341  TEST_FIELD_SIZE (LOGBRUSH, lbStyle, 4)
3342  TEST_FIELD_ALIGN (LOGBRUSH, lbStyle, 4)
3343  TEST_FIELD_OFFSET(LOGBRUSH, lbStyle, 0)
3344  TEST_FIELD_SIZE (LOGBRUSH, lbColor, 4)
3345  TEST_FIELD_ALIGN (LOGBRUSH, lbColor, 4)
3346  TEST_FIELD_OFFSET(LOGBRUSH, lbColor, 4)
3347  TEST_FIELD_SIZE (LOGBRUSH, lbHatch, 8)
3348  TEST_FIELD_ALIGN (LOGBRUSH, lbHatch, 8)
3349  TEST_FIELD_OFFSET(LOGBRUSH, lbHatch, 8)
3350 }
3351 
3352 static void test_pack_LOGCOLORSPACEA(void)
3353 {
3354  /* LOGCOLORSPACEA */
3357  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSignature, 4)
3358  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSignature, 4)
3359  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSignature, 0)
3360  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsVersion, 4)
3361  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsVersion, 4)
3362  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsVersion, 4)
3363  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSize, 4)
3364  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSize, 4)
3365  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSize, 8)
3366  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsCSType, 4)
3367  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsCSType, 4)
3368  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsCSType, 12)
3369  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsIntent, 4)
3370  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsIntent, 4)
3371  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsIntent, 16)
3372  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsEndpoints, 36)
3373  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsEndpoints, 4)
3374  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsEndpoints, 20)
3375  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaRed, 4)
3376  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaRed, 4)
3377  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaRed, 56)
3378  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaGreen, 4)
3379  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaGreen, 4)
3380  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaGreen, 60)
3381  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaBlue, 4)
3382  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaBlue, 4)
3383  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaBlue, 64)
3384  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsFilename, 260)
3385  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsFilename, 1)
3386  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsFilename, 68)
3387 }
3388 
3389 static void test_pack_LOGCOLORSPACEW(void)
3390 {
3391  /* LOGCOLORSPACEW */
3394  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSignature, 4)
3395  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSignature, 4)
3396  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSignature, 0)
3397  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsVersion, 4)
3398  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsVersion, 4)
3399  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsVersion, 4)
3400  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSize, 4)
3401  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSize, 4)
3402  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSize, 8)
3403  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsCSType, 4)
3404  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsCSType, 4)
3405  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsCSType, 12)
3406  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsIntent, 4)
3407  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsIntent, 4)
3408  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsIntent, 16)
3409  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsEndpoints, 36)
3410  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsEndpoints, 4)
3411  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsEndpoints, 20)
3412  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaRed, 4)
3413  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaRed, 4)
3414  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaRed, 56)
3415  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaGreen, 4)
3416  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaGreen, 4)
3417  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaGreen, 60)
3418  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaBlue, 4)
3419  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaBlue, 4)
3420  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaBlue, 64)
3421  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsFilename, 520)
3422  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsFilename, 2)
3423  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsFilename, 68)
3424 }
3425 
3426 static void test_pack_LOGFONTA(void)
3427 {
3428  /* LOGFONTA */
3429  TEST_TYPE_SIZE (LOGFONTA, 60)
3431  TEST_FIELD_SIZE (LOGFONTA, lfHeight, 4)
3432  TEST_FIELD_ALIGN (LOGFONTA, lfHeight, 4)
3433  TEST_FIELD_OFFSET(LOGFONTA, lfHeight, 0)
3434  TEST_FIELD_SIZE (LOGFONTA, lfWidth, 4)
3435  TEST_FIELD_ALIGN (LOGFONTA, lfWidth, 4)
3436  TEST_FIELD_OFFSET(LOGFONTA, lfWidth, 4)
3437  TEST_FIELD_SIZE (LOGFONTA, lfEscapement, 4)
3438  TEST_FIELD_ALIGN (LOGFONTA, lfEscapement, 4)
3439  TEST_FIELD_OFFSET(LOGFONTA, lfEscapement, 8)
3440  TEST_FIELD_SIZE (LOGFONTA, lfOrientation, 4)
3441  TEST_FIELD_ALIGN (LOGFONTA, lfOrientation, 4)
3442  TEST_FIELD_OFFSET(LOGFONTA, lfOrientation, 12)
3443  TEST_FIELD_SIZE (LOGFONTA, lfWeight, 4)
3444  TEST_FIELD_ALIGN (LOGFONTA, lfWeight, 4)
3445  TEST_FIELD_OFFSET(LOGFONTA, lfWeight, 16)
3446  TEST_FIELD_SIZE (LOGFONTA, lfItalic, 1)
3447  TEST_FIELD_ALIGN (LOGFONTA, lfItalic, 1)
3448  TEST_FIELD_OFFSET(LOGFONTA, lfItalic, 20)
3449  TEST_FIELD_SIZE (LOGFONTA, lfUnderline, 1)
3450  TEST_FIELD_ALIGN (LOGFONTA, lfUnderline, 1)
3451  TEST_FIELD_OFFSET(LOGFONTA, lfUnderline, 21)
3452  TEST_FIELD_SIZE (LOGFONTA, lfStrikeOut, 1)
3453  TEST_FIELD_ALIGN (LOGFONTA, lfStrikeOut, 1)
3454  TEST_FIELD_OFFSET(LOGFONTA, lfStrikeOut, 22)
3455  TEST_FIELD_SIZE (LOGFONTA, lfCharSet, 1)
3456  TEST_FIELD_ALIGN (LOGFONTA, lfCharSet, 1)
3457  TEST_FIELD_OFFSET(LOGFONTA, lfCharSet, 23)
3458  TEST_FIELD_SIZE (LOGFONTA, lfOutPrecision, 1)
3459  TEST_FIELD_ALIGN (LOGFONTA, lfOutPrecision, 1)
3460  TEST_FIELD_OFFSET(LOGFONTA, lfOutPrecision, 24)
3461  TEST_FIELD_SIZE (LOGFONTA, lfClipPrecision, 1)
3462  TEST_FIELD_ALIGN (LOGFONTA, lfClipPrecision, 1)
3463  TEST_FIELD_OFFSET(LOGFONTA, lfClipPrecision, 25)
3464  TEST_FIELD_SIZE (LOGFONTA, lfQuality, 1)
3465  TEST_FIELD_ALIGN (LOGFONTA, lfQuality, 1)
3466  TEST_FIELD_OFFSET(LOGFONTA, lfQuality, 26)
3467  TEST_FIELD_SIZE (LOGFONTA, lfPitchAndFamily, 1)
3468  TEST_FIELD_ALIGN (LOGFONTA, lfPitchAndFamily, 1)
3469  TEST_FIELD_OFFSET(LOGFONTA, lfPitchAndFamily, 27)
3470  TEST_FIELD_SIZE (LOGFONTA, lfFaceName, 32)
3471  TEST_FIELD_ALIGN (LOGFONTA, lfFaceName, 1)
3472  TEST_FIELD_OFFSET(LOGFONTA, lfFaceName, 28)
3473 }
3474 
3475 static void test_pack_LOGFONTW(void)
3476 {
3477  /* LOGFONTW */
3478  TEST_TYPE_SIZE (LOGFONTW, 92)
3480  TEST_FIELD_SIZE (LOGFONTW, lfHeight, 4)
3481  TEST_FIELD_ALIGN (LOGFONTW, lfHeight, 4)
3482  TEST_FIELD_OFFSET(LOGFONTW, lfHeight, 0)
3483  TEST_FIELD_SIZE (LOGFONTW, lfWidth, 4)
3484  TEST_FIELD_ALIGN (LOGFONTW, lfWidth, 4)
3485  TEST_FIELD_OFFSET(LOGFONTW, lfWidth, 4)
3486  TEST_FIELD_SIZE (LOGFONTW, lfEscapement, 4)
3487  TEST_FIELD_ALIGN (LOGFONTW, lfEscapement, 4)
3488  TEST_FIELD_OFFSET(LOGFONTW, lfEscapement, 8)
3489  TEST_FIELD_SIZE (LOGFONTW, lfOrientation, 4)
3490  TEST_FIELD_ALIGN (LOGFONTW, lfOrientation, 4)
3491  TEST_FIELD_OFFSET(LOGFONTW, lfOrientation, 12)
3492  TEST_FIELD_SIZE (LOGFONTW, lfWeight, 4)
3493  TEST_FIELD_ALIGN (LOGFONTW, lfWeight, 4)
3494  TEST_FIELD_OFFSET(LOGFONTW, lfWeight, 16)
3495  TEST_FIELD_SIZE (LOGFONTW, lfItalic, 1)
3496  TEST_FIELD_ALIGN (LOGFONTW, lfItalic, 1)
3497  TEST_FIELD_OFFSET(LOGFONTW, lfItalic, 20)
3498  TEST_FIELD_SIZE (LOGFONTW, lfUnderline, 1)
3499  TEST_FIELD_ALIGN (LOGFONTW, lfUnderline, 1)
3500  TEST_FIELD_OFFSET(LOGFONTW, lfUnderline, 21)
3501  TEST_FIELD_SIZE (LOGFONTW, lfStrikeOut, 1)
3502  TEST_FIELD_ALIGN (LOGFONTW, lfStrikeOut, 1)
3503  TEST_FIELD_OFFSET(LOGFONTW, lfStrikeOut, 22)
3504  TEST_FIELD_SIZE (LOGFONTW, lfCharSet, 1)
3505  TEST_FIELD_ALIGN (LOGFONTW, lfCharSet, 1)
3506  TEST_FIELD_OFFSET(LOGFONTW, lfCharSet, 23)
3507  TEST_FIELD_SIZE (LOGFONTW, lfOutPrecision, 1)
3508  TEST_FIELD_ALIGN (LOGFONTW, lfOutPrecision, 1)
3509  TEST_FIELD_OFFSET(LOGFONTW, lfOutPrecision, 24)
3510  TEST_FIELD_SIZE (LOGFONTW, lfClipPrecision, 1)
3511  TEST_FIELD_ALIGN (LOGFONTW, lfClipPrecision, 1)
3512  TEST_FIELD_OFFSET(LOGFONTW, lfClipPrecision, 25)
3513  TEST_FIELD_SIZE (LOGFONTW, lfQuality, 1)
3514  TEST_FIELD_ALIGN (LOGFONTW, lfQuality, 1)
3515  TEST_FIELD_OFFSET(LOGFONTW, lfQuality, 26)
3516  TEST_FIELD_SIZE (LOGFONTW, lfPitchAndFamily, 1)
3517  TEST_FIELD_ALIGN (LOGFONTW, lfPitchAndFamily, 1)
3518  TEST_FIELD_OFFSET(LOGFONTW, lfPitchAndFamily, 27)
3519  TEST_FIELD_SIZE (LOGFONTW, lfFaceName, 64)
3520  TEST_FIELD_ALIGN (LOGFONTW, lfFaceName, 2)
3521  TEST_FIELD_OFFSET(LOGFONTW, lfFaceName, 28)
3522 }
3523 
3524 static void test_pack_LOGPEN(void)
3525 {
3526  /* LOGPEN */
3527  TEST_TYPE_SIZE (LOGPEN, 16)
3528  TEST_TYPE_ALIGN (LOGPEN, 4)
3529  TEST_FIELD_SIZE (LOGPEN, lopnStyle, 4)
3530  TEST_FIELD_ALIGN (LOGPEN, lopnStyle, 4)
3531  TEST_FIELD_OFFSET(LOGPEN, lopnStyle, 0)
3532  TEST_FIELD_SIZE (LOGPEN, lopnWidth, 8)
3533  TEST_FIELD_ALIGN (LOGPEN, lopnWidth, 4)
3534  TEST_FIELD_OFFSET(LOGPEN, lopnWidth, 4)
3535  TEST_FIELD_SIZE (LOGPEN, lopnColor, 4)
3536  TEST_FIELD_ALIGN (LOGPEN, lopnColor, 4)
3537  TEST_FIELD_OFFSET(LOGPEN, lopnColor, 12)
3538 }
3539 
3540 static void test_pack_LPABC(void)
3541 {
3542  /* LPABC */
3543  TEST_TYPE_SIZE (LPABC, 8)
3544  TEST_TYPE_ALIGN (LPABC, 8)
3545  TEST_TARGET_SIZE (LPABC, 12)
3547 }
3548 
3549 static void test_pack_LPABCFLOAT(void)
3550 {
3551  /* LPABCFLOAT */
3556 }
3557 
3558 static void test_pack_LPBITMAP(void)
3559 {
3560  /* LPBITMAP */
3565 }
3566 
3567 static void test_pack_LPBITMAPCOREHEADER(void)
3568 {
3569  /* LPBITMAPCOREHEADER */
3574 }
3575 
3576 static void test_pack_LPBITMAPCOREINFO(void)
3577 {
3578  /* LPBITMAPCOREINFO */
3583 }
3584 
3585 static void test_pack_LPBITMAPFILEHEADER(void)
3586 {
3587  /* LPBITMAPFILEHEADER */
3592 }
3593 
3594 static void test_pack_LPBITMAPINFO(void)
3595 {
3596  /* LPBITMAPINFO */
3601 }
3602 
3603 static void test_pack_LPBITMAPINFOHEADER(void)
3604 {
3605  /* LPBITMAPINFOHEADER */
3610 }
3611 
3612 static void test_pack_LPBITMAPV5HEADER(void)
3613 {
3614  /* LPBITMAPV5HEADER */
3615  TEST_TYPE_SIZE (LPBITMAPV5HEADER, 8)
3616  TEST_TYPE_ALIGN (LPBITMAPV5HEADER, 8)
3617  TEST_TARGET_SIZE (LPBITMAPV5HEADER, 124)
3618  TEST_TARGET_ALIGN(LPBITMAPV5HEADER, 4)
3619 }
3620 
3621 static void test_pack_LPCHARSETINFO(void)
3622 {
3623  /* LPCHARSETINFO */
3628 }
3629 
3630 static void test_pack_LPCIEXYZ(void)
3631 {
3632  /* LPCIEXYZ */
3637 }
3638 
3639 static void test_pack_LPCIEXYZTRIPLE(void)
3640 {
3641  /* LPCIEXYZTRIPLE */
3646 }
3647 
3648 static void test_pack_LPCOLORADJUSTMENT(void)
3649 {
3650  /* LPCOLORADJUSTMENT */
3655 }
3656 
3657 static void test_pack_LPDEVMODEA(void)
3658 {
3659  /* LPDEVMODEA */
3662 }
3663 
3664 static void test_pack_LPDEVMODEW(void)
3665 {
3666  /* LPDEVMODEW */
3669 }
3670 
3671 static void test_pack_LPDIBSECTION(void)
3672 {
3673  /* LPDIBSECTION */
3678 }
3679 
3680 static void test_pack_LPDISPLAY_DEVICEA(void)
3681 {
3682  /* LPDISPLAY_DEVICEA */
3687 }
3688 
3689 static void test_pack_LPDISPLAY_DEVICEW(void)
3690 {
3691  /* LPDISPLAY_DEVICEW */
3696 }
3697 
3698 static void test_pack_LPDOCINFOA(void)
3699 {
3700  /* LPDOCINFOA */
3705 }
3706 
3707 static void test_pack_LPDOCINFOW(void)
3708 {
3709  /* LPDOCINFOW */
3714 }
3715 
3716 static void test_pack_LPENHMETAHEADER(void)
3717 {
3718  /* LPENHMETAHEADER */
3723 }
3724 
3725 static void test_pack_LPENHMETARECORD(void)
3726 {
3727  /* LPENHMETARECORD */
3732 }
3733 
3734 static void test_pack_LPENUMLOGFONTA(void)
3735 {
3736  /* LPENUMLOGFONTA */
3741 }
3742 
3743 static void test_pack_LPENUMLOGFONTEXA(void)
3744 {
3745  /* LPENUMLOGFONTEXA */
3750 }
3751 
3752 static void test_pack_LPENUMLOGFONTEXW(void)
3753 {
3754  /* LPENUMLOGFONTEXW */
3759 }
3760 
3761 static void test_pack_LPENUMLOGFONTW(void)
3762 {
3763  /* LPENUMLOGFONTW */
3768 }
3769 
3770 static void test_pack_LPEXTLOGFONTA(void)
3771 {
3772  /* LPEXTLOGFONTA */
3777 }
3778 
3779 static void test_pack_LPEXTLOGFONTW(void)
3780 {
3781  /* LPEXTLOGFONTW */
3786 }
3787 
3788 static void test_pack_LPEXTLOGPEN(void)
3789 {
3790  /* LPEXTLOGPEN */
3795 }
3796 
3797 static void test_pack_LPFONTSIGNATURE(void)
3798 {
3799  /* LPFONTSIGNATURE */
3804 }
3805 
3806 static void test_pack_LPGCP_RESULTSA(void)
3807 {
3808  /* LPGCP_RESULTSA */
3813 }
3814 
3815 static void test_pack_LPGCP_RESULTSW(void)
3816 {
3817  /* LPGCP_RESULTSW */
3822 }
3823 
3824 static void test_pack_LPGLYPHMETRICS(void)
3825 {
3826  /* LPGLYPHMETRICS */
3831 }
3832 
3833 static void test_pack_LPGLYPHMETRICSFLOAT(void)
3834 {
3835  /* LPGLYPHMETRICSFLOAT */
3840 }
3841 
3842 static void test_pack_LPGRADIENT_RECT(void)
3843 {
3844  /* LPGRADIENT_RECT */
3849 }
3850 
3851 static void test_pack_LPGRADIENT_TRIANGLE(void)
3852 {
3853  /* LPGRADIENT_TRIANGLE */
3858 }
3859 
3860 static void test_pack_LPHANDLETABLE(void)
3861 {
3862  /* LPHANDLETABLE */
3867 }
3868 
3869 static void test_pack_LPKERNINGPAIR(void)
3870 {
3871  /* LPKERNINGPAIR */
3876 }
3877 
3878 static void test_pack_LPLAYERPLANEDESCRIPTOR(void)
3879 {
3880  /* LPLAYERPLANEDESCRIPTOR */
3885 }
3886 
3887 static void test_pack_LPLOCALESIGNATURE(void)
3888 {
3889  /* LPLOCALESIGNATURE */
3894 }
3895 
3896 static void test_pack_LPLOGBRUSH(void)
3897 {
3898  /* LPLOGBRUSH */
3903 }
3904 
3905 static void test_pack_LPLOGCOLORSPACEA(void)
3906 {
3907  /* LPLOGCOLORSPACEA */
3912 }
3913 
3914 static void test_pack_LPLOGCOLORSPACEW(void)
3915 {
3916  /* LPLOGCOLORSPACEW */
3921 }
3922 
3923 static void test_pack_LPLOGFONTA(void)
3924 {
3925  /* LPLOGFONTA */
3930 }
3931 
3932 static void test_pack_LPLOGFONTW(void)
3933 {
3934  /* LPLOGFONTW */
3939 }
3940 
3941 static void test_pack_LPLOGPEN(void)
3942 {
3943  /* LPLOGPEN */
3948 }
3949 
3950 static void test_pack_LPMAT2(void)
3951 {
3952  /* LPMAT2 */
3953  TEST_TYPE_SIZE (LPMAT2, 8)
3954  TEST_TYPE_ALIGN (LPMAT2, 8)
3955  TEST_TARGET_SIZE (LPMAT2, 16)
3957 }
3958 
3959 static void test_pack_LPMETAFILEPICT(void)
3960 {
3961  /* LPMETAFILEPICT */
3966 }
3967 
3968 static void test_pack_LPMETAHEADER(void)
3969 {
3970  /* LPMETAHEADER */
3975 }
3976 
3977 static void test_pack_LPMETARECORD(void)
3978 {
3979  /* LPMETARECORD */
3984 }
3985 
3986 static void test_pack_LPNEWTEXTMETRICA(void)
3987 {
3988  /* LPNEWTEXTMETRICA */
3993 }
3994 
3995 static void test_pack_LPNEWTEXTMETRICW(void)
3996 {
3997  /* LPNEWTEXTMETRICW */
4002 }
4003 
4004 static void test_pack_LPOUTLINETEXTMETRICA(void)
4005 {
4006  /* LPOUTLINETEXTMETRICA */
4011 }
4012 
4013 static void test_pack_LPOUTLINETEXTMETRICW(void)
4014 {
4015  /* LPOUTLINETEXTMETRICW */
4020 }
4021 
4022 static void test_pack_LPPANOSE(void)
4023 {
4024  /* LPPANOSE */
4029 }
4030 
4031 static void test_pack_LPPELARRAY(void)
4032 {
4033  /* LPPELARRAY */
4038 }
4039 
4040 static void test_pack_LPPIXELFORMATDESCRIPTOR(void)
4041 {
4042  /* LPPIXELFORMATDESCRIPTOR */
4047 }
4048 
4049 static void test_pack_LPPOINTFX(void)
4050 {
4051  /* LPPOINTFX */
4056 }
4057 
4058 static void test_pack_LPPOLYTEXTA(void)
4059 {
4060  /* LPPOLYTEXTA */
4065 }
4066 
4067 static void test_pack_LPPOLYTEXTW(void)
4068 {
4069  /* LPPOLYTEXTW */
4074 }
4075 
4076 static void test_pack_LPRASTERIZER_STATUS(void)
4077 {
4078  /* LPRASTERIZER_STATUS */
4083 }
4084 
4085 static void test_pack_LPRGBQUAD(void)
4086 {
4087  /* LPRGBQUAD */
4092 }
4093 
4094 static void test_pack_LPRGNDATA(void)
4095 {
4096  /* LPRGNDATA */
4101 }
4102 
4103 static void test_pack_LPTEXTMETRICA(void)
4104 {
4105  /* LPTEXTMETRICA */
4110 }
4111 
4112 static void test_pack_LPTEXTMETRICW(void)
4113 {
4114  /* LPTEXTMETRICW */
4119 }
4120 
4121 static void test_pack_LPTRIVERTEX(void)
4122 {
4123  /* LPTRIVERTEX */
4128 }
4129 
4130 static void test_pack_LPTTPOLYCURVE(void)
4131 {
4132  /* LPTTPOLYCURVE */
4137 }
4138 
4139 static void test_pack_LPTTPOLYGONHEADER(void)
4140 {
4141  /* LPTTPOLYGONHEADER */
4146 }
4147 
4148 static void test_pack_LPXFORM(void)
4149 {
4150  /* LPXFORM */
4151  TEST_TYPE_SIZE (LPXFORM, 8)
4155 }
4156 
4157 static void test_pack_MAT2(void)
4158 {
4159  /* MAT2 */
4160  TEST_TYPE_SIZE (MAT2, 16)
4161  TEST_TYPE_ALIGN (MAT2, 2)
4162  TEST_FIELD_SIZE (MAT2, eM11, 4)
4163  TEST_FIELD_ALIGN (MAT2, eM11, 2)
4164  TEST_FIELD_OFFSET(MAT2, eM11, 0)
4165  TEST_FIELD_SIZE (MAT2, eM12, 4)
4166  TEST_FIELD_ALIGN (MAT2, eM12, 2)
4167  TEST_FIELD_OFFSET(MAT2, eM12, 4)
4168  TEST_FIELD_SIZE (MAT2, eM21, 4)