Fix packing bug in shlobj.h.
[wine] / dlls / shell32 / tests / generated.c
1 /* File generated automatically from tools/winapi/test.dat; do not edit! */
2 /* This file can be copied, modified and distributed without restriction. */
3
4 /*
5  * Unit tests for data structure packing
6  */
7
8 #define WINVER 0x0501
9 #define _WIN32_IE 0x0501
10 #define _WIN32_WINNT 0x0501
11
12 #define WINE_NOWINSOCK
13
14 #include <stdarg.h>
15 #include "windef.h"
16 #include "winbase.h"
17 #include "wtypes.h"
18 #include "shellapi.h"
19 #include "winuser.h"
20 #include "wingdi.h"
21 #include "shlobj.h"
22
23 #include "wine/test.h"
24
25 /***********************************************************************
26  * Compability macros
27  */
28
29 #define DWORD_PTR UINT_PTR
30 #define LONG_PTR INT_PTR
31 #define ULONG_PTR UINT_PTR
32
33 /***********************************************************************
34  * Windows API extension
35  */
36
37 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
38 # define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
39 #elif defined(__GNUC__)
40 # define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
41 #else
42 /* FIXME: Not sure if is possible to do without compiler extension */
43 #endif
44
45 #if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
46 # define _TYPE_ALIGNMENT(type) __alignof(type)
47 #elif defined(__GNUC__)
48 # define _TYPE_ALIGNMENT(type) __alignof__(type)
49 #else
50 /*
51  * FIXME: Not sure if is possible to do without compiler extension
52  *        (if type is not just a name that is, if so the normal)
53  *         TYPE_ALIGNMENT can be used)
54  */
55 #endif
56
57 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
58 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
59 #endif
60
61 /***********************************************************************
62  * Test helper macros
63  */
64
65 #ifdef FIELD_ALIGNMENT
66 # define TEST_FIELD_ALIGNMENT(type, field, align) \
67    ok(FIELD_ALIGNMENT(type, field) == align, \
68        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
69            FIELD_ALIGNMENT(type, field))
70 #else
71 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
72 #endif
73
74 #define TEST_FIELD_OFFSET(type, field, offset) \
75     ok(FIELD_OFFSET(type, field) == offset, \
76         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
77              FIELD_OFFSET(type, field))
78
79 #ifdef _TYPE_ALIGNMENT
80 #define TEST__TYPE_ALIGNMENT(type, align) \
81     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", _TYPE_ALIGNMENT(type))
82 #else
83 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
84 #endif
85
86 #ifdef TYPE_ALIGNMENT
87 #define TEST_TYPE_ALIGNMENT(type, align) \
88     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", TYPE_ALIGNMENT(type))
89 #else
90 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
91 #endif
92
93 #define TEST_TYPE_SIZE(type, size) \
94     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", sizeof(type))
95
96 /***********************************************************************
97  * Test macros
98  */
99
100 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
101   TEST_TYPE_SIZE(field_type, field_size); \
102   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
103   TEST_FIELD_OFFSET(type, field_name, field_offset); \
104
105 #define TEST_TYPE(type, size, align) \
106   TEST_TYPE_ALIGNMENT(type, align); \
107   TEST_TYPE_SIZE(type, size)
108
109 #define TEST_TYPE_POINTER(type, size, align) \
110     TEST__TYPE_ALIGNMENT(*(type)0, align); \
111     TEST_TYPE_SIZE(*(type)0, size)
112
113 #define TEST_TYPE_SIGNED(type) \
114     ok((type) -1 < 0, "(" #type ") -1 < 0\n");
115
116 #define TEST_TYPE_UNSIGNED(type) \
117      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
118
119 static void test_pack_BLOB(void)
120 {
121     /* BLOB (pack 4) */
122     TEST_TYPE(BLOB, 8, 4);
123     TEST_FIELD(BLOB, ULONG, cbSize, 0, 4, 4);
124     TEST_FIELD(BLOB, BYTE *, pBlobData, 4, 4, 4);
125 }
126
127 static void test_pack_BSTR(void)
128 {
129     /* BSTR */
130     TEST_TYPE(BSTR, 4, 4);
131     TEST_TYPE_POINTER(BSTR, 2, 2);
132 }
133
134 static void test_pack_BSTRBLOB(void)
135 {
136     /* BSTRBLOB (pack 4) */
137     TEST_TYPE(BSTRBLOB, 8, 4);
138     TEST_FIELD(BSTRBLOB, ULONG, cbSize, 0, 4, 4);
139     TEST_FIELD(BSTRBLOB, BYTE *, pData, 4, 4, 4);
140 }
141
142 static void test_pack_BYTE_BLOB(void)
143 {
144     /* BYTE_BLOB (pack 4) */
145     TEST_TYPE(BYTE_BLOB, 8, 4);
146     TEST_FIELD(BYTE_BLOB, unsigned long, clSize, 0, 4, 4);
147     TEST_FIELD(BYTE_BLOB, byte[1], abData, 4, 1, 1);
148 }
149
150 static void test_pack_BYTE_SIZEDARR(void)
151 {
152     /* BYTE_SIZEDARR (pack 4) */
153     TEST_TYPE(BYTE_SIZEDARR, 8, 4);
154     TEST_FIELD(BYTE_SIZEDARR, unsigned long, clSize, 0, 4, 4);
155     TEST_FIELD(BYTE_SIZEDARR, byte *, pData, 4, 4, 4);
156 }
157
158 static void test_pack_CLIPDATA(void)
159 {
160     /* CLIPDATA (pack 4) */
161     TEST_TYPE(CLIPDATA, 12, 4);
162     TEST_FIELD(CLIPDATA, ULONG, cbSize, 0, 4, 4);
163     TEST_FIELD(CLIPDATA, long, ulClipFmt, 4, 4, 4);
164     TEST_FIELD(CLIPDATA, BYTE *, pClipData, 8, 4, 4);
165 }
166
167 static void test_pack_CLIPFORMAT(void)
168 {
169     /* CLIPFORMAT */
170     TEST_TYPE(CLIPFORMAT, 2, 2);
171     TEST_TYPE_UNSIGNED(CLIPFORMAT);
172 }
173
174 static void test_pack_COAUTHIDENTITY(void)
175 {
176     /* COAUTHIDENTITY (pack 4) */
177     TEST_TYPE(COAUTHIDENTITY, 28, 4);
178     TEST_FIELD(COAUTHIDENTITY, USHORT *, User, 0, 4, 4);
179     TEST_FIELD(COAUTHIDENTITY, ULONG, UserLength, 4, 4, 4);
180     TEST_FIELD(COAUTHIDENTITY, USHORT *, Domain, 8, 4, 4);
181     TEST_FIELD(COAUTHIDENTITY, ULONG, DomainLength, 12, 4, 4);
182     TEST_FIELD(COAUTHIDENTITY, USHORT *, Password, 16, 4, 4);
183     TEST_FIELD(COAUTHIDENTITY, ULONG, PasswordLength, 20, 4, 4);
184     TEST_FIELD(COAUTHIDENTITY, ULONG, Flags, 24, 4, 4);
185 }
186
187 static void test_pack_COAUTHINFO(void)
188 {
189     /* COAUTHINFO (pack 4) */
190     TEST_TYPE(COAUTHINFO, 28, 4);
191     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnSvc, 0, 4, 4);
192     TEST_FIELD(COAUTHINFO, DWORD, dwAuthzSvc, 4, 4, 4);
193     TEST_FIELD(COAUTHINFO, LPWSTR, pwszServerPrincName, 8, 4, 4);
194     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnLevel, 12, 4, 4);
195     TEST_FIELD(COAUTHINFO, DWORD, dwImpersonationLevel, 16, 4, 4);
196     TEST_FIELD(COAUTHINFO, COAUTHIDENTITY *, pAuthIdentityData, 20, 4, 4);
197     TEST_FIELD(COAUTHINFO, DWORD, dwCapabilities, 24, 4, 4);
198 }
199
200 static void test_pack_COSERVERINFO(void)
201 {
202     /* COSERVERINFO (pack 4) */
203     TEST_TYPE(COSERVERINFO, 16, 4);
204     TEST_FIELD(COSERVERINFO, DWORD, dwReserved1, 0, 4, 4);
205     TEST_FIELD(COSERVERINFO, LPWSTR, pwszName, 4, 4, 4);
206     TEST_FIELD(COSERVERINFO, COAUTHINFO *, pAuthInfo, 8, 4, 4);
207     TEST_FIELD(COSERVERINFO, DWORD, dwReserved2, 12, 4, 4);
208 }
209
210 static void test_pack_DWORD_SIZEDARR(void)
211 {
212     /* DWORD_SIZEDARR (pack 4) */
213     TEST_TYPE(DWORD_SIZEDARR, 8, 4);
214     TEST_FIELD(DWORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
215     TEST_FIELD(DWORD_SIZEDARR, unsigned long *, pData, 4, 4, 4);
216 }
217
218 static void test_pack_FLAGGED_BYTE_BLOB(void)
219 {
220     /* FLAGGED_BYTE_BLOB (pack 4) */
221     TEST_TYPE(FLAGGED_BYTE_BLOB, 12, 4);
222     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, fFlags, 0, 4, 4);
223     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, clSize, 4, 4, 4);
224     TEST_FIELD(FLAGGED_BYTE_BLOB, byte[1], abData, 8, 1, 1);
225 }
226
227 static void test_pack_FLAGGED_WORD_BLOB(void)
228 {
229     /* FLAGGED_WORD_BLOB (pack 4) */
230     TEST_TYPE(FLAGGED_WORD_BLOB, 12, 4);
231     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, fFlags, 0, 4, 4);
232     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, clSize, 4, 4, 4);
233     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned short[1], asData, 8, 2, 2);
234 }
235
236 static void test_pack_HMETAFILEPICT(void)
237 {
238     /* HMETAFILEPICT */
239     TEST_TYPE(HMETAFILEPICT, 4, 4);
240 }
241
242 static void test_pack_HYPER_SIZEDARR(void)
243 {
244     /* HYPER_SIZEDARR (pack 4) */
245     TEST_TYPE(HYPER_SIZEDARR, 8, 4);
246     TEST_FIELD(HYPER_SIZEDARR, unsigned long, clSize, 0, 4, 4);
247     TEST_FIELD(HYPER_SIZEDARR, hyper *, pData, 4, 4, 4);
248 }
249
250 static void test_pack_LPBLOB(void)
251 {
252     /* LPBLOB */
253     TEST_TYPE(LPBLOB, 4, 4);
254     TEST_TYPE_POINTER(LPBLOB, 8, 4);
255 }
256
257 static void test_pack_LPBSTR(void)
258 {
259     /* LPBSTR */
260     TEST_TYPE(LPBSTR, 4, 4);
261     TEST_TYPE_POINTER(LPBSTR, 4, 4);
262 }
263
264 static void test_pack_LPBSTRBLOB(void)
265 {
266     /* LPBSTRBLOB */
267     TEST_TYPE(LPBSTRBLOB, 4, 4);
268     TEST_TYPE_POINTER(LPBSTRBLOB, 8, 4);
269 }
270
271 static void test_pack_LPCOLESTR(void)
272 {
273     /* LPCOLESTR */
274     TEST_TYPE(LPCOLESTR, 4, 4);
275     TEST_TYPE_POINTER(LPCOLESTR, 2, 2);
276 }
277
278 static void test_pack_LPCY(void)
279 {
280     /* LPCY */
281     TEST_TYPE(LPCY, 4, 4);
282 }
283
284 static void test_pack_LPDECIMAL(void)
285 {
286     /* LPDECIMAL */
287     TEST_TYPE(LPDECIMAL, 4, 4);
288 }
289
290 static void test_pack_LPOLESTR(void)
291 {
292     /* LPOLESTR */
293     TEST_TYPE(LPOLESTR, 4, 4);
294     TEST_TYPE_POINTER(LPOLESTR, 2, 2);
295 }
296
297 static void test_pack_OLECHAR(void)
298 {
299     /* OLECHAR */
300     TEST_TYPE(OLECHAR, 2, 2);
301 }
302
303 static void test_pack_PROPID(void)
304 {
305     /* PROPID */
306     TEST_TYPE(PROPID, 4, 4);
307 }
308
309 static void test_pack_RemHBITMAP(void)
310 {
311     /* RemHBITMAP (pack 4) */
312     TEST_TYPE(RemHBITMAP, 8, 4);
313     TEST_FIELD(RemHBITMAP, unsigned long, cbData, 0, 4, 4);
314     TEST_FIELD(RemHBITMAP, byte[1], data, 4, 1, 1);
315 }
316
317 static void test_pack_RemHENHMETAFILE(void)
318 {
319     /* RemHENHMETAFILE (pack 4) */
320     TEST_TYPE(RemHENHMETAFILE, 8, 4);
321     TEST_FIELD(RemHENHMETAFILE, unsigned long, cbData, 0, 4, 4);
322     TEST_FIELD(RemHENHMETAFILE, byte[1], data, 4, 1, 1);
323 }
324
325 static void test_pack_RemHGLOBAL(void)
326 {
327     /* RemHGLOBAL (pack 4) */
328     TEST_TYPE(RemHGLOBAL, 12, 4);
329     TEST_FIELD(RemHGLOBAL, long, fNullHGlobal, 0, 4, 4);
330     TEST_FIELD(RemHGLOBAL, unsigned long, cbData, 4, 4, 4);
331     TEST_FIELD(RemHGLOBAL, byte[1], data, 8, 1, 1);
332 }
333
334 static void test_pack_RemHMETAFILEPICT(void)
335 {
336     /* RemHMETAFILEPICT (pack 4) */
337     TEST_TYPE(RemHMETAFILEPICT, 20, 4);
338     TEST_FIELD(RemHMETAFILEPICT, long, mm, 0, 4, 4);
339     TEST_FIELD(RemHMETAFILEPICT, long, xExt, 4, 4, 4);
340     TEST_FIELD(RemHMETAFILEPICT, long, yExt, 8, 4, 4);
341     TEST_FIELD(RemHMETAFILEPICT, unsigned long, cbData, 12, 4, 4);
342     TEST_FIELD(RemHMETAFILEPICT, byte[1], data, 16, 1, 1);
343 }
344
345 static void test_pack_RemHPALETTE(void)
346 {
347     /* RemHPALETTE (pack 4) */
348     TEST_TYPE(RemHPALETTE, 8, 4);
349     TEST_FIELD(RemHPALETTE, unsigned long, cbData, 0, 4, 4);
350     TEST_FIELD(RemHPALETTE, byte[1], data, 4, 1, 1);
351 }
352
353 static void test_pack_SCODE(void)
354 {
355     /* SCODE */
356     TEST_TYPE(SCODE, 4, 4);
357 }
358
359 static void test_pack_UP_BYTE_BLOB(void)
360 {
361     /* UP_BYTE_BLOB */
362     TEST_TYPE(UP_BYTE_BLOB, 4, 4);
363     TEST_TYPE_POINTER(UP_BYTE_BLOB, 8, 4);
364 }
365
366 static void test_pack_UP_FLAGGED_BYTE_BLOB(void)
367 {
368     /* UP_FLAGGED_BYTE_BLOB */
369     TEST_TYPE(UP_FLAGGED_BYTE_BLOB, 4, 4);
370     TEST_TYPE_POINTER(UP_FLAGGED_BYTE_BLOB, 12, 4);
371 }
372
373 static void test_pack_UP_FLAGGED_WORD_BLOB(void)
374 {
375     /* UP_FLAGGED_WORD_BLOB */
376     TEST_TYPE(UP_FLAGGED_WORD_BLOB, 4, 4);
377     TEST_TYPE_POINTER(UP_FLAGGED_WORD_BLOB, 12, 4);
378 }
379
380 static void test_pack_VARIANT_BOOL(void)
381 {
382     /* VARIANT_BOOL */
383     TEST_TYPE(VARIANT_BOOL, 2, 2);
384     TEST_TYPE_SIGNED(VARIANT_BOOL);
385 }
386
387 static void test_pack_VARTYPE(void)
388 {
389     /* VARTYPE */
390     TEST_TYPE(VARTYPE, 2, 2);
391     TEST_TYPE_UNSIGNED(VARTYPE);
392 }
393
394 static void test_pack_WORD_SIZEDARR(void)
395 {
396     /* WORD_SIZEDARR (pack 4) */
397     TEST_TYPE(WORD_SIZEDARR, 8, 4);
398     TEST_FIELD(WORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
399     TEST_FIELD(WORD_SIZEDARR, unsigned short *, pData, 4, 4, 4);
400 }
401
402 static void test_pack_remoteMETAFILEPICT(void)
403 {
404     /* remoteMETAFILEPICT (pack 4) */
405     TEST_TYPE(remoteMETAFILEPICT, 16, 4);
406     TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
407     TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
408     TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
409     TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
410 }
411
412 static void test_pack_userBITMAP(void)
413 {
414     /* userBITMAP (pack 4) */
415     TEST_TYPE(userBITMAP, 28, 4);
416     TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
417     TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
418     TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
419     TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
420     TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
421     TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
422     TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
423     TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
424 }
425
426 static void test_pack_userCLIPFORMAT(void)
427 {
428     /* userCLIPFORMAT (pack 4) */
429     TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
430 }
431
432 static void test_pack_userHBITMAP(void)
433 {
434     /* userHBITMAP (pack 4) */
435     TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
436 }
437
438 static void test_pack_userHENHMETAFILE(void)
439 {
440     /* userHENHMETAFILE (pack 4) */
441     TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
442 }
443
444 static void test_pack_userHGLOBAL(void)
445 {
446     /* userHGLOBAL (pack 4) */
447     TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
448 }
449
450 static void test_pack_userHMETAFILE(void)
451 {
452     /* userHMETAFILE (pack 4) */
453     TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
454 }
455
456 static void test_pack_userHMETAFILEPICT(void)
457 {
458     /* userHMETAFILEPICT (pack 4) */
459     TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
460 }
461
462 static void test_pack_userHPALETTE(void)
463 {
464     /* userHPALETTE (pack 4) */
465     TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
466 }
467
468 static void test_pack_wireBSTR(void)
469 {
470     /* wireBSTR */
471     TEST_TYPE(wireBSTR, 4, 4);
472     TEST_TYPE_POINTER(wireBSTR, 12, 4);
473 }
474
475 static void test_pack_wireCLIPFORMAT(void)
476 {
477     /* wireCLIPFORMAT */
478     TEST_TYPE(wireCLIPFORMAT, 4, 4);
479 }
480
481 static void test_pack_wireHBITMAP(void)
482 {
483     /* wireHBITMAP */
484     TEST_TYPE(wireHBITMAP, 4, 4);
485 }
486
487 static void test_pack_wireHENHMETAFILE(void)
488 {
489     /* wireHENHMETAFILE */
490     TEST_TYPE(wireHENHMETAFILE, 4, 4);
491 }
492
493 static void test_pack_wireHGLOBAL(void)
494 {
495     /* wireHGLOBAL */
496     TEST_TYPE(wireHGLOBAL, 4, 4);
497 }
498
499 static void test_pack_wireHMETAFILE(void)
500 {
501     /* wireHMETAFILE */
502     TEST_TYPE(wireHMETAFILE, 4, 4);
503 }
504
505 static void test_pack_wireHMETAFILEPICT(void)
506 {
507     /* wireHMETAFILEPICT */
508     TEST_TYPE(wireHMETAFILEPICT, 4, 4);
509 }
510
511 static void test_pack_wireHPALETTE(void)
512 {
513     /* wireHPALETTE */
514     TEST_TYPE(wireHPALETTE, 4, 4);
515 }
516
517 static void test_pack_CLSID(void)
518 {
519     /* CLSID */
520     TEST_TYPE(CLSID, 16, 4);
521 }
522
523 static void test_pack_FMTID(void)
524 {
525     /* FMTID */
526     TEST_TYPE(FMTID, 16, 4);
527 }
528
529 static void test_pack_GUID(void)
530 {
531     /* GUID (pack 4) */
532     TEST_TYPE(GUID, 16, 4);
533     TEST_FIELD(GUID, unsigned long, Data1, 0, 4, 4);
534     TEST_FIELD(GUID, unsigned short, Data2, 4, 2, 2);
535     TEST_FIELD(GUID, unsigned short, Data3, 6, 2, 2);
536     TEST_FIELD(GUID, unsigned char[ 8 ], Data4, 8, 8, 1);
537 }
538
539 static void test_pack_IID(void)
540 {
541     /* IID */
542     TEST_TYPE(IID, 16, 4);
543 }
544
545 static void test_pack_LPGUID(void)
546 {
547     /* LPGUID */
548     TEST_TYPE(LPGUID, 4, 4);
549     TEST_TYPE_POINTER(LPGUID, 16, 4);
550 }
551
552 static void test_pack_APPBARDATA(void)
553 {
554     /* APPBARDATA (pack 1) */
555     TEST_TYPE(APPBARDATA, 36, 1);
556     TEST_FIELD(APPBARDATA, DWORD, cbSize, 0, 4, 1);
557     TEST_FIELD(APPBARDATA, HWND, hWnd, 4, 4, 1);
558     TEST_FIELD(APPBARDATA, UINT, uCallbackMessage, 8, 4, 1);
559     TEST_FIELD(APPBARDATA, UINT, uEdge, 12, 4, 1);
560     TEST_FIELD(APPBARDATA, RECT, rc, 16, 16, 1);
561     TEST_FIELD(APPBARDATA, LPARAM, lParam, 32, 4, 1);
562 }
563
564 static void test_pack_DRAGINFOA(void)
565 {
566     /* DRAGINFOA (pack 1) */
567     TEST_TYPE(DRAGINFOA, 24, 1);
568     TEST_FIELD(DRAGINFOA, UINT, uSize, 0, 4, 1);
569     TEST_FIELD(DRAGINFOA, POINT, pt, 4, 8, 1);
570     TEST_FIELD(DRAGINFOA, BOOL, fNC, 12, 4, 1);
571     TEST_FIELD(DRAGINFOA, LPSTR, lpFileList, 16, 4, 1);
572     TEST_FIELD(DRAGINFOA, DWORD, grfKeyState, 20, 4, 1);
573 }
574
575 static void test_pack_DRAGINFOW(void)
576 {
577     /* DRAGINFOW (pack 1) */
578     TEST_TYPE(DRAGINFOW, 24, 1);
579     TEST_FIELD(DRAGINFOW, UINT, uSize, 0, 4, 1);
580     TEST_FIELD(DRAGINFOW, POINT, pt, 4, 8, 1);
581     TEST_FIELD(DRAGINFOW, BOOL, fNC, 12, 4, 1);
582     TEST_FIELD(DRAGINFOW, LPWSTR, lpFileList, 16, 4, 1);
583     TEST_FIELD(DRAGINFOW, DWORD, grfKeyState, 20, 4, 1);
584 }
585
586 static void test_pack_FILEOP_FLAGS(void)
587 {
588     /* FILEOP_FLAGS */
589     TEST_TYPE(FILEOP_FLAGS, 2, 2);
590     TEST_TYPE_UNSIGNED(FILEOP_FLAGS);
591 }
592
593 static void test_pack_LPDRAGINFOA(void)
594 {
595     /* LPDRAGINFOA */
596     TEST_TYPE(LPDRAGINFOA, 4, 4);
597     TEST_TYPE_POINTER(LPDRAGINFOA, 24, 1);
598 }
599
600 static void test_pack_LPDRAGINFOW(void)
601 {
602     /* LPDRAGINFOW */
603     TEST_TYPE(LPDRAGINFOW, 4, 4);
604     TEST_TYPE_POINTER(LPDRAGINFOW, 24, 1);
605 }
606
607 static void test_pack_LPSHFILEOPSTRUCTA(void)
608 {
609     /* LPSHFILEOPSTRUCTA */
610     TEST_TYPE(LPSHFILEOPSTRUCTA, 4, 4);
611     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTA, 30, 1);
612 }
613
614 static void test_pack_LPSHFILEOPSTRUCTW(void)
615 {
616     /* LPSHFILEOPSTRUCTW */
617     TEST_TYPE(LPSHFILEOPSTRUCTW, 4, 4);
618     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTW, 30, 1);
619 }
620
621 static void test_pack_LPSHNAMEMAPPINGA(void)
622 {
623     /* LPSHNAMEMAPPINGA */
624     TEST_TYPE(LPSHNAMEMAPPINGA, 4, 4);
625     TEST_TYPE_POINTER(LPSHNAMEMAPPINGA, 16, 1);
626 }
627
628 static void test_pack_LPSHNAMEMAPPINGW(void)
629 {
630     /* LPSHNAMEMAPPINGW */
631     TEST_TYPE(LPSHNAMEMAPPINGW, 4, 4);
632     TEST_TYPE_POINTER(LPSHNAMEMAPPINGW, 16, 1);
633 }
634
635 static void test_pack_NOTIFYICONDATAA(void)
636 {
637     /* NOTIFYICONDATAA (pack 1) */
638     TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
639     TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
640     TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
641     TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
642     TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
643     TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
644     TEST_FIELD(NOTIFYICONDATAA, CHAR[128], szTip, 24, 128, 1);
645     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwState, 152, 4, 1);
646     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwStateMask, 156, 4, 1);
647     TEST_FIELD(NOTIFYICONDATAA, CHAR[256], szInfo, 160, 256, 1);
648 }
649
650 static void test_pack_NOTIFYICONDATAW(void)
651 {
652     /* NOTIFYICONDATAW (pack 1) */
653     TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
654     TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
655     TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
656     TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
657     TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
658     TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
659     TEST_FIELD(NOTIFYICONDATAW, WCHAR[128], szTip, 24, 256, 1);
660     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwState, 280, 4, 1);
661     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwStateMask, 284, 4, 1);
662     TEST_FIELD(NOTIFYICONDATAW, WCHAR[256], szInfo, 288, 512, 1);
663 }
664
665 static void test_pack_PAPPBARDATA(void)
666 {
667     /* PAPPBARDATA */
668     TEST_TYPE(PAPPBARDATA, 4, 4);
669     TEST_TYPE_POINTER(PAPPBARDATA, 36, 1);
670 }
671
672 static void test_pack_PNOTIFYICONDATAA(void)
673 {
674     /* PNOTIFYICONDATAA */
675     TEST_TYPE(PNOTIFYICONDATAA, 4, 4);
676 }
677
678 static void test_pack_PNOTIFYICONDATAW(void)
679 {
680     /* PNOTIFYICONDATAW */
681     TEST_TYPE(PNOTIFYICONDATAW, 4, 4);
682 }
683
684 static void test_pack_PRINTEROP_FLAGS(void)
685 {
686     /* PRINTEROP_FLAGS */
687     TEST_TYPE(PRINTEROP_FLAGS, 2, 2);
688     TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS);
689 }
690
691 static void test_pack_SHFILEINFOA(void)
692 {
693     /* SHFILEINFOA (pack 1) */
694     TEST_TYPE(SHFILEINFOA, 352, 1);
695     TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
696     TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
697     TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
698     TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
699     TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
700 }
701
702 static void test_pack_SHFILEINFOW(void)
703 {
704     /* SHFILEINFOW (pack 1) */
705     TEST_TYPE(SHFILEINFOW, 692, 1);
706     TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
707     TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
708     TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
709     TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
710     TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
711 }
712
713 static void test_pack_SHFILEOPSTRUCTA(void)
714 {
715     /* SHFILEOPSTRUCTA (pack 1) */
716     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
717     TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
718     TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
719     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
720     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
721     TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
722     TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
723     TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
724     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
725 }
726
727 static void test_pack_SHFILEOPSTRUCTW(void)
728 {
729     /* SHFILEOPSTRUCTW (pack 1) */
730     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
731     TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
732     TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
733     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
734     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
735     TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
736     TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
737     TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
738     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
739 }
740
741 static void test_pack_SHNAMEMAPPINGA(void)
742 {
743     /* SHNAMEMAPPINGA (pack 1) */
744     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
745     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
746     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
747     TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
748     TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
749 }
750
751 static void test_pack_SHNAMEMAPPINGW(void)
752 {
753     /* SHNAMEMAPPINGW (pack 1) */
754     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
755     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
756     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
757     TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
758     TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
759 }
760
761 static void test_pack_AUTO_SCROLL_DATA(void)
762 {
763     /* AUTO_SCROLL_DATA (pack 1) */
764     TEST_TYPE(AUTO_SCROLL_DATA, 48, 1);
765     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 1);
766     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 1);
767     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 1);
768     TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 1);
769     TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 1);
770 }
771
772 static void test_pack_BFFCALLBACK(void)
773 {
774     /* BFFCALLBACK */
775     TEST_TYPE(BFFCALLBACK, 4, 4);
776 }
777
778 static void test_pack_CABINETSTATE(void)
779 {
780     /* CABINETSTATE (pack 1) */
781     TEST_TYPE(CABINETSTATE, 12, 1);
782     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
783     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
784     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 8, 4, 1);
785 }
786
787 static void test_pack_CIDA(void)
788 {
789     /* CIDA (pack 1) */
790     TEST_TYPE(CIDA, 8, 1);
791     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
792     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
793 }
794
795 static void test_pack_DROPFILES(void)
796 {
797     /* DROPFILES (pack 1) */
798     TEST_TYPE(DROPFILES, 20, 1);
799     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
800     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
801     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
802     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
803 }
804
805 static void test_pack_FILEDESCRIPTORA(void)
806 {
807     /* FILEDESCRIPTORA (pack 1) */
808     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
809     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
810     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
811     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
812     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
813     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
814     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
815     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
816     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
817     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
818     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
819     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
820 }
821
822 static void test_pack_FILEDESCRIPTORW(void)
823 {
824     /* FILEDESCRIPTORW (pack 1) */
825     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
826     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
827     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
828     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
829     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
830     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
831     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
832     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
833     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
834     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
835     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
836     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
837 }
838
839 static void test_pack_FILEGROUPDESCRIPTORA(void)
840 {
841     /* FILEGROUPDESCRIPTORA (pack 1) */
842     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
843     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
844     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
845 }
846
847 static void test_pack_FILEGROUPDESCRIPTORW(void)
848 {
849     /* FILEGROUPDESCRIPTORW (pack 1) */
850     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
851     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
852     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
853 }
854
855 static void test_pack_IFileSystemBindData(void)
856 {
857     /* IFileSystemBindData */
858 }
859
860 static void test_pack_IFileSystemBindDataVtbl(void)
861 {
862     /* IFileSystemBindDataVtbl */
863 }
864
865 static void test_pack_IShellChangeNotify(void)
866 {
867     /* IShellChangeNotify */
868 }
869
870 static void test_pack_IShellIcon(void)
871 {
872     /* IShellIcon */
873 }
874
875 static void test_pack_LPCABINETSTATE(void)
876 {
877     /* LPCABINETSTATE */
878     TEST_TYPE(LPCABINETSTATE, 4, 4);
879     TEST_TYPE_POINTER(LPCABINETSTATE, 12, 1);
880 }
881
882 static void test_pack_LPDROPFILES(void)
883 {
884     /* LPDROPFILES */
885     TEST_TYPE(LPDROPFILES, 4, 4);
886     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
887 }
888
889 static void test_pack_LPFILEDESCRIPTORA(void)
890 {
891     /* LPFILEDESCRIPTORA */
892     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
893     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
894 }
895
896 static void test_pack_LPFILEDESCRIPTORW(void)
897 {
898     /* LPFILEDESCRIPTORW */
899     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
900     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
901 }
902
903 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
904 {
905     /* LPFILEGROUPDESCRIPTORA */
906     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
907     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
908 }
909
910 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
911 {
912     /* LPFILEGROUPDESCRIPTORW */
913     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
914     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
915 }
916
917 static void test_pack_LPIDA(void)
918 {
919     /* LPIDA */
920     TEST_TYPE(LPIDA, 4, 4);
921     TEST_TYPE_POINTER(LPIDA, 8, 1);
922 }
923
924 static void test_pack_LPSHChangeDWORDAsIDList(void)
925 {
926     /* LPSHChangeDWORDAsIDList */
927     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
928     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
929 }
930
931 static void test_pack_LPSHChangeProductKeyAsIDList(void)
932 {
933     /* LPSHChangeProductKeyAsIDList */
934     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
935     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
936 }
937
938 static void test_pack_LPSHDESCRIPTIONID(void)
939 {
940     /* LPSHDESCRIPTIONID */
941     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
942     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 4);
943 }
944
945 static void test_pack_LPSHELLFLAGSTATE(void)
946 {
947     /* LPSHELLFLAGSTATE */
948     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
949     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 4, 1);
950 }
951
952 static void test_pack_LPSHELLSTATE(void)
953 {
954     /* LPSHELLSTATE */
955     TEST_TYPE(LPSHELLSTATE, 4, 4);
956     TEST_TYPE_POINTER(LPSHELLSTATE, 32, 1);
957 }
958
959 static void test_pack_SHChangeDWORDAsIDList(void)
960 {
961     /* SHChangeDWORDAsIDList (pack 1) */
962     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
963     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
964     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
965     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
966     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
967 }
968
969 static void test_pack_SHChangeNotifyEntry(void)
970 {
971     /* SHChangeNotifyEntry (pack 1) */
972 }
973
974 static void test_pack_SHChangeProductKeyAsIDList(void)
975 {
976     /* SHChangeProductKeyAsIDList (pack 1) */
977     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
978     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
979     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
980     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
981 }
982
983 static void test_pack_SHDESCRIPTIONID(void)
984 {
985     /* SHDESCRIPTIONID (pack 1) */
986     TEST_TYPE(SHDESCRIPTIONID, 20, 4);
987     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 4);
988     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 4);
989 }
990
991 static void test_pack_SHELLFLAGSTATE(void)
992 {
993     /* SHELLFLAGSTATE (pack 1) */
994     TEST_TYPE(SHELLFLAGSTATE, 4, 1);
995 }
996
997 static void test_pack_SHELLSTATE(void)
998 {
999     /* SHELLSTATE (pack 1) */
1000     TEST_TYPE(SHELLSTATE, 32, 1);
1001     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 4, 4, 1);
1002     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 8, 4, 1);
1003     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 12, 4, 1);
1004     TEST_FIELD(SHELLSTATE, int, iSortDirection, 16, 4, 1);
1005     TEST_FIELD(SHELLSTATE, UINT, version, 20, 4, 1);
1006     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 24, 4, 1);
1007 }
1008
1009 static void test_pack_SHELLVIEWID(void)
1010 {
1011     /* SHELLVIEWID */
1012     TEST_TYPE(SHELLVIEWID, 16, 4);
1013 }
1014
1015 static void test_pack_SHELLVIEWPROC(void)
1016 {
1017     /* SHELLVIEWPROC */
1018     TEST_TYPE(SHELLVIEWPROC, 4, 4);
1019 }
1020
1021 static void test_pack(void)
1022 {
1023     test_pack_APPBARDATA();
1024     test_pack_AUTO_SCROLL_DATA();
1025     test_pack_BFFCALLBACK();
1026     test_pack_BLOB();
1027     test_pack_BSTR();
1028     test_pack_BSTRBLOB();
1029     test_pack_BYTE_BLOB();
1030     test_pack_BYTE_SIZEDARR();
1031     test_pack_CABINETSTATE();
1032     test_pack_CIDA();
1033     test_pack_CLIPDATA();
1034     test_pack_CLIPFORMAT();
1035     test_pack_CLSID();
1036     test_pack_COAUTHIDENTITY();
1037     test_pack_COAUTHINFO();
1038     test_pack_COSERVERINFO();
1039     test_pack_DRAGINFOA();
1040     test_pack_DRAGINFOW();
1041     test_pack_DROPFILES();
1042     test_pack_DWORD_SIZEDARR();
1043     test_pack_FILEDESCRIPTORA();
1044     test_pack_FILEDESCRIPTORW();
1045     test_pack_FILEGROUPDESCRIPTORA();
1046     test_pack_FILEGROUPDESCRIPTORW();
1047     test_pack_FILEOP_FLAGS();
1048     test_pack_FLAGGED_BYTE_BLOB();
1049     test_pack_FLAGGED_WORD_BLOB();
1050     test_pack_FMTID();
1051     test_pack_GUID();
1052     test_pack_HMETAFILEPICT();
1053     test_pack_HYPER_SIZEDARR();
1054     test_pack_IFileSystemBindData();
1055     test_pack_IFileSystemBindDataVtbl();
1056     test_pack_IID();
1057     test_pack_IShellChangeNotify();
1058     test_pack_IShellIcon();
1059     test_pack_LPBLOB();
1060     test_pack_LPBSTR();
1061     test_pack_LPBSTRBLOB();
1062     test_pack_LPCABINETSTATE();
1063     test_pack_LPCOLESTR();
1064     test_pack_LPCY();
1065     test_pack_LPDECIMAL();
1066     test_pack_LPDRAGINFOA();
1067     test_pack_LPDRAGINFOW();
1068     test_pack_LPDROPFILES();
1069     test_pack_LPFILEDESCRIPTORA();
1070     test_pack_LPFILEDESCRIPTORW();
1071     test_pack_LPFILEGROUPDESCRIPTORA();
1072     test_pack_LPFILEGROUPDESCRIPTORW();
1073     test_pack_LPGUID();
1074     test_pack_LPIDA();
1075     test_pack_LPOLESTR();
1076     test_pack_LPSHChangeDWORDAsIDList();
1077     test_pack_LPSHChangeProductKeyAsIDList();
1078     test_pack_LPSHDESCRIPTIONID();
1079     test_pack_LPSHELLFLAGSTATE();
1080     test_pack_LPSHELLSTATE();
1081     test_pack_LPSHFILEOPSTRUCTA();
1082     test_pack_LPSHFILEOPSTRUCTW();
1083     test_pack_LPSHNAMEMAPPINGA();
1084     test_pack_LPSHNAMEMAPPINGW();
1085     test_pack_NOTIFYICONDATAA();
1086     test_pack_NOTIFYICONDATAW();
1087     test_pack_OLECHAR();
1088     test_pack_PAPPBARDATA();
1089     test_pack_PNOTIFYICONDATAA();
1090     test_pack_PNOTIFYICONDATAW();
1091     test_pack_PRINTEROP_FLAGS();
1092     test_pack_PROPID();
1093     test_pack_RemHBITMAP();
1094     test_pack_RemHENHMETAFILE();
1095     test_pack_RemHGLOBAL();
1096     test_pack_RemHMETAFILEPICT();
1097     test_pack_RemHPALETTE();
1098     test_pack_SCODE();
1099     test_pack_SHChangeDWORDAsIDList();
1100     test_pack_SHChangeNotifyEntry();
1101     test_pack_SHChangeProductKeyAsIDList();
1102     test_pack_SHDESCRIPTIONID();
1103     test_pack_SHELLFLAGSTATE();
1104     test_pack_SHELLSTATE();
1105     test_pack_SHELLVIEWID();
1106     test_pack_SHELLVIEWPROC();
1107     test_pack_SHFILEINFOA();
1108     test_pack_SHFILEINFOW();
1109     test_pack_SHFILEOPSTRUCTA();
1110     test_pack_SHFILEOPSTRUCTW();
1111     test_pack_SHNAMEMAPPINGA();
1112     test_pack_SHNAMEMAPPINGW();
1113     test_pack_UP_BYTE_BLOB();
1114     test_pack_UP_FLAGGED_BYTE_BLOB();
1115     test_pack_UP_FLAGGED_WORD_BLOB();
1116     test_pack_VARIANT_BOOL();
1117     test_pack_VARTYPE();
1118     test_pack_WORD_SIZEDARR();
1119     test_pack_remoteMETAFILEPICT();
1120     test_pack_userBITMAP();
1121     test_pack_userCLIPFORMAT();
1122     test_pack_userHBITMAP();
1123     test_pack_userHENHMETAFILE();
1124     test_pack_userHGLOBAL();
1125     test_pack_userHMETAFILE();
1126     test_pack_userHMETAFILEPICT();
1127     test_pack_userHPALETTE();
1128     test_pack_wireBSTR();
1129     test_pack_wireCLIPFORMAT();
1130     test_pack_wireHBITMAP();
1131     test_pack_wireHENHMETAFILE();
1132     test_pack_wireHGLOBAL();
1133     test_pack_wireHMETAFILE();
1134     test_pack_wireHMETAFILEPICT();
1135     test_pack_wireHPALETTE();
1136 }
1137
1138 START_TEST(generated)
1139 {
1140     test_pack();
1141 }