Update shell32's version to WinXP level.
[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(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
58 #pragma warning(disable:4116)
59 #endif
60
61 #if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
62 # define TYPE_ALIGNMENT _TYPE_ALIGNMENT
63 #endif
64
65 /***********************************************************************
66  * Test helper macros
67  */
68
69 #ifdef FIELD_ALIGNMENT
70 # define TEST_FIELD_ALIGNMENT(type, field, align) \
71    ok(FIELD_ALIGNMENT(type, field) == align, \
72        "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
73            FIELD_ALIGNMENT(type, field))
74 #else
75 # define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
76 #endif
77
78 #define TEST_FIELD_OFFSET(type, field, offset) \
79     ok(FIELD_OFFSET(type, field) == offset, \
80         "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
81              FIELD_OFFSET(type, field))
82
83 #ifdef _TYPE_ALIGNMENT
84 #define TEST__TYPE_ALIGNMENT(type, align) \
85     ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", _TYPE_ALIGNMENT(type))
86 #else
87 # define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
88 #endif
89
90 #ifdef TYPE_ALIGNMENT
91 #define TEST_TYPE_ALIGNMENT(type, align) \
92     ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", TYPE_ALIGNMENT(type))
93 #else
94 # define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
95 #endif
96
97 #define TEST_TYPE_SIZE(type, size) \
98     ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", sizeof(type))
99
100 /***********************************************************************
101  * Test macros
102  */
103
104 #define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
105   TEST_TYPE_SIZE(field_type, field_size); \
106   TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
107   TEST_FIELD_OFFSET(type, field_name, field_offset); \
108
109 #define TEST_TYPE(type, size, align) \
110   TEST_TYPE_ALIGNMENT(type, align); \
111   TEST_TYPE_SIZE(type, size)
112
113 #define TEST_TYPE_POINTER(type, size, align) \
114     TEST__TYPE_ALIGNMENT(*(type)0, align); \
115     TEST_TYPE_SIZE(*(type)0, size)
116
117 #define TEST_TYPE_SIGNED(type) \
118     ok((type) -1 < 0, "(" #type ") -1 < 0\n");
119
120 #define TEST_TYPE_UNSIGNED(type) \
121      ok((type) -1 > 0, "(" #type ") -1 > 0\n");
122
123 static void test_pack_BLOB(void)
124 {
125     /* BLOB (pack 4) */
126     TEST_TYPE(BLOB, 8, 4);
127     TEST_FIELD(BLOB, ULONG, cbSize, 0, 4, 4);
128     TEST_FIELD(BLOB, BYTE *, pBlobData, 4, 4, 4);
129 }
130
131 static void test_pack_BSTR(void)
132 {
133     /* BSTR */
134     TEST_TYPE(BSTR, 4, 4);
135     TEST_TYPE_POINTER(BSTR, 2, 2);
136 }
137
138 static void test_pack_BSTRBLOB(void)
139 {
140     /* BSTRBLOB (pack 4) */
141     TEST_TYPE(BSTRBLOB, 8, 4);
142     TEST_FIELD(BSTRBLOB, ULONG, cbSize, 0, 4, 4);
143     TEST_FIELD(BSTRBLOB, BYTE *, pData, 4, 4, 4);
144 }
145
146 static void test_pack_BYTE_BLOB(void)
147 {
148     /* BYTE_BLOB (pack 4) */
149     TEST_TYPE(BYTE_BLOB, 8, 4);
150     TEST_FIELD(BYTE_BLOB, unsigned long, clSize, 0, 4, 4);
151     TEST_FIELD(BYTE_BLOB, byte[1], abData, 4, 1, 1);
152 }
153
154 static void test_pack_BYTE_SIZEDARR(void)
155 {
156     /* BYTE_SIZEDARR (pack 4) */
157     TEST_TYPE(BYTE_SIZEDARR, 8, 4);
158     TEST_FIELD(BYTE_SIZEDARR, unsigned long, clSize, 0, 4, 4);
159     TEST_FIELD(BYTE_SIZEDARR, byte *, pData, 4, 4, 4);
160 }
161
162 static void test_pack_CLIPDATA(void)
163 {
164     /* CLIPDATA (pack 4) */
165     TEST_TYPE(CLIPDATA, 12, 4);
166     TEST_FIELD(CLIPDATA, ULONG, cbSize, 0, 4, 4);
167     TEST_FIELD(CLIPDATA, long, ulClipFmt, 4, 4, 4);
168     TEST_FIELD(CLIPDATA, BYTE *, pClipData, 8, 4, 4);
169 }
170
171 static void test_pack_CLIPFORMAT(void)
172 {
173     /* CLIPFORMAT */
174     TEST_TYPE(CLIPFORMAT, 2, 2);
175     TEST_TYPE_UNSIGNED(CLIPFORMAT);
176 }
177
178 static void test_pack_COAUTHIDENTITY(void)
179 {
180     /* COAUTHIDENTITY (pack 4) */
181     TEST_TYPE(COAUTHIDENTITY, 28, 4);
182     TEST_FIELD(COAUTHIDENTITY, USHORT *, User, 0, 4, 4);
183     TEST_FIELD(COAUTHIDENTITY, ULONG, UserLength, 4, 4, 4);
184     TEST_FIELD(COAUTHIDENTITY, USHORT *, Domain, 8, 4, 4);
185     TEST_FIELD(COAUTHIDENTITY, ULONG, DomainLength, 12, 4, 4);
186     TEST_FIELD(COAUTHIDENTITY, USHORT *, Password, 16, 4, 4);
187     TEST_FIELD(COAUTHIDENTITY, ULONG, PasswordLength, 20, 4, 4);
188     TEST_FIELD(COAUTHIDENTITY, ULONG, Flags, 24, 4, 4);
189 }
190
191 static void test_pack_COAUTHINFO(void)
192 {
193     /* COAUTHINFO (pack 4) */
194     TEST_TYPE(COAUTHINFO, 28, 4);
195     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnSvc, 0, 4, 4);
196     TEST_FIELD(COAUTHINFO, DWORD, dwAuthzSvc, 4, 4, 4);
197     TEST_FIELD(COAUTHINFO, LPWSTR, pwszServerPrincName, 8, 4, 4);
198     TEST_FIELD(COAUTHINFO, DWORD, dwAuthnLevel, 12, 4, 4);
199     TEST_FIELD(COAUTHINFO, DWORD, dwImpersonationLevel, 16, 4, 4);
200     TEST_FIELD(COAUTHINFO, COAUTHIDENTITY *, pAuthIdentityData, 20, 4, 4);
201     TEST_FIELD(COAUTHINFO, DWORD, dwCapabilities, 24, 4, 4);
202 }
203
204 static void test_pack_COSERVERINFO(void)
205 {
206     /* COSERVERINFO (pack 4) */
207     TEST_TYPE(COSERVERINFO, 16, 4);
208     TEST_FIELD(COSERVERINFO, DWORD, dwReserved1, 0, 4, 4);
209     TEST_FIELD(COSERVERINFO, LPWSTR, pwszName, 4, 4, 4);
210     TEST_FIELD(COSERVERINFO, COAUTHINFO *, pAuthInfo, 8, 4, 4);
211     TEST_FIELD(COSERVERINFO, DWORD, dwReserved2, 12, 4, 4);
212 }
213
214 static void test_pack_DWORD_SIZEDARR(void)
215 {
216     /* DWORD_SIZEDARR (pack 4) */
217     TEST_TYPE(DWORD_SIZEDARR, 8, 4);
218     TEST_FIELD(DWORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
219     TEST_FIELD(DWORD_SIZEDARR, unsigned long *, pData, 4, 4, 4);
220 }
221
222 static void test_pack_FLAGGED_BYTE_BLOB(void)
223 {
224     /* FLAGGED_BYTE_BLOB (pack 4) */
225     TEST_TYPE(FLAGGED_BYTE_BLOB, 12, 4);
226     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, fFlags, 0, 4, 4);
227     TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, clSize, 4, 4, 4);
228     TEST_FIELD(FLAGGED_BYTE_BLOB, byte[1], abData, 8, 1, 1);
229 }
230
231 static void test_pack_FLAGGED_WORD_BLOB(void)
232 {
233     /* FLAGGED_WORD_BLOB (pack 4) */
234     TEST_TYPE(FLAGGED_WORD_BLOB, 12, 4);
235     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, fFlags, 0, 4, 4);
236     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, clSize, 4, 4, 4);
237     TEST_FIELD(FLAGGED_WORD_BLOB, unsigned short[1], asData, 8, 2, 2);
238 }
239
240 static void test_pack_HMETAFILEPICT(void)
241 {
242     /* HMETAFILEPICT */
243     TEST_TYPE(HMETAFILEPICT, 4, 4);
244 }
245
246 static void test_pack_HYPER_SIZEDARR(void)
247 {
248     /* HYPER_SIZEDARR (pack 4) */
249     TEST_TYPE(HYPER_SIZEDARR, 8, 4);
250     TEST_FIELD(HYPER_SIZEDARR, unsigned long, clSize, 0, 4, 4);
251     TEST_FIELD(HYPER_SIZEDARR, hyper *, pData, 4, 4, 4);
252 }
253
254 static void test_pack_LPBLOB(void)
255 {
256     /* LPBLOB */
257     TEST_TYPE(LPBLOB, 4, 4);
258     TEST_TYPE_POINTER(LPBLOB, 8, 4);
259 }
260
261 static void test_pack_LPBSTR(void)
262 {
263     /* LPBSTR */
264     TEST_TYPE(LPBSTR, 4, 4);
265     TEST_TYPE_POINTER(LPBSTR, 4, 4);
266 }
267
268 static void test_pack_LPBSTRBLOB(void)
269 {
270     /* LPBSTRBLOB */
271     TEST_TYPE(LPBSTRBLOB, 4, 4);
272     TEST_TYPE_POINTER(LPBSTRBLOB, 8, 4);
273 }
274
275 static void test_pack_LPCOLESTR(void)
276 {
277     /* LPCOLESTR */
278     TEST_TYPE(LPCOLESTR, 4, 4);
279     TEST_TYPE_POINTER(LPCOLESTR, 2, 2);
280 }
281
282 static void test_pack_LPCY(void)
283 {
284     /* LPCY */
285     TEST_TYPE(LPCY, 4, 4);
286 }
287
288 static void test_pack_LPDECIMAL(void)
289 {
290     /* LPDECIMAL */
291     TEST_TYPE(LPDECIMAL, 4, 4);
292 }
293
294 static void test_pack_LPOLESTR(void)
295 {
296     /* LPOLESTR */
297     TEST_TYPE(LPOLESTR, 4, 4);
298     TEST_TYPE_POINTER(LPOLESTR, 2, 2);
299 }
300
301 static void test_pack_OLECHAR(void)
302 {
303     /* OLECHAR */
304     TEST_TYPE(OLECHAR, 2, 2);
305 }
306
307 static void test_pack_PROPID(void)
308 {
309     /* PROPID */
310     TEST_TYPE(PROPID, 4, 4);
311 }
312
313 static void test_pack_RemHBITMAP(void)
314 {
315     /* RemHBITMAP (pack 4) */
316     TEST_TYPE(RemHBITMAP, 8, 4);
317     TEST_FIELD(RemHBITMAP, unsigned long, cbData, 0, 4, 4);
318     TEST_FIELD(RemHBITMAP, byte[1], data, 4, 1, 1);
319 }
320
321 static void test_pack_RemHENHMETAFILE(void)
322 {
323     /* RemHENHMETAFILE (pack 4) */
324     TEST_TYPE(RemHENHMETAFILE, 8, 4);
325     TEST_FIELD(RemHENHMETAFILE, unsigned long, cbData, 0, 4, 4);
326     TEST_FIELD(RemHENHMETAFILE, byte[1], data, 4, 1, 1);
327 }
328
329 static void test_pack_RemHGLOBAL(void)
330 {
331     /* RemHGLOBAL (pack 4) */
332     TEST_TYPE(RemHGLOBAL, 12, 4);
333     TEST_FIELD(RemHGLOBAL, long, fNullHGlobal, 0, 4, 4);
334     TEST_FIELD(RemHGLOBAL, unsigned long, cbData, 4, 4, 4);
335     TEST_FIELD(RemHGLOBAL, byte[1], data, 8, 1, 1);
336 }
337
338 static void test_pack_RemHMETAFILEPICT(void)
339 {
340     /* RemHMETAFILEPICT (pack 4) */
341     TEST_TYPE(RemHMETAFILEPICT, 20, 4);
342     TEST_FIELD(RemHMETAFILEPICT, long, mm, 0, 4, 4);
343     TEST_FIELD(RemHMETAFILEPICT, long, xExt, 4, 4, 4);
344     TEST_FIELD(RemHMETAFILEPICT, long, yExt, 8, 4, 4);
345     TEST_FIELD(RemHMETAFILEPICT, unsigned long, cbData, 12, 4, 4);
346     TEST_FIELD(RemHMETAFILEPICT, byte[1], data, 16, 1, 1);
347 }
348
349 static void test_pack_RemHPALETTE(void)
350 {
351     /* RemHPALETTE (pack 4) */
352     TEST_TYPE(RemHPALETTE, 8, 4);
353     TEST_FIELD(RemHPALETTE, unsigned long, cbData, 0, 4, 4);
354     TEST_FIELD(RemHPALETTE, byte[1], data, 4, 1, 1);
355 }
356
357 static void test_pack_SCODE(void)
358 {
359     /* SCODE */
360     TEST_TYPE(SCODE, 4, 4);
361 }
362
363 static void test_pack_UP_BYTE_BLOB(void)
364 {
365     /* UP_BYTE_BLOB */
366     TEST_TYPE(UP_BYTE_BLOB, 4, 4);
367     TEST_TYPE_POINTER(UP_BYTE_BLOB, 8, 4);
368 }
369
370 static void test_pack_UP_FLAGGED_BYTE_BLOB(void)
371 {
372     /* UP_FLAGGED_BYTE_BLOB */
373     TEST_TYPE(UP_FLAGGED_BYTE_BLOB, 4, 4);
374     TEST_TYPE_POINTER(UP_FLAGGED_BYTE_BLOB, 12, 4);
375 }
376
377 static void test_pack_UP_FLAGGED_WORD_BLOB(void)
378 {
379     /* UP_FLAGGED_WORD_BLOB */
380     TEST_TYPE(UP_FLAGGED_WORD_BLOB, 4, 4);
381     TEST_TYPE_POINTER(UP_FLAGGED_WORD_BLOB, 12, 4);
382 }
383
384 static void test_pack_VARIANT_BOOL(void)
385 {
386     /* VARIANT_BOOL */
387     TEST_TYPE(VARIANT_BOOL, 2, 2);
388     TEST_TYPE_SIGNED(VARIANT_BOOL);
389 }
390
391 static void test_pack_VARTYPE(void)
392 {
393     /* VARTYPE */
394     TEST_TYPE(VARTYPE, 2, 2);
395     TEST_TYPE_UNSIGNED(VARTYPE);
396 }
397
398 static void test_pack_WORD_SIZEDARR(void)
399 {
400     /* WORD_SIZEDARR (pack 4) */
401     TEST_TYPE(WORD_SIZEDARR, 8, 4);
402     TEST_FIELD(WORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
403     TEST_FIELD(WORD_SIZEDARR, unsigned short *, pData, 4, 4, 4);
404 }
405
406 static void test_pack_remoteMETAFILEPICT(void)
407 {
408     /* remoteMETAFILEPICT (pack 4) */
409     TEST_TYPE(remoteMETAFILEPICT, 16, 4);
410     TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
411     TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
412     TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
413     TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
414 }
415
416 static void test_pack_userBITMAP(void)
417 {
418     /* userBITMAP (pack 4) */
419     TEST_TYPE(userBITMAP, 28, 4);
420     TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
421     TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
422     TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
423     TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
424     TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
425     TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
426     TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
427     TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
428 }
429
430 static void test_pack_userCLIPFORMAT(void)
431 {
432     /* userCLIPFORMAT (pack 4) */
433     TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
434 }
435
436 static void test_pack_userHBITMAP(void)
437 {
438     /* userHBITMAP (pack 4) */
439     TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
440 }
441
442 static void test_pack_userHENHMETAFILE(void)
443 {
444     /* userHENHMETAFILE (pack 4) */
445     TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
446 }
447
448 static void test_pack_userHGLOBAL(void)
449 {
450     /* userHGLOBAL (pack 4) */
451     TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
452 }
453
454 static void test_pack_userHMETAFILE(void)
455 {
456     /* userHMETAFILE (pack 4) */
457     TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
458 }
459
460 static void test_pack_userHMETAFILEPICT(void)
461 {
462     /* userHMETAFILEPICT (pack 4) */
463     TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
464 }
465
466 static void test_pack_userHPALETTE(void)
467 {
468     /* userHPALETTE (pack 4) */
469     TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
470 }
471
472 static void test_pack_wireBSTR(void)
473 {
474     /* wireBSTR */
475     TEST_TYPE(wireBSTR, 4, 4);
476     TEST_TYPE_POINTER(wireBSTR, 12, 4);
477 }
478
479 static void test_pack_wireCLIPFORMAT(void)
480 {
481     /* wireCLIPFORMAT */
482     TEST_TYPE(wireCLIPFORMAT, 4, 4);
483 }
484
485 static void test_pack_wireHBITMAP(void)
486 {
487     /* wireHBITMAP */
488     TEST_TYPE(wireHBITMAP, 4, 4);
489 }
490
491 static void test_pack_wireHENHMETAFILE(void)
492 {
493     /* wireHENHMETAFILE */
494     TEST_TYPE(wireHENHMETAFILE, 4, 4);
495 }
496
497 static void test_pack_wireHGLOBAL(void)
498 {
499     /* wireHGLOBAL */
500     TEST_TYPE(wireHGLOBAL, 4, 4);
501 }
502
503 static void test_pack_wireHMETAFILE(void)
504 {
505     /* wireHMETAFILE */
506     TEST_TYPE(wireHMETAFILE, 4, 4);
507 }
508
509 static void test_pack_wireHMETAFILEPICT(void)
510 {
511     /* wireHMETAFILEPICT */
512     TEST_TYPE(wireHMETAFILEPICT, 4, 4);
513 }
514
515 static void test_pack_wireHPALETTE(void)
516 {
517     /* wireHPALETTE */
518     TEST_TYPE(wireHPALETTE, 4, 4);
519 }
520
521 static void test_pack_CLSID(void)
522 {
523     /* CLSID */
524     TEST_TYPE(CLSID, 16, 4);
525 }
526
527 static void test_pack_FMTID(void)
528 {
529     /* FMTID */
530     TEST_TYPE(FMTID, 16, 4);
531 }
532
533 static void test_pack_GUID(void)
534 {
535     /* GUID (pack 4) */
536     TEST_TYPE(GUID, 16, 4);
537     TEST_FIELD(GUID, unsigned long, Data1, 0, 4, 4);
538     TEST_FIELD(GUID, unsigned short, Data2, 4, 2, 2);
539     TEST_FIELD(GUID, unsigned short, Data3, 6, 2, 2);
540     TEST_FIELD(GUID, unsigned char[ 8 ], Data4, 8, 8, 1);
541 }
542
543 static void test_pack_IID(void)
544 {
545     /* IID */
546     TEST_TYPE(IID, 16, 4);
547 }
548
549 static void test_pack_LPGUID(void)
550 {
551     /* LPGUID */
552     TEST_TYPE(LPGUID, 4, 4);
553     TEST_TYPE_POINTER(LPGUID, 16, 4);
554 }
555
556 static void test_pack_APPBARDATA(void)
557 {
558     /* APPBARDATA (pack 1) */
559     TEST_TYPE(APPBARDATA, 36, 1);
560     TEST_FIELD(APPBARDATA, DWORD, cbSize, 0, 4, 1);
561     TEST_FIELD(APPBARDATA, HWND, hWnd, 4, 4, 1);
562     TEST_FIELD(APPBARDATA, UINT, uCallbackMessage, 8, 4, 1);
563     TEST_FIELD(APPBARDATA, UINT, uEdge, 12, 4, 1);
564     TEST_FIELD(APPBARDATA, RECT, rc, 16, 16, 1);
565     TEST_FIELD(APPBARDATA, LPARAM, lParam, 32, 4, 1);
566 }
567
568 static void test_pack_DRAGINFOA(void)
569 {
570     /* DRAGINFOA (pack 1) */
571     TEST_TYPE(DRAGINFOA, 24, 1);
572     TEST_FIELD(DRAGINFOA, UINT, uSize, 0, 4, 1);
573     TEST_FIELD(DRAGINFOA, POINT, pt, 4, 8, 1);
574     TEST_FIELD(DRAGINFOA, BOOL, fNC, 12, 4, 1);
575     TEST_FIELD(DRAGINFOA, LPSTR, lpFileList, 16, 4, 1);
576     TEST_FIELD(DRAGINFOA, DWORD, grfKeyState, 20, 4, 1);
577 }
578
579 static void test_pack_DRAGINFOW(void)
580 {
581     /* DRAGINFOW (pack 1) */
582     TEST_TYPE(DRAGINFOW, 24, 1);
583     TEST_FIELD(DRAGINFOW, UINT, uSize, 0, 4, 1);
584     TEST_FIELD(DRAGINFOW, POINT, pt, 4, 8, 1);
585     TEST_FIELD(DRAGINFOW, BOOL, fNC, 12, 4, 1);
586     TEST_FIELD(DRAGINFOW, LPWSTR, lpFileList, 16, 4, 1);
587     TEST_FIELD(DRAGINFOW, DWORD, grfKeyState, 20, 4, 1);
588 }
589
590 static void test_pack_FILEOP_FLAGS(void)
591 {
592     /* FILEOP_FLAGS */
593     TEST_TYPE(FILEOP_FLAGS, 2, 2);
594     TEST_TYPE_UNSIGNED(FILEOP_FLAGS);
595 }
596
597 static void test_pack_LPDRAGINFOA(void)
598 {
599     /* LPDRAGINFOA */
600     TEST_TYPE(LPDRAGINFOA, 4, 4);
601     TEST_TYPE_POINTER(LPDRAGINFOA, 24, 1);
602 }
603
604 static void test_pack_LPDRAGINFOW(void)
605 {
606     /* LPDRAGINFOW */
607     TEST_TYPE(LPDRAGINFOW, 4, 4);
608     TEST_TYPE_POINTER(LPDRAGINFOW, 24, 1);
609 }
610
611 static void test_pack_LPSHELLEXECUTEINFOA(void)
612 {
613     /* LPSHELLEXECUTEINFOA */
614     TEST_TYPE(LPSHELLEXECUTEINFOA, 4, 4);
615 }
616
617 static void test_pack_LPSHELLEXECUTEINFOW(void)
618 {
619     /* LPSHELLEXECUTEINFOW */
620     TEST_TYPE(LPSHELLEXECUTEINFOW, 4, 4);
621 }
622
623 static void test_pack_LPSHFILEOPSTRUCTA(void)
624 {
625     /* LPSHFILEOPSTRUCTA */
626     TEST_TYPE(LPSHFILEOPSTRUCTA, 4, 4);
627     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTA, 30, 1);
628 }
629
630 static void test_pack_LPSHFILEOPSTRUCTW(void)
631 {
632     /* LPSHFILEOPSTRUCTW */
633     TEST_TYPE(LPSHFILEOPSTRUCTW, 4, 4);
634     TEST_TYPE_POINTER(LPSHFILEOPSTRUCTW, 30, 1);
635 }
636
637 static void test_pack_LPSHNAMEMAPPINGA(void)
638 {
639     /* LPSHNAMEMAPPINGA */
640     TEST_TYPE(LPSHNAMEMAPPINGA, 4, 4);
641     TEST_TYPE_POINTER(LPSHNAMEMAPPINGA, 16, 1);
642 }
643
644 static void test_pack_LPSHNAMEMAPPINGW(void)
645 {
646     /* LPSHNAMEMAPPINGW */
647     TEST_TYPE(LPSHNAMEMAPPINGW, 4, 4);
648     TEST_TYPE_POINTER(LPSHNAMEMAPPINGW, 16, 1);
649 }
650
651 static void test_pack_NOTIFYICONDATAA(void)
652 {
653     /* NOTIFYICONDATAA (pack 1) */
654     TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
655     TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
656     TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
657     TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
658     TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
659     TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
660     TEST_FIELD(NOTIFYICONDATAA, CHAR[128], szTip, 24, 128, 1);
661     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwState, 152, 4, 1);
662     TEST_FIELD(NOTIFYICONDATAA, DWORD, dwStateMask, 156, 4, 1);
663     TEST_FIELD(NOTIFYICONDATAA, CHAR[256], szInfo, 160, 256, 1);
664 }
665
666 static void test_pack_NOTIFYICONDATAW(void)
667 {
668     /* NOTIFYICONDATAW (pack 1) */
669     TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
670     TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
671     TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
672     TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
673     TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
674     TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
675     TEST_FIELD(NOTIFYICONDATAW, WCHAR[128], szTip, 24, 256, 1);
676     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwState, 280, 4, 1);
677     TEST_FIELD(NOTIFYICONDATAW, DWORD, dwStateMask, 284, 4, 1);
678     TEST_FIELD(NOTIFYICONDATAW, WCHAR[256], szInfo, 288, 512, 1);
679 }
680
681 static void test_pack_PAPPBARDATA(void)
682 {
683     /* PAPPBARDATA */
684     TEST_TYPE(PAPPBARDATA, 4, 4);
685     TEST_TYPE_POINTER(PAPPBARDATA, 36, 1);
686 }
687
688 static void test_pack_PNOTIFYICONDATAA(void)
689 {
690     /* PNOTIFYICONDATAA */
691     TEST_TYPE(PNOTIFYICONDATAA, 4, 4);
692 }
693
694 static void test_pack_PNOTIFYICONDATAW(void)
695 {
696     /* PNOTIFYICONDATAW */
697     TEST_TYPE(PNOTIFYICONDATAW, 4, 4);
698 }
699
700 static void test_pack_PRINTEROP_FLAGS(void)
701 {
702     /* PRINTEROP_FLAGS */
703     TEST_TYPE(PRINTEROP_FLAGS, 2, 2);
704     TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS);
705 }
706
707 static void test_pack_SHELLEXECUTEINFOA(void)
708 {
709     /* SHELLEXECUTEINFOA (pack 1) */
710     TEST_FIELD(SHELLEXECUTEINFOA, DWORD, cbSize, 0, 4, 1);
711     TEST_FIELD(SHELLEXECUTEINFOA, ULONG, fMask, 4, 4, 1);
712     TEST_FIELD(SHELLEXECUTEINFOA, HWND, hwnd, 8, 4, 1);
713     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpVerb, 12, 4, 1);
714     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpFile, 16, 4, 1);
715     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpParameters, 20, 4, 1);
716     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpDirectory, 24, 4, 1);
717     TEST_FIELD(SHELLEXECUTEINFOA, INT, nShow, 28, 4, 1);
718     TEST_FIELD(SHELLEXECUTEINFOA, HINSTANCE, hInstApp, 32, 4, 1);
719     TEST_FIELD(SHELLEXECUTEINFOA, LPVOID, lpIDList, 36, 4, 1);
720     TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpClass, 40, 4, 1);
721     TEST_FIELD(SHELLEXECUTEINFOA, HKEY, hkeyClass, 44, 4, 1);
722     TEST_FIELD(SHELLEXECUTEINFOA, DWORD, dwHotKey, 48, 4, 1);
723 }
724
725 static void test_pack_SHELLEXECUTEINFOW(void)
726 {
727     /* SHELLEXECUTEINFOW (pack 1) */
728     TEST_FIELD(SHELLEXECUTEINFOW, DWORD, cbSize, 0, 4, 1);
729     TEST_FIELD(SHELLEXECUTEINFOW, ULONG, fMask, 4, 4, 1);
730     TEST_FIELD(SHELLEXECUTEINFOW, HWND, hwnd, 8, 4, 1);
731     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpVerb, 12, 4, 1);
732     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpFile, 16, 4, 1);
733     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpParameters, 20, 4, 1);
734     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpDirectory, 24, 4, 1);
735     TEST_FIELD(SHELLEXECUTEINFOW, INT, nShow, 28, 4, 1);
736     TEST_FIELD(SHELLEXECUTEINFOW, HINSTANCE, hInstApp, 32, 4, 1);
737     TEST_FIELD(SHELLEXECUTEINFOW, LPVOID, lpIDList, 36, 4, 1);
738     TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpClass, 40, 4, 1);
739     TEST_FIELD(SHELLEXECUTEINFOW, HKEY, hkeyClass, 44, 4, 1);
740     TEST_FIELD(SHELLEXECUTEINFOW, DWORD, dwHotKey, 48, 4, 1);
741 }
742
743 static void test_pack_SHFILEINFOA(void)
744 {
745     /* SHFILEINFOA (pack 1) */
746     TEST_TYPE(SHFILEINFOA, 352, 1);
747     TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
748     TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
749     TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
750     TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
751     TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
752 }
753
754 static void test_pack_SHFILEINFOW(void)
755 {
756     /* SHFILEINFOW (pack 1) */
757     TEST_TYPE(SHFILEINFOW, 692, 1);
758     TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
759     TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
760     TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
761     TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
762     TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
763 }
764
765 static void test_pack_SHFILEOPSTRUCTA(void)
766 {
767     /* SHFILEOPSTRUCTA (pack 1) */
768     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
769     TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
770     TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
771     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
772     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
773     TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
774     TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
775     TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
776     TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
777 }
778
779 static void test_pack_SHFILEOPSTRUCTW(void)
780 {
781     /* SHFILEOPSTRUCTW (pack 1) */
782     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
783     TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
784     TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
785     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
786     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
787     TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
788     TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
789     TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
790     TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
791 }
792
793 static void test_pack_SHNAMEMAPPINGA(void)
794 {
795     /* SHNAMEMAPPINGA (pack 1) */
796     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
797     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
798     TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
799     TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
800     TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
801 }
802
803 static void test_pack_SHNAMEMAPPINGW(void)
804 {
805     /* SHNAMEMAPPINGW (pack 1) */
806     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
807     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
808     TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
809     TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
810     TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
811 }
812
813 static void test_pack_ITEMIDLIST(void)
814 {
815     /* ITEMIDLIST (pack 1) */
816     TEST_TYPE(ITEMIDLIST, 3, 1);
817     TEST_FIELD(ITEMIDLIST, SHITEMID, mkid, 0, 3, 1);
818 }
819
820 static void test_pack_LPCITEMIDLIST(void)
821 {
822     /* LPCITEMIDLIST */
823     TEST_TYPE(LPCITEMIDLIST, 4, 4);
824     TEST_TYPE_POINTER(LPCITEMIDLIST, 3, 1);
825 }
826
827 static void test_pack_LPCSHITEMID(void)
828 {
829     /* LPCSHITEMID */
830     TEST_TYPE(LPCSHITEMID, 4, 4);
831     TEST_TYPE_POINTER(LPCSHITEMID, 3, 1);
832 }
833
834 static void test_pack_LPITEMIDLIST(void)
835 {
836     /* LPITEMIDLIST */
837     TEST_TYPE(LPITEMIDLIST, 4, 4);
838     TEST_TYPE_POINTER(LPITEMIDLIST, 3, 1);
839 }
840
841 static void test_pack_LPSHELLDETAILS(void)
842 {
843     /* LPSHELLDETAILS */
844     TEST_TYPE(LPSHELLDETAILS, 4, 4);
845 }
846
847 static void test_pack_LPSHITEMID(void)
848 {
849     /* LPSHITEMID */
850     TEST_TYPE(LPSHITEMID, 4, 4);
851     TEST_TYPE_POINTER(LPSHITEMID, 3, 1);
852 }
853
854 static void test_pack_LPSTRRET(void)
855 {
856     /* LPSTRRET */
857     TEST_TYPE(LPSTRRET, 4, 4);
858 }
859
860 static void test_pack_SHELLDETAILS(void)
861 {
862     /* SHELLDETAILS (pack 1) */
863     TEST_FIELD(SHELLDETAILS, int, fmt, 0, 4, 1);
864     TEST_FIELD(SHELLDETAILS, int, cxChar, 4, 4, 1);
865 }
866
867 static void test_pack_SHITEMID(void)
868 {
869     /* SHITEMID (pack 1) */
870     TEST_TYPE(SHITEMID, 3, 1);
871     TEST_FIELD(SHITEMID, WORD, cb, 0, 2, 1);
872     TEST_FIELD(SHITEMID, BYTE[1], abID, 2, 1, 1);
873 }
874
875 static void test_pack_STRRET(void)
876 {
877     /* STRRET (pack 4) */
878     TEST_FIELD(STRRET, UINT, uType, 0, 4, 4);
879 }
880
881 static void test_pack_AUTO_SCROLL_DATA(void)
882 {
883     /* AUTO_SCROLL_DATA (pack 1) */
884     TEST_TYPE(AUTO_SCROLL_DATA, 48, 1);
885     TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 1);
886     TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 1);
887     TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 1);
888     TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 1);
889     TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 1);
890 }
891
892 static void test_pack_BFFCALLBACK(void)
893 {
894     /* BFFCALLBACK */
895     TEST_TYPE(BFFCALLBACK, 4, 4);
896 }
897
898 static void test_pack_BROWSEINFOA(void)
899 {
900     /* BROWSEINFOA (pack 8) */
901     TEST_TYPE(BROWSEINFOA, 32, 4);
902     TEST_FIELD(BROWSEINFOA, HWND, hwndOwner, 0, 4, 4);
903     TEST_FIELD(BROWSEINFOA, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
904     TEST_FIELD(BROWSEINFOA, LPSTR, pszDisplayName, 8, 4, 4);
905     TEST_FIELD(BROWSEINFOA, LPCSTR, lpszTitle, 12, 4, 4);
906     TEST_FIELD(BROWSEINFOA, UINT, ulFlags, 16, 4, 4);
907     TEST_FIELD(BROWSEINFOA, BFFCALLBACK, lpfn, 20, 4, 4);
908     TEST_FIELD(BROWSEINFOA, LPARAM, lParam, 24, 4, 4);
909     TEST_FIELD(BROWSEINFOA, INT, iImage, 28, 4, 4);
910 }
911
912 static void test_pack_BROWSEINFOW(void)
913 {
914     /* BROWSEINFOW (pack 8) */
915     TEST_TYPE(BROWSEINFOW, 32, 4);
916     TEST_FIELD(BROWSEINFOW, HWND, hwndOwner, 0, 4, 4);
917     TEST_FIELD(BROWSEINFOW, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
918     TEST_FIELD(BROWSEINFOW, LPWSTR, pszDisplayName, 8, 4, 4);
919     TEST_FIELD(BROWSEINFOW, LPCWSTR, lpszTitle, 12, 4, 4);
920     TEST_FIELD(BROWSEINFOW, UINT, ulFlags, 16, 4, 4);
921     TEST_FIELD(BROWSEINFOW, BFFCALLBACK, lpfn, 20, 4, 4);
922     TEST_FIELD(BROWSEINFOW, LPARAM, lParam, 24, 4, 4);
923     TEST_FIELD(BROWSEINFOW, INT, iImage, 28, 4, 4);
924 }
925
926 static void test_pack_CABINETSTATE(void)
927 {
928     /* CABINETSTATE (pack 1) */
929     TEST_TYPE(CABINETSTATE, 12, 1);
930     TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
931     TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
932     TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 8, 4, 1);
933 }
934
935 static void test_pack_CIDA(void)
936 {
937     /* CIDA (pack 1) */
938     TEST_TYPE(CIDA, 8, 1);
939     TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
940     TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
941 }
942
943 static void test_pack_CSFV(void)
944 {
945     /* CSFV (pack 1) */
946     TEST_FIELD(CSFV, UINT, cbSize, 0, 4, 1);
947     TEST_FIELD(CSFV, IShellFolder*, pshf, 4, 4, 1);
948     TEST_FIELD(CSFV, IShellView*, psvOuter, 8, 4, 1);
949     TEST_FIELD(CSFV, LPCITEMIDLIST, pidl, 12, 4, 1);
950     TEST_FIELD(CSFV, LONG, lEvents, 16, 4, 1);
951     TEST_FIELD(CSFV, LPFNVIEWCALLBACK, pfnCallback, 20, 4, 1);
952 }
953
954 static void test_pack_DROPFILES(void)
955 {
956     /* DROPFILES (pack 1) */
957     TEST_TYPE(DROPFILES, 20, 1);
958     TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
959     TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
960     TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
961     TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
962 }
963
964 static void test_pack_FILEDESCRIPTORA(void)
965 {
966     /* FILEDESCRIPTORA (pack 1) */
967     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
968     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
969     TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
970     TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
971     TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
972     TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
973     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
974     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
975     TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
976     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
977     TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
978     TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
979 }
980
981 static void test_pack_FILEDESCRIPTORW(void)
982 {
983     /* FILEDESCRIPTORW (pack 1) */
984     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
985     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
986     TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
987     TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
988     TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
989     TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
990     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
991     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
992     TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
993     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
994     TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
995     TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
996 }
997
998 static void test_pack_FILEGROUPDESCRIPTORA(void)
999 {
1000     /* FILEGROUPDESCRIPTORA (pack 1) */
1001     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
1002     TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
1003     TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
1004 }
1005
1006 static void test_pack_FILEGROUPDESCRIPTORW(void)
1007 {
1008     /* FILEGROUPDESCRIPTORW (pack 1) */
1009     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
1010     TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
1011     TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
1012 }
1013
1014 static void test_pack_IFileSystemBindData(void)
1015 {
1016     /* IFileSystemBindData */
1017 }
1018
1019 static void test_pack_IFileSystemBindDataVtbl(void)
1020 {
1021     /* IFileSystemBindDataVtbl */
1022 }
1023
1024 static void test_pack_IShellChangeNotify(void)
1025 {
1026     /* IShellChangeNotify */
1027 }
1028
1029 static void test_pack_IShellIcon(void)
1030 {
1031     /* IShellIcon */
1032 }
1033
1034 static void test_pack_LPBROWSEINFOA(void)
1035 {
1036     /* LPBROWSEINFOA */
1037     TEST_TYPE(LPBROWSEINFOA, 4, 4);
1038     TEST_TYPE_POINTER(LPBROWSEINFOA, 32, 4);
1039 }
1040
1041 static void test_pack_LPBROWSEINFOW(void)
1042 {
1043     /* LPBROWSEINFOW */
1044     TEST_TYPE(LPBROWSEINFOW, 4, 4);
1045     TEST_TYPE_POINTER(LPBROWSEINFOW, 32, 4);
1046 }
1047
1048 static void test_pack_LPCABINETSTATE(void)
1049 {
1050     /* LPCABINETSTATE */
1051     TEST_TYPE(LPCABINETSTATE, 4, 4);
1052     TEST_TYPE_POINTER(LPCABINETSTATE, 12, 1);
1053 }
1054
1055 static void test_pack_LPCSFV(void)
1056 {
1057     /* LPCSFV */
1058     TEST_TYPE(LPCSFV, 4, 4);
1059 }
1060
1061 static void test_pack_LPDROPFILES(void)
1062 {
1063     /* LPDROPFILES */
1064     TEST_TYPE(LPDROPFILES, 4, 4);
1065     TEST_TYPE_POINTER(LPDROPFILES, 20, 1);
1066 }
1067
1068 static void test_pack_LPFILEDESCRIPTORA(void)
1069 {
1070     /* LPFILEDESCRIPTORA */
1071     TEST_TYPE(LPFILEDESCRIPTORA, 4, 4);
1072     TEST_TYPE_POINTER(LPFILEDESCRIPTORA, 332, 1);
1073 }
1074
1075 static void test_pack_LPFILEDESCRIPTORW(void)
1076 {
1077     /* LPFILEDESCRIPTORW */
1078     TEST_TYPE(LPFILEDESCRIPTORW, 4, 4);
1079     TEST_TYPE_POINTER(LPFILEDESCRIPTORW, 592, 1);
1080 }
1081
1082 static void test_pack_LPFILEGROUPDESCRIPTORA(void)
1083 {
1084     /* LPFILEGROUPDESCRIPTORA */
1085     TEST_TYPE(LPFILEGROUPDESCRIPTORA, 4, 4);
1086     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORA, 336, 1);
1087 }
1088
1089 static void test_pack_LPFILEGROUPDESCRIPTORW(void)
1090 {
1091     /* LPFILEGROUPDESCRIPTORW */
1092     TEST_TYPE(LPFILEGROUPDESCRIPTORW, 4, 4);
1093     TEST_TYPE_POINTER(LPFILEGROUPDESCRIPTORW, 596, 1);
1094 }
1095
1096 static void test_pack_LPFNVIEWCALLBACK(void)
1097 {
1098     /* LPFNVIEWCALLBACK */
1099     TEST_TYPE(LPFNVIEWCALLBACK, 4, 4);
1100 }
1101
1102 static void test_pack_LPIDA(void)
1103 {
1104     /* LPIDA */
1105     TEST_TYPE(LPIDA, 4, 4);
1106     TEST_TYPE_POINTER(LPIDA, 8, 1);
1107 }
1108
1109 static void test_pack_LPQCMINFO(void)
1110 {
1111     /* LPQCMINFO */
1112     TEST_TYPE(LPQCMINFO, 4, 4);
1113     TEST_TYPE_POINTER(LPQCMINFO, 20, 4);
1114 }
1115
1116 static void test_pack_LPSHChangeDWORDAsIDList(void)
1117 {
1118     /* LPSHChangeDWORDAsIDList */
1119     TEST_TYPE(LPSHChangeDWORDAsIDList, 4, 4);
1120     TEST_TYPE_POINTER(LPSHChangeDWORDAsIDList, 12, 1);
1121 }
1122
1123 static void test_pack_LPSHChangeProductKeyAsIDList(void)
1124 {
1125     /* LPSHChangeProductKeyAsIDList */
1126     TEST_TYPE(LPSHChangeProductKeyAsIDList, 4, 4);
1127     TEST_TYPE_POINTER(LPSHChangeProductKeyAsIDList, 82, 1);
1128 }
1129
1130 static void test_pack_LPSHDESCRIPTIONID(void)
1131 {
1132     /* LPSHDESCRIPTIONID */
1133     TEST_TYPE(LPSHDESCRIPTIONID, 4, 4);
1134     TEST_TYPE_POINTER(LPSHDESCRIPTIONID, 20, 4);
1135 }
1136
1137 static void test_pack_LPSHELLFLAGSTATE(void)
1138 {
1139     /* LPSHELLFLAGSTATE */
1140     TEST_TYPE(LPSHELLFLAGSTATE, 4, 4);
1141     TEST_TYPE_POINTER(LPSHELLFLAGSTATE, 4, 1);
1142 }
1143
1144 static void test_pack_LPSHELLSTATE(void)
1145 {
1146     /* LPSHELLSTATE */
1147     TEST_TYPE(LPSHELLSTATE, 4, 4);
1148     TEST_TYPE_POINTER(LPSHELLSTATE, 32, 1);
1149 }
1150
1151 static void test_pack_LPTBINFO(void)
1152 {
1153     /* LPTBINFO */
1154     TEST_TYPE(LPTBINFO, 4, 4);
1155     TEST_TYPE_POINTER(LPTBINFO, 8, 4);
1156 }
1157
1158 static void test_pack_PBROWSEINFOA(void)
1159 {
1160     /* PBROWSEINFOA */
1161     TEST_TYPE(PBROWSEINFOA, 4, 4);
1162     TEST_TYPE_POINTER(PBROWSEINFOA, 32, 4);
1163 }
1164
1165 static void test_pack_PBROWSEINFOW(void)
1166 {
1167     /* PBROWSEINFOW */
1168     TEST_TYPE(PBROWSEINFOW, 4, 4);
1169     TEST_TYPE_POINTER(PBROWSEINFOW, 32, 4);
1170 }
1171
1172 static void test_pack_QCMINFO(void)
1173 {
1174     /* QCMINFO (pack 8) */
1175     TEST_TYPE(QCMINFO, 20, 4);
1176     TEST_FIELD(QCMINFO, HMENU, hmenu, 0, 4, 4);
1177     TEST_FIELD(QCMINFO, UINT, indexMenu, 4, 4, 4);
1178     TEST_FIELD(QCMINFO, UINT, idCmdFirst, 8, 4, 4);
1179     TEST_FIELD(QCMINFO, UINT, idCmdLast, 12, 4, 4);
1180     TEST_FIELD(QCMINFO, QCMINFO_IDMAP const*, pIdMap, 16, 4, 4);
1181 }
1182
1183 static void test_pack_QCMINFO_IDMAP(void)
1184 {
1185     /* QCMINFO_IDMAP (pack 8) */
1186     TEST_TYPE(QCMINFO_IDMAP, 12, 4);
1187     TEST_FIELD(QCMINFO_IDMAP, UINT, nMaxIds, 0, 4, 4);
1188     TEST_FIELD(QCMINFO_IDMAP, QCMINFO_IDMAP_PLACEMENT[1], pIdList, 4, 8, 4);
1189 }
1190
1191 static void test_pack_QCMINFO_IDMAP_PLACEMENT(void)
1192 {
1193     /* QCMINFO_IDMAP_PLACEMENT (pack 8) */
1194     TEST_TYPE(QCMINFO_IDMAP_PLACEMENT, 8, 4);
1195     TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, UINT, id, 0, 4, 4);
1196     TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, UINT, fFlags, 4, 4, 4);
1197 }
1198
1199 static void test_pack_SHChangeDWORDAsIDList(void)
1200 {
1201     /* SHChangeDWORDAsIDList (pack 1) */
1202     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
1203     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
1204     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
1205     TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
1206     TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
1207 }
1208
1209 static void test_pack_SHChangeNotifyEntry(void)
1210 {
1211     /* SHChangeNotifyEntry (pack 1) */
1212     TEST_TYPE(SHChangeNotifyEntry, 8, 1);
1213     TEST_FIELD(SHChangeNotifyEntry, LPCITEMIDLIST, pidl, 0, 4, 1);
1214     TEST_FIELD(SHChangeNotifyEntry, BOOL, fRecursive, 4, 4, 1);
1215 }
1216
1217 static void test_pack_SHChangeProductKeyAsIDList(void)
1218 {
1219     /* SHChangeProductKeyAsIDList (pack 1) */
1220     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
1221     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
1222     TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
1223     TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
1224 }
1225
1226 static void test_pack_SHDESCRIPTIONID(void)
1227 {
1228     /* SHDESCRIPTIONID (pack 8) */
1229     TEST_TYPE(SHDESCRIPTIONID, 20, 4);
1230     TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 4);
1231     TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 4);
1232 }
1233
1234 static void test_pack_SHELLFLAGSTATE(void)
1235 {
1236     /* SHELLFLAGSTATE (pack 1) */
1237     TEST_TYPE(SHELLFLAGSTATE, 4, 1);
1238 }
1239
1240 static void test_pack_SHELLSTATE(void)
1241 {
1242     /* SHELLSTATE (pack 1) */
1243     TEST_TYPE(SHELLSTATE, 32, 1);
1244     TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 4, 4, 1);
1245     TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 8, 4, 1);
1246     TEST_FIELD(SHELLSTATE, LONG, lParamSort, 12, 4, 1);
1247     TEST_FIELD(SHELLSTATE, int, iSortDirection, 16, 4, 1);
1248     TEST_FIELD(SHELLSTATE, UINT, version, 20, 4, 1);
1249     TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 24, 4, 1);
1250 }
1251
1252 static void test_pack_SHELLVIEWID(void)
1253 {
1254     /* SHELLVIEWID */
1255     TEST_TYPE(SHELLVIEWID, 16, 4);
1256 }
1257
1258 static void test_pack_TBINFO(void)
1259 {
1260     /* TBINFO (pack 8) */
1261     TEST_TYPE(TBINFO, 8, 4);
1262     TEST_FIELD(TBINFO, UINT, cbuttons, 0, 4, 4);
1263     TEST_FIELD(TBINFO, UINT, uFlags, 4, 4, 4);
1264 }
1265
1266 static void test_pack(void)
1267 {
1268     test_pack_APPBARDATA();
1269     test_pack_AUTO_SCROLL_DATA();
1270     test_pack_BFFCALLBACK();
1271     test_pack_BLOB();
1272     test_pack_BROWSEINFOA();
1273     test_pack_BROWSEINFOW();
1274     test_pack_BSTR();
1275     test_pack_BSTRBLOB();
1276     test_pack_BYTE_BLOB();
1277     test_pack_BYTE_SIZEDARR();
1278     test_pack_CABINETSTATE();
1279     test_pack_CIDA();
1280     test_pack_CLIPDATA();
1281     test_pack_CLIPFORMAT();
1282     test_pack_CLSID();
1283     test_pack_COAUTHIDENTITY();
1284     test_pack_COAUTHINFO();
1285     test_pack_COSERVERINFO();
1286     test_pack_CSFV();
1287     test_pack_DRAGINFOA();
1288     test_pack_DRAGINFOW();
1289     test_pack_DROPFILES();
1290     test_pack_DWORD_SIZEDARR();
1291     test_pack_FILEDESCRIPTORA();
1292     test_pack_FILEDESCRIPTORW();
1293     test_pack_FILEGROUPDESCRIPTORA();
1294     test_pack_FILEGROUPDESCRIPTORW();
1295     test_pack_FILEOP_FLAGS();
1296     test_pack_FLAGGED_BYTE_BLOB();
1297     test_pack_FLAGGED_WORD_BLOB();
1298     test_pack_FMTID();
1299     test_pack_GUID();
1300     test_pack_HMETAFILEPICT();
1301     test_pack_HYPER_SIZEDARR();
1302     test_pack_IFileSystemBindData();
1303     test_pack_IFileSystemBindDataVtbl();
1304     test_pack_IID();
1305     test_pack_IShellChangeNotify();
1306     test_pack_IShellIcon();
1307     test_pack_ITEMIDLIST();
1308     test_pack_LPBLOB();
1309     test_pack_LPBROWSEINFOA();
1310     test_pack_LPBROWSEINFOW();
1311     test_pack_LPBSTR();
1312     test_pack_LPBSTRBLOB();
1313     test_pack_LPCABINETSTATE();
1314     test_pack_LPCITEMIDLIST();
1315     test_pack_LPCOLESTR();
1316     test_pack_LPCSFV();
1317     test_pack_LPCSHITEMID();
1318     test_pack_LPCY();
1319     test_pack_LPDECIMAL();
1320     test_pack_LPDRAGINFOA();
1321     test_pack_LPDRAGINFOW();
1322     test_pack_LPDROPFILES();
1323     test_pack_LPFILEDESCRIPTORA();
1324     test_pack_LPFILEDESCRIPTORW();
1325     test_pack_LPFILEGROUPDESCRIPTORA();
1326     test_pack_LPFILEGROUPDESCRIPTORW();
1327     test_pack_LPFNVIEWCALLBACK();
1328     test_pack_LPGUID();
1329     test_pack_LPIDA();
1330     test_pack_LPITEMIDLIST();
1331     test_pack_LPOLESTR();
1332     test_pack_LPQCMINFO();
1333     test_pack_LPSHChangeDWORDAsIDList();
1334     test_pack_LPSHChangeProductKeyAsIDList();
1335     test_pack_LPSHDESCRIPTIONID();
1336     test_pack_LPSHELLDETAILS();
1337     test_pack_LPSHELLEXECUTEINFOA();
1338     test_pack_LPSHELLEXECUTEINFOW();
1339     test_pack_LPSHELLFLAGSTATE();
1340     test_pack_LPSHELLSTATE();
1341     test_pack_LPSHFILEOPSTRUCTA();
1342     test_pack_LPSHFILEOPSTRUCTW();
1343     test_pack_LPSHITEMID();
1344     test_pack_LPSHNAMEMAPPINGA();
1345     test_pack_LPSHNAMEMAPPINGW();
1346     test_pack_LPSTRRET();
1347     test_pack_LPTBINFO();
1348     test_pack_NOTIFYICONDATAA();
1349     test_pack_NOTIFYICONDATAW();
1350     test_pack_OLECHAR();
1351     test_pack_PAPPBARDATA();
1352     test_pack_PBROWSEINFOA();
1353     test_pack_PBROWSEINFOW();
1354     test_pack_PNOTIFYICONDATAA();
1355     test_pack_PNOTIFYICONDATAW();
1356     test_pack_PRINTEROP_FLAGS();
1357     test_pack_PROPID();
1358     test_pack_QCMINFO();
1359     test_pack_QCMINFO_IDMAP();
1360     test_pack_QCMINFO_IDMAP_PLACEMENT();
1361     test_pack_RemHBITMAP();
1362     test_pack_RemHENHMETAFILE();
1363     test_pack_RemHGLOBAL();
1364     test_pack_RemHMETAFILEPICT();
1365     test_pack_RemHPALETTE();
1366     test_pack_SCODE();
1367     test_pack_SHChangeDWORDAsIDList();
1368     test_pack_SHChangeNotifyEntry();
1369     test_pack_SHChangeProductKeyAsIDList();
1370     test_pack_SHDESCRIPTIONID();
1371     test_pack_SHELLDETAILS();
1372     test_pack_SHELLEXECUTEINFOA();
1373     test_pack_SHELLEXECUTEINFOW();
1374     test_pack_SHELLFLAGSTATE();
1375     test_pack_SHELLSTATE();
1376     test_pack_SHELLVIEWID();
1377     test_pack_SHFILEINFOA();
1378     test_pack_SHFILEINFOW();
1379     test_pack_SHFILEOPSTRUCTA();
1380     test_pack_SHFILEOPSTRUCTW();
1381     test_pack_SHITEMID();
1382     test_pack_SHNAMEMAPPINGA();
1383     test_pack_SHNAMEMAPPINGW();
1384     test_pack_STRRET();
1385     test_pack_TBINFO();
1386     test_pack_UP_BYTE_BLOB();
1387     test_pack_UP_FLAGGED_BYTE_BLOB();
1388     test_pack_UP_FLAGGED_WORD_BLOB();
1389     test_pack_VARIANT_BOOL();
1390     test_pack_VARTYPE();
1391     test_pack_WORD_SIZEDARR();
1392     test_pack_remoteMETAFILEPICT();
1393     test_pack_userBITMAP();
1394     test_pack_userCLIPFORMAT();
1395     test_pack_userHBITMAP();
1396     test_pack_userHENHMETAFILE();
1397     test_pack_userHGLOBAL();
1398     test_pack_userHMETAFILE();
1399     test_pack_userHMETAFILEPICT();
1400     test_pack_userHPALETTE();
1401     test_pack_wireBSTR();
1402     test_pack_wireCLIPFORMAT();
1403     test_pack_wireHBITMAP();
1404     test_pack_wireHENHMETAFILE();
1405     test_pack_wireHGLOBAL();
1406     test_pack_wireHMETAFILE();
1407     test_pack_wireHMETAFILEPICT();
1408     test_pack_wireHPALETTE();
1409 }
1410
1411 START_TEST(generated)
1412 {
1413     test_pack();
1414 }