ReactOS  0.4.15-dev-344-g6808e40
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 #define WINE_NOWINSOCK
9 
10 #include "windows.h"
11 
12 #include "wine/test.h"
13 
14 /***********************************************************************
15  * Compatibility macros
16  */
17 
18 #define DWORD_PTR UINT_PTR
19 #define LONG_PTR INT_PTR
20 #define ULONG_PTR UINT_PTR
21 
22 /***********************************************************************
23  * Windows API extension
24  */
25 
26 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
27 # define _TYPE_ALIGNMENT(type) __alignof(type)
28 #elif defined(__GNUC__)
29 # define _TYPE_ALIGNMENT(type) __alignof__(type)
30 #else
31 /*
32  * FIXME: May not be possible without a compiler extension
33  * (if type is not just a name that is, otherwise the normal
34  * TYPE_ALIGNMENT can be used)
35  */
36 #endif
37 
38 #if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
39 #pragma warning(disable:4116)
40 #endif
41 
42 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
43 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
44 #endif
45 
46 /***********************************************************************
47  * Test helper macros
48  */
49 
50 #define TEST_TYPE_SIZE(type, size) C_ASSERT(sizeof(type) == size);
51 
52 #ifdef TYPE_ALIGNMENT
53 # define TEST_TYPE_ALIGN(type, align) C_ASSERT(TYPE_ALIGNMENT(type) == align);
54 #else
55 # define TEST_TYPE_ALIGN(type, align)
56 #endif
57 
58 #ifdef _TYPE_ALIGNMENT
59 # define TEST_TARGET_ALIGN(type, align) C_ASSERT(_TYPE_ALIGNMENT(*(type)0) == align);
60 # define TEST_FIELD_ALIGN(type, field, align) C_ASSERT(_TYPE_ALIGNMENT(((type*)0)->field) == align);
61 #else
62 # define TEST_TARGET_ALIGN(type, align)
63 # define TEST_FIELD_ALIGN(type, field, align)
64 #endif
65 
66 #define TEST_FIELD_OFFSET(type, field, offset) C_ASSERT(FIELD_OFFSET(type, field) == offset);
67 
68 #define TEST_TARGET_SIZE(type, size) TEST_TYPE_SIZE(*(type)0, size)
69 #define TEST_FIELD_SIZE(type, field, size) TEST_TYPE_SIZE((((type*)0)->field), size)
70 #define TEST_TYPE_SIGNED(type) C_ASSERT((type) -1 < 0);
71 #define TEST_TYPE_UNSIGNED(type) C_ASSERT((type) -1 > 0);
72 
73 
74 #ifdef _WIN64
75 
76 static void test_pack_ABC(void)
77 {
78  /* ABC */
79  TEST_TYPE_SIZE (ABC, 12)
80  TEST_TYPE_ALIGN (ABC, 4)
81  TEST_FIELD_SIZE (ABC, abcA, 4)
82  TEST_FIELD_ALIGN (ABC, abcA, 4)
83  TEST_FIELD_OFFSET(ABC, abcA, 0)
84  TEST_FIELD_SIZE (ABC, abcB, 4)
85  TEST_FIELD_ALIGN (ABC, abcB, 4)
86  TEST_FIELD_OFFSET(ABC, abcB, 4)
87  TEST_FIELD_SIZE (ABC, abcC, 4)
88  TEST_FIELD_ALIGN (ABC, abcC, 4)
89  TEST_FIELD_OFFSET(ABC, abcC, 8)
90 }
91 
92 static void test_pack_ABCFLOAT(void)
93 {
94  /* ABCFLOAT */
97  TEST_FIELD_SIZE (ABCFLOAT, abcfA, 4)
98  TEST_FIELD_ALIGN (ABCFLOAT, abcfA, 4)
99  TEST_FIELD_OFFSET(ABCFLOAT, abcfA, 0)
100  TEST_FIELD_SIZE (ABCFLOAT, abcfB, 4)
101  TEST_FIELD_ALIGN (ABCFLOAT, abcfB, 4)
102  TEST_FIELD_OFFSET(ABCFLOAT, abcfB, 4)
103  TEST_FIELD_SIZE (ABCFLOAT, abcfC, 4)
104  TEST_FIELD_ALIGN (ABCFLOAT, abcfC, 4)
105  TEST_FIELD_OFFSET(ABCFLOAT, abcfC, 8)
106 }
107 
108 static void test_pack_ABORTPROC(void)
109 {
110  /* ABORTPROC */
113 }
114 
115 static void test_pack_BITMAP(void)
116 {
117  /* BITMAP */
118  TEST_TYPE_SIZE (BITMAP, 32)
120  TEST_FIELD_SIZE (BITMAP, bmType, 4)
121  TEST_FIELD_ALIGN (BITMAP, bmType, 4)
122  TEST_FIELD_OFFSET(BITMAP, bmType, 0)
123  TEST_FIELD_SIZE (BITMAP, bmWidth, 4)
124  TEST_FIELD_ALIGN (BITMAP, bmWidth, 4)
125  TEST_FIELD_OFFSET(BITMAP, bmWidth, 4)
126  TEST_FIELD_SIZE (BITMAP, bmHeight, 4)
127  TEST_FIELD_ALIGN (BITMAP, bmHeight, 4)
128  TEST_FIELD_OFFSET(BITMAP, bmHeight, 8)
129  TEST_FIELD_SIZE (BITMAP, bmWidthBytes, 4)
130  TEST_FIELD_ALIGN (BITMAP, bmWidthBytes, 4)
131  TEST_FIELD_OFFSET(BITMAP, bmWidthBytes, 12)
132  TEST_FIELD_SIZE (BITMAP, bmPlanes, 2)
133  TEST_FIELD_ALIGN (BITMAP, bmPlanes, 2)
134  TEST_FIELD_OFFSET(BITMAP, bmPlanes, 16)
135  TEST_FIELD_SIZE (BITMAP, bmBitsPixel, 2)
136  TEST_FIELD_ALIGN (BITMAP, bmBitsPixel, 2)
137  TEST_FIELD_OFFSET(BITMAP, bmBitsPixel, 18)
138  TEST_FIELD_SIZE (BITMAP, bmBits, 8)
139  TEST_FIELD_ALIGN (BITMAP, bmBits, 8)
140  TEST_FIELD_OFFSET(BITMAP, bmBits, 24)
141 }
142 
143 static void test_pack_BITMAPCOREHEADER(void)
144 {
145  /* BITMAPCOREHEADER */
148  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcSize, 4)
151  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcWidth, 2)
152  TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcWidth, 2)
154  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcHeight, 2)
155  TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcHeight, 2)
156  TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcHeight, 6)
157  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcPlanes, 2)
158  TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcPlanes, 2)
159  TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcPlanes, 8)
160  TEST_FIELD_SIZE (BITMAPCOREHEADER, bcBitCount, 2)
161  TEST_FIELD_ALIGN (BITMAPCOREHEADER, bcBitCount, 2)
162  TEST_FIELD_OFFSET(BITMAPCOREHEADER, bcBitCount, 10)
163 }
164 
165 static void test_pack_BITMAPCOREINFO(void)
166 {
167  /* BITMAPCOREINFO */
170  TEST_FIELD_SIZE (BITMAPCOREINFO, bmciHeader, 12)
171  TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciHeader, 4)
172  TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciHeader, 0)
173  TEST_FIELD_SIZE (BITMAPCOREINFO, bmciColors, 3)
174  TEST_FIELD_ALIGN (BITMAPCOREINFO, bmciColors, 1)
175  TEST_FIELD_OFFSET(BITMAPCOREINFO, bmciColors, 12)
176 }
177 
178 static void test_pack_BITMAPFILEHEADER(void)
179 {
180  /* BITMAPFILEHEADER (pack 2) */
183  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfType, 2)
186  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfSize, 4)
189  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved1, 2)
190  TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved1, 2)
191  TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved1, 6)
192  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfReserved2, 2)
193  TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfReserved2, 2)
194  TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfReserved2, 8)
195  TEST_FIELD_SIZE (BITMAPFILEHEADER, bfOffBits, 4)
196  TEST_FIELD_ALIGN (BITMAPFILEHEADER, bfOffBits, 2)
197  TEST_FIELD_OFFSET(BITMAPFILEHEADER, bfOffBits, 10)
198 }
199 
200 static void test_pack_BITMAPINFO(void)
201 {
202  /* BITMAPINFO */
205  TEST_FIELD_SIZE (BITMAPINFO, bmiHeader, 40)
206  TEST_FIELD_ALIGN (BITMAPINFO, bmiHeader, 4)
207  TEST_FIELD_OFFSET(BITMAPINFO, bmiHeader, 0)
208  TEST_FIELD_SIZE (BITMAPINFO, bmiColors, 4)
209  TEST_FIELD_ALIGN (BITMAPINFO, bmiColors, 1)
210  TEST_FIELD_OFFSET(BITMAPINFO, bmiColors, 40)
211 }
212 
213 static void test_pack_BITMAPINFOHEADER(void)
214 {
215  /* BITMAPINFOHEADER */
218  TEST_FIELD_SIZE (BITMAPINFOHEADER, biSize, 4)
221  TEST_FIELD_SIZE (BITMAPINFOHEADER, biWidth, 4)
222  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biWidth, 4)
224  TEST_FIELD_SIZE (BITMAPINFOHEADER, biHeight, 4)
225  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biHeight, 4)
226  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biHeight, 8)
227  TEST_FIELD_SIZE (BITMAPINFOHEADER, biPlanes, 2)
228  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biPlanes, 2)
229  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biPlanes, 12)
230  TEST_FIELD_SIZE (BITMAPINFOHEADER, biBitCount, 2)
231  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biBitCount, 2)
232  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biBitCount, 14)
233  TEST_FIELD_SIZE (BITMAPINFOHEADER, biCompression, 4)
234  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biCompression, 4)
235  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biCompression, 16)
236  TEST_FIELD_SIZE (BITMAPINFOHEADER, biSizeImage, 4)
237  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biSizeImage, 4)
238  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biSizeImage, 20)
239  TEST_FIELD_SIZE (BITMAPINFOHEADER, biXPelsPerMeter, 4)
240  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biXPelsPerMeter, 4)
241  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biXPelsPerMeter, 24)
242  TEST_FIELD_SIZE (BITMAPINFOHEADER, biYPelsPerMeter, 4)
243  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biYPelsPerMeter, 4)
244  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biYPelsPerMeter, 28)
245  TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrUsed, 4)
246  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrUsed, 4)
247  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrUsed, 32)
248  TEST_FIELD_SIZE (BITMAPINFOHEADER, biClrImportant, 4)
249  TEST_FIELD_ALIGN (BITMAPINFOHEADER, biClrImportant, 4)
250  TEST_FIELD_OFFSET(BITMAPINFOHEADER, biClrImportant, 36)
251 }
252 
253 static void test_pack_BITMAPV4HEADER(void)
254 {
255  /* BITMAPV4HEADER */
258  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Size, 4)
259  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Size, 4)
260  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Size, 0)
261  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Width, 4)
262  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Width, 4)
263  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Width, 4)
264  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Height, 4)
265  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Height, 4)
266  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Height, 8)
267  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Planes, 2)
268  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Planes, 2)
269  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Planes, 12)
270  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BitCount, 2)
271  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BitCount, 2)
272  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BitCount, 14)
273  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4V4Compression, 4)
274  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4V4Compression, 4)
275  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4V4Compression, 16)
276  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4SizeImage, 4)
277  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4SizeImage, 4)
278  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4SizeImage, 20)
279  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4XPelsPerMeter, 4)
280  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4XPelsPerMeter, 4)
281  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4XPelsPerMeter, 24)
282  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4YPelsPerMeter, 4)
283  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4YPelsPerMeter, 4)
284  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4YPelsPerMeter, 28)
285  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrUsed, 4)
286  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrUsed, 4)
287  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrUsed, 32)
288  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4ClrImportant, 4)
289  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4ClrImportant, 4)
290  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4ClrImportant, 36)
291  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4RedMask, 4)
292  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4RedMask, 4)
293  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4RedMask, 40)
294  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GreenMask, 4)
295  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GreenMask, 4)
296  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GreenMask, 44)
297  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4BlueMask, 4)
298  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4BlueMask, 4)
299  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4BlueMask, 48)
300  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4AlphaMask, 4)
301  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4AlphaMask, 4)
302  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4AlphaMask, 52)
303  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4CSType, 4)
304  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4CSType, 4)
305  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4CSType, 56)
306  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4Endpoints, 36)
307  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4Endpoints, 4)
308  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4Endpoints, 60)
309  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaRed, 4)
310  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaRed, 4)
311  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaRed, 96)
312  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaGreen, 4)
313  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaGreen, 4)
314  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaGreen, 100)
315  TEST_FIELD_SIZE (BITMAPV4HEADER, bV4GammaBlue, 4)
316  TEST_FIELD_ALIGN (BITMAPV4HEADER, bV4GammaBlue, 4)
317  TEST_FIELD_OFFSET(BITMAPV4HEADER, bV4GammaBlue, 104)
318 }
319 
320 static void test_pack_BITMAPV5HEADER(void)
321 {
322  /* BITMAPV5HEADER */
323  TEST_TYPE_SIZE (BITMAPV5HEADER, 124)
324  TEST_TYPE_ALIGN (BITMAPV5HEADER, 4)
325  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Size, 4)
326  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Size, 4)
327  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Size, 0)
328  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Width, 4)
329  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Width, 4)
330  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Width, 4)
331  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Height, 4)
332  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Height, 4)
333  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Height, 8)
334  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Planes, 2)
335  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Planes, 2)
336  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Planes, 12)
337  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BitCount, 2)
338  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BitCount, 2)
339  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BitCount, 14)
340  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Compression, 4)
341  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Compression, 4)
342  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Compression, 16)
343  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5SizeImage, 4)
344  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5SizeImage, 4)
345  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5SizeImage, 20)
346  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5XPelsPerMeter, 4)
347  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5XPelsPerMeter, 4)
348  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5XPelsPerMeter, 24)
349  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5YPelsPerMeter, 4)
350  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5YPelsPerMeter, 4)
351  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5YPelsPerMeter, 28)
352  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrUsed, 4)
353  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrUsed, 4)
354  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrUsed, 32)
355  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ClrImportant, 4)
356  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ClrImportant, 4)
357  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ClrImportant, 36)
358  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5RedMask, 4)
359  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5RedMask, 4)
360  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5RedMask, 40)
361  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GreenMask, 4)
362  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GreenMask, 4)
363  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GreenMask, 44)
364  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5BlueMask, 4)
365  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5BlueMask, 4)
366  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5BlueMask, 48)
367  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5AlphaMask, 4)
368  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5AlphaMask, 4)
369  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5AlphaMask, 52)
370  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5CSType, 4)
371  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5CSType, 4)
372  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5CSType, 56)
373  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Endpoints, 36)
374  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Endpoints, 4)
375  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Endpoints, 60)
376  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaRed, 4)
377  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaRed, 4)
378  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaRed, 96)
379  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaGreen, 4)
380  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaGreen, 4)
381  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaGreen, 100)
382  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5GammaBlue, 4)
383  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5GammaBlue, 4)
384  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5GammaBlue, 104)
385  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Intent, 4)
386  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Intent, 4)
387  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Intent, 108)
388  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileData, 4)
389  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileData, 4)
390  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileData, 112)
391  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5ProfileSize, 4)
392  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5ProfileSize, 4)
393  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5ProfileSize, 116)
394  TEST_FIELD_SIZE (BITMAPV5HEADER, bV5Reserved, 4)
395  TEST_FIELD_ALIGN (BITMAPV5HEADER, bV5Reserved, 4)
396  TEST_FIELD_OFFSET(BITMAPV5HEADER, bV5Reserved, 120)
397 }
398 
399 static void test_pack_BLENDFUNCTION(void)
400 {
401  /* BLENDFUNCTION */
404  TEST_FIELD_SIZE (BLENDFUNCTION, BlendOp, 1)
405  TEST_FIELD_ALIGN (BLENDFUNCTION, BlendOp, 1)
406  TEST_FIELD_OFFSET(BLENDFUNCTION, BlendOp, 0)
407  TEST_FIELD_SIZE (BLENDFUNCTION, BlendFlags, 1)
408  TEST_FIELD_ALIGN (BLENDFUNCTION, BlendFlags, 1)
409  TEST_FIELD_OFFSET(BLENDFUNCTION, BlendFlags, 1)
410  TEST_FIELD_SIZE (BLENDFUNCTION, SourceConstantAlpha, 1)
411  TEST_FIELD_ALIGN (BLENDFUNCTION, SourceConstantAlpha, 1)
412  TEST_FIELD_OFFSET(BLENDFUNCTION, SourceConstantAlpha, 2)
413  TEST_FIELD_SIZE (BLENDFUNCTION, AlphaFormat, 1)
414  TEST_FIELD_ALIGN (BLENDFUNCTION, AlphaFormat, 1)
415  TEST_FIELD_OFFSET(BLENDFUNCTION, AlphaFormat, 3)
416 }
417 
418 static void test_pack_CHARSETINFO(void)
419 {
420  /* CHARSETINFO */
423  TEST_FIELD_SIZE (CHARSETINFO, ciCharset, 4)
424  TEST_FIELD_ALIGN (CHARSETINFO, ciCharset, 4)
425  TEST_FIELD_OFFSET(CHARSETINFO, ciCharset, 0)
426  TEST_FIELD_SIZE (CHARSETINFO, ciACP, 4)
427  TEST_FIELD_ALIGN (CHARSETINFO, ciACP, 4)
428  TEST_FIELD_OFFSET(CHARSETINFO, ciACP, 4)
432 }
433 
434 static void test_pack_CIEXYZ(void)
435 {
436  /* CIEXYZ */
437  TEST_TYPE_SIZE (CIEXYZ, 12)
439  TEST_FIELD_SIZE (CIEXYZ, ciexyzX, 4)
440  TEST_FIELD_ALIGN (CIEXYZ, ciexyzX, 4)
441  TEST_FIELD_OFFSET(CIEXYZ, ciexyzX, 0)
442  TEST_FIELD_SIZE (CIEXYZ, ciexyzY, 4)
443  TEST_FIELD_ALIGN (CIEXYZ, ciexyzY, 4)
444  TEST_FIELD_OFFSET(CIEXYZ, ciexyzY, 4)
445  TEST_FIELD_SIZE (CIEXYZ, ciexyzZ, 4)
446  TEST_FIELD_ALIGN (CIEXYZ, ciexyzZ, 4)
447  TEST_FIELD_OFFSET(CIEXYZ, ciexyzZ, 8)
448 }
449 
450 static void test_pack_CIEXYZTRIPLE(void)
451 {
452  /* CIEXYZTRIPLE */
455  TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzRed, 12)
456  TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzRed, 4)
457  TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzRed, 0)
458  TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzGreen, 12)
459  TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzGreen, 4)
460  TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzGreen, 12)
461  TEST_FIELD_SIZE (CIEXYZTRIPLE, ciexyzBlue, 12)
462  TEST_FIELD_ALIGN (CIEXYZTRIPLE, ciexyzBlue, 4)
463  TEST_FIELD_OFFSET(CIEXYZTRIPLE, ciexyzBlue, 24)
464 }
465 
466 static void test_pack_COLOR16(void)
467 {
468  /* COLOR16 */
471 }
472 
473 static void test_pack_COLORADJUSTMENT(void)
474 {
475  /* COLORADJUSTMENT */
478  TEST_FIELD_SIZE (COLORADJUSTMENT, caSize, 2)
479  TEST_FIELD_ALIGN (COLORADJUSTMENT, caSize, 2)
481  TEST_FIELD_SIZE (COLORADJUSTMENT, caFlags, 2)
482  TEST_FIELD_ALIGN (COLORADJUSTMENT, caFlags, 2)
484  TEST_FIELD_SIZE (COLORADJUSTMENT, caIlluminantIndex, 2)
485  TEST_FIELD_ALIGN (COLORADJUSTMENT, caIlluminantIndex, 2)
486  TEST_FIELD_OFFSET(COLORADJUSTMENT, caIlluminantIndex, 4)
487  TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGamma, 2)
488  TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGamma, 2)
489  TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGamma, 6)
490  TEST_FIELD_SIZE (COLORADJUSTMENT, caGreenGamma, 2)
491  TEST_FIELD_ALIGN (COLORADJUSTMENT, caGreenGamma, 2)
492  TEST_FIELD_OFFSET(COLORADJUSTMENT, caGreenGamma, 8)
493  TEST_FIELD_SIZE (COLORADJUSTMENT, caBlueGamma, 2)
494  TEST_FIELD_ALIGN (COLORADJUSTMENT, caBlueGamma, 2)
495  TEST_FIELD_OFFSET(COLORADJUSTMENT, caBlueGamma, 10)
496  TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceBlack, 2)
497  TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceBlack, 2)
498  TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceBlack, 12)
499  TEST_FIELD_SIZE (COLORADJUSTMENT, caReferenceWhite, 2)
500  TEST_FIELD_ALIGN (COLORADJUSTMENT, caReferenceWhite, 2)
501  TEST_FIELD_OFFSET(COLORADJUSTMENT, caReferenceWhite, 14)
502  TEST_FIELD_SIZE (COLORADJUSTMENT, caContrast, 2)
503  TEST_FIELD_ALIGN (COLORADJUSTMENT, caContrast, 2)
504  TEST_FIELD_OFFSET(COLORADJUSTMENT, caContrast, 16)
505  TEST_FIELD_SIZE (COLORADJUSTMENT, caBrightness, 2)
506  TEST_FIELD_ALIGN (COLORADJUSTMENT, caBrightness, 2)
507  TEST_FIELD_OFFSET(COLORADJUSTMENT, caBrightness, 18)
508  TEST_FIELD_SIZE (COLORADJUSTMENT, caColorfulness, 2)
509  TEST_FIELD_ALIGN (COLORADJUSTMENT, caColorfulness, 2)
510  TEST_FIELD_OFFSET(COLORADJUSTMENT, caColorfulness, 20)
511  TEST_FIELD_SIZE (COLORADJUSTMENT, caRedGreenTint, 2)
512  TEST_FIELD_ALIGN (COLORADJUSTMENT, caRedGreenTint, 2)
513  TEST_FIELD_OFFSET(COLORADJUSTMENT, caRedGreenTint, 22)
514 }
515 
516 static void test_pack_DEVMODEA(void)
517 {
518  /* DEVMODEA */
519  TEST_FIELD_SIZE (DEVMODEA, dmDeviceName, 32)
520  TEST_FIELD_ALIGN (DEVMODEA, dmDeviceName, 1)
521  TEST_FIELD_OFFSET(DEVMODEA, dmDeviceName, 0)
522  TEST_FIELD_SIZE (DEVMODEA, dmSpecVersion, 2)
523  TEST_FIELD_ALIGN (DEVMODEA, dmSpecVersion, 2)
524  TEST_FIELD_OFFSET(DEVMODEA, dmSpecVersion, 32)
525  TEST_FIELD_SIZE (DEVMODEA, dmDriverVersion, 2)
526  TEST_FIELD_ALIGN (DEVMODEA, dmDriverVersion, 2)
527  TEST_FIELD_OFFSET(DEVMODEA, dmDriverVersion, 34)
528  TEST_FIELD_SIZE (DEVMODEA, dmSize, 2)
529  TEST_FIELD_ALIGN (DEVMODEA, dmSize, 2)
530  TEST_FIELD_OFFSET(DEVMODEA, dmSize, 36)
531  TEST_FIELD_SIZE (DEVMODEA, dmDriverExtra, 2)
532  TEST_FIELD_ALIGN (DEVMODEA, dmDriverExtra, 2)
533  TEST_FIELD_OFFSET(DEVMODEA, dmDriverExtra, 38)
534  TEST_FIELD_SIZE (DEVMODEA, dmFields, 4)
535  TEST_FIELD_ALIGN (DEVMODEA, dmFields, 4)
536  TEST_FIELD_OFFSET(DEVMODEA, dmFields, 40)
537 }
538 
539 static void test_pack_DEVMODEW(void)
540 {
541  /* DEVMODEW */
542  TEST_FIELD_SIZE (DEVMODEW, dmDeviceName, 64)
543  TEST_FIELD_ALIGN (DEVMODEW, dmDeviceName, 2)
544  TEST_FIELD_OFFSET(DEVMODEW, dmDeviceName, 0)
545  TEST_FIELD_SIZE (DEVMODEW, dmSpecVersion, 2)
546  TEST_FIELD_ALIGN (DEVMODEW, dmSpecVersion, 2)
547  TEST_FIELD_OFFSET(DEVMODEW, dmSpecVersion, 64)
548  TEST_FIELD_SIZE (DEVMODEW, dmDriverVersion, 2)
549  TEST_FIELD_ALIGN (DEVMODEW, dmDriverVersion, 2)
550  TEST_FIELD_OFFSET(DEVMODEW, dmDriverVersion, 66)
551  TEST_FIELD_SIZE (DEVMODEW, dmSize, 2)
552  TEST_FIELD_ALIGN (DEVMODEW, dmSize, 2)
553  TEST_FIELD_OFFSET(DEVMODEW, dmSize, 68)
554  TEST_FIELD_SIZE (DEVMODEW, dmDriverExtra, 2)
555  TEST_FIELD_ALIGN (DEVMODEW, dmDriverExtra, 2)
556  TEST_FIELD_OFFSET(DEVMODEW, dmDriverExtra, 70)
557  TEST_FIELD_SIZE (DEVMODEW, dmFields, 4)
558  TEST_FIELD_ALIGN (DEVMODEW, dmFields, 4)
559  TEST_FIELD_OFFSET(DEVMODEW, dmFields, 72)
560 }
561 
562 static void test_pack_DIBSECTION(void)
563 {
564  /* DIBSECTION */
567  TEST_FIELD_SIZE (DIBSECTION, dsBm, 32)
568  TEST_FIELD_ALIGN (DIBSECTION, dsBm, 8)
569  TEST_FIELD_OFFSET(DIBSECTION, dsBm, 0)
570  TEST_FIELD_SIZE (DIBSECTION, dsBmih, 40)
571  TEST_FIELD_ALIGN (DIBSECTION, dsBmih, 4)
572  TEST_FIELD_OFFSET(DIBSECTION, dsBmih, 32)
573  TEST_FIELD_SIZE (DIBSECTION, dsBitfields, 12)
574  TEST_FIELD_ALIGN (DIBSECTION, dsBitfields, 4)
575  TEST_FIELD_OFFSET(DIBSECTION, dsBitfields, 72)
576  TEST_FIELD_SIZE (DIBSECTION, dshSection, 8)
577  TEST_FIELD_ALIGN (DIBSECTION, dshSection, 8)
578  TEST_FIELD_OFFSET(DIBSECTION, dshSection, 88)
579  TEST_FIELD_SIZE (DIBSECTION, dsOffset, 4)
580  TEST_FIELD_ALIGN (DIBSECTION, dsOffset, 4)
581  TEST_FIELD_OFFSET(DIBSECTION, dsOffset, 96)
582 }
583 
584 static void test_pack_DISPLAY_DEVICEA(void)
585 {
586  /* DISPLAY_DEVICEA */
595  TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceString, 128)
596  TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceString, 1)
597  TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceString, 36)
598  TEST_FIELD_SIZE (DISPLAY_DEVICEA, StateFlags, 4)
599  TEST_FIELD_ALIGN (DISPLAY_DEVICEA, StateFlags, 4)
600  TEST_FIELD_OFFSET(DISPLAY_DEVICEA, StateFlags, 164)
604  TEST_FIELD_SIZE (DISPLAY_DEVICEA, DeviceKey, 128)
605  TEST_FIELD_ALIGN (DISPLAY_DEVICEA, DeviceKey, 1)
606  TEST_FIELD_OFFSET(DISPLAY_DEVICEA, DeviceKey, 296)
607 }
608 
609 static void test_pack_DISPLAY_DEVICEW(void)
610 {
611  /* DISPLAY_DEVICEW */
620  TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceString, 256)
621  TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceString, 2)
622  TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceString, 68)
623  TEST_FIELD_SIZE (DISPLAY_DEVICEW, StateFlags, 4)
624  TEST_FIELD_ALIGN (DISPLAY_DEVICEW, StateFlags, 4)
625  TEST_FIELD_OFFSET(DISPLAY_DEVICEW, StateFlags, 324)
629  TEST_FIELD_SIZE (DISPLAY_DEVICEW, DeviceKey, 256)
630  TEST_FIELD_ALIGN (DISPLAY_DEVICEW, DeviceKey, 2)
631  TEST_FIELD_OFFSET(DISPLAY_DEVICEW, DeviceKey, 584)
632 }
633 
634 static void test_pack_DOCINFOA(void)
635 {
636  /* DOCINFOA */
639  TEST_FIELD_SIZE (DOCINFOA, cbSize, 4)
640  TEST_FIELD_ALIGN (DOCINFOA, cbSize, 4)
641  TEST_FIELD_OFFSET(DOCINFOA, cbSize, 0)
642  TEST_FIELD_SIZE (DOCINFOA, lpszDocName, 8)
643  TEST_FIELD_ALIGN (DOCINFOA, lpszDocName, 8)
644  TEST_FIELD_OFFSET(DOCINFOA, lpszDocName, 8)
645  TEST_FIELD_SIZE (DOCINFOA, lpszOutput, 8)
646  TEST_FIELD_ALIGN (DOCINFOA, lpszOutput, 8)
647  TEST_FIELD_OFFSET(DOCINFOA, lpszOutput, 16)
648  TEST_FIELD_SIZE (DOCINFOA, lpszDatatype, 8)
649  TEST_FIELD_ALIGN (DOCINFOA, lpszDatatype, 8)
650  TEST_FIELD_OFFSET(DOCINFOA, lpszDatatype, 24)
651  TEST_FIELD_SIZE (DOCINFOA, fwType, 4)
652  TEST_FIELD_ALIGN (DOCINFOA, fwType, 4)
653  TEST_FIELD_OFFSET(DOCINFOA, fwType, 32)
654 }
655 
656 static void test_pack_DOCINFOW(void)
657 {
658  /* DOCINFOW */
661  TEST_FIELD_SIZE (DOCINFOW, cbSize, 4)
662  TEST_FIELD_ALIGN (DOCINFOW, cbSize, 4)
663  TEST_FIELD_OFFSET(DOCINFOW, cbSize, 0)
664  TEST_FIELD_SIZE (DOCINFOW, lpszDocName, 8)
665  TEST_FIELD_ALIGN (DOCINFOW, lpszDocName, 8)
666  TEST_FIELD_OFFSET(DOCINFOW, lpszDocName, 8)
667  TEST_FIELD_SIZE (DOCINFOW, lpszOutput, 8)
668  TEST_FIELD_ALIGN (DOCINFOW, lpszOutput, 8)
669  TEST_FIELD_OFFSET(DOCINFOW, lpszOutput, 16)
670  TEST_FIELD_SIZE (DOCINFOW, lpszDatatype, 8)
671  TEST_FIELD_ALIGN (DOCINFOW, lpszDatatype, 8)
672  TEST_FIELD_OFFSET(DOCINFOW, lpszDatatype, 24)
673  TEST_FIELD_SIZE (DOCINFOW, fwType, 4)
674  TEST_FIELD_ALIGN (DOCINFOW, fwType, 4)
675  TEST_FIELD_OFFSET(DOCINFOW, fwType, 32)
676 }
677 
678 static void test_pack_EMR(void)
679 {
680  /* EMR */
681  TEST_TYPE_SIZE (EMR, 8)
682  TEST_TYPE_ALIGN (EMR, 4)
689 }
690 
691 static void test_pack_EMRABORTPATH(void)
692 {
693  /* EMRABORTPATH */
696  TEST_FIELD_SIZE (EMRABORTPATH, emr, 8)
699 }
700 
701 static void test_pack_EMRANGLEARC(void)
702 {
703  /* EMRANGLEARC */
706  TEST_FIELD_SIZE (EMRANGLEARC, emr, 8)
707  TEST_FIELD_ALIGN (EMRANGLEARC, emr, 4)
709  TEST_FIELD_SIZE (EMRANGLEARC, ptlCenter, 8)
710  TEST_FIELD_ALIGN (EMRANGLEARC, ptlCenter, 4)
711  TEST_FIELD_OFFSET(EMRANGLEARC, ptlCenter, 8)
712  TEST_FIELD_SIZE (EMRANGLEARC, nRadius, 4)
713  TEST_FIELD_ALIGN (EMRANGLEARC, nRadius, 4)
714  TEST_FIELD_OFFSET(EMRANGLEARC, nRadius, 16)
715  TEST_FIELD_SIZE (EMRANGLEARC, eStartAngle, 4)
716  TEST_FIELD_ALIGN (EMRANGLEARC, eStartAngle, 4)
717  TEST_FIELD_OFFSET(EMRANGLEARC, eStartAngle, 20)
718  TEST_FIELD_SIZE (EMRANGLEARC, eSweepAngle, 4)
719  TEST_FIELD_ALIGN (EMRANGLEARC, eSweepAngle, 4)
720  TEST_FIELD_OFFSET(EMRANGLEARC, eSweepAngle, 24)
721 }
722 
723 static void test_pack_EMRARC(void)
724 {
725  /* EMRARC */
726  TEST_TYPE_SIZE (EMRARC, 40)
728  TEST_FIELD_SIZE (EMRARC, emr, 8)
729  TEST_FIELD_ALIGN (EMRARC, emr, 4)
730  TEST_FIELD_OFFSET(EMRARC, emr, 0)
731  TEST_FIELD_SIZE (EMRARC, rclBox, 16)
732  TEST_FIELD_ALIGN (EMRARC, rclBox, 4)
733  TEST_FIELD_OFFSET(EMRARC, rclBox, 8)
734  TEST_FIELD_SIZE (EMRARC, ptlStart, 8)
735  TEST_FIELD_ALIGN (EMRARC, ptlStart, 4)
736  TEST_FIELD_OFFSET(EMRARC, ptlStart, 24)
737  TEST_FIELD_SIZE (EMRARC, ptlEnd, 8)
738  TEST_FIELD_ALIGN (EMRARC, ptlEnd, 4)
739  TEST_FIELD_OFFSET(EMRARC, ptlEnd, 32)
740 }
741 
742 static void test_pack_EMRARCTO(void)
743 {
744  /* EMRARCTO */
747  TEST_FIELD_SIZE (EMRARCTO, emr, 8)
748  TEST_FIELD_ALIGN (EMRARCTO, emr, 4)
749  TEST_FIELD_OFFSET(EMRARCTO, emr, 0)
750  TEST_FIELD_SIZE (EMRARCTO, rclBox, 16)
751  TEST_FIELD_ALIGN (EMRARCTO, rclBox, 4)
752  TEST_FIELD_OFFSET(EMRARCTO, rclBox, 8)
753  TEST_FIELD_SIZE (EMRARCTO, ptlStart, 8)
754  TEST_FIELD_ALIGN (EMRARCTO, ptlStart, 4)
755  TEST_FIELD_OFFSET(EMRARCTO, ptlStart, 24)
756  TEST_FIELD_SIZE (EMRARCTO, ptlEnd, 8)
757  TEST_FIELD_ALIGN (EMRARCTO, ptlEnd, 4)
758  TEST_FIELD_OFFSET(EMRARCTO, ptlEnd, 32)
759 }
760 
761 static void test_pack_EMRBEGINPATH(void)
762 {
763  /* EMRBEGINPATH */
766  TEST_FIELD_SIZE (EMRBEGINPATH, emr, 8)
769 }
770 
771 static void test_pack_EMRBITBLT(void)
772 {
773  /* EMRBITBLT */
776  TEST_FIELD_SIZE (EMRBITBLT, emr, 8)
777  TEST_FIELD_ALIGN (EMRBITBLT, emr, 4)
779  TEST_FIELD_SIZE (EMRBITBLT, rclBounds, 16)
780  TEST_FIELD_ALIGN (EMRBITBLT, rclBounds, 4)
781  TEST_FIELD_OFFSET(EMRBITBLT, rclBounds, 8)
782  TEST_FIELD_SIZE (EMRBITBLT, xDest, 4)
783  TEST_FIELD_ALIGN (EMRBITBLT, xDest, 4)
784  TEST_FIELD_OFFSET(EMRBITBLT, xDest, 24)
785  TEST_FIELD_SIZE (EMRBITBLT, yDest, 4)
786  TEST_FIELD_ALIGN (EMRBITBLT, yDest, 4)
787  TEST_FIELD_OFFSET(EMRBITBLT, yDest, 28)
788  TEST_FIELD_SIZE (EMRBITBLT, cxDest, 4)
789  TEST_FIELD_ALIGN (EMRBITBLT, cxDest, 4)
790  TEST_FIELD_OFFSET(EMRBITBLT, cxDest, 32)
791  TEST_FIELD_SIZE (EMRBITBLT, cyDest, 4)
792  TEST_FIELD_ALIGN (EMRBITBLT, cyDest, 4)
793  TEST_FIELD_OFFSET(EMRBITBLT, cyDest, 36)
794  TEST_FIELD_SIZE (EMRBITBLT, dwRop, 4)
795  TEST_FIELD_ALIGN (EMRBITBLT, dwRop, 4)
796  TEST_FIELD_OFFSET(EMRBITBLT, dwRop, 40)
797  TEST_FIELD_SIZE (EMRBITBLT, xSrc, 4)
798  TEST_FIELD_ALIGN (EMRBITBLT, xSrc, 4)
799  TEST_FIELD_OFFSET(EMRBITBLT, xSrc, 44)
800  TEST_FIELD_SIZE (EMRBITBLT, ySrc, 4)
801  TEST_FIELD_ALIGN (EMRBITBLT, ySrc, 4)
802  TEST_FIELD_OFFSET(EMRBITBLT, ySrc, 48)
803  TEST_FIELD_SIZE (EMRBITBLT, xformSrc, 24)
804  TEST_FIELD_ALIGN (EMRBITBLT, xformSrc, 4)
805  TEST_FIELD_OFFSET(EMRBITBLT, xformSrc, 52)
806  TEST_FIELD_SIZE (EMRBITBLT, crBkColorSrc, 4)
807  TEST_FIELD_ALIGN (EMRBITBLT, crBkColorSrc, 4)
808  TEST_FIELD_OFFSET(EMRBITBLT, crBkColorSrc, 76)
809  TEST_FIELD_SIZE (EMRBITBLT, iUsageSrc, 4)
810  TEST_FIELD_ALIGN (EMRBITBLT, iUsageSrc, 4)
811  TEST_FIELD_OFFSET(EMRBITBLT, iUsageSrc, 80)
812  TEST_FIELD_SIZE (EMRBITBLT, offBmiSrc, 4)
813  TEST_FIELD_ALIGN (EMRBITBLT, offBmiSrc, 4)
814  TEST_FIELD_OFFSET(EMRBITBLT, offBmiSrc, 84)
815  TEST_FIELD_SIZE (EMRBITBLT, cbBmiSrc, 4)
816  TEST_FIELD_ALIGN (EMRBITBLT, cbBmiSrc, 4)
817  TEST_FIELD_OFFSET(EMRBITBLT, cbBmiSrc, 88)
818  TEST_FIELD_SIZE (EMRBITBLT, offBitsSrc, 4)
819  TEST_FIELD_ALIGN (EMRBITBLT, offBitsSrc, 4)
820  TEST_FIELD_OFFSET(EMRBITBLT, offBitsSrc, 92)
821  TEST_FIELD_SIZE (EMRBITBLT, cbBitsSrc, 4)
822  TEST_FIELD_ALIGN (EMRBITBLT, cbBitsSrc, 4)
823  TEST_FIELD_OFFSET(EMRBITBLT, cbBitsSrc, 96)
824 }
825 
826 static void test_pack_EMRCHORD(void)
827 {
828  /* EMRCHORD */
831  TEST_FIELD_SIZE (EMRCHORD, emr, 8)
832  TEST_FIELD_ALIGN (EMRCHORD, emr, 4)
833  TEST_FIELD_OFFSET(EMRCHORD, emr, 0)
834  TEST_FIELD_SIZE (EMRCHORD, rclBox, 16)
835  TEST_FIELD_ALIGN (EMRCHORD, rclBox, 4)
836  TEST_FIELD_OFFSET(EMRCHORD, rclBox, 8)
837  TEST_FIELD_SIZE (EMRCHORD, ptlStart, 8)
838  TEST_FIELD_ALIGN (EMRCHORD, ptlStart, 4)
839  TEST_FIELD_OFFSET(EMRCHORD, ptlStart, 24)
840  TEST_FIELD_SIZE (EMRCHORD, ptlEnd, 8)
841  TEST_FIELD_ALIGN (EMRCHORD, ptlEnd, 4)
842  TEST_FIELD_OFFSET(EMRCHORD, ptlEnd, 32)
843 }
844 
845 static void test_pack_EMRCLOSEFIGURE(void)
846 {
847  /* EMRCLOSEFIGURE */
853 }
854 
855 static void test_pack_EMRCREATEBRUSHINDIRECT(void)
856 {
857  /* EMRCREATEBRUSHINDIRECT */
869 }
870 
871 static void test_pack_EMRCREATECOLORSPACE(void)
872 {
873  /* EMRCREATECOLORSPACE */
885 }
886 
887 static void test_pack_EMRCREATECOLORSPACEW(void)
888 {
889  /* EMRCREATECOLORSPACEW */
910 }
911 
912 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
913 {
914  /* EMRCREATEDIBPATTERNBRUSHPT */
938 }
939 
940 static void test_pack_EMRCREATEMONOBRUSH(void)
941 {
942  /* EMRCREATEMONOBRUSH */
948  TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, ihBrush, 4)
960  TEST_FIELD_SIZE (EMRCREATEMONOBRUSH, offBits, 4)
966 }
967 
968 static void test_pack_EMRCREATEPEN(void)
969 {
970  /* EMRCREATEPEN */
973  TEST_FIELD_SIZE (EMRCREATEPEN, emr, 8)
976  TEST_FIELD_SIZE (EMRCREATEPEN, ihPen, 4)
977  TEST_FIELD_ALIGN (EMRCREATEPEN, ihPen, 4)
979  TEST_FIELD_SIZE (EMRCREATEPEN, lopn, 16)
980  TEST_FIELD_ALIGN (EMRCREATEPEN, lopn, 4)
982 }
983 
984 static void test_pack_EMRDELETECOLORSPACE(void)
985 {
986  /* EMRDELETECOLORSPACE */
995 }
996 
997 static void test_pack_EMRDELETEOBJECT(void)
998 {
999  /* EMRDELETEOBJECT */
1005  TEST_FIELD_SIZE (EMRDELETEOBJECT, ihObject, 4)
1006  TEST_FIELD_ALIGN (EMRDELETEOBJECT, ihObject, 4)
1007  TEST_FIELD_OFFSET(EMRDELETEOBJECT, ihObject, 8)
1008 }
1009 
1010 static void test_pack_EMRELLIPSE(void)
1011 {
1012  /* EMRELLIPSE */
1015  TEST_FIELD_SIZE (EMRELLIPSE, emr, 8)
1016  TEST_FIELD_ALIGN (EMRELLIPSE, emr, 4)
1017  TEST_FIELD_OFFSET(EMRELLIPSE, emr, 0)
1018  TEST_FIELD_SIZE (EMRELLIPSE, rclBox, 16)
1019  TEST_FIELD_ALIGN (EMRELLIPSE, rclBox, 4)
1020  TEST_FIELD_OFFSET(EMRELLIPSE, rclBox, 8)
1021 }
1022 
1023 static void test_pack_EMRENDPATH(void)
1024 {
1025  /* EMRENDPATH */
1028  TEST_FIELD_SIZE (EMRENDPATH, emr, 8)
1029  TEST_FIELD_ALIGN (EMRENDPATH, emr, 4)
1030  TEST_FIELD_OFFSET(EMRENDPATH, emr, 0)
1031 }
1032 
1033 static void test_pack_EMREOF(void)
1034 {
1035  /* EMREOF */
1036  TEST_TYPE_SIZE (EMREOF, 20)
1037  TEST_TYPE_ALIGN (EMREOF, 4)
1038  TEST_FIELD_SIZE (EMREOF, emr, 8)
1039  TEST_FIELD_ALIGN (EMREOF, emr, 4)
1040  TEST_FIELD_OFFSET(EMREOF, emr, 0)
1041  TEST_FIELD_SIZE (EMREOF, nPalEntries, 4)
1042  TEST_FIELD_ALIGN (EMREOF, nPalEntries, 4)
1043  TEST_FIELD_OFFSET(EMREOF, nPalEntries, 8)
1044  TEST_FIELD_SIZE (EMREOF, offPalEntries, 4)
1045  TEST_FIELD_ALIGN (EMREOF, offPalEntries, 4)
1046  TEST_FIELD_OFFSET(EMREOF, offPalEntries, 12)
1047  TEST_FIELD_SIZE (EMREOF, nSizeLast, 4)
1048  TEST_FIELD_ALIGN (EMREOF, nSizeLast, 4)
1049  TEST_FIELD_OFFSET(EMREOF, nSizeLast, 16)
1050 }
1051 
1052 static void test_pack_EMREXCLUDECLIPRECT(void)
1053 {
1054  /* EMREXCLUDECLIPRECT */
1060  TEST_FIELD_SIZE (EMREXCLUDECLIPRECT, rclClip, 16)
1061  TEST_FIELD_ALIGN (EMREXCLUDECLIPRECT, rclClip, 4)
1063 }
1064 
1065 static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
1066 {
1067  /* EMREXTCREATEFONTINDIRECTW */
1079 }
1080 
1081 static void test_pack_EMREXTCREATEPEN(void)
1082 {
1083  /* EMREXTCREATEPEN */
1089  TEST_FIELD_SIZE (EMREXTCREATEPEN, ihPen, 4)
1090  TEST_FIELD_ALIGN (EMREXTCREATEPEN, ihPen, 4)
1092  TEST_FIELD_SIZE (EMREXTCREATEPEN, offBmi, 4)
1093  TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBmi, 4)
1094  TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBmi, 12)
1095  TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBmi, 4)
1096  TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBmi, 4)
1098  TEST_FIELD_SIZE (EMREXTCREATEPEN, offBits, 4)
1099  TEST_FIELD_ALIGN (EMREXTCREATEPEN, offBits, 4)
1100  TEST_FIELD_OFFSET(EMREXTCREATEPEN, offBits, 20)
1101  TEST_FIELD_SIZE (EMREXTCREATEPEN, cbBits, 4)
1102  TEST_FIELD_ALIGN (EMREXTCREATEPEN, cbBits, 4)
1103  TEST_FIELD_OFFSET(EMREXTCREATEPEN, cbBits, 24)
1104  TEST_FIELD_SIZE (EMREXTCREATEPEN, elp, 32)
1107 }
1108 
1109 static void test_pack_EMREXTFLOODFILL(void)
1110 {
1111  /* EMREXTFLOODFILL */
1117  TEST_FIELD_SIZE (EMREXTFLOODFILL, ptlStart, 8)
1118  TEST_FIELD_ALIGN (EMREXTFLOODFILL, ptlStart, 4)
1119  TEST_FIELD_OFFSET(EMREXTFLOODFILL, ptlStart, 8)
1120  TEST_FIELD_SIZE (EMREXTFLOODFILL, crColor, 4)
1121  TEST_FIELD_ALIGN (EMREXTFLOODFILL, crColor, 4)
1122  TEST_FIELD_OFFSET(EMREXTFLOODFILL, crColor, 16)
1126 }
1127 
1128 static void test_pack_EMREXTSELECTCLIPRGN(void)
1129 {
1130  /* EMREXTSELECTCLIPRGN */
1136  TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1137  TEST_FIELD_ALIGN (EMREXTSELECTCLIPRGN, cbRgnData, 4)
1138  TEST_FIELD_OFFSET(EMREXTSELECTCLIPRGN, cbRgnData, 8)
1142  TEST_FIELD_SIZE (EMREXTSELECTCLIPRGN, RgnData, 1)
1145 }
1146 
1147 static void test_pack_EMREXTTEXTOUTA(void)
1148 {
1149  /* EMREXTTEXTOUTA */
1155  TEST_FIELD_SIZE (EMREXTTEXTOUTA, rclBounds, 16)
1156  TEST_FIELD_ALIGN (EMREXTTEXTOUTA, rclBounds, 4)
1157  TEST_FIELD_OFFSET(EMREXTTEXTOUTA, rclBounds, 8)
1158  TEST_FIELD_SIZE (EMREXTTEXTOUTA, iGraphicsMode, 4)
1159  TEST_FIELD_ALIGN (EMREXTTEXTOUTA, iGraphicsMode, 4)
1160  TEST_FIELD_OFFSET(EMREXTTEXTOUTA, iGraphicsMode, 24)
1161  TEST_FIELD_SIZE (EMREXTTEXTOUTA, exScale, 4)
1162  TEST_FIELD_ALIGN (EMREXTTEXTOUTA, exScale, 4)
1163  TEST_FIELD_OFFSET(EMREXTTEXTOUTA, exScale, 28)
1164  TEST_FIELD_SIZE (EMREXTTEXTOUTA, eyScale, 4)
1165  TEST_FIELD_ALIGN (EMREXTTEXTOUTA, eyScale, 4)
1166  TEST_FIELD_OFFSET(EMREXTTEXTOUTA, eyScale, 32)
1167  TEST_FIELD_SIZE (EMREXTTEXTOUTA, emrtext, 40)
1168  TEST_FIELD_ALIGN (EMREXTTEXTOUTA, emrtext, 4)
1169  TEST_FIELD_OFFSET(EMREXTTEXTOUTA, emrtext, 36)
1170 }
1171 
1172 static void test_pack_EMREXTTEXTOUTW(void)
1173 {
1174  /* EMREXTTEXTOUTW */
1180  TEST_FIELD_SIZE (EMREXTTEXTOUTW, rclBounds, 16)
1181  TEST_FIELD_ALIGN (EMREXTTEXTOUTW, rclBounds, 4)
1182  TEST_FIELD_OFFSET(EMREXTTEXTOUTW, rclBounds, 8)
1183  TEST_FIELD_SIZE (EMREXTTEXTOUTW, iGraphicsMode, 4)
1184  TEST_FIELD_ALIGN (EMREXTTEXTOUTW, iGraphicsMode, 4)
1185  TEST_FIELD_OFFSET(EMREXTTEXTOUTW, iGraphicsMode, 24)
1186  TEST_FIELD_SIZE (EMREXTTEXTOUTW, exScale, 4)
1187  TEST_FIELD_ALIGN (EMREXTTEXTOUTW, exScale, 4)
1188  TEST_FIELD_OFFSET(EMREXTTEXTOUTW, exScale, 28)
1189  TEST_FIELD_SIZE (EMREXTTEXTOUTW, eyScale, 4)
1190  TEST_FIELD_ALIGN (EMREXTTEXTOUTW, eyScale, 4)
1191  TEST_FIELD_OFFSET(EMREXTTEXTOUTW, eyScale, 32)
1192  TEST_FIELD_SIZE (EMREXTTEXTOUTW, emrtext, 40)
1193  TEST_FIELD_ALIGN (EMREXTTEXTOUTW, emrtext, 4)
1194  TEST_FIELD_OFFSET(EMREXTTEXTOUTW, emrtext, 36)
1195 }
1196 
1197 static void test_pack_EMRFILLPATH(void)
1198 {
1199  /* EMRFILLPATH */
1202  TEST_FIELD_SIZE (EMRFILLPATH, emr, 8)
1203  TEST_FIELD_ALIGN (EMRFILLPATH, emr, 4)
1205  TEST_FIELD_SIZE (EMRFILLPATH, rclBounds, 16)
1206  TEST_FIELD_ALIGN (EMRFILLPATH, rclBounds, 4)
1207  TEST_FIELD_OFFSET(EMRFILLPATH, rclBounds, 8)
1208 }
1209 
1210 static void test_pack_EMRFILLRGN(void)
1211 {
1212  /* EMRFILLRGN */
1215  TEST_FIELD_SIZE (EMRFILLRGN, emr, 8)
1216  TEST_FIELD_ALIGN (EMRFILLRGN, emr, 4)
1217  TEST_FIELD_OFFSET(EMRFILLRGN, emr, 0)
1218  TEST_FIELD_SIZE (EMRFILLRGN, rclBounds, 16)
1219  TEST_FIELD_ALIGN (EMRFILLRGN, rclBounds, 4)
1220  TEST_FIELD_OFFSET(EMRFILLRGN, rclBounds, 8)
1221  TEST_FIELD_SIZE (EMRFILLRGN, cbRgnData, 4)
1222  TEST_FIELD_ALIGN (EMRFILLRGN, cbRgnData, 4)
1223  TEST_FIELD_OFFSET(EMRFILLRGN, cbRgnData, 24)
1224  TEST_FIELD_SIZE (EMRFILLRGN, ihBrush, 4)
1225  TEST_FIELD_ALIGN (EMRFILLRGN, ihBrush, 4)
1226  TEST_FIELD_OFFSET(EMRFILLRGN, ihBrush, 28)
1227  TEST_FIELD_SIZE (EMRFILLRGN, RgnData, 1)
1228  TEST_FIELD_ALIGN (EMRFILLRGN, RgnData, 1)
1229  TEST_FIELD_OFFSET(EMRFILLRGN, RgnData, 32)
1230 }
1231 
1232 static void test_pack_EMRFLATTENPATH(void)
1233 {
1234  /* EMRFLATTENPATH */
1240 }
1241 
1242 static void test_pack_EMRFORMAT(void)
1243 {
1244  /* EMRFORMAT */
1247  TEST_FIELD_SIZE (EMRFORMAT, dSignature, 4)
1248  TEST_FIELD_ALIGN (EMRFORMAT, dSignature, 4)
1249  TEST_FIELD_OFFSET(EMRFORMAT, dSignature, 0)
1250  TEST_FIELD_SIZE (EMRFORMAT, nVersion, 4)
1251  TEST_FIELD_ALIGN (EMRFORMAT, nVersion, 4)
1252  TEST_FIELD_OFFSET(EMRFORMAT, nVersion, 4)
1253  TEST_FIELD_SIZE (EMRFORMAT, cbData, 4)
1254  TEST_FIELD_ALIGN (EMRFORMAT, cbData, 4)
1255  TEST_FIELD_OFFSET(EMRFORMAT, cbData, 8)
1256  TEST_FIELD_SIZE (EMRFORMAT, offData, 4)
1257  TEST_FIELD_ALIGN (EMRFORMAT, offData, 4)
1258  TEST_FIELD_OFFSET(EMRFORMAT, offData, 12)
1259 }
1260 
1261 static void test_pack_EMRFRAMERGN(void)
1262 {
1263  /* EMRFRAMERGN */
1266  TEST_FIELD_SIZE (EMRFRAMERGN, emr, 8)
1267  TEST_FIELD_ALIGN (EMRFRAMERGN, emr, 4)
1269  TEST_FIELD_SIZE (EMRFRAMERGN, rclBounds, 16)
1270  TEST_FIELD_ALIGN (EMRFRAMERGN, rclBounds, 4)
1271  TEST_FIELD_OFFSET(EMRFRAMERGN, rclBounds, 8)
1272  TEST_FIELD_SIZE (EMRFRAMERGN, cbRgnData, 4)
1273  TEST_FIELD_ALIGN (EMRFRAMERGN, cbRgnData, 4)
1274  TEST_FIELD_OFFSET(EMRFRAMERGN, cbRgnData, 24)
1275  TEST_FIELD_SIZE (EMRFRAMERGN, ihBrush, 4)
1276  TEST_FIELD_ALIGN (EMRFRAMERGN, ihBrush, 4)
1277  TEST_FIELD_OFFSET(EMRFRAMERGN, ihBrush, 28)
1278  TEST_FIELD_SIZE (EMRFRAMERGN, szlStroke, 8)
1279  TEST_FIELD_ALIGN (EMRFRAMERGN, szlStroke, 4)
1280  TEST_FIELD_OFFSET(EMRFRAMERGN, szlStroke, 32)
1281  TEST_FIELD_SIZE (EMRFRAMERGN, RgnData, 1)
1282  TEST_FIELD_ALIGN (EMRFRAMERGN, RgnData, 1)
1283  TEST_FIELD_OFFSET(EMRFRAMERGN, RgnData, 40)
1284 }
1285 
1286 static void test_pack_EMRGDICOMMENT(void)
1287 {
1288  /* EMRGDICOMMENT */
1291  TEST_FIELD_SIZE (EMRGDICOMMENT, emr, 8)
1294  TEST_FIELD_SIZE (EMRGDICOMMENT, cbData, 4)
1295  TEST_FIELD_ALIGN (EMRGDICOMMENT, cbData, 4)
1296  TEST_FIELD_OFFSET(EMRGDICOMMENT, cbData, 8)
1300 }
1301 
1302 static void test_pack_EMRGLSBOUNDEDRECORD(void)
1303 {
1304  /* EMRGLSBOUNDEDRECORD */
1305  TEST_TYPE_SIZE (EMRGLSBOUNDEDRECORD, 32)
1306  TEST_TYPE_ALIGN (EMRGLSBOUNDEDRECORD, 4)
1307  TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, emr, 8)
1308  TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, emr, 4)
1309  TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, emr, 0)
1310  TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, rclBounds, 16)
1311  TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, rclBounds, 4)
1312  TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, rclBounds, 8)
1313  TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, cbData, 4)
1314  TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, cbData, 4)
1315  TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, cbData, 24)
1316  TEST_FIELD_SIZE (EMRGLSBOUNDEDRECORD, Data, 1)
1317  TEST_FIELD_ALIGN (EMRGLSBOUNDEDRECORD, Data, 1)
1318  TEST_FIELD_OFFSET(EMRGLSBOUNDEDRECORD, Data, 28)
1319 }
1320 
1321 static void test_pack_EMRGLSRECORD(void)
1322 {
1323  /* EMRGLSRECORD */
1324  TEST_TYPE_SIZE (EMRGLSRECORD, 16)
1325  TEST_TYPE_ALIGN (EMRGLSRECORD, 4)
1326  TEST_FIELD_SIZE (EMRGLSRECORD, emr, 8)
1327  TEST_FIELD_ALIGN (EMRGLSRECORD, emr, 4)
1328  TEST_FIELD_OFFSET(EMRGLSRECORD, emr, 0)
1329  TEST_FIELD_SIZE (EMRGLSRECORD, cbData, 4)
1330  TEST_FIELD_ALIGN (EMRGLSRECORD, cbData, 4)
1331  TEST_FIELD_OFFSET(EMRGLSRECORD, cbData, 8)
1332  TEST_FIELD_SIZE (EMRGLSRECORD, Data, 1)
1333  TEST_FIELD_ALIGN (EMRGLSRECORD, Data, 1)
1334  TEST_FIELD_OFFSET(EMRGLSRECORD, Data, 12)
1335 }
1336 
1337 static void test_pack_EMRINTERSECTCLIPRECT(void)
1338 {
1339  /* EMRINTERSECTCLIPRECT */
1345  TEST_FIELD_SIZE (EMRINTERSECTCLIPRECT, rclClip, 16)
1348 }
1349 
1350 static void test_pack_EMRINVERTRGN(void)
1351 {
1352  /* EMRINVERTRGN */
1355  TEST_FIELD_SIZE (EMRINVERTRGN, emr, 8)
1356  TEST_FIELD_ALIGN (EMRINVERTRGN, emr, 4)
1358  TEST_FIELD_SIZE (EMRINVERTRGN, rclBounds, 16)
1359  TEST_FIELD_ALIGN (EMRINVERTRGN, rclBounds, 4)
1360  TEST_FIELD_OFFSET(EMRINVERTRGN, rclBounds, 8)
1361  TEST_FIELD_SIZE (EMRINVERTRGN, cbRgnData, 4)
1362  TEST_FIELD_ALIGN (EMRINVERTRGN, cbRgnData, 4)
1363  TEST_FIELD_OFFSET(EMRINVERTRGN, cbRgnData, 24)
1364  TEST_FIELD_SIZE (EMRINVERTRGN, RgnData, 1)
1365  TEST_FIELD_ALIGN (EMRINVERTRGN, RgnData, 1)
1366  TEST_FIELD_OFFSET(EMRINVERTRGN, RgnData, 28)
1367 }
1368 
1369 static void test_pack_EMRLINETO(void)
1370 {
1371  /* EMRLINETO */
1374  TEST_FIELD_SIZE (EMRLINETO, emr, 8)
1375  TEST_FIELD_ALIGN (EMRLINETO, emr, 4)
1376  TEST_FIELD_OFFSET(EMRLINETO, emr, 0)
1377  TEST_FIELD_SIZE (EMRLINETO, ptl, 8)
1378  TEST_FIELD_ALIGN (EMRLINETO, ptl, 4)
1379  TEST_FIELD_OFFSET(EMRLINETO, ptl, 8)
1380 }
1381 
1382 static void test_pack_EMRMASKBLT(void)
1383 {
1384  /* EMRMASKBLT */
1385  TEST_TYPE_SIZE (EMRMASKBLT, 128)
1387  TEST_FIELD_SIZE (EMRMASKBLT, emr, 8)
1388  TEST_FIELD_ALIGN (EMRMASKBLT, emr, 4)
1389  TEST_FIELD_OFFSET(EMRMASKBLT, emr, 0)
1390  TEST_FIELD_SIZE (EMRMASKBLT, rclBounds, 16)
1391  TEST_FIELD_ALIGN (EMRMASKBLT, rclBounds, 4)
1392  TEST_FIELD_OFFSET(EMRMASKBLT, rclBounds, 8)
1393  TEST_FIELD_SIZE (EMRMASKBLT, xDest, 4)
1394  TEST_FIELD_ALIGN (EMRMASKBLT, xDest, 4)
1395  TEST_FIELD_OFFSET(EMRMASKBLT, xDest, 24)
1396  TEST_FIELD_SIZE (EMRMASKBLT, yDest, 4)
1397  TEST_FIELD_ALIGN (EMRMASKBLT, yDest, 4)
1398  TEST_FIELD_OFFSET(EMRMASKBLT, yDest, 28)
1399  TEST_FIELD_SIZE (EMRMASKBLT, cxDest, 4)
1400  TEST_FIELD_ALIGN (EMRMASKBLT, cxDest, 4)
1401  TEST_FIELD_OFFSET(EMRMASKBLT, cxDest, 32)
1402  TEST_FIELD_SIZE (EMRMASKBLT, cyDest, 4)
1403  TEST_FIELD_ALIGN (EMRMASKBLT, cyDest, 4)
1404  TEST_FIELD_OFFSET(EMRMASKBLT, cyDest, 36)
1405  TEST_FIELD_SIZE (EMRMASKBLT, dwRop, 4)
1406  TEST_FIELD_ALIGN (EMRMASKBLT, dwRop, 4)
1407  TEST_FIELD_OFFSET(EMRMASKBLT, dwRop, 40)
1408  TEST_FIELD_SIZE (EMRMASKBLT, xSrc, 4)
1409  TEST_FIELD_ALIGN (EMRMASKBLT, xSrc, 4)
1410  TEST_FIELD_OFFSET(EMRMASKBLT, xSrc, 44)
1411  TEST_FIELD_SIZE (EMRMASKBLT, ySrc, 4)
1412  TEST_FIELD_ALIGN (EMRMASKBLT, ySrc, 4)
1413  TEST_FIELD_OFFSET(EMRMASKBLT, ySrc, 48)
1414  TEST_FIELD_SIZE (EMRMASKBLT, xformSrc, 24)
1415  TEST_FIELD_ALIGN (EMRMASKBLT, xformSrc, 4)
1416  TEST_FIELD_OFFSET(EMRMASKBLT, xformSrc, 52)
1417  TEST_FIELD_SIZE (EMRMASKBLT, crBkColorSrc, 4)
1418  TEST_FIELD_ALIGN (EMRMASKBLT, crBkColorSrc, 4)
1419  TEST_FIELD_OFFSET(EMRMASKBLT, crBkColorSrc, 76)
1420  TEST_FIELD_SIZE (EMRMASKBLT, iUsageSrc, 4)
1421  TEST_FIELD_ALIGN (EMRMASKBLT, iUsageSrc, 4)
1422  TEST_FIELD_OFFSET(EMRMASKBLT, iUsageSrc, 80)
1423  TEST_FIELD_SIZE (EMRMASKBLT, offBmiSrc, 4)
1424  TEST_FIELD_ALIGN (EMRMASKBLT, offBmiSrc, 4)
1425  TEST_FIELD_OFFSET(EMRMASKBLT, offBmiSrc, 84)
1426  TEST_FIELD_SIZE (EMRMASKBLT, cbBmiSrc, 4)
1427  TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiSrc, 4)
1428  TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiSrc, 88)
1429  TEST_FIELD_SIZE (EMRMASKBLT, offBitsSrc, 4)
1430  TEST_FIELD_ALIGN (EMRMASKBLT, offBitsSrc, 4)
1431  TEST_FIELD_OFFSET(EMRMASKBLT, offBitsSrc, 92)
1432  TEST_FIELD_SIZE (EMRMASKBLT, cbBitsSrc, 4)
1433  TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsSrc, 4)
1434  TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsSrc, 96)
1435  TEST_FIELD_SIZE (EMRMASKBLT, xMask, 4)
1436  TEST_FIELD_ALIGN (EMRMASKBLT, xMask, 4)
1437  TEST_FIELD_OFFSET(EMRMASKBLT, xMask, 100)
1438  TEST_FIELD_SIZE (EMRMASKBLT, yMask, 4)
1439  TEST_FIELD_ALIGN (EMRMASKBLT, yMask, 4)
1440  TEST_FIELD_OFFSET(EMRMASKBLT, yMask, 104)
1441  TEST_FIELD_SIZE (EMRMASKBLT, iUsageMask, 4)
1442  TEST_FIELD_ALIGN (EMRMASKBLT, iUsageMask, 4)
1443  TEST_FIELD_OFFSET(EMRMASKBLT, iUsageMask, 108)
1444  TEST_FIELD_SIZE (EMRMASKBLT, offBmiMask, 4)
1445  TEST_FIELD_ALIGN (EMRMASKBLT, offBmiMask, 4)
1446  TEST_FIELD_OFFSET(EMRMASKBLT, offBmiMask, 112)
1447  TEST_FIELD_SIZE (EMRMASKBLT, cbBmiMask, 4)
1448  TEST_FIELD_ALIGN (EMRMASKBLT, cbBmiMask, 4)
1449  TEST_FIELD_OFFSET(EMRMASKBLT, cbBmiMask, 116)
1450  TEST_FIELD_SIZE (EMRMASKBLT, offBitsMask, 4)
1451  TEST_FIELD_ALIGN (EMRMASKBLT, offBitsMask, 4)
1452  TEST_FIELD_OFFSET(EMRMASKBLT, offBitsMask, 120)
1453  TEST_FIELD_SIZE (EMRMASKBLT, cbBitsMask, 4)
1454  TEST_FIELD_ALIGN (EMRMASKBLT, cbBitsMask, 4)
1455  TEST_FIELD_OFFSET(EMRMASKBLT, cbBitsMask, 124)
1456 }
1457 
1458 static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
1459 {
1460  /* EMRMODIFYWORLDTRANSFORM */
1472 }
1473 
1474 static void test_pack_EMRMOVETOEX(void)
1475 {
1476  /* EMRMOVETOEX */
1479  TEST_FIELD_SIZE (EMRMOVETOEX, emr, 8)
1480  TEST_FIELD_ALIGN (EMRMOVETOEX, emr, 4)
1482  TEST_FIELD_SIZE (EMRMOVETOEX, ptl, 8)
1483  TEST_FIELD_ALIGN (EMRMOVETOEX, ptl, 4)
1485 }
1486 
1487 static void test_pack_EMROFFSETCLIPRGN(void)
1488 {
1489  /* EMROFFSETCLIPRGN */
1495  TEST_FIELD_SIZE (EMROFFSETCLIPRGN, ptlOffset, 8)
1496  TEST_FIELD_ALIGN (EMROFFSETCLIPRGN, ptlOffset, 4)
1497  TEST_FIELD_OFFSET(EMROFFSETCLIPRGN, ptlOffset, 8)
1498 }
1499 
1500 static void test_pack_EMRPAINTRGN(void)
1501 {
1502  /* EMRPAINTRGN */
1505  TEST_FIELD_SIZE (EMRPAINTRGN, emr, 8)
1506  TEST_FIELD_ALIGN (EMRPAINTRGN, emr, 4)
1508  TEST_FIELD_SIZE (EMRPAINTRGN, rclBounds, 16)
1509  TEST_FIELD_ALIGN (EMRPAINTRGN, rclBounds, 4)
1510  TEST_FIELD_OFFSET(EMRPAINTRGN, rclBounds, 8)
1511  TEST_FIELD_SIZE (EMRPAINTRGN, cbRgnData, 4)
1512  TEST_FIELD_ALIGN (EMRPAINTRGN, cbRgnData, 4)
1513  TEST_FIELD_OFFSET(EMRPAINTRGN, cbRgnData, 24)
1514  TEST_FIELD_SIZE (EMRPAINTRGN, RgnData, 1)
1515  TEST_FIELD_ALIGN (EMRPAINTRGN, RgnData, 1)
1516  TEST_FIELD_OFFSET(EMRPAINTRGN, RgnData, 28)
1517 }
1518 
1519 static void test_pack_EMRPIE(void)
1520 {
1521  /* EMRPIE */
1522  TEST_TYPE_SIZE (EMRPIE, 40)
1523  TEST_TYPE_ALIGN (EMRPIE, 4)
1524  TEST_FIELD_SIZE (EMRPIE, emr, 8)
1525  TEST_FIELD_ALIGN (EMRPIE, emr, 4)
1526  TEST_FIELD_OFFSET(EMRPIE, emr, 0)
1527  TEST_FIELD_SIZE (EMRPIE, rclBox, 16)
1528  TEST_FIELD_ALIGN (EMRPIE, rclBox, 4)
1529  TEST_FIELD_OFFSET(EMRPIE, rclBox, 8)
1530  TEST_FIELD_SIZE (EMRPIE, ptlStart, 8)
1531  TEST_FIELD_ALIGN (EMRPIE, ptlStart, 4)
1532  TEST_FIELD_OFFSET(EMRPIE, ptlStart, 24)
1533  TEST_FIELD_SIZE (EMRPIE, ptlEnd, 8)
1534  TEST_FIELD_ALIGN (EMRPIE, ptlEnd, 4)
1535  TEST_FIELD_OFFSET(EMRPIE, ptlEnd, 32)
1536 }
1537 
1538 static void test_pack_EMRPIXELFORMAT(void)
1539 {
1540  /* EMRPIXELFORMAT */
1549 }
1550 
1551 static void test_pack_EMRPLGBLT(void)
1552 {
1553  /* EMRPLGBLT */
1554  TEST_TYPE_SIZE (EMRPLGBLT, 140)
1556  TEST_FIELD_SIZE (EMRPLGBLT, emr, 8)
1557  TEST_FIELD_ALIGN (EMRPLGBLT, emr, 4)
1558  TEST_FIELD_OFFSET(EMRPLGBLT, emr, 0)
1559  TEST_FIELD_SIZE (EMRPLGBLT, rclBounds, 16)
1560  TEST_FIELD_ALIGN (EMRPLGBLT, rclBounds, 4)
1561  TEST_FIELD_OFFSET(EMRPLGBLT, rclBounds, 8)
1562  TEST_FIELD_SIZE (EMRPLGBLT, aptlDest, 24)
1563  TEST_FIELD_ALIGN (EMRPLGBLT, aptlDest, 4)
1564  TEST_FIELD_OFFSET(EMRPLGBLT, aptlDest, 24)
1565  TEST_FIELD_SIZE (EMRPLGBLT, xSrc, 4)
1566  TEST_FIELD_ALIGN (EMRPLGBLT, xSrc, 4)
1567  TEST_FIELD_OFFSET(EMRPLGBLT, xSrc, 48)
1568  TEST_FIELD_SIZE (EMRPLGBLT, ySrc, 4)
1569  TEST_FIELD_ALIGN (EMRPLGBLT, ySrc, 4)
1570  TEST_FIELD_OFFSET(EMRPLGBLT, ySrc, 52)
1571  TEST_FIELD_SIZE (EMRPLGBLT, cxSrc, 4)
1572  TEST_FIELD_ALIGN (EMRPLGBLT, cxSrc, 4)
1573  TEST_FIELD_OFFSET(EMRPLGBLT, cxSrc, 56)
1574  TEST_FIELD_SIZE (EMRPLGBLT, cySrc, 4)
1575  TEST_FIELD_ALIGN (EMRPLGBLT, cySrc, 4)
1576  TEST_FIELD_OFFSET(EMRPLGBLT, cySrc, 60)
1577  TEST_FIELD_SIZE (EMRPLGBLT, xformSrc, 24)
1578  TEST_FIELD_ALIGN (EMRPLGBLT, xformSrc, 4)
1579  TEST_FIELD_OFFSET(EMRPLGBLT, xformSrc, 64)
1580  TEST_FIELD_SIZE (EMRPLGBLT, crBkColorSrc, 4)
1581  TEST_FIELD_ALIGN (EMRPLGBLT, crBkColorSrc, 4)
1582  TEST_FIELD_OFFSET(EMRPLGBLT, crBkColorSrc, 88)
1583  TEST_FIELD_SIZE (EMRPLGBLT, iUsageSrc, 4)
1584  TEST_FIELD_ALIGN (EMRPLGBLT, iUsageSrc, 4)
1585  TEST_FIELD_OFFSET(EMRPLGBLT, iUsageSrc, 92)
1586  TEST_FIELD_SIZE (EMRPLGBLT, offBmiSrc, 4)
1587  TEST_FIELD_ALIGN (EMRPLGBLT, offBmiSrc, 4)
1588  TEST_FIELD_OFFSET(EMRPLGBLT, offBmiSrc, 96)
1589  TEST_FIELD_SIZE (EMRPLGBLT, cbBmiSrc, 4)
1590  TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiSrc, 4)
1591  TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiSrc, 100)
1592  TEST_FIELD_SIZE (EMRPLGBLT, offBitsSrc, 4)
1593  TEST_FIELD_ALIGN (EMRPLGBLT, offBitsSrc, 4)
1594  TEST_FIELD_OFFSET(EMRPLGBLT, offBitsSrc, 104)
1595  TEST_FIELD_SIZE (EMRPLGBLT, cbBitsSrc, 4)
1596  TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsSrc, 4)
1597  TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsSrc, 108)
1598  TEST_FIELD_SIZE (EMRPLGBLT, xMask, 4)
1599  TEST_FIELD_ALIGN (EMRPLGBLT, xMask, 4)
1600  TEST_FIELD_OFFSET(EMRPLGBLT, xMask, 112)
1601  TEST_FIELD_SIZE (EMRPLGBLT, yMask, 4)
1602  TEST_FIELD_ALIGN (EMRPLGBLT, yMask, 4)
1603  TEST_FIELD_OFFSET(EMRPLGBLT, yMask, 116)
1604  TEST_FIELD_SIZE (EMRPLGBLT, iUsageMask, 4)
1605  TEST_FIELD_ALIGN (EMRPLGBLT, iUsageMask, 4)
1606  TEST_FIELD_OFFSET(EMRPLGBLT, iUsageMask, 120)
1607  TEST_FIELD_SIZE (EMRPLGBLT, offBmiMask, 4)
1608  TEST_FIELD_ALIGN (EMRPLGBLT, offBmiMask, 4)
1609  TEST_FIELD_OFFSET(EMRPLGBLT, offBmiMask, 124)
1610  TEST_FIELD_SIZE (EMRPLGBLT, cbBmiMask, 4)
1611  TEST_FIELD_ALIGN (EMRPLGBLT, cbBmiMask, 4)
1612  TEST_FIELD_OFFSET(EMRPLGBLT, cbBmiMask, 128)
1613  TEST_FIELD_SIZE (EMRPLGBLT, offBitsMask, 4)
1614  TEST_FIELD_ALIGN (EMRPLGBLT, offBitsMask, 4)
1615  TEST_FIELD_OFFSET(EMRPLGBLT, offBitsMask, 132)
1616  TEST_FIELD_SIZE (EMRPLGBLT, cbBitsMask, 4)
1617  TEST_FIELD_ALIGN (EMRPLGBLT, cbBitsMask, 4)
1618  TEST_FIELD_OFFSET(EMRPLGBLT, cbBitsMask, 136)
1619 }
1620 
1621 static void test_pack_EMRPOLYBEZIER(void)
1622 {
1623  /* EMRPOLYBEZIER */
1626  TEST_FIELD_SIZE (EMRPOLYBEZIER, emr, 8)
1629  TEST_FIELD_SIZE (EMRPOLYBEZIER, rclBounds, 16)
1630  TEST_FIELD_ALIGN (EMRPOLYBEZIER, rclBounds, 4)
1631  TEST_FIELD_OFFSET(EMRPOLYBEZIER, rclBounds, 8)
1632  TEST_FIELD_SIZE (EMRPOLYBEZIER, cptl, 4)
1633  TEST_FIELD_ALIGN (EMRPOLYBEZIER, cptl, 4)
1634  TEST_FIELD_OFFSET(EMRPOLYBEZIER, cptl, 24)
1635  TEST_FIELD_SIZE (EMRPOLYBEZIER, aptl, 8)
1636  TEST_FIELD_ALIGN (EMRPOLYBEZIER, aptl, 4)
1637  TEST_FIELD_OFFSET(EMRPOLYBEZIER, aptl, 28)
1638 }
1639 
1640 static void test_pack_EMRPOLYBEZIER16(void)
1641 {
1642  /* EMRPOLYBEZIER16 */
1648  TEST_FIELD_SIZE (EMRPOLYBEZIER16, rclBounds, 16)
1649  TEST_FIELD_ALIGN (EMRPOLYBEZIER16, rclBounds, 4)
1650  TEST_FIELD_OFFSET(EMRPOLYBEZIER16, rclBounds, 8)
1651  TEST_FIELD_SIZE (EMRPOLYBEZIER16, cpts, 4)
1657 }
1658 
1659 static void test_pack_EMRPOLYBEZIERTO(void)
1660 {
1661  /* EMRPOLYBEZIERTO */
1667  TEST_FIELD_SIZE (EMRPOLYBEZIERTO, rclBounds, 16)
1668  TEST_FIELD_ALIGN (EMRPOLYBEZIERTO, rclBounds, 4)
1669  TEST_FIELD_OFFSET(EMRPOLYBEZIERTO, rclBounds, 8)
1670  TEST_FIELD_SIZE (EMRPOLYBEZIERTO, cptl, 4)
1673  TEST_FIELD_SIZE (EMRPOLYBEZIERTO, aptl, 8)
1676 }
1677 
1678 static void test_pack_EMRPOLYBEZIERTO16(void)
1679 {
1680  /* EMRPOLYBEZIERTO16 */
1686  TEST_FIELD_SIZE (EMRPOLYBEZIERTO16, rclBounds, 16)
1687  TEST_FIELD_ALIGN (EMRPOLYBEZIERTO16, rclBounds, 4)
1688  TEST_FIELD_OFFSET(EMRPOLYBEZIERTO16, rclBounds, 8)
1695 }
1696 
1697 static void test_pack_EMRPOLYDRAW(void)
1698 {
1699  /* EMRPOLYDRAW */
1702  TEST_FIELD_SIZE (EMRPOLYDRAW, emr, 8)
1703  TEST_FIELD_ALIGN (EMRPOLYDRAW, emr, 4)
1705  TEST_FIELD_SIZE (EMRPOLYDRAW, rclBounds, 16)
1706  TEST_FIELD_ALIGN (EMRPOLYDRAW, rclBounds, 4)
1707  TEST_FIELD_OFFSET(EMRPOLYDRAW, rclBounds, 8)
1708  TEST_FIELD_SIZE (EMRPOLYDRAW, cptl, 4)
1709  TEST_FIELD_ALIGN (EMRPOLYDRAW, cptl, 4)
1710  TEST_FIELD_OFFSET(EMRPOLYDRAW, cptl, 24)
1711  TEST_FIELD_SIZE (EMRPOLYDRAW, aptl, 8)
1712  TEST_FIELD_ALIGN (EMRPOLYDRAW, aptl, 4)
1713  TEST_FIELD_OFFSET(EMRPOLYDRAW, aptl, 28)
1714  TEST_FIELD_SIZE (EMRPOLYDRAW, abTypes, 1)
1715  TEST_FIELD_ALIGN (EMRPOLYDRAW, abTypes, 1)
1716  TEST_FIELD_OFFSET(EMRPOLYDRAW, abTypes, 36)
1717 }
1718 
1719 static void test_pack_EMRPOLYDRAW16(void)
1720 {
1721  /* EMRPOLYDRAW16 */
1724  TEST_FIELD_SIZE (EMRPOLYDRAW16, emr, 8)
1727  TEST_FIELD_SIZE (EMRPOLYDRAW16, rclBounds, 16)
1728  TEST_FIELD_ALIGN (EMRPOLYDRAW16, rclBounds, 4)
1729  TEST_FIELD_OFFSET(EMRPOLYDRAW16, rclBounds, 8)
1730  TEST_FIELD_SIZE (EMRPOLYDRAW16, cpts, 4)
1731  TEST_FIELD_ALIGN (EMRPOLYDRAW16, cpts, 4)
1732  TEST_FIELD_OFFSET(EMRPOLYDRAW16, cpts, 24)
1736  TEST_FIELD_SIZE (EMRPOLYDRAW16, abTypes, 1)
1737  TEST_FIELD_ALIGN (EMRPOLYDRAW16, abTypes, 1)
1738  TEST_FIELD_OFFSET(EMRPOLYDRAW16, abTypes, 32)
1739 }
1740 
1741 static void test_pack_EMRPOLYGON(void)
1742 {
1743  /* EMRPOLYGON */
1746  TEST_FIELD_SIZE (EMRPOLYGON, emr, 8)
1747  TEST_FIELD_ALIGN (EMRPOLYGON, emr, 4)
1748  TEST_FIELD_OFFSET(EMRPOLYGON, emr, 0)
1749  TEST_FIELD_SIZE (EMRPOLYGON, rclBounds, 16)
1750  TEST_FIELD_ALIGN (EMRPOLYGON, rclBounds, 4)
1751  TEST_FIELD_OFFSET(EMRPOLYGON, rclBounds, 8)
1752  TEST_FIELD_SIZE (EMRPOLYGON, cptl, 4)
1753  TEST_FIELD_ALIGN (EMRPOLYGON, cptl, 4)
1754  TEST_FIELD_OFFSET(EMRPOLYGON, cptl, 24)
1755  TEST_FIELD_SIZE (EMRPOLYGON, aptl, 8)
1756  TEST_FIELD_ALIGN (EMRPOLYGON, aptl, 4)
1757  TEST_FIELD_OFFSET(EMRPOLYGON, aptl, 28)
1758 }
1759 
1760 static void test_pack_EMRPOLYGON16(void)
1761 {
1762  /* EMRPOLYGON16 */
1765  TEST_FIELD_SIZE (EMRPOLYGON16, emr, 8)
1766  TEST_FIELD_ALIGN (EMRPOLYGON16, emr, 4)
1768  TEST_FIELD_SIZE (EMRPOLYGON16, rclBounds, 16)
1769  TEST_FIELD_ALIGN (EMRPOLYGON16, rclBounds, 4)
1770  TEST_FIELD_OFFSET(EMRPOLYGON16, rclBounds, 8)
1771  TEST_FIELD_SIZE (EMRPOLYGON16, cpts, 4)
1772  TEST_FIELD_ALIGN (EMRPOLYGON16, cpts, 4)
1773  TEST_FIELD_OFFSET(EMRPOLYGON16, cpts, 24)
1777 }
1778 
1779 static void test_pack_EMRPOLYLINE(void)
1780 {
1781  /* EMRPOLYLINE */
1784  TEST_FIELD_SIZE (EMRPOLYLINE, emr, 8)
1785  TEST_FIELD_ALIGN (EMRPOLYLINE, emr, 4)
1787  TEST_FIELD_SIZE (EMRPOLYLINE, rclBounds, 16)
1788  TEST_FIELD_ALIGN (EMRPOLYLINE, rclBounds, 4)
1789  TEST_FIELD_OFFSET(EMRPOLYLINE, rclBounds, 8)
1790  TEST_FIELD_SIZE (EMRPOLYLINE, cptl, 4)
1791  TEST_FIELD_ALIGN (EMRPOLYLINE, cptl, 4)
1792  TEST_FIELD_OFFSET(EMRPOLYLINE, cptl, 24)
1793  TEST_FIELD_SIZE (EMRPOLYLINE, aptl, 8)
1794  TEST_FIELD_ALIGN (EMRPOLYLINE, aptl, 4)
1795  TEST_FIELD_OFFSET(EMRPOLYLINE, aptl, 28)
1796 }
1797 
1798 static void test_pack_EMRPOLYLINE16(void)
1799 {
1800  /* EMRPOLYLINE16 */
1803  TEST_FIELD_SIZE (EMRPOLYLINE16, emr, 8)
1806  TEST_FIELD_SIZE (EMRPOLYLINE16, rclBounds, 16)
1807  TEST_FIELD_ALIGN (EMRPOLYLINE16, rclBounds, 4)
1808  TEST_FIELD_OFFSET(EMRPOLYLINE16, rclBounds, 8)
1809  TEST_FIELD_SIZE (EMRPOLYLINE16, cpts, 4)
1810  TEST_FIELD_ALIGN (EMRPOLYLINE16, cpts, 4)
1811  TEST_FIELD_OFFSET(EMRPOLYLINE16, cpts, 24)
1815 }
1816 
1817 static void test_pack_EMRPOLYLINETO(void)
1818 {
1819  /* EMRPOLYLINETO */
1822  TEST_FIELD_SIZE (EMRPOLYLINETO, emr, 8)
1825  TEST_FIELD_SIZE (EMRPOLYLINETO, rclBounds, 16)
1826  TEST_FIELD_ALIGN (EMRPOLYLINETO, rclBounds, 4)
1827  TEST_FIELD_OFFSET(EMRPOLYLINETO, rclBounds, 8)
1828  TEST_FIELD_SIZE (EMRPOLYLINETO, cptl, 4)
1829  TEST_FIELD_ALIGN (EMRPOLYLINETO, cptl, 4)
1830  TEST_FIELD_OFFSET(EMRPOLYLINETO, cptl, 24)
1831  TEST_FIELD_SIZE (EMRPOLYLINETO, aptl, 8)
1832  TEST_FIELD_ALIGN (EMRPOLYLINETO, aptl, 4)
1833  TEST_FIELD_OFFSET(EMRPOLYLINETO, aptl, 28)
1834 }
1835 
1836 static void test_pack_EMRPOLYLINETO16(void)
1837 {
1838  /* EMRPOLYLINETO16 */
1844  TEST_FIELD_SIZE (EMRPOLYLINETO16, rclBounds, 16)
1845  TEST_FIELD_ALIGN (EMRPOLYLINETO16, rclBounds, 4)
1846  TEST_FIELD_OFFSET(EMRPOLYLINETO16, rclBounds, 8)
1847  TEST_FIELD_SIZE (EMRPOLYLINETO16, cpts, 4)
1853 }
1854 
1855 static void test_pack_EMRPOLYPOLYGON(void)
1856 {
1857  /* EMRPOLYPOLYGON */
1863  TEST_FIELD_SIZE (EMRPOLYPOLYGON, rclBounds, 16)
1864  TEST_FIELD_ALIGN (EMRPOLYPOLYGON, rclBounds, 4)
1865  TEST_FIELD_OFFSET(EMRPOLYPOLYGON, rclBounds, 8)
1866  TEST_FIELD_SIZE (EMRPOLYPOLYGON, nPolys, 4)
1867  TEST_FIELD_ALIGN (EMRPOLYPOLYGON, nPolys, 4)
1868  TEST_FIELD_OFFSET(EMRPOLYPOLYGON, nPolys, 24)
1869  TEST_FIELD_SIZE (EMRPOLYPOLYGON, cptl, 4)
1870  TEST_FIELD_ALIGN (EMRPOLYPOLYGON, cptl, 4)
1872  TEST_FIELD_SIZE (EMRPOLYPOLYGON, aPolyCounts, 4)
1873  TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aPolyCounts, 4)
1874  TEST_FIELD_OFFSET(EMRPOLYPOLYGON, aPolyCounts, 32)
1875  TEST_FIELD_SIZE (EMRPOLYPOLYGON, aptl, 8)
1876  TEST_FIELD_ALIGN (EMRPOLYPOLYGON, aptl, 4)
1878 }
1879 
1880 static void test_pack_EMRPOLYPOLYGON16(void)
1881 {
1882  /* EMRPOLYPOLYGON16 */
1888  TEST_FIELD_SIZE (EMRPOLYPOLYGON16, rclBounds, 16)
1889  TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, rclBounds, 4)
1890  TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, rclBounds, 8)
1891  TEST_FIELD_SIZE (EMRPOLYPOLYGON16, nPolys, 4)
1892  TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, nPolys, 4)
1893  TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, nPolys, 24)
1897  TEST_FIELD_SIZE (EMRPOLYPOLYGON16, aPolyCounts, 4)
1898  TEST_FIELD_ALIGN (EMRPOLYPOLYGON16, aPolyCounts, 4)
1899  TEST_FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts, 32)
1903 }
1904 
1905 static void test_pack_EMRPOLYPOLYLINE(void)
1906 {
1907  /* EMRPOLYPOLYLINE */
1913  TEST_FIELD_SIZE (EMRPOLYPOLYLINE, rclBounds, 16)
1914  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, rclBounds, 4)
1915  TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, rclBounds, 8)
1916  TEST_FIELD_SIZE (EMRPOLYPOLYLINE, nPolys, 4)
1917  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, nPolys, 4)
1918  TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, nPolys, 24)
1919  TEST_FIELD_SIZE (EMRPOLYPOLYLINE, cptl, 4)
1922  TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aPolyCounts, 4)
1923  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE, aPolyCounts, 4)
1924  TEST_FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts, 32)
1925  TEST_FIELD_SIZE (EMRPOLYPOLYLINE, aptl, 8)
1928 }
1929 
1930 static void test_pack_EMRPOLYPOLYLINE16(void)
1931 {
1932  /* EMRPOLYPOLYLINE16 */
1938  TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, rclBounds, 16)
1939  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, rclBounds, 4)
1940  TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, rclBounds, 8)
1941  TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, nPolys, 4)
1942  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, nPolys, 4)
1947  TEST_FIELD_SIZE (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1948  TEST_FIELD_ALIGN (EMRPOLYPOLYLINE16, aPolyCounts, 4)
1949  TEST_FIELD_OFFSET(EMRPOLYPOLYLINE16, aPolyCounts, 32)
1953 }
1954 
1955 static void test_pack_EMRPOLYTEXTOUTA(void)
1956 {
1957  /* EMRPOLYTEXTOUTA */
1963  TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, rclBounds, 16)
1964  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, rclBounds, 4)
1965  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, rclBounds, 8)
1966  TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, iGraphicsMode, 4)
1967  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, iGraphicsMode, 4)
1968  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, iGraphicsMode, 24)
1969  TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, exScale, 4)
1970  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, exScale, 4)
1971  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, exScale, 28)
1972  TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, eyScale, 4)
1973  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, eyScale, 4)
1974  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, eyScale, 32)
1975  TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, cStrings, 4)
1976  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, cStrings, 4)
1977  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, cStrings, 36)
1978  TEST_FIELD_SIZE (EMRPOLYTEXTOUTA, aemrtext, 40)
1979  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTA, aemrtext, 4)
1980  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTA, aemrtext, 40)
1981 }
1982 
1983 static void test_pack_EMRPOLYTEXTOUTW(void)
1984 {
1985  /* EMRPOLYTEXTOUTW */
1991  TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, rclBounds, 16)
1992  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, rclBounds, 4)
1993  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, rclBounds, 8)
1994  TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, iGraphicsMode, 4)
1995  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, iGraphicsMode, 4)
1996  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, iGraphicsMode, 24)
1997  TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, exScale, 4)
1998  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, exScale, 4)
1999  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, exScale, 28)
2000  TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, eyScale, 4)
2001  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, eyScale, 4)
2002  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, eyScale, 32)
2003  TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, cStrings, 4)
2004  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, cStrings, 4)
2005  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, cStrings, 36)
2006  TEST_FIELD_SIZE (EMRPOLYTEXTOUTW, aemrtext, 40)
2007  TEST_FIELD_ALIGN (EMRPOLYTEXTOUTW, aemrtext, 4)
2008  TEST_FIELD_OFFSET(EMRPOLYTEXTOUTW, aemrtext, 40)
2009 }
2010 
2011 static void test_pack_EMRREALIZEPALETTE(void)
2012 {
2013  /* EMRREALIZEPALETTE */
2019 }
2020 
2021 static void test_pack_EMRRECTANGLE(void)
2022 {
2023  /* EMRRECTANGLE */
2026  TEST_FIELD_SIZE (EMRRECTANGLE, emr, 8)
2027  TEST_FIELD_ALIGN (EMRRECTANGLE, emr, 4)
2029  TEST_FIELD_SIZE (EMRRECTANGLE, rclBox, 16)
2030  TEST_FIELD_ALIGN (EMRRECTANGLE, rclBox, 4)
2031  TEST_FIELD_OFFSET(EMRRECTANGLE, rclBox, 8)
2032 }
2033 
2034 static void test_pack_EMRRESIZEPALETTE(void)
2035 {
2036  /* EMRRESIZEPALETTE */
2042  TEST_FIELD_SIZE (EMRRESIZEPALETTE, ihPal, 4)
2048 }
2049 
2050 static void test_pack_EMRRESTOREDC(void)
2051 {
2052  /* EMRRESTOREDC */
2055  TEST_FIELD_SIZE (EMRRESTOREDC, emr, 8)
2056  TEST_FIELD_ALIGN (EMRRESTOREDC, emr, 4)
2058  TEST_FIELD_SIZE (EMRRESTOREDC, iRelative, 4)
2059  TEST_FIELD_ALIGN (EMRRESTOREDC, iRelative, 4)
2060  TEST_FIELD_OFFSET(EMRRESTOREDC, iRelative, 8)
2061 }
2062 
2063 static void test_pack_EMRROUNDRECT(void)
2064 {
2065  /* EMRROUNDRECT */
2068  TEST_FIELD_SIZE (EMRROUNDRECT, emr, 8)
2069  TEST_FIELD_ALIGN (EMRROUNDRECT, emr, 4)
2071  TEST_FIELD_SIZE (EMRROUNDRECT, rclBox, 16)
2072  TEST_FIELD_ALIGN (EMRROUNDRECT, rclBox, 4)
2073  TEST_FIELD_OFFSET(EMRROUNDRECT, rclBox, 8)
2074  TEST_FIELD_SIZE (EMRROUNDRECT, szlCorner, 8)
2075  TEST_FIELD_ALIGN (EMRROUNDRECT, szlCorner, 4)
2076  TEST_FIELD_OFFSET(EMRROUNDRECT, szlCorner, 24)
2077 }
2078 
2079 static void test_pack_EMRSAVEDC(void)
2080 {
2081  /* EMRSAVEDC */
2084  TEST_FIELD_SIZE (EMRSAVEDC, emr, 8)
2085  TEST_FIELD_ALIGN (EMRSAVEDC, emr, 4)
2086  TEST_FIELD_OFFSET(EMRSAVEDC, emr, 0)
2087 }
2088 
2089 static void test_pack_EMRSCALEVIEWPORTEXTEX(void)
2090 {
2091  /* EMRSCALEVIEWPORTEXTEX */
2109 }
2110 
2111 static void test_pack_EMRSCALEWINDOWEXTEX(void)
2112 {
2113  /* EMRSCALEWINDOWEXTEX */
2131 }
2132 
2133 static void test_pack_EMRSELECTCLIPPATH(void)
2134 {
2135  /* EMRSELECTCLIPPATH */
2144 }
2145 
2146 static void test_pack_EMRSELECTCOLORSPACE(void)
2147 {
2148  /* EMRSELECTCOLORSPACE */
2157 }
2158 
2159 static void test_pack_EMRSELECTOBJECT(void)
2160 {
2161  /* EMRSELECTOBJECT */
2167  TEST_FIELD_SIZE (EMRSELECTOBJECT, ihObject, 4)
2168  TEST_FIELD_ALIGN (EMRSELECTOBJECT, ihObject, 4)
2169  TEST_FIELD_OFFSET(EMRSELECTOBJECT, ihObject, 8)
2170 }
2171 
2172 static void test_pack_EMRSELECTPALETTE(void)
2173 {
2174  /* EMRSELECTPALETTE */
2180  TEST_FIELD_SIZE (EMRSELECTPALETTE, ihPal, 4)
2183 }
2184 
2185 static void test_pack_EMRSETARCDIRECTION(void)
2186 {
2187  /* EMRSETARCDIRECTION */
2193  TEST_FIELD_SIZE (EMRSETARCDIRECTION, iArcDirection, 4)
2194  TEST_FIELD_ALIGN (EMRSETARCDIRECTION, iArcDirection, 4)
2195  TEST_FIELD_OFFSET(EMRSETARCDIRECTION, iArcDirection, 8)
2196 }
2197 
2198 static void test_pack_EMRSETBKCOLOR(void)
2199 {
2200  /* EMRSETBKCOLOR */
2203  TEST_FIELD_SIZE (EMRSETBKCOLOR, emr, 8)
2206  TEST_FIELD_SIZE (EMRSETBKCOLOR, crColor, 4)
2207  TEST_FIELD_ALIGN (EMRSETBKCOLOR, crColor, 4)
2208  TEST_FIELD_OFFSET(EMRSETBKCOLOR, crColor, 8)
2209 }
2210 
2211 static void test_pack_EMRSETBKMODE(void)
2212 {
2213  /* EMRSETBKMODE */
2216  TEST_FIELD_SIZE (EMRSETBKMODE, emr, 8)
2217  TEST_FIELD_ALIGN (EMRSETBKMODE, emr, 4)
2222 }
2223 
2224 static void test_pack_EMRSETBRUSHORGEX(void)
2225 {
2226  /* EMRSETBRUSHORGEX */
2232  TEST_FIELD_SIZE (EMRSETBRUSHORGEX, ptlOrigin, 8)
2233  TEST_FIELD_ALIGN (EMRSETBRUSHORGEX, ptlOrigin, 4)
2234  TEST_FIELD_OFFSET(EMRSETBRUSHORGEX, ptlOrigin, 8)
2235 }
2236 
2237 static void test_pack_EMRSETCOLORADJUSTMENT(void)
2238 {
2239  /* EMRSETCOLORADJUSTMENT */
2245  TEST_FIELD_SIZE (EMRSETCOLORADJUSTMENT, ColorAdjustment, 24)
2246  TEST_FIELD_ALIGN (EMRSETCOLORADJUSTMENT, ColorAdjustment, 2)
2247  TEST_FIELD_OFFSET(EMRSETCOLORADJUSTMENT, ColorAdjustment, 8)
2248 }
2249 
2250 static void test_pack_EMRSETCOLORSPACE(void)
2251 {
2252  /* EMRSETCOLORSPACE */
2261 }
2262 
2263 static void test_pack_EMRSETDIBITSTODEVICE(void)
2264 {
2265  /* EMRSETDIBITSTODEVICE */
2271  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, rclBounds, 16)
2272  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, rclBounds, 4)
2292  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBmiSrc, 4)
2293  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBmiSrc, 4)
2294  TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBmiSrc, 48)
2295  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBmiSrc, 4)
2296  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBmiSrc, 4)
2298  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, offBitsSrc, 4)
2299  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, offBitsSrc, 4)
2300  TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, offBitsSrc, 56)
2301  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, cbBitsSrc, 4)
2302  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, cbBitsSrc, 4)
2303  TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, cbBitsSrc, 60)
2304  TEST_FIELD_SIZE (EMRSETDIBITSTODEVICE, iUsageSrc, 4)
2305  TEST_FIELD_ALIGN (EMRSETDIBITSTODEVICE, iUsageSrc, 4)
2306  TEST_FIELD_OFFSET(EMRSETDIBITSTODEVICE, iUsageSrc, 64)
2313 }
2314 
2315 static void test_pack_EMRSETICMMODE(void)
2316 {
2317  /* EMRSETICMMODE */
2320  TEST_FIELD_SIZE (EMRSETICMMODE, emr, 8)
2326 }
2327 
2328 static void test_pack_EMRSETLAYOUT(void)
2329 {
2330  /* EMRSETLAYOUT */
2331  TEST_TYPE_SIZE (EMRSETLAYOUT, 12)
2332  TEST_TYPE_ALIGN (EMRSETLAYOUT, 4)
2333  TEST_FIELD_SIZE (EMRSETLAYOUT, emr, 8)
2334  TEST_FIELD_ALIGN (EMRSETLAYOUT, emr, 4)
2335  TEST_FIELD_OFFSET(EMRSETLAYOUT, emr, 0)
2336  TEST_FIELD_SIZE (EMRSETLAYOUT, iMode, 4)
2337  TEST_FIELD_ALIGN (EMRSETLAYOUT, iMode, 4)
2338  TEST_FIELD_OFFSET(EMRSETLAYOUT, iMode, 8)
2339 }
2340 
2341 static void test_pack_EMRSETMAPMODE(void)
2342 {
2343  /* EMRSETMAPMODE */
2346  TEST_FIELD_SIZE (EMRSETMAPMODE, emr, 8)
2352 }
2353 
2354 static void test_pack_EMRSETMAPPERFLAGS(void)
2355 {
2356  /* EMRSETMAPPERFLAGS */
2365 }
2366 
2367 static void test_pack_EMRSETMETARGN(void)
2368 {
2369  /* EMRSETMETARGN */
2372  TEST_FIELD_SIZE (EMRSETMETARGN, emr, 8)
2375 }
2376 
2377 static void test_pack_EMRSETMITERLIMIT(void)
2378 {
2379  /* EMRSETMITERLIMIT */
2385  TEST_FIELD_SIZE (EMRSETMITERLIMIT, eMiterLimit, 4)
2386  TEST_FIELD_ALIGN (EMRSETMITERLIMIT, eMiterLimit, 4)
2387  TEST_FIELD_OFFSET(EMRSETMITERLIMIT, eMiterLimit, 8)
2388 }
2389 
2390 static void test_pack_EMRSETPIXELV(void)
2391 {
2392  /* EMRSETPIXELV */
2395  TEST_FIELD_SIZE (EMRSETPIXELV, emr, 8)
2396  TEST_FIELD_ALIGN (EMRSETPIXELV, emr, 4)
2398  TEST_FIELD_SIZE (EMRSETPIXELV, ptlPixel, 8)
2399  TEST_FIELD_ALIGN (EMRSETPIXELV, ptlPixel, 4)
2400  TEST_FIELD_OFFSET(EMRSETPIXELV, ptlPixel, 8)
2401  TEST_FIELD_SIZE (EMRSETPIXELV, crColor, 4)
2402  TEST_FIELD_ALIGN (EMRSETPIXELV, crColor, 4)
2403  TEST_FIELD_OFFSET(EMRSETPIXELV, crColor, 16)
2404 }
2405 
2406 static void test_pack_EMRSETPOLYFILLMODE(void)
2407 {
2408  /* EMRSETPOLYFILLMODE */
2417 }
2418 
2419 static void test_pack_EMRSETROP2(void)
2420 {
2421  /* EMRSETROP2 */
2424  TEST_FIELD_SIZE (EMRSETROP2, emr, 8)
2425  TEST_FIELD_ALIGN (EMRSETROP2, emr, 4)
2426  TEST_FIELD_OFFSET(EMRSETROP2, emr, 0)
2430 }
2431 
2432 static void test_pack_EMRSETSTRETCHBLTMODE(void)
2433 {
2434  /* EMRSETSTRETCHBLTMODE */
2443 }
2444 
2445 static void test_pack_EMRSETTEXTALIGN(void)
2446 {
2447  /* EMRSETTEXTALIGN */
2456 }
2457 
2458 static void test_pack_EMRSETTEXTCOLOR(void)
2459 {
2460  /* EMRSETTEXTCOLOR */
2466  TEST_FIELD_SIZE (EMRSETTEXTCOLOR, crColor, 4)
2467  TEST_FIELD_ALIGN (EMRSETTEXTCOLOR, crColor, 4)
2468  TEST_FIELD_OFFSET(EMRSETTEXTCOLOR, crColor, 8)
2469 }
2470 
2471 static void test_pack_EMRSETVIEWPORTEXTEX(void)
2472 {
2473  /* EMRSETVIEWPORTEXTEX */
2479  TEST_FIELD_SIZE (EMRSETVIEWPORTEXTEX, szlExtent, 8)
2480  TEST_FIELD_ALIGN (EMRSETVIEWPORTEXTEX, szlExtent, 4)
2481  TEST_FIELD_OFFSET(EMRSETVIEWPORTEXTEX, szlExtent, 8)
2482 }
2483 
2484 static void test_pack_EMRSETVIEWPORTORGEX(void)
2485 {
2486  /* EMRSETVIEWPORTORGEX */
2492  TEST_FIELD_SIZE (EMRSETVIEWPORTORGEX, ptlOrigin, 8)
2493  TEST_FIELD_ALIGN (EMRSETVIEWPORTORGEX, ptlOrigin, 4)
2494  TEST_FIELD_OFFSET(EMRSETVIEWPORTORGEX, ptlOrigin, 8)
2495 }
2496 
2497 static void test_pack_EMRSETWINDOWEXTEX(void)
2498 {
2499  /* EMRSETWINDOWEXTEX */
2505  TEST_FIELD_SIZE (EMRSETWINDOWEXTEX, szlExtent, 8)
2506  TEST_FIELD_ALIGN (EMRSETWINDOWEXTEX, szlExtent, 4)
2507  TEST_FIELD_OFFSET(EMRSETWINDOWEXTEX, szlExtent, 8)
2508 }
2509 
2510 static void test_pack_EMRSETWINDOWORGEX(void)
2511 {
2512  /* EMRSETWINDOWORGEX */
2518  TEST_FIELD_SIZE (EMRSETWINDOWORGEX, ptlOrigin, 8)
2519  TEST_FIELD_ALIGN (EMRSETWINDOWORGEX, ptlOrigin, 4)
2520  TEST_FIELD_OFFSET(EMRSETWINDOWORGEX, ptlOrigin, 8)
2521 }
2522 
2523 static void test_pack_EMRSETWORLDTRANSFORM(void)
2524 {
2525  /* EMRSETWORLDTRANSFORM */
2534 }
2535 
2536 static void test_pack_EMRSTRETCHBLT(void)
2537 {
2538  /* EMRSTRETCHBLT */
2541  TEST_FIELD_SIZE (EMRSTRETCHBLT, emr, 8)
2544  TEST_FIELD_SIZE (EMRSTRETCHBLT, rclBounds, 16)
2545  TEST_FIELD_ALIGN (EMRSTRETCHBLT, rclBounds, 4)
2546  TEST_FIELD_OFFSET(EMRSTRETCHBLT, rclBounds, 8)
2547  TEST_FIELD_SIZE (EMRSTRETCHBLT, xDest, 4)
2548  TEST_FIELD_ALIGN (EMRSTRETCHBLT, xDest, 4)
2549  TEST_FIELD_OFFSET(EMRSTRETCHBLT, xDest, 24)
2550  TEST_FIELD_SIZE (EMRSTRETCHBLT, yDest, 4)
2551  TEST_FIELD_ALIGN (EMRSTRETCHBLT, yDest, 4)
2552  TEST_FIELD_OFFSET(EMRSTRETCHBLT, yDest, 28)
2553  TEST_FIELD_SIZE (EMRSTRETCHBLT, cxDest, 4)
2554  TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxDest, 4)
2555  TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxDest, 32)
2556  TEST_FIELD_SIZE (EMRSTRETCHBLT, cyDest, 4)
2557  TEST_FIELD_ALIGN (EMRSTRETCHBLT, cyDest, 4)
2558  TEST_FIELD_OFFSET(EMRSTRETCHBLT, cyDest, 36)
2559  TEST_FIELD_SIZE (EMRSTRETCHBLT, dwRop, 4)
2560  TEST_FIELD_ALIGN (EMRSTRETCHBLT, dwRop, 4)
2561  TEST_FIELD_OFFSET(EMRSTRETCHBLT, dwRop, 40)
2562  TEST_FIELD_SIZE (EMRSTRETCHBLT, xSrc, 4)
2563  TEST_FIELD_ALIGN (EMRSTRETCHBLT, xSrc, 4)
2564  TEST_FIELD_OFFSET(EMRSTRETCHBLT, xSrc, 44)
2565  TEST_FIELD_SIZE (EMRSTRETCHBLT, ySrc, 4)
2566  TEST_FIELD_ALIGN (EMRSTRETCHBLT, ySrc, 4)
2567  TEST_FIELD_OFFSET(EMRSTRETCHBLT, ySrc, 48)
2568  TEST_FIELD_SIZE (EMRSTRETCHBLT, xformSrc, 24)
2569  TEST_FIELD_ALIGN (EMRSTRETCHBLT, xformSrc, 4)
2570  TEST_FIELD_OFFSET(EMRSTRETCHBLT, xformSrc, 52)
2571  TEST_FIELD_SIZE (EMRSTRETCHBLT, crBkColorSrc, 4)
2572  TEST_FIELD_ALIGN (EMRSTRETCHBLT, crBkColorSrc, 4)
2573  TEST_FIELD_OFFSET(EMRSTRETCHBLT, crBkColorSrc, 76)
2574  TEST_FIELD_SIZE (EMRSTRETCHBLT, iUsageSrc, 4)
2575  TEST_FIELD_ALIGN (EMRSTRETCHBLT, iUsageSrc, 4)
2576  TEST_FIELD_OFFSET(EMRSTRETCHBLT, iUsageSrc, 80)
2577  TEST_FIELD_SIZE (EMRSTRETCHBLT, offBmiSrc, 4)
2578  TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBmiSrc, 4)
2579  TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBmiSrc, 84)
2580  TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBmiSrc, 4)
2581  TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBmiSrc, 4)
2582  TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBmiSrc, 88)
2583  TEST_FIELD_SIZE (EMRSTRETCHBLT, offBitsSrc, 4)
2584  TEST_FIELD_ALIGN (EMRSTRETCHBLT, offBitsSrc, 4)
2585  TEST_FIELD_OFFSET(EMRSTRETCHBLT, offBitsSrc, 92)
2586  TEST_FIELD_SIZE (EMRSTRETCHBLT, cbBitsSrc, 4)
2587  TEST_FIELD_ALIGN (EMRSTRETCHBLT, cbBitsSrc, 4)
2588  TEST_FIELD_OFFSET(EMRSTRETCHBLT, cbBitsSrc, 96)
2589  TEST_FIELD_SIZE (EMRSTRETCHBLT, cxSrc, 4)
2590  TEST_FIELD_ALIGN (EMRSTRETCHBLT, cxSrc, 4)
2591  TEST_FIELD_OFFSET(EMRSTRETCHBLT, cxSrc, 100)
2592  TEST_FIELD_SIZE (EMRSTRETCHBLT, cySrc, 4)
2593  TEST_FIELD_ALIGN (EMRSTRETCHBLT, cySrc, 4)
2594  TEST_FIELD_OFFSET(EMRSTRETCHBLT, cySrc, 104)
2595 }
2596 
2597 static void test_pack_EMRSTRETCHDIBITS(void)
2598 {
2599  /* EMRSTRETCHDIBITS */
2605  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, rclBounds, 16)
2606  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, rclBounds, 4)
2607  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, rclBounds, 8)
2608  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, xDest, 4)
2611  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, yDest, 4)
2620  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxSrc, 4)
2623  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cySrc, 4)
2626  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBmiSrc, 4)
2627  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBmiSrc, 4)
2628  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBmiSrc, 48)
2629  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBmiSrc, 4)
2630  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBmiSrc, 4)
2631  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBmiSrc, 52)
2632  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, offBitsSrc, 4)
2633  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, offBitsSrc, 4)
2634  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, offBitsSrc, 56)
2635  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cbBitsSrc, 4)
2636  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cbBitsSrc, 4)
2637  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cbBitsSrc, 60)
2638  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, iUsageSrc, 4)
2639  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, iUsageSrc, 4)
2640  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, iUsageSrc, 64)
2641  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, dwRop, 4)
2644  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cxDest, 4)
2645  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cxDest, 4)
2646  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cxDest, 72)
2647  TEST_FIELD_SIZE (EMRSTRETCHDIBITS, cyDest, 4)
2648  TEST_FIELD_ALIGN (EMRSTRETCHDIBITS, cyDest, 4)
2649  TEST_FIELD_OFFSET(EMRSTRETCHDIBITS, cyDest, 76)
2650 }
2651 
2652 static void test_pack_EMRSTROKEANDFILLPATH(void)
2653 {
2654  /* EMRSTROKEANDFILLPATH */
2660  TEST_FIELD_SIZE (EMRSTROKEANDFILLPATH, rclBounds, 16)
2661  TEST_FIELD_ALIGN (EMRSTROKEANDFILLPATH, rclBounds, 4)
2663 }
2664 
2665 static void test_pack_EMRSTROKEPATH(void)
2666 {
2667  /* EMRSTROKEPATH */
2670  TEST_FIELD_SIZE (EMRSTROKEPATH, emr, 8)
2673  TEST_FIELD_SIZE (EMRSTROKEPATH, rclBounds, 16)
2674  TEST_FIELD_ALIGN (EMRSTROKEPATH, rclBounds, 4)
2675  TEST_FIELD_OFFSET(EMRSTROKEPATH, rclBounds, 8)
2676 }
2677 
2678 static void test_pack_EMRTEXT(void)
2679 {
2680  /* EMRTEXT */
2681  TEST_TYPE_SIZE (EMRTEXT, 40)
2683  TEST_FIELD_SIZE (EMRTEXT, ptlReference, 8)
2684  TEST_FIELD_ALIGN (EMRTEXT, ptlReference, 4)
2685  TEST_FIELD_OFFSET(EMRTEXT, ptlReference, 0)
2686  TEST_FIELD_SIZE (EMRTEXT, nChars, 4)
2687  TEST_FIELD_ALIGN (EMRTEXT, nChars, 4)
2688  TEST_FIELD_OFFSET(EMRTEXT, nChars, 8)
2689  TEST_FIELD_SIZE (EMRTEXT, offString, 4)
2690  TEST_FIELD_ALIGN (EMRTEXT, offString, 4)
2691  TEST_FIELD_OFFSET(EMRTEXT, offString, 12)
2692  TEST_FIELD_SIZE (EMRTEXT, fOptions, 4)
2693  TEST_FIELD_ALIGN (EMRTEXT, fOptions, 4)
2694  TEST_FIELD_OFFSET(EMRTEXT, fOptions, 16)
2695  TEST_FIELD_SIZE (EMRTEXT, rcl, 16)
2696  TEST_FIELD_ALIGN (EMRTEXT, rcl, 4)
2697  TEST_FIELD_OFFSET(EMRTEXT, rcl, 20)
2698  TEST_FIELD_SIZE (EMRTEXT, offDx, 4)
2699  TEST_FIELD_ALIGN (EMRTEXT, offDx, 4)
2700  TEST_FIELD_OFFSET(EMRTEXT, offDx, 36)
2701 }
2702 
2703 static void test_pack_EMRWIDENPATH(void)
2704 {
2705  /* EMRWIDENPATH */
2708  TEST_FIELD_SIZE (EMRWIDENPATH, emr, 8)
2709  TEST_FIELD_ALIGN (EMRWIDENPATH, emr, 4)
2711 }
2712 
2713 static void test_pack_ENHMETAHEADER(void)
2714 {
2715  /* ENHMETAHEADER */
2724  TEST_FIELD_SIZE (ENHMETAHEADER, rclBounds, 16)
2725  TEST_FIELD_ALIGN (ENHMETAHEADER, rclBounds, 4)
2726  TEST_FIELD_OFFSET(ENHMETAHEADER, rclBounds, 8)
2727  TEST_FIELD_SIZE (ENHMETAHEADER, rclFrame, 16)
2728  TEST_FIELD_ALIGN (ENHMETAHEADER, rclFrame, 4)
2729  TEST_FIELD_OFFSET(ENHMETAHEADER, rclFrame, 24)
2730  TEST_FIELD_SIZE (ENHMETAHEADER, dSignature, 4)
2731  TEST_FIELD_ALIGN (ENHMETAHEADER, dSignature, 4)
2732  TEST_FIELD_OFFSET(ENHMETAHEADER, dSignature, 40)
2733  TEST_FIELD_SIZE (ENHMETAHEADER, nVersion, 4)
2734  TEST_FIELD_ALIGN (ENHMETAHEADER, nVersion, 4)
2735  TEST_FIELD_OFFSET(ENHMETAHEADER, nVersion, 44)
2736  TEST_FIELD_SIZE (ENHMETAHEADER, nBytes, 4)
2737  TEST_FIELD_ALIGN (ENHMETAHEADER, nBytes, 4)
2738  TEST_FIELD_OFFSET(ENHMETAHEADER, nBytes, 48)
2739  TEST_FIELD_SIZE (ENHMETAHEADER, nRecords, 4)
2740  TEST_FIELD_ALIGN (ENHMETAHEADER, nRecords, 4)
2741  TEST_FIELD_OFFSET(ENHMETAHEADER, nRecords, 52)
2742  TEST_FIELD_SIZE (ENHMETAHEADER, nHandles, 2)
2743  TEST_FIELD_ALIGN (ENHMETAHEADER, nHandles, 2)
2744  TEST_FIELD_OFFSET(ENHMETAHEADER, nHandles, 56)
2745  TEST_FIELD_SIZE (ENHMETAHEADER, sReserved, 2)
2746  TEST_FIELD_ALIGN (ENHMETAHEADER, sReserved, 2)
2747  TEST_FIELD_OFFSET(ENHMETAHEADER, sReserved, 58)
2748  TEST_FIELD_SIZE (ENHMETAHEADER, nDescription, 4)
2749  TEST_FIELD_ALIGN (ENHMETAHEADER, nDescription, 4)
2750  TEST_FIELD_OFFSET(ENHMETAHEADER, nDescription, 60)
2751  TEST_FIELD_SIZE (ENHMETAHEADER, offDescription, 4)
2752  TEST_FIELD_ALIGN (ENHMETAHEADER, offDescription, 4)
2753  TEST_FIELD_OFFSET(ENHMETAHEADER, offDescription, 64)
2754  TEST_FIELD_SIZE (ENHMETAHEADER, nPalEntries, 4)
2755  TEST_FIELD_ALIGN (ENHMETAHEADER, nPalEntries, 4)
2756  TEST_FIELD_OFFSET(ENHMETAHEADER, nPalEntries, 68)
2757  TEST_FIELD_SIZE (ENHMETAHEADER, szlDevice, 8)
2758  TEST_FIELD_ALIGN (ENHMETAHEADER, szlDevice, 4)
2759  TEST_FIELD_OFFSET(ENHMETAHEADER, szlDevice, 72)
2760  TEST_FIELD_SIZE (ENHMETAHEADER, szlMillimeters, 8)
2761  TEST_FIELD_ALIGN (ENHMETAHEADER, szlMillimeters, 4)
2762  TEST_FIELD_OFFSET(ENHMETAHEADER, szlMillimeters, 80)
2763  TEST_FIELD_SIZE (ENHMETAHEADER, cbPixelFormat, 4)
2764  TEST_FIELD_ALIGN (ENHMETAHEADER, cbPixelFormat, 4)
2765  TEST_FIELD_OFFSET(ENHMETAHEADER, cbPixelFormat, 88)
2766  TEST_FIELD_SIZE (ENHMETAHEADER, offPixelFormat, 4)
2767  TEST_FIELD_ALIGN (ENHMETAHEADER, offPixelFormat, 4)
2768  TEST_FIELD_OFFSET(ENHMETAHEADER, offPixelFormat, 92)
2769  TEST_FIELD_SIZE (ENHMETAHEADER, bOpenGL, 4)
2770  TEST_FIELD_ALIGN (ENHMETAHEADER, bOpenGL, 4)
2771  TEST_FIELD_OFFSET(ENHMETAHEADER, bOpenGL, 96)
2772  TEST_FIELD_SIZE (ENHMETAHEADER, szlMicrometers, 8)
2773  TEST_FIELD_ALIGN (ENHMETAHEADER, szlMicrometers, 4)
2774  TEST_FIELD_OFFSET(ENHMETAHEADER, szlMicrometers, 100)
2775 }
2776 
2777 static void test_pack_ENHMETARECORD(void)
2778 {
2779  /* ENHMETARECORD */
2788  TEST_FIELD_SIZE (ENHMETARECORD, dParm, 4)
2789  TEST_FIELD_ALIGN (ENHMETARECORD, dParm, 4)
2790  TEST_FIELD_OFFSET(ENHMETARECORD, dParm, 8)
2791 }
2792 
2793 static void test_pack_ENHMFENUMPROC(void)
2794 {
2795  /* ENHMFENUMPROC */
2798 }
2799 
2800 static void test_pack_ENUMLOGFONTA(void)
2801 {
2802  /* ENUMLOGFONTA */
2805  TEST_FIELD_SIZE (ENUMLOGFONTA, elfLogFont, 60)
2806  TEST_FIELD_ALIGN (ENUMLOGFONTA, elfLogFont, 4)
2807  TEST_FIELD_OFFSET(ENUMLOGFONTA, elfLogFont, 0)
2808  TEST_FIELD_SIZE (ENUMLOGFONTA, elfFullName, 64)
2809  TEST_FIELD_ALIGN (ENUMLOGFONTA, elfFullName, 1)
2810  TEST_FIELD_OFFSET(ENUMLOGFONTA, elfFullName, 60)
2811  TEST_FIELD_SIZE (ENUMLOGFONTA, elfStyle, 32)
2812  TEST_FIELD_ALIGN (ENUMLOGFONTA, elfStyle, 1)
2813  TEST_FIELD_OFFSET(ENUMLOGFONTA, elfStyle, 124)
2814 }
2815 
2816 static void test_pack_ENUMLOGFONTEXA(void)
2817 {
2818  /* ENUMLOGFONTEXA */
2821  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfLogFont, 60)
2822  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfLogFont, 4)
2823  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfLogFont, 0)
2824  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfFullName, 64)
2825  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfFullName, 1)
2826  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfFullName, 60)
2827  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfStyle, 32)
2828  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfStyle, 1)
2829  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfStyle, 124)
2830  TEST_FIELD_SIZE (ENUMLOGFONTEXA, elfScript, 32)
2831  TEST_FIELD_ALIGN (ENUMLOGFONTEXA, elfScript, 1)
2832  TEST_FIELD_OFFSET(ENUMLOGFONTEXA, elfScript, 156)
2833 }
2834 
2835 static void test_pack_ENUMLOGFONTEXW(void)
2836 {
2837  /* ENUMLOGFONTEXW */
2840  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfLogFont, 92)
2841  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfLogFont, 4)
2842  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfLogFont, 0)
2843  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfFullName, 128)
2844  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfFullName, 2)
2845  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfFullName, 92)
2846  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfStyle, 64)
2847  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfStyle, 2)
2848  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfStyle, 220)
2849  TEST_FIELD_SIZE (ENUMLOGFONTEXW, elfScript, 64)
2850  TEST_FIELD_ALIGN (ENUMLOGFONTEXW, elfScript, 2)
2851  TEST_FIELD_OFFSET(ENUMLOGFONTEXW, elfScript, 284)
2852 }
2853 
2854 static void test_pack_ENUMLOGFONTW(void)
2855 {
2856  /* ENUMLOGFONTW */
2859  TEST_FIELD_SIZE (ENUMLOGFONTW, elfLogFont, 92)
2860  TEST_FIELD_ALIGN (ENUMLOGFONTW, elfLogFont, 4)
2861  TEST_FIELD_OFFSET(ENUMLOGFONTW, elfLogFont, 0)
2862  TEST_FIELD_SIZE (ENUMLOGFONTW, elfFullName, 128)
2863  TEST_FIELD_ALIGN (ENUMLOGFONTW, elfFullName, 2)
2864  TEST_FIELD_OFFSET(ENUMLOGFONTW, elfFullName, 92)
2865  TEST_FIELD_SIZE (ENUMLOGFONTW, elfStyle, 64)
2866  TEST_FIELD_ALIGN (ENUMLOGFONTW, elfStyle, 2)
2867  TEST_FIELD_OFFSET(ENUMLOGFONTW, elfStyle, 220)
2868 }
2869 
2870 static void test_pack_EXTLOGFONTA(void)
2871 {
2872  /* EXTLOGFONTA */
2875  TEST_FIELD_SIZE (EXTLOGFONTA, elfLogFont, 60)
2876  TEST_FIELD_ALIGN (EXTLOGFONTA, elfLogFont, 4)
2877  TEST_FIELD_OFFSET(EXTLOGFONTA, elfLogFont, 0)
2878  TEST_FIELD_SIZE (EXTLOGFONTA, elfFullName, 64)
2879  TEST_FIELD_ALIGN (EXTLOGFONTA, elfFullName, 1)
2880  TEST_FIELD_OFFSET(EXTLOGFONTA, elfFullName, 60)
2881  TEST_FIELD_SIZE (EXTLOGFONTA, elfStyle, 32)
2882  TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyle, 1)
2883  TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyle, 124)
2884  TEST_FIELD_SIZE (EXTLOGFONTA, elfVersion, 4)
2885  TEST_FIELD_ALIGN (EXTLOGFONTA, elfVersion, 4)
2886  TEST_FIELD_OFFSET(EXTLOGFONTA, elfVersion, 156)
2887  TEST_FIELD_SIZE (EXTLOGFONTA, elfStyleSize, 4)
2888  TEST_FIELD_ALIGN (EXTLOGFONTA, elfStyleSize, 4)
2889  TEST_FIELD_OFFSET(EXTLOGFONTA, elfStyleSize, 160)
2890  TEST_FIELD_SIZE (EXTLOGFONTA, elfMatch, 4)
2891  TEST_FIELD_ALIGN (EXTLOGFONTA, elfMatch, 4)
2892  TEST_FIELD_OFFSET(EXTLOGFONTA, elfMatch, 164)
2893  TEST_FIELD_SIZE (EXTLOGFONTA, elfReserved, 4)
2894  TEST_FIELD_ALIGN (EXTLOGFONTA, elfReserved, 4)
2895  TEST_FIELD_OFFSET(EXTLOGFONTA, elfReserved, 168)
2896  TEST_FIELD_SIZE (EXTLOGFONTA, elfVendorId, 4)
2897  TEST_FIELD_ALIGN (EXTLOGFONTA, elfVendorId, 1)
2898  TEST_FIELD_OFFSET(EXTLOGFONTA, elfVendorId, 172)
2899  TEST_FIELD_SIZE (EXTLOGFONTA, elfCulture, 4)
2900  TEST_FIELD_ALIGN (EXTLOGFONTA, elfCulture, 4)
2901  TEST_FIELD_OFFSET(EXTLOGFONTA, elfCulture, 176)
2902  TEST_FIELD_SIZE (EXTLOGFONTA, elfPanose, 10)
2903  TEST_FIELD_ALIGN (EXTLOGFONTA, elfPanose, 1)
2904  TEST_FIELD_OFFSET(EXTLOGFONTA, elfPanose, 180)
2905 }
2906 
2907 static void test_pack_EXTLOGFONTW(void)
2908 {
2909  /* EXTLOGFONTW */
2912  TEST_FIELD_SIZE (EXTLOGFONTW, elfLogFont, 92)
2913  TEST_FIELD_ALIGN (EXTLOGFONTW, elfLogFont, 4)
2914  TEST_FIELD_OFFSET(EXTLOGFONTW, elfLogFont, 0)
2915  TEST_FIELD_SIZE (EXTLOGFONTW, elfFullName, 128)
2916  TEST_FIELD_ALIGN (EXTLOGFONTW, elfFullName, 2)
2917  TEST_FIELD_OFFSET(EXTLOGFONTW, elfFullName, 92)
2918  TEST_FIELD_SIZE (EXTLOGFONTW, elfStyle, 64)
2919  TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyle, 2)
2920  TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyle, 220)
2921  TEST_FIELD_SIZE (EXTLOGFONTW, elfVersion, 4)
2922  TEST_FIELD_ALIGN (EXTLOGFONTW, elfVersion, 4)
2923  TEST_FIELD_OFFSET(EXTLOGFONTW, elfVersion, 284)
2924  TEST_FIELD_SIZE (EXTLOGFONTW, elfStyleSize, 4)
2925  TEST_FIELD_ALIGN (EXTLOGFONTW, elfStyleSize, 4)
2926  TEST_FIELD_OFFSET(EXTLOGFONTW, elfStyleSize, 288)
2927  TEST_FIELD_SIZE (EXTLOGFONTW, elfMatch, 4)
2928  TEST_FIELD_ALIGN (EXTLOGFONTW, elfMatch, 4)
2929  TEST_FIELD_OFFSET(EXTLOGFONTW, elfMatch, 292)
2930  TEST_FIELD_SIZE (EXTLOGFONTW, elfReserved, 4)
2931  TEST_FIELD_ALIGN (EXTLOGFONTW, elfReserved, 4)
2932  TEST_FIELD_OFFSET(EXTLOGFONTW, elfReserved, 296)
2933  TEST_FIELD_SIZE (EXTLOGFONTW, elfVendorId, 4)
2934  TEST_FIELD_ALIGN (EXTLOGFONTW, elfVendorId, 1)
2935  TEST_FIELD_OFFSET(EXTLOGFONTW, elfVendorId, 300)
2936  TEST_FIELD_SIZE (EXTLOGFONTW, elfCulture, 4)
2937  TEST_FIELD_ALIGN (EXTLOGFONTW, elfCulture, 4)
2938  TEST_FIELD_OFFSET(EXTLOGFONTW, elfCulture, 304)
2939  TEST_FIELD_SIZE (EXTLOGFONTW, elfPanose, 10)
2940  TEST_FIELD_ALIGN (EXTLOGFONTW, elfPanose, 1)
2941  TEST_FIELD_OFFSET(EXTLOGFONTW, elfPanose, 308)
2942 }
2943 
2944 static void test_pack_EXTLOGPEN(void)
2945 {
2946  /* EXTLOGPEN */
2949  TEST_FIELD_SIZE (EXTLOGPEN, elpPenStyle, 4)
2950  TEST_FIELD_ALIGN (EXTLOGPEN, elpPenStyle, 4)
2951  TEST_FIELD_OFFSET(EXTLOGPEN, elpPenStyle, 0)
2952  TEST_FIELD_SIZE (EXTLOGPEN, elpWidth, 4)
2953  TEST_FIELD_ALIGN (EXTLOGPEN, elpWidth, 4)
2954  TEST_FIELD_OFFSET(EXTLOGPEN, elpWidth, 4)
2955  TEST_FIELD_SIZE (EXTLOGPEN, elpBrushStyle, 4)
2956  TEST_FIELD_ALIGN (EXTLOGPEN, elpBrushStyle, 4)
2957  TEST_FIELD_OFFSET(EXTLOGPEN, elpBrushStyle, 8)
2958  TEST_FIELD_SIZE (EXTLOGPEN, elpColor, 4)
2959  TEST_FIELD_ALIGN (EXTLOGPEN, elpColor, 4)
2960  TEST_FIELD_OFFSET(EXTLOGPEN, elpColor, 12)
2961  TEST_FIELD_SIZE (EXTLOGPEN, elpHatch, 8)
2962  TEST_FIELD_ALIGN (EXTLOGPEN, elpHatch, 8)
2963  TEST_FIELD_OFFSET(EXTLOGPEN, elpHatch, 16)
2964  TEST_FIELD_SIZE (EXTLOGPEN, elpNumEntries, 4)
2965  TEST_FIELD_ALIGN (EXTLOGPEN, elpNumEntries, 4)
2966  TEST_FIELD_OFFSET(EXTLOGPEN, elpNumEntries, 24)
2967  TEST_FIELD_SIZE (EXTLOGPEN, elpStyleEntry, 4)
2968  TEST_FIELD_ALIGN (EXTLOGPEN, elpStyleEntry, 4)
2969  TEST_FIELD_OFFSET(EXTLOGPEN, elpStyleEntry, 28)
2970 }
2971 
2972 static void test_pack_FIXED(void)
2973 {
2974  /* FIXED */
2975  TEST_TYPE_SIZE (FIXED, 4)
2976  TEST_TYPE_ALIGN (FIXED, 2)
2977  TEST_FIELD_SIZE (FIXED, fract, 2)
2978  TEST_FIELD_ALIGN (FIXED, fract, 2)
2979  TEST_FIELD_OFFSET(FIXED, fract, 0)
2983 }
2984 
2985 static void test_pack_FONTENUMPROCA(void)
2986 {
2987  /* FONTENUMPROCA */
2990 }
2991 
2992 static void test_pack_FONTENUMPROCW(void)
2993 {
2994  /* FONTENUMPROCW */
2997 }
2998 
2999 static void test_pack_FONTSIGNATURE(void)
3000 {
3001  /* FONTSIGNATURE */
3004  TEST_FIELD_SIZE (FONTSIGNATURE, fsUsb, 16)
3005  TEST_FIELD_ALIGN (FONTSIGNATURE, fsUsb, 4)
3006  TEST_FIELD_OFFSET(FONTSIGNATURE, fsUsb, 0)
3007  TEST_FIELD_SIZE (FONTSIGNATURE, fsCsb, 8)
3008  TEST_FIELD_ALIGN (FONTSIGNATURE, fsCsb, 4)
3009  TEST_FIELD_OFFSET(FONTSIGNATURE, fsCsb, 16)
3010 }
3011 
3012 static void test_pack_FXPT16DOT16(void)
3013 {
3014  /* FXPT16DOT16 */
3017 }
3018 
3019 static void test_pack_FXPT2DOT30(void)
3020 {
3021  /* FXPT2DOT30 */
3024 }
3025 
3026 static void test_pack_GCP_RESULTSA(void)
3027 {
3028  /* GCP_RESULTSA */
3031  TEST_FIELD_SIZE (GCP_RESULTSA, lStructSize, 4)
3032  TEST_FIELD_ALIGN (GCP_RESULTSA, lStructSize, 4)
3033  TEST_FIELD_OFFSET(GCP_RESULTSA, lStructSize, 0)
3034  TEST_FIELD_SIZE (GCP_RESULTSA, lpOutString, 8)
3035  TEST_FIELD_ALIGN (GCP_RESULTSA, lpOutString, 8)
3036  TEST_FIELD_OFFSET(GCP_RESULTSA, lpOutString, 8)
3037  TEST_FIELD_SIZE (GCP_RESULTSA, lpOrder, 8)
3038  TEST_FIELD_ALIGN (GCP_RESULTSA, lpOrder, 8)
3039  TEST_FIELD_OFFSET(GCP_RESULTSA, lpOrder, 16)
3040  TEST_FIELD_SIZE (GCP_RESULTSA, lpDx, 8)
3041  TEST_FIELD_ALIGN (GCP_RESULTSA, lpDx, 8)
3042  TEST_FIELD_OFFSET(GCP_RESULTSA, lpDx, 24)
3043  TEST_FIELD_SIZE (GCP_RESULTSA, lpCaretPos, 8)
3044  TEST_FIELD_ALIGN (GCP_RESULTSA, lpCaretPos, 8)
3045  TEST_FIELD_OFFSET(GCP_RESULTSA, lpCaretPos, 32)
3046  TEST_FIELD_SIZE (GCP_RESULTSA, lpClass, 8)
3047  TEST_FIELD_ALIGN (GCP_RESULTSA, lpClass, 8)
3048  TEST_FIELD_OFFSET(GCP_RESULTSA, lpClass, 40)
3049  TEST_FIELD_SIZE (GCP_RESULTSA, lpGlyphs, 8)
3050  TEST_FIELD_ALIGN (GCP_RESULTSA, lpGlyphs, 8)
3051  TEST_FIELD_OFFSET(GCP_RESULTSA, lpGlyphs, 48)
3052  TEST_FIELD_SIZE (GCP_RESULTSA, nGlyphs, 4)
3053  TEST_FIELD_ALIGN (GCP_RESULTSA, nGlyphs, 4)
3054  TEST_FIELD_OFFSET(GCP_RESULTSA, nGlyphs, 56)
3055  TEST_FIELD_SIZE (GCP_RESULTSA, nMaxFit, 4)
3056  TEST_FIELD_ALIGN (GCP_RESULTSA, nMaxFit, 4)
3057  TEST_FIELD_OFFSET(GCP_RESULTSA, nMaxFit, 60)
3058 }
3059 
3060 static void test_pack_GCP_RESULTSW(void)
3061 {
3062  /* GCP_RESULTSW */
3065  TEST_FIELD_SIZE (GCP_RESULTSW, lStructSize, 4)
3066  TEST_FIELD_ALIGN (GCP_RESULTSW, lStructSize, 4)
3067  TEST_FIELD_OFFSET(GCP_RESULTSW, lStructSize, 0)
3068  TEST_FIELD_SIZE (GCP_RESULTSW, lpOutString, 8)
3069  TEST_FIELD_ALIGN (GCP_RESULTSW, lpOutString, 8)
3070  TEST_FIELD_OFFSET(GCP_RESULTSW, lpOutString, 8)
3071  TEST_FIELD_SIZE (GCP_RESULTSW, lpOrder, 8)
3072  TEST_FIELD_ALIGN (GCP_RESULTSW, lpOrder, 8)
3073  TEST_FIELD_OFFSET(GCP_RESULTSW, lpOrder, 16)
3074  TEST_FIELD_SIZE (GCP_RESULTSW, lpDx, 8)
3075  TEST_FIELD_ALIGN (GCP_RESULTSW, lpDx, 8)
3076  TEST_FIELD_OFFSET(GCP_RESULTSW, lpDx, 24)
3077  TEST_FIELD_SIZE (GCP_RESULTSW, lpCaretPos, 8)
3078  TEST_FIELD_ALIGN (GCP_RESULTSW, lpCaretPos, 8)
3079  TEST_FIELD_OFFSET(GCP_RESULTSW, lpCaretPos, 32)
3080  TEST_FIELD_SIZE (GCP_RESULTSW, lpClass, 8)
3081  TEST_FIELD_ALIGN (GCP_RESULTSW, lpClass, 8)
3082  TEST_FIELD_OFFSET(GCP_RESULTSW, lpClass, 40)
3083  TEST_FIELD_SIZE (GCP_RESULTSW, lpGlyphs, 8)
3084  TEST_FIELD_ALIGN (GCP_RESULTSW, lpGlyphs, 8)
3085  TEST_FIELD_OFFSET(GCP_RESULTSW, lpGlyphs, 48)
3086  TEST_FIELD_SIZE (GCP_RESULTSW, nGlyphs, 4)
3087  TEST_FIELD_ALIGN (GCP_RESULTSW, nGlyphs, 4)
3088  TEST_FIELD_OFFSET(GCP_RESULTSW, nGlyphs, 56)
3089  TEST_FIELD_SIZE (GCP_RESULTSW, nMaxFit, 4)
3090  TEST_FIELD_ALIGN (GCP_RESULTSW, nMaxFit, 4)
3091  TEST_FIELD_OFFSET(GCP_RESULTSW, nMaxFit, 60)
3092 }
3093 
3094 static void test_pack_GLYPHMETRICS(void)
3095 {
3096  /* GLYPHMETRICS */
3099  TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxX, 4)
3100  TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxX, 4)
3101  TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxX, 0)
3102  TEST_FIELD_SIZE (GLYPHMETRICS, gmBlackBoxY, 4)
3103  TEST_FIELD_ALIGN (GLYPHMETRICS, gmBlackBoxY, 4)
3104  TEST_FIELD_OFFSET(GLYPHMETRICS, gmBlackBoxY, 4)
3105  TEST_FIELD_SIZE (GLYPHMETRICS, gmptGlyphOrigin, 8)
3106  TEST_FIELD_ALIGN (GLYPHMETRICS, gmptGlyphOrigin, 4)
3107  TEST_FIELD_OFFSET(GLYPHMETRICS, gmptGlyphOrigin, 8)
3108  TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncX, 2)
3109  TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncX, 2)
3110  TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncX, 16)
3111  TEST_FIELD_SIZE (GLYPHMETRICS, gmCellIncY, 2)
3112  TEST_FIELD_ALIGN (GLYPHMETRICS, gmCellIncY, 2)
3113  TEST_FIELD_OFFSET(GLYPHMETRICS, gmCellIncY, 18)
3114 }
3115 
3116 static void test_pack_GLYPHMETRICSFLOAT(void)
3117 {
3118  /* GLYPHMETRICSFLOAT */
3121  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4)
3122  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxX, 4)
3123  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxX, 0)
3124  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4)
3125  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfBlackBoxY, 4)
3126  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfBlackBoxY, 4)
3127  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8)
3128  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 4)
3129  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8)
3130  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncX, 4)
3131  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncX, 4)
3132  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncX, 16)
3133  TEST_FIELD_SIZE (GLYPHMETRICSFLOAT, gmfCellIncY, 4)
3134  TEST_FIELD_ALIGN (GLYPHMETRICSFLOAT, gmfCellIncY, 4)
3135  TEST_FIELD_OFFSET(GLYPHMETRICSFLOAT, gmfCellIncY, 20)
3136 }
3137 
3138 static void test_pack_GOBJENUMPROC(void)
3139 {
3140  /* GOBJENUMPROC */
3143 }
3144 
3145 static void test_pack_GRADIENT_RECT(void)
3146 {
3147  /* GRADIENT_RECT */
3150  TEST_FIELD_SIZE (GRADIENT_RECT, UpperLeft, 4)
3151  TEST_FIELD_ALIGN (GRADIENT_RECT, UpperLeft, 4)
3152  TEST_FIELD_OFFSET(GRADIENT_RECT, UpperLeft, 0)
3153  TEST_FIELD_SIZE (GRADIENT_RECT, LowerRight, 4)
3154  TEST_FIELD_ALIGN (GRADIENT_RECT, LowerRight, 4)
3155  TEST_FIELD_OFFSET(GRADIENT_RECT, LowerRight, 4)
3156 }
3157 
3158 static void test_pack_GRADIENT_TRIANGLE(void)
3159 {
3160  /* GRADIENT_TRIANGLE */
3163  TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex1, 4)
3164  TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex1, 4)
3166  TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex2, 4)
3167  TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex2, 4)
3169  TEST_FIELD_SIZE (GRADIENT_TRIANGLE, Vertex3, 4)
3170  TEST_FIELD_ALIGN (GRADIENT_TRIANGLE, Vertex3, 4)
3172 }
3173 
3174 static void test_pack_HANDLETABLE(void)
3175 {
3176  /* HANDLETABLE */
3179  TEST_FIELD_SIZE (HANDLETABLE, objectHandle, 8)
3180  TEST_FIELD_ALIGN (HANDLETABLE, objectHandle, 8)
3181  TEST_FIELD_OFFSET(HANDLETABLE, objectHandle, 0)
3182 }
3183 
3184 static void test_pack_ICMENUMPROCA(void)
3185 {
3186  /* ICMENUMPROCA */
3189 }
3190 
3191 static void test_pack_ICMENUMPROCW(void)
3192 {
3193  /* ICMENUMPROCW */
3196 }
3197 
3198 static void test_pack_KERNINGPAIR(void)
3199 {
3200  /* KERNINGPAIR */
3203  TEST_FIELD_SIZE (KERNINGPAIR, wFirst, 2)
3204  TEST_FIELD_ALIGN (KERNINGPAIR, wFirst, 2)
3205  TEST_FIELD_OFFSET(KERNINGPAIR, wFirst, 0)
3206  TEST_FIELD_SIZE (KERNINGPAIR, wSecond, 2)
3207  TEST_FIELD_ALIGN (KERNINGPAIR, wSecond, 2)
3208  TEST_FIELD_OFFSET(KERNINGPAIR, wSecond, 2)
3209  TEST_FIELD_SIZE (KERNINGPAIR, iKernAmount, 4)
3210  TEST_FIELD_ALIGN (KERNINGPAIR, iKernAmount, 4)
3211  TEST_FIELD_OFFSET(KERNINGPAIR, iKernAmount, 4)
3212 }
3213 
3214 static void test_pack_LAYERPLANEDESCRIPTOR(void)
3215 {
3216  /* LAYERPLANEDESCRIPTOR */
3222  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, nVersion, 2)
3223  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, nVersion, 2)
3228  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iPixelType, 1)
3229  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iPixelType, 1)
3230  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iPixelType, 8)
3231  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cColorBits, 1)
3232  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cColorBits, 1)
3233  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cColorBits, 9)
3234  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedBits, 1)
3235  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedBits, 1)
3237  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cRedShift, 1)
3238  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cRedShift, 1)
3239  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cRedShift, 11)
3240  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenBits, 1)
3241  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenBits, 1)
3242  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenBits, 12)
3243  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cGreenShift, 1)
3244  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cGreenShift, 1)
3245  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cGreenShift, 13)
3246  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueBits, 1)
3247  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueBits, 1)
3248  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueBits, 14)
3249  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cBlueShift, 1)
3250  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cBlueShift, 1)
3251  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cBlueShift, 15)
3252  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaBits, 1)
3253  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaBits, 1)
3254  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaBits, 16)
3255  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAlphaShift, 1)
3256  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAlphaShift, 1)
3257  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAlphaShift, 17)
3258  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBits, 1)
3259  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBits, 1)
3260  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBits, 18)
3261  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1)
3262  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumRedBits, 1)
3263  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumRedBits, 19)
3264  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1)
3265  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumGreenBits, 1)
3266  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumGreenBits, 20)
3267  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1)
3268  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumBlueBits, 1)
3269  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumBlueBits, 21)
3270  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1)
3271  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 1)
3272  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 22)
3273  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cDepthBits, 1)
3274  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cDepthBits, 1)
3275  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cDepthBits, 23)
3276  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cStencilBits, 1)
3277  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cStencilBits, 1)
3278  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cStencilBits, 24)
3279  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1)
3280  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, cAuxBuffers, 1)
3281  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, cAuxBuffers, 25)
3282  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, iLayerPlane, 1)
3283  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, iLayerPlane, 1)
3284  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, iLayerPlane, 26)
3285  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, bReserved, 1)
3286  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, bReserved, 1)
3287  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, bReserved, 27)
3288  TEST_FIELD_SIZE (LAYERPLANEDESCRIPTOR, crTransparent, 4)
3289  TEST_FIELD_ALIGN (LAYERPLANEDESCRIPTOR, crTransparent, 4)
3290  TEST_FIELD_OFFSET(LAYERPLANEDESCRIPTOR, crTransparent, 28)
3291 }
3292 
3293 static void test_pack_LCSCSTYPE(void)
3294 {
3295  /* LCSCSTYPE */
3298 }
3299 
3300 static void test_pack_LCSGAMUTMATCH(void)
3301 {
3302  /* LCSGAMUTMATCH */
3305 }
3306 
3307 static void test_pack_LINEDDAPROC(void)
3308 {
3309  /* LINEDDAPROC */
3312 }
3313 
3314 static void test_pack_LOCALESIGNATURE(void)
3315 {
3316  /* LOCALESIGNATURE */
3319  TEST_FIELD_SIZE (LOCALESIGNATURE, lsUsb, 16)
3320  TEST_FIELD_ALIGN (LOCALESIGNATURE, lsUsb, 4)
3322  TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbDefault, 8)
3323  TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbDefault, 4)
3324  TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbDefault, 16)
3325  TEST_FIELD_SIZE (LOCALESIGNATURE, lsCsbSupported, 8)
3326  TEST_FIELD_ALIGN (LOCALESIGNATURE, lsCsbSupported, 4)
3327  TEST_FIELD_OFFSET(LOCALESIGNATURE, lsCsbSupported, 24)
3328 }
3329 
3330 static void test_pack_LOGBRUSH(void)
3331 {
3332  /* LOGBRUSH */
3333  TEST_TYPE_SIZE (LOGBRUSH, 16)
3335  TEST_FIELD_SIZE (LOGBRUSH, lbStyle, 4)
3336  TEST_FIELD_ALIGN (LOGBRUSH, lbStyle, 4)
3337  TEST_FIELD_OFFSET(LOGBRUSH, lbStyle, 0)
3338  TEST_FIELD_SIZE (LOGBRUSH, lbColor, 4)
3339  TEST_FIELD_ALIGN (LOGBRUSH, lbColor, 4)
3340  TEST_FIELD_OFFSET(LOGBRUSH, lbColor, 4)
3341  TEST_FIELD_SIZE (LOGBRUSH, lbHatch, 8)
3342  TEST_FIELD_ALIGN (LOGBRUSH, lbHatch, 8)
3343  TEST_FIELD_OFFSET(LOGBRUSH, lbHatch, 8)
3344 }
3345 
3346 static void test_pack_LOGCOLORSPACEA(void)
3347 {
3348  /* LOGCOLORSPACEA */
3351  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSignature, 4)
3352  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSignature, 4)
3353  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSignature, 0)
3354  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsVersion, 4)
3355  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsVersion, 4)
3356  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsVersion, 4)
3357  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsSize, 4)
3358  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsSize, 4)
3359  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsSize, 8)
3360  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsCSType, 4)
3361  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsCSType, 4)
3362  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsCSType, 12)
3363  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsIntent, 4)
3364  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsIntent, 4)
3365  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsIntent, 16)
3366  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsEndpoints, 36)
3367  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsEndpoints, 4)
3368  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsEndpoints, 20)
3369  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaRed, 4)
3370  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaRed, 4)
3371  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaRed, 56)
3372  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaGreen, 4)
3373  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaGreen, 4)
3374  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaGreen, 60)
3375  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsGammaBlue, 4)
3376  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsGammaBlue, 4)
3377  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsGammaBlue, 64)
3378  TEST_FIELD_SIZE (LOGCOLORSPACEA, lcsFilename, 260)
3379  TEST_FIELD_ALIGN (LOGCOLORSPACEA, lcsFilename, 1)
3380  TEST_FIELD_OFFSET(LOGCOLORSPACEA, lcsFilename, 68)
3381 }
3382 
3383 static void test_pack_LOGCOLORSPACEW(void)
3384 {
3385  /* LOGCOLORSPACEW */
3388  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSignature, 4)
3389  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSignature, 4)
3390  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSignature, 0)
3391  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsVersion, 4)
3392  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsVersion, 4)
3393  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsVersion, 4)
3394  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsSize, 4)
3395  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsSize, 4)
3396  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsSize, 8)
3397  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsCSType, 4)
3398  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsCSType, 4)
3399  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsCSType, 12)
3400  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsIntent, 4)
3401  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsIntent, 4)
3402  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsIntent, 16)
3403  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsEndpoints, 36)
3404  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsEndpoints, 4)
3405  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsEndpoints, 20)
3406  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaRed, 4)
3407  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaRed, 4)
3408  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaRed, 56)
3409  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaGreen, 4)
3410  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaGreen, 4)
3411  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaGreen, 60)
3412  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsGammaBlue, 4)
3413  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsGammaBlue, 4)
3414  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsGammaBlue, 64)
3415  TEST_FIELD_SIZE (LOGCOLORSPACEW, lcsFilename, 520)
3416  TEST_FIELD_ALIGN (LOGCOLORSPACEW, lcsFilename, 2)
3417  TEST_FIELD_OFFSET(LOGCOLORSPACEW, lcsFilename, 68)
3418 }
3419 
3420 static void test_pack_LOGFONTA(void)
3421 {
3422  /* LOGFONTA */
3423  TEST_TYPE_SIZE (LOGFONTA, 60)
3425  TEST_FIELD_SIZE (LOGFONTA, lfHeight, 4)
3426  TEST_FIELD_ALIGN (LOGFONTA, lfHeight, 4)
3427  TEST_FIELD_OFFSET(LOGFONTA, lfHeight, 0)
3428  TEST_FIELD_SIZE (LOGFONTA, lfWidth, 4)
3429  TEST_FIELD_ALIGN (LOGFONTA, lfWidth, 4)
3430  TEST_FIELD_OFFSET(LOGFONTA, lfWidth, 4)
3431  TEST_FIELD_SIZE (LOGFONTA, lfEscapement, 4)
3432  TEST_FIELD_ALIGN (LOGFONTA, lfEscapement, 4)
3433  TEST_FIELD_OFFSET(LOGFONTA, lfEscapement, 8)
3434  TEST_FIELD_SIZE (LOGFONTA, lfOrientation, 4)
3435  TEST_FIELD_ALIGN (LOGFONTA, lfOrientation, 4)
3436  TEST_FIELD_OFFSET(LOGFONTA, lfOrientation, 12)
3437  TEST_FIELD_SIZE (LOGFONTA, lfWeight, 4)
3438  TEST_FIELD_ALIGN (LOGFONTA, lfWeight, 4)
3439  TEST_FIELD_OFFSET(LOGFONTA, lfWeight, 16)
3440  TEST_FIELD_SIZE (LOGFONTA, lfItalic, 1)
3441  TEST_FIELD_ALIGN (LOGFONTA, lfItalic, 1)
3442  TEST_FIELD_OFFSET(LOGFONTA, lfItalic, 20)
3443  TEST_FIELD_SIZE (LOGFONTA, lfUnderline, 1)
3444  TEST_FIELD_ALIGN (LOGFONTA, lfUnderline, 1)
3445  TEST_FIELD_OFFSET(LOGFONTA, lfUnderline, 21)
3446  TEST_FIELD_SIZE (LOGFONTA, lfStrikeOut, 1)
3447  TEST_FIELD_ALIGN (LOGFONTA, lfStrikeOut, 1)
3448  TEST_FIELD_OFFSET(LOGFONTA, lfStrikeOut, 22)
3449  TEST_FIELD_SIZE (LOGFONTA, lfCharSet, 1)
3450  TEST_FIELD_ALIGN (LOGFONTA, lfCharSet, 1)
3451  TEST_FIELD_OFFSET(LOGFONTA, lfCharSet, 23)
3452  TEST_FIELD_SIZE (LOGFONTA, lfOutPrecision, 1)
3453  TEST_FIELD_ALIGN (LOGFONTA, lfOutPrecision, 1)
3454  TEST_FIELD_OFFSET(LOGFONTA, lfOutPrecision, 24)
3455  TEST_FIELD_SIZE (LOGFONTA, lfClipPrecision, 1)
3456  TEST_FIELD_ALIGN (LOGFONTA, lfClipPrecision, 1)
3457  TEST_FIELD_OFFSET(LOGFONTA, lfClipPrecision, 25)
3458  TEST_FIELD_SIZE (LOGFONTA, lfQuality, 1)
3459  TEST_FIELD_ALIGN (LOGFONTA, lfQuality, 1)
3460  TEST_FIELD_OFFSET(LOGFONTA, lfQuality, 26)
3461  TEST_FIELD_SIZE (LOGFONTA, lfPitchAndFamily, 1)
3462  TEST_FIELD_ALIGN (LOGFONTA, lfPitchAndFamily, 1)
3463  TEST_FIELD_OFFSET(LOGFONTA, lfPitchAndFamily, 27)
3464  TEST_FIELD_SIZE (LOGFONTA, lfFaceName, 32)
3465  TEST_FIELD_ALIGN (LOGFONTA, lfFaceName, 1)
3466  TEST_FIELD_OFFSET(LOGFONTA, lfFaceName, 28)
3467 }
3468 
3469 static void test_pack_LOGFONTW(void)
3470 {
3471  /* LOGFONTW */
3472  TEST_TYPE_SIZE (LOGFONTW, 92)
3474  TEST_FIELD_SIZE (LOGFONTW, lfHeight, 4)
3475  TEST_FIELD_ALIGN (LOGFONTW, lfHeight, 4)
3476  TEST_FIELD_OFFSET(LOGFONTW, lfHeight, 0)
3477  TEST_FIELD_SIZE (LOGFONTW, lfWidth, 4)
3478  TEST_FIELD_ALIGN (LOGFONTW, lfWidth, 4)
3479  TEST_FIELD_OFFSET(LOGFONTW, lfWidth, 4)
3480  TEST_FIELD_SIZE (LOGFONTW, lfEscapement, 4)
3481  TEST_FIELD_ALIGN (LOGFONTW, lfEscapement, 4)
3482  TEST_FIELD_OFFSET(LOGFONTW, lfEscapement, 8)
3483  TEST_FIELD_SIZE (LOGFONTW, lfOrientation, 4)
3484  TEST_FIELD_ALIGN (LOGFONTW, lfOrientation, 4)
3485  TEST_FIELD_OFFSET(LOGFONTW, lfOrientation, 12)
3486  TEST_FIELD_SIZE (LOGFONTW, lfWeight, 4)
3487  TEST_FIELD_ALIGN (LOGFONTW, lfWeight, 4)
3488  TEST_FIELD_OFFSET(LOGFONTW, lfWeight, 16)
3489  TEST_FIELD_SIZE (LOGFONTW, lfItalic, 1)
3490  TEST_FIELD_ALIGN (LOGFONTW, lfItalic, 1)
3491  TEST_FIELD_OFFSET(LOGFONTW, lfItalic, 20)
3492  TEST_FIELD_SIZE (LOGFONTW, lfUnderline, 1)
3493  TEST_FIELD_ALIGN (LOGFONTW, lfUnderline, 1)
3494  TEST_FIELD_OFFSET(LOGFONTW, lfUnderline, 21)
3495  TEST_FIELD_SIZE (LOGFONTW, lfStrikeOut, 1)
3496  TEST_FIELD_ALIGN (LOGFONTW, lfStrikeOut, 1)
3497  TEST_FIELD_OFFSET(LOGFONTW, lfStrikeOut, 22)
3498  TEST_FIELD_SIZE (LOGFONTW, lfCharSet, 1)
3499  TEST_FIELD_ALIGN (LOGFONTW, lfCharSet, 1)
3500  TEST_FIELD_OFFSET(LOGFONTW, lfCharSet, 23)
3501  TEST_FIELD_SIZE (LOGFONTW, lfOutPrecision, 1)
3502  TEST_FIELD_ALIGN (LOGFONTW, lfOutPrecision, 1)
3503  TEST_FIELD_OFFSET(LOGFONTW, lfOutPrecision, 24)
3504  TEST_FIELD_SIZE (LOGFONTW, lfClipPrecision, 1)
3505  TEST_FIELD_ALIGN (LOGFONTW, lfClipPrecision, 1)
3506  TEST_FIELD_OFFSET(LOGFONTW, lfClipPrecision, 25)
3507  TEST_FIELD_SIZE (LOGFONTW, lfQuality, 1)
3508  TEST_FIELD_ALIGN (LOGFONTW, lfQuality, 1)
3509  TEST_FIELD_OFFSET(LOGFONTW, lfQuality, 26)
3510  TEST_FIELD_SIZE (LOGFONTW, lfPitchAndFamily, 1)
3511  TEST_FIELD_ALIGN (LOGFONTW, lfPitchAndFamily, 1)
3512  TEST_FIELD_OFFSET(LOGFONTW, lfPitchAndFamily, 27)
3513  TEST_FIELD_SIZE (LOGFONTW, lfFaceName, 64)
3514  TEST_FIELD_ALIGN (LOGFONTW, lfFaceName, 2)
3515  TEST_FIELD_OFFSET(LOGFONTW, lfFaceName, 28)
3516 }
3517 
3518 static void test_pack_LOGPEN(void)
3519 {
3520  /* LOGPEN */
3521  TEST_TYPE_SIZE (LOGPEN, 16)
3522  TEST_TYPE_ALIGN (LOGPEN, 4)
3523  TEST_FIELD_SIZE (LOGPEN, lopnStyle, 4)
3524  TEST_FIELD_ALIGN (LOGPEN, lopnStyle, 4)
3525  TEST_FIELD_OFFSET(LOGPEN, lopnStyle, 0)
3526  TEST_FIELD_SIZE (LOGPEN, lopnWidth, 8)
3527  TEST_FIELD_ALIGN (LOGPEN, lopnWidth, 4)
3528  TEST_FIELD_OFFSET(LOGPEN, lopnWidth, 4)
3529  TEST_FIELD_SIZE (LOGPEN, lopnColor, 4)
3530  TEST_FIELD_ALIGN (LOGPEN, lopnColor, 4)
3531  TEST_FIELD_OFFSET(LOGPEN, lopnColor, 12)
3532 }
3533 
3534 static void test_pack_LPABC(void)
3535 {
3536  /* LPABC */
3537  TEST_TYPE_SIZE (LPABC, 8)
3538  TEST_TYPE_ALIGN (LPABC, 8)
3539  TEST_TARGET_SIZE (LPABC, 12)
3541 }
3542 
3543 static void test_pack_LPABCFLOAT(void)
3544 {
3545  /* LPABCFLOAT */
3550 }
3551 
3552 static void test_pack_LPBITMAP(void)
3553 {
3554  /* LPBITMAP */
3559 }
3560 
3561 static void test_pack_LPBITMAPCOREHEADER(void)
3562 {
3563  /* LPBITMAPCOREHEADER */
3568 }
3569 
3570 static void test_pack_LPBITMAPCOREINFO(void)
3571 {
3572  /* LPBITMAPCOREINFO */
3577 }
3578 
3579 static void test_pack_LPBITMAPFILEHEADER(void)
3580 {
3581  /* LPBITMAPFILEHEADER */
3586 }
3587 
3588 static void test_pack_LPBITMAPINFO(void)
3589 {
3590  /* LPBITMAPINFO */
3595 }
3596 
3597 static void test_pack_LPBITMAPINFOHEADER(void)
3598 {
3599  /* LPBITMAPINFOHEADER */
3604 }
3605 
3606 static void test_pack_LPBITMAPV5HEADER(void)
3607 {
3608  /* LPBITMAPV5HEADER */
3609  TEST_TYPE_SIZE (LPBITMAPV5HEADER, 8)
3610  TEST_TYPE_ALIGN (LPBITMAPV5HEADER, 8)
3611  TEST_TARGET_SIZE (LPBITMAPV5HEADER, 124)
3612  TEST_TARGET_ALIGN(LPBITMAPV5HEADER, 4)
3613 }
3614 
3615 static void test_pack_LPCHARSETINFO(void)
3616 {
3617  /* LPCHARSETINFO */
3622 }
3623 
3624 static void test_pack_LPCIEXYZ(void)
3625 {
3626  /* LPCIEXYZ */
3631 }
3632 
3633 static void test_pack_LPCIEXYZTRIPLE(void)
3634 {
3635  /* LPCIEXYZTRIPLE */
3640 }
3641 
3642 static void test_pack_LPCOLORADJUSTMENT(void)
3643 {
3644  /* LPCOLORADJUSTMENT */
3649 }
3650 
3651 static void test_pack_LPDEVMODEA(void)
3652 {
3653  /* LPDEVMODEA */
3656 }
3657 
3658 static void test_pack_LPDEVMODEW(void)
3659 {
3660  /* LPDEVMODEW */
3663 }
3664 
3665 static void test_pack_LPDIBSECTION(void)
3666 {
3667  /* LPDIBSECTION */
3672 }
3673 
3674 static void test_pack_LPDISPLAY_DEVICEA(void)
3675 {
3676  /* LPDISPLAY_DEVICEA */
3681 }
3682 
3683 static void test_pack_LPDISPLAY_DEVICEW(void)
3684 {
3685  /* LPDISPLAY_DEVICEW */
3690 }
3691 
3692 static void test_pack_LPDOCINFOA(void)
3693 {
3694  /* LPDOCINFOA */
3699 }
3700 
3701 static void test_pack_LPDOCINFOW(void)
3702 {
3703  /* LPDOCINFOW */
3708 }
3709 
3710 static void test_pack_LPENHMETAHEADER(void)
3711 {
3712  /* LPENHMETAHEADER */
3717 }
3718 
3719 static void test_pack_LPENHMETARECORD(void)
3720 {
3721  /* LPENHMETARECORD */
3726 }
3727 
3728 static void test_pack_LPENUMLOGFONTA(void)
3729 {
3730  /* LPENUMLOGFONTA */
3735 }
3736 
3737 static void test_pack_LPENUMLOGFONTEXA(void)
3738 {
3739  /* LPENUMLOGFONTEXA */
3744 }
3745 
3746 static void test_pack_LPENUMLOGFONTEXW(void)
3747 {
3748  /* LPENUMLOGFONTEXW */
3753 }
3754 
3755 static void test_pack_LPENUMLOGFONTW(void)
3756 {
3757  /* LPENUMLOGFONTW */
3762 }
3763 
3764 static void test_pack_LPEXTLOGFONTA(void)
3765 {
3766  /* LPEXTLOGFONTA */
3771 }
3772 
3773 static void test_pack_LPEXTLOGFONTW(void)
3774 {
3775  /* LPEXTLOGFONTW */
3780 }
3781 
3782 static void test_pack_LPEXTLOGPEN(void)
3783 {
3784  /* LPEXTLOGPEN */
3789 }
3790 
3791 static void test_pack_LPFONTSIGNATURE(void)
3792 {
3793  /* LPFONTSIGNATURE */
3798 }
3799 
3800 static void test_pack_LPGCP_RESULTSA(void)
3801 {
3802  /* LPGCP_RESULTSA */
3807 }
3808 
3809 static void test_pack_LPGCP_RESULTSW(void)
3810 {
3811  /* LPGCP_RESULTSW */
3816 }
3817 
3818 static void test_pack_LPGLYPHMETRICS(void)
3819 {
3820  /* LPGLYPHMETRICS */
3825 }
3826 
3827 static void test_pack_LPGLYPHMETRICSFLOAT(void)
3828 {
3829  /* LPGLYPHMETRICSFLOAT */
3834 }
3835 
3836 static void test_pack_LPGRADIENT_RECT(void)
3837 {
3838  /* LPGRADIENT_RECT */
3843 }
3844 
3845 static void test_pack_LPGRADIENT_TRIANGLE(void)
3846 {
3847  /* LPGRADIENT_TRIANGLE */
3852 }
3853 
3854 static void test_pack_LPHANDLETABLE(void)
3855 {
3856  /* LPHANDLETABLE */
3861 }
3862 
3863 static void test_pack_LPKERNINGPAIR(void)
3864 {
3865  /* LPKERNINGPAIR */
3870 }
3871 
3872 static void test_pack_LPLAYERPLANEDESCRIPTOR(void)
3873 {
3874  /* LPLAYERPLANEDESCRIPTOR */
3879 }
3880 
3881 static void test_pack_LPLOCALESIGNATURE(void)
3882 {
3883  /* LPLOCALESIGNATURE */
3888 }
3889 
3890 static void test_pack_LPLOGBRUSH(void)
3891 {
3892  /* LPLOGBRUSH */
3897 }
3898 
3899 static void test_pack_LPLOGCOLORSPACEA(void)
3900 {
3901  /* LPLOGCOLORSPACEA */
3906 }
3907 
3908 static void test_pack_LPLOGCOLORSPACEW(void)
3909 {
3910  /* LPLOGCOLORSPACEW */
3915 }
3916 
3917 static void test_pack_LPLOGFONTA(void)
3918 {
3919  /* LPLOGFONTA */
3924 }
3925 
3926 static void test_pack_LPLOGFONTW(void)
3927 {
3928  /* LPLOGFONTW */
3933 }
3934 
3935 static void test_pack_LPLOGPEN(void)
3936 {
3937  /* LPLOGPEN */
3942 }
3943 
3944 static void test_pack_LPMAT2(void)
3945 {
3946  /* LPMAT2 */
3947  TEST_TYPE_SIZE (LPMAT2, 8)
3948  TEST_TYPE_ALIGN (LPMAT2, 8)
3949  TEST_TARGET_SIZE (LPMAT2, 16)
3951 }
3952 
3953 static void test_pack_LPMETAFILEPICT(void)
3954 {
3955  /* LPMETAFILEPICT */
3960 }
3961 
3962 static void test_pack_LPMETAHEADER(void)
3963 {
3964  /* LPMETAHEADER */
3969 }
3970 
3971 static void test_pack_LPMETARECORD(void)
3972 {
3973  /* LPMETARECORD */
3978 }
3979 
3980 static void test_pack_LPNEWTEXTMETRICA(void)
3981 {
3982  /* LPNEWTEXTMETRICA */
3987 }
3988 
3989 static void test_pack_LPNEWTEXTMETRICW(void)
3990 {
3991  /* LPNEWTEXTMETRICW */
3996 }
3997 
3998 static void test_pack_LPOUTLINETEXTMETRICA(void)
3999 {
4000  /* LPOUTLINETEXTMETRICA */
4005 }
4006 
4007 static void test_pack_LPOUTLINETEXTMETRICW(void)
4008 {
4009  /* LPOUTLINETEXTMETRICW */
4014 }
4015 
4016 static void test_pack_LPPANOSE(void)
4017 {
4018  /* LPPANOSE */
4023 }
4024 
4025 static void test_pack_LPPELARRAY(void)
4026 {
4027  /* LPPELARRAY */
4032 }
4033 
4034 static void test_pack_LPPIXELFORMATDESCRIPTOR(void)
4035 {
4036  /* LPPIXELFORMATDESCRIPTOR */
4041 }
4042 
4043 static void test_pack_LPPOINTFX(void)
4044 {
4045  /* LPPOINTFX */
4050 }
4051 
4052 static void test_pack_LPPOLYTEXTA(void)
4053 {
4054  /* LPPOLYTEXTA */
4059 }
4060 
4061 static void test_pack_LPPOLYTEXTW(void)
4062 {
4063  /* LPPOLYTEXTW */
4068 }
4069 
4070 static void test_pack_LPRASTERIZER_STATUS(void)
4071 {
4072  /* LPRASTERIZER_STATUS */
4077 }
4078 
4079 static void test_pack_LPRGBQUAD(void)
4080 {
4081  /* LPRGBQUAD */
4086 }
4087 
4088 static void test_pack_LPRGNDATA(void)
4089 {
4090  /* LPRGNDATA */
4095 }
4096 
4097 static void test_pack_LPTEXTMETRICA(void)
4098 {
4099  /* LPTEXTMETRICA */
4104 }
4105 
4106 static void test_pack_LPTEXTMETRICW(void)
4107 {
4108  /* LPTEXTMETRICW */
4113 }
4114 
4115 static void test_pack_LPTRIVERTEX(void)
4116 {
4117  /* LPTRIVERTEX */
4122 }
4123 
4124 static void test_pack_LPTTPOLYCURVE(void)
4125 {
4126  /* LPTTPOLYCURVE */
4131 }
4132 
4133 static void test_pack_LPTTPOLYGONHEADER(void)
4134 {
4135  /* LPTTPOLYGONHEADER */
4140 }
4141 
4142 static void test_pack_LPXFORM(void)
4143 {
4144  /* LPXFORM */
4145  TEST_TYPE_SIZE (LPXFORM, 8)
4149 }
4150 
4151 static void test_pack_MAT2(void)
4152 {
4153  /* MAT2 */
4154  TEST_TYPE_SIZE (MAT2, 16)
4155  TEST_TYPE_ALIGN (MAT2, 2)
4156  TEST_FIELD_SIZE (MAT2, eM11, 4)
4157  TEST_FIELD_ALIGN (MAT2, eM11, 2)
4158  TEST_FIELD_OFFSET(MAT2, eM11, 0)
4159  TEST_FIELD_SIZE (MAT2, eM12, 4)
4160  TEST_FIELD_ALIGN (MAT2, eM12, 2)
4161  TEST_FIELD_OFFSET(MAT2, eM12, 4)
4162  TEST_FIELD_SIZE (MAT2, eM21, 4)
4163  TEST_FIELD_ALIGN (MAT2, eM21, 2)
4164  TEST_FIELD_OFFSET(MAT2, eM21, 8)
4165  TEST_FIELD_SIZE (MAT2, eM22, 4)
4166  TEST_FIELD_ALIGN (MAT2, eM22, 2)
4167