diff --git a/dlls/gdi/tests/generated.c b/dlls/gdi/tests/generated.c
index baa1ae9..e310a18 100644
--- a/dlls/gdi/tests/generated.c
+++ b/dlls/gdi/tests/generated.c
@@ -108,22 +108,32 @@
 #define TEST_TYPE_UNSIGNED(type) \
      ok((type) -1 > 0, "(" #type ") -1 > 0");
 
-void test_pack(void)
+static void test_pack_ABC(void)
 {
     /* ABC (pack 4) */
     TEST_TYPE(ABC, 12, 4);
     TEST_FIELD(ABC, INT, abcA, 0, 4, 4);
     TEST_FIELD(ABC, UINT, abcB, 4, 4, 4);
     TEST_FIELD(ABC, INT, abcC, 8, 4, 4);
+}
 
+static void test_pack_ABCFLOAT(void)
+{
     /* ABCFLOAT (pack 4) */
     TEST_TYPE(ABCFLOAT, 12, 4);
     TEST_FIELD(ABCFLOAT, FLOAT, abcfA, 0, 4, 4);
     TEST_FIELD(ABCFLOAT, FLOAT, abcfB, 4, 4, 4);
     TEST_FIELD(ABCFLOAT, FLOAT, abcfC, 8, 4, 4);
+}
 
+static void test_pack_ABORTPROC(void)
+{
     /* ABORTPROC */
+    TEST_TYPE(ABORTPROC, 4, 4);
+}
 
+static void test_pack_BITMAP(void)
+{
     /* BITMAP (pack 4) */
     TEST_TYPE(BITMAP, 24, 4);
     TEST_FIELD(BITMAP, INT, bmType, 0, 4, 4);
@@ -133,7 +143,10 @@
     TEST_FIELD(BITMAP, WORD, bmPlanes, 16, 2, 2);
     TEST_FIELD(BITMAP, WORD, bmBitsPixel, 18, 2, 2);
     TEST_FIELD(BITMAP, LPVOID, bmBits, 20, 4, 4);
+}
 
+static void test_pack_BITMAPCOREHEADER(void)
+{
     /* BITMAPCOREHEADER (pack 4) */
     TEST_TYPE(BITMAPCOREHEADER, 12, 4);
     TEST_FIELD(BITMAPCOREHEADER, DWORD, bcSize, 0, 4, 4);
@@ -141,12 +154,18 @@
     TEST_FIELD(BITMAPCOREHEADER, WORD, bcHeight, 6, 2, 2);
     TEST_FIELD(BITMAPCOREHEADER, WORD, bcPlanes, 8, 2, 2);
     TEST_FIELD(BITMAPCOREHEADER, WORD, bcBitCount, 10, 2, 2);
+}
 
+static void test_pack_BITMAPCOREINFO(void)
+{
     /* BITMAPCOREINFO (pack 4) */
     TEST_TYPE(BITMAPCOREINFO, 16, 4);
     TEST_FIELD(BITMAPCOREINFO, BITMAPCOREHEADER, bmciHeader, 0, 12, 4);
     TEST_FIELD(BITMAPCOREINFO, RGBTRIPLE[1], bmciColors, 12, 3, 1);
+}
 
+static void test_pack_BITMAPFILEHEADER(void)
+{
     /* BITMAPFILEHEADER (pack 2) */
     TEST_TYPE(BITMAPFILEHEADER, 14, 2);
     TEST_FIELD(BITMAPFILEHEADER, WORD, bfType, 0, 2, 2);
@@ -154,12 +173,18 @@
     TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved1, 6, 2, 2);
     TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved2, 8, 2, 2);
     TEST_FIELD(BITMAPFILEHEADER, DWORD, bfOffBits, 10, 4, 2);
+}
 
+static void test_pack_BITMAPINFO(void)
+{
     /* BITMAPINFO (pack 4) */
     TEST_TYPE(BITMAPINFO, 44, 4);
     TEST_FIELD(BITMAPINFO, BITMAPINFOHEADER, bmiHeader, 0, 40, 4);
     TEST_FIELD(BITMAPINFO, RGBQUAD[1], bmiColors, 40, 4, 1);
+}
 
+static void test_pack_BITMAPINFOHEADER(void)
+{
     /* BITMAPINFOHEADER (pack 4) */
     TEST_TYPE(BITMAPINFOHEADER, 40, 4);
     TEST_FIELD(BITMAPINFOHEADER, DWORD, biSize, 0, 4, 4);
@@ -173,7 +198,10 @@
     TEST_FIELD(BITMAPINFOHEADER, LONG, biYPelsPerMeter, 28, 4, 4);
     TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrUsed, 32, 4, 4);
     TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrImportant, 36, 4, 4);
+}
 
+static void test_pack_BITMAPV4HEADER(void)
+{
     /* BITMAPV4HEADER (pack 4) */
     TEST_TYPE(BITMAPV4HEADER, 108, 4);
     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4Size, 0, 4, 4);
@@ -196,7 +224,10 @@
     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaRed, 96, 4, 4);
     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaGreen, 100, 4, 4);
     TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaBlue, 104, 4, 4);
+}
 
+static void test_pack_BITMAPV5HEADER(void)
+{
     /* BITMAPV5HEADER (pack 4) */
     TEST_TYPE(BITMAPV5HEADER, 124, 4);
     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Size, 0, 4, 4);
@@ -223,35 +254,53 @@
     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileData, 112, 4, 4);
     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileSize, 116, 4, 4);
     TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Reserved, 120, 4, 4);
+}
 
+static void test_pack_BLENDFUNCTION(void)
+{
     /* BLENDFUNCTION (pack 4) */
     TEST_TYPE(BLENDFUNCTION, 4, 1);
     TEST_FIELD(BLENDFUNCTION, BYTE, BlendOp, 0, 1, 1);
     TEST_FIELD(BLENDFUNCTION, BYTE, BlendFlags, 1, 1, 1);
     TEST_FIELD(BLENDFUNCTION, BYTE, SourceConstantAlpha, 2, 1, 1);
     TEST_FIELD(BLENDFUNCTION, BYTE, AlphaFormat, 3, 1, 1);
+}
 
+static void test_pack_CHARSETINFO(void)
+{
     /* CHARSETINFO (pack 4) */
     TEST_TYPE(CHARSETINFO, 32, 4);
     TEST_FIELD(CHARSETINFO, UINT, ciCharset, 0, 4, 4);
     TEST_FIELD(CHARSETINFO, UINT, ciACP, 4, 4, 4);
     TEST_FIELD(CHARSETINFO, FONTSIGNATURE, fs, 8, 24, 4);
+}
 
+static void test_pack_CIEXYZ(void)
+{
     /* CIEXYZ (pack 4) */
     TEST_TYPE(CIEXYZ, 12, 4);
     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzX, 0, 4, 4);
     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzY, 4, 4, 4);
     TEST_FIELD(CIEXYZ, FXPT2DOT30, ciexyzZ, 8, 4, 4);
+}
 
+static void test_pack_CIEXYZTRIPLE(void)
+{
     /* CIEXYZTRIPLE (pack 4) */
     TEST_TYPE(CIEXYZTRIPLE, 36, 4);
     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzRed, 0, 12, 4);
     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzGreen, 12, 12, 4);
     TEST_FIELD(CIEXYZTRIPLE, CIEXYZ, ciexyzBlue, 24, 12, 4);
+}
 
+static void test_pack_COLOR16(void)
+{
     /* COLOR16 */
     TEST_TYPE(COLOR16, 2, 2);
+}
 
+static void test_pack_COLORADJUSTMENT(void)
+{
     /* COLORADJUSTMENT (pack 4) */
     TEST_TYPE(COLORADJUSTMENT, 24, 2);
     TEST_FIELD(COLORADJUSTMENT, WORD, caSize, 0, 2, 2);
@@ -266,7 +315,10 @@
     TEST_FIELD(COLORADJUSTMENT, SHORT, caBrightness, 18, 2, 2);
     TEST_FIELD(COLORADJUSTMENT, SHORT, caColorfulness, 20, 2, 2);
     TEST_FIELD(COLORADJUSTMENT, SHORT, caRedGreenTint, 22, 2, 2);
+}
 
+static void test_pack_DIBSECTION(void)
+{
     /* DIBSECTION (pack 4) */
     TEST_TYPE(DIBSECTION, 84, 4);
     TEST_FIELD(DIBSECTION, BITMAP, dsBm, 0, 24, 4);
@@ -274,19 +326,28 @@
     TEST_FIELD(DIBSECTION, DWORD[3], dsBitfields, 64, 12, 4);
     TEST_FIELD(DIBSECTION, HANDLE, dshSection, 76, 4, 4);
     TEST_FIELD(DIBSECTION, DWORD, dsOffset, 80, 4, 4);
+}
 
+static void test_pack_DISPLAY_DEVICEA(void)
+{
     /* DISPLAY_DEVICEA (pack 4) */
     TEST_FIELD(DISPLAY_DEVICEA, DWORD, cb, 0, 4, 4);
     TEST_FIELD(DISPLAY_DEVICEA, CHAR[32], DeviceName, 4, 32, 1);
     TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceString, 36, 128, 1);
     TEST_FIELD(DISPLAY_DEVICEA, DWORD, StateFlags, 164, 4, 4);
+}
 
+static void test_pack_DISPLAY_DEVICEW(void)
+{
     /* DISPLAY_DEVICEW (pack 4) */
     TEST_FIELD(DISPLAY_DEVICEW, DWORD, cb, 0, 4, 4);
     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[32], DeviceName, 4, 64, 2);
     TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceString, 68, 256, 2);
     TEST_FIELD(DISPLAY_DEVICEW, DWORD, StateFlags, 324, 4, 4);
+}
 
+static void test_pack_DOCINFOA(void)
+{
     /* DOCINFOA (pack 4) */
     TEST_TYPE(DOCINFOA, 20, 4);
     TEST_FIELD(DOCINFOA, INT, cbSize, 0, 4, 4);
@@ -294,7 +355,10 @@
     TEST_FIELD(DOCINFOA, LPCSTR, lpszOutput, 8, 4, 4);
     TEST_FIELD(DOCINFOA, LPCSTR, lpszDatatype, 12, 4, 4);
     TEST_FIELD(DOCINFOA, DWORD, fwType, 16, 4, 4);
+}
 
+static void test_pack_DOCINFOW(void)
+{
     /* DOCINFOW (pack 4) */
     TEST_TYPE(DOCINFOW, 20, 4);
     TEST_FIELD(DOCINFOW, INT, cbSize, 0, 4, 4);
@@ -302,16 +366,25 @@
     TEST_FIELD(DOCINFOW, LPCWSTR, lpszOutput, 8, 4, 4);
     TEST_FIELD(DOCINFOW, LPCWSTR, lpszDatatype, 12, 4, 4);
     TEST_FIELD(DOCINFOW, DWORD, fwType, 16, 4, 4);
+}
 
+static void test_pack_EMR(void)
+{
     /* EMR (pack 4) */
     TEST_TYPE(EMR, 8, 4);
     TEST_FIELD(EMR, DWORD, iType, 0, 4, 4);
     TEST_FIELD(EMR, DWORD, nSize, 4, 4, 4);
+}
 
+static void test_pack_EMRABORTPATH(void)
+{
     /* EMRABORTPATH (pack 4) */
     TEST_TYPE(EMRABORTPATH, 8, 4);
     TEST_FIELD(EMRABORTPATH, EMR, emr, 0, 8, 4);
+}
 
+static void test_pack_EMRANGLEARC(void)
+{
     /* EMRANGLEARC (pack 4) */
     TEST_TYPE(EMRANGLEARC, 28, 4);
     TEST_FIELD(EMRANGLEARC, EMR, emr, 0, 8, 4);
@@ -319,14 +392,37 @@
     TEST_FIELD(EMRANGLEARC, DWORD, nRadius, 16, 4, 4);
     TEST_FIELD(EMRANGLEARC, FLOAT, eStartAngle, 20, 4, 4);
     TEST_FIELD(EMRANGLEARC, FLOAT, eSweepAngle, 24, 4, 4);
+}
 
+static void test_pack_EMRARC(void)
+{
     /* EMRARC (pack 4) */
     TEST_TYPE(EMRARC, 40, 4);
     TEST_FIELD(EMRARC, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRARC, RECTL, rclBox, 8, 16, 4);
     TEST_FIELD(EMRARC, POINTL, ptlStart, 24, 8, 4);
     TEST_FIELD(EMRARC, POINTL, ptlEnd, 32, 8, 4);
+}
 
+static void test_pack_EMRARCTO(void)
+{
+    /* EMRARCTO (pack 4) */
+    TEST_TYPE(EMRARCTO, 40, 4);
+    TEST_FIELD(EMRARCTO, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRARCTO, RECTL, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRARCTO, POINTL, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRARCTO, POINTL, ptlEnd, 32, 8, 4);
+}
+
+static void test_pack_EMRBEGINPATH(void)
+{
+    /* EMRBEGINPATH (pack 4) */
+    TEST_TYPE(EMRBEGINPATH, 8, 4);
+    TEST_FIELD(EMRBEGINPATH, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMRBITBLT(void)
+{
     /* EMRBITBLT (pack 4) */
     TEST_TYPE(EMRBITBLT, 100, 4);
     TEST_FIELD(EMRBITBLT, EMR, emr, 0, 8, 4);
@@ -345,13 +441,36 @@
     TEST_FIELD(EMRBITBLT, DWORD, cbBmiSrc, 88, 4, 4);
     TEST_FIELD(EMRBITBLT, DWORD, offBitsSrc, 92, 4, 4);
     TEST_FIELD(EMRBITBLT, DWORD, cbBitsSrc, 96, 4, 4);
+}
 
+static void test_pack_EMRCHORD(void)
+{
+    /* EMRCHORD (pack 4) */
+    TEST_TYPE(EMRCHORD, 40, 4);
+    TEST_FIELD(EMRCHORD, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRCHORD, RECTL, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRCHORD, POINTL, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRCHORD, POINTL, ptlEnd, 32, 8, 4);
+}
+
+static void test_pack_EMRCLOSEFIGURE(void)
+{
+    /* EMRCLOSEFIGURE (pack 4) */
+    TEST_TYPE(EMRCLOSEFIGURE, 8, 4);
+    TEST_FIELD(EMRCLOSEFIGURE, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMRCREATEBRUSHINDIRECT(void)
+{
     /* EMRCREATEBRUSHINDIRECT (pack 4) */
     TEST_TYPE(EMRCREATEBRUSHINDIRECT, 24, 4);
     TEST_FIELD(EMRCREATEBRUSHINDIRECT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRCREATEBRUSHINDIRECT, DWORD, ihBrush, 8, 4, 4);
     TEST_FIELD(EMRCREATEBRUSHINDIRECT, LOGBRUSH, lb, 12, 12, 4);
+}
 
+static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
+{
     /* EMRCREATEDIBPATTERNBRUSHPT (pack 4) */
     TEST_TYPE(EMRCREATEDIBPATTERNBRUSHPT, 32, 4);
     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, EMR, emr, 0, 8, 4);
@@ -361,7 +480,10 @@
     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBmi, 20, 4, 4);
     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBits, 24, 4, 4);
     TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBits, 28, 4, 4);
+}
 
+static void test_pack_EMRCREATEMONOBRUSH(void)
+{
     /* EMRCREATEMONOBRUSH (pack 4) */
     TEST_TYPE(EMRCREATEMONOBRUSH, 32, 4);
     TEST_FIELD(EMRCREATEMONOBRUSH, EMR, emr, 0, 8, 4);
@@ -371,46 +493,77 @@
     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBmi, 20, 4, 4);
     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBits, 24, 4, 4);
     TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBits, 28, 4, 4);
+}
 
+static void test_pack_EMRCREATEPEN(void)
+{
     /* EMRCREATEPEN (pack 4) */
     TEST_TYPE(EMRCREATEPEN, 28, 4);
     TEST_FIELD(EMRCREATEPEN, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRCREATEPEN, DWORD, ihPen, 8, 4, 4);
     TEST_FIELD(EMRCREATEPEN, LOGPEN, lopn, 12, 16, 4);
+}
 
+static void test_pack_EMRDELETECOLORSPACE(void)
+{
     /* EMRDELETECOLORSPACE (pack 4) */
     TEST_TYPE(EMRDELETECOLORSPACE, 12, 4);
     TEST_FIELD(EMRDELETECOLORSPACE, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRDELETECOLORSPACE, DWORD, ihCS, 8, 4, 4);
+}
 
+static void test_pack_EMRDELETEOBJECT(void)
+{
     /* EMRDELETEOBJECT (pack 4) */
     TEST_TYPE(EMRDELETEOBJECT, 12, 4);
     TEST_FIELD(EMRDELETEOBJECT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRDELETEOBJECT, DWORD, ihObject, 8, 4, 4);
+}
 
+static void test_pack_EMRELLIPSE(void)
+{
     /* EMRELLIPSE (pack 4) */
     TEST_TYPE(EMRELLIPSE, 24, 4);
     TEST_FIELD(EMRELLIPSE, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRELLIPSE, RECTL, rclBox, 8, 16, 4);
+}
 
+static void test_pack_EMRENDPATH(void)
+{
+    /* EMRENDPATH (pack 4) */
+    TEST_TYPE(EMRENDPATH, 8, 4);
+    TEST_FIELD(EMRENDPATH, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMREOF(void)
+{
     /* EMREOF (pack 4) */
     TEST_TYPE(EMREOF, 20, 4);
     TEST_FIELD(EMREOF, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMREOF, DWORD, nPalEntries, 8, 4, 4);
     TEST_FIELD(EMREOF, DWORD, offPalEntries, 12, 4, 4);
     TEST_FIELD(EMREOF, DWORD, nSizeLast, 16, 4, 4);
+}
 
+static void test_pack_EMREXCLUDECLIPRECT(void)
+{
     /* EMREXCLUDECLIPRECT (pack 4) */
     TEST_TYPE(EMREXCLUDECLIPRECT, 24, 4);
     TEST_FIELD(EMREXCLUDECLIPRECT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMREXCLUDECLIPRECT, RECTL, rclClip, 8, 16, 4);
+}
 
+static void test_pack_EMREXTCREATEFONTINDIRECTW(void)
+{
     /* EMREXTCREATEFONTINDIRECTW (pack 4) */
     TEST_TYPE(EMREXTCREATEFONTINDIRECTW, 332, 4);
     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, DWORD, ihFont, 8, 4, 4);
     TEST_FIELD(EMREXTCREATEFONTINDIRECTW, EXTLOGFONTW, elfw, 12, 320, 4);
+}
 
+static void test_pack_EMREXTCREATEPEN(void)
+{
     /* EMREXTCREATEPEN (pack 4) */
     TEST_TYPE(EMREXTCREATEPEN, 56, 4);
     TEST_FIELD(EMREXTCREATEPEN, EMR, emr, 0, 8, 4);
@@ -420,21 +573,30 @@
     TEST_FIELD(EMREXTCREATEPEN, DWORD, offBits, 20, 4, 4);
     TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBits, 24, 4, 4);
     TEST_FIELD(EMREXTCREATEPEN, EXTLOGPEN, elp, 28, 28, 4);
+}
 
+static void test_pack_EMREXTFLOODFILL(void)
+{
     /* EMREXTFLOODFILL (pack 4) */
     TEST_TYPE(EMREXTFLOODFILL, 24, 4);
     TEST_FIELD(EMREXTFLOODFILL, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMREXTFLOODFILL, POINTL, ptlStart, 8, 8, 4);
     TEST_FIELD(EMREXTFLOODFILL, COLORREF, crColor, 16, 4, 4);
     TEST_FIELD(EMREXTFLOODFILL, DWORD, iMode, 20, 4, 4);
+}
 
+static void test_pack_EMREXTSELECTCLIPRGN(void)
+{
     /* EMREXTSELECTCLIPRGN (pack 4) */
     TEST_TYPE(EMREXTSELECTCLIPRGN, 20, 4);
     TEST_FIELD(EMREXTSELECTCLIPRGN, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, cbRgnData, 8, 4, 4);
     TEST_FIELD(EMREXTSELECTCLIPRGN, DWORD, iMode, 12, 4, 4);
     TEST_FIELD(EMREXTSELECTCLIPRGN, BYTE[1], RgnData, 16, 1, 1);
+}
 
+static void test_pack_EMREXTTEXTOUTA(void)
+{
     /* EMREXTTEXTOUTA (pack 4) */
     TEST_TYPE(EMREXTTEXTOUTA, 76, 4);
     TEST_FIELD(EMREXTTEXTOUTA, EMR, emr, 0, 8, 4);
@@ -443,12 +605,30 @@
     TEST_FIELD(EMREXTTEXTOUTA, FLOAT, exScale, 28, 4, 4);
     TEST_FIELD(EMREXTTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
     TEST_FIELD(EMREXTTEXTOUTA, EMRTEXT, emrtext, 36, 40, 4);
+}
 
+static void test_pack_EMREXTTEXTOUTW(void)
+{
+    /* EMREXTTEXTOUTW (pack 4) */
+    TEST_TYPE(EMREXTTEXTOUTW, 76, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, FLOAT, exScale, 28, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, EMRTEXT, emrtext, 36, 40, 4);
+}
+
+static void test_pack_EMRFILLPATH(void)
+{
     /* EMRFILLPATH (pack 4) */
     TEST_TYPE(EMRFILLPATH, 24, 4);
     TEST_FIELD(EMRFILLPATH, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRFILLPATH, RECTL, rclBounds, 8, 16, 4);
+}
 
+static void test_pack_EMRFILLRGN(void)
+{
     /* EMRFILLRGN (pack 4) */
     TEST_TYPE(EMRFILLRGN, 36, 4);
     TEST_FIELD(EMRFILLRGN, EMR, emr, 0, 8, 4);
@@ -456,14 +636,27 @@
     TEST_FIELD(EMRFILLRGN, DWORD, cbRgnData, 24, 4, 4);
     TEST_FIELD(EMRFILLRGN, DWORD, ihBrush, 28, 4, 4);
     TEST_FIELD(EMRFILLRGN, BYTE[1], RgnData, 32, 1, 1);
+}
 
+static void test_pack_EMRFLATTENPATH(void)
+{
+    /* EMRFLATTENPATH (pack 4) */
+    TEST_TYPE(EMRFLATTENPATH, 8, 4);
+    TEST_FIELD(EMRFLATTENPATH, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMRFORMAT(void)
+{
     /* EMRFORMAT (pack 4) */
     TEST_TYPE(EMRFORMAT, 16, 4);
     TEST_FIELD(EMRFORMAT, DWORD, dSignature, 0, 4, 4);
     TEST_FIELD(EMRFORMAT, DWORD, nVersion, 4, 4, 4);
     TEST_FIELD(EMRFORMAT, DWORD, cbData, 8, 4, 4);
     TEST_FIELD(EMRFORMAT, DWORD, offData, 12, 4, 4);
+}
 
+static void test_pack_EMRFRAMERGN(void)
+{
     /* EMRFRAMERGN (pack 4) */
     TEST_TYPE(EMRFRAMERGN, 44, 4);
     TEST_FIELD(EMRFRAMERGN, EMR, emr, 0, 8, 4);
@@ -472,38 +665,64 @@
     TEST_FIELD(EMRFRAMERGN, DWORD, ihBrush, 28, 4, 4);
     TEST_FIELD(EMRFRAMERGN, SIZEL, szlStroke, 32, 8, 4);
     TEST_FIELD(EMRFRAMERGN, BYTE[1], RgnData, 40, 1, 1);
+}
 
+static void test_pack_EMRGDICOMMENT(void)
+{
     /* EMRGDICOMMENT (pack 4) */
     TEST_TYPE(EMRGDICOMMENT, 16, 4);
     TEST_FIELD(EMRGDICOMMENT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRGDICOMMENT, DWORD, cbData, 8, 4, 4);
     TEST_FIELD(EMRGDICOMMENT, BYTE[1], Data, 12, 1, 1);
+}
 
+static void test_pack_EMRGLSBOUNDEDRECORD(void)
+{
     /* EMRGLSBOUNDEDRECORD (pack 4) */
     TEST_TYPE(EMRGLSBOUNDEDRECORD, 32, 4);
     TEST_FIELD(EMRGLSBOUNDEDRECORD, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRGLSBOUNDEDRECORD, RECTL, rclBounds, 8, 16, 4);
     TEST_FIELD(EMRGLSBOUNDEDRECORD, DWORD, cbData, 24, 4, 4);
     TEST_FIELD(EMRGLSBOUNDEDRECORD, BYTE[1], Data, 28, 1, 1);
+}
 
+static void test_pack_EMRGLSRECORD(void)
+{
     /* EMRGLSRECORD (pack 4) */
     TEST_TYPE(EMRGLSRECORD, 16, 4);
     TEST_FIELD(EMRGLSRECORD, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRGLSRECORD, DWORD, cbData, 8, 4, 4);
     TEST_FIELD(EMRGLSRECORD, BYTE[1], Data, 12, 1, 1);
+}
 
+static void test_pack_EMRINVERTRGN(void)
+{
     /* EMRINVERTRGN (pack 4) */
     TEST_TYPE(EMRINVERTRGN, 32, 4);
     TEST_FIELD(EMRINVERTRGN, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRINVERTRGN, RECTL, rclBounds, 8, 16, 4);
     TEST_FIELD(EMRINVERTRGN, DWORD, cbRgnData, 24, 4, 4);
     TEST_FIELD(EMRINVERTRGN, BYTE[1], RgnData, 28, 1, 1);
+}
 
+static void test_pack_EMRINTERSECTCLIPRECT(void)
+{
+    /* EMRINTERSECTCLIPRECT (pack 4) */
+    TEST_TYPE(EMRINTERSECTCLIPRECT, 24, 4);
+    TEST_FIELD(EMRINTERSECTCLIPRECT, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRINTERSECTCLIPRECT, RECTL, rclClip, 8, 16, 4);
+}
+
+static void test_pack_EMRLINETO(void)
+{
     /* EMRLINETO (pack 4) */
     TEST_TYPE(EMRLINETO, 16, 4);
     TEST_FIELD(EMRLINETO, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRLINETO, POINTL, ptl, 8, 8, 4);
+}
 
+static void test_pack_EMRMASKBLT(void)
+{
     /* EMRMASKBLT (pack 4) */
     TEST_TYPE(EMRMASKBLT, 128, 4);
     TEST_FIELD(EMRMASKBLT, EMR, emr, 0, 8, 4);
@@ -529,23 +748,63 @@
     TEST_FIELD(EMRMASKBLT, DWORD, cbBmiMask, 116, 4, 4);
     TEST_FIELD(EMRMASKBLT, DWORD, offBitsMask, 120, 4, 4);
     TEST_FIELD(EMRMASKBLT, DWORD, cbBitsMask, 124, 4, 4);
+}
 
+static void test_pack_EMRMODIFYWORLDTRANSFORM(void)
+{
     /* EMRMODIFYWORLDTRANSFORM (pack 4) */
     TEST_TYPE(EMRMODIFYWORLDTRANSFORM, 36, 4);
     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
     TEST_FIELD(EMRMODIFYWORLDTRANSFORM, DWORD, iMode, 32, 4, 4);
+}
 
+static void test_pack_EMRMOVETOEX(void)
+{
+    /* EMRMOVETOEX (pack 4) */
+    TEST_TYPE(EMRMOVETOEX, 16, 4);
+    TEST_FIELD(EMRMOVETOEX, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRMOVETOEX, POINTL, ptl, 8, 8, 4);
+}
+
+static void test_pack_EMROFFSETCLIPRGN(void)
+{
     /* EMROFFSETCLIPRGN (pack 4) */
     TEST_TYPE(EMROFFSETCLIPRGN, 16, 4);
     TEST_FIELD(EMROFFSETCLIPRGN, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMROFFSETCLIPRGN, POINTL, ptlOffset, 8, 8, 4);
+}
 
+static void test_pack_EMRPAINTRGN(void)
+{
+    /* EMRPAINTRGN (pack 4) */
+    TEST_TYPE(EMRPAINTRGN, 32, 4);
+    TEST_FIELD(EMRPAINTRGN, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPAINTRGN, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPAINTRGN, DWORD, cbRgnData, 24, 4, 4);
+    TEST_FIELD(EMRPAINTRGN, BYTE[1], RgnData, 28, 1, 1);
+}
+
+static void test_pack_EMRPIE(void)
+{
+    /* EMRPIE (pack 4) */
+    TEST_TYPE(EMRPIE, 40, 4);
+    TEST_FIELD(EMRPIE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPIE, RECTL, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRPIE, POINTL, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRPIE, POINTL, ptlEnd, 32, 8, 4);
+}
+
+static void test_pack_EMRPIXELFORMAT(void)
+{
     /* EMRPIXELFORMAT (pack 4) */
     TEST_TYPE(EMRPIXELFORMAT, 48, 4);
     TEST_FIELD(EMRPIXELFORMAT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRPIXELFORMAT, PIXELFORMATDESCRIPTOR, pfd, 8, 40, 4);
+}
 
+static void test_pack_EMRPLGBLT(void)
+{
     /* EMRPLGBLT (pack 4) */
     TEST_TYPE(EMRPLGBLT, 140, 4);
     TEST_FIELD(EMRPLGBLT, EMR, emr, 0, 8, 4);
@@ -569,7 +828,30 @@
     TEST_FIELD(EMRPLGBLT, DWORD, cbBmiMask, 128, 4, 4);
     TEST_FIELD(EMRPLGBLT, DWORD, offBitsMask, 132, 4, 4);
     TEST_FIELD(EMRPLGBLT, DWORD, cbBitsMask, 136, 4, 4);
+}
 
+static void test_pack_EMRPOLYBEZIER(void)
+{
+    /* EMRPOLYBEZIER (pack 4) */
+    TEST_TYPE(EMRPOLYBEZIER, 36, 4);
+    TEST_FIELD(EMRPOLYBEZIER, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYBEZIER, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYBEZIER, DWORD, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYBEZIER, POINTL[1], aptl, 28, 8, 4);
+}
+
+static void test_pack_EMRPOLYBEZIERTO(void)
+{
+    /* EMRPOLYBEZIERTO (pack 4) */
+    TEST_TYPE(EMRPOLYBEZIERTO, 36, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, DWORD, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, POINTL[1], aptl, 28, 8, 4);
+}
+
+static void test_pack_EMRPOLYDRAW(void)
+{
     /* EMRPOLYDRAW (pack 4) */
     TEST_TYPE(EMRPOLYDRAW, 40, 4);
     TEST_FIELD(EMRPOLYDRAW, EMR, emr, 0, 8, 4);
@@ -577,14 +859,52 @@
     TEST_FIELD(EMRPOLYDRAW, DWORD, cptl, 24, 4, 4);
     TEST_FIELD(EMRPOLYDRAW, POINTL[1], aptl, 28, 8, 4);
     TEST_FIELD(EMRPOLYDRAW, BYTE[1], abTypes, 36, 1, 1);
+}
 
+static void test_pack_EMRPOLYGON(void)
+{
+    /* EMRPOLYGON (pack 4) */
+    TEST_TYPE(EMRPOLYGON, 36, 4);
+    TEST_FIELD(EMRPOLYGON, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYGON, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYGON, DWORD, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYGON, POINTL[1], aptl, 28, 8, 4);
+}
+
+static void test_pack_EMRPOLYLINE(void)
+{
     /* EMRPOLYLINE (pack 4) */
     TEST_TYPE(EMRPOLYLINE, 36, 4);
     TEST_FIELD(EMRPOLYLINE, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRPOLYLINE, RECTL, rclBounds, 8, 16, 4);
     TEST_FIELD(EMRPOLYLINE, DWORD, cptl, 24, 4, 4);
     TEST_FIELD(EMRPOLYLINE, POINTL[1], aptl, 28, 8, 4);
+}
 
+static void test_pack_EMRPOLYLINETO(void)
+{
+    /* EMRPOLYLINETO (pack 4) */
+    TEST_TYPE(EMRPOLYLINETO, 36, 4);
+    TEST_FIELD(EMRPOLYLINETO, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYLINETO, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYLINETO, DWORD, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYLINETO, POINTL[1], aptl, 28, 8, 4);
+}
+
+static void test_pack_EMRPOLYPOLYGON(void)
+{
+    /* EMRPOLYPOLYGON (pack 4) */
+    TEST_TYPE(EMRPOLYPOLYGON, 44, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, DWORD, nPolys, 24, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, DWORD, cptl, 28, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, DWORD[1], aPolyCounts, 32, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, POINTL[1], aptl, 36, 8, 4);
+}
+
+static void test_pack_EMRPOLYPOLYLINE(void)
+{
     /* EMRPOLYPOLYLINE (pack 4) */
     TEST_TYPE(EMRPOLYPOLYLINE, 44, 4);
     TEST_FIELD(EMRPOLYPOLYLINE, EMR, emr, 0, 8, 4);
@@ -593,7 +913,10 @@
     TEST_FIELD(EMRPOLYPOLYLINE, DWORD, cptl, 28, 4, 4);
     TEST_FIELD(EMRPOLYPOLYLINE, DWORD[1], aPolyCounts, 32, 4, 4);
     TEST_FIELD(EMRPOLYPOLYLINE, POINTL[1], aptl, 36, 8, 4);
+}
 
+static void test_pack_EMRPOLYTEXTOUTA(void)
+{
     /* EMRPOLYTEXTOUTA (pack 4) */
     TEST_TYPE(EMRPOLYTEXTOUTA, 80, 4);
     TEST_FIELD(EMRPOLYTEXTOUTA, EMR, emr, 0, 8, 4);
@@ -603,24 +926,71 @@
     TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
     TEST_FIELD(EMRPOLYTEXTOUTA, LONG, cStrings, 36, 4, 4);
     TEST_FIELD(EMRPOLYTEXTOUTA, EMRTEXT[1], aemrtext, 40, 40, 4);
+}
 
+static void test_pack_EMRPOLYTEXTOUTW(void)
+{
+    /* EMRPOLYTEXTOUTW (pack 4) */
+    TEST_TYPE(EMRPOLYTEXTOUTW, 80, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, RECTL, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, DWORD, iGraphicsMode, 24, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, FLOAT, exScale, 28, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, FLOAT, eyScale, 32, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, LONG, cStrings, 36, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, EMRTEXT[1], aemrtext, 40, 40, 4);
+}
+
+static void test_pack_EMRREALIZEPALETTE(void)
+{
+    /* EMRREALIZEPALETTE (pack 4) */
+    TEST_TYPE(EMRREALIZEPALETTE, 8, 4);
+    TEST_FIELD(EMRREALIZEPALETTE, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMRRECTANGLE(void)
+{
+    /* EMRRECTANGLE (pack 4) */
+    TEST_TYPE(EMRRECTANGLE, 24, 4);
+    TEST_FIELD(EMRRECTANGLE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRRECTANGLE, RECTL, rclBox, 8, 16, 4);
+}
+
+static void test_pack_EMRRESIZEPALETTE(void)
+{
     /* EMRRESIZEPALETTE (pack 4) */
     TEST_TYPE(EMRRESIZEPALETTE, 16, 4);
     TEST_FIELD(EMRRESIZEPALETTE, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRRESIZEPALETTE, DWORD, ihPal, 8, 4, 4);
     TEST_FIELD(EMRRESIZEPALETTE, DWORD, cEntries, 12, 4, 4);
+}
 
+static void test_pack_EMRRESTOREDC(void)
+{
     /* EMRRESTOREDC (pack 4) */
     TEST_TYPE(EMRRESTOREDC, 12, 4);
     TEST_FIELD(EMRRESTOREDC, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRRESTOREDC, LONG, iRelative, 8, 4, 4);
+}
 
+static void test_pack_EMRROUNDRECT(void)
+{
     /* EMRROUNDRECT (pack 4) */
     TEST_TYPE(EMRROUNDRECT, 32, 4);
     TEST_FIELD(EMRROUNDRECT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRROUNDRECT, RECTL, rclBox, 8, 16, 4);
     TEST_FIELD(EMRROUNDRECT, SIZEL, szlCorner, 24, 8, 4);
+}
 
+static void test_pack_EMRSAVEDC(void)
+{
+    /* EMRSAVEDC (pack 4) */
+    TEST_TYPE(EMRSAVEDC, 8, 4);
+    TEST_FIELD(EMRSAVEDC, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMRSCALEVIEWPORTEXTEX(void)
+{
     /* EMRSCALEVIEWPORTEXTEX (pack 4) */
     TEST_TYPE(EMRSCALEVIEWPORTEXTEX, 24, 4);
     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
@@ -628,37 +998,93 @@
     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xDenom, 12, 4, 4);
     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yNum, 16, 4, 4);
     TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yDenom, 20, 4, 4);
+}
 
+static void test_pack_EMRSCALEWINDOWEXTEX(void)
+{
+    /* EMRSCALEWINDOWEXTEX (pack 4) */
+    TEST_TYPE(EMRSCALEWINDOWEXTEX, 24, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, xNum, 8, 4, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, xDenom, 12, 4, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, yNum, 16, 4, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, LONG, yDenom, 20, 4, 4);
+}
+
+static void test_pack_EMRSELECTCLIPPATH(void)
+{
     /* EMRSELECTCLIPPATH (pack 4) */
     TEST_TYPE(EMRSELECTCLIPPATH, 12, 4);
     TEST_FIELD(EMRSELECTCLIPPATH, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSELECTCLIPPATH, DWORD, iMode, 8, 4, 4);
+}
 
+static void test_pack_EMRSELECTCOLORSPACE(void)
+{
+    /* EMRSELECTCOLORSPACE (pack 4) */
+    TEST_TYPE(EMRSELECTCOLORSPACE, 12, 4);
+    TEST_FIELD(EMRSELECTCOLORSPACE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSELECTCOLORSPACE, DWORD, ihCS, 8, 4, 4);
+}
+
+static void test_pack_EMRSELECTOBJECT(void)
+{
+    /* EMRSELECTOBJECT (pack 4) */
+    TEST_TYPE(EMRSELECTOBJECT, 12, 4);
+    TEST_FIELD(EMRSELECTOBJECT, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSELECTOBJECT, DWORD, ihObject, 8, 4, 4);
+}
+
+static void test_pack_EMRSELECTPALETTE(void)
+{
     /* EMRSELECTPALETTE (pack 4) */
     TEST_TYPE(EMRSELECTPALETTE, 12, 4);
     TEST_FIELD(EMRSELECTPALETTE, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSELECTPALETTE, DWORD, ihPal, 8, 4, 4);
+}
 
+static void test_pack_EMRSETARCDIRECTION(void)
+{
     /* EMRSETARCDIRECTION (pack 4) */
     TEST_TYPE(EMRSETARCDIRECTION, 12, 4);
     TEST_FIELD(EMRSETARCDIRECTION, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETARCDIRECTION, DWORD, iArcDirection, 8, 4, 4);
+}
 
+static void test_pack_EMRSETBKCOLOR(void)
+{
     /* EMRSETBKCOLOR (pack 4) */
     TEST_TYPE(EMRSETBKCOLOR, 12, 4);
     TEST_FIELD(EMRSETBKCOLOR, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETBKCOLOR, COLORREF, crColor, 8, 4, 4);
+}
 
+static void test_pack_EMRSETBKMODE(void)
+{
+    /* EMRSETBKMODE (pack 4) */
+    TEST_TYPE(EMRSETBKMODE, 12, 4);
+    TEST_FIELD(EMRSETBKMODE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETBKMODE, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETBRUSHORGEX(void)
+{
     /* EMRSETBRUSHORGEX (pack 4) */
     TEST_TYPE(EMRSETBRUSHORGEX, 16, 4);
     TEST_FIELD(EMRSETBRUSHORGEX, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETBRUSHORGEX, POINTL, ptlOrigin, 8, 8, 4);
+}
 
+static void test_pack_EMRSETCOLORADJUSTMENT(void)
+{
     /* EMRSETCOLORADJUSTMENT (pack 4) */
     TEST_TYPE(EMRSETCOLORADJUSTMENT, 32, 4);
     TEST_FIELD(EMRSETCOLORADJUSTMENT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETCOLORADJUSTMENT, COLORADJUSTMENT, ColorAdjustment, 8, 24, 2);
+}
 
+static void test_pack_EMRSETDIBITSTODEVICE(void)
+{
     /* EMRSETDIBITSTODEVICE (pack 4) */
     TEST_TYPE(EMRSETDIBITSTODEVICE, 76, 4);
     TEST_FIELD(EMRSETDIBITSTODEVICE, EMR, emr, 0, 8, 4);
@@ -676,33 +1102,138 @@
     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iUsageSrc, 64, 4, 4);
     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iStartScan, 68, 4, 4);
     TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cScans, 72, 4, 4);
+}
 
+static void test_pack_EMRSETICMMODE(void)
+{
+    /* EMRSETICMMODE (pack 4) */
+    TEST_TYPE(EMRSETICMMODE, 12, 4);
+    TEST_FIELD(EMRSETICMMODE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETICMMODE, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETMAPMODE(void)
+{
+    /* EMRSETMAPMODE (pack 4) */
+    TEST_TYPE(EMRSETMAPMODE, 12, 4);
+    TEST_FIELD(EMRSETMAPMODE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETMAPMODE, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETMAPPERFLAGS(void)
+{
     /* EMRSETMAPPERFLAGS (pack 4) */
     TEST_TYPE(EMRSETMAPPERFLAGS, 12, 4);
     TEST_FIELD(EMRSETMAPPERFLAGS, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETMAPPERFLAGS, DWORD, dwFlags, 8, 4, 4);
+}
 
+static void test_pack_EMRSETMETARGN(void)
+{
+    /* EMRSETMETARGN (pack 4) */
+    TEST_TYPE(EMRSETMETARGN, 8, 4);
+    TEST_FIELD(EMRSETMETARGN, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_EMRSETMITERLIMIT(void)
+{
     /* EMRSETMITERLIMIT (pack 4) */
     TEST_TYPE(EMRSETMITERLIMIT, 12, 4);
     TEST_FIELD(EMRSETMITERLIMIT, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETMITERLIMIT, FLOAT, eMiterLimit, 8, 4, 4);
+}
 
+static void test_pack_EMRSETPIXELV(void)
+{
     /* EMRSETPIXELV (pack 4) */
     TEST_TYPE(EMRSETPIXELV, 20, 4);
     TEST_FIELD(EMRSETPIXELV, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETPIXELV, POINTL, ptlPixel, 8, 8, 4);
     TEST_FIELD(EMRSETPIXELV, COLORREF, crColor, 16, 4, 4);
+}
 
+static void test_pack_EMRSETPOLYFILLMODE(void)
+{
+    /* EMRSETPOLYFILLMODE (pack 4) */
+    TEST_TYPE(EMRSETPOLYFILLMODE, 12, 4);
+    TEST_FIELD(EMRSETPOLYFILLMODE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETPOLYFILLMODE, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETROP2(void)
+{
+    /* EMRSETROP2 (pack 4) */
+    TEST_TYPE(EMRSETROP2, 12, 4);
+    TEST_FIELD(EMRSETROP2, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETROP2, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETSTRETCHBLTMODE(void)
+{
+    /* EMRSETSTRETCHBLTMODE (pack 4) */
+    TEST_TYPE(EMRSETSTRETCHBLTMODE, 12, 4);
+    TEST_FIELD(EMRSETSTRETCHBLTMODE, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETSTRETCHBLTMODE, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETTEXTALIGN(void)
+{
+    /* EMRSETTEXTALIGN (pack 4) */
+    TEST_TYPE(EMRSETTEXTALIGN, 12, 4);
+    TEST_FIELD(EMRSETTEXTALIGN, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETTEXTALIGN, DWORD, iMode, 8, 4, 4);
+}
+
+static void test_pack_EMRSETTEXTCOLOR(void)
+{
+    /* EMRSETTEXTCOLOR (pack 4) */
+    TEST_TYPE(EMRSETTEXTCOLOR, 12, 4);
+    TEST_FIELD(EMRSETTEXTCOLOR, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETTEXTCOLOR, COLORREF, crColor, 8, 4, 4);
+}
+
+static void test_pack_EMRSETVIEWPORTEXTEX(void)
+{
     /* EMRSETVIEWPORTEXTEX (pack 4) */
     TEST_TYPE(EMRSETVIEWPORTEXTEX, 16, 4);
     TEST_FIELD(EMRSETVIEWPORTEXTEX, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETVIEWPORTEXTEX, SIZEL, szlExtent, 8, 8, 4);
+}
 
+static void test_pack_EMRSETVIEWPORTORGEX(void)
+{
+    /* EMRSETVIEWPORTORGEX (pack 4) */
+    TEST_TYPE(EMRSETVIEWPORTORGEX, 16, 4);
+    TEST_FIELD(EMRSETVIEWPORTORGEX, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETVIEWPORTORGEX, POINTL, ptlOrigin, 8, 8, 4);
+}
+
+static void test_pack_EMRSETWINDOWEXTEX(void)
+{
+    /* EMRSETWINDOWEXTEX (pack 4) */
+    TEST_TYPE(EMRSETWINDOWEXTEX, 16, 4);
+    TEST_FIELD(EMRSETWINDOWEXTEX, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETWINDOWEXTEX, SIZEL, szlExtent, 8, 8, 4);
+}
+
+static void test_pack_EMRSETWINDOWORGEX(void)
+{
+    /* EMRSETWINDOWORGEX (pack 4) */
+    TEST_TYPE(EMRSETWINDOWORGEX, 16, 4);
+    TEST_FIELD(EMRSETWINDOWORGEX, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETWINDOWORGEX, POINTL, ptlOrigin, 8, 8, 4);
+}
+
+static void test_pack_EMRSETWORLDTRANSFORM(void)
+{
     /* EMRSETWORLDTRANSFORM (pack 4) */
     TEST_TYPE(EMRSETWORLDTRANSFORM, 32, 4);
     TEST_FIELD(EMRSETWORLDTRANSFORM, EMR, emr, 0, 8, 4);
     TEST_FIELD(EMRSETWORLDTRANSFORM, XFORM, xform, 8, 24, 4);
+}
 
+static void test_pack_EMRSTRETCHBLT(void)
+{
     /* EMRSTRETCHBLT (pack 4) */
     TEST_TYPE(EMRSTRETCHBLT, 108, 4);
     TEST_FIELD(EMRSTRETCHBLT, EMR, emr, 0, 8, 4);
@@ -723,7 +1254,10 @@
     TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBitsSrc, 96, 4, 4);
     TEST_FIELD(EMRSTRETCHBLT, LONG, cxSrc, 100, 4, 4);
     TEST_FIELD(EMRSTRETCHBLT, LONG, cySrc, 104, 4, 4);
+}
 
+static void test_pack_EMRSTRETCHDIBITS(void)
+{
     /* EMRSTRETCHDIBITS (pack 4) */
     TEST_TYPE(EMRSTRETCHDIBITS, 80, 4);
     TEST_FIELD(EMRSTRETCHDIBITS, EMR, emr, 0, 8, 4);
@@ -742,7 +1276,26 @@
     TEST_FIELD(EMRSTRETCHDIBITS, DWORD, dwRop, 68, 4, 4);
     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxDest, 72, 4, 4);
     TEST_FIELD(EMRSTRETCHDIBITS, LONG, cyDest, 76, 4, 4);
+}
 
+static void test_pack_EMRSTROKEANDFILLPATH(void)
+{
+    /* EMRSTROKEANDFILLPATH (pack 4) */
+    TEST_TYPE(EMRSTROKEANDFILLPATH, 24, 4);
+    TEST_FIELD(EMRSTROKEANDFILLPATH, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSTROKEANDFILLPATH, RECTL, rclBounds, 8, 16, 4);
+}
+
+static void test_pack_EMRSTROKEPATH(void)
+{
+    /* EMRSTROKEPATH (pack 4) */
+    TEST_TYPE(EMRSTROKEPATH, 24, 4);
+    TEST_FIELD(EMRSTROKEPATH, EMR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSTROKEPATH, RECTL, rclBounds, 8, 16, 4);
+}
+
+static void test_pack_EMRTEXT(void)
+{
     /* EMRTEXT (pack 4) */
     TEST_TYPE(EMRTEXT, 40, 4);
     TEST_FIELD(EMRTEXT, POINTL, ptlReference, 0, 8, 4);
@@ -751,7 +1304,17 @@
     TEST_FIELD(EMRTEXT, DWORD, fOptions, 16, 4, 4);
     TEST_FIELD(EMRTEXT, RECTL, rcl, 20, 16, 4);
     TEST_FIELD(EMRTEXT, DWORD, offDx, 36, 4, 4);
+}
 
+static void test_pack_EMRWIDENPATH(void)
+{
+    /* EMRWIDENPATH (pack 4) */
+    TEST_TYPE(EMRWIDENPATH, 8, 4);
+    TEST_FIELD(EMRWIDENPATH, EMR, emr, 0, 8, 4);
+}
+
+static void test_pack_ENHMETAHEADER(void)
+{
     /* ENHMETAHEADER (pack 4) */
     TEST_FIELD(ENHMETAHEADER, DWORD, iType, 0, 4, 4);
     TEST_FIELD(ENHMETAHEADER, DWORD, nSize, 4, 4, 4);
@@ -771,41 +1334,63 @@
     TEST_FIELD(ENHMETAHEADER, DWORD, cbPixelFormat, 88, 4, 4);
     TEST_FIELD(ENHMETAHEADER, DWORD, offPixelFormat, 92, 4, 4);
     TEST_FIELD(ENHMETAHEADER, DWORD, bOpenGL, 96, 4, 4);
+}
 
+static void test_pack_ENHMETARECORD(void)
+{
     /* ENHMETARECORD (pack 4) */
     TEST_TYPE(ENHMETARECORD, 12, 4);
     TEST_FIELD(ENHMETARECORD, DWORD, iType, 0, 4, 4);
     TEST_FIELD(ENHMETARECORD, DWORD, nSize, 4, 4, 4);
     TEST_FIELD(ENHMETARECORD, DWORD[1], dParm, 8, 4, 4);
+}
 
+static void test_pack_ENHMFENUMPROC(void)
+{
     /* ENHMFENUMPROC */
+    TEST_TYPE(ENHMFENUMPROC, 4, 4);
+}
 
+static void test_pack_ENUMLOGFONTA(void)
+{
     /* ENUMLOGFONTA (pack 4) */
     TEST_TYPE(ENUMLOGFONTA, 156, 4);
     TEST_FIELD(ENUMLOGFONTA, LOGFONTA, elfLogFont, 0, 60, 4);
     TEST_FIELD(ENUMLOGFONTA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
     TEST_FIELD(ENUMLOGFONTA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
+}
 
+static void test_pack_ENUMLOGFONTEXA(void)
+{
     /* ENUMLOGFONTEXA (pack 4) */
     TEST_TYPE(ENUMLOGFONTEXA, 188, 4);
     TEST_FIELD(ENUMLOGFONTEXA, LOGFONTA, elfLogFont, 0, 60, 4);
     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
     TEST_FIELD(ENUMLOGFONTEXA, BYTE[LF_FACESIZE], elfScript, 156, 32, 1);
+}
 
+static void test_pack_ENUMLOGFONTEXW(void)
+{
     /* ENUMLOGFONTEXW (pack 4) */
     TEST_TYPE(ENUMLOGFONTEXW, 348, 4);
     TEST_FIELD(ENUMLOGFONTEXW, LOGFONTW, elfLogFont, 0, 92, 4);
     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
     TEST_FIELD(ENUMLOGFONTEXW, WCHAR[LF_FACESIZE], elfScript, 284, 64, 2);
+}
 
+static void test_pack_ENUMLOGFONTW(void)
+{
     /* ENUMLOGFONTW (pack 4) */
     TEST_TYPE(ENUMLOGFONTW, 284, 4);
     TEST_FIELD(ENUMLOGFONTW, LOGFONTW, elfLogFont, 0, 92, 4);
     TEST_FIELD(ENUMLOGFONTW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
     TEST_FIELD(ENUMLOGFONTW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
+}
 
+static void test_pack_EXTLOGFONTA(void)
+{
     /* EXTLOGFONTA (pack 4) */
     TEST_TYPE(EXTLOGFONTA, 192, 4);
     TEST_FIELD(EXTLOGFONTA, LOGFONTA, elfLogFont, 0, 60, 4);
@@ -818,7 +1403,10 @@
     TEST_FIELD(EXTLOGFONTA, BYTE[ELF_VENDOR_SIZE], elfVendorId, 172, 4, 1);
     TEST_FIELD(EXTLOGFONTA, DWORD, elfCulture, 176, 4, 4);
     TEST_FIELD(EXTLOGFONTA, PANOSE, elfPanose, 180, 10, 1);
+}
 
+static void test_pack_EXTLOGFONTW(void)
+{
     /* EXTLOGFONTW (pack 4) */
     TEST_TYPE(EXTLOGFONTW, 320, 4);
     TEST_FIELD(EXTLOGFONTW, LOGFONTW, elfLogFont, 0, 92, 4);
@@ -831,7 +1419,10 @@
     TEST_FIELD(EXTLOGFONTW, BYTE[ELF_VENDOR_SIZE], elfVendorId, 300, 4, 1);
     TEST_FIELD(EXTLOGFONTW, DWORD, elfCulture, 304, 4, 4);
     TEST_FIELD(EXTLOGFONTW, PANOSE, elfPanose, 308, 10, 1);
+}
 
+static void test_pack_EXTLOGPEN(void)
+{
     /* EXTLOGPEN (pack 4) */
     TEST_TYPE(EXTLOGPEN, 28, 4);
     TEST_FIELD(EXTLOGPEN, DWORD, elpPenStyle, 0, 4, 4);
@@ -841,55 +1432,66 @@
     TEST_FIELD(EXTLOGPEN, LONG, elpHatch, 16, 4, 4);
     TEST_FIELD(EXTLOGPEN, DWORD, elpNumEntries, 20, 4, 4);
     TEST_FIELD(EXTLOGPEN, DWORD[1], elpStyleEntry, 24, 4, 4);
+}
 
+static void test_pack_FIXED(void)
+{
     /* FIXED (pack 4) */
     TEST_TYPE(FIXED, 4, 2);
     TEST_FIELD(FIXED, WORD, fract, 0, 2, 2);
     TEST_FIELD(FIXED, SHORT, value, 2, 2, 2);
+}
 
+static void test_pack_FONTENUMPROCA(void)
+{
     /* FONTENUMPROCA */
+    TEST_TYPE(FONTENUMPROCA, 4, 4);
+}
 
-    /* FONTENUMPROCEXA */
-
-    /* FONTENUMPROCEXW */
-
+static void test_pack_FONTENUMPROCW(void)
+{
     /* FONTENUMPROCW */
+    TEST_TYPE(FONTENUMPROCW, 4, 4);
+}
 
+static void test_pack_FONTSIGNATURE(void)
+{
     /* FONTSIGNATURE (pack 4) */
     TEST_TYPE(FONTSIGNATURE, 24, 4);
     TEST_FIELD(FONTSIGNATURE, DWORD[4], fsUsb, 0, 16, 4);
     TEST_FIELD(FONTSIGNATURE, DWORD[2], fsCsb, 16, 8, 4);
+}
 
+static void test_pack_FXPT16DOT16(void)
+{
     /* FXPT16DOT16 */
     TEST_TYPE(FXPT16DOT16, 4, 4);
+}
 
+static void test_pack_FXPT2DOT30(void)
+{
     /* FXPT2DOT30 */
     TEST_TYPE(FXPT2DOT30, 4, 4);
+}
 
+static void test_pack_GCP_RESULTSA(void)
+{
     /* GCP_RESULTSA (pack 4) */
-    TEST_TYPE(GCP_RESULTSA, 36, 4);
     TEST_FIELD(GCP_RESULTSA, DWORD, lStructSize, 0, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, LPSTR, lpOutString, 4, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, UINT *, lpOrder, 8, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, INT *, lpDx, 12, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, INT *, lpCaretPos, 16, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, LPSTR, lpClass, 20, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, LPWSTR, lpGlyphs, 24, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, UINT, nGlyphs, 28, 4, 4);
-    TEST_FIELD(GCP_RESULTSA, UINT, nMaxFit, 32, 4, 4);
+}
 
+static void test_pack_GCP_RESULTSW(void)
+{
     /* GCP_RESULTSW (pack 4) */
-    TEST_TYPE(GCP_RESULTSW, 36, 4);
     TEST_FIELD(GCP_RESULTSW, DWORD, lStructSize, 0, 4, 4);
     TEST_FIELD(GCP_RESULTSW, LPWSTR, lpOutString, 4, 4, 4);
     TEST_FIELD(GCP_RESULTSW, UINT *, lpOrder, 8, 4, 4);
     TEST_FIELD(GCP_RESULTSW, INT *, lpDx, 12, 4, 4);
     TEST_FIELD(GCP_RESULTSW, INT *, lpCaretPos, 16, 4, 4);
-    TEST_FIELD(GCP_RESULTSW, LPSTR, lpClass, 20, 4, 4);
-    TEST_FIELD(GCP_RESULTSW, LPWSTR, lpGlyphs, 24, 4, 4);
-    TEST_FIELD(GCP_RESULTSW, UINT, nGlyphs, 28, 4, 4);
-    TEST_FIELD(GCP_RESULTSW, UINT, nMaxFit, 32, 4, 4);
+}
 
+static void test_pack_GLYPHMETRICS(void)
+{
     /* GLYPHMETRICS (pack 4) */
     TEST_TYPE(GLYPHMETRICS, 20, 4);
     TEST_FIELD(GLYPHMETRICS, UINT, gmBlackBoxX, 0, 4, 4);
@@ -897,50 +1499,85 @@
     TEST_FIELD(GLYPHMETRICS, POINT, gmptGlyphOrigin, 8, 8, 4);
     TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncX, 16, 2, 2);
     TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncY, 18, 2, 2);
+}
 
+static void test_pack_GOBJENUMPROC(void)
+{
     /* GOBJENUMPROC */
+    TEST_TYPE(GOBJENUMPROC, 4, 4);
+}
 
+static void test_pack_GRADIENT_RECT(void)
+{
     /* GRADIENT_RECT (pack 4) */
     TEST_TYPE(GRADIENT_RECT, 8, 4);
     TEST_FIELD(GRADIENT_RECT, ULONG, UpperLeft, 0, 4, 4);
     TEST_FIELD(GRADIENT_RECT, ULONG, LowerRight, 4, 4, 4);
+}
 
+static void test_pack_GRADIENT_TRIANGLE(void)
+{
     /* GRADIENT_TRIANGLE (pack 4) */
     TEST_TYPE(GRADIENT_TRIANGLE, 12, 4);
     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex1, 0, 4, 4);
     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex2, 4, 4, 4);
     TEST_FIELD(GRADIENT_TRIANGLE, ULONG, Vertex3, 8, 4, 4);
+}
 
+static void test_pack_HANDLETABLE(void)
+{
     /* HANDLETABLE (pack 4) */
     TEST_TYPE(HANDLETABLE, 4, 4);
     TEST_FIELD(HANDLETABLE, HGDIOBJ[1], objectHandle, 0, 4, 4);
+}
 
+static void test_pack_KERNINGPAIR(void)
+{
     /* KERNINGPAIR (pack 4) */
     TEST_TYPE(KERNINGPAIR, 8, 4);
     TEST_FIELD(KERNINGPAIR, WORD, wFirst, 0, 2, 2);
     TEST_FIELD(KERNINGPAIR, WORD, wSecond, 2, 2, 2);
     TEST_FIELD(KERNINGPAIR, INT, iKernAmount, 4, 4, 4);
+}
 
+static void test_pack_LCSCSTYPE(void)
+{
     /* LCSCSTYPE */
     TEST_TYPE(LCSCSTYPE, 4, 4);
+}
 
+static void test_pack_LCSGAMUTMATCH(void)
+{
     /* LCSGAMUTMATCH */
     TEST_TYPE(LCSGAMUTMATCH, 4, 4);
+}
 
+static void test_pack_LINEDDAPROC(void)
+{
     /* LINEDDAPROC */
+    TEST_TYPE(LINEDDAPROC, 4, 4);
+}
 
+static void test_pack_LOCALESIGNATURE(void)
+{
     /* LOCALESIGNATURE (pack 4) */
     TEST_TYPE(LOCALESIGNATURE, 32, 4);
     TEST_FIELD(LOCALESIGNATURE, DWORD[4], lsUsb, 0, 16, 4);
     TEST_FIELD(LOCALESIGNATURE, DWORD[2], lsCsbDefault, 16, 8, 4);
     TEST_FIELD(LOCALESIGNATURE, DWORD[2], lsCsbSupported, 24, 8, 4);
+}
 
+static void test_pack_LOGBRUSH(void)
+{
     /* LOGBRUSH (pack 4) */
     TEST_TYPE(LOGBRUSH, 12, 4);
     TEST_FIELD(LOGBRUSH, UINT, lbStyle, 0, 4, 4);
     TEST_FIELD(LOGBRUSH, COLORREF, lbColor, 4, 4, 4);
     TEST_FIELD(LOGBRUSH, INT, lbHatch, 8, 4, 4);
+}
 
+static void test_pack_LOGCOLORSPACEA(void)
+{
     /* LOGCOLORSPACEA (pack 4) */
     TEST_TYPE(LOGCOLORSPACEA, 328, 4);
     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsSignature, 0, 4, 4);
@@ -953,7 +1590,10 @@
     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaGreen, 60, 4, 4);
     TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaBlue, 64, 4, 4);
     TEST_FIELD(LOGCOLORSPACEA, CHAR[MAX_PATH], lcsFilename, 68, 260, 1);
+}
 
+static void test_pack_LOGCOLORSPACEW(void)
+{
     /* LOGCOLORSPACEW (pack 4) */
     TEST_TYPE(LOGCOLORSPACEW, 588, 4);
     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsSignature, 0, 4, 4);
@@ -966,7 +1606,10 @@
     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaGreen, 60, 4, 4);
     TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaBlue, 64, 4, 4);
     TEST_FIELD(LOGCOLORSPACEW, WCHAR[MAX_PATH], lcsFilename, 68, 520, 2);
+}
 
+static void test_pack_LOGFONTA(void)
+{
     /* LOGFONTA (pack 4) */
     TEST_TYPE(LOGFONTA, 60, 4);
     TEST_FIELD(LOGFONTA, LONG, lfHeight, 0, 4, 4);
@@ -983,7 +1626,10 @@
     TEST_FIELD(LOGFONTA, BYTE, lfQuality, 26, 1, 1);
     TEST_FIELD(LOGFONTA, BYTE, lfPitchAndFamily, 27, 1, 1);
     TEST_FIELD(LOGFONTA, CHAR[LF_FACESIZE], lfFaceName, 28, 32, 1);
+}
 
+static void test_pack_LOGFONTW(void)
+{
     /* LOGFONTW (pack 4) */
     TEST_TYPE(LOGFONTW, 92, 4);
     TEST_FIELD(LOGFONTW, LONG, lfHeight, 0, 4, 4);
@@ -1000,286 +1646,499 @@
     TEST_FIELD(LOGFONTW, BYTE, lfQuality, 26, 1, 1);
     TEST_FIELD(LOGFONTW, BYTE, lfPitchAndFamily, 27, 1, 1);
     TEST_FIELD(LOGFONTW, WCHAR[LF_FACESIZE], lfFaceName, 28, 64, 2);
+}
 
+static void test_pack_LOGPEN(void)
+{
     /* LOGPEN (pack 4) */
     TEST_TYPE(LOGPEN, 16, 4);
     TEST_FIELD(LOGPEN, UINT, lopnStyle, 0, 4, 4);
     TEST_FIELD(LOGPEN, POINT, lopnWidth, 4, 8, 4);
     TEST_FIELD(LOGPEN, COLORREF, lopnColor, 12, 4, 4);
+}
 
+static void test_pack_LPABC(void)
+{
     /* LPABC */
     TEST_TYPE(LPABC, 4, 4);
     TEST_TYPE_POINTER(LPABC, 12, 4);
+}
 
+static void test_pack_LPABCFLOAT(void)
+{
     /* LPABCFLOAT */
     TEST_TYPE(LPABCFLOAT, 4, 4);
     TEST_TYPE_POINTER(LPABCFLOAT, 12, 4);
+}
 
+static void test_pack_LPBITMAP(void)
+{
     /* LPBITMAP */
     TEST_TYPE(LPBITMAP, 4, 4);
     TEST_TYPE_POINTER(LPBITMAP, 24, 4);
+}
 
+static void test_pack_LPBITMAPCOREHEADER(void)
+{
     /* LPBITMAPCOREHEADER */
     TEST_TYPE(LPBITMAPCOREHEADER, 4, 4);
     TEST_TYPE_POINTER(LPBITMAPCOREHEADER, 12, 4);
+}
 
+static void test_pack_LPBITMAPCOREINFO(void)
+{
     /* LPBITMAPCOREINFO */
     TEST_TYPE(LPBITMAPCOREINFO, 4, 4);
     TEST_TYPE_POINTER(LPBITMAPCOREINFO, 16, 4);
+}
 
+static void test_pack_LPBITMAPFILEHEADER(void)
+{
     /* LPBITMAPFILEHEADER */
     TEST_TYPE(LPBITMAPFILEHEADER, 4, 4);
     TEST_TYPE_POINTER(LPBITMAPFILEHEADER, 14, 2);
+}
 
+static void test_pack_LPBITMAPINFO(void)
+{
     /* LPBITMAPINFO */
     TEST_TYPE(LPBITMAPINFO, 4, 4);
     TEST_TYPE_POINTER(LPBITMAPINFO, 44, 4);
+}
 
+static void test_pack_LPBITMAPINFOHEADER(void)
+{
     /* LPBITMAPINFOHEADER */
     TEST_TYPE(LPBITMAPINFOHEADER, 4, 4);
     TEST_TYPE_POINTER(LPBITMAPINFOHEADER, 40, 4);
+}
 
+static void test_pack_LPBITMAPV5HEADER(void)
+{
     /* LPBITMAPV5HEADER */
     TEST_TYPE(LPBITMAPV5HEADER, 4, 4);
     TEST_TYPE_POINTER(LPBITMAPV5HEADER, 124, 4);
+}
 
+static void test_pack_LPCHARSETINFO(void)
+{
     /* LPCHARSETINFO */
     TEST_TYPE(LPCHARSETINFO, 4, 4);
     TEST_TYPE_POINTER(LPCHARSETINFO, 32, 4);
+}
 
+static void test_pack_LPCIEXYZ(void)
+{
     /* LPCIEXYZ */
     TEST_TYPE(LPCIEXYZ, 4, 4);
     TEST_TYPE_POINTER(LPCIEXYZ, 12, 4);
+}
 
+static void test_pack_LPCIEXYZTRIPLE(void)
+{
     /* LPCIEXYZTRIPLE */
     TEST_TYPE(LPCIEXYZTRIPLE, 4, 4);
     TEST_TYPE_POINTER(LPCIEXYZTRIPLE, 36, 4);
+}
 
+static void test_pack_LPCOLORADJUSTMENT(void)
+{
     /* LPCOLORADJUSTMENT */
     TEST_TYPE(LPCOLORADJUSTMENT, 4, 4);
     TEST_TYPE_POINTER(LPCOLORADJUSTMENT, 24, 2);
+}
 
+static void test_pack_LPDEVMODEA(void)
+{
     /* LPDEVMODEA */
     TEST_TYPE(LPDEVMODEA, 4, 4);
+}
 
+static void test_pack_LPDEVMODEW(void)
+{
     /* LPDEVMODEW */
     TEST_TYPE(LPDEVMODEW, 4, 4);
+}
 
+static void test_pack_LPDIBSECTION(void)
+{
     /* LPDIBSECTION */
     TEST_TYPE(LPDIBSECTION, 4, 4);
     TEST_TYPE_POINTER(LPDIBSECTION, 84, 4);
+}
 
+static void test_pack_LPDISPLAY_DEVICEA(void)
+{
     /* LPDISPLAY_DEVICEA */
     TEST_TYPE(LPDISPLAY_DEVICEA, 4, 4);
+}
 
+static void test_pack_LPDISPLAY_DEVICEW(void)
+{
     /* LPDISPLAY_DEVICEW */
     TEST_TYPE(LPDISPLAY_DEVICEW, 4, 4);
+}
 
+static void test_pack_LPDOCINFOA(void)
+{
     /* LPDOCINFOA */
     TEST_TYPE(LPDOCINFOA, 4, 4);
     TEST_TYPE_POINTER(LPDOCINFOA, 20, 4);
+}
 
+static void test_pack_LPDOCINFOW(void)
+{
     /* LPDOCINFOW */
     TEST_TYPE(LPDOCINFOW, 4, 4);
     TEST_TYPE_POINTER(LPDOCINFOW, 20, 4);
+}
 
+static void test_pack_LPENHMETAHEADER(void)
+{
     /* LPENHMETAHEADER */
     TEST_TYPE(LPENHMETAHEADER, 4, 4);
+}
 
+static void test_pack_LPENHMETARECORD(void)
+{
     /* LPENHMETARECORD */
     TEST_TYPE(LPENHMETARECORD, 4, 4);
     TEST_TYPE_POINTER(LPENHMETARECORD, 12, 4);
+}
 
+static void test_pack_LPENUMLOGFONTA(void)
+{
     /* LPENUMLOGFONTA */
     TEST_TYPE(LPENUMLOGFONTA, 4, 4);
     TEST_TYPE_POINTER(LPENUMLOGFONTA, 156, 4);
+}
 
+static void test_pack_LPENUMLOGFONTEXA(void)
+{
     /* LPENUMLOGFONTEXA */
     TEST_TYPE(LPENUMLOGFONTEXA, 4, 4);
     TEST_TYPE_POINTER(LPENUMLOGFONTEXA, 188, 4);
+}
 
+static void test_pack_LPENUMLOGFONTEXW(void)
+{
     /* LPENUMLOGFONTEXW */
     TEST_TYPE(LPENUMLOGFONTEXW, 4, 4);
     TEST_TYPE_POINTER(LPENUMLOGFONTEXW, 348, 4);
+}
 
+static void test_pack_LPENUMLOGFONTW(void)
+{
     /* LPENUMLOGFONTW */
     TEST_TYPE(LPENUMLOGFONTW, 4, 4);
     TEST_TYPE_POINTER(LPENUMLOGFONTW, 284, 4);
+}
 
+static void test_pack_LPEXTLOGFONTA(void)
+{
     /* LPEXTLOGFONTA */
     TEST_TYPE(LPEXTLOGFONTA, 4, 4);
     TEST_TYPE_POINTER(LPEXTLOGFONTA, 192, 4);
+}
 
+static void test_pack_LPEXTLOGFONTW(void)
+{
     /* LPEXTLOGFONTW */
     TEST_TYPE(LPEXTLOGFONTW, 4, 4);
     TEST_TYPE_POINTER(LPEXTLOGFONTW, 320, 4);
+}
 
+static void test_pack_LPEXTLOGPEN(void)
+{
     /* LPEXTLOGPEN */
     TEST_TYPE(LPEXTLOGPEN, 4, 4);
     TEST_TYPE_POINTER(LPEXTLOGPEN, 28, 4);
+}
 
+static void test_pack_LPFONTSIGNATURE(void)
+{
     /* LPFONTSIGNATURE */
     TEST_TYPE(LPFONTSIGNATURE, 4, 4);
     TEST_TYPE_POINTER(LPFONTSIGNATURE, 24, 4);
+}
 
+static void test_pack_LPGCP_RESULTSA(void)
+{
     /* LPGCP_RESULTSA */
     TEST_TYPE(LPGCP_RESULTSA, 4, 4);
-    TEST_TYPE_POINTER(LPGCP_RESULTSA, 36, 4);
+}
 
+static void test_pack_LPGCP_RESULTSW(void)
+{
     /* LPGCP_RESULTSW */
     TEST_TYPE(LPGCP_RESULTSW, 4, 4);
-    TEST_TYPE_POINTER(LPGCP_RESULTSW, 36, 4);
+}
 
+static void test_pack_LPGLYPHMETRICS(void)
+{
     /* LPGLYPHMETRICS */
     TEST_TYPE(LPGLYPHMETRICS, 4, 4);
     TEST_TYPE_POINTER(LPGLYPHMETRICS, 20, 4);
+}
 
+static void test_pack_LPGRADIENT_RECT(void)
+{
     /* LPGRADIENT_RECT */
     TEST_TYPE(LPGRADIENT_RECT, 4, 4);
     TEST_TYPE_POINTER(LPGRADIENT_RECT, 8, 4);
+}
 
+static void test_pack_LPGRADIENT_TRIANGLE(void)
+{
     /* LPGRADIENT_TRIANGLE */
     TEST_TYPE(LPGRADIENT_TRIANGLE, 4, 4);
     TEST_TYPE_POINTER(LPGRADIENT_TRIANGLE, 12, 4);
+}
 
+static void test_pack_LPHANDLETABLE(void)
+{
     /* LPHANDLETABLE */
     TEST_TYPE(LPHANDLETABLE, 4, 4);
     TEST_TYPE_POINTER(LPHANDLETABLE, 4, 4);
+}
 
+static void test_pack_LPKERNINGPAIR(void)
+{
     /* LPKERNINGPAIR */
     TEST_TYPE(LPKERNINGPAIR, 4, 4);
     TEST_TYPE_POINTER(LPKERNINGPAIR, 8, 4);
+}
 
+static void test_pack_LPLOCALESIGNATURE(void)
+{
+    /* LPLOCALESIGNATURE */
+    TEST_TYPE(LPLOCALESIGNATURE, 4, 4);
+    TEST_TYPE_POINTER(LPLOCALESIGNATURE, 32, 4);
+}
+
+static void test_pack_LPLOGBRUSH(void)
+{
     /* LPLOGBRUSH */
     TEST_TYPE(LPLOGBRUSH, 4, 4);
     TEST_TYPE_POINTER(LPLOGBRUSH, 12, 4);
+}
 
+static void test_pack_LPLOGCOLORSPACEA(void)
+{
     /* LPLOGCOLORSPACEA */
     TEST_TYPE(LPLOGCOLORSPACEA, 4, 4);
     TEST_TYPE_POINTER(LPLOGCOLORSPACEA, 328, 4);
+}
 
+static void test_pack_LPLOGCOLORSPACEW(void)
+{
     /* LPLOGCOLORSPACEW */
     TEST_TYPE(LPLOGCOLORSPACEW, 4, 4);
     TEST_TYPE_POINTER(LPLOGCOLORSPACEW, 588, 4);
+}
 
+static void test_pack_LPLOGFONTA(void)
+{
     /* LPLOGFONTA */
     TEST_TYPE(LPLOGFONTA, 4, 4);
     TEST_TYPE_POINTER(LPLOGFONTA, 60, 4);
+}
 
+static void test_pack_LPLOGFONTW(void)
+{
     /* LPLOGFONTW */
     TEST_TYPE(LPLOGFONTW, 4, 4);
     TEST_TYPE_POINTER(LPLOGFONTW, 92, 4);
+}
 
+static void test_pack_LPLOGPEN(void)
+{
     /* LPLOGPEN */
     TEST_TYPE(LPLOGPEN, 4, 4);
     TEST_TYPE_POINTER(LPLOGPEN, 16, 4);
+}
 
+static void test_pack_LPMAT2(void)
+{
     /* LPMAT2 */
     TEST_TYPE(LPMAT2, 4, 4);
     TEST_TYPE_POINTER(LPMAT2, 16, 2);
+}
 
+static void test_pack_LPMETAFILEPICT(void)
+{
     /* LPMETAFILEPICT */
     TEST_TYPE(LPMETAFILEPICT, 4, 4);
     TEST_TYPE_POINTER(LPMETAFILEPICT, 16, 4);
+}
 
+static void test_pack_LPMETAHEADER(void)
+{
     /* LPMETAHEADER */
     TEST_TYPE(LPMETAHEADER, 4, 4);
     TEST_TYPE_POINTER(LPMETAHEADER, 18, 2);
+}
 
+static void test_pack_LPMETARECORD(void)
+{
     /* LPMETARECORD */
     TEST_TYPE(LPMETARECORD, 4, 4);
     TEST_TYPE_POINTER(LPMETARECORD, 8, 4);
+}
 
+static void test_pack_LPNEWTEXTMETRICA(void)
+{
     /* LPNEWTEXTMETRICA */
     TEST_TYPE(LPNEWTEXTMETRICA, 4, 4);
     TEST_TYPE_POINTER(LPNEWTEXTMETRICA, 72, 4);
+}
 
+static void test_pack_LPNEWTEXTMETRICW(void)
+{
     /* LPNEWTEXTMETRICW */
     TEST_TYPE(LPNEWTEXTMETRICW, 4, 4);
     TEST_TYPE_POINTER(LPNEWTEXTMETRICW, 76, 4);
+}
 
+static void test_pack_LPOUTLINETEXTMETRICA(void)
+{
     /* LPOUTLINETEXTMETRICA */
     TEST_TYPE(LPOUTLINETEXTMETRICA, 4, 4);
-    TEST_TYPE_POINTER(LPOUTLINETEXTMETRICA, 212, 4);
+}
 
+static void test_pack_LPOUTLINETEXTMETRICW(void)
+{
     /* LPOUTLINETEXTMETRICW */
     TEST_TYPE(LPOUTLINETEXTMETRICW, 4, 4);
-    TEST_TYPE_POINTER(LPOUTLINETEXTMETRICW, 216, 4);
+}
 
+static void test_pack_LPPANOSE(void)
+{
     /* LPPANOSE */
     TEST_TYPE(LPPANOSE, 4, 4);
     TEST_TYPE_POINTER(LPPANOSE, 10, 1);
+}
 
+static void test_pack_LPPELARRAY(void)
+{
     /* LPPELARRAY */
     TEST_TYPE(LPPELARRAY, 4, 4);
     TEST_TYPE_POINTER(LPPELARRAY, 20, 4);
+}
 
+static void test_pack_LPPIXELFORMATDESCRIPTOR(void)
+{
     /* LPPIXELFORMATDESCRIPTOR */
     TEST_TYPE(LPPIXELFORMATDESCRIPTOR, 4, 4);
     TEST_TYPE_POINTER(LPPIXELFORMATDESCRIPTOR, 40, 4);
+}
 
+static void test_pack_LPPOINTFX(void)
+{
     /* LPPOINTFX */
     TEST_TYPE(LPPOINTFX, 4, 4);
     TEST_TYPE_POINTER(LPPOINTFX, 8, 2);
+}
 
+static void test_pack_LPPOLYTEXTA(void)
+{
     /* LPPOLYTEXTA */
     TEST_TYPE(LPPOLYTEXTA, 4, 4);
     TEST_TYPE_POINTER(LPPOLYTEXTA, 40, 4);
+}
 
+static void test_pack_LPPOLYTEXTW(void)
+{
     /* LPPOLYTEXTW */
     TEST_TYPE(LPPOLYTEXTW, 4, 4);
     TEST_TYPE_POINTER(LPPOLYTEXTW, 40, 4);
+}
 
+static void test_pack_LPRASTERIZER_STATUS(void)
+{
     /* LPRASTERIZER_STATUS */
     TEST_TYPE(LPRASTERIZER_STATUS, 4, 4);
     TEST_TYPE_POINTER(LPRASTERIZER_STATUS, 6, 2);
+}
 
+static void test_pack_LPRGBQUAD(void)
+{
     /* LPRGBQUAD */
     TEST_TYPE(LPRGBQUAD, 4, 4);
     TEST_TYPE_POINTER(LPRGBQUAD, 4, 1);
+}
 
+static void test_pack_LPRGNDATA(void)
+{
     /* LPRGNDATA */
     TEST_TYPE(LPRGNDATA, 4, 4);
     TEST_TYPE_POINTER(LPRGNDATA, 36, 4);
+}
 
+static void test_pack_LPTEXTMETRICA(void)
+{
     /* LPTEXTMETRICA */
     TEST_TYPE(LPTEXTMETRICA, 4, 4);
     TEST_TYPE_POINTER(LPTEXTMETRICA, 56, 4);
+}
 
+static void test_pack_LPTEXTMETRICW(void)
+{
     /* LPTEXTMETRICW */
     TEST_TYPE(LPTEXTMETRICW, 4, 4);
     TEST_TYPE_POINTER(LPTEXTMETRICW, 60, 4);
+}
 
+static void test_pack_LPTRIVERTEX(void)
+{
     /* LPTRIVERTEX */
     TEST_TYPE(LPTRIVERTEX, 4, 4);
     TEST_TYPE_POINTER(LPTRIVERTEX, 16, 4);
+}
 
+static void test_pack_LPTTPOLYCURVE(void)
+{
     /* LPTTPOLYCURVE */
     TEST_TYPE(LPTTPOLYCURVE, 4, 4);
     TEST_TYPE_POINTER(LPTTPOLYCURVE, 12, 2);
+}
 
+static void test_pack_LPTTPOLYGONHEADER(void)
+{
     /* LPTTPOLYGONHEADER */
     TEST_TYPE(LPTTPOLYGONHEADER, 4, 4);
     TEST_TYPE_POINTER(LPTTPOLYGONHEADER, 16, 4);
+}
 
+static void test_pack_LPXFORM(void)
+{
     /* LPXFORM */
     TEST_TYPE(LPXFORM, 4, 4);
     TEST_TYPE_POINTER(LPXFORM, 24, 4);
+}
 
+static void test_pack_MAT2(void)
+{
     /* MAT2 (pack 4) */
     TEST_TYPE(MAT2, 16, 2);
     TEST_FIELD(MAT2, FIXED, eM11, 0, 4, 2);
     TEST_FIELD(MAT2, FIXED, eM12, 4, 4, 2);
     TEST_FIELD(MAT2, FIXED, eM21, 8, 4, 2);
     TEST_FIELD(MAT2, FIXED, eM22, 12, 4, 2);
+}
 
+static void test_pack_METAFILEPICT(void)
+{
     /* METAFILEPICT (pack 4) */
     TEST_TYPE(METAFILEPICT, 16, 4);
     TEST_FIELD(METAFILEPICT, LONG, mm, 0, 4, 4);
     TEST_FIELD(METAFILEPICT, LONG, xExt, 4, 4, 4);
     TEST_FIELD(METAFILEPICT, LONG, yExt, 8, 4, 4);
     TEST_FIELD(METAFILEPICT, HMETAFILE, hMF, 12, 4, 4);
+}
 
+static void test_pack_METAHEADER(void)
+{
     /* METAHEADER (pack 2) */
     TEST_TYPE(METAHEADER, 18, 2);
     TEST_FIELD(METAHEADER, WORD, mtType, 0, 2, 2);
@@ -1289,15 +2148,25 @@
     TEST_FIELD(METAHEADER, WORD, mtNoObjects, 10, 2, 2);
     TEST_FIELD(METAHEADER, DWORD, mtMaxRecord, 12, 4, 2);
     TEST_FIELD(METAHEADER, WORD, mtNoParameters, 16, 2, 2);
+}
 
+static void test_pack_METARECORD(void)
+{
     /* METARECORD (pack 4) */
     TEST_TYPE(METARECORD, 8, 4);
     TEST_FIELD(METARECORD, DWORD, rdSize, 0, 4, 4);
     TEST_FIELD(METARECORD, WORD, rdFunction, 4, 2, 2);
     TEST_FIELD(METARECORD, WORD[1], rdParm, 6, 2, 2);
+}
 
+static void test_pack_MFENUMPROC(void)
+{
     /* MFENUMPROC */
+    TEST_TYPE(MFENUMPROC, 4, 4);
+}
 
+static void test_pack_NEWTEXTMETRICA(void)
+{
     /* NEWTEXTMETRICA (pack 4) */
     TEST_TYPE(NEWTEXTMETRICA, 72, 4);
     TEST_FIELD(NEWTEXTMETRICA, LONG, tmHeight, 0, 4, 4);
@@ -1324,17 +2193,26 @@
     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmSizeEM, 60, 4, 4);
     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmCellHeight, 64, 4, 4);
     TEST_FIELD(NEWTEXTMETRICA, UINT, ntmAvgWidth, 68, 4, 4);
+}
 
+static void test_pack_NEWTEXTMETRICEXA(void)
+{
     /* NEWTEXTMETRICEXA (pack 4) */
     TEST_TYPE(NEWTEXTMETRICEXA, 96, 4);
     TEST_FIELD(NEWTEXTMETRICEXA, NEWTEXTMETRICA, ntmTm, 0, 72, 4);
     TEST_FIELD(NEWTEXTMETRICEXA, FONTSIGNATURE, ntmFontSig, 72, 24, 4);
+}
 
+static void test_pack_NEWTEXTMETRICEXW(void)
+{
     /* NEWTEXTMETRICEXW (pack 4) */
     TEST_TYPE(NEWTEXTMETRICEXW, 100, 4);
     TEST_FIELD(NEWTEXTMETRICEXW, NEWTEXTMETRICW, ntmTm, 0, 76, 4);
     TEST_FIELD(NEWTEXTMETRICEXW, FONTSIGNATURE, ntmFontSig, 76, 24, 4);
+}
 
+static void test_pack_NEWTEXTMETRICW(void)
+{
     /* NEWTEXTMETRICW (pack 4) */
     TEST_TYPE(NEWTEXTMETRICW, 76, 4);
     TEST_FIELD(NEWTEXTMETRICW, LONG, tmHeight, 0, 4, 4);
@@ -1361,17 +2239,30 @@
     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmSizeEM, 64, 4, 4);
     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmCellHeight, 68, 4, 4);
     TEST_FIELD(NEWTEXTMETRICW, UINT, ntmAvgWidth, 72, 4, 4);
+}
 
+static void test_pack_NPEXTLOGPEN(void)
+{
     /* NPEXTLOGPEN */
     TEST_TYPE(NPEXTLOGPEN, 4, 4);
     TEST_TYPE_POINTER(NPEXTLOGPEN, 28, 4);
+}
 
+static void test_pack_OLDFONTENUMPROCA(void)
+{
     /* OLDFONTENUMPROCA */
+    TEST_TYPE(OLDFONTENUMPROCA, 4, 4);
+}
 
+static void test_pack_OLDFONTENUMPROCW(void)
+{
     /* OLDFONTENUMPROCW */
+    TEST_TYPE(OLDFONTENUMPROCW, 4, 4);
+}
 
+static void test_pack_OUTLINETEXTMETRICA(void)
+{
     /* OUTLINETEXTMETRICA (pack 4) */
-    TEST_TYPE(OUTLINETEXTMETRICA, 212, 4);
     TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmSize, 0, 4, 4);
     TEST_FIELD(OUTLINETEXTMETRICA, TEXTMETRICA, otmTextMetrics, 4, 56, 4);
     TEST_FIELD(OUTLINETEXTMETRICA, BYTE, otmFiller, 60, 1, 1);
@@ -1400,13 +2291,11 @@
     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsStrikeoutPosition, 184, 4, 4);
     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsUnderscoreSize, 188, 4, 4);
     TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsUnderscorePosition, 192, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFamilyName, 196, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFaceName, 200, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpStyleName, 204, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, LPSTR, otmpFullName, 208, 4, 4);
+}
 
+static void test_pack_OUTLINETEXTMETRICW(void)
+{
     /* OUTLINETEXTMETRICW (pack 4) */
-    TEST_TYPE(OUTLINETEXTMETRICW, 216, 4);
     TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmSize, 0, 4, 4);
     TEST_FIELD(OUTLINETEXTMETRICW, TEXTMETRICW, otmTextMetrics, 4, 60, 4);
     TEST_FIELD(OUTLINETEXTMETRICW, BYTE, otmFiller, 64, 1, 1);
@@ -1435,19 +2324,24 @@
     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsStrikeoutPosition, 188, 4, 4);
     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsUnderscoreSize, 192, 4, 4);
     TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsUnderscorePosition, 196, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFamilyName, 200, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFaceName, 204, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpStyleName, 208, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, LPSTR, otmpFullName, 212, 4, 4);
+}
 
+static void test_pack_PABC(void)
+{
     /* PABC */
     TEST_TYPE(PABC, 4, 4);
     TEST_TYPE_POINTER(PABC, 12, 4);
+}
 
+static void test_pack_PABCFLOAT(void)
+{
     /* PABCFLOAT */
     TEST_TYPE(PABCFLOAT, 4, 4);
     TEST_TYPE_POINTER(PABCFLOAT, 12, 4);
+}
 
+static void test_pack_PANOSE(void)
+{
     /* PANOSE (pack 4) */
     TEST_TYPE(PANOSE, 10, 1);
     TEST_FIELD(PANOSE, BYTE, bFamilyType, 0, 1, 1);
@@ -1460,70 +2354,124 @@
     TEST_FIELD(PANOSE, BYTE, bLetterform, 7, 1, 1);
     TEST_FIELD(PANOSE, BYTE, bMidline, 8, 1, 1);
     TEST_FIELD(PANOSE, BYTE, bXHeight, 9, 1, 1);
+}
 
+static void test_pack_PATTERN(void)
+{
     /* PATTERN */
     TEST_TYPE(PATTERN, 12, 4);
+}
 
+static void test_pack_PBITMAP(void)
+{
     /* PBITMAP */
     TEST_TYPE(PBITMAP, 4, 4);
     TEST_TYPE_POINTER(PBITMAP, 24, 4);
+}
 
+static void test_pack_PBITMAPCOREHEADER(void)
+{
     /* PBITMAPCOREHEADER */
     TEST_TYPE(PBITMAPCOREHEADER, 4, 4);
     TEST_TYPE_POINTER(PBITMAPCOREHEADER, 12, 4);
+}
 
+static void test_pack_PBITMAPCOREINFO(void)
+{
     /* PBITMAPCOREINFO */
     TEST_TYPE(PBITMAPCOREINFO, 4, 4);
     TEST_TYPE_POINTER(PBITMAPCOREINFO, 16, 4);
+}
 
+static void test_pack_PBITMAPFILEHEADER(void)
+{
     /* PBITMAPFILEHEADER */
     TEST_TYPE(PBITMAPFILEHEADER, 4, 4);
     TEST_TYPE_POINTER(PBITMAPFILEHEADER, 14, 2);
+}
 
+static void test_pack_PBITMAPINFO(void)
+{
     /* PBITMAPINFO */
     TEST_TYPE(PBITMAPINFO, 4, 4);
     TEST_TYPE_POINTER(PBITMAPINFO, 44, 4);
+}
 
+static void test_pack_PBITMAPINFOHEADER(void)
+{
     /* PBITMAPINFOHEADER */
     TEST_TYPE(PBITMAPINFOHEADER, 4, 4);
     TEST_TYPE_POINTER(PBITMAPINFOHEADER, 40, 4);
+}
 
+static void test_pack_PBITMAPV4HEADER(void)
+{
     /* PBITMAPV4HEADER */
     TEST_TYPE(PBITMAPV4HEADER, 4, 4);
     TEST_TYPE_POINTER(PBITMAPV4HEADER, 108, 4);
+}
 
+static void test_pack_PBITMAPV5HEADER(void)
+{
     /* PBITMAPV5HEADER */
     TEST_TYPE(PBITMAPV5HEADER, 4, 4);
     TEST_TYPE_POINTER(PBITMAPV5HEADER, 124, 4);
+}
 
+static void test_pack_PBLENDFUNCTION(void)
+{
     /* PBLENDFUNCTION */
     TEST_TYPE(PBLENDFUNCTION, 4, 4);
     TEST_TYPE_POINTER(PBLENDFUNCTION, 4, 1);
+}
 
+static void test_pack_PCHARSETINFO(void)
+{
     /* PCHARSETINFO */
     TEST_TYPE(PCHARSETINFO, 4, 4);
     TEST_TYPE_POINTER(PCHARSETINFO, 32, 4);
+}
 
+static void test_pack_PCOLORADJUSTMENT(void)
+{
     /* PCOLORADJUSTMENT */
     TEST_TYPE(PCOLORADJUSTMENT, 4, 4);
     TEST_TYPE_POINTER(PCOLORADJUSTMENT, 24, 2);
+}
 
+static void test_pack_PDEVMODEA(void)
+{
     /* PDEVMODEA */
     TEST_TYPE(PDEVMODEA, 4, 4);
+}
 
+static void test_pack_PDEVMODEW(void)
+{
     /* PDEVMODEW */
     TEST_TYPE(PDEVMODEW, 4, 4);
+}
 
+static void test_pack_PDIBSECTION(void)
+{
     /* PDIBSECTION */
     TEST_TYPE(PDIBSECTION, 4, 4);
     TEST_TYPE_POINTER(PDIBSECTION, 84, 4);
+}
 
+static void test_pack_PDISPLAY_DEVICEA(void)
+{
     /* PDISPLAY_DEVICEA */
     TEST_TYPE(PDISPLAY_DEVICEA, 4, 4);
+}
 
+static void test_pack_PDISPLAY_DEVICEW(void)
+{
     /* PDISPLAY_DEVICEW */
     TEST_TYPE(PDISPLAY_DEVICEW, 4, 4);
+}
 
+static void test_pack_PELARRAY(void)
+{
     /* PELARRAY (pack 4) */
     TEST_TYPE(PELARRAY, 20, 4);
     TEST_FIELD(PELARRAY, LONG, paXCount, 0, 4, 4);
@@ -1531,418 +2479,737 @@
     TEST_FIELD(PELARRAY, LONG, paXExt, 8, 4, 4);
     TEST_FIELD(PELARRAY, LONG, paYExt, 12, 4, 4);
     TEST_FIELD(PELARRAY, BYTE, paRGBs, 16, 1, 1);
+}
 
+static void test_pack_PEMR(void)
+{
     /* PEMR */
     TEST_TYPE(PEMR, 4, 4);
     TEST_TYPE_POINTER(PEMR, 8, 4);
+}
 
+static void test_pack_PEMRABORTPATH(void)
+{
     /* PEMRABORTPATH */
     TEST_TYPE(PEMRABORTPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRABORTPATH, 8, 4);
+}
 
+static void test_pack_PEMRANGLEARC(void)
+{
     /* PEMRANGLEARC */
     TEST_TYPE(PEMRANGLEARC, 4, 4);
     TEST_TYPE_POINTER(PEMRANGLEARC, 28, 4);
+}
 
+static void test_pack_PEMRARC(void)
+{
     /* PEMRARC */
     TEST_TYPE(PEMRARC, 4, 4);
     TEST_TYPE_POINTER(PEMRARC, 40, 4);
+}
 
+static void test_pack_PEMRARCTO(void)
+{
     /* PEMRARCTO */
     TEST_TYPE(PEMRARCTO, 4, 4);
     TEST_TYPE_POINTER(PEMRARCTO, 40, 4);
+}
 
+static void test_pack_PEMRBEGINPATH(void)
+{
     /* PEMRBEGINPATH */
     TEST_TYPE(PEMRBEGINPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRBEGINPATH, 8, 4);
+}
 
+static void test_pack_PEMRBITBLT(void)
+{
     /* PEMRBITBLT */
     TEST_TYPE(PEMRBITBLT, 4, 4);
     TEST_TYPE_POINTER(PEMRBITBLT, 100, 4);
+}
 
+static void test_pack_PEMRCHORD(void)
+{
     /* PEMRCHORD */
     TEST_TYPE(PEMRCHORD, 4, 4);
     TEST_TYPE_POINTER(PEMRCHORD, 40, 4);
+}
 
+static void test_pack_PEMRCLOSEFIGURE(void)
+{
     /* PEMRCLOSEFIGURE */
     TEST_TYPE(PEMRCLOSEFIGURE, 4, 4);
     TEST_TYPE_POINTER(PEMRCLOSEFIGURE, 8, 4);
+}
 
+static void test_pack_PEMRCREATEBRUSHINDIRECT(void)
+{
     /* PEMRCREATEBRUSHINDIRECT */
     TEST_TYPE(PEMRCREATEBRUSHINDIRECT, 4, 4);
     TEST_TYPE_POINTER(PEMRCREATEBRUSHINDIRECT, 24, 4);
+}
 
+static void test_pack_PEMRCREATEDIBPATTERNBRUSHPT(void)
+{
     /* PEMRCREATEDIBPATTERNBRUSHPT */
     TEST_TYPE(PEMRCREATEDIBPATTERNBRUSHPT, 4, 4);
     TEST_TYPE_POINTER(PEMRCREATEDIBPATTERNBRUSHPT, 32, 4);
+}
 
+static void test_pack_PEMRCREATEMONOBRUSH(void)
+{
     /* PEMRCREATEMONOBRUSH */
     TEST_TYPE(PEMRCREATEMONOBRUSH, 4, 4);
     TEST_TYPE_POINTER(PEMRCREATEMONOBRUSH, 32, 4);
+}
 
+static void test_pack_PEMRCREATEPALETTE(void)
+{
     /* PEMRCREATEPALETTE */
     TEST_TYPE(PEMRCREATEPALETTE, 4, 4);
     TEST_TYPE_POINTER(PEMRCREATEPALETTE, 20, 4);
+}
 
+static void test_pack_PEMRCREATEPEN(void)
+{
     /* PEMRCREATEPEN */
     TEST_TYPE(PEMRCREATEPEN, 4, 4);
     TEST_TYPE_POINTER(PEMRCREATEPEN, 28, 4);
+}
 
+static void test_pack_PEMRDELETECOLORSPACE(void)
+{
     /* PEMRDELETECOLORSPACE */
     TEST_TYPE(PEMRDELETECOLORSPACE, 4, 4);
     TEST_TYPE_POINTER(PEMRDELETECOLORSPACE, 12, 4);
+}
 
+static void test_pack_PEMRDELETEOBJECT(void)
+{
     /* PEMRDELETEOBJECT */
     TEST_TYPE(PEMRDELETEOBJECT, 4, 4);
     TEST_TYPE_POINTER(PEMRDELETEOBJECT, 12, 4);
+}
 
+static void test_pack_PEMRELLIPSE(void)
+{
     /* PEMRELLIPSE */
     TEST_TYPE(PEMRELLIPSE, 4, 4);
     TEST_TYPE_POINTER(PEMRELLIPSE, 24, 4);
+}
 
+static void test_pack_PEMRENDPATH(void)
+{
     /* PEMRENDPATH */
     TEST_TYPE(PEMRENDPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRENDPATH, 8, 4);
+}
 
+static void test_pack_PEMREOF(void)
+{
     /* PEMREOF */
     TEST_TYPE(PEMREOF, 4, 4);
     TEST_TYPE_POINTER(PEMREOF, 20, 4);
+}
 
+static void test_pack_PEMREXCLUDECLIPRECT(void)
+{
     /* PEMREXCLUDECLIPRECT */
     TEST_TYPE(PEMREXCLUDECLIPRECT, 4, 4);
     TEST_TYPE_POINTER(PEMREXCLUDECLIPRECT, 24, 4);
+}
 
+static void test_pack_PEMREXTCREATEFONTINDIRECTW(void)
+{
     /* PEMREXTCREATEFONTINDIRECTW */
     TEST_TYPE(PEMREXTCREATEFONTINDIRECTW, 4, 4);
     TEST_TYPE_POINTER(PEMREXTCREATEFONTINDIRECTW, 332, 4);
+}
 
+static void test_pack_PEMREXTCREATEPEN(void)
+{
     /* PEMREXTCREATEPEN */
     TEST_TYPE(PEMREXTCREATEPEN, 4, 4);
     TEST_TYPE_POINTER(PEMREXTCREATEPEN, 56, 4);
+}
 
+static void test_pack_PEMREXTFLOODFILL(void)
+{
     /* PEMREXTFLOODFILL */
     TEST_TYPE(PEMREXTFLOODFILL, 4, 4);
     TEST_TYPE_POINTER(PEMREXTFLOODFILL, 24, 4);
+}
 
+static void test_pack_PEMREXTSELECTCLIPRGN(void)
+{
     /* PEMREXTSELECTCLIPRGN */
     TEST_TYPE(PEMREXTSELECTCLIPRGN, 4, 4);
     TEST_TYPE_POINTER(PEMREXTSELECTCLIPRGN, 20, 4);
+}
 
+static void test_pack_PEMREXTTEXTOUTA(void)
+{
     /* PEMREXTTEXTOUTA */
     TEST_TYPE(PEMREXTTEXTOUTA, 4, 4);
     TEST_TYPE_POINTER(PEMREXTTEXTOUTA, 76, 4);
+}
 
+static void test_pack_PEMREXTTEXTOUTW(void)
+{
     /* PEMREXTTEXTOUTW */
     TEST_TYPE(PEMREXTTEXTOUTW, 4, 4);
     TEST_TYPE_POINTER(PEMREXTTEXTOUTW, 76, 4);
+}
 
+static void test_pack_PEMRFILLPATH(void)
+{
     /* PEMRFILLPATH */
     TEST_TYPE(PEMRFILLPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRFILLPATH, 24, 4);
+}
 
+static void test_pack_PEMRFILLRGN(void)
+{
     /* PEMRFILLRGN */
     TEST_TYPE(PEMRFILLRGN, 4, 4);
     TEST_TYPE_POINTER(PEMRFILLRGN, 36, 4);
+}
 
+static void test_pack_PEMRFLATTENPATH(void)
+{
     /* PEMRFLATTENPATH */
     TEST_TYPE(PEMRFLATTENPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRFLATTENPATH, 8, 4);
+}
 
+static void test_pack_PEMRFORMAT(void)
+{
     /* PEMRFORMAT */
     TEST_TYPE(PEMRFORMAT, 4, 4);
     TEST_TYPE_POINTER(PEMRFORMAT, 16, 4);
+}
 
+static void test_pack_PEMRFRAMERGN(void)
+{
     /* PEMRFRAMERGN */
     TEST_TYPE(PEMRFRAMERGN, 4, 4);
     TEST_TYPE_POINTER(PEMRFRAMERGN, 44, 4);
+}
 
+static void test_pack_PEMRGDICOMMENT(void)
+{
     /* PEMRGDICOMMENT */
     TEST_TYPE(PEMRGDICOMMENT, 4, 4);
     TEST_TYPE_POINTER(PEMRGDICOMMENT, 16, 4);
+}
 
+static void test_pack_PEMRGLSBOUNDEDRECORD(void)
+{
     /* PEMRGLSBOUNDEDRECORD */
     TEST_TYPE(PEMRGLSBOUNDEDRECORD, 4, 4);
     TEST_TYPE_POINTER(PEMRGLSBOUNDEDRECORD, 32, 4);
+}
 
+static void test_pack_PEMRGLSRECORD(void)
+{
     /* PEMRGLSRECORD */
     TEST_TYPE(PEMRGLSRECORD, 4, 4);
     TEST_TYPE_POINTER(PEMRGLSRECORD, 16, 4);
+}
 
+static void test_pack_PEMRINTERSECTCLIPRECT(void)
+{
     /* PEMRINTERSECTCLIPRECT */
     TEST_TYPE(PEMRINTERSECTCLIPRECT, 4, 4);
     TEST_TYPE_POINTER(PEMRINTERSECTCLIPRECT, 24, 4);
+}
 
+static void test_pack_PEMRINVERTRGN(void)
+{
     /* PEMRINVERTRGN */
     TEST_TYPE(PEMRINVERTRGN, 4, 4);
     TEST_TYPE_POINTER(PEMRINVERTRGN, 32, 4);
+}
 
+static void test_pack_PEMRLINETO(void)
+{
     /* PEMRLINETO */
     TEST_TYPE(PEMRLINETO, 4, 4);
     TEST_TYPE_POINTER(PEMRLINETO, 16, 4);
+}
 
+static void test_pack_PEMRMASKBLT(void)
+{
     /* PEMRMASKBLT */
     TEST_TYPE(PEMRMASKBLT, 4, 4);
     TEST_TYPE_POINTER(PEMRMASKBLT, 128, 4);
+}
 
+static void test_pack_PEMRMODIFYWORLDTRANSFORM(void)
+{
     /* PEMRMODIFYWORLDTRANSFORM */
     TEST_TYPE(PEMRMODIFYWORLDTRANSFORM, 4, 4);
     TEST_TYPE_POINTER(PEMRMODIFYWORLDTRANSFORM, 36, 4);
+}
 
+static void test_pack_PEMRMOVETOEX(void)
+{
     /* PEMRMOVETOEX */
     TEST_TYPE(PEMRMOVETOEX, 4, 4);
     TEST_TYPE_POINTER(PEMRMOVETOEX, 16, 4);
+}
 
+static void test_pack_PEMROFFSETCLIPRGN(void)
+{
     /* PEMROFFSETCLIPRGN */
     TEST_TYPE(PEMROFFSETCLIPRGN, 4, 4);
     TEST_TYPE_POINTER(PEMROFFSETCLIPRGN, 16, 4);
+}
 
+static void test_pack_PEMRPAINTRGN(void)
+{
     /* PEMRPAINTRGN */
     TEST_TYPE(PEMRPAINTRGN, 4, 4);
     TEST_TYPE_POINTER(PEMRPAINTRGN, 32, 4);
+}
 
+static void test_pack_PEMRPIE(void)
+{
     /* PEMRPIE */
     TEST_TYPE(PEMRPIE, 4, 4);
     TEST_TYPE_POINTER(PEMRPIE, 40, 4);
+}
 
+static void test_pack_PEMRPIXELFORMAT(void)
+{
     /* PEMRPIXELFORMAT */
     TEST_TYPE(PEMRPIXELFORMAT, 4, 4);
     TEST_TYPE_POINTER(PEMRPIXELFORMAT, 48, 4);
+}
 
+static void test_pack_PEMRPLGBLT(void)
+{
     /* PEMRPLGBLT */
     TEST_TYPE(PEMRPLGBLT, 4, 4);
     TEST_TYPE_POINTER(PEMRPLGBLT, 140, 4);
+}
 
+static void test_pack_PEMRPOLYBEZIER(void)
+{
     /* PEMRPOLYBEZIER */
     TEST_TYPE(PEMRPOLYBEZIER, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYBEZIER, 36, 4);
+}
 
+static void test_pack_PEMRPOLYBEZIERTO(void)
+{
     /* PEMRPOLYBEZIERTO */
     TEST_TYPE(PEMRPOLYBEZIERTO, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYBEZIERTO, 36, 4);
+}
 
+static void test_pack_PEMRPOLYDRAW(void)
+{
     /* PEMRPOLYDRAW */
     TEST_TYPE(PEMRPOLYDRAW, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYDRAW, 40, 4);
+}
 
+static void test_pack_PEMRPOLYGON(void)
+{
     /* PEMRPOLYGON */
     TEST_TYPE(PEMRPOLYGON, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYGON, 36, 4);
+}
 
+static void test_pack_PEMRPOLYLINE(void)
+{
     /* PEMRPOLYLINE */
     TEST_TYPE(PEMRPOLYLINE, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYLINE, 36, 4);
+}
 
+static void test_pack_PEMRPOLYLINETO(void)
+{
     /* PEMRPOLYLINETO */
     TEST_TYPE(PEMRPOLYLINETO, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYLINETO, 36, 4);
+}
 
+static void test_pack_PEMRPOLYPOLYGON(void)
+{
     /* PEMRPOLYPOLYGON */
     TEST_TYPE(PEMRPOLYPOLYGON, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYPOLYGON, 44, 4);
+}
 
+static void test_pack_PEMRPOLYPOLYLINE(void)
+{
     /* PEMRPOLYPOLYLINE */
     TEST_TYPE(PEMRPOLYPOLYLINE, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYPOLYLINE, 44, 4);
+}
 
+static void test_pack_PEMRPOLYTEXTOUTA(void)
+{
     /* PEMRPOLYTEXTOUTA */
     TEST_TYPE(PEMRPOLYTEXTOUTA, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYTEXTOUTA, 80, 4);
+}
 
+static void test_pack_PEMRPOLYTEXTOUTW(void)
+{
     /* PEMRPOLYTEXTOUTW */
     TEST_TYPE(PEMRPOLYTEXTOUTW, 4, 4);
     TEST_TYPE_POINTER(PEMRPOLYTEXTOUTW, 80, 4);
+}
 
+static void test_pack_PEMRREALIZEPALETTE(void)
+{
     /* PEMRREALIZEPALETTE */
     TEST_TYPE(PEMRREALIZEPALETTE, 4, 4);
     TEST_TYPE_POINTER(PEMRREALIZEPALETTE, 8, 4);
+}
 
+static void test_pack_PEMRRECTANGLE(void)
+{
     /* PEMRRECTANGLE */
     TEST_TYPE(PEMRRECTANGLE, 4, 4);
     TEST_TYPE_POINTER(PEMRRECTANGLE, 24, 4);
+}
 
+static void test_pack_PEMRRESIZEPALETTE(void)
+{
     /* PEMRRESIZEPALETTE */
     TEST_TYPE(PEMRRESIZEPALETTE, 4, 4);
     TEST_TYPE_POINTER(PEMRRESIZEPALETTE, 16, 4);
+}
 
+static void test_pack_PEMRRESTOREDC(void)
+{
     /* PEMRRESTOREDC */
     TEST_TYPE(PEMRRESTOREDC, 4, 4);
     TEST_TYPE_POINTER(PEMRRESTOREDC, 12, 4);
+}
 
+static void test_pack_PEMRROUNDRECT(void)
+{
     /* PEMRROUNDRECT */
     TEST_TYPE(PEMRROUNDRECT, 4, 4);
     TEST_TYPE_POINTER(PEMRROUNDRECT, 32, 4);
+}
 
+static void test_pack_PEMRSAVEDC(void)
+{
     /* PEMRSAVEDC */
     TEST_TYPE(PEMRSAVEDC, 4, 4);
     TEST_TYPE_POINTER(PEMRSAVEDC, 8, 4);
+}
 
+static void test_pack_PEMRSCALEVIEWPORTEXTEX(void)
+{
     /* PEMRSCALEVIEWPORTEXTEX */
     TEST_TYPE(PEMRSCALEVIEWPORTEXTEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSCALEVIEWPORTEXTEX, 24, 4);
+}
 
+static void test_pack_PEMRSCALEWINDOWEXTEX(void)
+{
     /* PEMRSCALEWINDOWEXTEX */
     TEST_TYPE(PEMRSCALEWINDOWEXTEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSCALEWINDOWEXTEX, 24, 4);
+}
 
+static void test_pack_PEMRSELECTCLIPPATH(void)
+{
     /* PEMRSELECTCLIPPATH */
     TEST_TYPE(PEMRSELECTCLIPPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRSELECTCLIPPATH, 12, 4);
+}
 
+static void test_pack_PEMRSELECTCOLORSPACE(void)
+{
     /* PEMRSELECTCOLORSPACE */
     TEST_TYPE(PEMRSELECTCOLORSPACE, 4, 4);
     TEST_TYPE_POINTER(PEMRSELECTCOLORSPACE, 12, 4);
+}
 
+static void test_pack_PEMRSELECTOBJECT(void)
+{
     /* PEMRSELECTOBJECT */
     TEST_TYPE(PEMRSELECTOBJECT, 4, 4);
     TEST_TYPE_POINTER(PEMRSELECTOBJECT, 12, 4);
+}
 
+static void test_pack_PEMRSELECTPALETTE(void)
+{
     /* PEMRSELECTPALETTE */
     TEST_TYPE(PEMRSELECTPALETTE, 4, 4);
     TEST_TYPE_POINTER(PEMRSELECTPALETTE, 12, 4);
+}
 
+static void test_pack_PEMRSETARCDIRECTION(void)
+{
     /* PEMRSETARCDIRECTION */
     TEST_TYPE(PEMRSETARCDIRECTION, 4, 4);
     TEST_TYPE_POINTER(PEMRSETARCDIRECTION, 12, 4);
+}
 
+static void test_pack_PEMRSETBKCOLOR(void)
+{
     /* PEMRSETBKCOLOR */
     TEST_TYPE(PEMRSETBKCOLOR, 4, 4);
     TEST_TYPE_POINTER(PEMRSETBKCOLOR, 12, 4);
+}
 
+static void test_pack_PEMRSETBKMODE(void)
+{
     /* PEMRSETBKMODE */
     TEST_TYPE(PEMRSETBKMODE, 4, 4);
     TEST_TYPE_POINTER(PEMRSETBKMODE, 12, 4);
+}
 
+static void test_pack_PEMRSETBRUSHORGEX(void)
+{
     /* PEMRSETBRUSHORGEX */
     TEST_TYPE(PEMRSETBRUSHORGEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSETBRUSHORGEX, 16, 4);
+}
 
+static void test_pack_PEMRSETCOLORADJUSTMENT(void)
+{
     /* PEMRSETCOLORADJUSTMENT */
     TEST_TYPE(PEMRSETCOLORADJUSTMENT, 4, 4);
     TEST_TYPE_POINTER(PEMRSETCOLORADJUSTMENT, 32, 4);
+}
 
+static void test_pack_PEMRSETDIBITSTODEVICE(void)
+{
     /* PEMRSETDIBITSTODEVICE */
     TEST_TYPE(PEMRSETDIBITSTODEVICE, 4, 4);
     TEST_TYPE_POINTER(PEMRSETDIBITSTODEVICE, 76, 4);
+}
 
+static void test_pack_PEMRSETICMMODE(void)
+{
+    /* PEMRSETICMMODE */
+    TEST_TYPE(PEMRSETICMMODE, 4, 4);
+    TEST_TYPE_POINTER(PEMRSETICMMODE, 12, 4);
+}
+
+static void test_pack_PEMRSETMAPMODE(void)
+{
     /* PEMRSETMAPMODE */
     TEST_TYPE(PEMRSETMAPMODE, 4, 4);
     TEST_TYPE_POINTER(PEMRSETMAPMODE, 12, 4);
+}
 
+static void test_pack_PEMRSETMAPPERFLAGS(void)
+{
     /* PEMRSETMAPPERFLAGS */
     TEST_TYPE(PEMRSETMAPPERFLAGS, 4, 4);
     TEST_TYPE_POINTER(PEMRSETMAPPERFLAGS, 12, 4);
+}
 
+static void test_pack_PEMRSETMETARGN(void)
+{
     /* PEMRSETMETARGN */
     TEST_TYPE(PEMRSETMETARGN, 4, 4);
     TEST_TYPE_POINTER(PEMRSETMETARGN, 8, 4);
+}
 
+static void test_pack_PEMRSETMITERLIMIT(void)
+{
     /* PEMRSETMITERLIMIT */
     TEST_TYPE(PEMRSETMITERLIMIT, 4, 4);
     TEST_TYPE_POINTER(PEMRSETMITERLIMIT, 12, 4);
+}
 
+static void test_pack_PEMRSETPALETTEENTRIES(void)
+{
     /* PEMRSETPALETTEENTRIES */
     TEST_TYPE(PEMRSETPALETTEENTRIES, 4, 4);
     TEST_TYPE_POINTER(PEMRSETPALETTEENTRIES, 24, 4);
+}
 
+static void test_pack_PEMRSETPIXELV(void)
+{
     /* PEMRSETPIXELV */
     TEST_TYPE(PEMRSETPIXELV, 4, 4);
     TEST_TYPE_POINTER(PEMRSETPIXELV, 20, 4);
+}
 
+static void test_pack_PEMRSETPOLYFILLMODE(void)
+{
     /* PEMRSETPOLYFILLMODE */
     TEST_TYPE(PEMRSETPOLYFILLMODE, 4, 4);
     TEST_TYPE_POINTER(PEMRSETPOLYFILLMODE, 12, 4);
+}
 
+static void test_pack_PEMRSETROP2(void)
+{
     /* PEMRSETROP2 */
     TEST_TYPE(PEMRSETROP2, 4, 4);
     TEST_TYPE_POINTER(PEMRSETROP2, 12, 4);
+}
 
+static void test_pack_PEMRSETSTRETCHBLTMODE(void)
+{
     /* PEMRSETSTRETCHBLTMODE */
     TEST_TYPE(PEMRSETSTRETCHBLTMODE, 4, 4);
     TEST_TYPE_POINTER(PEMRSETSTRETCHBLTMODE, 12, 4);
+}
 
+static void test_pack_PEMRSETTEXTALIGN(void)
+{
     /* PEMRSETTEXTALIGN */
     TEST_TYPE(PEMRSETTEXTALIGN, 4, 4);
     TEST_TYPE_POINTER(PEMRSETTEXTALIGN, 12, 4);
+}
 
+static void test_pack_PEMRSETTEXTCOLOR(void)
+{
     /* PEMRSETTEXTCOLOR */
     TEST_TYPE(PEMRSETTEXTCOLOR, 4, 4);
     TEST_TYPE_POINTER(PEMRSETTEXTCOLOR, 12, 4);
+}
 
+static void test_pack_PEMRSETVIEWPORTEXTEX(void)
+{
     /* PEMRSETVIEWPORTEXTEX */
     TEST_TYPE(PEMRSETVIEWPORTEXTEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSETVIEWPORTEXTEX, 16, 4);
+}
 
+static void test_pack_PEMRSETVIEWPORTORGEX(void)
+{
     /* PEMRSETVIEWPORTORGEX */
     TEST_TYPE(PEMRSETVIEWPORTORGEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSETVIEWPORTORGEX, 16, 4);
+}
 
+static void test_pack_PEMRSETWINDOWEXTEX(void)
+{
     /* PEMRSETWINDOWEXTEX */
     TEST_TYPE(PEMRSETWINDOWEXTEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSETWINDOWEXTEX, 16, 4);
+}
 
+static void test_pack_PEMRSETWINDOWORGEX(void)
+{
     /* PEMRSETWINDOWORGEX */
     TEST_TYPE(PEMRSETWINDOWORGEX, 4, 4);
     TEST_TYPE_POINTER(PEMRSETWINDOWORGEX, 16, 4);
+}
 
+static void test_pack_PEMRSETWORLDTRANSFORM(void)
+{
     /* PEMRSETWORLDTRANSFORM */
     TEST_TYPE(PEMRSETWORLDTRANSFORM, 4, 4);
     TEST_TYPE_POINTER(PEMRSETWORLDTRANSFORM, 32, 4);
+}
 
+static void test_pack_PEMRSTRETCHBLT(void)
+{
     /* PEMRSTRETCHBLT */
     TEST_TYPE(PEMRSTRETCHBLT, 4, 4);
     TEST_TYPE_POINTER(PEMRSTRETCHBLT, 108, 4);
+}
 
+static void test_pack_PEMRSTRETCHDIBITS(void)
+{
     /* PEMRSTRETCHDIBITS */
     TEST_TYPE(PEMRSTRETCHDIBITS, 4, 4);
     TEST_TYPE_POINTER(PEMRSTRETCHDIBITS, 80, 4);
+}
 
+static void test_pack_PEMRSTROKEANDFILLPATH(void)
+{
     /* PEMRSTROKEANDFILLPATH */
     TEST_TYPE(PEMRSTROKEANDFILLPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRSTROKEANDFILLPATH, 24, 4);
+}
 
+static void test_pack_PEMRSTROKEPATH(void)
+{
     /* PEMRSTROKEPATH */
     TEST_TYPE(PEMRSTROKEPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRSTROKEPATH, 24, 4);
+}
 
+static void test_pack_PEMRTEXT(void)
+{
     /* PEMRTEXT */
     TEST_TYPE(PEMRTEXT, 4, 4);
     TEST_TYPE_POINTER(PEMRTEXT, 40, 4);
+}
 
+static void test_pack_PEMRWIDENPATH(void)
+{
     /* PEMRWIDENPATH */
     TEST_TYPE(PEMRWIDENPATH, 4, 4);
     TEST_TYPE_POINTER(PEMRWIDENPATH, 8, 4);
+}
 
+static void test_pack_PENHMETAHEADER(void)
+{
     /* PENHMETAHEADER */
     TEST_TYPE(PENHMETAHEADER, 4, 4);
+}
 
+static void test_pack_PEXTLOGFONTA(void)
+{
     /* PEXTLOGFONTA */
     TEST_TYPE(PEXTLOGFONTA, 4, 4);
     TEST_TYPE_POINTER(PEXTLOGFONTA, 192, 4);
+}
 
+static void test_pack_PEXTLOGFONTW(void)
+{
     /* PEXTLOGFONTW */
     TEST_TYPE(PEXTLOGFONTW, 4, 4);
     TEST_TYPE_POINTER(PEXTLOGFONTW, 320, 4);
+}
 
+static void test_pack_PEXTLOGPEN(void)
+{
     /* PEXTLOGPEN */
     TEST_TYPE(PEXTLOGPEN, 4, 4);
     TEST_TYPE_POINTER(PEXTLOGPEN, 28, 4);
+}
 
+static void test_pack_PFONTSIGNATURE(void)
+{
     /* PFONTSIGNATURE */
     TEST_TYPE(PFONTSIGNATURE, 4, 4);
     TEST_TYPE_POINTER(PFONTSIGNATURE, 24, 4);
+}
 
+static void test_pack_PGRADIENT_RECT(void)
+{
     /* PGRADIENT_RECT */
     TEST_TYPE(PGRADIENT_RECT, 4, 4);
     TEST_TYPE_POINTER(PGRADIENT_RECT, 8, 4);
+}
 
+static void test_pack_PGRADIENT_TRIANGLE(void)
+{
     /* PGRADIENT_TRIANGLE */
     TEST_TYPE(PGRADIENT_TRIANGLE, 4, 4);
     TEST_TYPE_POINTER(PGRADIENT_TRIANGLE, 12, 4);
+}
 
+static void test_pack_PHANDLETABLE(void)
+{
     /* PHANDLETABLE */
     TEST_TYPE(PHANDLETABLE, 4, 4);
     TEST_TYPE_POINTER(PHANDLETABLE, 4, 4);
+}
 
+static void test_pack_PIXELFORMATDESCRIPTOR(void)
+{
     /* PIXELFORMATDESCRIPTOR (pack 4) */
     TEST_TYPE(PIXELFORMATDESCRIPTOR, 40, 4);
     TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nSize, 0, 2, 2);
@@ -1971,40 +3238,74 @@
     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwLayerMask, 28, 4, 4);
     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwVisibleMask, 32, 4, 4);
     TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwDamageMask, 36, 4, 4);
+}
 
+static void test_pack_PLOCALESIGNATURE(void)
+{
+    /* PLOCALESIGNATURE */
+    TEST_TYPE(PLOCALESIGNATURE, 4, 4);
+    TEST_TYPE_POINTER(PLOCALESIGNATURE, 32, 4);
+}
+
+static void test_pack_PLOGBRUSH(void)
+{
     /* PLOGBRUSH */
     TEST_TYPE(PLOGBRUSH, 4, 4);
     TEST_TYPE_POINTER(PLOGBRUSH, 12, 4);
+}
 
+static void test_pack_PLOGFONTA(void)
+{
     /* PLOGFONTA */
     TEST_TYPE(PLOGFONTA, 4, 4);
     TEST_TYPE_POINTER(PLOGFONTA, 60, 4);
+}
 
+static void test_pack_PLOGFONTW(void)
+{
     /* PLOGFONTW */
     TEST_TYPE(PLOGFONTW, 4, 4);
     TEST_TYPE_POINTER(PLOGFONTW, 92, 4);
+}
 
+static void test_pack_PMETAHEADER(void)
+{
     /* PMETAHEADER */
     TEST_TYPE(PMETAHEADER, 4, 4);
     TEST_TYPE_POINTER(PMETAHEADER, 18, 2);
+}
 
+static void test_pack_PMETARECORD(void)
+{
     /* PMETARECORD */
     TEST_TYPE(PMETARECORD, 4, 4);
     TEST_TYPE_POINTER(PMETARECORD, 8, 4);
+}
 
+static void test_pack_PNEWTEXTMETRICA(void)
+{
     /* PNEWTEXTMETRICA */
     TEST_TYPE(PNEWTEXTMETRICA, 4, 4);
     TEST_TYPE_POINTER(PNEWTEXTMETRICA, 72, 4);
+}
 
+static void test_pack_PNEWTEXTMETRICW(void)
+{
     /* PNEWTEXTMETRICW */
     TEST_TYPE(PNEWTEXTMETRICW, 4, 4);
     TEST_TYPE_POINTER(PNEWTEXTMETRICW, 76, 4);
+}
 
+static void test_pack_POINTFX(void)
+{
     /* POINTFX (pack 4) */
     TEST_TYPE(POINTFX, 8, 2);
     TEST_FIELD(POINTFX, FIXED, x, 0, 4, 2);
     TEST_FIELD(POINTFX, FIXED, y, 4, 4, 2);
+}
 
+static void test_pack_POLYTEXTA(void)
+{
     /* POLYTEXTA (pack 4) */
     TEST_TYPE(POLYTEXTA, 40, 4);
     TEST_FIELD(POLYTEXTA, INT, x, 0, 4, 4);
@@ -2014,7 +3315,10 @@
     TEST_FIELD(POLYTEXTA, UINT, uiFlags, 16, 4, 4);
     TEST_FIELD(POLYTEXTA, RECT, rcl, 20, 16, 4);
     TEST_FIELD(POLYTEXTA, INT *, pdx, 36, 4, 4);
+}
 
+static void test_pack_POLYTEXTW(void)
+{
     /* POLYTEXTW (pack 4) */
     TEST_TYPE(POLYTEXTW, 40, 4);
     TEST_FIELD(POLYTEXTW, INT, x, 0, 4, 4);
@@ -2024,79 +3328,128 @@
     TEST_FIELD(POLYTEXTW, UINT, uiFlags, 16, 4, 4);
     TEST_FIELD(POLYTEXTW, RECT, rcl, 20, 16, 4);
     TEST_FIELD(POLYTEXTW, INT *, pdx, 36, 4, 4);
+}
 
+static void test_pack_POUTLINETEXTMETRICA(void)
+{
     /* POUTLINETEXTMETRICA */
     TEST_TYPE(POUTLINETEXTMETRICA, 4, 4);
-    TEST_TYPE_POINTER(POUTLINETEXTMETRICA, 212, 4);
+}
 
+static void test_pack_POUTLINETEXTMETRICW(void)
+{
     /* POUTLINETEXTMETRICW */
     TEST_TYPE(POUTLINETEXTMETRICW, 4, 4);
-    TEST_TYPE_POINTER(POUTLINETEXTMETRICW, 216, 4);
+}
 
+static void test_pack_PPELARRAY(void)
+{
     /* PPELARRAY */
     TEST_TYPE(PPELARRAY, 4, 4);
     TEST_TYPE_POINTER(PPELARRAY, 20, 4);
+}
 
+static void test_pack_PPIXELFORMATDESCRIPTOR(void)
+{
     /* PPIXELFORMATDESCRIPTOR */
     TEST_TYPE(PPIXELFORMATDESCRIPTOR, 4, 4);
     TEST_TYPE_POINTER(PPIXELFORMATDESCRIPTOR, 40, 4);
+}
 
+static void test_pack_PPOLYTEXTA(void)
+{
     /* PPOLYTEXTA */
     TEST_TYPE(PPOLYTEXTA, 4, 4);
     TEST_TYPE_POINTER(PPOLYTEXTA, 40, 4);
+}
 
+static void test_pack_PPOLYTEXTW(void)
+{
     /* PPOLYTEXTW */
     TEST_TYPE(PPOLYTEXTW, 4, 4);
     TEST_TYPE_POINTER(PPOLYTEXTW, 40, 4);
+}
 
+static void test_pack_PRGNDATA(void)
+{
     /* PRGNDATA */
     TEST_TYPE(PRGNDATA, 4, 4);
     TEST_TYPE_POINTER(PRGNDATA, 36, 4);
+}
 
+static void test_pack_PRGNDATAHEADER(void)
+{
     /* PRGNDATAHEADER */
     TEST_TYPE(PRGNDATAHEADER, 4, 4);
     TEST_TYPE_POINTER(PRGNDATAHEADER, 32, 4);
+}
 
+static void test_pack_PTEXTMETRICA(void)
+{
     /* PTEXTMETRICA */
     TEST_TYPE(PTEXTMETRICA, 4, 4);
     TEST_TYPE_POINTER(PTEXTMETRICA, 56, 4);
+}
 
+static void test_pack_PTEXTMETRICW(void)
+{
     /* PTEXTMETRICW */
     TEST_TYPE(PTEXTMETRICW, 4, 4);
     TEST_TYPE_POINTER(PTEXTMETRICW, 60, 4);
+}
 
+static void test_pack_PTRIVERTEX(void)
+{
     /* PTRIVERTEX */
     TEST_TYPE(PTRIVERTEX, 4, 4);
     TEST_TYPE_POINTER(PTRIVERTEX, 16, 4);
+}
 
+static void test_pack_PXFORM(void)
+{
     /* PXFORM */
     TEST_TYPE(PXFORM, 4, 4);
     TEST_TYPE_POINTER(PXFORM, 24, 4);
+}
 
+static void test_pack_RASTERIZER_STATUS(void)
+{
     /* RASTERIZER_STATUS (pack 4) */
     TEST_TYPE(RASTERIZER_STATUS, 6, 2);
     TEST_FIELD(RASTERIZER_STATUS, SHORT, nSize, 0, 2, 2);
     TEST_FIELD(RASTERIZER_STATUS, SHORT, wFlags, 2, 2, 2);
     TEST_FIELD(RASTERIZER_STATUS, SHORT, nLanguageID, 4, 2, 2);
+}
 
+static void test_pack_RGBQUAD(void)
+{
     /* RGBQUAD (pack 4) */
     TEST_TYPE(RGBQUAD, 4, 1);
     TEST_FIELD(RGBQUAD, BYTE, rgbBlue, 0, 1, 1);
     TEST_FIELD(RGBQUAD, BYTE, rgbGreen, 1, 1, 1);
     TEST_FIELD(RGBQUAD, BYTE, rgbRed, 2, 1, 1);
     TEST_FIELD(RGBQUAD, BYTE, rgbReserved, 3, 1, 1);
+}
 
+static void test_pack_RGBTRIPLE(void)
+{
     /* RGBTRIPLE (pack 4) */
     TEST_TYPE(RGBTRIPLE, 3, 1);
     TEST_FIELD(RGBTRIPLE, BYTE, rgbtBlue, 0, 1, 1);
     TEST_FIELD(RGBTRIPLE, BYTE, rgbtGreen, 1, 1, 1);
     TEST_FIELD(RGBTRIPLE, BYTE, rgbtRed, 2, 1, 1);
+}
 
+static void test_pack_RGNDATA(void)
+{
     /* RGNDATA (pack 4) */
     TEST_TYPE(RGNDATA, 36, 4);
     TEST_FIELD(RGNDATA, RGNDATAHEADER, rdh, 0, 32, 4);
     TEST_FIELD(RGNDATA, char[1], Buffer, 32, 1, 1);
+}
 
+static void test_pack_RGNDATAHEADER(void)
+{
     /* RGNDATAHEADER (pack 4) */
     TEST_TYPE(RGNDATAHEADER, 32, 4);
     TEST_FIELD(RGNDATAHEADER, DWORD, dwSize, 0, 4, 4);
@@ -2104,7 +3457,10 @@
     TEST_FIELD(RGNDATAHEADER, DWORD, nCount, 8, 4, 4);
     TEST_FIELD(RGNDATAHEADER, DWORD, nRgnSize, 12, 4, 4);
     TEST_FIELD(RGNDATAHEADER, RECT, rcBound, 16, 16, 4);
+}
 
+static void test_pack_TEXTMETRICA(void)
+{
     /* TEXTMETRICA (pack 4) */
     TEST_TYPE(TEXTMETRICA, 56, 4);
     TEST_FIELD(TEXTMETRICA, LONG, tmHeight, 0, 4, 4);
@@ -2127,7 +3483,10 @@
     TEST_FIELD(TEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
     TEST_FIELD(TEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
     TEST_FIELD(TEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
+}
 
+static void test_pack_TEXTMETRICW(void)
+{
     /* TEXTMETRICW (pack 4) */
     TEST_TYPE(TEXTMETRICW, 60, 4);
     TEST_FIELD(TEXTMETRICW, LONG, tmHeight, 0, 4, 4);
@@ -2150,7 +3509,10 @@
     TEST_FIELD(TEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
     TEST_FIELD(TEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
     TEST_FIELD(TEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
+}
 
+static void test_pack_TRIVERTEX(void)
+{
     /* TRIVERTEX (pack 4) */
     TEST_TYPE(TRIVERTEX, 16, 4);
     TEST_FIELD(TRIVERTEX, LONG, x, 0, 4, 4);
@@ -2159,19 +3521,28 @@
     TEST_FIELD(TRIVERTEX, COLOR16, Green, 10, 2, 2);
     TEST_FIELD(TRIVERTEX, COLOR16, Blue, 12, 2, 2);
     TEST_FIELD(TRIVERTEX, COLOR16, Alpha, 14, 2, 2);
+}
 
+static void test_pack_TTPOLYCURVE(void)
+{
     /* TTPOLYCURVE (pack 4) */
     TEST_TYPE(TTPOLYCURVE, 12, 2);
     TEST_FIELD(TTPOLYCURVE, WORD, wType, 0, 2, 2);
     TEST_FIELD(TTPOLYCURVE, WORD, cpfx, 2, 2, 2);
     TEST_FIELD(TTPOLYCURVE, POINTFX[1], apfx, 4, 8, 2);
+}
 
+static void test_pack_TTPOLYGONHEADER(void)
+{
     /* TTPOLYGONHEADER (pack 4) */
     TEST_TYPE(TTPOLYGONHEADER, 16, 4);
     TEST_FIELD(TTPOLYGONHEADER, DWORD, cb, 0, 4, 4);
     TEST_FIELD(TTPOLYGONHEADER, DWORD, dwType, 4, 4, 4);
     TEST_FIELD(TTPOLYGONHEADER, POINTFX, pfxStart, 8, 8, 2);
+}
 
+static void test_pack_XFORM(void)
+{
     /* XFORM (pack 4) */
     TEST_TYPE(XFORM, 24, 4);
     TEST_FIELD(XFORM, FLOAT, eM11, 0, 4, 4);
@@ -2180,7 +3551,401 @@
     TEST_FIELD(XFORM, FLOAT, eM22, 12, 4, 4);
     TEST_FIELD(XFORM, FLOAT, eDx, 16, 4, 4);
     TEST_FIELD(XFORM, FLOAT, eDy, 20, 4, 4);
+}
 
+static void test_pack(void)
+{
+    test_pack_ABC();
+    test_pack_ABCFLOAT();
+    test_pack_ABORTPROC();
+    test_pack_BITMAP();
+    test_pack_BITMAPCOREHEADER();
+    test_pack_BITMAPCOREINFO();
+    test_pack_BITMAPFILEHEADER();
+    test_pack_BITMAPINFO();
+    test_pack_BITMAPINFOHEADER();
+    test_pack_BITMAPV4HEADER();
+    test_pack_BITMAPV5HEADER();
+    test_pack_BLENDFUNCTION();
+    test_pack_CHARSETINFO();
+    test_pack_CIEXYZ();
+    test_pack_CIEXYZTRIPLE();
+    test_pack_COLOR16();
+    test_pack_COLORADJUSTMENT();
+    test_pack_DIBSECTION();
+    test_pack_DISPLAY_DEVICEA();
+    test_pack_DISPLAY_DEVICEW();
+    test_pack_DOCINFOA();
+    test_pack_DOCINFOW();
+    test_pack_EMR();
+    test_pack_EMRABORTPATH();
+    test_pack_EMRANGLEARC();
+    test_pack_EMRARC();
+    test_pack_EMRARCTO();
+    test_pack_EMRBEGINPATH();
+    test_pack_EMRBITBLT();
+    test_pack_EMRCHORD();
+    test_pack_EMRCLOSEFIGURE();
+    test_pack_EMRCREATEBRUSHINDIRECT();
+    test_pack_EMRCREATEDIBPATTERNBRUSHPT();
+    test_pack_EMRCREATEMONOBRUSH();
+    test_pack_EMRCREATEPEN();
+    test_pack_EMRDELETECOLORSPACE();
+    test_pack_EMRDELETEOBJECT();
+    test_pack_EMRELLIPSE();
+    test_pack_EMRENDPATH();
+    test_pack_EMREOF();
+    test_pack_EMREXCLUDECLIPRECT();
+    test_pack_EMREXTCREATEFONTINDIRECTW();
+    test_pack_EMREXTCREATEPEN();
+    test_pack_EMREXTFLOODFILL();
+    test_pack_EMREXTSELECTCLIPRGN();
+    test_pack_EMREXTTEXTOUTA();
+    test_pack_EMREXTTEXTOUTW();
+    test_pack_EMRFILLPATH();
+    test_pack_EMRFILLRGN();
+    test_pack_EMRFLATTENPATH();
+    test_pack_EMRFORMAT();
+    test_pack_EMRFRAMERGN();
+    test_pack_EMRGDICOMMENT();
+    test_pack_EMRGLSBOUNDEDRECORD();
+    test_pack_EMRGLSRECORD();
+    test_pack_EMRINTERSECTCLIPRECT();
+    test_pack_EMRINVERTRGN();
+    test_pack_EMRLINETO();
+    test_pack_EMRMASKBLT();
+    test_pack_EMRMODIFYWORLDTRANSFORM();
+    test_pack_EMRMOVETOEX();
+    test_pack_EMROFFSETCLIPRGN();
+    test_pack_EMRPAINTRGN();
+    test_pack_EMRPIE();
+    test_pack_EMRPIXELFORMAT();
+    test_pack_EMRPLGBLT();
+    test_pack_EMRPOLYBEZIER();
+    test_pack_EMRPOLYBEZIERTO();
+    test_pack_EMRPOLYDRAW();
+    test_pack_EMRPOLYGON();
+    test_pack_EMRPOLYLINE();
+    test_pack_EMRPOLYLINETO();
+    test_pack_EMRPOLYPOLYGON();
+    test_pack_EMRPOLYPOLYLINE();
+    test_pack_EMRPOLYTEXTOUTA();
+    test_pack_EMRPOLYTEXTOUTW();
+    test_pack_EMRREALIZEPALETTE();
+    test_pack_EMRRECTANGLE();
+    test_pack_EMRRESIZEPALETTE();
+    test_pack_EMRRESTOREDC();
+    test_pack_EMRROUNDRECT();
+    test_pack_EMRSAVEDC();
+    test_pack_EMRSCALEVIEWPORTEXTEX();
+    test_pack_EMRSCALEWINDOWEXTEX();
+    test_pack_EMRSELECTCLIPPATH();
+    test_pack_EMRSELECTCOLORSPACE();
+    test_pack_EMRSELECTOBJECT();
+    test_pack_EMRSELECTPALETTE();
+    test_pack_EMRSETARCDIRECTION();
+    test_pack_EMRSETBKCOLOR();
+    test_pack_EMRSETBKMODE();
+    test_pack_EMRSETBRUSHORGEX();
+    test_pack_EMRSETCOLORADJUSTMENT();
+    test_pack_EMRSETDIBITSTODEVICE();
+    test_pack_EMRSETICMMODE();
+    test_pack_EMRSETMAPMODE();
+    test_pack_EMRSETMAPPERFLAGS();
+    test_pack_EMRSETMETARGN();
+    test_pack_EMRSETMITERLIMIT();
+    test_pack_EMRSETPIXELV();
+    test_pack_EMRSETPOLYFILLMODE();
+    test_pack_EMRSETROP2();
+    test_pack_EMRSETSTRETCHBLTMODE();
+    test_pack_EMRSETTEXTALIGN();
+    test_pack_EMRSETTEXTCOLOR();
+    test_pack_EMRSETVIEWPORTEXTEX();
+    test_pack_EMRSETVIEWPORTORGEX();
+    test_pack_EMRSETWINDOWEXTEX();
+    test_pack_EMRSETWINDOWORGEX();
+    test_pack_EMRSETWORLDTRANSFORM();
+    test_pack_EMRSTRETCHBLT();
+    test_pack_EMRSTRETCHDIBITS();
+    test_pack_EMRSTROKEANDFILLPATH();
+    test_pack_EMRSTROKEPATH();
+    test_pack_EMRTEXT();
+    test_pack_EMRWIDENPATH();
+    test_pack_ENHMETAHEADER();
+    test_pack_ENHMETARECORD();
+    test_pack_ENHMFENUMPROC();
+    test_pack_ENUMLOGFONTA();
+    test_pack_ENUMLOGFONTEXA();
+    test_pack_ENUMLOGFONTEXW();
+    test_pack_ENUMLOGFONTW();
+    test_pack_EXTLOGFONTA();
+    test_pack_EXTLOGFONTW();
+    test_pack_EXTLOGPEN();
+    test_pack_FIXED();
+    test_pack_FONTENUMPROCA();
+    test_pack_FONTENUMPROCW();
+    test_pack_FONTSIGNATURE();
+    test_pack_FXPT16DOT16();
+    test_pack_FXPT2DOT30();
+    test_pack_GCP_RESULTSA();
+    test_pack_GCP_RESULTSW();
+    test_pack_GLYPHMETRICS();
+    test_pack_GOBJENUMPROC();
+    test_pack_GRADIENT_RECT();
+    test_pack_GRADIENT_TRIANGLE();
+    test_pack_HANDLETABLE();
+    test_pack_KERNINGPAIR();
+    test_pack_LCSCSTYPE();
+    test_pack_LCSGAMUTMATCH();
+    test_pack_LINEDDAPROC();
+    test_pack_LOCALESIGNATURE();
+    test_pack_LOGBRUSH();
+    test_pack_LOGCOLORSPACEA();
+    test_pack_LOGCOLORSPACEW();
+    test_pack_LOGFONTA();
+    test_pack_LOGFONTW();
+    test_pack_LOGPEN();
+    test_pack_LPABC();
+    test_pack_LPABCFLOAT();
+    test_pack_LPBITMAP();
+    test_pack_LPBITMAPCOREHEADER();
+    test_pack_LPBITMAPCOREINFO();
+    test_pack_LPBITMAPFILEHEADER();
+    test_pack_LPBITMAPINFO();
+    test_pack_LPBITMAPINFOHEADER();
+    test_pack_LPBITMAPV5HEADER();
+    test_pack_LPCHARSETINFO();
+    test_pack_LPCIEXYZ();
+    test_pack_LPCIEXYZTRIPLE();
+    test_pack_LPCOLORADJUSTMENT();
+    test_pack_LPDEVMODEA();
+    test_pack_LPDEVMODEW();
+    test_pack_LPDIBSECTION();
+    test_pack_LPDISPLAY_DEVICEA();
+    test_pack_LPDISPLAY_DEVICEW();
+    test_pack_LPDOCINFOA();
+    test_pack_LPDOCINFOW();
+    test_pack_LPENHMETAHEADER();
+    test_pack_LPENHMETARECORD();
+    test_pack_LPENUMLOGFONTA();
+    test_pack_LPENUMLOGFONTEXA();
+    test_pack_LPENUMLOGFONTEXW();
+    test_pack_LPENUMLOGFONTW();
+    test_pack_LPEXTLOGFONTA();
+    test_pack_LPEXTLOGFONTW();
+    test_pack_LPEXTLOGPEN();
+    test_pack_LPFONTSIGNATURE();
+    test_pack_LPGCP_RESULTSA();
+    test_pack_LPGCP_RESULTSW();
+    test_pack_LPGLYPHMETRICS();
+    test_pack_LPGRADIENT_RECT();
+    test_pack_LPGRADIENT_TRIANGLE();
+    test_pack_LPHANDLETABLE();
+    test_pack_LPKERNINGPAIR();
+    test_pack_LPLOCALESIGNATURE();
+    test_pack_LPLOGBRUSH();
+    test_pack_LPLOGCOLORSPACEA();
+    test_pack_LPLOGCOLORSPACEW();
+    test_pack_LPLOGFONTA();
+    test_pack_LPLOGFONTW();
+    test_pack_LPLOGPEN();
+    test_pack_LPMAT2();
+    test_pack_LPMETAFILEPICT();
+    test_pack_LPMETAHEADER();
+    test_pack_LPMETARECORD();
+    test_pack_LPNEWTEXTMETRICA();
+    test_pack_LPNEWTEXTMETRICW();
+    test_pack_LPOUTLINETEXTMETRICA();
+    test_pack_LPOUTLINETEXTMETRICW();
+    test_pack_LPPANOSE();
+    test_pack_LPPELARRAY();
+    test_pack_LPPIXELFORMATDESCRIPTOR();
+    test_pack_LPPOINTFX();
+    test_pack_LPPOLYTEXTA();
+    test_pack_LPPOLYTEXTW();
+    test_pack_LPRASTERIZER_STATUS();
+    test_pack_LPRGBQUAD();
+    test_pack_LPRGNDATA();
+    test_pack_LPTEXTMETRICA();
+    test_pack_LPTEXTMETRICW();
+    test_pack_LPTRIVERTEX();
+    test_pack_LPTTPOLYCURVE();
+    test_pack_LPTTPOLYGONHEADER();
+    test_pack_LPXFORM();
+    test_pack_MAT2();
+    test_pack_METAFILEPICT();
+    test_pack_METAHEADER();
+    test_pack_METARECORD();
+    test_pack_MFENUMPROC();
+    test_pack_NEWTEXTMETRICA();
+    test_pack_NEWTEXTMETRICEXA();
+    test_pack_NEWTEXTMETRICEXW();
+    test_pack_NEWTEXTMETRICW();
+    test_pack_NPEXTLOGPEN();
+    test_pack_OLDFONTENUMPROCA();
+    test_pack_OLDFONTENUMPROCW();
+    test_pack_OUTLINETEXTMETRICA();
+    test_pack_OUTLINETEXTMETRICW();
+    test_pack_PABC();
+    test_pack_PABCFLOAT();
+    test_pack_PANOSE();
+    test_pack_PATTERN();
+    test_pack_PBITMAP();
+    test_pack_PBITMAPCOREHEADER();
+    test_pack_PBITMAPCOREINFO();
+    test_pack_PBITMAPFILEHEADER();
+    test_pack_PBITMAPINFO();
+    test_pack_PBITMAPINFOHEADER();
+    test_pack_PBITMAPV4HEADER();
+    test_pack_PBITMAPV5HEADER();
+    test_pack_PBLENDFUNCTION();
+    test_pack_PCHARSETINFO();
+    test_pack_PCOLORADJUSTMENT();
+    test_pack_PDEVMODEA();
+    test_pack_PDEVMODEW();
+    test_pack_PDIBSECTION();
+    test_pack_PDISPLAY_DEVICEA();
+    test_pack_PDISPLAY_DEVICEW();
+    test_pack_PELARRAY();
+    test_pack_PEMR();
+    test_pack_PEMRABORTPATH();
+    test_pack_PEMRANGLEARC();
+    test_pack_PEMRARC();
+    test_pack_PEMRARCTO();
+    test_pack_PEMRBEGINPATH();
+    test_pack_PEMRBITBLT();
+    test_pack_PEMRCHORD();
+    test_pack_PEMRCLOSEFIGURE();
+    test_pack_PEMRCREATEBRUSHINDIRECT();
+    test_pack_PEMRCREATEDIBPATTERNBRUSHPT();
+    test_pack_PEMRCREATEMONOBRUSH();
+    test_pack_PEMRCREATEPALETTE();
+    test_pack_PEMRCREATEPEN();
+    test_pack_PEMRDELETECOLORSPACE();
+    test_pack_PEMRDELETEOBJECT();
+    test_pack_PEMRELLIPSE();
+    test_pack_PEMRENDPATH();
+    test_pack_PEMREOF();
+    test_pack_PEMREXCLUDECLIPRECT();
+    test_pack_PEMREXTCREATEFONTINDIRECTW();
+    test_pack_PEMREXTCREATEPEN();
+    test_pack_PEMREXTFLOODFILL();
+    test_pack_PEMREXTSELECTCLIPRGN();
+    test_pack_PEMREXTTEXTOUTA();
+    test_pack_PEMREXTTEXTOUTW();
+    test_pack_PEMRFILLPATH();
+    test_pack_PEMRFILLRGN();
+    test_pack_PEMRFLATTENPATH();
+    test_pack_PEMRFORMAT();
+    test_pack_PEMRFRAMERGN();
+    test_pack_PEMRGDICOMMENT();
+    test_pack_PEMRGLSBOUNDEDRECORD();
+    test_pack_PEMRGLSRECORD();
+    test_pack_PEMRINTERSECTCLIPRECT();
+    test_pack_PEMRINVERTRGN();
+    test_pack_PEMRLINETO();
+    test_pack_PEMRMASKBLT();
+    test_pack_PEMRMODIFYWORLDTRANSFORM();
+    test_pack_PEMRMOVETOEX();
+    test_pack_PEMROFFSETCLIPRGN();
+    test_pack_PEMRPAINTRGN();
+    test_pack_PEMRPIE();
+    test_pack_PEMRPIXELFORMAT();
+    test_pack_PEMRPLGBLT();
+    test_pack_PEMRPOLYBEZIER();
+    test_pack_PEMRPOLYBEZIERTO();
+    test_pack_PEMRPOLYDRAW();
+    test_pack_PEMRPOLYGON();
+    test_pack_PEMRPOLYLINE();
+    test_pack_PEMRPOLYLINETO();
+    test_pack_PEMRPOLYPOLYGON();
+    test_pack_PEMRPOLYPOLYLINE();
+    test_pack_PEMRPOLYTEXTOUTA();
+    test_pack_PEMRPOLYTEXTOUTW();
+    test_pack_PEMRREALIZEPALETTE();
+    test_pack_PEMRRECTANGLE();
+    test_pack_PEMRRESIZEPALETTE();
+    test_pack_PEMRRESTOREDC();
+    test_pack_PEMRROUNDRECT();
+    test_pack_PEMRSAVEDC();
+    test_pack_PEMRSCALEVIEWPORTEXTEX();
+    test_pack_PEMRSCALEWINDOWEXTEX();
+    test_pack_PEMRSELECTCLIPPATH();
+    test_pack_PEMRSELECTCOLORSPACE();
+    test_pack_PEMRSELECTOBJECT();
+    test_pack_PEMRSELECTPALETTE();
+    test_pack_PEMRSETARCDIRECTION();
+    test_pack_PEMRSETBKCOLOR();
+    test_pack_PEMRSETBKMODE();
+    test_pack_PEMRSETBRUSHORGEX();
+    test_pack_PEMRSETCOLORADJUSTMENT();
+    test_pack_PEMRSETDIBITSTODEVICE();
+    test_pack_PEMRSETICMMODE();
+    test_pack_PEMRSETMAPMODE();
+    test_pack_PEMRSETMAPPERFLAGS();
+    test_pack_PEMRSETMETARGN();
+    test_pack_PEMRSETMITERLIMIT();
+    test_pack_PEMRSETPALETTEENTRIES();
+    test_pack_PEMRSETPIXELV();
+    test_pack_PEMRSETPOLYFILLMODE();
+    test_pack_PEMRSETROP2();
+    test_pack_PEMRSETSTRETCHBLTMODE();
+    test_pack_PEMRSETTEXTALIGN();
+    test_pack_PEMRSETTEXTCOLOR();
+    test_pack_PEMRSETVIEWPORTEXTEX();
+    test_pack_PEMRSETVIEWPORTORGEX();
+    test_pack_PEMRSETWINDOWEXTEX();
+    test_pack_PEMRSETWINDOWORGEX();
+    test_pack_PEMRSETWORLDTRANSFORM();
+    test_pack_PEMRSTRETCHBLT();
+    test_pack_PEMRSTRETCHDIBITS();
+    test_pack_PEMRSTROKEANDFILLPATH();
+    test_pack_PEMRSTROKEPATH();
+    test_pack_PEMRTEXT();
+    test_pack_PEMRWIDENPATH();
+    test_pack_PENHMETAHEADER();
+    test_pack_PEXTLOGFONTA();
+    test_pack_PEXTLOGFONTW();
+    test_pack_PEXTLOGPEN();
+    test_pack_PFONTSIGNATURE();
+    test_pack_PGRADIENT_RECT();
+    test_pack_PGRADIENT_TRIANGLE();
+    test_pack_PHANDLETABLE();
+    test_pack_PIXELFORMATDESCRIPTOR();
+    test_pack_PLOCALESIGNATURE();
+    test_pack_PLOGBRUSH();
+    test_pack_PLOGFONTA();
+    test_pack_PLOGFONTW();
+    test_pack_PMETAHEADER();
+    test_pack_PMETARECORD();
+    test_pack_PNEWTEXTMETRICA();
+    test_pack_PNEWTEXTMETRICW();
+    test_pack_POINTFX();
+    test_pack_POLYTEXTA();
+    test_pack_POLYTEXTW();
+    test_pack_POUTLINETEXTMETRICA();
+    test_pack_POUTLINETEXTMETRICW();
+    test_pack_PPELARRAY();
+    test_pack_PPIXELFORMATDESCRIPTOR();
+    test_pack_PPOLYTEXTA();
+    test_pack_PPOLYTEXTW();
+    test_pack_PRGNDATA();
+    test_pack_PRGNDATAHEADER();
+    test_pack_PTEXTMETRICA();
+    test_pack_PTEXTMETRICW();
+    test_pack_PTRIVERTEX();
+    test_pack_PXFORM();
+    test_pack_RASTERIZER_STATUS();
+    test_pack_RGBQUAD();
+    test_pack_RGBTRIPLE();
+    test_pack_RGNDATA();
+    test_pack_RGNDATAHEADER();
+    test_pack_TEXTMETRICA();
+    test_pack_TEXTMETRICW();
+    test_pack_TRIVERTEX();
+    test_pack_TTPOLYCURVE();
+    test_pack_TTPOLYGONHEADER();
+    test_pack_XFORM();
 }
 
 START_TEST(generated)
diff --git a/dlls/kernel/tests/generated.c b/dlls/kernel/tests/generated.c
index a8bc0c5..98099fb 100644
--- a/dlls/kernel/tests/generated.c
+++ b/dlls/kernel/tests/generated.c
@@ -108,7 +108,7 @@
 #define TEST_TYPE_UNSIGNED(type) \
      ok((type) -1 > 0, "(" #type ") -1 > 0");
 
-void test_pack(void)
+static void test_pack_BY_HANDLE_FILE_INFORMATION(void)
 {
     /* BY_HANDLE_FILE_INFORMATION (pack 4) */
     TEST_TYPE(BY_HANDLE_FILE_INFORMATION, 52, 4);
@@ -122,12 +122,18 @@
     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nNumberOfLinks, 40, 4, 4);
     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileIndexHigh, 44, 4, 4);
     TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileIndexLow, 48, 4, 4);
+}
 
+static void test_pack_COMMCONFIG(void)
+{
     /* COMMCONFIG (pack 4) */
     TEST_FIELD(COMMCONFIG, DWORD, dwSize, 0, 4, 4);
     TEST_FIELD(COMMCONFIG, WORD, wVersion, 4, 2, 2);
     TEST_FIELD(COMMCONFIG, WORD, wReserved, 6, 2, 2);
+}
 
+static void test_pack_COMMPROP(void)
+{
     /* COMMPROP (pack 4) */
     TEST_TYPE(COMMPROP, 64, 4);
     TEST_FIELD(COMMPROP, WORD, wPacketLength, 0, 2, 2);
@@ -148,7 +154,10 @@
     TEST_FIELD(COMMPROP, DWORD, dwProvSpec1, 52, 4, 4);
     TEST_FIELD(COMMPROP, DWORD, dwProvSpec2, 56, 4, 4);
     TEST_FIELD(COMMPROP, WCHAR[1], wcProvChar, 60, 2, 2);
+}
 
+static void test_pack_COMMTIMEOUTS(void)
+{
     /* COMMTIMEOUTS (pack 4) */
     TEST_TYPE(COMMTIMEOUTS, 20, 4);
     TEST_FIELD(COMMTIMEOUTS, DWORD, ReadIntervalTimeout, 0, 4, 4);
@@ -156,12 +165,18 @@
     TEST_FIELD(COMMTIMEOUTS, DWORD, ReadTotalTimeoutConstant, 8, 4, 4);
     TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutMultiplier, 12, 4, 4);
     TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutConstant, 16, 4, 4);
+}
 
+static void test_pack_COMSTAT(void)
+{
     /* COMSTAT (pack 4) */
     TEST_TYPE(COMSTAT, 12, 4);
     TEST_FIELD(COMSTAT, DWORD, cbInQue, 4, 4, 4);
     TEST_FIELD(COMSTAT, DWORD, cbOutQue, 8, 4, 4);
+}
 
+static void test_pack_CREATE_PROCESS_DEBUG_INFO(void)
+{
     /* CREATE_PROCESS_DEBUG_INFO (pack 4) */
     TEST_TYPE(CREATE_PROCESS_DEBUG_INFO, 40, 4);
     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, HANDLE, hFile, 0, 4, 4);
@@ -174,63 +189,93 @@
     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPTHREAD_START_ROUTINE, lpStartAddress, 28, 4, 4);
     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPVOID, lpImageName, 32, 4, 4);
     TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, WORD, fUnicode, 36, 2, 2);
+}
 
+static void test_pack_CREATE_THREAD_DEBUG_INFO(void)
+{
     /* CREATE_THREAD_DEBUG_INFO (pack 4) */
     TEST_TYPE(CREATE_THREAD_DEBUG_INFO, 12, 4);
     TEST_FIELD(CREATE_THREAD_DEBUG_INFO, HANDLE, hThread, 0, 4, 4);
     TEST_FIELD(CREATE_THREAD_DEBUG_INFO, LPVOID, lpThreadLocalBase, 4, 4, 4);
     TEST_FIELD(CREATE_THREAD_DEBUG_INFO, LPTHREAD_START_ROUTINE, lpStartAddress, 8, 4, 4);
+}
 
+static void test_pack_CRITICAL_SECTION(void)
+{
     /* CRITICAL_SECTION */
     TEST_TYPE(CRITICAL_SECTION, 24, 4);
+}
 
+static void test_pack_CRITICAL_SECTION_DEBUG(void)
+{
     /* CRITICAL_SECTION_DEBUG */
     TEST_TYPE(CRITICAL_SECTION_DEBUG, 32, 4);
+}
 
+static void test_pack_DCB(void)
+{
     /* DCB (pack 4) */
     TEST_FIELD(DCB, DWORD, DCBlength, 0, 4, 4);
     TEST_FIELD(DCB, DWORD, BaudRate, 4, 4, 4);
+}
 
+static void test_pack_DEBUG_EVENT(void)
+{
     /* DEBUG_EVENT (pack 4) */
     TEST_FIELD(DEBUG_EVENT, DWORD, dwDebugEventCode, 0, 4, 4);
     TEST_FIELD(DEBUG_EVENT, DWORD, dwProcessId, 4, 4, 4);
     TEST_FIELD(DEBUG_EVENT, DWORD, dwThreadId, 8, 4, 4);
+}
 
-    /* ENUMRESLANGPROCA */
-
-    /* ENUMRESLANGPROCW */
-
-    /* ENUMRESNAMEPROCA */
-
-    /* ENUMRESNAMEPROCW */
-
-    /* ENUMRESTYPEPROCA */
-
-    /* ENUMRESTYPEPROCW */
-
+static void test_pack_EXCEPTION_DEBUG_INFO(void)
+{
     /* EXCEPTION_DEBUG_INFO (pack 4) */
     TEST_TYPE(EXCEPTION_DEBUG_INFO, 84, 4);
     TEST_FIELD(EXCEPTION_DEBUG_INFO, EXCEPTION_RECORD, ExceptionRecord, 0, 80, 4);
     TEST_FIELD(EXCEPTION_DEBUG_INFO, DWORD, dwFirstChance, 80, 4, 4);
+}
 
+static void test_pack_EXIT_PROCESS_DEBUG_INFO(void)
+{
     /* EXIT_PROCESS_DEBUG_INFO (pack 4) */
     TEST_TYPE(EXIT_PROCESS_DEBUG_INFO, 4, 4);
     TEST_FIELD(EXIT_PROCESS_DEBUG_INFO, DWORD, dwExitCode, 0, 4, 4);
+}
 
+static void test_pack_EXIT_THREAD_DEBUG_INFO(void)
+{
     /* EXIT_THREAD_DEBUG_INFO (pack 4) */
     TEST_TYPE(EXIT_THREAD_DEBUG_INFO, 4, 4);
     TEST_FIELD(EXIT_THREAD_DEBUG_INFO, DWORD, dwExitCode, 0, 4, 4);
+}
 
+static void test_pack_HW_PROFILE_INFOA(void)
+{
     /* HW_PROFILE_INFOA (pack 4) */
     TEST_TYPE(HW_PROFILE_INFOA, 124, 4);
     TEST_FIELD(HW_PROFILE_INFOA, DWORD, dwDockInfo, 0, 4, 4);
     TEST_FIELD(HW_PROFILE_INFOA, CHAR[HW_PROFILE_GUIDLEN], szHwProfileGuid, 4, 39, 1);
     TEST_FIELD(HW_PROFILE_INFOA, CHAR[MAX_PROFILE_LEN], szHwProfileName, 43, 80, 1);
+}
 
+static void test_pack_HW_PROFILE_INFOW(void)
+{
+    /* HW_PROFILE_INFOW (pack 4) */
+    TEST_TYPE(HW_PROFILE_INFOW, 244, 4);
+    TEST_FIELD(HW_PROFILE_INFOW, DWORD, dwDockInfo, 0, 4, 4);
+    TEST_FIELD(HW_PROFILE_INFOW, WCHAR[HW_PROFILE_GUIDLEN], szHwProfileGuid, 4, 78, 2);
+    TEST_FIELD(HW_PROFILE_INFOW, WCHAR[MAX_PROFILE_LEN], szHwProfileName, 82, 160, 2);
+}
+
+static void test_pack_LDT_ENTRY(void)
+{
     /* LDT_ENTRY (pack 4) */
     TEST_FIELD(LDT_ENTRY, WORD, LimitLow, 0, 2, 2);
     TEST_FIELD(LDT_ENTRY, WORD, BaseLow, 2, 2, 2);
+}
 
+static void test_pack_LOAD_DLL_DEBUG_INFO(void)
+{
     /* LOAD_DLL_DEBUG_INFO (pack 4) */
     TEST_TYPE(LOAD_DLL_DEBUG_INFO, 24, 4);
     TEST_FIELD(LOAD_DLL_DEBUG_INFO, HANDLE, hFile, 0, 4, 4);
@@ -239,142 +284,265 @@
     TEST_FIELD(LOAD_DLL_DEBUG_INFO, DWORD, nDebugInfoSize, 12, 4, 4);
     TEST_FIELD(LOAD_DLL_DEBUG_INFO, LPVOID, lpImageName, 16, 4, 4);
     TEST_FIELD(LOAD_DLL_DEBUG_INFO, WORD, fUnicode, 20, 2, 2);
+}
 
+static void test_pack_LPBY_HANDLE_FILE_INFORMATION(void)
+{
     /* LPBY_HANDLE_FILE_INFORMATION */
     TEST_TYPE(LPBY_HANDLE_FILE_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(LPBY_HANDLE_FILE_INFORMATION, 52, 4);
+}
 
+static void test_pack_LPCOMMCONFIG(void)
+{
     /* LPCOMMCONFIG */
     TEST_TYPE(LPCOMMCONFIG, 4, 4);
+}
 
+static void test_pack_LPCOMMPROP(void)
+{
     /* LPCOMMPROP */
     TEST_TYPE(LPCOMMPROP, 4, 4);
     TEST_TYPE_POINTER(LPCOMMPROP, 64, 4);
+}
 
+static void test_pack_LPCOMMTIMEOUTS(void)
+{
     /* LPCOMMTIMEOUTS */
     TEST_TYPE(LPCOMMTIMEOUTS, 4, 4);
     TEST_TYPE_POINTER(LPCOMMTIMEOUTS, 20, 4);
+}
 
+static void test_pack_LPCOMSTAT(void)
+{
     /* LPCOMSTAT */
     TEST_TYPE(LPCOMSTAT, 4, 4);
     TEST_TYPE_POINTER(LPCOMSTAT, 12, 4);
+}
 
+static void test_pack_LPCONTEXT(void)
+{
     /* LPCONTEXT */
     TEST_TYPE(LPCONTEXT, 4, 4);
+}
 
+static void test_pack_LPCRITICAL_SECTION(void)
+{
     /* LPCRITICAL_SECTION */
     TEST_TYPE(LPCRITICAL_SECTION, 4, 4);
+}
 
+static void test_pack_LPCRITICAL_SECTION_DEBUG(void)
+{
     /* LPCRITICAL_SECTION_DEBUG */
     TEST_TYPE(LPCRITICAL_SECTION_DEBUG, 4, 4);
+}
 
+static void test_pack_LPDCB(void)
+{
     /* LPDCB */
     TEST_TYPE(LPDCB, 4, 4);
+}
 
+static void test_pack_LPDEBUG_EVENT(void)
+{
     /* LPDEBUG_EVENT */
     TEST_TYPE(LPDEBUG_EVENT, 4, 4);
+}
 
+static void test_pack_LPEXCEPTION_POINTERS(void)
+{
     /* LPEXCEPTION_POINTERS */
     TEST_TYPE(LPEXCEPTION_POINTERS, 4, 4);
+}
 
+static void test_pack_LPEXCEPTION_RECORD(void)
+{
     /* LPEXCEPTION_RECORD */
     TEST_TYPE(LPEXCEPTION_RECORD, 4, 4);
+}
 
+static void test_pack_LPFIBER_START_ROUTINE(void)
+{
     /* LPFIBER_START_ROUTINE */
+    TEST_TYPE(LPFIBER_START_ROUTINE, 4, 4);
+}
 
+static void test_pack_LPHW_PROFILE_INFOA(void)
+{
     /* LPHW_PROFILE_INFOA */
     TEST_TYPE(LPHW_PROFILE_INFOA, 4, 4);
     TEST_TYPE_POINTER(LPHW_PROFILE_INFOA, 124, 4);
+}
 
+static void test_pack_LPHW_PROFILE_INFOW(void)
+{
     /* LPHW_PROFILE_INFOW */
     TEST_TYPE(LPHW_PROFILE_INFOW, 4, 4);
     TEST_TYPE_POINTER(LPHW_PROFILE_INFOW, 244, 4);
+}
 
+static void test_pack_LPLDT_ENTRY(void)
+{
     /* LPLDT_ENTRY */
     TEST_TYPE(LPLDT_ENTRY, 4, 4);
+}
 
+static void test_pack_LPMEMORYSTATUS(void)
+{
     /* LPMEMORYSTATUS */
     TEST_TYPE(LPMEMORYSTATUS, 4, 4);
     TEST_TYPE_POINTER(LPMEMORYSTATUS, 32, 4);
+}
 
+static void test_pack_LPOFSTRUCT(void)
+{
     /* LPOFSTRUCT */
     TEST_TYPE(LPOFSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPOFSTRUCT, 136, 2);
+}
 
+static void test_pack_LPOSVERSIONINFOA(void)
+{
     /* LPOSVERSIONINFOA */
     TEST_TYPE(LPOSVERSIONINFOA, 4, 4);
     TEST_TYPE_POINTER(LPOSVERSIONINFOA, 148, 4);
+}
 
+static void test_pack_LPOSVERSIONINFOEXA(void)
+{
     /* LPOSVERSIONINFOEXA */
     TEST_TYPE(LPOSVERSIONINFOEXA, 4, 4);
+}
 
+static void test_pack_LPOSVERSIONINFOEXW(void)
+{
     /* LPOSVERSIONINFOEXW */
     TEST_TYPE(LPOSVERSIONINFOEXW, 4, 4);
+}
 
+static void test_pack_LPOSVERSIONINFOW(void)
+{
     /* LPOSVERSIONINFOW */
     TEST_TYPE(LPOSVERSIONINFOW, 4, 4);
     TEST_TYPE_POINTER(LPOSVERSIONINFOW, 276, 4);
+}
 
+static void test_pack_LPOVERLAPPED(void)
+{
     /* LPOVERLAPPED */
     TEST_TYPE(LPOVERLAPPED, 4, 4);
     TEST_TYPE_POINTER(LPOVERLAPPED, 20, 4);
+}
 
+static void test_pack_LPOVERLAPPED_COMPLETION_ROUTINE(void)
+{
     /* LPOVERLAPPED_COMPLETION_ROUTINE */
+    TEST_TYPE(LPOVERLAPPED_COMPLETION_ROUTINE, 4, 4);
+}
 
+static void test_pack_LPPROCESS_HEAP_ENTRY(void)
+{
     /* LPPROCESS_HEAP_ENTRY */
     TEST_TYPE(LPPROCESS_HEAP_ENTRY, 4, 4);
+}
 
+static void test_pack_LPPROCESS_INFORMATION(void)
+{
     /* LPPROCESS_INFORMATION */
     TEST_TYPE(LPPROCESS_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(LPPROCESS_INFORMATION, 16, 4);
+}
 
+static void test_pack_LPPROGRESS_ROUTINE(void)
+{
     /* LPPROGRESS_ROUTINE */
+    TEST_TYPE(LPPROGRESS_ROUTINE, 4, 4);
+}
 
+static void test_pack_LPSECURITY_ATTRIBUTES(void)
+{
     /* LPSECURITY_ATTRIBUTES */
     TEST_TYPE(LPSECURITY_ATTRIBUTES, 4, 4);
     TEST_TYPE_POINTER(LPSECURITY_ATTRIBUTES, 12, 4);
+}
 
+static void test_pack_LPSTARTUPINFOA(void)
+{
     /* LPSTARTUPINFOA */
     TEST_TYPE(LPSTARTUPINFOA, 4, 4);
-    TEST_TYPE_POINTER(LPSTARTUPINFOA, 68, 4);
+}
 
+static void test_pack_LPSTARTUPINFOW(void)
+{
     /* LPSTARTUPINFOW */
     TEST_TYPE(LPSTARTUPINFOW, 4, 4);
     TEST_TYPE_POINTER(LPSTARTUPINFOW, 68, 4);
+}
 
+static void test_pack_LPSYSTEMTIME(void)
+{
     /* LPSYSTEMTIME */
     TEST_TYPE(LPSYSTEMTIME, 4, 4);
     TEST_TYPE_POINTER(LPSYSTEMTIME, 16, 2);
+}
 
+static void test_pack_LPSYSTEM_INFO(void)
+{
     /* LPSYSTEM_INFO */
     TEST_TYPE(LPSYSTEM_INFO, 4, 4);
+}
 
+static void test_pack_LPSYSTEM_POWER_STATUS(void)
+{
     /* LPSYSTEM_POWER_STATUS */
     TEST_TYPE(LPSYSTEM_POWER_STATUS, 4, 4);
     TEST_TYPE_POINTER(LPSYSTEM_POWER_STATUS, 12, 4);
+}
 
+static void test_pack_LPTHREAD_START_ROUTINE(void)
+{
     /* LPTHREAD_START_ROUTINE */
+    TEST_TYPE(LPTHREAD_START_ROUTINE, 4, 4);
+}
 
+static void test_pack_LPTIME_ZONE_INFORMATION(void)
+{
     /* LPTIME_ZONE_INFORMATION */
     TEST_TYPE(LPTIME_ZONE_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(LPTIME_ZONE_INFORMATION, 172, 4);
+}
 
+static void test_pack_LPWIN32_FILE_ATTRIBUTE_DATA(void)
+{
     /* LPWIN32_FILE_ATTRIBUTE_DATA */
     TEST_TYPE(LPWIN32_FILE_ATTRIBUTE_DATA, 4, 4);
     TEST_TYPE_POINTER(LPWIN32_FILE_ATTRIBUTE_DATA, 36, 4);
+}
 
+static void test_pack_LPWIN32_FIND_DATAA(void)
+{
     /* LPWIN32_FIND_DATAA */
     TEST_TYPE(LPWIN32_FIND_DATAA, 4, 4);
     TEST_TYPE_POINTER(LPWIN32_FIND_DATAA, 320, 4);
+}
 
+static void test_pack_LPWIN32_FIND_DATAW(void)
+{
     /* LPWIN32_FIND_DATAW */
     TEST_TYPE(LPWIN32_FIND_DATAW, 4, 4);
     TEST_TYPE_POINTER(LPWIN32_FIND_DATAW, 592, 4);
+}
 
+static void test_pack_LPWIN32_STREAM_ID(void)
+{
     /* LPWIN32_STREAM_ID */
     TEST_TYPE(LPWIN32_STREAM_ID, 4, 4);
     TEST_TYPE_POINTER(LPWIN32_STREAM_ID, 24, 4);
+}
 
+static void test_pack_MEMORYSTATUS(void)
+{
     /* MEMORYSTATUS (pack 4) */
     TEST_TYPE(MEMORYSTATUS, 32, 4);
     TEST_FIELD(MEMORYSTATUS, DWORD, dwLength, 0, 4, 4);
@@ -385,7 +553,10 @@
     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwAvailPageFile, 20, 4, 4);
     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwTotalVirtual, 24, 4, 4);
     TEST_FIELD(MEMORYSTATUS, SIZE_T, dwAvailVirtual, 28, 4, 4);
+}
 
+static void test_pack_OFSTRUCT(void)
+{
     /* OFSTRUCT (pack 4) */
     TEST_TYPE(OFSTRUCT, 136, 2);
     TEST_FIELD(OFSTRUCT, BYTE, cBytes, 0, 1, 1);
@@ -394,7 +565,10 @@
     TEST_FIELD(OFSTRUCT, WORD, Reserved1, 4, 2, 2);
     TEST_FIELD(OFSTRUCT, WORD, Reserved2, 6, 2, 2);
     TEST_FIELD(OFSTRUCT, BYTE[OFS_MAXPATHNAME], szPathName, 8, 128, 1);
+}
 
+static void test_pack_OSVERSIONINFOA(void)
+{
     /* OSVERSIONINFOA (pack 4) */
     TEST_TYPE(OSVERSIONINFOA, 148, 4);
     TEST_FIELD(OSVERSIONINFOA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
@@ -403,7 +577,10 @@
     TEST_FIELD(OSVERSIONINFOA, DWORD, dwBuildNumber, 12, 4, 4);
     TEST_FIELD(OSVERSIONINFOA, DWORD, dwPlatformId, 16, 4, 4);
     TEST_FIELD(OSVERSIONINFOA, CHAR[128], szCSDVersion, 20, 128, 1);
+}
 
+static void test_pack_OSVERSIONINFOEXA(void)
+{
     /* OSVERSIONINFOEXA (pack 4) */
     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
     TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMajorVersion, 4, 4, 4);
@@ -413,7 +590,10 @@
     TEST_FIELD(OSVERSIONINFOEXA, CHAR[128], szCSDVersion, 20, 128, 1);
     TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMajor, 148, 2, 2);
     TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMinor, 150, 2, 2);
+}
 
+static void test_pack_OSVERSIONINFOEXW(void)
+{
     /* OSVERSIONINFOEXW (pack 4) */
     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
     TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
@@ -423,7 +603,10 @@
     TEST_FIELD(OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
     TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
     TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
+}
 
+static void test_pack_OSVERSIONINFOW(void)
+{
     /* OSVERSIONINFOW (pack 4) */
     TEST_TYPE(OSVERSIONINFOW, 276, 4);
     TEST_FIELD(OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
@@ -432,13 +615,15 @@
     TEST_FIELD(OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
     TEST_FIELD(OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
     TEST_FIELD(OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
+}
 
+static void test_pack_OUTPUT_DEBUG_STRING_INFO(void)
+{
     /* OUTPUT_DEBUG_STRING_INFO (pack 4) */
-    TEST_TYPE(OUTPUT_DEBUG_STRING_INFO, 8, 4);
-    TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, LPSTR, lpDebugStringData, 0, 4, 4);
-    TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, WORD, fUnicode, 4, 2, 2);
-    TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, WORD, nDebugStringLength, 6, 2, 2);
+}
 
+static void test_pack_OVERLAPPED(void)
+{
     /* OVERLAPPED (pack 4) */
     TEST_TYPE(OVERLAPPED, 20, 4);
     TEST_FIELD(OVERLAPPED, DWORD, Internal, 0, 4, 4);
@@ -446,114 +631,171 @@
     TEST_FIELD(OVERLAPPED, DWORD, Offset, 8, 4, 4);
     TEST_FIELD(OVERLAPPED, DWORD, OffsetHigh, 12, 4, 4);
     TEST_FIELD(OVERLAPPED, HANDLE, hEvent, 16, 4, 4);
+}
 
+static void test_pack_PAPCFUNC(void)
+{
     /* PAPCFUNC */
+    TEST_TYPE(PAPCFUNC, 4, 4);
+}
 
+static void test_pack_PBY_HANDLE_FILE_INFORMATION(void)
+{
     /* PBY_HANDLE_FILE_INFORMATION */
     TEST_TYPE(PBY_HANDLE_FILE_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(PBY_HANDLE_FILE_INFORMATION, 52, 4);
+}
 
+static void test_pack_PCRITICAL_SECTION(void)
+{
     /* PCRITICAL_SECTION */
     TEST_TYPE(PCRITICAL_SECTION, 4, 4);
+}
 
+static void test_pack_PCRITICAL_SECTION_DEBUG(void)
+{
     /* PCRITICAL_SECTION_DEBUG */
     TEST_TYPE(PCRITICAL_SECTION_DEBUG, 4, 4);
+}
 
+static void test_pack_PFIBER_START_ROUTINE(void)
+{
     /* PFIBER_START_ROUTINE */
+    TEST_TYPE(PFIBER_START_ROUTINE, 4, 4);
+}
 
+static void test_pack_POFSTRUCT(void)
+{
     /* POFSTRUCT */
     TEST_TYPE(POFSTRUCT, 4, 4);
     TEST_TYPE_POINTER(POFSTRUCT, 136, 2);
+}
 
+static void test_pack_POSVERSIONINFOA(void)
+{
     /* POSVERSIONINFOA */
     TEST_TYPE(POSVERSIONINFOA, 4, 4);
     TEST_TYPE_POINTER(POSVERSIONINFOA, 148, 4);
+}
 
+static void test_pack_POSVERSIONINFOEXA(void)
+{
     /* POSVERSIONINFOEXA */
     TEST_TYPE(POSVERSIONINFOEXA, 4, 4);
+}
 
+static void test_pack_POSVERSIONINFOEXW(void)
+{
     /* POSVERSIONINFOEXW */
     TEST_TYPE(POSVERSIONINFOEXW, 4, 4);
+}
 
+static void test_pack_POSVERSIONINFOW(void)
+{
     /* POSVERSIONINFOW */
     TEST_TYPE(POSVERSIONINFOW, 4, 4);
     TEST_TYPE_POINTER(POSVERSIONINFOW, 276, 4);
+}
 
+static void test_pack_PPROCESS_HEAP_ENTRY(void)
+{
     /* PPROCESS_HEAP_ENTRY */
     TEST_TYPE(PPROCESS_HEAP_ENTRY, 4, 4);
+}
 
+static void test_pack_PPROCESS_INFORMATION(void)
+{
     /* PPROCESS_INFORMATION */
     TEST_TYPE(PPROCESS_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(PPROCESS_INFORMATION, 16, 4);
+}
 
+static void test_pack_PROCESS_HEAP_ENTRY(void)
+{
     /* PROCESS_HEAP_ENTRY (pack 4) */
     TEST_FIELD(PROCESS_HEAP_ENTRY, LPVOID, lpData, 0, 4, 4);
     TEST_FIELD(PROCESS_HEAP_ENTRY, DWORD, cbData, 4, 4, 4);
     TEST_FIELD(PROCESS_HEAP_ENTRY, BYTE, cbOverhead, 8, 1, 1);
     TEST_FIELD(PROCESS_HEAP_ENTRY, BYTE, iRegionIndex, 9, 1, 1);
     TEST_FIELD(PROCESS_HEAP_ENTRY, WORD, wFlags, 10, 2, 2);
+}
 
+static void test_pack_PROCESS_INFORMATION(void)
+{
     /* PROCESS_INFORMATION (pack 4) */
     TEST_TYPE(PROCESS_INFORMATION, 16, 4);
     TEST_FIELD(PROCESS_INFORMATION, HANDLE, hProcess, 0, 4, 4);
     TEST_FIELD(PROCESS_INFORMATION, HANDLE, hThread, 4, 4, 4);
     TEST_FIELD(PROCESS_INFORMATION, DWORD, dwProcessId, 8, 4, 4);
     TEST_FIELD(PROCESS_INFORMATION, DWORD, dwThreadId, 12, 4, 4);
+}
 
+static void test_pack_PSECURITY_ATTRIBUTES(void)
+{
     /* PSECURITY_ATTRIBUTES */
     TEST_TYPE(PSECURITY_ATTRIBUTES, 4, 4);
     TEST_TYPE_POINTER(PSECURITY_ATTRIBUTES, 12, 4);
+}
 
+static void test_pack_PSYSTEMTIME(void)
+{
     /* PSYSTEMTIME */
     TEST_TYPE(PSYSTEMTIME, 4, 4);
     TEST_TYPE_POINTER(PSYSTEMTIME, 16, 2);
+}
 
+static void test_pack_PTIMERAPCROUTINE(void)
+{
     /* PTIMERAPCROUTINE */
+    TEST_TYPE(PTIMERAPCROUTINE, 4, 4);
+}
 
+static void test_pack_PTIME_ZONE_INFORMATION(void)
+{
     /* PTIME_ZONE_INFORMATION */
     TEST_TYPE(PTIME_ZONE_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(PTIME_ZONE_INFORMATION, 172, 4);
+}
 
+static void test_pack_PWIN32_FIND_DATAA(void)
+{
     /* PWIN32_FIND_DATAA */
     TEST_TYPE(PWIN32_FIND_DATAA, 4, 4);
     TEST_TYPE_POINTER(PWIN32_FIND_DATAA, 320, 4);
+}
 
+static void test_pack_PWIN32_FIND_DATAW(void)
+{
     /* PWIN32_FIND_DATAW */
     TEST_TYPE(PWIN32_FIND_DATAW, 4, 4);
     TEST_TYPE_POINTER(PWIN32_FIND_DATAW, 592, 4);
+}
 
+static void test_pack_RIP_INFO(void)
+{
     /* RIP_INFO (pack 4) */
     TEST_TYPE(RIP_INFO, 8, 4);
     TEST_FIELD(RIP_INFO, DWORD, dwError, 0, 4, 4);
     TEST_FIELD(RIP_INFO, DWORD, dwType, 4, 4, 4);
+}
 
+static void test_pack_SECURITY_ATTRIBUTES(void)
+{
     /* SECURITY_ATTRIBUTES (pack 4) */
     TEST_TYPE(SECURITY_ATTRIBUTES, 12, 4);
     TEST_FIELD(SECURITY_ATTRIBUTES, DWORD, nLength, 0, 4, 4);
     TEST_FIELD(SECURITY_ATTRIBUTES, LPVOID, lpSecurityDescriptor, 4, 4, 4);
     TEST_FIELD(SECURITY_ATTRIBUTES, BOOL, bInheritHandle, 8, 4, 4);
+}
 
+static void test_pack_STARTUPINFOA(void)
+{
     /* STARTUPINFOA (pack 4) */
-    TEST_TYPE(STARTUPINFOA, 68, 4);
     TEST_FIELD(STARTUPINFOA, DWORD, cb, 0, 4, 4);
-    TEST_FIELD(STARTUPINFOA, LPSTR, lpReserved, 4, 4, 4);
-    TEST_FIELD(STARTUPINFOA, LPSTR, lpDesktop, 8, 4, 4);
-    TEST_FIELD(STARTUPINFOA, LPSTR, lpTitle, 12, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwX, 16, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwY, 20, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwXSize, 24, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwYSize, 28, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwXCountChars, 32, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwYCountChars, 36, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwFillAttribute, 40, 4, 4);
-    TEST_FIELD(STARTUPINFOA, DWORD, dwFlags, 44, 4, 4);
-    TEST_FIELD(STARTUPINFOA, WORD, wShowWindow, 48, 2, 2);
-    TEST_FIELD(STARTUPINFOA, WORD, cbReserved2, 50, 2, 2);
-    TEST_FIELD(STARTUPINFOA, BYTE *, lpReserved2, 52, 4, 4);
-    TEST_FIELD(STARTUPINFOA, HANDLE, hStdInput, 56, 4, 4);
-    TEST_FIELD(STARTUPINFOA, HANDLE, hStdOutput, 60, 4, 4);
-    TEST_FIELD(STARTUPINFOA, HANDLE, hStdError, 64, 4, 4);
+}
 
+static void test_pack_STARTUPINFOW(void)
+{
     /* STARTUPINFOW (pack 4) */
     TEST_TYPE(STARTUPINFOW, 68, 4);
     TEST_FIELD(STARTUPINFOW, DWORD, cb, 0, 4, 4);
@@ -574,7 +816,10 @@
     TEST_FIELD(STARTUPINFOW, HANDLE, hStdInput, 56, 4, 4);
     TEST_FIELD(STARTUPINFOW, HANDLE, hStdOutput, 60, 4, 4);
     TEST_FIELD(STARTUPINFOW, HANDLE, hStdError, 64, 4, 4);
+}
 
+static void test_pack_SYSTEMTIME(void)
+{
     /* SYSTEMTIME (pack 4) */
     TEST_TYPE(SYSTEMTIME, 16, 2);
     TEST_FIELD(SYSTEMTIME, WORD, wYear, 0, 2, 2);
@@ -585,7 +830,10 @@
     TEST_FIELD(SYSTEMTIME, WORD, wMinute, 10, 2, 2);
     TEST_FIELD(SYSTEMTIME, WORD, wSecond, 12, 2, 2);
     TEST_FIELD(SYSTEMTIME, WORD, wMilliseconds, 14, 2, 2);
+}
 
+static void test_pack_SYSTEM_POWER_STATUS(void)
+{
     /* SYSTEM_POWER_STATUS (pack 4) */
     TEST_TYPE(SYSTEM_POWER_STATUS, 12, 4);
     TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, ACLineStatus, 0, 1, 1);
@@ -594,7 +842,10 @@
     TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, Reserved1, 3, 1, 1);
     TEST_FIELD(SYSTEM_POWER_STATUS, DWORD, BatteryLifeTime, 4, 4, 4);
     TEST_FIELD(SYSTEM_POWER_STATUS, DWORD, BatteryFullLifeTime, 8, 4, 4);
+}
 
+static void test_pack_TIME_ZONE_INFORMATION(void)
+{
     /* TIME_ZONE_INFORMATION (pack 4) */
     TEST_TYPE(TIME_ZONE_INFORMATION, 172, 4);
     TEST_FIELD(TIME_ZONE_INFORMATION, LONG, Bias, 0, 4, 4);
@@ -604,13 +855,17 @@
     TEST_FIELD(TIME_ZONE_INFORMATION, WCHAR[32], DaylightName, 88, 64, 2);
     TEST_FIELD(TIME_ZONE_INFORMATION, SYSTEMTIME, DaylightDate, 152, 16, 2);
     TEST_FIELD(TIME_ZONE_INFORMATION, LONG, DaylightBias, 168, 4, 4);
+}
 
+static void test_pack_UNLOAD_DLL_DEBUG_INFO(void)
+{
     /* UNLOAD_DLL_DEBUG_INFO (pack 4) */
     TEST_TYPE(UNLOAD_DLL_DEBUG_INFO, 4, 4);
     TEST_FIELD(UNLOAD_DLL_DEBUG_INFO, LPVOID, lpBaseOfDll, 0, 4, 4);
+}
 
-    /* WAITORTIMERCALLBACK */
-
+static void test_pack_WIN32_FILE_ATTRIBUTE_DATA(void)
+{
     /* WIN32_FILE_ATTRIBUTE_DATA (pack 4) */
     TEST_TYPE(WIN32_FILE_ATTRIBUTE_DATA, 36, 4);
     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, DWORD, dwFileAttributes, 0, 4, 4);
@@ -619,7 +874,10 @@
     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, FILETIME, ftLastWriteTime, 20, 8, 4);
     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, DWORD, nFileSizeHigh, 28, 4, 4);
     TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, DWORD, nFileSizeLow, 32, 4, 4);
+}
 
+static void test_pack_WIN32_FIND_DATAA(void)
+{
     /* WIN32_FIND_DATAA (pack 4) */
     TEST_TYPE(WIN32_FIND_DATAA, 320, 4);
     TEST_FIELD(WIN32_FIND_DATAA, DWORD, dwFileAttributes, 0, 4, 4);
@@ -632,7 +890,10 @@
     TEST_FIELD(WIN32_FIND_DATAA, DWORD, dwReserved1, 40, 4, 4);
     TEST_FIELD(WIN32_FIND_DATAA, CHAR[260], cFileName, 44, 260, 1);
     TEST_FIELD(WIN32_FIND_DATAA, CHAR[14], cAlternateFileName, 304, 14, 1);
+}
 
+static void test_pack_WIN32_FIND_DATAW(void)
+{
     /* WIN32_FIND_DATAW (pack 4) */
     TEST_TYPE(WIN32_FIND_DATAW, 592, 4);
     TEST_FIELD(WIN32_FIND_DATAW, DWORD, dwFileAttributes, 0, 4, 4);
@@ -645,7 +906,106 @@
     TEST_FIELD(WIN32_FIND_DATAW, DWORD, dwReserved1, 40, 4, 4);
     TEST_FIELD(WIN32_FIND_DATAW, WCHAR[260], cFileName, 44, 520, 2);
     TEST_FIELD(WIN32_FIND_DATAW, WCHAR[14], cAlternateFileName, 564, 28, 2);
+}
 
+static void test_pack(void)
+{
+    test_pack_BY_HANDLE_FILE_INFORMATION();
+    test_pack_COMMCONFIG();
+    test_pack_COMMPROP();
+    test_pack_COMMTIMEOUTS();
+    test_pack_COMSTAT();
+    test_pack_CREATE_PROCESS_DEBUG_INFO();
+    test_pack_CREATE_THREAD_DEBUG_INFO();
+    test_pack_CRITICAL_SECTION();
+    test_pack_CRITICAL_SECTION_DEBUG();
+    test_pack_DCB();
+    test_pack_DEBUG_EVENT();
+    test_pack_EXCEPTION_DEBUG_INFO();
+    test_pack_EXIT_PROCESS_DEBUG_INFO();
+    test_pack_EXIT_THREAD_DEBUG_INFO();
+    test_pack_HW_PROFILE_INFOA();
+    test_pack_HW_PROFILE_INFOW();
+    test_pack_LDT_ENTRY();
+    test_pack_LOAD_DLL_DEBUG_INFO();
+    test_pack_LPBY_HANDLE_FILE_INFORMATION();
+    test_pack_LPCOMMCONFIG();
+    test_pack_LPCOMMPROP();
+    test_pack_LPCOMMTIMEOUTS();
+    test_pack_LPCOMSTAT();
+    test_pack_LPCONTEXT();
+    test_pack_LPCRITICAL_SECTION();
+    test_pack_LPCRITICAL_SECTION_DEBUG();
+    test_pack_LPDCB();
+    test_pack_LPDEBUG_EVENT();
+    test_pack_LPEXCEPTION_POINTERS();
+    test_pack_LPEXCEPTION_RECORD();
+    test_pack_LPFIBER_START_ROUTINE();
+    test_pack_LPHW_PROFILE_INFOA();
+    test_pack_LPHW_PROFILE_INFOW();
+    test_pack_LPLDT_ENTRY();
+    test_pack_LPMEMORYSTATUS();
+    test_pack_LPOFSTRUCT();
+    test_pack_LPOSVERSIONINFOA();
+    test_pack_LPOSVERSIONINFOEXA();
+    test_pack_LPOSVERSIONINFOEXW();
+    test_pack_LPOSVERSIONINFOW();
+    test_pack_LPOVERLAPPED();
+    test_pack_LPOVERLAPPED_COMPLETION_ROUTINE();
+    test_pack_LPPROCESS_HEAP_ENTRY();
+    test_pack_LPPROCESS_INFORMATION();
+    test_pack_LPPROGRESS_ROUTINE();
+    test_pack_LPSECURITY_ATTRIBUTES();
+    test_pack_LPSTARTUPINFOA();
+    test_pack_LPSTARTUPINFOW();
+    test_pack_LPSYSTEMTIME();
+    test_pack_LPSYSTEM_INFO();
+    test_pack_LPSYSTEM_POWER_STATUS();
+    test_pack_LPTHREAD_START_ROUTINE();
+    test_pack_LPTIME_ZONE_INFORMATION();
+    test_pack_LPWIN32_FILE_ATTRIBUTE_DATA();
+    test_pack_LPWIN32_FIND_DATAA();
+    test_pack_LPWIN32_FIND_DATAW();
+    test_pack_LPWIN32_STREAM_ID();
+    test_pack_MEMORYSTATUS();
+    test_pack_OFSTRUCT();
+    test_pack_OSVERSIONINFOA();
+    test_pack_OSVERSIONINFOEXA();
+    test_pack_OSVERSIONINFOEXW();
+    test_pack_OSVERSIONINFOW();
+    test_pack_OUTPUT_DEBUG_STRING_INFO();
+    test_pack_OVERLAPPED();
+    test_pack_PAPCFUNC();
+    test_pack_PBY_HANDLE_FILE_INFORMATION();
+    test_pack_PCRITICAL_SECTION();
+    test_pack_PCRITICAL_SECTION_DEBUG();
+    test_pack_PFIBER_START_ROUTINE();
+    test_pack_POFSTRUCT();
+    test_pack_POSVERSIONINFOA();
+    test_pack_POSVERSIONINFOEXA();
+    test_pack_POSVERSIONINFOEXW();
+    test_pack_POSVERSIONINFOW();
+    test_pack_PPROCESS_HEAP_ENTRY();
+    test_pack_PPROCESS_INFORMATION();
+    test_pack_PROCESS_HEAP_ENTRY();
+    test_pack_PROCESS_INFORMATION();
+    test_pack_PSECURITY_ATTRIBUTES();
+    test_pack_PSYSTEMTIME();
+    test_pack_PTIMERAPCROUTINE();
+    test_pack_PTIME_ZONE_INFORMATION();
+    test_pack_PWIN32_FIND_DATAA();
+    test_pack_PWIN32_FIND_DATAW();
+    test_pack_RIP_INFO();
+    test_pack_SECURITY_ATTRIBUTES();
+    test_pack_STARTUPINFOA();
+    test_pack_STARTUPINFOW();
+    test_pack_SYSTEMTIME();
+    test_pack_SYSTEM_POWER_STATUS();
+    test_pack_TIME_ZONE_INFORMATION();
+    test_pack_UNLOAD_DLL_DEBUG_INFO();
+    test_pack_WIN32_FILE_ATTRIBUTE_DATA();
+    test_pack_WIN32_FIND_DATAA();
+    test_pack_WIN32_FIND_DATAW();
 }
 
 START_TEST(generated)
diff --git a/dlls/ntdll/tests/generated.c b/dlls/ntdll/tests/generated.c
index 1ef3ab2..94d6781 100644
--- a/dlls/ntdll/tests/generated.c
+++ b/dlls/ntdll/tests/generated.c
@@ -108,54 +108,136 @@
 #define TEST_TYPE_UNSIGNED(type) \
      ok((type) -1 > 0, "(" #type ") -1 > 0");
 
-void test_pack(void)
+static void test_pack_DWORD32(void)
+{
+    /* DWORD32 */
+    TEST_TYPE(DWORD32, 4, 4);
+    TEST_TYPE_UNSIGNED(DWORD32);
+}
+
+static void test_pack_DWORD_PTR(void)
 {
     /* DWORD_PTR */
     TEST_TYPE(DWORD_PTR, 4, 4);
+}
 
+static void test_pack_HALF_PTR(void)
+{
+    /* HALF_PTR */
+    TEST_TYPE(HALF_PTR, 2, 2);
+    TEST_TYPE_SIGNED(HALF_PTR);
+}
+
+static void test_pack_INT32(void)
+{
+    /* INT32 */
+    TEST_TYPE(INT32, 4, 4);
+    TEST_TYPE_SIGNED(INT32);
+}
+
+static void test_pack_INT_PTR(void)
+{
     /* INT_PTR */
     TEST_TYPE(INT_PTR, 4, 4);
     TEST_TYPE_SIGNED(INT_PTR);
+}
 
+static void test_pack_LONG32(void)
+{
+    /* LONG32 */
+    TEST_TYPE(LONG32, 4, 4);
+    TEST_TYPE_SIGNED(LONG32);
+}
+
+static void test_pack_LONG_PTR(void)
+{
     /* LONG_PTR */
     TEST_TYPE(LONG_PTR, 4, 4);
     TEST_TYPE_SIGNED(LONG_PTR);
+}
 
+static void test_pack_SIZE_T(void)
+{
     /* SIZE_T */
     TEST_TYPE(SIZE_T, 4, 4);
+}
 
+static void test_pack_SSIZE_T(void)
+{
     /* SSIZE_T */
     TEST_TYPE(SSIZE_T, 4, 4);
+}
 
+static void test_pack_UHALF_PTR(void)
+{
+    /* UHALF_PTR */
+    TEST_TYPE(UHALF_PTR, 2, 2);
+    TEST_TYPE_UNSIGNED(UHALF_PTR);
+}
+
+static void test_pack_UINT32(void)
+{
+    /* UINT32 */
+    TEST_TYPE(UINT32, 4, 4);
+    TEST_TYPE_UNSIGNED(UINT32);
+}
+
+static void test_pack_UINT_PTR(void)
+{
     /* UINT_PTR */
     TEST_TYPE(UINT_PTR, 4, 4);
     TEST_TYPE_UNSIGNED(UINT_PTR);
+}
 
+static void test_pack_ULONG32(void)
+{
+    /* ULONG32 */
+    TEST_TYPE(ULONG32, 4, 4);
+    TEST_TYPE_UNSIGNED(ULONG32);
+}
+
+static void test_pack_ULONG_PTR(void)
+{
     /* ULONG_PTR */
     TEST_TYPE(ULONG_PTR, 4, 4);
     TEST_TYPE_UNSIGNED(ULONG_PTR);
+}
 
+static void test_pack_ACCESS_ALLOWED_ACE(void)
+{
     /* ACCESS_ALLOWED_ACE (pack 4) */
     TEST_TYPE(ACCESS_ALLOWED_ACE, 12, 4);
     TEST_FIELD(ACCESS_ALLOWED_ACE, ACE_HEADER, Header, 0, 4, 2);
     TEST_FIELD(ACCESS_ALLOWED_ACE, DWORD, Mask, 4, 4, 4);
     TEST_FIELD(ACCESS_ALLOWED_ACE, DWORD, SidStart, 8, 4, 4);
+}
 
+static void test_pack_ACCESS_DENIED_ACE(void)
+{
     /* ACCESS_DENIED_ACE (pack 4) */
     TEST_TYPE(ACCESS_DENIED_ACE, 12, 4);
     TEST_FIELD(ACCESS_DENIED_ACE, ACE_HEADER, Header, 0, 4, 2);
     TEST_FIELD(ACCESS_DENIED_ACE, DWORD, Mask, 4, 4, 4);
     TEST_FIELD(ACCESS_DENIED_ACE, DWORD, SidStart, 8, 4, 4);
+}
 
+static void test_pack_ACCESS_MASK(void)
+{
     /* ACCESS_MASK */
     TEST_TYPE(ACCESS_MASK, 4, 4);
+}
 
+static void test_pack_ACE_HEADER(void)
+{
     /* ACE_HEADER (pack 4) */
     TEST_TYPE(ACE_HEADER, 4, 2);
     TEST_FIELD(ACE_HEADER, BYTE, AceType, 0, 1, 1);
     TEST_FIELD(ACE_HEADER, BYTE, AceFlags, 1, 1, 1);
     TEST_FIELD(ACE_HEADER, WORD, AceSize, 2, 2, 2);
+}
 
+static void test_pack_ACL(void)
+{
     /* ACL (pack 4) */
     TEST_TYPE(ACL, 8, 2);
     TEST_FIELD(ACL, BYTE, AclRevision, 0, 1, 1);
@@ -163,35 +245,59 @@
     TEST_FIELD(ACL, WORD, AclSize, 2, 2, 2);
     TEST_FIELD(ACL, WORD, AceCount, 4, 2, 2);
     TEST_FIELD(ACL, WORD, Sbz2, 6, 2, 2);
+}
 
+static void test_pack_BOOL(void)
+{
     /* BOOL */
     TEST_TYPE(BOOL, 4, 4);
     TEST_TYPE_SIGNED(BOOL);
+}
 
+static void test_pack_BOOLEAN(void)
+{
     /* BOOLEAN */
     TEST_TYPE(BOOLEAN, 1, 1);
+}
 
+static void test_pack_BYTE(void)
+{
     /* BYTE */
     TEST_TYPE(BYTE, 1, 1);
     TEST_TYPE_UNSIGNED(BYTE);
+}
 
+static void test_pack_CCHAR(void)
+{
     /* CCHAR */
     TEST_TYPE(CCHAR, 1, 1);
     TEST_TYPE_SIGNED(CCHAR);
+}
 
+static void test_pack_CHAR(void)
+{
     /* CHAR */
     TEST_TYPE(CHAR, 1, 1);
     TEST_TYPE_SIGNED(CHAR);
+}
 
+static void test_pack_DWORD(void)
+{
     /* DWORD */
     TEST_TYPE(DWORD, 4, 4);
     TEST_TYPE_UNSIGNED(DWORD);
+}
 
+static void test_pack_EXCEPTION_POINTERS(void)
+{
     /* EXCEPTION_POINTERS (pack 4) */
     TEST_TYPE(EXCEPTION_POINTERS, 8, 4);
     TEST_FIELD(EXCEPTION_POINTERS, PEXCEPTION_RECORD, ExceptionRecord, 0, 4, 4);
     TEST_FIELD(EXCEPTION_POINTERS, PCONTEXT, ContextRecord, 4, 4, 4);
+}
 
+static void test_pack_EXCEPTION_RECORD(void)
+{
     /* EXCEPTION_RECORD (pack 4) */
     TEST_TYPE(EXCEPTION_RECORD, 80, 4);
     TEST_FIELD(EXCEPTION_RECORD, DWORD, ExceptionCode, 0, 4, 4);
@@ -200,13 +306,22 @@
     TEST_FIELD(EXCEPTION_RECORD, LPVOID, ExceptionAddress, 12, 4, 4);
     TEST_FIELD(EXCEPTION_RECORD, DWORD, NumberParameters, 16, 4, 4);
     TEST_FIELD(EXCEPTION_RECORD, DWORD[EXCEPTION_MAXIMUM_PARAMETERS], ExceptionInformation, 20, 60, 4);
+}
 
+static void test_pack_EXECUTION_STATE(void)
+{
     /* EXECUTION_STATE */
     TEST_TYPE(EXECUTION_STATE, 4, 4);
+}
 
+static void test_pack_FLOAT(void)
+{
     /* FLOAT */
     TEST_TYPE(FLOAT, 4, 4);
+}
 
+static void test_pack_FLOATING_SAVE_AREA(void)
+{
     /* FLOATING_SAVE_AREA (pack 4) */
     TEST_TYPE(FLOATING_SAVE_AREA, 112, 4);
     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ControlWord, 0, 4, 4);
@@ -218,26 +333,41 @@
     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, DataSelector, 24, 4, 4);
     TEST_FIELD(FLOATING_SAVE_AREA, BYTE[SIZE_OF_80387_REGISTERS], RegisterArea, 28, 80, 1);
     TEST_FIELD(FLOATING_SAVE_AREA, DWORD, Cr0NpxState, 108, 4, 4);
+}
 
+static void test_pack_FPO_DATA(void)
+{
     /* FPO_DATA (pack 4) */
     TEST_FIELD(FPO_DATA, DWORD, ulOffStart, 0, 4, 4);
     TEST_FIELD(FPO_DATA, DWORD, cbProcSize, 4, 4, 4);
     TEST_FIELD(FPO_DATA, DWORD, cdwLocals, 8, 4, 4);
     TEST_FIELD(FPO_DATA, WORD, cdwParams, 12, 2, 2);
+}
 
+static void test_pack_GENERIC_MAPPING(void)
+{
     /* GENERIC_MAPPING (pack 4) */
     TEST_TYPE(GENERIC_MAPPING, 16, 4);
     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericRead, 0, 4, 4);
     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericWrite, 4, 4, 4);
     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericExecute, 8, 4, 4);
     TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericAll, 12, 4, 4);
+}
 
+static void test_pack_HANDLE(void)
+{
     /* HANDLE */
     TEST_TYPE(HANDLE, 4, 4);
+}
 
+static void test_pack_HRESULT(void)
+{
     /* HRESULT */
     TEST_TYPE(HRESULT, 4, 4);
+}
 
+static void test_pack_IMAGE_ARCHIVE_MEMBER_HEADER(void)
+{
     /* IMAGE_ARCHIVE_MEMBER_HEADER (pack 4) */
     TEST_TYPE(IMAGE_ARCHIVE_MEMBER_HEADER, 60, 1);
     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[16], Name, 0, 16, 1);
@@ -247,26 +377,41 @@
     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[8], Mode, 40, 8, 1);
     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[10], Size, 48, 10, 1);
     TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[2], EndHeader, 58, 2, 1);
+}
 
+static void test_pack_IMAGE_AUX_SYMBOL(void)
+{
     /* IMAGE_AUX_SYMBOL (pack 2) */
+}
 
+static void test_pack_IMAGE_BASE_RELOCATION(void)
+{
     /* IMAGE_BASE_RELOCATION (pack 4) */
     TEST_TYPE(IMAGE_BASE_RELOCATION, 8, 4);
     TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, VirtualAddress, 0, 4, 4);
     TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, SizeOfBlock, 4, 4, 4);
+}
 
+static void test_pack_IMAGE_BOUND_FORWARDER_REF(void)
+{
     /* IMAGE_BOUND_FORWARDER_REF (pack 4) */
     TEST_TYPE(IMAGE_BOUND_FORWARDER_REF, 8, 4);
     TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, DWORD, TimeDateStamp, 0, 4, 4);
     TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, WORD, OffsetModuleName, 4, 2, 2);
     TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, WORD, Reserved, 6, 2, 2);
+}
 
+static void test_pack_IMAGE_BOUND_IMPORT_DESCRIPTOR(void)
+{
     /* IMAGE_BOUND_IMPORT_DESCRIPTOR (pack 4) */
     TEST_TYPE(IMAGE_BOUND_IMPORT_DESCRIPTOR, 8, 4);
     TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, DWORD, TimeDateStamp, 0, 4, 4);
     TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, WORD, OffsetModuleName, 4, 2, 2);
     TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, WORD, NumberOfModuleForwarderRefs, 6, 2, 2);
+}
 
+static void test_pack_IMAGE_COFF_SYMBOLS_HEADER(void)
+{
     /* IMAGE_COFF_SYMBOLS_HEADER (pack 4) */
     TEST_TYPE(IMAGE_COFF_SYMBOLS_HEADER, 32, 4);
     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, NumberOfSymbols, 0, 4, 4);
@@ -277,12 +422,18 @@
     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToLastByteOfCode, 20, 4, 4);
     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToFirstByteOfData, 24, 4, 4);
     TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToLastByteOfData, 28, 4, 4);
+}
 
+static void test_pack_IMAGE_DATA_DIRECTORY(void)
+{
     /* IMAGE_DATA_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_DATA_DIRECTORY, 8, 4);
     TEST_FIELD(IMAGE_DATA_DIRECTORY, DWORD, VirtualAddress, 0, 4, 4);
     TEST_FIELD(IMAGE_DATA_DIRECTORY, DWORD, Size, 4, 4, 4);
+}
 
+static void test_pack_IMAGE_DEBUG_DIRECTORY(void)
+{
     /* IMAGE_DEBUG_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_DEBUG_DIRECTORY, 28, 4);
     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
@@ -293,7 +444,10 @@
     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, SizeOfData, 16, 4, 4);
     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, AddressOfRawData, 20, 4, 4);
     TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, PointerToRawData, 24, 4, 4);
+}
 
+static void test_pack_IMAGE_DEBUG_MISC(void)
+{
     /* IMAGE_DEBUG_MISC (pack 4) */
     TEST_TYPE(IMAGE_DEBUG_MISC, 16, 4);
     TEST_FIELD(IMAGE_DEBUG_MISC, DWORD, DataType, 0, 4, 4);
@@ -301,7 +455,10 @@
     TEST_FIELD(IMAGE_DEBUG_MISC, BYTE, Unicode, 8, 1, 1);
     TEST_FIELD(IMAGE_DEBUG_MISC, BYTE[ 3 ], Reserved, 9, 3, 1);
     TEST_FIELD(IMAGE_DEBUG_MISC, BYTE[ 1 ], Data, 12, 1, 1);
+}
 
+static void test_pack_IMAGE_DOS_HEADER(void)
+{
     /* IMAGE_DOS_HEADER (pack 2) */
     TEST_TYPE(IMAGE_DOS_HEADER, 64, 2);
     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_magic, 0, 2, 2);
@@ -323,7 +480,10 @@
     TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_oeminfo, 38, 2, 2);
     TEST_FIELD(IMAGE_DOS_HEADER, WORD[10], e_res2, 40, 20, 2);
     TEST_FIELD(IMAGE_DOS_HEADER, DWORD, e_lfanew, 60, 4, 2);
+}
 
+static void test_pack_IMAGE_EXPORT_DIRECTORY(void)
+{
     /* IMAGE_EXPORT_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_EXPORT_DIRECTORY, 40, 4);
     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
@@ -337,7 +497,10 @@
     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfFunctions, 28, 4, 4);
     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfNames, 32, 4, 4);
     TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfNameOrdinals, 36, 4, 4);
+}
 
+static void test_pack_IMAGE_FILE_HEADER(void)
+{
     /* IMAGE_FILE_HEADER (pack 4) */
     TEST_TYPE(IMAGE_FILE_HEADER, 20, 4);
     TEST_FIELD(IMAGE_FILE_HEADER, WORD, Machine, 0, 2, 2);
@@ -347,18 +510,27 @@
     TEST_FIELD(IMAGE_FILE_HEADER, DWORD, NumberOfSymbols, 12, 4, 4);
     TEST_FIELD(IMAGE_FILE_HEADER, WORD, SizeOfOptionalHeader, 16, 2, 2);
     TEST_FIELD(IMAGE_FILE_HEADER, WORD, Characteristics, 18, 2, 2);
+}
 
+static void test_pack_IMAGE_FUNCTION_ENTRY(void)
+{
     /* IMAGE_FUNCTION_ENTRY (pack 4) */
     TEST_TYPE(IMAGE_FUNCTION_ENTRY, 12, 4);
     TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, StartingAddress, 0, 4, 4);
     TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, EndingAddress, 4, 4, 4);
     TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, EndOfPrologue, 8, 4, 4);
+}
 
+static void test_pack_IMAGE_IMPORT_BY_NAME(void)
+{
     /* IMAGE_IMPORT_BY_NAME (pack 4) */
     TEST_TYPE(IMAGE_IMPORT_BY_NAME, 4, 2);
     TEST_FIELD(IMAGE_IMPORT_BY_NAME, WORD, Hint, 0, 2, 2);
     TEST_FIELD(IMAGE_IMPORT_BY_NAME, BYTE[1], Name, 2, 1, 1);
+}
 
+static void test_pack_IMAGE_LOAD_CONFIG_DIRECTORY(void)
+{
     /* IMAGE_LOAD_CONFIG_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_LOAD_CONFIG_DIRECTORY, 64, 4);
     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
@@ -379,13 +551,19 @@
     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, Reserved1, 54, 2, 2);
     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, PVOID, EditList, 56, 4, 4);
     TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD[1], Reserved, 60, 4, 4);
+}
 
+static void test_pack_IMAGE_NT_HEADERS(void)
+{
     /* IMAGE_NT_HEADERS (pack 4) */
     TEST_TYPE(IMAGE_NT_HEADERS, 248, 4);
     TEST_FIELD(IMAGE_NT_HEADERS, DWORD, Signature, 0, 4, 4);
     TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_FILE_HEADER, FileHeader, 4, 20, 4);
     TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_OPTIONAL_HEADER, OptionalHeader, 24, 224, 4);
+}
 
+static void test_pack_IMAGE_OPTIONAL_HEADER(void)
+{
     /* IMAGE_OPTIONAL_HEADER (pack 4) */
     TEST_TYPE(IMAGE_OPTIONAL_HEADER, 224, 4);
     TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Magic, 0, 2, 2);
@@ -419,7 +597,10 @@
     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, LoaderFlags, 88, 4, 4);
     TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, NumberOfRvaAndSizes, 92, 4, 4);
     TEST_FIELD(IMAGE_OPTIONAL_HEADER, IMAGE_DATA_DIRECTORY[IMAGE_NUMBEROF_DIRECTORY_ENTRIES], DataDirectory, 96, 128, 4);
+}
 
+static void test_pack_IMAGE_OS2_HEADER(void)
+{
     /* IMAGE_OS2_HEADER (pack 2) */
     TEST_TYPE(IMAGE_OS2_HEADER, 64, 2);
     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_magic, 0, 2, 2);
@@ -452,12 +633,18 @@
     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_psegrefbytes, 58, 2, 2);
     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_swaparea, 60, 2, 2);
     TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_expver, 62, 2, 2);
+}
 
+static void test_pack_IMAGE_RESOURCE_DATA_ENTRY(void)
+{
     /* IMAGE_RESOURCE_DATA_ENTRY (pack 4) */
     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, OffsetToData, 0, 4, 4);
     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, Size, 4, 4, 4);
     TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, CodePage, 8, 4, 4);
+}
 
+static void test_pack_IMAGE_RESOURCE_DIRECTORY(void)
+{
     /* IMAGE_RESOURCE_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_RESOURCE_DIRECTORY, 16, 4);
     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
@@ -466,19 +653,31 @@
     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, NumberOfNamedEntries, 12, 2, 2);
     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, NumberOfIdEntries, 14, 2, 2);
+}
 
+static void test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY(void)
+{
     /* IMAGE_RESOURCE_DIRECTORY_ENTRY (pack 4) */
+}
 
+static void test_pack_IMAGE_RESOURCE_DIRECTORY_STRING(void)
+{
     /* IMAGE_RESOURCE_DIRECTORY_STRING (pack 4) */
     TEST_TYPE(IMAGE_RESOURCE_DIRECTORY_STRING, 4, 2);
     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, WORD, Length, 0, 2, 2);
     TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, CHAR[ 1 ], NameString, 2, 1, 1);
+}
 
+static void test_pack_IMAGE_RESOURCE_DIR_STRING_U(void)
+{
     /* IMAGE_RESOURCE_DIR_STRING_U (pack 4) */
     TEST_TYPE(IMAGE_RESOURCE_DIR_STRING_U, 4, 2);
     TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, WORD, Length, 0, 2, 2);
     TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, WCHAR[ 1 ], NameString, 2, 2, 2);
+}
 
+static void test_pack_IMAGE_SEPARATE_DEBUG_HEADER(void)
+{
     /* IMAGE_SEPARATE_DEBUG_HEADER (pack 4) */
     TEST_TYPE(IMAGE_SEPARATE_DEBUG_HEADER, 48, 4);
     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Signature, 0, 2, 2);
@@ -494,9 +693,15 @@
     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, DebugDirectorySize, 32, 4, 4);
     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, SectionAlignment, 36, 4, 4);
     TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD[ 2 ], Reserved, 40, 8, 4);
+}
 
+static void test_pack_IMAGE_THUNK_DATA(void)
+{
     /* IMAGE_THUNK_DATA (pack 4) */
+}
 
+static void test_pack_IMAGE_TLS_DIRECTORY(void)
+{
     /* IMAGE_TLS_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_TLS_DIRECTORY, 24, 4);
     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, StartAddressOfRawData, 0, 4, 4);
@@ -505,7 +710,10 @@
     TEST_FIELD(IMAGE_TLS_DIRECTORY, PIMAGE_TLS_CALLBACK *, AddressOfCallBacks, 12, 4, 4);
     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, SizeOfZeroFill, 16, 4, 4);
     TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, Characteristics, 20, 4, 4);
+}
 
+static void test_pack_IMAGE_VXD_HEADER(void)
+{
     /* IMAGE_VXD_HEADER (pack 2) */
     TEST_TYPE(IMAGE_VXD_HEADER, 196, 2);
     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_magic, 0, 2, 2);
@@ -559,41 +767,72 @@
     TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winreslen, 188, 4, 2);
     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_devid, 192, 2, 2);
     TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_ddkver, 194, 2, 2);
+}
 
+static void test_pack_INT(void)
+{
     /* INT */
     TEST_TYPE(INT, 4, 4);
     TEST_TYPE_SIGNED(INT);
+}
 
+static void test_pack_LANGID(void)
+{
     /* LANGID */
     TEST_TYPE(LANGID, 2, 2);
+}
 
+static void test_pack_LCID(void)
+{
     /* LCID */
     TEST_TYPE(LCID, 4, 4);
+}
 
+static void test_pack_LIST_ENTRY(void)
+{
     /* LIST_ENTRY (pack 4) */
     TEST_TYPE(LIST_ENTRY, 8, 4);
     TEST_FIELD(LIST_ENTRY, struct _LIST_ENTRY *, Flink, 0, 4, 4);
     TEST_FIELD(LIST_ENTRY, struct _LIST_ENTRY *, Blink, 4, 4, 4);
+}
 
+static void test_pack_LONG(void)
+{
     /* LONG */
     TEST_TYPE(LONG, 4, 4);
     TEST_TYPE_SIGNED(LONG);
+}
 
+static void test_pack_LPCVOID(void)
+{
     /* LPCVOID */
     TEST_TYPE(LPCVOID, 4, 4);
+}
 
+static void test_pack_LPTOP_LEVEL_EXCEPTION_FILTER(void)
+{
     /* LPTOP_LEVEL_EXCEPTION_FILTER */
+    TEST_TYPE(LPTOP_LEVEL_EXCEPTION_FILTER, 4, 4);
+}
 
+static void test_pack_LUID(void)
+{
     /* LUID (pack 4) */
     TEST_TYPE(LUID, 8, 4);
     TEST_FIELD(LUID, DWORD, LowPart, 0, 4, 4);
     TEST_FIELD(LUID, LONG, HighPart, 4, 4, 4);
+}
 
+static void test_pack_LUID_AND_ATTRIBUTES(void)
+{
     /* LUID_AND_ATTRIBUTES (pack 4) */
     TEST_TYPE(LUID_AND_ATTRIBUTES, 12, 4);
     TEST_FIELD(LUID_AND_ATTRIBUTES, LUID, Luid, 0, 8, 4);
     TEST_FIELD(LUID_AND_ATTRIBUTES, DWORD, Attributes, 8, 4, 4);
+}
 
+static void test_pack_MEMORY_BASIC_INFORMATION(void)
+{
     /* MEMORY_BASIC_INFORMATION (pack 4) */
     TEST_TYPE(MEMORY_BASIC_INFORMATION, 28, 4);
     TEST_FIELD(MEMORY_BASIC_INFORMATION, LPVOID, BaseAddress, 0, 4, 4);
@@ -603,315 +842,557 @@
     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, State, 16, 4, 4);
     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, Protect, 20, 4, 4);
     TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, Type, 24, 4, 4);
+}
 
+static void test_pack_MESSAGE_RESOURCE_BLOCK(void)
+{
     /* MESSAGE_RESOURCE_BLOCK (pack 4) */
     TEST_TYPE(MESSAGE_RESOURCE_BLOCK, 12, 4);
     TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, LowId, 0, 4, 4);
     TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, HighId, 4, 4, 4);
     TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, OffsetToEntries, 8, 4, 4);
+}
 
+static void test_pack_MESSAGE_RESOURCE_DATA(void)
+{
     /* MESSAGE_RESOURCE_DATA (pack 4) */
     TEST_TYPE(MESSAGE_RESOURCE_DATA, 16, 4);
     TEST_FIELD(MESSAGE_RESOURCE_DATA, DWORD, NumberOfBlocks, 0, 4, 4);
     TEST_FIELD(MESSAGE_RESOURCE_DATA, MESSAGE_RESOURCE_BLOCK[ 1 ], Blocks, 4, 12, 4);
+}
 
+static void test_pack_MESSAGE_RESOURCE_ENTRY(void)
+{
     /* MESSAGE_RESOURCE_ENTRY (pack 4) */
     TEST_TYPE(MESSAGE_RESOURCE_ENTRY, 6, 2);
     TEST_FIELD(MESSAGE_RESOURCE_ENTRY, WORD, Length, 0, 2, 2);
     TEST_FIELD(MESSAGE_RESOURCE_ENTRY, WORD, Flags, 2, 2, 2);
     TEST_FIELD(MESSAGE_RESOURCE_ENTRY, BYTE[1], Text, 4, 1, 1);
+}
 
+static void test_pack_PACCESS_ALLOWED_ACE(void)
+{
     /* PACCESS_ALLOWED_ACE */
     TEST_TYPE(PACCESS_ALLOWED_ACE, 4, 4);
     TEST_TYPE_POINTER(PACCESS_ALLOWED_ACE, 12, 4);
+}
 
+static void test_pack_PACCESS_DENIED_ACE(void)
+{
     /* PACCESS_DENIED_ACE */
     TEST_TYPE(PACCESS_DENIED_ACE, 4, 4);
     TEST_TYPE_POINTER(PACCESS_DENIED_ACE, 12, 4);
+}
 
+static void test_pack_PACCESS_TOKEN(void)
+{
     /* PACCESS_TOKEN */
     TEST_TYPE(PACCESS_TOKEN, 4, 4);
+}
 
+static void test_pack_PACE_HEADER(void)
+{
     /* PACE_HEADER */
     TEST_TYPE(PACE_HEADER, 4, 4);
     TEST_TYPE_POINTER(PACE_HEADER, 4, 2);
+}
 
+static void test_pack_PACL(void)
+{
     /* PACL */
     TEST_TYPE(PACL, 4, 4);
     TEST_TYPE_POINTER(PACL, 8, 2);
+}
 
+static void test_pack_PCCH(void)
+{
     /* PCCH */
     TEST_TYPE(PCCH, 4, 4);
     TEST_TYPE_POINTER(PCCH, 1, 1);
+}
 
+static void test_pack_PCH(void)
+{
     /* PCH */
     TEST_TYPE(PCH, 4, 4);
     TEST_TYPE_POINTER(PCH, 1, 1);
+}
 
+static void test_pack_PCSTR(void)
+{
     /* PCSTR */
     TEST_TYPE(PCSTR, 4, 4);
     TEST_TYPE_POINTER(PCSTR, 1, 1);
+}
 
+static void test_pack_PCWCH(void)
+{
     /* PCWCH */
     TEST_TYPE(PCWCH, 4, 4);
     TEST_TYPE_POINTER(PCWCH, 2, 2);
+}
 
+static void test_pack_PCWSTR(void)
+{
     /* PCWSTR */
     TEST_TYPE(PCWSTR, 4, 4);
     TEST_TYPE_POINTER(PCWSTR, 2, 2);
+}
 
-    /* PEXCEPTION_HANDLER */
-
+static void test_pack_PEXCEPTION_POINTERS(void)
+{
     /* PEXCEPTION_POINTERS */
     TEST_TYPE(PEXCEPTION_POINTERS, 4, 4);
     TEST_TYPE_POINTER(PEXCEPTION_POINTERS, 8, 4);
+}
 
+static void test_pack_PEXCEPTION_RECORD(void)
+{
     /* PEXCEPTION_RECORD */
     TEST_TYPE(PEXCEPTION_RECORD, 4, 4);
     TEST_TYPE_POINTER(PEXCEPTION_RECORD, 80, 4);
+}
 
+static void test_pack_PFLOATING_SAVE_AREA(void)
+{
     /* PFLOATING_SAVE_AREA */
     TEST_TYPE(PFLOATING_SAVE_AREA, 4, 4);
     TEST_TYPE_POINTER(PFLOATING_SAVE_AREA, 112, 4);
+}
 
+static void test_pack_PFPO_DATA(void)
+{
     /* PFPO_DATA */
     TEST_TYPE(PFPO_DATA, 4, 4);
+}
 
+static void test_pack_PGENERIC_MAPPING(void)
+{
     /* PGENERIC_MAPPING */
     TEST_TYPE(PGENERIC_MAPPING, 4, 4);
     TEST_TYPE_POINTER(PGENERIC_MAPPING, 16, 4);
+}
 
+static void test_pack_PHANDLE(void)
+{
     /* PHANDLE */
     TEST_TYPE(PHANDLE, 4, 4);
     TEST_TYPE_POINTER(PHANDLE, 4, 4);
+}
 
+static void test_pack_PIMAGE_ARCHIVE_MEMBER_HEADER(void)
+{
     /* PIMAGE_ARCHIVE_MEMBER_HEADER */
     TEST_TYPE(PIMAGE_ARCHIVE_MEMBER_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_ARCHIVE_MEMBER_HEADER, 60, 1);
+}
 
+static void test_pack_PIMAGE_AUX_SYMBOL(void)
+{
     /* PIMAGE_AUX_SYMBOL */
     TEST_TYPE(PIMAGE_AUX_SYMBOL, 4, 4);
+}
 
+static void test_pack_PIMAGE_BASE_RELOCATION(void)
+{
     /* PIMAGE_BASE_RELOCATION */
     TEST_TYPE(PIMAGE_BASE_RELOCATION, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_BASE_RELOCATION, 8, 4);
+}
 
+static void test_pack_PIMAGE_BOUND_FORWARDER_REF(void)
+{
     /* PIMAGE_BOUND_FORWARDER_REF */
     TEST_TYPE(PIMAGE_BOUND_FORWARDER_REF, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_BOUND_FORWARDER_REF, 8, 4);
+}
 
+static void test_pack_PIMAGE_BOUND_IMPORT_DESCRIPTOR(void)
+{
     /* PIMAGE_BOUND_IMPORT_DESCRIPTOR */
     TEST_TYPE(PIMAGE_BOUND_IMPORT_DESCRIPTOR, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_BOUND_IMPORT_DESCRIPTOR, 8, 4);
+}
 
+static void test_pack_PIMAGE_COFF_SYMBOLS_HEADER(void)
+{
     /* PIMAGE_COFF_SYMBOLS_HEADER */
     TEST_TYPE(PIMAGE_COFF_SYMBOLS_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_COFF_SYMBOLS_HEADER, 32, 4);
+}
 
+static void test_pack_PIMAGE_DATA_DIRECTORY(void)
+{
     /* PIMAGE_DATA_DIRECTORY */
     TEST_TYPE(PIMAGE_DATA_DIRECTORY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_DATA_DIRECTORY, 8, 4);
+}
 
+static void test_pack_PIMAGE_DEBUG_DIRECTORY(void)
+{
     /* PIMAGE_DEBUG_DIRECTORY */
     TEST_TYPE(PIMAGE_DEBUG_DIRECTORY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_DEBUG_DIRECTORY, 28, 4);
+}
 
+static void test_pack_PIMAGE_DEBUG_MISC(void)
+{
     /* PIMAGE_DEBUG_MISC */
     TEST_TYPE(PIMAGE_DEBUG_MISC, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_DEBUG_MISC, 16, 4);
+}
 
+static void test_pack_PIMAGE_DOS_HEADER(void)
+{
     /* PIMAGE_DOS_HEADER */
     TEST_TYPE(PIMAGE_DOS_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_DOS_HEADER, 64, 2);
+}
 
+static void test_pack_PIMAGE_EXPORT_DIRECTORY(void)
+{
     /* PIMAGE_EXPORT_DIRECTORY */
     TEST_TYPE(PIMAGE_EXPORT_DIRECTORY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_EXPORT_DIRECTORY, 40, 4);
+}
 
+static void test_pack_PIMAGE_FILE_HEADER(void)
+{
     /* PIMAGE_FILE_HEADER */
     TEST_TYPE(PIMAGE_FILE_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_FILE_HEADER, 20, 4);
+}
 
+static void test_pack_PIMAGE_FUNCTION_ENTRY(void)
+{
     /* PIMAGE_FUNCTION_ENTRY */
     TEST_TYPE(PIMAGE_FUNCTION_ENTRY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_FUNCTION_ENTRY, 12, 4);
+}
 
+static void test_pack_PIMAGE_IMPORT_BY_NAME(void)
+{
     /* PIMAGE_IMPORT_BY_NAME */
     TEST_TYPE(PIMAGE_IMPORT_BY_NAME, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_IMPORT_BY_NAME, 4, 2);
+}
 
+static void test_pack_PIMAGE_IMPORT_DESCRIPTOR(void)
+{
     /* PIMAGE_IMPORT_DESCRIPTOR */
     TEST_TYPE(PIMAGE_IMPORT_DESCRIPTOR, 4, 4);
+}
 
+static void test_pack_PIMAGE_LINENUMBER(void)
+{
     /* PIMAGE_LINENUMBER */
     TEST_TYPE(PIMAGE_LINENUMBER, 4, 4);
+}
 
+static void test_pack_PIMAGE_LOAD_CONFIG_DIRECTORY(void)
+{
     /* PIMAGE_LOAD_CONFIG_DIRECTORY */
     TEST_TYPE(PIMAGE_LOAD_CONFIG_DIRECTORY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_LOAD_CONFIG_DIRECTORY, 64, 4);
+}
 
+static void test_pack_PIMAGE_NT_HEADERS(void)
+{
     /* PIMAGE_NT_HEADERS */
     TEST_TYPE(PIMAGE_NT_HEADERS, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_NT_HEADERS, 248, 4);
+}
 
+static void test_pack_PIMAGE_OPTIONAL_HEADER(void)
+{
     /* PIMAGE_OPTIONAL_HEADER */
     TEST_TYPE(PIMAGE_OPTIONAL_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_OPTIONAL_HEADER, 224, 4);
+}
 
+static void test_pack_PIMAGE_OS2_HEADER(void)
+{
     /* PIMAGE_OS2_HEADER */
     TEST_TYPE(PIMAGE_OS2_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_OS2_HEADER, 64, 2);
+}
 
+static void test_pack_PIMAGE_RELOCATION(void)
+{
     /* PIMAGE_RELOCATION */
     TEST_TYPE(PIMAGE_RELOCATION, 4, 4);
+}
 
+static void test_pack_PIMAGE_RESOURCE_DATA_ENTRY(void)
+{
     /* PIMAGE_RESOURCE_DATA_ENTRY */
     TEST_TYPE(PIMAGE_RESOURCE_DATA_ENTRY, 4, 4);
+}
 
+static void test_pack_PIMAGE_RESOURCE_DIRECTORY(void)
+{
     /* PIMAGE_RESOURCE_DIRECTORY */
     TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIRECTORY, 16, 4);
+}
 
+static void test_pack_PIMAGE_RESOURCE_DIRECTORY_ENTRY(void)
+{
     /* PIMAGE_RESOURCE_DIRECTORY_ENTRY */
     TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY_ENTRY, 4, 4);
+}
 
+static void test_pack_PIMAGE_RESOURCE_DIRECTORY_STRING(void)
+{
     /* PIMAGE_RESOURCE_DIRECTORY_STRING */
     TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY_STRING, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIRECTORY_STRING, 4, 2);
+}
 
+static void test_pack_PIMAGE_RESOURCE_DIR_STRING_U(void)
+{
     /* PIMAGE_RESOURCE_DIR_STRING_U */
     TEST_TYPE(PIMAGE_RESOURCE_DIR_STRING_U, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIR_STRING_U, 4, 2);
+}
 
+static void test_pack_PIMAGE_SECTION_HEADER(void)
+{
     /* PIMAGE_SECTION_HEADER */
     TEST_TYPE(PIMAGE_SECTION_HEADER, 4, 4);
+}
 
+static void test_pack_PIMAGE_SEPARATE_DEBUG_HEADER(void)
+{
     /* PIMAGE_SEPARATE_DEBUG_HEADER */
     TEST_TYPE(PIMAGE_SEPARATE_DEBUG_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_SEPARATE_DEBUG_HEADER, 48, 4);
+}
 
+static void test_pack_PIMAGE_SYMBOL(void)
+{
     /* PIMAGE_SYMBOL */
     TEST_TYPE(PIMAGE_SYMBOL, 4, 4);
+}
 
+static void test_pack_PIMAGE_THUNK_DATA(void)
+{
     /* PIMAGE_THUNK_DATA */
     TEST_TYPE(PIMAGE_THUNK_DATA, 4, 4);
+}
 
+static void test_pack_PIMAGE_TLS_CALLBACK(void)
+{
     /* PIMAGE_TLS_CALLBACK */
+    TEST_TYPE(PIMAGE_TLS_CALLBACK, 4, 4);
+}
 
+static void test_pack_PIMAGE_TLS_DIRECTORY(void)
+{
     /* PIMAGE_TLS_DIRECTORY */
     TEST_TYPE(PIMAGE_TLS_DIRECTORY, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_TLS_DIRECTORY, 24, 4);
+}
 
+static void test_pack_PIMAGE_VXD_HEADER(void)
+{
     /* PIMAGE_VXD_HEADER */
     TEST_TYPE(PIMAGE_VXD_HEADER, 4, 4);
     TEST_TYPE_POINTER(PIMAGE_VXD_HEADER, 196, 2);
+}
 
+static void test_pack_PISECURITY_DESCRIPTOR_RELATIVE(void)
+{
     /* PISECURITY_DESCRIPTOR_RELATIVE */
     TEST_TYPE(PISECURITY_DESCRIPTOR_RELATIVE, 4, 4);
     TEST_TYPE_POINTER(PISECURITY_DESCRIPTOR_RELATIVE, 20, 4);
+}
 
+static void test_pack_PLARGE_INTEGER(void)
+{
     /* PLARGE_INTEGER */
     TEST_TYPE(PLARGE_INTEGER, 4, 4);
+}
 
+static void test_pack_PLIST_ENTRY(void)
+{
     /* PLIST_ENTRY */
     TEST_TYPE(PLIST_ENTRY, 4, 4);
     TEST_TYPE_POINTER(PLIST_ENTRY, 8, 4);
+}
 
+static void test_pack_PLUID(void)
+{
     /* PLUID */
     TEST_TYPE(PLUID, 4, 4);
     TEST_TYPE_POINTER(PLUID, 8, 4);
+}
 
+static void test_pack_PMEMORY_BASIC_INFORMATION(void)
+{
     /* PMEMORY_BASIC_INFORMATION */
     TEST_TYPE(PMEMORY_BASIC_INFORMATION, 4, 4);
     TEST_TYPE_POINTER(PMEMORY_BASIC_INFORMATION, 28, 4);
+}
 
+static void test_pack_PMESSAGE_RESOURCE_BLOCK(void)
+{
     /* PMESSAGE_RESOURCE_BLOCK */
     TEST_TYPE(PMESSAGE_RESOURCE_BLOCK, 4, 4);
     TEST_TYPE_POINTER(PMESSAGE_RESOURCE_BLOCK, 12, 4);
+}
 
+static void test_pack_PMESSAGE_RESOURCE_DATA(void)
+{
     /* PMESSAGE_RESOURCE_DATA */
     TEST_TYPE(PMESSAGE_RESOURCE_DATA, 4, 4);
     TEST_TYPE_POINTER(PMESSAGE_RESOURCE_DATA, 16, 4);
+}
 
+static void test_pack_PMESSAGE_RESOURCE_ENTRY(void)
+{
     /* PMESSAGE_RESOURCE_ENTRY */
     TEST_TYPE(PMESSAGE_RESOURCE_ENTRY, 4, 4);
     TEST_TYPE_POINTER(PMESSAGE_RESOURCE_ENTRY, 6, 2);
+}
 
+static void test_pack_PNT_TIB(void)
+{
     /* PNT_TIB */
     TEST_TYPE(PNT_TIB, 4, 4);
+}
 
+static void test_pack_PPRIVILEGE_SET(void)
+{
     /* PPRIVILEGE_SET */
     TEST_TYPE(PPRIVILEGE_SET, 4, 4);
     TEST_TYPE_POINTER(PPRIVILEGE_SET, 20, 4);
+}
 
+static void test_pack_PRIVILEGE_SET(void)
+{
     /* PRIVILEGE_SET (pack 4) */
     TEST_TYPE(PRIVILEGE_SET, 20, 4);
     TEST_FIELD(PRIVILEGE_SET, DWORD, PrivilegeCount, 0, 4, 4);
     TEST_FIELD(PRIVILEGE_SET, DWORD, Control, 4, 4, 4);
     TEST_FIELD(PRIVILEGE_SET, LUID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Privilege, 8, 12, 4);
+}
 
+static void test_pack_PRLIST_ENTRY(void)
+{
     /* PRLIST_ENTRY */
     TEST_TYPE(PRLIST_ENTRY, 4, 4);
     TEST_TYPE_POINTER(PRLIST_ENTRY, 8, 4);
+}
 
+static void test_pack_PRTL_CRITICAL_SECTION(void)
+{
     /* PRTL_CRITICAL_SECTION */
     TEST_TYPE(PRTL_CRITICAL_SECTION, 4, 4);
     TEST_TYPE_POINTER(PRTL_CRITICAL_SECTION, 24, 4);
+}
 
+static void test_pack_PRTL_CRITICAL_SECTION_DEBUG(void)
+{
     /* PRTL_CRITICAL_SECTION_DEBUG */
     TEST_TYPE(PRTL_CRITICAL_SECTION_DEBUG, 4, 4);
     TEST_TYPE_POINTER(PRTL_CRITICAL_SECTION_DEBUG, 32, 4);
+}
 
+static void test_pack_PRTL_RESOURCE_DEBUG(void)
+{
     /* PRTL_RESOURCE_DEBUG */
     TEST_TYPE(PRTL_RESOURCE_DEBUG, 4, 4);
     TEST_TYPE_POINTER(PRTL_RESOURCE_DEBUG, 32, 4);
+}
 
+static void test_pack_PSECURITY_QUALITY_OF_SERVICE(void)
+{
     /* PSECURITY_QUALITY_OF_SERVICE */
     TEST_TYPE(PSECURITY_QUALITY_OF_SERVICE, 4, 4);
+}
 
+static void test_pack_PSID_IDENTIFIER_AUTHORITY(void)
+{
     /* PSID_IDENTIFIER_AUTHORITY */
     TEST_TYPE(PSID_IDENTIFIER_AUTHORITY, 4, 4);
     TEST_TYPE_POINTER(PSID_IDENTIFIER_AUTHORITY, 6, 1);
+}
 
+static void test_pack_PSINGLE_LIST_ENTRY(void)
+{
     /* PSINGLE_LIST_ENTRY */
     TEST_TYPE(PSINGLE_LIST_ENTRY, 4, 4);
     TEST_TYPE_POINTER(PSINGLE_LIST_ENTRY, 4, 4);
+}
 
+static void test_pack_PSTR(void)
+{
     /* PSTR */
     TEST_TYPE(PSTR, 4, 4);
     TEST_TYPE_POINTER(PSTR, 1, 1);
+}
 
+static void test_pack_PSYSTEM_ALARM_ACE(void)
+{
     /* PSYSTEM_ALARM_ACE */
     TEST_TYPE(PSYSTEM_ALARM_ACE, 4, 4);
     TEST_TYPE_POINTER(PSYSTEM_ALARM_ACE, 12, 4);
+}
 
+static void test_pack_PSYSTEM_AUDIT_ACE(void)
+{
     /* PSYSTEM_AUDIT_ACE */
     TEST_TYPE(PSYSTEM_AUDIT_ACE, 4, 4);
     TEST_TYPE_POINTER(PSYSTEM_AUDIT_ACE, 12, 4);
+}
 
+static void test_pack_PTOKEN_PRIVILEGES(void)
+{
     /* PTOKEN_PRIVILEGES */
     TEST_TYPE(PTOKEN_PRIVILEGES, 4, 4);
     TEST_TYPE_POINTER(PTOKEN_PRIVILEGES, 16, 4);
+}
 
+static void test_pack_PTOP_LEVEL_EXCEPTION_FILTER(void)
+{
     /* PTOP_LEVEL_EXCEPTION_FILTER */
+    TEST_TYPE(PTOP_LEVEL_EXCEPTION_FILTER, 4, 4);
+}
 
+static void test_pack_PTSTR(void)
+{
     /* PTSTR */
-    TEST_TYPE(PTSTR, 4, 4);
+}
 
+static void test_pack_PULARGE_INTEGER(void)
+{
     /* PULARGE_INTEGER */
     TEST_TYPE(PULARGE_INTEGER, 4, 4);
+}
 
+static void test_pack_PVOID(void)
+{
     /* PVOID */
     TEST_TYPE(PVOID, 4, 4);
+}
 
+static void test_pack_PWCH(void)
+{
     /* PWCH */
     TEST_TYPE(PWCH, 4, 4);
     TEST_TYPE_POINTER(PWCH, 2, 2);
+}
 
+static void test_pack_PWSTR(void)
+{
     /* PWSTR */
     TEST_TYPE(PWSTR, 4, 4);
     TEST_TYPE_POINTER(PWSTR, 2, 2);
+}
 
+static void test_pack_RTL_CRITICAL_SECTION(void)
+{
     /* RTL_CRITICAL_SECTION (pack 4) */
     TEST_TYPE(RTL_CRITICAL_SECTION, 24, 4);
     TEST_FIELD(RTL_CRITICAL_SECTION, PRTL_CRITICAL_SECTION_DEBUG, DebugInfo, 0, 4, 4);
@@ -920,7 +1401,10 @@
     TEST_FIELD(RTL_CRITICAL_SECTION, HANDLE, OwningThread, 12, 4, 4);
     TEST_FIELD(RTL_CRITICAL_SECTION, HANDLE, LockSemaphore, 16, 4, 4);
     TEST_FIELD(RTL_CRITICAL_SECTION, ULONG_PTR, SpinCount, 20, 4, 4);
+}
 
+static void test_pack_RTL_CRITICAL_SECTION_DEBUG(void)
+{
     /* RTL_CRITICAL_SECTION_DEBUG (pack 4) */
     TEST_TYPE(RTL_CRITICAL_SECTION_DEBUG, 32, 4);
     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, Type, 0, 2, 2);
@@ -930,10 +1414,29 @@
     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD, EntryCount, 16, 4, 4);
     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD, ContentionCount, 20, 4, 4);
     TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD[ 2 ], Spare, 24, 8, 4);
+}
 
+static void test_pack_RTL_RESOURCE_DEBUG(void)
+{
+    /* RTL_RESOURCE_DEBUG (pack 4) */
+    TEST_TYPE(RTL_RESOURCE_DEBUG, 32, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, WORD, Type, 0, 2, 2);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, WORD, CreatorBackTraceIndex, 2, 2, 2);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, struct _RTL_CRITICAL_SECTION *, CriticalSection, 4, 4, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, LIST_ENTRY, ProcessLocksList, 8, 8, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD, EntryCount, 16, 4, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD, ContentionCount, 20, 4, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD[ 2 ], Spare, 24, 8, 4);
+}
+
+static void test_pack_SECURITY_CONTEXT_TRACKING_MODE(void)
+{
     /* SECURITY_CONTEXT_TRACKING_MODE */
     TEST_TYPE(SECURITY_CONTEXT_TRACKING_MODE, 1, 1);
+}
 
+static void test_pack_SECURITY_DESCRIPTOR(void)
+{
     /* SECURITY_DESCRIPTOR (pack 4) */
     TEST_TYPE(SECURITY_DESCRIPTOR, 20, 4);
     TEST_FIELD(SECURITY_DESCRIPTOR, BYTE, Revision, 0, 1, 1);
@@ -943,10 +1446,16 @@
     TEST_FIELD(SECURITY_DESCRIPTOR, PSID, Group, 8, 4, 4);
     TEST_FIELD(SECURITY_DESCRIPTOR, PACL, Sacl, 12, 4, 4);
     TEST_FIELD(SECURITY_DESCRIPTOR, PACL, Dacl, 16, 4, 4);
+}
 
+static void test_pack_SECURITY_DESCRIPTOR_CONTROL(void)
+{
     /* SECURITY_DESCRIPTOR_CONTROL */
     TEST_TYPE(SECURITY_DESCRIPTOR_CONTROL, 2, 2);
+}
 
+static void test_pack_SECURITY_DESCRIPTOR_RELATIVE(void)
+{
     /* SECURITY_DESCRIPTOR_RELATIVE (pack 4) */
     TEST_TYPE(SECURITY_DESCRIPTOR_RELATIVE, 20, 4);
     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, BYTE, Revision, 0, 1, 1);
@@ -956,203 +1465,629 @@
     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Group, 8, 4, 4);
     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Sacl, 12, 4, 4);
     TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Dacl, 16, 4, 4);
+}
 
+static void test_pack_SECURITY_INFORMATION(void)
+{
     /* SECURITY_INFORMATION */
     TEST_TYPE(SECURITY_INFORMATION, 4, 4);
+}
 
+static void test_pack_SHORT(void)
+{
     /* SHORT */
     TEST_TYPE(SHORT, 2, 2);
     TEST_TYPE_SIGNED(SHORT);
+}
 
+static void test_pack_SID(void)
+{
     /* SID (pack 4) */
     TEST_TYPE(SID, 12, 4);
     TEST_FIELD(SID, BYTE, Revision, 0, 1, 1);
     TEST_FIELD(SID, BYTE, SubAuthorityCount, 1, 1, 1);
     TEST_FIELD(SID, SID_IDENTIFIER_AUTHORITY, IdentifierAuthority, 2, 6, 1);
     TEST_FIELD(SID, DWORD[1], SubAuthority, 8, 4, 4);
+}
 
+static void test_pack_SID_AND_ATTRIBUTES(void)
+{
     /* SID_AND_ATTRIBUTES (pack 4) */
     TEST_TYPE(SID_AND_ATTRIBUTES, 8, 4);
     TEST_FIELD(SID_AND_ATTRIBUTES, PSID, Sid, 0, 4, 4);
     TEST_FIELD(SID_AND_ATTRIBUTES, DWORD, Attributes, 4, 4, 4);
+}
 
+static void test_pack_SID_IDENTIFIER_AUTHORITY(void)
+{
     /* SID_IDENTIFIER_AUTHORITY (pack 4) */
     TEST_TYPE(SID_IDENTIFIER_AUTHORITY, 6, 1);
     TEST_FIELD(SID_IDENTIFIER_AUTHORITY, BYTE[6], Value, 0, 6, 1);
+}
 
+static void test_pack_SINGLE_LIST_ENTRY(void)
+{
     /* SINGLE_LIST_ENTRY (pack 4) */
     TEST_TYPE(SINGLE_LIST_ENTRY, 4, 4);
     TEST_FIELD(SINGLE_LIST_ENTRY, struct _SINGLE_LIST_ENTRY *, Next, 0, 4, 4);
+}
 
+static void test_pack_SYSTEM_ALARM_ACE(void)
+{
     /* SYSTEM_ALARM_ACE (pack 4) */
     TEST_TYPE(SYSTEM_ALARM_ACE, 12, 4);
     TEST_FIELD(SYSTEM_ALARM_ACE, ACE_HEADER, Header, 0, 4, 2);
     TEST_FIELD(SYSTEM_ALARM_ACE, DWORD, Mask, 4, 4, 4);
     TEST_FIELD(SYSTEM_ALARM_ACE, DWORD, SidStart, 8, 4, 4);
+}
 
+static void test_pack_SYSTEM_AUDIT_ACE(void)
+{
     /* SYSTEM_AUDIT_ACE (pack 4) */
     TEST_TYPE(SYSTEM_AUDIT_ACE, 12, 4);
     TEST_FIELD(SYSTEM_AUDIT_ACE, ACE_HEADER, Header, 0, 4, 2);
     TEST_FIELD(SYSTEM_AUDIT_ACE, DWORD, Mask, 4, 4, 4);
     TEST_FIELD(SYSTEM_AUDIT_ACE, DWORD, SidStart, 8, 4, 4);
+}
 
+static void test_pack_TCHAR(void)
+{
     /* TCHAR */
     TEST_TYPE(TCHAR, 1, 1);
+}
 
+static void test_pack_TOKEN_DEFAULT_DACL(void)
+{
     /* TOKEN_DEFAULT_DACL (pack 4) */
     TEST_TYPE(TOKEN_DEFAULT_DACL, 4, 4);
     TEST_FIELD(TOKEN_DEFAULT_DACL, PACL, DefaultDacl, 0, 4, 4);
+}
 
+static void test_pack_TOKEN_GROUPS(void)
+{
     /* TOKEN_GROUPS (pack 4) */
     TEST_TYPE(TOKEN_GROUPS, 12, 4);
     TEST_FIELD(TOKEN_GROUPS, DWORD, GroupCount, 0, 4, 4);
     TEST_FIELD(TOKEN_GROUPS, SID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Groups, 4, 8, 4);
+}
 
+static void test_pack_TOKEN_OWNER(void)
+{
     /* TOKEN_OWNER (pack 4) */
     TEST_TYPE(TOKEN_OWNER, 4, 4);
     TEST_FIELD(TOKEN_OWNER, PSID, Owner, 0, 4, 4);
+}
 
+static void test_pack_TOKEN_PRIMARY_GROUP(void)
+{
     /* TOKEN_PRIMARY_GROUP (pack 4) */
     TEST_TYPE(TOKEN_PRIMARY_GROUP, 4, 4);
     TEST_FIELD(TOKEN_PRIMARY_GROUP, PSID, PrimaryGroup, 0, 4, 4);
+}
 
+static void test_pack_TOKEN_PRIVILEGES(void)
+{
     /* TOKEN_PRIVILEGES (pack 4) */
     TEST_TYPE(TOKEN_PRIVILEGES, 16, 4);
     TEST_FIELD(TOKEN_PRIVILEGES, DWORD, PrivilegeCount, 0, 4, 4);
     TEST_FIELD(TOKEN_PRIVILEGES, LUID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Privileges, 4, 12, 4);
+}
 
+static void test_pack_TOKEN_SOURCE(void)
+{
     /* TOKEN_SOURCE (pack 4) */
     TEST_TYPE(TOKEN_SOURCE, 16, 4);
     TEST_FIELD(TOKEN_SOURCE, char[TOKEN_SOURCE_LENGTH], SourceName, 0, 8, 1);
     TEST_FIELD(TOKEN_SOURCE, LUID, SourceIdentifier, 8, 8, 4);
+}
 
+static void test_pack_TOKEN_USER(void)
+{
     /* TOKEN_USER (pack 4) */
     TEST_TYPE(TOKEN_USER, 8, 4);
     TEST_FIELD(TOKEN_USER, SID_AND_ATTRIBUTES, User, 0, 8, 4);
+}
 
+static void test_pack_UCHAR(void)
+{
     /* UCHAR */
     TEST_TYPE(UCHAR, 1, 1);
     TEST_TYPE_UNSIGNED(UCHAR);
+}
 
+static void test_pack_UINT(void)
+{
     /* UINT */
     TEST_TYPE(UINT, 4, 4);
     TEST_TYPE_UNSIGNED(UINT);
+}
 
+static void test_pack_ULONG(void)
+{
     /* ULONG */
     TEST_TYPE(ULONG, 4, 4);
     TEST_TYPE_UNSIGNED(ULONG);
+}
 
+static void test_pack_USHORT(void)
+{
     /* USHORT */
     TEST_TYPE(USHORT, 2, 2);
     TEST_TYPE_UNSIGNED(USHORT);
+}
 
+static void test_pack_WAITORTIMERCALLBACKFUNC(void)
+{
     /* WAITORTIMERCALLBACKFUNC */
+    TEST_TYPE(WAITORTIMERCALLBACKFUNC, 4, 4);
+}
 
+static void test_pack_WCHAR(void)
+{
     /* WCHAR */
     TEST_TYPE(WCHAR, 2, 2);
     TEST_TYPE_UNSIGNED(WCHAR);
+}
 
+static void test_pack_WORD(void)
+{
     /* WORD */
     TEST_TYPE(WORD, 2, 2);
     TEST_TYPE_UNSIGNED(WORD);
+}
 
+static void test_pack_ATOM(void)
+{
     /* ATOM */
     TEST_TYPE(ATOM, 2, 2);
+}
 
+static void test_pack_COLORREF(void)
+{
     /* COLORREF */
     TEST_TYPE(COLORREF, 4, 4);
+}
 
+static void test_pack_FARPROC(void)
+{
     /* FARPROC */
+    TEST_TYPE(FARPROC, 4, 4);
+}
 
+static void test_pack_GLOBALHANDLE(void)
+{
     /* GLOBALHANDLE */
     TEST_TYPE(GLOBALHANDLE, 4, 4);
+}
 
+static void test_pack_HCURSOR(void)
+{
     /* HCURSOR */
     TEST_TYPE(HCURSOR, 4, 4);
     TEST_TYPE_UNSIGNED(HCURSOR);
+}
 
+static void test_pack_HFILE(void)
+{
     /* HFILE */
     TEST_TYPE(HFILE, 4, 4);
     TEST_TYPE_SIGNED(HFILE);
+}
 
+static void test_pack_HGDIOBJ(void)
+{
     /* HGDIOBJ */
     TEST_TYPE(HGDIOBJ, 4, 4);
+}
 
+static void test_pack_HGLOBAL(void)
+{
     /* HGLOBAL */
     TEST_TYPE(HGLOBAL, 4, 4);
+}
 
+static void test_pack_HLOCAL(void)
+{
     /* HLOCAL */
     TEST_TYPE(HLOCAL, 4, 4);
+}
 
+static void test_pack_HMODULE(void)
+{
     /* HMODULE */
     TEST_TYPE(HMODULE, 4, 4);
     TEST_TYPE_UNSIGNED(HMODULE);
+}
 
+static void test_pack_LOCALHANDLE(void)
+{
     /* LOCALHANDLE */
     TEST_TYPE(LOCALHANDLE, 4, 4);
+}
 
+static void test_pack_LPARAM(void)
+{
     /* LPARAM */
     TEST_TYPE(LPARAM, 4, 4);
+}
 
+static void test_pack_LPCRECT(void)
+{
     /* LPCRECT */
     TEST_TYPE(LPCRECT, 4, 4);
     TEST_TYPE_POINTER(LPCRECT, 16, 4);
+}
 
+static void test_pack_LPCRECTL(void)
+{
     /* LPCRECTL */
     TEST_TYPE(LPCRECTL, 4, 4);
     TEST_TYPE_POINTER(LPCRECTL, 16, 4);
+}
 
+static void test_pack_LPPOINT(void)
+{
     /* LPPOINT */
     TEST_TYPE(LPPOINT, 4, 4);
     TEST_TYPE_POINTER(LPPOINT, 8, 4);
+}
 
+static void test_pack_LPPOINTS(void)
+{
     /* LPPOINTS */
     TEST_TYPE(LPPOINTS, 4, 4);
     TEST_TYPE_POINTER(LPPOINTS, 4, 2);
+}
 
+static void test_pack_LPRECT(void)
+{
     /* LPRECT */
     TEST_TYPE(LPRECT, 4, 4);
     TEST_TYPE_POINTER(LPRECT, 16, 4);
+}
 
+static void test_pack_LPRECTL(void)
+{
     /* LPRECTL */
     TEST_TYPE(LPRECTL, 4, 4);
     TEST_TYPE_POINTER(LPRECTL, 16, 4);
+}
 
+static void test_pack_LPSIZE(void)
+{
     /* LPSIZE */
     TEST_TYPE(LPSIZE, 4, 4);
     TEST_TYPE_POINTER(LPSIZE, 8, 4);
+}
 
+static void test_pack_LRESULT(void)
+{
     /* LRESULT */
     TEST_TYPE(LRESULT, 4, 4);
+}
 
+static void test_pack_POINT(void)
+{
+    /* POINT (pack 4) */
+    TEST_TYPE(POINT, 8, 4);
+    TEST_FIELD(POINT, LONG, x, 0, 4, 4);
+    TEST_FIELD(POINT, LONG, y, 4, 4, 4);
+}
+
+static void test_pack_POINTL(void)
+{
+    /* POINTL (pack 4) */
+    TEST_TYPE(POINTL, 8, 4);
+    TEST_FIELD(POINTL, LONG, x, 0, 4, 4);
+    TEST_FIELD(POINTL, LONG, y, 4, 4, 4);
+}
+
+static void test_pack_POINTS(void)
+{
+    /* POINTS (pack 4) */
+    TEST_TYPE(POINTS, 4, 2);
+    TEST_FIELD(POINTS, SHORT, x, 0, 2, 2);
+    TEST_FIELD(POINTS, SHORT, y, 2, 2, 2);
+}
+
+static void test_pack_PPOINT(void)
+{
     /* PPOINT */
     TEST_TYPE(PPOINT, 4, 4);
     TEST_TYPE_POINTER(PPOINT, 8, 4);
+}
 
+static void test_pack_PPOINTS(void)
+{
     /* PPOINTS */
     TEST_TYPE(PPOINTS, 4, 4);
     TEST_TYPE_POINTER(PPOINTS, 4, 2);
+}
 
+static void test_pack_PRECT(void)
+{
     /* PRECT */
     TEST_TYPE(PRECT, 4, 4);
     TEST_TYPE_POINTER(PRECT, 16, 4);
+}
 
+static void test_pack_PRECTL(void)
+{
     /* PRECTL */
     TEST_TYPE(PRECTL, 4, 4);
     TEST_TYPE_POINTER(PRECTL, 16, 4);
+}
 
+static void test_pack_PROC(void)
+{
     /* PROC */
+    TEST_TYPE(PROC, 4, 4);
+}
 
+static void test_pack_PSIZE(void)
+{
     /* PSIZE */
     TEST_TYPE(PSIZE, 4, 4);
     TEST_TYPE_POINTER(PSIZE, 8, 4);
+}
 
+static void test_pack_RECT(void)
+{
+    /* RECT (pack 4) */
+    TEST_TYPE(RECT, 16, 4);
+    TEST_FIELD(RECT, INT, left, 0, 4, 4);
+    TEST_FIELD(RECT, INT, top, 4, 4, 4);
+    TEST_FIELD(RECT, INT, right, 8, 4, 4);
+    TEST_FIELD(RECT, INT, bottom, 12, 4, 4);
+}
+
+static void test_pack_RECTL(void)
+{
+    /* RECTL (pack 4) */
+    TEST_TYPE(RECTL, 16, 4);
+    TEST_FIELD(RECTL, LONG, left, 0, 4, 4);
+    TEST_FIELD(RECTL, LONG, top, 4, 4, 4);
+    TEST_FIELD(RECTL, LONG, right, 8, 4, 4);
+    TEST_FIELD(RECTL, LONG, bottom, 12, 4, 4);
+}
+
+static void test_pack_SIZE(void)
+{
+    /* SIZE (pack 4) */
+    TEST_TYPE(SIZE, 8, 4);
+    TEST_FIELD(SIZE, LONG, cx, 0, 4, 4);
+    TEST_FIELD(SIZE, LONG, cy, 4, 4, 4);
+}
+
+static void test_pack_SIZEL(void)
+{
     /* SIZEL */
     TEST_TYPE(SIZEL, 8, 4);
+}
 
+static void test_pack_WPARAM(void)
+{
     /* WPARAM */
     TEST_TYPE(WPARAM, 4, 4);
+}
 
+static void test_pack(void)
+{
+    test_pack_ACCESS_ALLOWED_ACE();
+    test_pack_ACCESS_DENIED_ACE();
+    test_pack_ACCESS_MASK();
+    test_pack_ACE_HEADER();
+    test_pack_ACL();
+    test_pack_ATOM();
+    test_pack_BOOL();
+    test_pack_BOOLEAN();
+    test_pack_BYTE();
+    test_pack_CCHAR();
+    test_pack_CHAR();
+    test_pack_COLORREF();
+    test_pack_DWORD();
+    test_pack_DWORD32();
+    test_pack_DWORD_PTR();
+    test_pack_EXCEPTION_POINTERS();
+    test_pack_EXCEPTION_RECORD();
+    test_pack_EXECUTION_STATE();
+    test_pack_FARPROC();
+    test_pack_FLOAT();
+    test_pack_FLOATING_SAVE_AREA();
+    test_pack_FPO_DATA();
+    test_pack_GENERIC_MAPPING();
+    test_pack_GLOBALHANDLE();
+    test_pack_HALF_PTR();
+    test_pack_HANDLE();
+    test_pack_HCURSOR();
+    test_pack_HFILE();
+    test_pack_HGDIOBJ();
+    test_pack_HGLOBAL();
+    test_pack_HLOCAL();
+    test_pack_HMODULE();
+    test_pack_HRESULT();
+    test_pack_IMAGE_ARCHIVE_MEMBER_HEADER();
+    test_pack_IMAGE_AUX_SYMBOL();
+    test_pack_IMAGE_BASE_RELOCATION();
+    test_pack_IMAGE_BOUND_FORWARDER_REF();
+    test_pack_IMAGE_BOUND_IMPORT_DESCRIPTOR();
+    test_pack_IMAGE_COFF_SYMBOLS_HEADER();
+    test_pack_IMAGE_DATA_DIRECTORY();
+    test_pack_IMAGE_DEBUG_DIRECTORY();
+    test_pack_IMAGE_DEBUG_MISC();
+    test_pack_IMAGE_DOS_HEADER();
+    test_pack_IMAGE_EXPORT_DIRECTORY();
+    test_pack_IMAGE_FILE_HEADER();
+    test_pack_IMAGE_FUNCTION_ENTRY();
+    test_pack_IMAGE_IMPORT_BY_NAME();
+    test_pack_IMAGE_LOAD_CONFIG_DIRECTORY();
+    test_pack_IMAGE_NT_HEADERS();
+    test_pack_IMAGE_OPTIONAL_HEADER();
+    test_pack_IMAGE_OS2_HEADER();
+    test_pack_IMAGE_RESOURCE_DATA_ENTRY();
+    test_pack_IMAGE_RESOURCE_DIRECTORY();
+    test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY();
+    test_pack_IMAGE_RESOURCE_DIRECTORY_STRING();
+    test_pack_IMAGE_RESOURCE_DIR_STRING_U();
+    test_pack_IMAGE_SEPARATE_DEBUG_HEADER();
+    test_pack_IMAGE_THUNK_DATA();
+    test_pack_IMAGE_TLS_DIRECTORY();
+    test_pack_IMAGE_VXD_HEADER();
+    test_pack_INT();
+    test_pack_INT32();
+    test_pack_INT_PTR();
+    test_pack_LANGID();
+    test_pack_LCID();
+    test_pack_LIST_ENTRY();
+    test_pack_LOCALHANDLE();
+    test_pack_LONG();
+    test_pack_LONG32();
+    test_pack_LONG_PTR();
+    test_pack_LPARAM();
+    test_pack_LPCRECT();
+    test_pack_LPCRECTL();
+    test_pack_LPCVOID();
+    test_pack_LPPOINT();
+    test_pack_LPPOINTS();
+    test_pack_LPRECT();
+    test_pack_LPRECTL();
+    test_pack_LPSIZE();
+    test_pack_LPTOP_LEVEL_EXCEPTION_FILTER();
+    test_pack_LRESULT();
+    test_pack_LUID();
+    test_pack_LUID_AND_ATTRIBUTES();
+    test_pack_MEMORY_BASIC_INFORMATION();
+    test_pack_MESSAGE_RESOURCE_BLOCK();
+    test_pack_MESSAGE_RESOURCE_DATA();
+    test_pack_MESSAGE_RESOURCE_ENTRY();
+    test_pack_PACCESS_ALLOWED_ACE();
+    test_pack_PACCESS_DENIED_ACE();
+    test_pack_PACCESS_TOKEN();
+    test_pack_PACE_HEADER();
+    test_pack_PACL();
+    test_pack_PCCH();
+    test_pack_PCH();
+    test_pack_PCSTR();
+    test_pack_PCWCH();
+    test_pack_PCWSTR();
+    test_pack_PEXCEPTION_POINTERS();
+    test_pack_PEXCEPTION_RECORD();
+    test_pack_PFLOATING_SAVE_AREA();
+    test_pack_PFPO_DATA();
+    test_pack_PGENERIC_MAPPING();
+    test_pack_PHANDLE();
+    test_pack_PIMAGE_ARCHIVE_MEMBER_HEADER();
+    test_pack_PIMAGE_AUX_SYMBOL();
+    test_pack_PIMAGE_BASE_RELOCATION();
+    test_pack_PIMAGE_BOUND_FORWARDER_REF();
+    test_pack_PIMAGE_BOUND_IMPORT_DESCRIPTOR();
+    test_pack_PIMAGE_COFF_SYMBOLS_HEADER();
+    test_pack_PIMAGE_DATA_DIRECTORY();
+    test_pack_PIMAGE_DEBUG_DIRECTORY();
+    test_pack_PIMAGE_DEBUG_MISC();
+    test_pack_PIMAGE_DOS_HEADER();
+    test_pack_PIMAGE_EXPORT_DIRECTORY();
+    test_pack_PIMAGE_FILE_HEADER();
+    test_pack_PIMAGE_FUNCTION_ENTRY();
+    test_pack_PIMAGE_IMPORT_BY_NAME();
+    test_pack_PIMAGE_IMPORT_DESCRIPTOR();
+    test_pack_PIMAGE_LINENUMBER();
+    test_pack_PIMAGE_LOAD_CONFIG_DIRECTORY();
+    test_pack_PIMAGE_NT_HEADERS();
+    test_pack_PIMAGE_OPTIONAL_HEADER();
+    test_pack_PIMAGE_OS2_HEADER();
+    test_pack_PIMAGE_RELOCATION();
+    test_pack_PIMAGE_RESOURCE_DATA_ENTRY();
+    test_pack_PIMAGE_RESOURCE_DIRECTORY();
+    test_pack_PIMAGE_RESOURCE_DIRECTORY_ENTRY();
+    test_pack_PIMAGE_RESOURCE_DIRECTORY_STRING();
+    test_pack_PIMAGE_RESOURCE_DIR_STRING_U();
+    test_pack_PIMAGE_SECTION_HEADER();
+    test_pack_PIMAGE_SEPARATE_DEBUG_HEADER();
+    test_pack_PIMAGE_SYMBOL();
+    test_pack_PIMAGE_THUNK_DATA();
+    test_pack_PIMAGE_TLS_CALLBACK();
+    test_pack_PIMAGE_TLS_DIRECTORY();
+    test_pack_PIMAGE_VXD_HEADER();
+    test_pack_PISECURITY_DESCRIPTOR_RELATIVE();
+    test_pack_PLARGE_INTEGER();
+    test_pack_PLIST_ENTRY();
+    test_pack_PLUID();
+    test_pack_PMEMORY_BASIC_INFORMATION();
+    test_pack_PMESSAGE_RESOURCE_BLOCK();
+    test_pack_PMESSAGE_RESOURCE_DATA();
+    test_pack_PMESSAGE_RESOURCE_ENTRY();
+    test_pack_PNT_TIB();
+    test_pack_POINT();
+    test_pack_POINTL();
+    test_pack_POINTS();
+    test_pack_PPOINT();
+    test_pack_PPOINTS();
+    test_pack_PPRIVILEGE_SET();
+    test_pack_PRECT();
+    test_pack_PRECTL();
+    test_pack_PRIVILEGE_SET();
+    test_pack_PRLIST_ENTRY();
+    test_pack_PROC();
+    test_pack_PRTL_CRITICAL_SECTION();
+    test_pack_PRTL_CRITICAL_SECTION_DEBUG();
+    test_pack_PRTL_RESOURCE_DEBUG();
+    test_pack_PSECURITY_QUALITY_OF_SERVICE();
+    test_pack_PSID_IDENTIFIER_AUTHORITY();
+    test_pack_PSINGLE_LIST_ENTRY();
+    test_pack_PSIZE();
+    test_pack_PSTR();
+    test_pack_PSYSTEM_ALARM_ACE();
+    test_pack_PSYSTEM_AUDIT_ACE();
+    test_pack_PTOKEN_PRIVILEGES();
+    test_pack_PTOP_LEVEL_EXCEPTION_FILTER();
+    test_pack_PTSTR();
+    test_pack_PULARGE_INTEGER();
+    test_pack_PVOID();
+    test_pack_PWCH();
+    test_pack_PWSTR();
+    test_pack_RECT();
+    test_pack_RECTL();
+    test_pack_RTL_CRITICAL_SECTION();
+    test_pack_RTL_CRITICAL_SECTION_DEBUG();
+    test_pack_RTL_RESOURCE_DEBUG();
+    test_pack_SECURITY_CONTEXT_TRACKING_MODE();
+    test_pack_SECURITY_DESCRIPTOR();
+    test_pack_SECURITY_DESCRIPTOR_CONTROL();
+    test_pack_SECURITY_DESCRIPTOR_RELATIVE();
+    test_pack_SECURITY_INFORMATION();
+    test_pack_SHORT();
+    test_pack_SID();
+    test_pack_SID_AND_ATTRIBUTES();
+    test_pack_SID_IDENTIFIER_AUTHORITY();
+    test_pack_SINGLE_LIST_ENTRY();
+    test_pack_SIZE();
+    test_pack_SIZEL();
+    test_pack_SIZE_T();
+    test_pack_SSIZE_T();
+    test_pack_SYSTEM_ALARM_ACE();
+    test_pack_SYSTEM_AUDIT_ACE();
+    test_pack_TCHAR();
+    test_pack_TOKEN_DEFAULT_DACL();
+    test_pack_TOKEN_GROUPS();
+    test_pack_TOKEN_OWNER();
+    test_pack_TOKEN_PRIMARY_GROUP();
+    test_pack_TOKEN_PRIVILEGES();
+    test_pack_TOKEN_SOURCE();
+    test_pack_TOKEN_USER();
+    test_pack_UCHAR();
+    test_pack_UHALF_PTR();
+    test_pack_UINT();
+    test_pack_UINT32();
+    test_pack_UINT_PTR();
+    test_pack_ULONG();
+    test_pack_ULONG32();
+    test_pack_ULONG_PTR();
+    test_pack_USHORT();
+    test_pack_WAITORTIMERCALLBACKFUNC();
+    test_pack_WCHAR();
+    test_pack_WORD();
+    test_pack_WPARAM();
 }
 
 START_TEST(generated)
diff --git a/dlls/user/tests/generated.c b/dlls/user/tests/generated.c
index b35b9e7..9774653 100644
--- a/dlls/user/tests/generated.c
+++ b/dlls/user/tests/generated.c
@@ -108,45 +108,79 @@
 #define TEST_TYPE_UNSIGNED(type) \
      ok((type) -1 > 0, "(" #type ") -1 > 0");
 
-void test_pack(void)
+static void test_pack_ACCEL(void)
 {
     /* ACCEL (pack 4) */
     TEST_TYPE(ACCEL, 6, 2);
     TEST_FIELD(ACCEL, BYTE, fVirt, 0, 1, 1);
     TEST_FIELD(ACCEL, WORD, key, 2, 2, 2);
     TEST_FIELD(ACCEL, WORD, cmd, 4, 2, 2);
+}
 
+static void test_pack_ACCESSTIMEOUT(void)
+{
     /* ACCESSTIMEOUT (pack 4) */
     TEST_TYPE(ACCESSTIMEOUT, 12, 4);
     TEST_FIELD(ACCESSTIMEOUT, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(ACCESSTIMEOUT, DWORD, dwFlags, 4, 4, 4);
     TEST_FIELD(ACCESSTIMEOUT, DWORD, iTimeOutMSec, 8, 4, 4);
+}
 
+static void test_pack_ANIMATIONINFO(void)
+{
     /* ANIMATIONINFO (pack 4) */
     TEST_TYPE(ANIMATIONINFO, 8, 4);
     TEST_FIELD(ANIMATIONINFO, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(ANIMATIONINFO, INT, iMinAnimate, 4, 4, 4);
+}
 
+static void test_pack_CBTACTIVATESTRUCT(void)
+{
     /* CBTACTIVATESTRUCT (pack 4) */
     TEST_TYPE(CBTACTIVATESTRUCT, 8, 4);
     TEST_FIELD(CBTACTIVATESTRUCT, BOOL, fMouse, 0, 4, 4);
     TEST_FIELD(CBTACTIVATESTRUCT, HWND, hWndActive, 4, 4, 4);
+}
 
+static void test_pack_CBT_CREATEWNDA(void)
+{
     /* CBT_CREATEWNDA (pack 4) */
     TEST_TYPE(CBT_CREATEWNDA, 8, 4);
     TEST_FIELD(CBT_CREATEWNDA, CREATESTRUCTA *, lpcs, 0, 4, 4);
     TEST_FIELD(CBT_CREATEWNDA, HWND, hwndInsertAfter, 4, 4, 4);
+}
 
+static void test_pack_CBT_CREATEWNDW(void)
+{
     /* CBT_CREATEWNDW (pack 4) */
     TEST_TYPE(CBT_CREATEWNDW, 8, 4);
     TEST_FIELD(CBT_CREATEWNDW, CREATESTRUCTW *, lpcs, 0, 4, 4);
     TEST_FIELD(CBT_CREATEWNDW, HWND, hwndInsertAfter, 4, 4, 4);
+}
 
+static void test_pack_CLIENTCREATESTRUCT(void)
+{
     /* CLIENTCREATESTRUCT (pack 4) */
     TEST_TYPE(CLIENTCREATESTRUCT, 8, 4);
     TEST_FIELD(CLIENTCREATESTRUCT, HMENU, hWindowMenu, 0, 4, 4);
     TEST_FIELD(CLIENTCREATESTRUCT, UINT, idFirstChild, 4, 4, 4);
+}
 
+static void test_pack_COMBOBOXINFO(void)
+{
+    /* COMBOBOXINFO (pack 4) */
+    TEST_TYPE(COMBOBOXINFO, 52, 4);
+    TEST_FIELD(COMBOBOXINFO, DWORD, cbSize, 0, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, RECT, rcItem, 4, 16, 4);
+    TEST_FIELD(COMBOBOXINFO, RECT, rcButton, 20, 16, 4);
+    TEST_FIELD(COMBOBOXINFO, DWORD, stateButton, 36, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, HWND, hwndCombo, 40, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, HWND, hwndItem, 44, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, HWND, hwndList, 48, 4, 4);
+}
+
+static void test_pack_COMPAREITEMSTRUCT(void)
+{
     /* COMPAREITEMSTRUCT (pack 4) */
     TEST_TYPE(COMPAREITEMSTRUCT, 32, 4);
     TEST_FIELD(COMPAREITEMSTRUCT, UINT, CtlType, 0, 4, 4);
@@ -157,13 +191,19 @@
     TEST_FIELD(COMPAREITEMSTRUCT, UINT, itemID2, 20, 4, 4);
     TEST_FIELD(COMPAREITEMSTRUCT, ULONG_PTR, itemData2, 24, 4, 4);
     TEST_FIELD(COMPAREITEMSTRUCT, DWORD, dwLocaleId, 28, 4, 4);
+}
 
+static void test_pack_COPYDATASTRUCT(void)
+{
     /* COPYDATASTRUCT (pack 4) */
     TEST_TYPE(COPYDATASTRUCT, 12, 4);
     TEST_FIELD(COPYDATASTRUCT, ULONG_PTR, dwData, 0, 4, 4);
     TEST_FIELD(COPYDATASTRUCT, DWORD, cbData, 4, 4, 4);
     TEST_FIELD(COPYDATASTRUCT, PVOID, lpData, 8, 4, 4);
+}
 
+static void test_pack_CREATESTRUCTA(void)
+{
     /* CREATESTRUCTA (pack 4) */
     TEST_TYPE(CREATESTRUCTA, 48, 4);
     TEST_FIELD(CREATESTRUCTA, LPVOID, lpCreateParams, 0, 4, 4);
@@ -178,7 +218,10 @@
     TEST_FIELD(CREATESTRUCTA, LPCSTR, lpszName, 36, 4, 4);
     TEST_FIELD(CREATESTRUCTA, LPCSTR, lpszClass, 40, 4, 4);
     TEST_FIELD(CREATESTRUCTA, DWORD, dwExStyle, 44, 4, 4);
+}
 
+static void test_pack_CREATESTRUCTW(void)
+{
     /* CREATESTRUCTW (pack 4) */
     TEST_TYPE(CREATESTRUCTW, 48, 4);
     TEST_FIELD(CREATESTRUCTW, LPVOID, lpCreateParams, 0, 4, 4);
@@ -193,14 +236,20 @@
     TEST_FIELD(CREATESTRUCTW, LPCWSTR, lpszName, 36, 4, 4);
     TEST_FIELD(CREATESTRUCTW, LPCWSTR, lpszClass, 40, 4, 4);
     TEST_FIELD(CREATESTRUCTW, DWORD, dwExStyle, 44, 4, 4);
+}
 
+static void test_pack_CURSORINFO(void)
+{
     /* CURSORINFO (pack 4) */
     TEST_TYPE(CURSORINFO, 20, 4);
     TEST_FIELD(CURSORINFO, DWORD, cbSize, 0, 4, 4);
     TEST_FIELD(CURSORINFO, DWORD, flags, 4, 4, 4);
     TEST_FIELD(CURSORINFO, HCURSOR, hCursor, 8, 4, 4);
     TEST_FIELD(CURSORINFO, POINT, ptScreenPos, 12, 8, 4);
+}
 
+static void test_pack_CWPRETSTRUCT(void)
+{
     /* CWPRETSTRUCT (pack 4) */
     TEST_TYPE(CWPRETSTRUCT, 20, 4);
     TEST_FIELD(CWPRETSTRUCT, LRESULT, lResult, 0, 4, 4);
@@ -208,14 +257,20 @@
     TEST_FIELD(CWPRETSTRUCT, WPARAM, wParam, 8, 4, 4);
     TEST_FIELD(CWPRETSTRUCT, DWORD, message, 12, 4, 4);
     TEST_FIELD(CWPRETSTRUCT, HWND, hwnd, 16, 4, 4);
+}
 
+static void test_pack_CWPSTRUCT(void)
+{
     /* CWPSTRUCT (pack 4) */
     TEST_TYPE(CWPSTRUCT, 16, 4);
     TEST_FIELD(CWPSTRUCT, LPARAM, lParam, 0, 4, 4);
     TEST_FIELD(CWPSTRUCT, WPARAM, wParam, 4, 4, 4);
     TEST_FIELD(CWPSTRUCT, UINT, message, 8, 4, 4);
     TEST_FIELD(CWPSTRUCT, HWND, hwnd, 12, 4, 4);
+}
 
+static void test_pack_DEBUGHOOKINFO(void)
+{
     /* DEBUGHOOKINFO (pack 4) */
     TEST_TYPE(DEBUGHOOKINFO, 20, 4);
     TEST_FIELD(DEBUGHOOKINFO, DWORD, idThread, 0, 4, 4);
@@ -223,7 +278,10 @@
     TEST_FIELD(DEBUGHOOKINFO, LPARAM, lParam, 8, 4, 4);
     TEST_FIELD(DEBUGHOOKINFO, WPARAM, wParam, 12, 4, 4);
     TEST_FIELD(DEBUGHOOKINFO, INT, code, 16, 4, 4);
+}
 
+static void test_pack_DELETEITEMSTRUCT(void)
+{
     /* DELETEITEMSTRUCT (pack 4) */
     TEST_TYPE(DELETEITEMSTRUCT, 20, 4);
     TEST_FIELD(DELETEITEMSTRUCT, UINT, CtlType, 0, 4, 4);
@@ -231,13 +289,22 @@
     TEST_FIELD(DELETEITEMSTRUCT, UINT, itemID, 8, 4, 4);
     TEST_FIELD(DELETEITEMSTRUCT, HWND, hwndItem, 12, 4, 4);
     TEST_FIELD(DELETEITEMSTRUCT, ULONG_PTR, itemData, 16, 4, 4);
+}
 
+static void test_pack_DESKTOPENUMPROCA(void)
+{
     /* DESKTOPENUMPROCA */
     TEST_TYPE(DESKTOPENUMPROCA, 4, 4);
+}
 
+static void test_pack_DESKTOPENUMPROCW(void)
+{
     /* DESKTOPENUMPROCW */
     TEST_TYPE(DESKTOPENUMPROCW, 4, 4);
+}
 
+static void test_pack_DLGITEMTEMPLATE(void)
+{
     /* DLGITEMTEMPLATE (pack 2) */
     TEST_TYPE(DLGITEMTEMPLATE, 18, 2);
     TEST_FIELD(DLGITEMTEMPLATE, DWORD, style, 0, 4, 2);
@@ -247,13 +314,16 @@
     TEST_FIELD(DLGITEMTEMPLATE, short, cx, 12, 2, 2);
     TEST_FIELD(DLGITEMTEMPLATE, short, cy, 14, 2, 2);
     TEST_FIELD(DLGITEMTEMPLATE, WORD, id, 16, 2, 2);
+}
 
+static void test_pack_DLGPROC(void)
+{
     /* DLGPROC */
     TEST_TYPE(DLGPROC, 4, 4);
+}
 
-    /* DLGPROC */
-    TEST_TYPE(DLGPROC, 4, 4);
-
+static void test_pack_DLGTEMPLATE(void)
+{
     /* DLGTEMPLATE (pack 2) */
     TEST_TYPE(DLGTEMPLATE, 18, 2);
     TEST_FIELD(DLGTEMPLATE, DWORD, style, 0, 4, 2);
@@ -263,13 +333,16 @@
     TEST_FIELD(DLGTEMPLATE, short, y, 12, 2, 2);
     TEST_FIELD(DLGTEMPLATE, short, cx, 14, 2, 2);
     TEST_FIELD(DLGTEMPLATE, short, cy, 16, 2, 2);
+}
 
+static void test_pack_DRAWSTATEPROC(void)
+{
     /* DRAWSTATEPROC */
     TEST_TYPE(DRAWSTATEPROC, 4, 4);
+}
 
-    /* DRAWSTATEPROC */
-    TEST_TYPE(DRAWSTATEPROC, 4, 4);
-
+static void test_pack_DRAWTEXTPARAMS(void)
+{
     /* DRAWTEXTPARAMS (pack 4) */
     TEST_TYPE(DRAWTEXTPARAMS, 20, 4);
     TEST_FIELD(DRAWTEXTPARAMS, UINT, cbSize, 0, 4, 4);
@@ -277,19 +350,22 @@
     TEST_FIELD(DRAWTEXTPARAMS, INT, iLeftMargin, 8, 4, 4);
     TEST_FIELD(DRAWTEXTPARAMS, INT, iRightMargin, 12, 4, 4);
     TEST_FIELD(DRAWTEXTPARAMS, UINT, uiLengthDrawn, 16, 4, 4);
+}
 
+static void test_pack_EDITWORDBREAKPROCA(void)
+{
     /* EDITWORDBREAKPROCA */
     TEST_TYPE(EDITWORDBREAKPROCA, 4, 4);
+}
 
-    /* EDITWORDBREAKPROCA */
-    TEST_TYPE(EDITWORDBREAKPROCA, 4, 4);
-
+static void test_pack_EDITWORDBREAKPROCW(void)
+{
     /* EDITWORDBREAKPROCW */
     TEST_TYPE(EDITWORDBREAKPROCW, 4, 4);
+}
 
-    /* EDITWORDBREAKPROCW */
-    TEST_TYPE(EDITWORDBREAKPROCW, 4, 4);
-
+static void test_pack_EVENTMSG(void)
+{
     /* EVENTMSG (pack 4) */
     TEST_TYPE(EVENTMSG, 20, 4);
     TEST_FIELD(EVENTMSG, UINT, message, 0, 4, 4);
@@ -297,7 +373,10 @@
     TEST_FIELD(EVENTMSG, UINT, paramH, 8, 4, 4);
     TEST_FIELD(EVENTMSG, DWORD, time, 12, 4, 4);
     TEST_FIELD(EVENTMSG, HWND, hwnd, 16, 4, 4);
+}
 
+static void test_pack_FILTERKEYS(void)
+{
     /* FILTERKEYS (pack 4) */
     TEST_TYPE(FILTERKEYS, 24, 4);
     TEST_FIELD(FILTERKEYS, UINT, cbSize, 0, 4, 4);
@@ -306,32 +385,62 @@
     TEST_FIELD(FILTERKEYS, DWORD, iDelayMSec, 12, 4, 4);
     TEST_FIELD(FILTERKEYS, DWORD, iRepeatMSec, 16, 4, 4);
     TEST_FIELD(FILTERKEYS, DWORD, iBounceMSec, 20, 4, 4);
+}
 
+static void test_pack_GUITHREADINFO(void)
+{
+    /* GUITHREADINFO (pack 4) */
+    TEST_TYPE(GUITHREADINFO, 48, 4);
+    TEST_FIELD(GUITHREADINFO, DWORD, cbSize, 0, 4, 4);
+    TEST_FIELD(GUITHREADINFO, DWORD, flags, 4, 4, 4);
+    TEST_FIELD(GUITHREADINFO, HWND, hwndActive, 8, 4, 4);
+    TEST_FIELD(GUITHREADINFO, HWND, hwndFocus, 12, 4, 4);
+    TEST_FIELD(GUITHREADINFO, HWND, hwndCapture, 16, 4, 4);
+    TEST_FIELD(GUITHREADINFO, HWND, hwndMenuOwner, 20, 4, 4);
+    TEST_FIELD(GUITHREADINFO, HWND, hwndMoveSize, 24, 4, 4);
+    TEST_FIELD(GUITHREADINFO, HWND, hwndCaret, 28, 4, 4);
+    TEST_FIELD(GUITHREADINFO, RECT, rcCaret, 32, 16, 4);
+}
+
+static void test_pack_GRAYSTRINGPROC(void)
+{
     /* GRAYSTRINGPROC */
     TEST_TYPE(GRAYSTRINGPROC, 4, 4);
+}
 
-    /* GRAYSTRINGPROC */
-    TEST_TYPE(GRAYSTRINGPROC, 4, 4);
-
+static void test_pack_HARDWAREHOOKSTRUCT(void)
+{
     /* HARDWAREHOOKSTRUCT (pack 4) */
     TEST_TYPE(HARDWAREHOOKSTRUCT, 16, 4);
     TEST_FIELD(HARDWAREHOOKSTRUCT, HWND, hwnd, 0, 4, 4);
     TEST_FIELD(HARDWAREHOOKSTRUCT, UINT, message, 4, 4, 4);
     TEST_FIELD(HARDWAREHOOKSTRUCT, WPARAM, wParam, 8, 4, 4);
     TEST_FIELD(HARDWAREHOOKSTRUCT, LPARAM, lParam, 12, 4, 4);
+}
 
+static void test_pack_HARDWAREINPUT(void)
+{
     /* HARDWAREINPUT (pack 4) */
     TEST_TYPE(HARDWAREINPUT, 8, 4);
     TEST_FIELD(HARDWAREINPUT, DWORD, uMsg, 0, 4, 4);
     TEST_FIELD(HARDWAREINPUT, WORD, wParamL, 4, 2, 2);
     TEST_FIELD(HARDWAREINPUT, WORD, wParamH, 6, 2, 2);
+}
 
+static void test_pack_HDEVNOTIFY(void)
+{
     /* HDEVNOTIFY */
     TEST_TYPE(HDEVNOTIFY, 4, 4);
+}
 
+static void test_pack_HDWP(void)
+{
     /* HDWP */
     TEST_TYPE(HDWP, 4, 4);
+}
 
+static void test_pack_HELPINFO(void)
+{
     /* HELPINFO (pack 4) */
     TEST_TYPE(HELPINFO, 28, 4);
     TEST_FIELD(HELPINFO, UINT, cbSize, 0, 4, 4);
@@ -340,7 +449,10 @@
     TEST_FIELD(HELPINFO, HANDLE, hItemHandle, 12, 4, 4);
     TEST_FIELD(HELPINFO, DWORD_PTR, dwContextId, 16, 4, 4);
     TEST_FIELD(HELPINFO, POINT, MousePos, 20, 8, 4);
+}
 
+static void test_pack_HELPWININFOA(void)
+{
     /* HELPWININFOA (pack 4) */
     TEST_TYPE(HELPWININFOA, 28, 4);
     TEST_FIELD(HELPWININFOA, int, wStructSize, 0, 4, 4);
@@ -350,7 +462,10 @@
     TEST_FIELD(HELPWININFOA, int, dy, 16, 4, 4);
     TEST_FIELD(HELPWININFOA, int, wMax, 20, 4, 4);
     TEST_FIELD(HELPWININFOA, CHAR[2], rgchMember, 24, 2, 1);
+}
 
+static void test_pack_HELPWININFOW(void)
+{
     /* HELPWININFOW (pack 4) */
     TEST_TYPE(HELPWININFOW, 28, 4);
     TEST_FIELD(HELPWININFOW, int, wStructSize, 0, 4, 4);
@@ -360,25 +475,32 @@
     TEST_FIELD(HELPWININFOW, int, dy, 16, 4, 4);
     TEST_FIELD(HELPWININFOW, int, wMax, 20, 4, 4);
     TEST_FIELD(HELPWININFOW, WCHAR[2], rgchMember, 24, 4, 2);
+}
 
+static void test_pack_HIGHCONTRASTA(void)
+{
     /* HIGHCONTRASTA (pack 4) */
-    TEST_TYPE(HIGHCONTRASTA, 12, 4);
     TEST_FIELD(HIGHCONTRASTA, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(HIGHCONTRASTA, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(HIGHCONTRASTA, LPSTR, lpszDefaultScheme, 8, 4, 4);
+}
 
+static void test_pack_HIGHCONTRASTW(void)
+{
     /* HIGHCONTRASTW (pack 4) */
     TEST_TYPE(HIGHCONTRASTW, 12, 4);
     TEST_FIELD(HIGHCONTRASTW, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(HIGHCONTRASTW, DWORD, dwFlags, 4, 4, 4);
     TEST_FIELD(HIGHCONTRASTW, LPWSTR, lpszDefaultScheme, 8, 4, 4);
+}
 
+static void test_pack_HOOKPROC(void)
+{
     /* HOOKPROC */
     TEST_TYPE(HOOKPROC, 4, 4);
+}
 
-    /* HOOKPROC */
-    TEST_TYPE(HOOKPROC, 4, 4);
-
+static void test_pack_ICONINFO(void)
+{
     /* ICONINFO (pack 4) */
     TEST_TYPE(ICONINFO, 20, 4);
     TEST_FIELD(ICONINFO, BOOL, fIcon, 0, 4, 4);
@@ -386,7 +508,10 @@
     TEST_FIELD(ICONINFO, DWORD, yHotspot, 8, 4, 4);
     TEST_FIELD(ICONINFO, HBITMAP, hbmMask, 12, 4, 4);
     TEST_FIELD(ICONINFO, HBITMAP, hbmColor, 16, 4, 4);
+}
 
+static void test_pack_ICONMETRICSA(void)
+{
     /* ICONMETRICSA (pack 4) */
     TEST_TYPE(ICONMETRICSA, 76, 4);
     TEST_FIELD(ICONMETRICSA, UINT, cbSize, 0, 4, 4);
@@ -394,7 +519,10 @@
     TEST_FIELD(ICONMETRICSA, int, iVertSpacing, 8, 4, 4);
     TEST_FIELD(ICONMETRICSA, int, iTitleWrap, 12, 4, 4);
     TEST_FIELD(ICONMETRICSA, LOGFONTA, lfFont, 16, 60, 4);
+}
 
+static void test_pack_ICONMETRICSW(void)
+{
     /* ICONMETRICSW (pack 4) */
     TEST_TYPE(ICONMETRICSW, 108, 4);
     TEST_FIELD(ICONMETRICSW, UINT, cbSize, 0, 4, 4);
@@ -402,10 +530,16 @@
     TEST_FIELD(ICONMETRICSW, int, iVertSpacing, 8, 4, 4);
     TEST_FIELD(ICONMETRICSW, int, iTitleWrap, 12, 4, 4);
     TEST_FIELD(ICONMETRICSW, LOGFONTW, lfFont, 16, 92, 4);
+}
 
+static void test_pack_INPUT(void)
+{
     /* INPUT (pack 4) */
     TEST_FIELD(INPUT, DWORD, type, 0, 4, 4);
+}
 
+static void test_pack_KBDLLHOOKSTRUCT(void)
+{
     /* KBDLLHOOKSTRUCT (pack 4) */
     TEST_TYPE(KBDLLHOOKSTRUCT, 20, 4);
     TEST_FIELD(KBDLLHOOKSTRUCT, DWORD, vkCode, 0, 4, 4);
@@ -413,7 +547,10 @@
     TEST_FIELD(KBDLLHOOKSTRUCT, DWORD, flags, 8, 4, 4);
     TEST_FIELD(KBDLLHOOKSTRUCT, DWORD, time, 12, 4, 4);
     TEST_FIELD(KBDLLHOOKSTRUCT, ULONG_PTR, dwExtraInfo, 16, 4, 4);
+}
 
+static void test_pack_KEYBDINPUT(void)
+{
     /* KEYBDINPUT (pack 4) */
     TEST_TYPE(KEYBDINPUT, 16, 4);
     TEST_FIELD(KEYBDINPUT, WORD, wVk, 0, 2, 2);
@@ -421,348 +558,604 @@
     TEST_FIELD(KEYBDINPUT, DWORD, dwFlags, 4, 4, 4);
     TEST_FIELD(KEYBDINPUT, DWORD, time, 8, 4, 4);
     TEST_FIELD(KEYBDINPUT, ULONG_PTR, dwExtraInfo, 12, 4, 4);
+}
 
+static void test_pack_LPACCEL(void)
+{
     /* LPACCEL */
     TEST_TYPE(LPACCEL, 4, 4);
     TEST_TYPE_POINTER(LPACCEL, 6, 2);
+}
 
+static void test_pack_LPACCESSTIMEOUT(void)
+{
     /* LPACCESSTIMEOUT */
     TEST_TYPE(LPACCESSTIMEOUT, 4, 4);
     TEST_TYPE_POINTER(LPACCESSTIMEOUT, 12, 4);
+}
 
+static void test_pack_LPANIMATIONINFO(void)
+{
     /* LPANIMATIONINFO */
     TEST_TYPE(LPANIMATIONINFO, 4, 4);
     TEST_TYPE_POINTER(LPANIMATIONINFO, 8, 4);
+}
 
+static void test_pack_LPCBTACTIVATESTRUCT(void)
+{
     /* LPCBTACTIVATESTRUCT */
     TEST_TYPE(LPCBTACTIVATESTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPCBTACTIVATESTRUCT, 8, 4);
+}
 
+static void test_pack_LPCBT_CREATEWNDA(void)
+{
     /* LPCBT_CREATEWNDA */
     TEST_TYPE(LPCBT_CREATEWNDA, 4, 4);
     TEST_TYPE_POINTER(LPCBT_CREATEWNDA, 8, 4);
+}
 
+static void test_pack_LPCBT_CREATEWNDW(void)
+{
     /* LPCBT_CREATEWNDW */
     TEST_TYPE(LPCBT_CREATEWNDW, 4, 4);
     TEST_TYPE_POINTER(LPCBT_CREATEWNDW, 8, 4);
+}
 
+static void test_pack_LPCDLGTEMPLATEA(void)
+{
     /* LPCDLGTEMPLATEA */
     TEST_TYPE(LPCDLGTEMPLATEA, 4, 4);
     TEST_TYPE_POINTER(LPCDLGTEMPLATEA, 18, 2);
+}
 
+static void test_pack_LPCDLGTEMPLATEW(void)
+{
     /* LPCDLGTEMPLATEW */
     TEST_TYPE(LPCDLGTEMPLATEW, 4, 4);
     TEST_TYPE_POINTER(LPCDLGTEMPLATEW, 18, 2);
+}
 
+static void test_pack_LPCLIENTCREATESTRUCT(void)
+{
     /* LPCLIENTCREATESTRUCT */
     TEST_TYPE(LPCLIENTCREATESTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPCLIENTCREATESTRUCT, 8, 4);
+}
 
+static void test_pack_LPCMENUINFO(void)
+{
     /* LPCMENUINFO */
     TEST_TYPE(LPCMENUINFO, 4, 4);
     TEST_TYPE_POINTER(LPCMENUINFO, 28, 4);
+}
 
+static void test_pack_LPCMENUITEMINFOA(void)
+{
     /* LPCMENUITEMINFOA */
     TEST_TYPE(LPCMENUITEMINFOA, 4, 4);
-    TEST_TYPE_POINTER(LPCMENUITEMINFOA, 48, 4);
+}
 
+static void test_pack_LPCMENUITEMINFOW(void)
+{
     /* LPCMENUITEMINFOW */
     TEST_TYPE(LPCMENUITEMINFOW, 4, 4);
     TEST_TYPE_POINTER(LPCMENUITEMINFOW, 48, 4);
+}
 
+static void test_pack_LPCOMBOBOXINFO(void)
+{
     /* LPCOMBOBOXINFO */
     TEST_TYPE(LPCOMBOBOXINFO, 4, 4);
     TEST_TYPE_POINTER(LPCOMBOBOXINFO, 52, 4);
+}
 
+static void test_pack_LPCOMPAREITEMSTRUCT(void)
+{
     /* LPCOMPAREITEMSTRUCT */
     TEST_TYPE(LPCOMPAREITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPCOMPAREITEMSTRUCT, 32, 4);
+}
 
+static void test_pack_LPCREATESTRUCTA(void)
+{
     /* LPCREATESTRUCTA */
     TEST_TYPE(LPCREATESTRUCTA, 4, 4);
     TEST_TYPE_POINTER(LPCREATESTRUCTA, 48, 4);
+}
 
+static void test_pack_LPCREATESTRUCTW(void)
+{
     /* LPCREATESTRUCTW */
     TEST_TYPE(LPCREATESTRUCTW, 4, 4);
     TEST_TYPE_POINTER(LPCREATESTRUCTW, 48, 4);
+}
 
+static void test_pack_LPCSCROLLINFO(void)
+{
     /* LPCSCROLLINFO */
     TEST_TYPE(LPCSCROLLINFO, 4, 4);
     TEST_TYPE_POINTER(LPCSCROLLINFO, 28, 4);
+}
 
+static void test_pack_LPCURSORINFO(void)
+{
     /* LPCURSORINFO */
     TEST_TYPE(LPCURSORINFO, 4, 4);
     TEST_TYPE_POINTER(LPCURSORINFO, 20, 4);
+}
 
+static void test_pack_LPCWPRETSTRUCT(void)
+{
     /* LPCWPRETSTRUCT */
     TEST_TYPE(LPCWPRETSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPCWPRETSTRUCT, 20, 4);
+}
 
+static void test_pack_LPCWPSTRUCT(void)
+{
     /* LPCWPSTRUCT */
     TEST_TYPE(LPCWPSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPCWPSTRUCT, 16, 4);
+}
 
+static void test_pack_LPDEBUGHOOKINFO(void)
+{
     /* LPDEBUGHOOKINFO */
     TEST_TYPE(LPDEBUGHOOKINFO, 4, 4);
     TEST_TYPE_POINTER(LPDEBUGHOOKINFO, 20, 4);
+}
 
+static void test_pack_LPDELETEITEMSTRUCT(void)
+{
     /* LPDELETEITEMSTRUCT */
     TEST_TYPE(LPDELETEITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPDELETEITEMSTRUCT, 20, 4);
+}
 
+static void test_pack_LPDLGITEMTEMPLATEA(void)
+{
     /* LPDLGITEMTEMPLATEA */
     TEST_TYPE(LPDLGITEMTEMPLATEA, 4, 4);
     TEST_TYPE_POINTER(LPDLGITEMTEMPLATEA, 18, 2);
+}
 
+static void test_pack_LPDLGITEMTEMPLATEW(void)
+{
     /* LPDLGITEMTEMPLATEW */
     TEST_TYPE(LPDLGITEMTEMPLATEW, 4, 4);
     TEST_TYPE_POINTER(LPDLGITEMTEMPLATEW, 18, 2);
+}
 
+static void test_pack_LPDLGTEMPLATEA(void)
+{
     /* LPDLGTEMPLATEA */
     TEST_TYPE(LPDLGTEMPLATEA, 4, 4);
     TEST_TYPE_POINTER(LPDLGTEMPLATEA, 18, 2);
+}
 
+static void test_pack_LPDLGTEMPLATEW(void)
+{
     /* LPDLGTEMPLATEW */
     TEST_TYPE(LPDLGTEMPLATEW, 4, 4);
     TEST_TYPE_POINTER(LPDLGTEMPLATEW, 18, 2);
+}
 
+static void test_pack_LPDRAWITEMSTRUCT(void)
+{
     /* LPDRAWITEMSTRUCT */
     TEST_TYPE(LPDRAWITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPDRAWITEMSTRUCT, 48, 4);
+}
 
+static void test_pack_LPDRAWTEXTPARAMS(void)
+{
     /* LPDRAWTEXTPARAMS */
     TEST_TYPE(LPDRAWTEXTPARAMS, 4, 4);
     TEST_TYPE_POINTER(LPDRAWTEXTPARAMS, 20, 4);
+}
 
+static void test_pack_LPEVENTMSG(void)
+{
     /* LPEVENTMSG */
     TEST_TYPE(LPEVENTMSG, 4, 4);
     TEST_TYPE_POINTER(LPEVENTMSG, 20, 4);
+}
 
+static void test_pack_LPFILTERKEYS(void)
+{
     /* LPFILTERKEYS */
     TEST_TYPE(LPFILTERKEYS, 4, 4);
     TEST_TYPE_POINTER(LPFILTERKEYS, 24, 4);
+}
 
+static void test_pack_LPHARDWAREHOOKSTRUCT(void)
+{
     /* LPHARDWAREHOOKSTRUCT */
     TEST_TYPE(LPHARDWAREHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPHARDWAREHOOKSTRUCT, 16, 4);
+}
 
+static void test_pack_LPHARDWAREINPUT(void)
+{
     /* LPHARDWAREINPUT */
     TEST_TYPE(LPHARDWAREINPUT, 4, 4);
     TEST_TYPE_POINTER(LPHARDWAREINPUT, 8, 4);
+}
 
+static void test_pack_LPHELPINFO(void)
+{
     /* LPHELPINFO */
     TEST_TYPE(LPHELPINFO, 4, 4);
     TEST_TYPE_POINTER(LPHELPINFO, 28, 4);
+}
 
+static void test_pack_LPHELPWININFOA(void)
+{
     /* LPHELPWININFOA */
     TEST_TYPE(LPHELPWININFOA, 4, 4);
     TEST_TYPE_POINTER(LPHELPWININFOA, 28, 4);
+}
 
+static void test_pack_LPHELPWININFOW(void)
+{
     /* LPHELPWININFOW */
     TEST_TYPE(LPHELPWININFOW, 4, 4);
     TEST_TYPE_POINTER(LPHELPWININFOW, 28, 4);
+}
 
+static void test_pack_LPHIGHCONTRASTA(void)
+{
     /* LPHIGHCONTRASTA */
     TEST_TYPE(LPHIGHCONTRASTA, 4, 4);
-    TEST_TYPE_POINTER(LPHIGHCONTRASTA, 12, 4);
+}
 
+static void test_pack_LPHIGHCONTRASTW(void)
+{
     /* LPHIGHCONTRASTW */
     TEST_TYPE(LPHIGHCONTRASTW, 4, 4);
     TEST_TYPE_POINTER(LPHIGHCONTRASTW, 12, 4);
+}
 
+static void test_pack_LPICONMETRICSA(void)
+{
     /* LPICONMETRICSA */
     TEST_TYPE(LPICONMETRICSA, 4, 4);
     TEST_TYPE_POINTER(LPICONMETRICSA, 76, 4);
+}
 
+static void test_pack_LPICONMETRICSW(void)
+{
     /* LPICONMETRICSW */
     TEST_TYPE(LPICONMETRICSW, 4, 4);
     TEST_TYPE_POINTER(LPICONMETRICSW, 108, 4);
+}
 
+static void test_pack_LPINPUT(void)
+{
     /* LPINPUT */
     TEST_TYPE(LPINPUT, 4, 4);
+}
 
+static void test_pack_LPKBDLLHOOKSTRUCT(void)
+{
     /* LPKBDLLHOOKSTRUCT */
     TEST_TYPE(LPKBDLLHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPKBDLLHOOKSTRUCT, 20, 4);
+}
 
+static void test_pack_LPKEYBDINPUT(void)
+{
     /* LPKEYBDINPUT */
     TEST_TYPE(LPKEYBDINPUT, 4, 4);
     TEST_TYPE_POINTER(LPKEYBDINPUT, 16, 4);
+}
 
+static void test_pack_LPMDICREATESTRUCTA(void)
+{
     /* LPMDICREATESTRUCTA */
     TEST_TYPE(LPMDICREATESTRUCTA, 4, 4);
     TEST_TYPE_POINTER(LPMDICREATESTRUCTA, 36, 4);
+}
 
+static void test_pack_LPMDICREATESTRUCTW(void)
+{
     /* LPMDICREATESTRUCTW */
     TEST_TYPE(LPMDICREATESTRUCTW, 4, 4);
     TEST_TYPE_POINTER(LPMDICREATESTRUCTW, 36, 4);
+}
 
+static void test_pack_LPMDINEXTMENU(void)
+{
     /* LPMDINEXTMENU */
     TEST_TYPE(LPMDINEXTMENU, 4, 4);
     TEST_TYPE_POINTER(LPMDINEXTMENU, 12, 4);
+}
 
+static void test_pack_LPMEASUREITEMSTRUCT(void)
+{
     /* LPMEASUREITEMSTRUCT */
     TEST_TYPE(LPMEASUREITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPMEASUREITEMSTRUCT, 24, 4);
+}
 
+static void test_pack_LPMENUINFO(void)
+{
     /* LPMENUINFO */
     TEST_TYPE(LPMENUINFO, 4, 4);
     TEST_TYPE_POINTER(LPMENUINFO, 28, 4);
+}
 
+static void test_pack_LPMENUITEMINFOA(void)
+{
     /* LPMENUITEMINFOA */
     TEST_TYPE(LPMENUITEMINFOA, 4, 4);
-    TEST_TYPE_POINTER(LPMENUITEMINFOA, 48, 4);
+}
 
+static void test_pack_LPMENUITEMINFOW(void)
+{
     /* LPMENUITEMINFOW */
     TEST_TYPE(LPMENUITEMINFOW, 4, 4);
     TEST_TYPE_POINTER(LPMENUITEMINFOW, 48, 4);
+}
 
+static void test_pack_LPMENUTEMPLATE(void)
+{
     /* LPMENUTEMPLATE */
     TEST_TYPE(LPMENUTEMPLATE, 4, 4);
+}
 
+static void test_pack_LPMINIMIZEDMETRICS(void)
+{
     /* LPMINIMIZEDMETRICS */
     TEST_TYPE(LPMINIMIZEDMETRICS, 4, 4);
     TEST_TYPE_POINTER(LPMINIMIZEDMETRICS, 20, 4);
+}
 
+static void test_pack_LPMINMAXINFO(void)
+{
     /* LPMINMAXINFO */
     TEST_TYPE(LPMINMAXINFO, 4, 4);
     TEST_TYPE_POINTER(LPMINMAXINFO, 40, 4);
+}
 
+static void test_pack_LPMONITORINFO(void)
+{
     /* LPMONITORINFO */
     TEST_TYPE(LPMONITORINFO, 4, 4);
     TEST_TYPE_POINTER(LPMONITORINFO, 40, 4);
+}
 
+static void test_pack_LPMONITORINFOEXA(void)
+{
     /* LPMONITORINFOEXA */
     TEST_TYPE(LPMONITORINFOEXA, 4, 4);
     TEST_TYPE_POINTER(LPMONITORINFOEXA, 72, 4);
+}
 
+static void test_pack_LPMONITORINFOEXW(void)
+{
     /* LPMONITORINFOEXW */
     TEST_TYPE(LPMONITORINFOEXW, 4, 4);
     TEST_TYPE_POINTER(LPMONITORINFOEXW, 104, 4);
+}
 
+static void test_pack_LPMOUSEHOOKSTRUCT(void)
+{
     /* LPMOUSEHOOKSTRUCT */
     TEST_TYPE(LPMOUSEHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPMOUSEHOOKSTRUCT, 20, 4);
+}
 
+static void test_pack_LPMOUSEINPUT(void)
+{
     /* LPMOUSEINPUT */
     TEST_TYPE(LPMOUSEINPUT, 4, 4);
     TEST_TYPE_POINTER(LPMOUSEINPUT, 24, 4);
+}
 
+static void test_pack_LPMOUSEKEYS(void)
+{
     /* LPMOUSEKEYS */
     TEST_TYPE(LPMOUSEKEYS, 4, 4);
     TEST_TYPE_POINTER(LPMOUSEKEYS, 28, 4);
+}
 
+static void test_pack_LPMSG(void)
+{
     /* LPMSG */
     TEST_TYPE(LPMSG, 4, 4);
     TEST_TYPE_POINTER(LPMSG, 28, 4);
+}
 
+static void test_pack_LPMSGBOXPARAMSA(void)
+{
     /* LPMSGBOXPARAMSA */
     TEST_TYPE(LPMSGBOXPARAMSA, 4, 4);
     TEST_TYPE_POINTER(LPMSGBOXPARAMSA, 40, 4);
+}
 
+static void test_pack_LPMSGBOXPARAMSW(void)
+{
     /* LPMSGBOXPARAMSW */
     TEST_TYPE(LPMSGBOXPARAMSW, 4, 4);
     TEST_TYPE_POINTER(LPMSGBOXPARAMSW, 40, 4);
+}
 
+static void test_pack_LPMSLLHOOKSTRUCT(void)
+{
     /* LPMSLLHOOKSTRUCT */
     TEST_TYPE(LPMSLLHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPMSLLHOOKSTRUCT, 24, 4);
+}
 
+static void test_pack_LPMULTIKEYHELPA(void)
+{
     /* LPMULTIKEYHELPA */
     TEST_TYPE(LPMULTIKEYHELPA, 4, 4);
     TEST_TYPE_POINTER(LPMULTIKEYHELPA, 8, 4);
+}
 
+static void test_pack_LPMULTIKEYHELPW(void)
+{
     /* LPMULTIKEYHELPW */
     TEST_TYPE(LPMULTIKEYHELPW, 4, 4);
     TEST_TYPE_POINTER(LPMULTIKEYHELPW, 8, 4);
+}
 
+static void test_pack_LPNCCALCSIZE_PARAMS(void)
+{
     /* LPNCCALCSIZE_PARAMS */
     TEST_TYPE(LPNCCALCSIZE_PARAMS, 4, 4);
     TEST_TYPE_POINTER(LPNCCALCSIZE_PARAMS, 52, 4);
+}
 
+static void test_pack_LPNMHDR(void)
+{
     /* LPNMHDR */
     TEST_TYPE(LPNMHDR, 4, 4);
     TEST_TYPE_POINTER(LPNMHDR, 12, 4);
+}
 
+static void test_pack_LPNONCLIENTMETRICSA(void)
+{
     /* LPNONCLIENTMETRICSA */
     TEST_TYPE(LPNONCLIENTMETRICSA, 4, 4);
     TEST_TYPE_POINTER(LPNONCLIENTMETRICSA, 340, 4);
+}
 
+static void test_pack_LPNONCLIENTMETRICSW(void)
+{
     /* LPNONCLIENTMETRICSW */
     TEST_TYPE(LPNONCLIENTMETRICSW, 4, 4);
     TEST_TYPE_POINTER(LPNONCLIENTMETRICSW, 500, 4);
+}
 
+static void test_pack_LPPAINTSTRUCT(void)
+{
     /* LPPAINTSTRUCT */
     TEST_TYPE(LPPAINTSTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPPAINTSTRUCT, 64, 4);
+}
 
+static void test_pack_LPSCROLLINFO(void)
+{
     /* LPSCROLLINFO */
     TEST_TYPE(LPSCROLLINFO, 4, 4);
     TEST_TYPE_POINTER(LPSCROLLINFO, 28, 4);
+}
 
+static void test_pack_LPSERIALKEYSA(void)
+{
     /* LPSERIALKEYSA */
     TEST_TYPE(LPSERIALKEYSA, 4, 4);
-    TEST_TYPE_POINTER(LPSERIALKEYSA, 28, 4);
+}
 
+static void test_pack_LPSERIALKEYSW(void)
+{
     /* LPSERIALKEYSW */
     TEST_TYPE(LPSERIALKEYSW, 4, 4);
     TEST_TYPE_POINTER(LPSERIALKEYSW, 28, 4);
+}
 
+static void test_pack_LPSOUNDSENTRYA(void)
+{
     /* LPSOUNDSENTRYA */
     TEST_TYPE(LPSOUNDSENTRYA, 4, 4);
-    TEST_TYPE_POINTER(LPSOUNDSENTRYA, 48, 4);
+}
 
+static void test_pack_LPSOUNDSENTRYW(void)
+{
     /* LPSOUNDSENTRYW */
     TEST_TYPE(LPSOUNDSENTRYW, 4, 4);
     TEST_TYPE_POINTER(LPSOUNDSENTRYW, 48, 4);
+}
 
+static void test_pack_LPSTICKYKEYS(void)
+{
     /* LPSTICKYKEYS */
     TEST_TYPE(LPSTICKYKEYS, 4, 4);
     TEST_TYPE_POINTER(LPSTICKYKEYS, 8, 4);
+}
 
+static void test_pack_LPSTYLESTRUCT(void)
+{
     /* LPSTYLESTRUCT */
     TEST_TYPE(LPSTYLESTRUCT, 4, 4);
     TEST_TYPE_POINTER(LPSTYLESTRUCT, 8, 4);
+}
 
+static void test_pack_LPTOGGLEKEYS(void)
+{
     /* LPTOGGLEKEYS */
     TEST_TYPE(LPTOGGLEKEYS, 4, 4);
     TEST_TYPE_POINTER(LPTOGGLEKEYS, 8, 4);
+}
 
+static void test_pack_LPTPMPARAMS(void)
+{
     /* LPTPMPARAMS */
     TEST_TYPE(LPTPMPARAMS, 4, 4);
     TEST_TYPE_POINTER(LPTPMPARAMS, 20, 4);
+}
 
+static void test_pack_LPTRACKMOUSEEVENT(void)
+{
     /* LPTRACKMOUSEEVENT */
     TEST_TYPE(LPTRACKMOUSEEVENT, 4, 4);
     TEST_TYPE_POINTER(LPTRACKMOUSEEVENT, 16, 4);
+}
 
+static void test_pack_LPWINDOWINFO(void)
+{
     /* LPWINDOWINFO */
     TEST_TYPE(LPWINDOWINFO, 4, 4);
+}
 
+static void test_pack_LPWINDOWPLACEMENT(void)
+{
     /* LPWINDOWPLACEMENT */
     TEST_TYPE(LPWINDOWPLACEMENT, 4, 4);
     TEST_TYPE_POINTER(LPWINDOWPLACEMENT, 44, 4);
+}
 
+static void test_pack_LPWINDOWPOS(void)
+{
     /* LPWINDOWPOS */
     TEST_TYPE(LPWINDOWPOS, 4, 4);
     TEST_TYPE_POINTER(LPWINDOWPOS, 28, 4);
+}
 
+static void test_pack_LPWNDCLASSA(void)
+{
     /* LPWNDCLASSA */
     TEST_TYPE(LPWNDCLASSA, 4, 4);
     TEST_TYPE_POINTER(LPWNDCLASSA, 40, 4);
+}
 
+static void test_pack_LPWNDCLASSEXA(void)
+{
     /* LPWNDCLASSEXA */
     TEST_TYPE(LPWNDCLASSEXA, 4, 4);
     TEST_TYPE_POINTER(LPWNDCLASSEXA, 48, 4);
+}
 
+static void test_pack_LPWNDCLASSEXW(void)
+{
     /* LPWNDCLASSEXW */
     TEST_TYPE(LPWNDCLASSEXW, 4, 4);
     TEST_TYPE_POINTER(LPWNDCLASSEXW, 48, 4);
+}
 
+static void test_pack_LPWNDCLASSW(void)
+{
     /* LPWNDCLASSW */
     TEST_TYPE(LPWNDCLASSW, 4, 4);
     TEST_TYPE_POINTER(LPWNDCLASSW, 40, 4);
+}
 
+static void test_pack_MDICREATESTRUCTA(void)
+{
     /* MDICREATESTRUCTA (pack 4) */
     TEST_TYPE(MDICREATESTRUCTA, 36, 4);
     TEST_FIELD(MDICREATESTRUCTA, LPCSTR, szClass, 0, 4, 4);
@@ -774,7 +1167,10 @@
     TEST_FIELD(MDICREATESTRUCTA, INT, cy, 24, 4, 4);
     TEST_FIELD(MDICREATESTRUCTA, DWORD, style, 28, 4, 4);
     TEST_FIELD(MDICREATESTRUCTA, LPARAM, lParam, 32, 4, 4);
+}
 
+static void test_pack_MDICREATESTRUCTW(void)
+{
     /* MDICREATESTRUCTW (pack 4) */
     TEST_TYPE(MDICREATESTRUCTW, 36, 4);
     TEST_FIELD(MDICREATESTRUCTW, LPCWSTR, szClass, 0, 4, 4);
@@ -786,13 +1182,19 @@
     TEST_FIELD(MDICREATESTRUCTW, INT, cy, 24, 4, 4);
     TEST_FIELD(MDICREATESTRUCTW, DWORD, style, 28, 4, 4);
     TEST_FIELD(MDICREATESTRUCTW, LPARAM, lParam, 32, 4, 4);
+}
 
+static void test_pack_MDINEXTMENU(void)
+{
     /* MDINEXTMENU (pack 4) */
     TEST_TYPE(MDINEXTMENU, 12, 4);
     TEST_FIELD(MDINEXTMENU, HMENU, hmenuIn, 0, 4, 4);
     TEST_FIELD(MDINEXTMENU, HMENU, hmenuNext, 4, 4, 4);
     TEST_FIELD(MDINEXTMENU, HWND, hwndNext, 8, 4, 4);
+}
 
+static void test_pack_MEASUREITEMSTRUCT(void)
+{
     /* MEASUREITEMSTRUCT (pack 4) */
     TEST_TYPE(MEASUREITEMSTRUCT, 24, 4);
     TEST_FIELD(MEASUREITEMSTRUCT, UINT, CtlType, 0, 4, 4);
@@ -801,7 +1203,10 @@
     TEST_FIELD(MEASUREITEMSTRUCT, UINT, itemWidth, 12, 4, 4);
     TEST_FIELD(MEASUREITEMSTRUCT, UINT, itemHeight, 16, 4, 4);
     TEST_FIELD(MEASUREITEMSTRUCT, ULONG_PTR, itemData, 20, 4, 4);
+}
 
+static void test_pack_MENUINFO(void)
+{
     /* MENUINFO (pack 4) */
     TEST_TYPE(MENUINFO, 28, 4);
     TEST_FIELD(MENUINFO, DWORD, cbSize, 0, 4, 4);
@@ -811,9 +1216,11 @@
     TEST_FIELD(MENUINFO, HBRUSH, hbrBack, 16, 4, 4);
     TEST_FIELD(MENUINFO, DWORD, dwContextHelpID, 20, 4, 4);
     TEST_FIELD(MENUINFO, ULONG_PTR, dwMenuData, 24, 4, 4);
+}
 
+static void test_pack_MENUITEMINFOA(void)
+{
     /* MENUITEMINFOA (pack 4) */
-    TEST_TYPE(MENUITEMINFOA, 48, 4);
     TEST_FIELD(MENUITEMINFOA, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(MENUITEMINFOA, UINT, fMask, 4, 4, 4);
     TEST_FIELD(MENUITEMINFOA, UINT, fType, 8, 4, 4);
@@ -823,10 +1230,10 @@
     TEST_FIELD(MENUITEMINFOA, HBITMAP, hbmpChecked, 24, 4, 4);
     TEST_FIELD(MENUITEMINFOA, HBITMAP, hbmpUnchecked, 28, 4, 4);
     TEST_FIELD(MENUITEMINFOA, ULONG_PTR, dwItemData, 32, 4, 4);
-    TEST_FIELD(MENUITEMINFOA, LPSTR, dwTypeData, 36, 4, 4);
-    TEST_FIELD(MENUITEMINFOA, UINT, cch, 40, 4, 4);
-    TEST_FIELD(MENUITEMINFOA, HBITMAP, hbmpItem, 44, 4, 4);
+}
 
+static void test_pack_MENUITEMINFOW(void)
+{
     /* MENUITEMINFOW (pack 4) */
     TEST_TYPE(MENUITEMINFOW, 48, 4);
     TEST_FIELD(MENUITEMINFOW, UINT, cbSize, 0, 4, 4);
@@ -841,20 +1248,32 @@
     TEST_FIELD(MENUITEMINFOW, LPWSTR, dwTypeData, 36, 4, 4);
     TEST_FIELD(MENUITEMINFOW, UINT, cch, 40, 4, 4);
     TEST_FIELD(MENUITEMINFOW, HBITMAP, hbmpItem, 44, 4, 4);
+}
 
+static void test_pack_MENUITEMTEMPLATE(void)
+{
     /* MENUITEMTEMPLATE (pack 4) */
     TEST_TYPE(MENUITEMTEMPLATE, 6, 2);
     TEST_FIELD(MENUITEMTEMPLATE, WORD, mtOption, 0, 2, 2);
     TEST_FIELD(MENUITEMTEMPLATE, WORD, mtID, 2, 2, 2);
     TEST_FIELD(MENUITEMTEMPLATE, WCHAR[1], mtString, 4, 2, 2);
+}
 
+static void test_pack_MENUITEMTEMPLATEHEADER(void)
+{
     /* MENUITEMTEMPLATEHEADER (pack 4) */
     TEST_TYPE(MENUITEMTEMPLATEHEADER, 4, 2);
     TEST_FIELD(MENUITEMTEMPLATEHEADER, WORD, versionNumber, 0, 2, 2);
     TEST_FIELD(MENUITEMTEMPLATEHEADER, WORD, offset, 2, 2, 2);
+}
 
+static void test_pack_MENUTEMPLATE(void)
+{
     /* MENUTEMPLATE */
+}
 
+static void test_pack_MINIMIZEDMETRICS(void)
+{
     /* MINIMIZEDMETRICS (pack 4) */
     TEST_TYPE(MINIMIZEDMETRICS, 20, 4);
     TEST_FIELD(MINIMIZEDMETRICS, UINT, cbSize, 0, 4, 4);
@@ -862,7 +1281,10 @@
     TEST_FIELD(MINIMIZEDMETRICS, int, iHorzGap, 8, 4, 4);
     TEST_FIELD(MINIMIZEDMETRICS, int, iVertGap, 12, 4, 4);
     TEST_FIELD(MINIMIZEDMETRICS, int, iArrange, 16, 4, 4);
+}
 
+static void test_pack_MINMAXINFO(void)
+{
     /* MINMAXINFO (pack 4) */
     TEST_TYPE(MINMAXINFO, 40, 4);
     TEST_FIELD(MINMAXINFO, POINT, ptReserved, 0, 8, 4);
@@ -870,16 +1292,26 @@
     TEST_FIELD(MINMAXINFO, POINT, ptMaxPosition, 16, 8, 4);
     TEST_FIELD(MINMAXINFO, POINT, ptMinTrackSize, 24, 8, 4);
     TEST_FIELD(MINMAXINFO, POINT, ptMaxTrackSize, 32, 8, 4);
+}
 
+static void test_pack_MONITORENUMPROC(void)
+{
     /* MONITORENUMPROC */
+    TEST_TYPE(MONITORENUMPROC, 4, 4);
+}
 
+static void test_pack_MONITORINFO(void)
+{
     /* MONITORINFO (pack 4) */
     TEST_TYPE(MONITORINFO, 40, 4);
     TEST_FIELD(MONITORINFO, DWORD, cbSize, 0, 4, 4);
     TEST_FIELD(MONITORINFO, RECT, rcMonitor, 4, 16, 4);
     TEST_FIELD(MONITORINFO, RECT, rcWork, 20, 16, 4);
     TEST_FIELD(MONITORINFO, DWORD, dwFlags, 36, 4, 4);
+}
 
+static void test_pack_MONITORINFOEXA(void)
+{
     /* MONITORINFOEXA (pack 4) */
     TEST_TYPE(MONITORINFOEXA, 72, 4);
 #ifdef NONAMELESSSTRUCT
@@ -891,7 +1323,10 @@
     TEST_FIELD(MONITORINFOEXA, DWORD, dwFlags, 36, 4, 4);
 #endif
     TEST_FIELD(MONITORINFOEXA, CHAR[CCHDEVICENAME], szDevice, 40, 32, 1);
+}
 
+static void test_pack_MONITORINFOEXW(void)
+{
     /* MONITORINFOEXW (pack 4) */
     TEST_TYPE(MONITORINFOEXW, 104, 4);
 #ifdef NONAMELESSSTRUCT
@@ -903,14 +1338,20 @@
     TEST_FIELD(MONITORINFOEXW, DWORD, dwFlags, 36, 4, 4);
 #endif
     TEST_FIELD(MONITORINFOEXW, WCHAR[CCHDEVICENAME], szDevice, 40, 64, 2);
+}
 
+static void test_pack_MOUSEHOOKSTRUCT(void)
+{
     /* MOUSEHOOKSTRUCT (pack 4) */
     TEST_TYPE(MOUSEHOOKSTRUCT, 20, 4);
     TEST_FIELD(MOUSEHOOKSTRUCT, POINT, pt, 0, 8, 4);
     TEST_FIELD(MOUSEHOOKSTRUCT, HWND, hwnd, 8, 4, 4);
     TEST_FIELD(MOUSEHOOKSTRUCT, UINT, wHitTestCode, 12, 4, 4);
     TEST_FIELD(MOUSEHOOKSTRUCT, ULONG_PTR, dwExtraInfo, 16, 4, 4);
+}
 
+static void test_pack_MOUSEINPUT(void)
+{
     /* MOUSEINPUT (pack 4) */
     TEST_TYPE(MOUSEINPUT, 24, 4);
     TEST_FIELD(MOUSEINPUT, LONG, dx, 0, 4, 4);
@@ -919,7 +1360,10 @@
     TEST_FIELD(MOUSEINPUT, DWORD, dwFlags, 12, 4, 4);
     TEST_FIELD(MOUSEINPUT, DWORD, time, 16, 4, 4);
     TEST_FIELD(MOUSEINPUT, ULONG_PTR, dwExtraInfo, 20, 4, 4);
+}
 
+static void test_pack_MOUSEKEYS(void)
+{
     /* MOUSEKEYS (pack 4) */
     TEST_TYPE(MOUSEKEYS, 28, 4);
     TEST_FIELD(MOUSEKEYS, UINT, cbSize, 0, 4, 4);
@@ -929,7 +1373,10 @@
     TEST_FIELD(MOUSEKEYS, DWORD, iCtrlSpeed, 16, 4, 4);
     TEST_FIELD(MOUSEKEYS, DWORD, dwReserved1, 20, 4, 4);
     TEST_FIELD(MOUSEKEYS, DWORD, dwReserved2, 24, 4, 4);
+}
 
+static void test_pack_MSG(void)
+{
     /* MSG (pack 4) */
     TEST_TYPE(MSG, 28, 4);
     TEST_FIELD(MSG, HWND, hwnd, 0, 4, 4);
@@ -938,9 +1385,16 @@
     TEST_FIELD(MSG, LPARAM, lParam, 12, 4, 4);
     TEST_FIELD(MSG, DWORD, time, 16, 4, 4);
     TEST_FIELD(MSG, POINT, pt, 20, 8, 4);
+}
 
+static void test_pack_MSGBOXCALLBACK(void)
+{
     /* MSGBOXCALLBACK */
+    TEST_TYPE(MSGBOXCALLBACK, 4, 4);
+}
 
+static void test_pack_MSGBOXPARAMSA(void)
+{
     /* MSGBOXPARAMSA (pack 4) */
     TEST_TYPE(MSGBOXPARAMSA, 40, 4);
     TEST_FIELD(MSGBOXPARAMSA, UINT, cbSize, 0, 4, 4);
@@ -953,7 +1407,10 @@
     TEST_FIELD(MSGBOXPARAMSA, DWORD_PTR, dwContextHelpId, 28, 4, 4);
     TEST_FIELD(MSGBOXPARAMSA, MSGBOXCALLBACK, lpfnMsgBoxCallback, 32, 4, 4);
     TEST_FIELD(MSGBOXPARAMSA, DWORD, dwLanguageId, 36, 4, 4);
+}
 
+static void test_pack_MSGBOXPARAMSW(void)
+{
     /* MSGBOXPARAMSW (pack 4) */
     TEST_TYPE(MSGBOXPARAMSW, 40, 4);
     TEST_FIELD(MSGBOXPARAMSW, UINT, cbSize, 0, 4, 4);
@@ -966,7 +1423,10 @@
     TEST_FIELD(MSGBOXPARAMSW, DWORD_PTR, dwContextHelpId, 28, 4, 4);
     TEST_FIELD(MSGBOXPARAMSW, MSGBOXCALLBACK, lpfnMsgBoxCallback, 32, 4, 4);
     TEST_FIELD(MSGBOXPARAMSW, DWORD, dwLanguageId, 36, 4, 4);
+}
 
+static void test_pack_MSLLHOOKSTRUCT(void)
+{
     /* MSLLHOOKSTRUCT (pack 4) */
     TEST_TYPE(MSLLHOOKSTRUCT, 24, 4);
     TEST_FIELD(MSLLHOOKSTRUCT, POINT, pt, 0, 8, 4);
@@ -974,42 +1434,57 @@
     TEST_FIELD(MSLLHOOKSTRUCT, DWORD, flags, 12, 4, 4);
     TEST_FIELD(MSLLHOOKSTRUCT, DWORD, time, 16, 4, 4);
     TEST_FIELD(MSLLHOOKSTRUCT, ULONG_PTR, dwExtraInfo, 20, 4, 4);
+}
 
+static void test_pack_MULTIKEYHELPA(void)
+{
     /* MULTIKEYHELPA (pack 4) */
     TEST_TYPE(MULTIKEYHELPA, 8, 4);
     TEST_FIELD(MULTIKEYHELPA, DWORD, mkSize, 0, 4, 4);
     TEST_FIELD(MULTIKEYHELPA, CHAR, mkKeylist, 4, 1, 1);
     TEST_FIELD(MULTIKEYHELPA, CHAR[1], szKeyphrase, 5, 1, 1);
+}
 
+static void test_pack_MULTIKEYHELPW(void)
+{
     /* MULTIKEYHELPW (pack 4) */
     TEST_TYPE(MULTIKEYHELPW, 8, 4);
     TEST_FIELD(MULTIKEYHELPW, DWORD, mkSize, 0, 4, 4);
     TEST_FIELD(MULTIKEYHELPW, WCHAR, mkKeylist, 4, 2, 2);
     TEST_FIELD(MULTIKEYHELPW, WCHAR[1], szKeyphrase, 6, 2, 2);
+}
 
+static void test_pack_NAMEENUMPROCA(void)
+{
     /* NAMEENUMPROCA */
     TEST_TYPE(NAMEENUMPROCA, 4, 4);
+}
 
-    /* NAMEENUMPROCA */
-    TEST_TYPE(NAMEENUMPROCA, 4, 4);
-
+static void test_pack_NAMEENUMPROCW(void)
+{
     /* NAMEENUMPROCW */
     TEST_TYPE(NAMEENUMPROCW, 4, 4);
+}
 
-    /* NAMEENUMPROCW */
-    TEST_TYPE(NAMEENUMPROCW, 4, 4);
-
+static void test_pack_NCCALCSIZE_PARAMS(void)
+{
     /* NCCALCSIZE_PARAMS (pack 4) */
     TEST_TYPE(NCCALCSIZE_PARAMS, 52, 4);
     TEST_FIELD(NCCALCSIZE_PARAMS, RECT[3], rgrc, 0, 48, 4);
     TEST_FIELD(NCCALCSIZE_PARAMS, WINDOWPOS *, lppos, 48, 4, 4);
+}
 
+static void test_pack_NMHDR(void)
+{
     /* NMHDR (pack 4) */
     TEST_TYPE(NMHDR, 12, 4);
     TEST_FIELD(NMHDR, HWND, hwndFrom, 0, 4, 4);
     TEST_FIELD(NMHDR, UINT_PTR, idFrom, 4, 4, 4);
     TEST_FIELD(NMHDR, UINT, code, 8, 4, 4);
+}
 
+static void test_pack_NONCLIENTMETRICSA(void)
+{
     /* NONCLIENTMETRICSA (pack 4) */
     TEST_TYPE(NONCLIENTMETRICSA, 340, 4);
     TEST_FIELD(NONCLIENTMETRICSA, UINT, cbSize, 0, 4, 4);
@@ -1027,7 +1502,10 @@
     TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfMenuFont, 160, 60, 4);
     TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfStatusFont, 220, 60, 4);
     TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfMessageFont, 280, 60, 4);
+}
 
+static void test_pack_NONCLIENTMETRICSW(void)
+{
     /* NONCLIENTMETRICSW (pack 4) */
     TEST_TYPE(NONCLIENTMETRICSW, 500, 4);
     TEST_FIELD(NONCLIENTMETRICSW, UINT, cbSize, 0, 4, 4);
@@ -1045,7 +1523,10 @@
     TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfMenuFont, 224, 92, 4);
     TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfStatusFont, 316, 92, 4);
     TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfMessageFont, 408, 92, 4);
+}
 
+static void test_pack_PAINTSTRUCT(void)
+{
     /* PAINTSTRUCT (pack 4) */
     TEST_TYPE(PAINTSTRUCT, 64, 4);
     TEST_FIELD(PAINTSTRUCT, HDC, hdc, 0, 4, 4);
@@ -1054,221 +1535,368 @@
     TEST_FIELD(PAINTSTRUCT, BOOL, fRestore, 24, 4, 4);
     TEST_FIELD(PAINTSTRUCT, BOOL, fIncUpdate, 28, 4, 4);
     TEST_FIELD(PAINTSTRUCT, BYTE[32], rgbReserved, 32, 32, 1);
+}
 
+static void test_pack_PCOMBOBOXINFO(void)
+{
     /* PCOMBOBOXINFO */
     TEST_TYPE(PCOMBOBOXINFO, 4, 4);
     TEST_TYPE_POINTER(PCOMBOBOXINFO, 52, 4);
+}
 
+static void test_pack_PCOMPAREITEMSTRUCT(void)
+{
     /* PCOMPAREITEMSTRUCT */
     TEST_TYPE(PCOMPAREITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PCOMPAREITEMSTRUCT, 32, 4);
+}
 
+static void test_pack_PCOPYDATASTRUCT(void)
+{
     /* PCOPYDATASTRUCT */
     TEST_TYPE(PCOPYDATASTRUCT, 4, 4);
     TEST_TYPE_POINTER(PCOPYDATASTRUCT, 12, 4);
+}
 
+static void test_pack_PCURSORINFO(void)
+{
     /* PCURSORINFO */
     TEST_TYPE(PCURSORINFO, 4, 4);
     TEST_TYPE_POINTER(PCURSORINFO, 20, 4);
+}
 
+static void test_pack_PCWPRETSTRUCT(void)
+{
     /* PCWPRETSTRUCT */
     TEST_TYPE(PCWPRETSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PCWPRETSTRUCT, 20, 4);
+}
 
+static void test_pack_PCWPSTRUCT(void)
+{
     /* PCWPSTRUCT */
     TEST_TYPE(PCWPSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PCWPSTRUCT, 16, 4);
+}
 
+static void test_pack_PDEBUGHOOKINFO(void)
+{
     /* PDEBUGHOOKINFO */
     TEST_TYPE(PDEBUGHOOKINFO, 4, 4);
     TEST_TYPE_POINTER(PDEBUGHOOKINFO, 20, 4);
+}
 
+static void test_pack_PDELETEITEMSTRUCT(void)
+{
     /* PDELETEITEMSTRUCT */
     TEST_TYPE(PDELETEITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PDELETEITEMSTRUCT, 20, 4);
+}
 
+static void test_pack_PDLGITEMTEMPLATEA(void)
+{
     /* PDLGITEMTEMPLATEA */
     TEST_TYPE(PDLGITEMTEMPLATEA, 4, 4);
     TEST_TYPE_POINTER(PDLGITEMTEMPLATEA, 18, 2);
+}
 
+static void test_pack_PDLGITEMTEMPLATEW(void)
+{
     /* PDLGITEMTEMPLATEW */
     TEST_TYPE(PDLGITEMTEMPLATEW, 4, 4);
     TEST_TYPE_POINTER(PDLGITEMTEMPLATEW, 18, 2);
+}
 
+static void test_pack_PDRAWITEMSTRUCT(void)
+{
     /* PDRAWITEMSTRUCT */
     TEST_TYPE(PDRAWITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PDRAWITEMSTRUCT, 48, 4);
+}
 
+static void test_pack_PEVENTMSG(void)
+{
     /* PEVENTMSG */
     TEST_TYPE(PEVENTMSG, 4, 4);
     TEST_TYPE_POINTER(PEVENTMSG, 20, 4);
+}
 
+static void test_pack_PGUITHREADINFO(void)
+{
     /* PGUITHREADINFO */
     TEST_TYPE(PGUITHREADINFO, 4, 4);
     TEST_TYPE_POINTER(PGUITHREADINFO, 48, 4);
+}
 
+static void test_pack_PHARDWAREHOOKSTRUCT(void)
+{
     /* PHARDWAREHOOKSTRUCT */
     TEST_TYPE(PHARDWAREHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PHARDWAREHOOKSTRUCT, 16, 4);
+}
 
+static void test_pack_PHARDWAREINPUT(void)
+{
     /* PHARDWAREINPUT */
     TEST_TYPE(PHARDWAREINPUT, 4, 4);
     TEST_TYPE_POINTER(PHARDWAREINPUT, 8, 4);
+}
 
+static void test_pack_PHDEVNOTIFY(void)
+{
     /* PHDEVNOTIFY */
     TEST_TYPE(PHDEVNOTIFY, 4, 4);
     TEST_TYPE_POINTER(PHDEVNOTIFY, 4, 4);
+}
 
+static void test_pack_PHELPWININFOA(void)
+{
     /* PHELPWININFOA */
     TEST_TYPE(PHELPWININFOA, 4, 4);
     TEST_TYPE_POINTER(PHELPWININFOA, 28, 4);
+}
 
+static void test_pack_PHELPWININFOW(void)
+{
     /* PHELPWININFOW */
     TEST_TYPE(PHELPWININFOW, 4, 4);
     TEST_TYPE_POINTER(PHELPWININFOW, 28, 4);
+}
 
+static void test_pack_PICONINFO(void)
+{
     /* PICONINFO */
     TEST_TYPE(PICONINFO, 4, 4);
     TEST_TYPE_POINTER(PICONINFO, 20, 4);
+}
 
+static void test_pack_PICONMETRICSA(void)
+{
     /* PICONMETRICSA */
     TEST_TYPE(PICONMETRICSA, 4, 4);
     TEST_TYPE_POINTER(PICONMETRICSA, 76, 4);
+}
 
+static void test_pack_PICONMETRICSW(void)
+{
     /* PICONMETRICSW */
     TEST_TYPE(PICONMETRICSW, 4, 4);
     TEST_TYPE_POINTER(PICONMETRICSW, 108, 4);
+}
 
+static void test_pack_PINPUT(void)
+{
     /* PINPUT */
     TEST_TYPE(PINPUT, 4, 4);
+}
 
+static void test_pack_PKBDLLHOOKSTRUCT(void)
+{
     /* PKBDLLHOOKSTRUCT */
     TEST_TYPE(PKBDLLHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PKBDLLHOOKSTRUCT, 20, 4);
+}
 
+static void test_pack_PKEYBDINPUT(void)
+{
     /* PKEYBDINPUT */
     TEST_TYPE(PKEYBDINPUT, 4, 4);
     TEST_TYPE_POINTER(PKEYBDINPUT, 16, 4);
+}
 
+static void test_pack_PMDINEXTMENU(void)
+{
     /* PMDINEXTMENU */
     TEST_TYPE(PMDINEXTMENU, 4, 4);
     TEST_TYPE_POINTER(PMDINEXTMENU, 12, 4);
+}
 
+static void test_pack_PMEASUREITEMSTRUCT(void)
+{
     /* PMEASUREITEMSTRUCT */
     TEST_TYPE(PMEASUREITEMSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PMEASUREITEMSTRUCT, 24, 4);
+}
 
+static void test_pack_PMENUITEMTEMPLATE(void)
+{
     /* PMENUITEMTEMPLATE */
     TEST_TYPE(PMENUITEMTEMPLATE, 4, 4);
     TEST_TYPE_POINTER(PMENUITEMTEMPLATE, 6, 2);
+}
 
+static void test_pack_PMENUITEMTEMPLATEHEADER(void)
+{
     /* PMENUITEMTEMPLATEHEADER */
     TEST_TYPE(PMENUITEMTEMPLATEHEADER, 4, 4);
     TEST_TYPE_POINTER(PMENUITEMTEMPLATEHEADER, 4, 2);
+}
 
+static void test_pack_PMINIMIZEDMETRICS(void)
+{
     /* PMINIMIZEDMETRICS */
     TEST_TYPE(PMINIMIZEDMETRICS, 4, 4);
     TEST_TYPE_POINTER(PMINIMIZEDMETRICS, 20, 4);
+}
 
+static void test_pack_PMINMAXINFO(void)
+{
     /* PMINMAXINFO */
     TEST_TYPE(PMINMAXINFO, 4, 4);
     TEST_TYPE_POINTER(PMINMAXINFO, 40, 4);
+}
 
+static void test_pack_PMOUSEHOOKSTRUCT(void)
+{
     /* PMOUSEHOOKSTRUCT */
     TEST_TYPE(PMOUSEHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PMOUSEHOOKSTRUCT, 20, 4);
+}
 
+static void test_pack_PMOUSEINPUT(void)
+{
     /* PMOUSEINPUT */
     TEST_TYPE(PMOUSEINPUT, 4, 4);
     TEST_TYPE_POINTER(PMOUSEINPUT, 24, 4);
+}
 
+static void test_pack_PMSG(void)
+{
     /* PMSG */
     TEST_TYPE(PMSG, 4, 4);
     TEST_TYPE_POINTER(PMSG, 28, 4);
+}
 
+static void test_pack_PMSGBOXPARAMSA(void)
+{
     /* PMSGBOXPARAMSA */
     TEST_TYPE(PMSGBOXPARAMSA, 4, 4);
     TEST_TYPE_POINTER(PMSGBOXPARAMSA, 40, 4);
+}
 
+static void test_pack_PMSGBOXPARAMSW(void)
+{
     /* PMSGBOXPARAMSW */
     TEST_TYPE(PMSGBOXPARAMSW, 4, 4);
     TEST_TYPE_POINTER(PMSGBOXPARAMSW, 40, 4);
+}
 
+static void test_pack_PMSLLHOOKSTRUCT(void)
+{
     /* PMSLLHOOKSTRUCT */
     TEST_TYPE(PMSLLHOOKSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PMSLLHOOKSTRUCT, 24, 4);
+}
 
+static void test_pack_PMULTIKEYHELPA(void)
+{
     /* PMULTIKEYHELPA */
     TEST_TYPE(PMULTIKEYHELPA, 4, 4);
     TEST_TYPE_POINTER(PMULTIKEYHELPA, 8, 4);
+}
 
+static void test_pack_PMULTIKEYHELPW(void)
+{
     /* PMULTIKEYHELPW */
     TEST_TYPE(PMULTIKEYHELPW, 4, 4);
     TEST_TYPE_POINTER(PMULTIKEYHELPW, 8, 4);
+}
 
+static void test_pack_PNONCLIENTMETRICSA(void)
+{
     /* PNONCLIENTMETRICSA */
     TEST_TYPE(PNONCLIENTMETRICSA, 4, 4);
     TEST_TYPE_POINTER(PNONCLIENTMETRICSA, 340, 4);
+}
 
+static void test_pack_PNONCLIENTMETRICSW(void)
+{
     /* PNONCLIENTMETRICSW */
     TEST_TYPE(PNONCLIENTMETRICSW, 4, 4);
     TEST_TYPE_POINTER(PNONCLIENTMETRICSW, 500, 4);
+}
 
+static void test_pack_PPAINTSTRUCT(void)
+{
     /* PPAINTSTRUCT */
     TEST_TYPE(PPAINTSTRUCT, 4, 4);
     TEST_TYPE_POINTER(PPAINTSTRUCT, 64, 4);
+}
 
+static void test_pack_PROPENUMPROCA(void)
+{
     /* PROPENUMPROCA */
     TEST_TYPE(PROPENUMPROCA, 4, 4);
+}
 
-    /* PROPENUMPROCA */
-    TEST_TYPE(PROPENUMPROCA, 4, 4);
-
+static void test_pack_PROPENUMPROCEXA(void)
+{
     /* PROPENUMPROCEXA */
     TEST_TYPE(PROPENUMPROCEXA, 4, 4);
+}
 
-    /* PROPENUMPROCEXA */
-    TEST_TYPE(PROPENUMPROCEXA, 4, 4);
-
+static void test_pack_PROPENUMPROCEXW(void)
+{
     /* PROPENUMPROCEXW */
     TEST_TYPE(PROPENUMPROCEXW, 4, 4);
+}
 
-    /* PROPENUMPROCEXW */
-    TEST_TYPE(PROPENUMPROCEXW, 4, 4);
-
+static void test_pack_PROPENUMPROCW(void)
+{
     /* PROPENUMPROCW */
     TEST_TYPE(PROPENUMPROCW, 4, 4);
+}
 
-    /* PROPENUMPROCW */
-    TEST_TYPE(PROPENUMPROCW, 4, 4);
-
+static void test_pack_PWINDOWINFO(void)
+{
     /* PWINDOWINFO */
     TEST_TYPE(PWINDOWINFO, 4, 4);
+}
 
+static void test_pack_PWINDOWPLACEMENT(void)
+{
     /* PWINDOWPLACEMENT */
     TEST_TYPE(PWINDOWPLACEMENT, 4, 4);
     TEST_TYPE_POINTER(PWINDOWPLACEMENT, 44, 4);
+}
 
+static void test_pack_PWINDOWPOS(void)
+{
     /* PWINDOWPOS */
     TEST_TYPE(PWINDOWPOS, 4, 4);
     TEST_TYPE_POINTER(PWINDOWPOS, 28, 4);
+}
 
+static void test_pack_PWNDCLASSA(void)
+{
     /* PWNDCLASSA */
     TEST_TYPE(PWNDCLASSA, 4, 4);
     TEST_TYPE_POINTER(PWNDCLASSA, 40, 4);
+}
 
+static void test_pack_PWNDCLASSEXA(void)
+{
     /* PWNDCLASSEXA */
     TEST_TYPE(PWNDCLASSEXA, 4, 4);
     TEST_TYPE_POINTER(PWNDCLASSEXA, 48, 4);
+}
 
+static void test_pack_PWNDCLASSEXW(void)
+{
     /* PWNDCLASSEXW */
     TEST_TYPE(PWNDCLASSEXW, 4, 4);
     TEST_TYPE_POINTER(PWNDCLASSEXW, 48, 4);
+}
 
+static void test_pack_PWNDCLASSW(void)
+{
     /* PWNDCLASSW */
     TEST_TYPE(PWNDCLASSW, 4, 4);
     TEST_TYPE_POINTER(PWNDCLASSW, 40, 4);
+}
 
+static void test_pack_SCROLLINFO(void)
+{
     /* SCROLLINFO (pack 4) */
     TEST_TYPE(SCROLLINFO, 28, 4);
     TEST_FIELD(SCROLLINFO, UINT, cbSize, 0, 4, 4);
@@ -1278,23 +1906,23 @@
     TEST_FIELD(SCROLLINFO, UINT, nPage, 16, 4, 4);
     TEST_FIELD(SCROLLINFO, INT, nPos, 20, 4, 4);
     TEST_FIELD(SCROLLINFO, INT, nTrackPos, 24, 4, 4);
+}
 
+static void test_pack_SENDASYNCPROC(void)
+{
     /* SENDASYNCPROC */
     TEST_TYPE(SENDASYNCPROC, 4, 4);
+}
 
-    /* SENDASYNCPROC */
-    TEST_TYPE(SENDASYNCPROC, 4, 4);
-
+static void test_pack_SERIALKEYSA(void)
+{
     /* SERIALKEYSA (pack 4) */
-    TEST_TYPE(SERIALKEYSA, 28, 4);
     TEST_FIELD(SERIALKEYSA, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(SERIALKEYSA, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(SERIALKEYSA, LPSTR, lpszActivePort, 8, 4, 4);
-    TEST_FIELD(SERIALKEYSA, LPSTR, lpszPort, 12, 4, 4);
-    TEST_FIELD(SERIALKEYSA, UINT, iBaudRate, 16, 4, 4);
-    TEST_FIELD(SERIALKEYSA, UINT, iPortState, 20, 4, 4);
-    TEST_FIELD(SERIALKEYSA, UINT, iActive, 24, 4, 4);
+}
 
+static void test_pack_SERIALKEYSW(void)
+{
     /* SERIALKEYSW (pack 4) */
     TEST_TYPE(SERIALKEYSW, 28, 4);
     TEST_FIELD(SERIALKEYSW, UINT, cbSize, 0, 4, 4);
@@ -1304,9 +1932,11 @@
     TEST_FIELD(SERIALKEYSW, UINT, iBaudRate, 16, 4, 4);
     TEST_FIELD(SERIALKEYSW, UINT, iPortState, 20, 4, 4);
     TEST_FIELD(SERIALKEYSW, UINT, iActive, 24, 4, 4);
+}
 
+static void test_pack_SOUNDSENTRYA(void)
+{
     /* SOUNDSENTRYA (pack 4) */
-    TEST_TYPE(SOUNDSENTRYA, 48, 4);
     TEST_FIELD(SOUNDSENTRYA, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(SOUNDSENTRYA, DWORD, dwFlags, 4, 4, 4);
     TEST_FIELD(SOUNDSENTRYA, DWORD, iFSTextEffect, 8, 4, 4);
@@ -1317,9 +1947,10 @@
     TEST_FIELD(SOUNDSENTRYA, DWORD, iFSGrafEffectColor, 28, 4, 4);
     TEST_FIELD(SOUNDSENTRYA, DWORD, iWindowsEffect, 32, 4, 4);
     TEST_FIELD(SOUNDSENTRYA, DWORD, iWindowsEffectMSec, 36, 4, 4);
-    TEST_FIELD(SOUNDSENTRYA, LPSTR, lpszWindowsEffectDLL, 40, 4, 4);
-    TEST_FIELD(SOUNDSENTRYA, DWORD, iWindowsEffectOrdinal, 44, 4, 4);
+}
 
+static void test_pack_SOUNDSENTRYW(void)
+{
     /* SOUNDSENTRYW (pack 4) */
     TEST_TYPE(SOUNDSENTRYW, 48, 4);
     TEST_FIELD(SOUNDSENTRYW, UINT, cbSize, 0, 4, 4);
@@ -1334,40 +1965,58 @@
     TEST_FIELD(SOUNDSENTRYW, DWORD, iWindowsEffectMSec, 36, 4, 4);
     TEST_FIELD(SOUNDSENTRYW, LPWSTR, lpszWindowsEffectDLL, 40, 4, 4);
     TEST_FIELD(SOUNDSENTRYW, DWORD, iWindowsEffectOrdinal, 44, 4, 4);
+}
 
+static void test_pack_STICKYKEYS(void)
+{
     /* STICKYKEYS (pack 4) */
     TEST_TYPE(STICKYKEYS, 8, 4);
     TEST_FIELD(STICKYKEYS, DWORD, cbSize, 0, 4, 4);
     TEST_FIELD(STICKYKEYS, DWORD, dwFlags, 4, 4, 4);
+}
 
+static void test_pack_STYLESTRUCT(void)
+{
     /* STYLESTRUCT (pack 4) */
     TEST_TYPE(STYLESTRUCT, 8, 4);
     TEST_FIELD(STYLESTRUCT, DWORD, styleOld, 0, 4, 4);
     TEST_FIELD(STYLESTRUCT, DWORD, styleNew, 4, 4, 4);
+}
 
+static void test_pack_TIMERPROC(void)
+{
     /* TIMERPROC */
     TEST_TYPE(TIMERPROC, 4, 4);
+}
 
-    /* TIMERPROC */
-    TEST_TYPE(TIMERPROC, 4, 4);
-
+static void test_pack_TOGGLEKEYS(void)
+{
     /* TOGGLEKEYS (pack 4) */
     TEST_TYPE(TOGGLEKEYS, 8, 4);
     TEST_FIELD(TOGGLEKEYS, DWORD, cbSize, 0, 4, 4);
     TEST_FIELD(TOGGLEKEYS, DWORD, dwFlags, 4, 4, 4);
+}
 
+static void test_pack_TPMPARAMS(void)
+{
     /* TPMPARAMS (pack 4) */
     TEST_TYPE(TPMPARAMS, 20, 4);
     TEST_FIELD(TPMPARAMS, UINT, cbSize, 0, 4, 4);
     TEST_FIELD(TPMPARAMS, RECT, rcExclude, 4, 16, 4);
+}
 
+static void test_pack_TRACKMOUSEEVENT(void)
+{
     /* TRACKMOUSEEVENT (pack 4) */
     TEST_TYPE(TRACKMOUSEEVENT, 16, 4);
     TEST_FIELD(TRACKMOUSEEVENT, DWORD, cbSize, 0, 4, 4);
     TEST_FIELD(TRACKMOUSEEVENT, DWORD, dwFlags, 4, 4, 4);
     TEST_FIELD(TRACKMOUSEEVENT, HWND, hwndTrack, 8, 4, 4);
     TEST_FIELD(TRACKMOUSEEVENT, DWORD, dwHoverTime, 12, 4, 4);
+}
 
+static void test_pack_WINDOWINFO(void)
+{
     /* WINDOWINFO (pack 4) */
     TEST_FIELD(WINDOWINFO, DWORD, cbSize, 0, 4, 4);
     TEST_FIELD(WINDOWINFO, RECT, rcWindow, 4, 16, 4);
@@ -1378,7 +2027,10 @@
     TEST_FIELD(WINDOWINFO, UINT, cyWindowBorders, 52, 4, 4);
     TEST_FIELD(WINDOWINFO, ATOM, atomWindowType, 56, 2, 2);
     TEST_FIELD(WINDOWINFO, WORD, wCreatorVersion, 58, 2, 2);
+}
 
+static void test_pack_WINDOWPOS(void)
+{
     /* WINDOWPOS (pack 4) */
     TEST_TYPE(WINDOWPOS, 28, 4);
     TEST_FIELD(WINDOWPOS, HWND, hwnd, 0, 4, 4);
@@ -1388,19 +2040,28 @@
     TEST_FIELD(WINDOWPOS, INT, cx, 16, 4, 4);
     TEST_FIELD(WINDOWPOS, INT, cy, 20, 4, 4);
     TEST_FIELD(WINDOWPOS, UINT, flags, 24, 4, 4);
+}
 
+static void test_pack_WINEVENTPROC(void)
+{
     /* WINEVENTPROC */
     TEST_TYPE(WINEVENTPROC, 4, 4);
+}
 
-    /* WINEVENTPROC */
-    TEST_TYPE(WINEVENTPROC, 4, 4);
-
+static void test_pack_WINSTAENUMPROCA(void)
+{
     /* WINSTAENUMPROCA */
     TEST_TYPE(WINSTAENUMPROCA, 4, 4);
+}
 
+static void test_pack_WINSTAENUMPROCW(void)
+{
     /* WINSTAENUMPROCW */
     TEST_TYPE(WINSTAENUMPROCW, 4, 4);
+}
 
+static void test_pack_WNDCLASSA(void)
+{
     /* WNDCLASSA (pack 4) */
     TEST_TYPE(WNDCLASSA, 40, 4);
     TEST_FIELD(WNDCLASSA, UINT, style, 0, 4, 4);
@@ -1413,7 +2074,10 @@
     TEST_FIELD(WNDCLASSA, HBRUSH, hbrBackground, 28, 4, 4);
     TEST_FIELD(WNDCLASSA, LPCSTR, lpszMenuName, 32, 4, 4);
     TEST_FIELD(WNDCLASSA, LPCSTR, lpszClassName, 36, 4, 4);
+}
 
+static void test_pack_WNDCLASSEXA(void)
+{
     /* WNDCLASSEXA (pack 4) */
     TEST_TYPE(WNDCLASSEXA, 48, 4);
     TEST_FIELD(WNDCLASSEXA, UINT, cbSize, 0, 4, 4);
@@ -1428,7 +2092,10 @@
     TEST_FIELD(WNDCLASSEXA, LPCSTR, lpszMenuName, 36, 4, 4);
     TEST_FIELD(WNDCLASSEXA, LPCSTR, lpszClassName, 40, 4, 4);
     TEST_FIELD(WNDCLASSEXA, HICON, hIconSm, 44, 4, 4);
+}
 
+static void test_pack_WNDCLASSEXW(void)
+{
     /* WNDCLASSEXW (pack 4) */
     TEST_TYPE(WNDCLASSEXW, 48, 4);
     TEST_FIELD(WNDCLASSEXW, UINT, cbSize, 0, 4, 4);
@@ -1443,7 +2110,10 @@
     TEST_FIELD(WNDCLASSEXW, LPCWSTR, lpszMenuName, 36, 4, 4);
     TEST_FIELD(WNDCLASSEXW, LPCWSTR, lpszClassName, 40, 4, 4);
     TEST_FIELD(WNDCLASSEXW, HICON, hIconSm, 44, 4, 4);
+}
 
+static void test_pack_WNDCLASSW(void)
+{
     /* WNDCLASSW (pack 4) */
     TEST_TYPE(WNDCLASSW, 40, 4);
     TEST_FIELD(WNDCLASSW, UINT, style, 0, 4, 4);
@@ -1456,15 +2126,262 @@
     TEST_FIELD(WNDCLASSW, HBRUSH, hbrBackground, 28, 4, 4);
     TEST_FIELD(WNDCLASSW, LPCWSTR, lpszMenuName, 32, 4, 4);
     TEST_FIELD(WNDCLASSW, LPCWSTR, lpszClassName, 36, 4, 4);
+}
 
+static void test_pack_WNDENUMPROC(void)
+{
     /* WNDENUMPROC */
     TEST_TYPE(WNDENUMPROC, 4, 4);
+}
 
-    /* WNDENUMPROC */
-    TEST_TYPE(WNDENUMPROC, 4, 4);
-
+static void test_pack_WNDPROC(void)
+{
     /* WNDPROC */
+    TEST_TYPE(WNDPROC, 4, 4);
+}
 
+static void test_pack(void)
+{
+    test_pack_ACCEL();
+    test_pack_ACCESSTIMEOUT();
+    test_pack_ANIMATIONINFO();
+    test_pack_CBTACTIVATESTRUCT();
+    test_pack_CBT_CREATEWNDA();
+    test_pack_CBT_CREATEWNDW();
+    test_pack_CLIENTCREATESTRUCT();
+    test_pack_COMBOBOXINFO();
+    test_pack_COMPAREITEMSTRUCT();
+    test_pack_COPYDATASTRUCT();
+    test_pack_CREATESTRUCTA();
+    test_pack_CREATESTRUCTW();
+    test_pack_CURSORINFO();
+    test_pack_CWPRETSTRUCT();
+    test_pack_CWPSTRUCT();
+    test_pack_DEBUGHOOKINFO();
+    test_pack_DELETEITEMSTRUCT();
+    test_pack_DESKTOPENUMPROCA();
+    test_pack_DESKTOPENUMPROCW();
+    test_pack_DLGITEMTEMPLATE();
+    test_pack_DLGPROC();
+    test_pack_DLGTEMPLATE();
+    test_pack_DRAWSTATEPROC();
+    test_pack_DRAWTEXTPARAMS();
+    test_pack_EDITWORDBREAKPROCA();
+    test_pack_EDITWORDBREAKPROCW();
+    test_pack_EVENTMSG();
+    test_pack_FILTERKEYS();
+    test_pack_GRAYSTRINGPROC();
+    test_pack_GUITHREADINFO();
+    test_pack_HARDWAREHOOKSTRUCT();
+    test_pack_HARDWAREINPUT();
+    test_pack_HDEVNOTIFY();
+    test_pack_HDWP();
+    test_pack_HELPINFO();
+    test_pack_HELPWININFOA();
+    test_pack_HELPWININFOW();
+    test_pack_HIGHCONTRASTA();
+    test_pack_HIGHCONTRASTW();
+    test_pack_HOOKPROC();
+    test_pack_ICONINFO();
+    test_pack_ICONMETRICSA();
+    test_pack_ICONMETRICSW();
+    test_pack_INPUT();
+    test_pack_KBDLLHOOKSTRUCT();
+    test_pack_KEYBDINPUT();
+    test_pack_LPACCEL();
+    test_pack_LPACCESSTIMEOUT();
+    test_pack_LPANIMATIONINFO();
+    test_pack_LPCBTACTIVATESTRUCT();
+    test_pack_LPCBT_CREATEWNDA();
+    test_pack_LPCBT_CREATEWNDW();
+    test_pack_LPCDLGTEMPLATEA();
+    test_pack_LPCDLGTEMPLATEW();
+    test_pack_LPCLIENTCREATESTRUCT();
+    test_pack_LPCMENUINFO();
+    test_pack_LPCMENUITEMINFOA();
+    test_pack_LPCMENUITEMINFOW();
+    test_pack_LPCOMBOBOXINFO();
+    test_pack_LPCOMPAREITEMSTRUCT();
+    test_pack_LPCREATESTRUCTA();
+    test_pack_LPCREATESTRUCTW();
+    test_pack_LPCSCROLLINFO();
+    test_pack_LPCURSORINFO();
+    test_pack_LPCWPRETSTRUCT();
+    test_pack_LPCWPSTRUCT();
+    test_pack_LPDEBUGHOOKINFO();
+    test_pack_LPDELETEITEMSTRUCT();
+    test_pack_LPDLGITEMTEMPLATEA();
+    test_pack_LPDLGITEMTEMPLATEW();
+    test_pack_LPDLGTEMPLATEA();
+    test_pack_LPDLGTEMPLATEW();
+    test_pack_LPDRAWITEMSTRUCT();
+    test_pack_LPDRAWTEXTPARAMS();
+    test_pack_LPEVENTMSG();
+    test_pack_LPFILTERKEYS();
+    test_pack_LPHARDWAREHOOKSTRUCT();
+    test_pack_LPHARDWAREINPUT();
+    test_pack_LPHELPINFO();
+    test_pack_LPHELPWININFOA();
+    test_pack_LPHELPWININFOW();
+    test_pack_LPHIGHCONTRASTA();
+    test_pack_LPHIGHCONTRASTW();
+    test_pack_LPICONMETRICSA();
+    test_pack_LPICONMETRICSW();
+    test_pack_LPINPUT();
+    test_pack_LPKBDLLHOOKSTRUCT();
+    test_pack_LPKEYBDINPUT();
+    test_pack_LPMDICREATESTRUCTA();
+    test_pack_LPMDICREATESTRUCTW();
+    test_pack_LPMDINEXTMENU();
+    test_pack_LPMEASUREITEMSTRUCT();
+    test_pack_LPMENUINFO();
+    test_pack_LPMENUITEMINFOA();
+    test_pack_LPMENUITEMINFOW();
+    test_pack_LPMENUTEMPLATE();
+    test_pack_LPMINIMIZEDMETRICS();
+    test_pack_LPMINMAXINFO();
+    test_pack_LPMONITORINFO();
+    test_pack_LPMONITORINFOEXA();
+    test_pack_LPMONITORINFOEXW();
+    test_pack_LPMOUSEHOOKSTRUCT();
+    test_pack_LPMOUSEINPUT();
+    test_pack_LPMOUSEKEYS();
+    test_pack_LPMSG();
+    test_pack_LPMSGBOXPARAMSA();
+    test_pack_LPMSGBOXPARAMSW();
+    test_pack_LPMSLLHOOKSTRUCT();
+    test_pack_LPMULTIKEYHELPA();
+    test_pack_LPMULTIKEYHELPW();
+    test_pack_LPNCCALCSIZE_PARAMS();
+    test_pack_LPNMHDR();
+    test_pack_LPNONCLIENTMETRICSA();
+    test_pack_LPNONCLIENTMETRICSW();
+    test_pack_LPPAINTSTRUCT();
+    test_pack_LPSCROLLINFO();
+    test_pack_LPSERIALKEYSA();
+    test_pack_LPSERIALKEYSW();
+    test_pack_LPSOUNDSENTRYA();
+    test_pack_LPSOUNDSENTRYW();
+    test_pack_LPSTICKYKEYS();
+    test_pack_LPSTYLESTRUCT();
+    test_pack_LPTOGGLEKEYS();
+    test_pack_LPTPMPARAMS();
+    test_pack_LPTRACKMOUSEEVENT();
+    test_pack_LPWINDOWINFO();
+    test_pack_LPWINDOWPLACEMENT();
+    test_pack_LPWINDOWPOS();
+    test_pack_LPWNDCLASSA();
+    test_pack_LPWNDCLASSEXA();
+    test_pack_LPWNDCLASSEXW();
+    test_pack_LPWNDCLASSW();
+    test_pack_MDICREATESTRUCTA();
+    test_pack_MDICREATESTRUCTW();
+    test_pack_MDINEXTMENU();
+    test_pack_MEASUREITEMSTRUCT();
+    test_pack_MENUINFO();
+    test_pack_MENUITEMINFOA();
+    test_pack_MENUITEMINFOW();
+    test_pack_MENUITEMTEMPLATE();
+    test_pack_MENUITEMTEMPLATEHEADER();
+    test_pack_MENUTEMPLATE();
+    test_pack_MINIMIZEDMETRICS();
+    test_pack_MINMAXINFO();
+    test_pack_MONITORENUMPROC();
+    test_pack_MONITORINFO();
+    test_pack_MONITORINFOEXA();
+    test_pack_MONITORINFOEXW();
+    test_pack_MOUSEHOOKSTRUCT();
+    test_pack_MOUSEINPUT();
+    test_pack_MOUSEKEYS();
+    test_pack_MSG();
+    test_pack_MSGBOXCALLBACK();
+    test_pack_MSGBOXPARAMSA();
+    test_pack_MSGBOXPARAMSW();
+    test_pack_MSLLHOOKSTRUCT();
+    test_pack_MULTIKEYHELPA();
+    test_pack_MULTIKEYHELPW();
+    test_pack_NAMEENUMPROCA();
+    test_pack_NAMEENUMPROCW();
+    test_pack_NCCALCSIZE_PARAMS();
+    test_pack_NMHDR();
+    test_pack_NONCLIENTMETRICSA();
+    test_pack_NONCLIENTMETRICSW();
+    test_pack_PAINTSTRUCT();
+    test_pack_PCOMBOBOXINFO();
+    test_pack_PCOMPAREITEMSTRUCT();
+    test_pack_PCOPYDATASTRUCT();
+    test_pack_PCURSORINFO();
+    test_pack_PCWPRETSTRUCT();
+    test_pack_PCWPSTRUCT();
+    test_pack_PDEBUGHOOKINFO();
+    test_pack_PDELETEITEMSTRUCT();
+    test_pack_PDLGITEMTEMPLATEA();
+    test_pack_PDLGITEMTEMPLATEW();
+    test_pack_PDRAWITEMSTRUCT();
+    test_pack_PEVENTMSG();
+    test_pack_PGUITHREADINFO();
+    test_pack_PHARDWAREHOOKSTRUCT();
+    test_pack_PHARDWAREINPUT();
+    test_pack_PHDEVNOTIFY();
+    test_pack_PHELPWININFOA();
+    test_pack_PHELPWININFOW();
+    test_pack_PICONINFO();
+    test_pack_PICONMETRICSA();
+    test_pack_PICONMETRICSW();
+    test_pack_PINPUT();
+    test_pack_PKBDLLHOOKSTRUCT();
+    test_pack_PKEYBDINPUT();
+    test_pack_PMDINEXTMENU();
+    test_pack_PMEASUREITEMSTRUCT();
+    test_pack_PMENUITEMTEMPLATE();
+    test_pack_PMENUITEMTEMPLATEHEADER();
+    test_pack_PMINIMIZEDMETRICS();
+    test_pack_PMINMAXINFO();
+    test_pack_PMOUSEHOOKSTRUCT();
+    test_pack_PMOUSEINPUT();
+    test_pack_PMSG();
+    test_pack_PMSGBOXPARAMSA();
+    test_pack_PMSGBOXPARAMSW();
+    test_pack_PMSLLHOOKSTRUCT();
+    test_pack_PMULTIKEYHELPA();
+    test_pack_PMULTIKEYHELPW();
+    test_pack_PNONCLIENTMETRICSA();
+    test_pack_PNONCLIENTMETRICSW();
+    test_pack_PPAINTSTRUCT();
+    test_pack_PROPENUMPROCA();
+    test_pack_PROPENUMPROCEXA();
+    test_pack_PROPENUMPROCEXW();
+    test_pack_PROPENUMPROCW();
+    test_pack_PWINDOWINFO();
+    test_pack_PWINDOWPLACEMENT();
+    test_pack_PWINDOWPOS();
+    test_pack_PWNDCLASSA();
+    test_pack_PWNDCLASSEXA();
+    test_pack_PWNDCLASSEXW();
+    test_pack_PWNDCLASSW();
+    test_pack_SCROLLINFO();
+    test_pack_SENDASYNCPROC();
+    test_pack_SERIALKEYSA();
+    test_pack_SERIALKEYSW();
+    test_pack_SOUNDSENTRYA();
+    test_pack_SOUNDSENTRYW();
+    test_pack_STICKYKEYS();
+    test_pack_STYLESTRUCT();
+    test_pack_TIMERPROC();
+    test_pack_TOGGLEKEYS();
+    test_pack_TPMPARAMS();
+    test_pack_TRACKMOUSEEVENT();
+    test_pack_WINDOWINFO();
+    test_pack_WINDOWPOS();
+    test_pack_WINEVENTPROC();
+    test_pack_WINSTAENUMPROCA();
+    test_pack_WINSTAENUMPROCW();
+    test_pack_WNDCLASSA();
+    test_pack_WNDCLASSEXA();
+    test_pack_WNDCLASSEXW();
+    test_pack_WNDCLASSW();
+    test_pack_WNDENUMPROC();
+    test_pack_WNDPROC();
 }
 
 START_TEST(generated)