diff --git a/dlls/gdi32/tests/generated.c b/dlls/gdi32/tests/generated.c
index 758851dbd7c..e125b0efc97 100644
--- a/dlls/gdi32/tests/generated.c
+++ b/dlls/gdi32/tests/generated.c
@@ -86,10 +86,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -109,18 +109,18 @@ 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);
+    TEST_FIELD(ABC, abcA, 0, 4, 4);
+    TEST_FIELD(ABC, abcB, 4, 4, 4);
+    TEST_FIELD(ABC, 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);
+    TEST_FIELD(ABCFLOAT, abcfA, 0, 4, 4);
+    TEST_FIELD(ABCFLOAT, abcfB, 4, 4, 4);
+    TEST_FIELD(ABCFLOAT, abcfC, 8, 4, 4);
 }
 
 static void test_pack_ABORTPROC(void)
@@ -133,161 +133,161 @@ static void test_pack_BITMAP(void)
 {
     /* BITMAP (pack 4) */
     TEST_TYPE(BITMAP, 24, 4);
-    TEST_FIELD(BITMAP, INT, bmType, 0, 4, 4);
-    TEST_FIELD(BITMAP, INT, bmWidth, 4, 4, 4);
-    TEST_FIELD(BITMAP, INT, bmHeight, 8, 4, 4);
-    TEST_FIELD(BITMAP, INT, bmWidthBytes, 12, 4, 4);
-    TEST_FIELD(BITMAP, WORD, bmPlanes, 16, 2, 2);
-    TEST_FIELD(BITMAP, WORD, bmBitsPixel, 18, 2, 2);
-    TEST_FIELD(BITMAP, LPVOID, bmBits, 20, 4, 4);
+    TEST_FIELD(BITMAP, bmType, 0, 4, 4);
+    TEST_FIELD(BITMAP, bmWidth, 4, 4, 4);
+    TEST_FIELD(BITMAP, bmHeight, 8, 4, 4);
+    TEST_FIELD(BITMAP, bmWidthBytes, 12, 4, 4);
+    TEST_FIELD(BITMAP, bmPlanes, 16, 2, 2);
+    TEST_FIELD(BITMAP, bmBitsPixel, 18, 2, 2);
+    TEST_FIELD(BITMAP, 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);
-    TEST_FIELD(BITMAPCOREHEADER, WORD, bcWidth, 4, 2, 2);
-    TEST_FIELD(BITMAPCOREHEADER, WORD, bcHeight, 6, 2, 2);
-    TEST_FIELD(BITMAPCOREHEADER, WORD, bcPlanes, 8, 2, 2);
-    TEST_FIELD(BITMAPCOREHEADER, WORD, bcBitCount, 10, 2, 2);
+    TEST_FIELD(BITMAPCOREHEADER, bcSize, 0, 4, 4);
+    TEST_FIELD(BITMAPCOREHEADER, bcWidth, 4, 2, 2);
+    TEST_FIELD(BITMAPCOREHEADER, bcHeight, 6, 2, 2);
+    TEST_FIELD(BITMAPCOREHEADER, bcPlanes, 8, 2, 2);
+    TEST_FIELD(BITMAPCOREHEADER, 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);
+    TEST_FIELD(BITMAPCOREINFO, bmciHeader, 0, 12, 4);
+    TEST_FIELD(BITMAPCOREINFO, 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);
-    TEST_FIELD(BITMAPFILEHEADER, DWORD, bfSize, 2, 4, 2);
-    TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved1, 6, 2, 2);
-    TEST_FIELD(BITMAPFILEHEADER, WORD, bfReserved2, 8, 2, 2);
-    TEST_FIELD(BITMAPFILEHEADER, DWORD, bfOffBits, 10, 4, 2);
+    TEST_FIELD(BITMAPFILEHEADER, bfType, 0, 2, 2);
+    TEST_FIELD(BITMAPFILEHEADER, bfSize, 2, 4, 2);
+    TEST_FIELD(BITMAPFILEHEADER, bfReserved1, 6, 2, 2);
+    TEST_FIELD(BITMAPFILEHEADER, bfReserved2, 8, 2, 2);
+    TEST_FIELD(BITMAPFILEHEADER, 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);
+    TEST_FIELD(BITMAPINFO, bmiHeader, 0, 40, 4);
+    TEST_FIELD(BITMAPINFO, 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);
-    TEST_FIELD(BITMAPINFOHEADER, LONG, biWidth, 4, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, LONG, biHeight, 8, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, WORD, biPlanes, 12, 2, 2);
-    TEST_FIELD(BITMAPINFOHEADER, WORD, biBitCount, 14, 2, 2);
-    TEST_FIELD(BITMAPINFOHEADER, DWORD, biCompression, 16, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, DWORD, biSizeImage, 20, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, LONG, biXPelsPerMeter, 24, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, LONG, biYPelsPerMeter, 28, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrUsed, 32, 4, 4);
-    TEST_FIELD(BITMAPINFOHEADER, DWORD, biClrImportant, 36, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biSize, 0, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biWidth, 4, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biHeight, 8, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biPlanes, 12, 2, 2);
+    TEST_FIELD(BITMAPINFOHEADER, biBitCount, 14, 2, 2);
+    TEST_FIELD(BITMAPINFOHEADER, biCompression, 16, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biSizeImage, 20, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biXPelsPerMeter, 24, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biYPelsPerMeter, 28, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, biClrUsed, 32, 4, 4);
+    TEST_FIELD(BITMAPINFOHEADER, 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);
-    TEST_FIELD(BITMAPV4HEADER, LONG, bV4Width, 4, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, LONG, bV4Height, 8, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, WORD, bV4Planes, 12, 2, 2);
-    TEST_FIELD(BITMAPV4HEADER, WORD, bV4BitCount, 14, 2, 2);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4V4Compression, 16, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4SizeImage, 20, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, LONG, bV4XPelsPerMeter, 24, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, LONG, bV4YPelsPerMeter, 28, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrUsed, 32, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4ClrImportant, 36, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4RedMask, 40, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GreenMask, 44, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4BlueMask, 48, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4AlphaMask, 52, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4CSType, 56, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, CIEXYZTRIPLE, bV4Endpoints, 60, 36, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaRed, 96, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaGreen, 100, 4, 4);
-    TEST_FIELD(BITMAPV4HEADER, DWORD, bV4GammaBlue, 104, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4Size, 0, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4Width, 4, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4Height, 8, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4Planes, 12, 2, 2);
+    TEST_FIELD(BITMAPV4HEADER, bV4BitCount, 14, 2, 2);
+    TEST_FIELD(BITMAPV4HEADER, bV4V4Compression, 16, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4SizeImage, 20, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4XPelsPerMeter, 24, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4YPelsPerMeter, 28, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4ClrUsed, 32, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4ClrImportant, 36, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4RedMask, 40, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4GreenMask, 44, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4BlueMask, 48, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4AlphaMask, 52, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4CSType, 56, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4Endpoints, 60, 36, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4GammaRed, 96, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, bV4GammaGreen, 100, 4, 4);
+    TEST_FIELD(BITMAPV4HEADER, 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);
-    TEST_FIELD(BITMAPV5HEADER, LONG, bV5Width, 4, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, LONG, bV5Height, 8, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, WORD, bV5Planes, 12, 2, 2);
-    TEST_FIELD(BITMAPV5HEADER, WORD, bV5BitCount, 14, 2, 2);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Compression, 16, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5SizeImage, 20, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, LONG, bV5XPelsPerMeter, 24, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, LONG, bV5YPelsPerMeter, 28, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrUsed, 32, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ClrImportant, 36, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5RedMask, 40, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GreenMask, 44, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5BlueMask, 48, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5AlphaMask, 52, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5CSType, 56, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, CIEXYZTRIPLE, bV5Endpoints, 60, 36, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaRed, 96, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaGreen, 100, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5GammaBlue, 104, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Intent, 108, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileData, 112, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5ProfileSize, 116, 4, 4);
-    TEST_FIELD(BITMAPV5HEADER, DWORD, bV5Reserved, 120, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5Size, 0, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5Width, 4, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5Height, 8, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5Planes, 12, 2, 2);
+    TEST_FIELD(BITMAPV5HEADER, bV5BitCount, 14, 2, 2);
+    TEST_FIELD(BITMAPV5HEADER, bV5Compression, 16, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5SizeImage, 20, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5XPelsPerMeter, 24, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5YPelsPerMeter, 28, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5ClrUsed, 32, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5ClrImportant, 36, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5RedMask, 40, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5GreenMask, 44, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5BlueMask, 48, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5AlphaMask, 52, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5CSType, 56, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5Endpoints, 60, 36, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5GammaRed, 96, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5GammaGreen, 100, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5GammaBlue, 104, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5Intent, 108, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5ProfileData, 112, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, bV5ProfileSize, 116, 4, 4);
+    TEST_FIELD(BITMAPV5HEADER, 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);
+    TEST_FIELD(BLENDFUNCTION, BlendOp, 0, 1, 1);
+    TEST_FIELD(BLENDFUNCTION, BlendFlags, 1, 1, 1);
+    TEST_FIELD(BLENDFUNCTION, SourceConstantAlpha, 2, 1, 1);
+    TEST_FIELD(BLENDFUNCTION, 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);
+    TEST_FIELD(CHARSETINFO, ciCharset, 0, 4, 4);
+    TEST_FIELD(CHARSETINFO, ciACP, 4, 4, 4);
+    TEST_FIELD(CHARSETINFO, 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);
+    TEST_FIELD(CIEXYZ, ciexyzX, 0, 4, 4);
+    TEST_FIELD(CIEXYZ, ciexyzY, 4, 4, 4);
+    TEST_FIELD(CIEXYZ, 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);
+    TEST_FIELD(CIEXYZTRIPLE, ciexyzRed, 0, 12, 4);
+    TEST_FIELD(CIEXYZTRIPLE, ciexyzGreen, 12, 12, 4);
+    TEST_FIELD(CIEXYZTRIPLE, ciexyzBlue, 24, 12, 4);
 }
 
 static void test_pack_COLOR16(void)
@@ -300,1198 +300,1198 @@ static void test_pack_COLORADJUSTMENT(void)
 {
     /* COLORADJUSTMENT (pack 4) */
     TEST_TYPE(COLORADJUSTMENT, 24, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caSize, 0, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caFlags, 2, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caIlluminantIndex, 4, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caRedGamma, 6, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caGreenGamma, 8, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caBlueGamma, 10, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceBlack, 12, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, WORD, caReferenceWhite, 14, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, SHORT, caContrast, 16, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, SHORT, caBrightness, 18, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, SHORT, caColorfulness, 20, 2, 2);
-    TEST_FIELD(COLORADJUSTMENT, SHORT, caRedGreenTint, 22, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caSize, 0, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caFlags, 2, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caIlluminantIndex, 4, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caRedGamma, 6, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caGreenGamma, 8, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caBlueGamma, 10, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caReferenceBlack, 12, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caReferenceWhite, 14, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caContrast, 16, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caBrightness, 18, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caColorfulness, 20, 2, 2);
+    TEST_FIELD(COLORADJUSTMENT, caRedGreenTint, 22, 2, 2);
 }
 
 static void test_pack_DEVMODEA(void)
 {
     /* DEVMODEA (pack 4) */
-    TEST_FIELD(DEVMODEA, BYTE[CCHDEVICENAME], dmDeviceName, 0, 32, 1);
-    TEST_FIELD(DEVMODEA, WORD, dmSpecVersion, 32, 2, 2);
-    TEST_FIELD(DEVMODEA, WORD, dmDriverVersion, 34, 2, 2);
-    TEST_FIELD(DEVMODEA, WORD, dmSize, 36, 2, 2);
-    TEST_FIELD(DEVMODEA, WORD, dmDriverExtra, 38, 2, 2);
-    TEST_FIELD(DEVMODEA, DWORD, dmFields, 40, 4, 4);
+    TEST_FIELD(DEVMODEA, dmDeviceName, 0, 32, 1);
+    TEST_FIELD(DEVMODEA, dmSpecVersion, 32, 2, 2);
+    TEST_FIELD(DEVMODEA, dmDriverVersion, 34, 2, 2);
+    TEST_FIELD(DEVMODEA, dmSize, 36, 2, 2);
+    TEST_FIELD(DEVMODEA, dmDriverExtra, 38, 2, 2);
+    TEST_FIELD(DEVMODEA, dmFields, 40, 4, 4);
 }
 
 static void test_pack_DEVMODEW(void)
 {
     /* DEVMODEW (pack 4) */
-    TEST_FIELD(DEVMODEW, WCHAR[CCHDEVICENAME], dmDeviceName, 0, 64, 2);
-    TEST_FIELD(DEVMODEW, WORD, dmSpecVersion, 64, 2, 2);
-    TEST_FIELD(DEVMODEW, WORD, dmDriverVersion, 66, 2, 2);
-    TEST_FIELD(DEVMODEW, WORD, dmSize, 68, 2, 2);
-    TEST_FIELD(DEVMODEW, WORD, dmDriverExtra, 70, 2, 2);
-    TEST_FIELD(DEVMODEW, DWORD, dmFields, 72, 4, 4);
+    TEST_FIELD(DEVMODEW, dmDeviceName, 0, 64, 2);
+    TEST_FIELD(DEVMODEW, dmSpecVersion, 64, 2, 2);
+    TEST_FIELD(DEVMODEW, dmDriverVersion, 66, 2, 2);
+    TEST_FIELD(DEVMODEW, dmSize, 68, 2, 2);
+    TEST_FIELD(DEVMODEW, dmDriverExtra, 70, 2, 2);
+    TEST_FIELD(DEVMODEW, dmFields, 72, 4, 4);
 }
 
 static void test_pack_DIBSECTION(void)
 {
     /* DIBSECTION (pack 4) */
     TEST_TYPE(DIBSECTION, 84, 4);
-    TEST_FIELD(DIBSECTION, BITMAP, dsBm, 0, 24, 4);
-    TEST_FIELD(DIBSECTION, BITMAPINFOHEADER, dsBmih, 24, 40, 4);
-    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);
+    TEST_FIELD(DIBSECTION, dsBm, 0, 24, 4);
+    TEST_FIELD(DIBSECTION, dsBmih, 24, 40, 4);
+    TEST_FIELD(DIBSECTION, dsBitfields, 64, 12, 4);
+    TEST_FIELD(DIBSECTION, dshSection, 76, 4, 4);
+    TEST_FIELD(DIBSECTION, dsOffset, 80, 4, 4);
 }
 
 static void test_pack_DISPLAY_DEVICEA(void)
 {
     /* DISPLAY_DEVICEA (pack 4) */
     TEST_TYPE(DISPLAY_DEVICEA, 424, 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);
-    TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceID, 168, 128, 1);
-    TEST_FIELD(DISPLAY_DEVICEA, CHAR[128], DeviceKey, 296, 128, 1);
+    TEST_FIELD(DISPLAY_DEVICEA, cb, 0, 4, 4);
+    TEST_FIELD(DISPLAY_DEVICEA, DeviceName, 4, 32, 1);
+    TEST_FIELD(DISPLAY_DEVICEA, DeviceString, 36, 128, 1);
+    TEST_FIELD(DISPLAY_DEVICEA, StateFlags, 164, 4, 4);
+    TEST_FIELD(DISPLAY_DEVICEA, DeviceID, 168, 128, 1);
+    TEST_FIELD(DISPLAY_DEVICEA, DeviceKey, 296, 128, 1);
 }
 
 static void test_pack_DISPLAY_DEVICEW(void)
 {
     /* DISPLAY_DEVICEW (pack 4) */
     TEST_TYPE(DISPLAY_DEVICEW, 840, 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);
-    TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceID, 328, 256, 2);
-    TEST_FIELD(DISPLAY_DEVICEW, WCHAR[128], DeviceKey, 584, 256, 2);
+    TEST_FIELD(DISPLAY_DEVICEW, cb, 0, 4, 4);
+    TEST_FIELD(DISPLAY_DEVICEW, DeviceName, 4, 64, 2);
+    TEST_FIELD(DISPLAY_DEVICEW, DeviceString, 68, 256, 2);
+    TEST_FIELD(DISPLAY_DEVICEW, StateFlags, 324, 4, 4);
+    TEST_FIELD(DISPLAY_DEVICEW, DeviceID, 328, 256, 2);
+    TEST_FIELD(DISPLAY_DEVICEW, DeviceKey, 584, 256, 2);
 }
 
 static void test_pack_DOCINFOA(void)
 {
     /* DOCINFOA (pack 4) */
     TEST_TYPE(DOCINFOA, 20, 4);
-    TEST_FIELD(DOCINFOA, INT, cbSize, 0, 4, 4);
-    TEST_FIELD(DOCINFOA, LPCSTR, lpszDocName, 4, 4, 4);
-    TEST_FIELD(DOCINFOA, LPCSTR, lpszOutput, 8, 4, 4);
-    TEST_FIELD(DOCINFOA, LPCSTR, lpszDatatype, 12, 4, 4);
-    TEST_FIELD(DOCINFOA, DWORD, fwType, 16, 4, 4);
+    TEST_FIELD(DOCINFOA, cbSize, 0, 4, 4);
+    TEST_FIELD(DOCINFOA, lpszDocName, 4, 4, 4);
+    TEST_FIELD(DOCINFOA, lpszOutput, 8, 4, 4);
+    TEST_FIELD(DOCINFOA, lpszDatatype, 12, 4, 4);
+    TEST_FIELD(DOCINFOA, 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);
-    TEST_FIELD(DOCINFOW, LPCWSTR, lpszDocName, 4, 4, 4);
-    TEST_FIELD(DOCINFOW, LPCWSTR, lpszOutput, 8, 4, 4);
-    TEST_FIELD(DOCINFOW, LPCWSTR, lpszDatatype, 12, 4, 4);
-    TEST_FIELD(DOCINFOW, DWORD, fwType, 16, 4, 4);
+    TEST_FIELD(DOCINFOW, cbSize, 0, 4, 4);
+    TEST_FIELD(DOCINFOW, lpszDocName, 4, 4, 4);
+    TEST_FIELD(DOCINFOW, lpszOutput, 8, 4, 4);
+    TEST_FIELD(DOCINFOW, lpszDatatype, 12, 4, 4);
+    TEST_FIELD(DOCINFOW, 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);
+    TEST_FIELD(EMR, iType, 0, 4, 4);
+    TEST_FIELD(EMR, 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);
+    TEST_FIELD(EMRABORTPATH, 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);
-    TEST_FIELD(EMRANGLEARC, POINTL, ptlCenter, 8, 8, 4);
-    TEST_FIELD(EMRANGLEARC, DWORD, nRadius, 16, 4, 4);
-    TEST_FIELD(EMRANGLEARC, FLOAT, eStartAngle, 20, 4, 4);
-    TEST_FIELD(EMRANGLEARC, FLOAT, eSweepAngle, 24, 4, 4);
+    TEST_FIELD(EMRANGLEARC, emr, 0, 8, 4);
+    TEST_FIELD(EMRANGLEARC, ptlCenter, 8, 8, 4);
+    TEST_FIELD(EMRANGLEARC, nRadius, 16, 4, 4);
+    TEST_FIELD(EMRANGLEARC, eStartAngle, 20, 4, 4);
+    TEST_FIELD(EMRANGLEARC, 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);
+    TEST_FIELD(EMRARC, emr, 0, 8, 4);
+    TEST_FIELD(EMRARC, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRARC, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRARC, 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);
+    TEST_FIELD(EMRARCTO, emr, 0, 8, 4);
+    TEST_FIELD(EMRARCTO, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRARCTO, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRARCTO, 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);
+    TEST_FIELD(EMRBEGINPATH, 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);
-    TEST_FIELD(EMRBITBLT, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRBITBLT, LONG, xDest, 24, 4, 4);
-    TEST_FIELD(EMRBITBLT, LONG, yDest, 28, 4, 4);
-    TEST_FIELD(EMRBITBLT, LONG, cxDest, 32, 4, 4);
-    TEST_FIELD(EMRBITBLT, LONG, cyDest, 36, 4, 4);
-    TEST_FIELD(EMRBITBLT, DWORD, dwRop, 40, 4, 4);
-    TEST_FIELD(EMRBITBLT, LONG, xSrc, 44, 4, 4);
-    TEST_FIELD(EMRBITBLT, LONG, ySrc, 48, 4, 4);
-    TEST_FIELD(EMRBITBLT, XFORM, xformSrc, 52, 24, 4);
-    TEST_FIELD(EMRBITBLT, COLORREF, crBkColorSrc, 76, 4, 4);
-    TEST_FIELD(EMRBITBLT, DWORD, iUsageSrc, 80, 4, 4);
-    TEST_FIELD(EMRBITBLT, DWORD, offBmiSrc, 84, 4, 4);
-    TEST_FIELD(EMRBITBLT, DWORD, cbBmiSrc, 88, 4, 4);
-    TEST_FIELD(EMRBITBLT, DWORD, offBitsSrc, 92, 4, 4);
-    TEST_FIELD(EMRBITBLT, DWORD, cbBitsSrc, 96, 4, 4);
+    TEST_FIELD(EMRBITBLT, emr, 0, 8, 4);
+    TEST_FIELD(EMRBITBLT, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRBITBLT, xDest, 24, 4, 4);
+    TEST_FIELD(EMRBITBLT, yDest, 28, 4, 4);
+    TEST_FIELD(EMRBITBLT, cxDest, 32, 4, 4);
+    TEST_FIELD(EMRBITBLT, cyDest, 36, 4, 4);
+    TEST_FIELD(EMRBITBLT, dwRop, 40, 4, 4);
+    TEST_FIELD(EMRBITBLT, xSrc, 44, 4, 4);
+    TEST_FIELD(EMRBITBLT, ySrc, 48, 4, 4);
+    TEST_FIELD(EMRBITBLT, xformSrc, 52, 24, 4);
+    TEST_FIELD(EMRBITBLT, crBkColorSrc, 76, 4, 4);
+    TEST_FIELD(EMRBITBLT, iUsageSrc, 80, 4, 4);
+    TEST_FIELD(EMRBITBLT, offBmiSrc, 84, 4, 4);
+    TEST_FIELD(EMRBITBLT, cbBmiSrc, 88, 4, 4);
+    TEST_FIELD(EMRBITBLT, offBitsSrc, 92, 4, 4);
+    TEST_FIELD(EMRBITBLT, 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);
+    TEST_FIELD(EMRCHORD, emr, 0, 8, 4);
+    TEST_FIELD(EMRCHORD, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRCHORD, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRCHORD, 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);
+    TEST_FIELD(EMRCLOSEFIGURE, 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, LOGBRUSH32, lb, 12, 12, 4);
+    TEST_FIELD(EMRCREATEBRUSHINDIRECT, emr, 0, 8, 4);
+    TEST_FIELD(EMRCREATEBRUSHINDIRECT, ihBrush, 8, 4, 4);
+    TEST_FIELD(EMRCREATEBRUSHINDIRECT, lb, 12, 12, 4);
 }
 
 static void test_pack_EMRCREATECOLORSPACE(void)
 {
     /* EMRCREATECOLORSPACE (pack 4) */
     TEST_TYPE(EMRCREATECOLORSPACE, 340, 4);
-    TEST_FIELD(EMRCREATECOLORSPACE, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRCREATECOLORSPACE, DWORD, ihCS, 8, 4, 4);
-    TEST_FIELD(EMRCREATECOLORSPACE, LOGCOLORSPACEA, lcs, 12, 328, 4);
+    TEST_FIELD(EMRCREATECOLORSPACE, emr, 0, 8, 4);
+    TEST_FIELD(EMRCREATECOLORSPACE, ihCS, 8, 4, 4);
+    TEST_FIELD(EMRCREATECOLORSPACE, lcs, 12, 328, 4);
 }
 
 static void test_pack_EMRCREATECOLORSPACEW(void)
 {
     /* EMRCREATECOLORSPACEW (pack 4) */
     TEST_TYPE(EMRCREATECOLORSPACEW, 612, 4);
-    TEST_FIELD(EMRCREATECOLORSPACEW, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, ihCS, 8, 4, 4);
-    TEST_FIELD(EMRCREATECOLORSPACEW, LOGCOLORSPACEW, lcs, 12, 588, 4);
-    TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, dwFlags, 600, 4, 4);
-    TEST_FIELD(EMRCREATECOLORSPACEW, DWORD, cbData, 604, 4, 4);
-    TEST_FIELD(EMRCREATECOLORSPACEW, BYTE[1], Data, 608, 1, 1);
+    TEST_FIELD(EMRCREATECOLORSPACEW, emr, 0, 8, 4);
+    TEST_FIELD(EMRCREATECOLORSPACEW, ihCS, 8, 4, 4);
+    TEST_FIELD(EMRCREATECOLORSPACEW, lcs, 12, 588, 4);
+    TEST_FIELD(EMRCREATECOLORSPACEW, dwFlags, 600, 4, 4);
+    TEST_FIELD(EMRCREATECOLORSPACEW, cbData, 604, 4, 4);
+    TEST_FIELD(EMRCREATECOLORSPACEW, Data, 608, 1, 1);
 }
 
 static void test_pack_EMRCREATEDIBPATTERNBRUSHPT(void)
 {
     /* EMRCREATEDIBPATTERNBRUSHPT (pack 4) */
     TEST_TYPE(EMRCREATEDIBPATTERNBRUSHPT, 32, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, ihBrush, 8, 4, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, iUsage, 12, 4, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBmi, 16, 4, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBmi, 20, 4, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, offBits, 24, 4, 4);
-    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, DWORD, cbBits, 28, 4, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, emr, 0, 8, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, ihBrush, 8, 4, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, iUsage, 12, 4, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, offBmi, 16, 4, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, cbBmi, 20, 4, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, offBits, 24, 4, 4);
+    TEST_FIELD(EMRCREATEDIBPATTERNBRUSHPT, 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);
-    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, ihBrush, 8, 4, 4);
-    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, iUsage, 12, 4, 4);
-    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBmi, 16, 4, 4);
-    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBmi, 20, 4, 4);
-    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, offBits, 24, 4, 4);
-    TEST_FIELD(EMRCREATEMONOBRUSH, DWORD, cbBits, 28, 4, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, emr, 0, 8, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, ihBrush, 8, 4, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, iUsage, 12, 4, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, offBmi, 16, 4, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, cbBmi, 20, 4, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, offBits, 24, 4, 4);
+    TEST_FIELD(EMRCREATEMONOBRUSH, 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);
+    TEST_FIELD(EMRCREATEPEN, emr, 0, 8, 4);
+    TEST_FIELD(EMRCREATEPEN, ihPen, 8, 4, 4);
+    TEST_FIELD(EMRCREATEPEN, 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);
+    TEST_FIELD(EMRDELETECOLORSPACE, emr, 0, 8, 4);
+    TEST_FIELD(EMRDELETECOLORSPACE, 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);
+    TEST_FIELD(EMRDELETEOBJECT, emr, 0, 8, 4);
+    TEST_FIELD(EMRDELETEOBJECT, 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);
+    TEST_FIELD(EMRELLIPSE, emr, 0, 8, 4);
+    TEST_FIELD(EMRELLIPSE, 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);
+    TEST_FIELD(EMRENDPATH, 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);
+    TEST_FIELD(EMREOF, emr, 0, 8, 4);
+    TEST_FIELD(EMREOF, nPalEntries, 8, 4, 4);
+    TEST_FIELD(EMREOF, offPalEntries, 12, 4, 4);
+    TEST_FIELD(EMREOF, 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);
+    TEST_FIELD(EMREXCLUDECLIPRECT, emr, 0, 8, 4);
+    TEST_FIELD(EMREXCLUDECLIPRECT, 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);
+    TEST_FIELD(EMREXTCREATEFONTINDIRECTW, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTCREATEFONTINDIRECTW, ihFont, 8, 4, 4);
+    TEST_FIELD(EMREXTCREATEFONTINDIRECTW, 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);
-    TEST_FIELD(EMREXTCREATEPEN, DWORD, ihPen, 8, 4, 4);
-    TEST_FIELD(EMREXTCREATEPEN, DWORD, offBmi, 12, 4, 4);
-    TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBmi, 16, 4, 4);
-    TEST_FIELD(EMREXTCREATEPEN, DWORD, offBits, 20, 4, 4);
-    TEST_FIELD(EMREXTCREATEPEN, DWORD, cbBits, 24, 4, 4);
-    TEST_FIELD(EMREXTCREATEPEN, EXTLOGPEN, elp, 28, 28, 4);
+    TEST_FIELD(EMREXTCREATEPEN, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTCREATEPEN, ihPen, 8, 4, 4);
+    TEST_FIELD(EMREXTCREATEPEN, offBmi, 12, 4, 4);
+    TEST_FIELD(EMREXTCREATEPEN, cbBmi, 16, 4, 4);
+    TEST_FIELD(EMREXTCREATEPEN, offBits, 20, 4, 4);
+    TEST_FIELD(EMREXTCREATEPEN, cbBits, 24, 4, 4);
+    TEST_FIELD(EMREXTCREATEPEN, 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);
+    TEST_FIELD(EMREXTFLOODFILL, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTFLOODFILL, ptlStart, 8, 8, 4);
+    TEST_FIELD(EMREXTFLOODFILL, crColor, 16, 4, 4);
+    TEST_FIELD(EMREXTFLOODFILL, 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);
+    TEST_FIELD(EMREXTSELECTCLIPRGN, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTSELECTCLIPRGN, cbRgnData, 8, 4, 4);
+    TEST_FIELD(EMREXTSELECTCLIPRGN, iMode, 12, 4, 4);
+    TEST_FIELD(EMREXTSELECTCLIPRGN, 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);
-    TEST_FIELD(EMREXTTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMREXTTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
-    TEST_FIELD(EMREXTTEXTOUTA, FLOAT, exScale, 28, 4, 4);
-    TEST_FIELD(EMREXTTEXTOUTA, FLOAT, eyScale, 32, 4, 4);
-    TEST_FIELD(EMREXTTEXTOUTA, EMRTEXT, emrtext, 36, 40, 4);
+    TEST_FIELD(EMREXTTEXTOUTA, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTTEXTOUTA, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMREXTTEXTOUTA, iGraphicsMode, 24, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTA, exScale, 28, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTA, eyScale, 32, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTA, 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);
+    TEST_FIELD(EMREXTTEXTOUTW, emr, 0, 8, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, iGraphicsMode, 24, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, exScale, 28, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, eyScale, 32, 4, 4);
+    TEST_FIELD(EMREXTTEXTOUTW, 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);
+    TEST_FIELD(EMRFILLPATH, emr, 0, 8, 4);
+    TEST_FIELD(EMRFILLPATH, 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);
-    TEST_FIELD(EMRFILLRGN, RECTL, rclBounds, 8, 16, 4);
-    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);
+    TEST_FIELD(EMRFILLRGN, emr, 0, 8, 4);
+    TEST_FIELD(EMRFILLRGN, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRFILLRGN, cbRgnData, 24, 4, 4);
+    TEST_FIELD(EMRFILLRGN, ihBrush, 28, 4, 4);
+    TEST_FIELD(EMRFILLRGN, 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);
+    TEST_FIELD(EMRFLATTENPATH, 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);
+    TEST_FIELD(EMRFORMAT, dSignature, 0, 4, 4);
+    TEST_FIELD(EMRFORMAT, nVersion, 4, 4, 4);
+    TEST_FIELD(EMRFORMAT, cbData, 8, 4, 4);
+    TEST_FIELD(EMRFORMAT, 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);
-    TEST_FIELD(EMRFRAMERGN, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRFRAMERGN, DWORD, cbRgnData, 24, 4, 4);
-    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);
+    TEST_FIELD(EMRFRAMERGN, emr, 0, 8, 4);
+    TEST_FIELD(EMRFRAMERGN, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRFRAMERGN, cbRgnData, 24, 4, 4);
+    TEST_FIELD(EMRFRAMERGN, ihBrush, 28, 4, 4);
+    TEST_FIELD(EMRFRAMERGN, szlStroke, 32, 8, 4);
+    TEST_FIELD(EMRFRAMERGN, 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);
+    TEST_FIELD(EMRGDICOMMENT, emr, 0, 8, 4);
+    TEST_FIELD(EMRGDICOMMENT, cbData, 8, 4, 4);
+    TEST_FIELD(EMRGDICOMMENT, 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);
+    TEST_FIELD(EMRGLSBOUNDEDRECORD, emr, 0, 8, 4);
+    TEST_FIELD(EMRGLSBOUNDEDRECORD, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRGLSBOUNDEDRECORD, cbData, 24, 4, 4);
+    TEST_FIELD(EMRGLSBOUNDEDRECORD, 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);
+    TEST_FIELD(EMRGLSRECORD, emr, 0, 8, 4);
+    TEST_FIELD(EMRGLSRECORD, cbData, 8, 4, 4);
+    TEST_FIELD(EMRGLSRECORD, Data, 12, 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);
+    TEST_FIELD(EMRINTERSECTCLIPRECT, emr, 0, 8, 4);
+    TEST_FIELD(EMRINTERSECTCLIPRECT, rclClip, 8, 16, 4);
 }
 
 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);
+    TEST_FIELD(EMRINVERTRGN, emr, 0, 8, 4);
+    TEST_FIELD(EMRINVERTRGN, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRINVERTRGN, cbRgnData, 24, 4, 4);
+    TEST_FIELD(EMRINVERTRGN, RgnData, 28, 1, 1);
 }
 
 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);
+    TEST_FIELD(EMRLINETO, emr, 0, 8, 4);
+    TEST_FIELD(EMRLINETO, 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);
-    TEST_FIELD(EMRMASKBLT, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, xDest, 24, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, yDest, 28, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, cxDest, 32, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, cyDest, 36, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, dwRop, 40, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, xSrc, 44, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, ySrc, 48, 4, 4);
-    TEST_FIELD(EMRMASKBLT, XFORM, xformSrc, 52, 24, 4);
-    TEST_FIELD(EMRMASKBLT, COLORREF, crBkColorSrc, 76, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, iUsageSrc, 80, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, offBmiSrc, 84, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, cbBmiSrc, 88, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, offBitsSrc, 92, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, cbBitsSrc, 96, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, xMask, 100, 4, 4);
-    TEST_FIELD(EMRMASKBLT, LONG, yMask, 104, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, iUsageMask, 108, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, offBmiMask, 112, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, cbBmiMask, 116, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, offBitsMask, 120, 4, 4);
-    TEST_FIELD(EMRMASKBLT, DWORD, cbBitsMask, 124, 4, 4);
+    TEST_FIELD(EMRMASKBLT, emr, 0, 8, 4);
+    TEST_FIELD(EMRMASKBLT, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRMASKBLT, xDest, 24, 4, 4);
+    TEST_FIELD(EMRMASKBLT, yDest, 28, 4, 4);
+    TEST_FIELD(EMRMASKBLT, cxDest, 32, 4, 4);
+    TEST_FIELD(EMRMASKBLT, cyDest, 36, 4, 4);
+    TEST_FIELD(EMRMASKBLT, dwRop, 40, 4, 4);
+    TEST_FIELD(EMRMASKBLT, xSrc, 44, 4, 4);
+    TEST_FIELD(EMRMASKBLT, ySrc, 48, 4, 4);
+    TEST_FIELD(EMRMASKBLT, xformSrc, 52, 24, 4);
+    TEST_FIELD(EMRMASKBLT, crBkColorSrc, 76, 4, 4);
+    TEST_FIELD(EMRMASKBLT, iUsageSrc, 80, 4, 4);
+    TEST_FIELD(EMRMASKBLT, offBmiSrc, 84, 4, 4);
+    TEST_FIELD(EMRMASKBLT, cbBmiSrc, 88, 4, 4);
+    TEST_FIELD(EMRMASKBLT, offBitsSrc, 92, 4, 4);
+    TEST_FIELD(EMRMASKBLT, cbBitsSrc, 96, 4, 4);
+    TEST_FIELD(EMRMASKBLT, xMask, 100, 4, 4);
+    TEST_FIELD(EMRMASKBLT, yMask, 104, 4, 4);
+    TEST_FIELD(EMRMASKBLT, iUsageMask, 108, 4, 4);
+    TEST_FIELD(EMRMASKBLT, offBmiMask, 112, 4, 4);
+    TEST_FIELD(EMRMASKBLT, cbBmiMask, 116, 4, 4);
+    TEST_FIELD(EMRMASKBLT, offBitsMask, 120, 4, 4);
+    TEST_FIELD(EMRMASKBLT, 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);
+    TEST_FIELD(EMRMODIFYWORLDTRANSFORM, emr, 0, 8, 4);
+    TEST_FIELD(EMRMODIFYWORLDTRANSFORM, xform, 8, 24, 4);
+    TEST_FIELD(EMRMODIFYWORLDTRANSFORM, 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);
+    TEST_FIELD(EMRMOVETOEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRMOVETOEX, 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);
+    TEST_FIELD(EMROFFSETCLIPRGN, emr, 0, 8, 4);
+    TEST_FIELD(EMROFFSETCLIPRGN, 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);
+    TEST_FIELD(EMRPAINTRGN, emr, 0, 8, 4);
+    TEST_FIELD(EMRPAINTRGN, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPAINTRGN, cbRgnData, 24, 4, 4);
+    TEST_FIELD(EMRPAINTRGN, 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);
+    TEST_FIELD(EMRPIE, emr, 0, 8, 4);
+    TEST_FIELD(EMRPIE, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRPIE, ptlStart, 24, 8, 4);
+    TEST_FIELD(EMRPIE, 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);
+    TEST_FIELD(EMRPIXELFORMAT, emr, 0, 8, 4);
+    TEST_FIELD(EMRPIXELFORMAT, 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);
-    TEST_FIELD(EMRPLGBLT, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPLGBLT, POINTL[3], aptlDest, 24, 24, 4);
-    TEST_FIELD(EMRPLGBLT, LONG, xSrc, 48, 4, 4);
-    TEST_FIELD(EMRPLGBLT, LONG, ySrc, 52, 4, 4);
-    TEST_FIELD(EMRPLGBLT, LONG, cxSrc, 56, 4, 4);
-    TEST_FIELD(EMRPLGBLT, LONG, cySrc, 60, 4, 4);
-    TEST_FIELD(EMRPLGBLT, XFORM, xformSrc, 64, 24, 4);
-    TEST_FIELD(EMRPLGBLT, COLORREF, crBkColorSrc, 88, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, iUsageSrc, 92, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, offBmiSrc, 96, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, cbBmiSrc, 100, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, offBitsSrc, 104, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, cbBitsSrc, 108, 4, 4);
-    TEST_FIELD(EMRPLGBLT, LONG, xMask, 112, 4, 4);
-    TEST_FIELD(EMRPLGBLT, LONG, yMask, 116, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, iUsageMask, 120, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, offBmiMask, 124, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, cbBmiMask, 128, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, offBitsMask, 132, 4, 4);
-    TEST_FIELD(EMRPLGBLT, DWORD, cbBitsMask, 136, 4, 4);
+    TEST_FIELD(EMRPLGBLT, emr, 0, 8, 4);
+    TEST_FIELD(EMRPLGBLT, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPLGBLT, aptlDest, 24, 24, 4);
+    TEST_FIELD(EMRPLGBLT, xSrc, 48, 4, 4);
+    TEST_FIELD(EMRPLGBLT, ySrc, 52, 4, 4);
+    TEST_FIELD(EMRPLGBLT, cxSrc, 56, 4, 4);
+    TEST_FIELD(EMRPLGBLT, cySrc, 60, 4, 4);
+    TEST_FIELD(EMRPLGBLT, xformSrc, 64, 24, 4);
+    TEST_FIELD(EMRPLGBLT, crBkColorSrc, 88, 4, 4);
+    TEST_FIELD(EMRPLGBLT, iUsageSrc, 92, 4, 4);
+    TEST_FIELD(EMRPLGBLT, offBmiSrc, 96, 4, 4);
+    TEST_FIELD(EMRPLGBLT, cbBmiSrc, 100, 4, 4);
+    TEST_FIELD(EMRPLGBLT, offBitsSrc, 104, 4, 4);
+    TEST_FIELD(EMRPLGBLT, cbBitsSrc, 108, 4, 4);
+    TEST_FIELD(EMRPLGBLT, xMask, 112, 4, 4);
+    TEST_FIELD(EMRPLGBLT, yMask, 116, 4, 4);
+    TEST_FIELD(EMRPLGBLT, iUsageMask, 120, 4, 4);
+    TEST_FIELD(EMRPLGBLT, offBmiMask, 124, 4, 4);
+    TEST_FIELD(EMRPLGBLT, cbBmiMask, 128, 4, 4);
+    TEST_FIELD(EMRPLGBLT, offBitsMask, 132, 4, 4);
+    TEST_FIELD(EMRPLGBLT, 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);
+    TEST_FIELD(EMRPOLYBEZIER, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYBEZIER, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYBEZIER, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYBEZIER, aptl, 28, 8, 4);
 }
 
 static void test_pack_EMRPOLYBEZIER16(void)
 {
     /* EMRPOLYBEZIER16 (pack 4) */
     TEST_TYPE(EMRPOLYBEZIER16, 32, 4);
-    TEST_FIELD(EMRPOLYBEZIER16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYBEZIER16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYBEZIER16, DWORD, cpts, 24, 4, 4);
-    TEST_FIELD(EMRPOLYBEZIER16, POINTS[1], apts, 28, 4, 2);
+    TEST_FIELD(EMRPOLYBEZIER16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYBEZIER16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYBEZIER16, cpts, 24, 4, 4);
+    TEST_FIELD(EMRPOLYBEZIER16, apts, 28, 4, 2);
 }
 
 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);
+    TEST_FIELD(EMRPOLYBEZIERTO, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO, aptl, 28, 8, 4);
 }
 
 static void test_pack_EMRPOLYBEZIERTO16(void)
 {
     /* EMRPOLYBEZIERTO16 (pack 4) */
     TEST_TYPE(EMRPOLYBEZIERTO16, 32, 4);
-    TEST_FIELD(EMRPOLYBEZIERTO16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYBEZIERTO16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYBEZIERTO16, DWORD, cpts, 24, 4, 4);
-    TEST_FIELD(EMRPOLYBEZIERTO16, POINTS[1], apts, 28, 4, 2);
+    TEST_FIELD(EMRPOLYBEZIERTO16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO16, cpts, 24, 4, 4);
+    TEST_FIELD(EMRPOLYBEZIERTO16, apts, 28, 4, 2);
 }
 
 static void test_pack_EMRPOLYDRAW(void)
 {
     /* EMRPOLYDRAW (pack 4) */
     TEST_TYPE(EMRPOLYDRAW, 40, 4);
-    TEST_FIELD(EMRPOLYDRAW, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYDRAW, RECTL, rclBounds, 8, 16, 4);
-    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);
+    TEST_FIELD(EMRPOLYDRAW, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYDRAW, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYDRAW, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYDRAW, aptl, 28, 8, 4);
+    TEST_FIELD(EMRPOLYDRAW, abTypes, 36, 1, 1);
 }
 
 static void test_pack_EMRPOLYDRAW16(void)
 {
     /* EMRPOLYDRAW16 (pack 4) */
     TEST_TYPE(EMRPOLYDRAW16, 36, 4);
-    TEST_FIELD(EMRPOLYDRAW16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYDRAW16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYDRAW16, DWORD, cpts, 24, 4, 4);
-    TEST_FIELD(EMRPOLYDRAW16, POINTS[1], apts, 28, 4, 2);
-    TEST_FIELD(EMRPOLYDRAW16, BYTE[1], abTypes, 32, 1, 1);
+    TEST_FIELD(EMRPOLYDRAW16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYDRAW16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYDRAW16, cpts, 24, 4, 4);
+    TEST_FIELD(EMRPOLYDRAW16, apts, 28, 4, 2);
+    TEST_FIELD(EMRPOLYDRAW16, abTypes, 32, 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);
+    TEST_FIELD(EMRPOLYGON, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYGON, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYGON, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYGON, aptl, 28, 8, 4);
 }
 
 static void test_pack_EMRPOLYGON16(void)
 {
     /* EMRPOLYGON16 (pack 4) */
     TEST_TYPE(EMRPOLYGON16, 32, 4);
-    TEST_FIELD(EMRPOLYGON16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYGON16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYGON16, DWORD, cpts, 24, 4, 4);
-    TEST_FIELD(EMRPOLYGON16, POINTS[1], apts, 28, 4, 2);
+    TEST_FIELD(EMRPOLYGON16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYGON16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYGON16, cpts, 24, 4, 4);
+    TEST_FIELD(EMRPOLYGON16, apts, 28, 4, 2);
 }
 
 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);
+    TEST_FIELD(EMRPOLYLINE, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYLINE, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYLINE, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYLINE, aptl, 28, 8, 4);
 }
 
 static void test_pack_EMRPOLYLINE16(void)
 {
     /* EMRPOLYLINE16 (pack 4) */
     TEST_TYPE(EMRPOLYLINE16, 32, 4);
-    TEST_FIELD(EMRPOLYLINE16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYLINE16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYLINE16, DWORD, cpts, 24, 4, 4);
-    TEST_FIELD(EMRPOLYLINE16, POINTS[1], apts, 28, 4, 2);
+    TEST_FIELD(EMRPOLYLINE16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYLINE16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYLINE16, cpts, 24, 4, 4);
+    TEST_FIELD(EMRPOLYLINE16, apts, 28, 4, 2);
 }
 
 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);
+    TEST_FIELD(EMRPOLYLINETO, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYLINETO, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYLINETO, cptl, 24, 4, 4);
+    TEST_FIELD(EMRPOLYLINETO, aptl, 28, 8, 4);
 }
 
 static void test_pack_EMRPOLYLINETO16(void)
 {
     /* EMRPOLYLINETO16 (pack 4) */
     TEST_TYPE(EMRPOLYLINETO16, 32, 4);
-    TEST_FIELD(EMRPOLYLINETO16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYLINETO16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYLINETO16, DWORD, cpts, 24, 4, 4);
-    TEST_FIELD(EMRPOLYLINETO16, POINTS[1], apts, 28, 4, 2);
+    TEST_FIELD(EMRPOLYLINETO16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYLINETO16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYLINETO16, cpts, 24, 4, 4);
+    TEST_FIELD(EMRPOLYLINETO16, apts, 28, 4, 2);
 }
 
 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);
+    TEST_FIELD(EMRPOLYPOLYGON, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, nPolys, 24, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, cptl, 28, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, aPolyCounts, 32, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON, aptl, 36, 8, 4);
 }
 
 static void test_pack_EMRPOLYPOLYGON16(void)
 {
     /* EMRPOLYPOLYGON16 (pack 4) */
     TEST_TYPE(EMRPOLYPOLYGON16, 40, 4);
-    TEST_FIELD(EMRPOLYPOLYGON16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYPOLYGON16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYPOLYGON16, DWORD, nPolys, 24, 4, 4);
-    TEST_FIELD(EMRPOLYPOLYGON16, DWORD, cpts, 28, 4, 4);
-    TEST_FIELD(EMRPOLYPOLYGON16, DWORD[1], aPolyCounts, 32, 4, 4);
-    TEST_FIELD(EMRPOLYPOLYGON16, POINTS[1], apts, 36, 4, 2);
+    TEST_FIELD(EMRPOLYPOLYGON16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYPOLYGON16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYPOLYGON16, nPolys, 24, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON16, cpts, 28, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON16, aPolyCounts, 32, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYGON16, apts, 36, 4, 2);
 }
 
 static void test_pack_EMRPOLYPOLYLINE(void)
 {
     /* EMRPOLYPOLYLINE (pack 4) */
     TEST_TYPE(EMRPOLYPOLYLINE, 44, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE, DWORD, nPolys, 24, 4, 4);
-    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);
+    TEST_FIELD(EMRPOLYPOLYLINE, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE, nPolys, 24, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE, cptl, 28, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE, aPolyCounts, 32, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE, aptl, 36, 8, 4);
 }
 
 static void test_pack_EMRPOLYPOLYLINE16(void)
 {
     /* EMRPOLYPOLYLINE16 (pack 4) */
     TEST_TYPE(EMRPOLYPOLYLINE16, 40, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE16, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE16, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE16, DWORD, nPolys, 24, 4, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE16, DWORD, cpts, 28, 4, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE16, DWORD[1], aPolyCounts, 32, 4, 4);
-    TEST_FIELD(EMRPOLYPOLYLINE16, POINTS[1], apts, 36, 4, 2);
+    TEST_FIELD(EMRPOLYPOLYLINE16, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE16, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE16, nPolys, 24, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE16, cpts, 28, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE16, aPolyCounts, 32, 4, 4);
+    TEST_FIELD(EMRPOLYPOLYLINE16, apts, 36, 4, 2);
 }
 
 static void test_pack_EMRPOLYTEXTOUTA(void)
 {
     /* EMRPOLYTEXTOUTA (pack 4) */
     TEST_TYPE(EMRPOLYTEXTOUTA, 80, 4);
-    TEST_FIELD(EMRPOLYTEXTOUTA, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRPOLYTEXTOUTA, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRPOLYTEXTOUTA, DWORD, iGraphicsMode, 24, 4, 4);
-    TEST_FIELD(EMRPOLYTEXTOUTA, FLOAT, exScale, 28, 4, 4);
-    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);
+    TEST_FIELD(EMRPOLYTEXTOUTA, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTA, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTA, iGraphicsMode, 24, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTA, exScale, 28, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTA, eyScale, 32, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTA, cStrings, 36, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTA, 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);
+    TEST_FIELD(EMRPOLYTEXTOUTW, emr, 0, 8, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, iGraphicsMode, 24, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, exScale, 28, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, eyScale, 32, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, cStrings, 36, 4, 4);
+    TEST_FIELD(EMRPOLYTEXTOUTW, 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);
+    TEST_FIELD(EMRREALIZEPALETTE, 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);
+    TEST_FIELD(EMRRECTANGLE, emr, 0, 8, 4);
+    TEST_FIELD(EMRRECTANGLE, 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);
+    TEST_FIELD(EMRRESIZEPALETTE, emr, 0, 8, 4);
+    TEST_FIELD(EMRRESIZEPALETTE, ihPal, 8, 4, 4);
+    TEST_FIELD(EMRRESIZEPALETTE, 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);
+    TEST_FIELD(EMRRESTOREDC, emr, 0, 8, 4);
+    TEST_FIELD(EMRRESTOREDC, 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);
+    TEST_FIELD(EMRROUNDRECT, emr, 0, 8, 4);
+    TEST_FIELD(EMRROUNDRECT, rclBox, 8, 16, 4);
+    TEST_FIELD(EMRROUNDRECT, 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);
+    TEST_FIELD(EMRSAVEDC, 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);
-    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xNum, 8, 4, 4);
-    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, xDenom, 12, 4, 4);
-    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yNum, 16, 4, 4);
-    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, LONG, yDenom, 20, 4, 4);
+    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, xNum, 8, 4, 4);
+    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, xDenom, 12, 4, 4);
+    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, yNum, 16, 4, 4);
+    TEST_FIELD(EMRSCALEVIEWPORTEXTEX, 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);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, xNum, 8, 4, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, xDenom, 12, 4, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, yNum, 16, 4, 4);
+    TEST_FIELD(EMRSCALEWINDOWEXTEX, 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);
+    TEST_FIELD(EMRSELECTCLIPPATH, emr, 0, 8, 4);
+    TEST_FIELD(EMRSELECTCLIPPATH, 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);
+    TEST_FIELD(EMRSELECTCOLORSPACE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSELECTCOLORSPACE, 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);
+    TEST_FIELD(EMRSELECTOBJECT, emr, 0, 8, 4);
+    TEST_FIELD(EMRSELECTOBJECT, 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);
+    TEST_FIELD(EMRSELECTPALETTE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSELECTPALETTE, 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);
+    TEST_FIELD(EMRSETARCDIRECTION, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETARCDIRECTION, 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);
+    TEST_FIELD(EMRSETBKCOLOR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETBKCOLOR, 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);
+    TEST_FIELD(EMRSETBKMODE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETBKMODE, 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);
+    TEST_FIELD(EMRSETBRUSHORGEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETBRUSHORGEX, 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);
+    TEST_FIELD(EMRSETCOLORADJUSTMENT, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETCOLORADJUSTMENT, ColorAdjustment, 8, 24, 2);
 }
 
 static void test_pack_EMRSETCOLORSPACE(void)
 {
     /* EMRSETCOLORSPACE (pack 4) */
     TEST_TYPE(EMRSETCOLORSPACE, 12, 4);
-    TEST_FIELD(EMRSETCOLORSPACE, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRSETCOLORSPACE, DWORD, ihCS, 8, 4, 4);
+    TEST_FIELD(EMRSETCOLORSPACE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETCOLORSPACE, ihCS, 8, 4, 4);
 }
 
 static void test_pack_EMRSETDIBITSTODEVICE(void)
 {
     /* EMRSETDIBITSTODEVICE (pack 4) */
     TEST_TYPE(EMRSETDIBITSTODEVICE, 76, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xDest, 24, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, yDest, 28, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, xSrc, 32, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, ySrc, 36, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cxSrc, 40, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, LONG, cySrc, 44, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBmiSrc, 48, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBmiSrc, 52, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, offBitsSrc, 56, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cbBitsSrc, 60, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iUsageSrc, 64, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, iStartScan, 68, 4, 4);
-    TEST_FIELD(EMRSETDIBITSTODEVICE, DWORD, cScans, 72, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, xDest, 24, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, yDest, 28, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, xSrc, 32, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, ySrc, 36, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, cxSrc, 40, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, cySrc, 44, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, offBmiSrc, 48, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, cbBmiSrc, 52, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, offBitsSrc, 56, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, cbBitsSrc, 60, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, iUsageSrc, 64, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, iStartScan, 68, 4, 4);
+    TEST_FIELD(EMRSETDIBITSTODEVICE, 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);
+    TEST_FIELD(EMRSETICMMODE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETICMMODE, iMode, 8, 4, 4);
 }
 
 static void test_pack_EMRSETLAYOUT(void)
 {
     /* EMRSETLAYOUT (pack 4) */
     TEST_TYPE(EMRSETLAYOUT, 12, 4);
-    TEST_FIELD(EMRSETLAYOUT, EMR, emr, 0, 8, 4);
-    TEST_FIELD(EMRSETLAYOUT, DWORD, iMode, 8, 4, 4);
+    TEST_FIELD(EMRSETLAYOUT, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETLAYOUT, 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);
+    TEST_FIELD(EMRSETMAPMODE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETMAPMODE, 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);
+    TEST_FIELD(EMRSETMAPPERFLAGS, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETMAPPERFLAGS, 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);
+    TEST_FIELD(EMRSETMETARGN, 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);
+    TEST_FIELD(EMRSETMITERLIMIT, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETMITERLIMIT, 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);
+    TEST_FIELD(EMRSETPIXELV, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETPIXELV, ptlPixel, 8, 8, 4);
+    TEST_FIELD(EMRSETPIXELV, 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);
+    TEST_FIELD(EMRSETPOLYFILLMODE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETPOLYFILLMODE, 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);
+    TEST_FIELD(EMRSETROP2, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETROP2, 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);
+    TEST_FIELD(EMRSETSTRETCHBLTMODE, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETSTRETCHBLTMODE, 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);
+    TEST_FIELD(EMRSETTEXTALIGN, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETTEXTALIGN, 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);
+    TEST_FIELD(EMRSETTEXTCOLOR, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETTEXTCOLOR, 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);
+    TEST_FIELD(EMRSETVIEWPORTEXTEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETVIEWPORTEXTEX, 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);
+    TEST_FIELD(EMRSETVIEWPORTORGEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETVIEWPORTORGEX, 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);
+    TEST_FIELD(EMRSETWINDOWEXTEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETWINDOWEXTEX, 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);
+    TEST_FIELD(EMRSETWINDOWORGEX, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETWINDOWORGEX, 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);
+    TEST_FIELD(EMRSETWORLDTRANSFORM, emr, 0, 8, 4);
+    TEST_FIELD(EMRSETWORLDTRANSFORM, 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);
-    TEST_FIELD(EMRSTRETCHBLT, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, xDest, 24, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, yDest, 28, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, cxDest, 32, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, cyDest, 36, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, DWORD, dwRop, 40, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, xSrc, 44, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, ySrc, 48, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, XFORM, xformSrc, 52, 24, 4);
-    TEST_FIELD(EMRSTRETCHBLT, COLORREF, crBkColorSrc, 76, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, DWORD, iUsageSrc, 80, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, DWORD, offBmiSrc, 84, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBmiSrc, 88, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, DWORD, offBitsSrc, 92, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, DWORD, cbBitsSrc, 96, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, cxSrc, 100, 4, 4);
-    TEST_FIELD(EMRSTRETCHBLT, LONG, cySrc, 104, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, emr, 0, 8, 4);
+    TEST_FIELD(EMRSTRETCHBLT, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRSTRETCHBLT, xDest, 24, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, yDest, 28, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, cxDest, 32, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, cyDest, 36, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, dwRop, 40, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, xSrc, 44, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, ySrc, 48, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, xformSrc, 52, 24, 4);
+    TEST_FIELD(EMRSTRETCHBLT, crBkColorSrc, 76, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, iUsageSrc, 80, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, offBmiSrc, 84, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, cbBmiSrc, 88, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, offBitsSrc, 92, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, cbBitsSrc, 96, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, cxSrc, 100, 4, 4);
+    TEST_FIELD(EMRSTRETCHBLT, 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);
-    TEST_FIELD(EMRSTRETCHDIBITS, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, xDest, 24, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, yDest, 28, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, xSrc, 32, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, ySrc, 36, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxSrc, 40, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, cySrc, 44, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, DWORD, offBmiSrc, 48, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, DWORD, cbBmiSrc, 52, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, DWORD, offBitsSrc, 56, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, DWORD, cbBitsSrc, 60, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, DWORD, iUsageSrc, 64, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, DWORD, dwRop, 68, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, cxDest, 72, 4, 4);
-    TEST_FIELD(EMRSTRETCHDIBITS, LONG, cyDest, 76, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, emr, 0, 8, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, rclBounds, 8, 16, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, xDest, 24, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, yDest, 28, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, xSrc, 32, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, ySrc, 36, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, cxSrc, 40, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, cySrc, 44, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, offBmiSrc, 48, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, cbBmiSrc, 52, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, offBitsSrc, 56, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, cbBitsSrc, 60, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, iUsageSrc, 64, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, dwRop, 68, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, cxDest, 72, 4, 4);
+    TEST_FIELD(EMRSTRETCHDIBITS, 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);
+    TEST_FIELD(EMRSTROKEANDFILLPATH, emr, 0, 8, 4);
+    TEST_FIELD(EMRSTROKEANDFILLPATH, 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);
+    TEST_FIELD(EMRSTROKEPATH, emr, 0, 8, 4);
+    TEST_FIELD(EMRSTROKEPATH, 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);
-    TEST_FIELD(EMRTEXT, DWORD, nChars, 8, 4, 4);
-    TEST_FIELD(EMRTEXT, DWORD, offString, 12, 4, 4);
-    TEST_FIELD(EMRTEXT, DWORD, fOptions, 16, 4, 4);
-    TEST_FIELD(EMRTEXT, RECTL, rcl, 20, 16, 4);
-    TEST_FIELD(EMRTEXT, DWORD, offDx, 36, 4, 4);
+    TEST_FIELD(EMRTEXT, ptlReference, 0, 8, 4);
+    TEST_FIELD(EMRTEXT, nChars, 8, 4, 4);
+    TEST_FIELD(EMRTEXT, offString, 12, 4, 4);
+    TEST_FIELD(EMRTEXT, fOptions, 16, 4, 4);
+    TEST_FIELD(EMRTEXT, rcl, 20, 16, 4);
+    TEST_FIELD(EMRTEXT, 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);
+    TEST_FIELD(EMRWIDENPATH, emr, 0, 8, 4);
 }
 
 static void test_pack_ENHMETAHEADER(void)
 {
     /* ENHMETAHEADER (pack 4) */
     TEST_TYPE(ENHMETAHEADER, 108, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, iType, 0, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, nSize, 4, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, RECTL, rclBounds, 8, 16, 4);
-    TEST_FIELD(ENHMETAHEADER, RECTL, rclFrame, 24, 16, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, dSignature, 40, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, nVersion, 44, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, nBytes, 48, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, nRecords, 52, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, WORD, nHandles, 56, 2, 2);
-    TEST_FIELD(ENHMETAHEADER, WORD, sReserved, 58, 2, 2);
-    TEST_FIELD(ENHMETAHEADER, DWORD, nDescription, 60, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, offDescription, 64, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, nPalEntries, 68, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, SIZEL, szlDevice, 72, 8, 4);
-    TEST_FIELD(ENHMETAHEADER, SIZEL, szlMillimeters, 80, 8, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, cbPixelFormat, 88, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, offPixelFormat, 92, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, DWORD, bOpenGL, 96, 4, 4);
-    TEST_FIELD(ENHMETAHEADER, SIZEL, szlMicrometers, 100, 8, 4);
+    TEST_FIELD(ENHMETAHEADER, iType, 0, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, nSize, 4, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, rclBounds, 8, 16, 4);
+    TEST_FIELD(ENHMETAHEADER, rclFrame, 24, 16, 4);
+    TEST_FIELD(ENHMETAHEADER, dSignature, 40, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, nVersion, 44, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, nBytes, 48, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, nRecords, 52, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, nHandles, 56, 2, 2);
+    TEST_FIELD(ENHMETAHEADER, sReserved, 58, 2, 2);
+    TEST_FIELD(ENHMETAHEADER, nDescription, 60, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, offDescription, 64, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, nPalEntries, 68, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, szlDevice, 72, 8, 4);
+    TEST_FIELD(ENHMETAHEADER, szlMillimeters, 80, 8, 4);
+    TEST_FIELD(ENHMETAHEADER, cbPixelFormat, 88, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, offPixelFormat, 92, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, bOpenGL, 96, 4, 4);
+    TEST_FIELD(ENHMETAHEADER, szlMicrometers, 100, 8, 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);
+    TEST_FIELD(ENHMETARECORD, iType, 0, 4, 4);
+    TEST_FIELD(ENHMETARECORD, nSize, 4, 4, 4);
+    TEST_FIELD(ENHMETARECORD, dParm, 8, 4, 4);
 }
 
 static void test_pack_ENHMFENUMPROC(void)
@@ -1504,91 +1504,91 @@ 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);
+    TEST_FIELD(ENUMLOGFONTA, elfLogFont, 0, 60, 4);
+    TEST_FIELD(ENUMLOGFONTA, elfFullName, 60, 64, 1);
+    TEST_FIELD(ENUMLOGFONTA, 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);
+    TEST_FIELD(ENUMLOGFONTEXA, elfLogFont, 0, 60, 4);
+    TEST_FIELD(ENUMLOGFONTEXA, elfFullName, 60, 64, 1);
+    TEST_FIELD(ENUMLOGFONTEXA, elfStyle, 124, 32, 1);
+    TEST_FIELD(ENUMLOGFONTEXA, 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);
+    TEST_FIELD(ENUMLOGFONTEXW, elfLogFont, 0, 92, 4);
+    TEST_FIELD(ENUMLOGFONTEXW, elfFullName, 92, 128, 2);
+    TEST_FIELD(ENUMLOGFONTEXW, elfStyle, 220, 64, 2);
+    TEST_FIELD(ENUMLOGFONTEXW, 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);
+    TEST_FIELD(ENUMLOGFONTW, elfLogFont, 0, 92, 4);
+    TEST_FIELD(ENUMLOGFONTW, elfFullName, 92, 128, 2);
+    TEST_FIELD(ENUMLOGFONTW, 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);
-    TEST_FIELD(EXTLOGFONTA, BYTE[LF_FULLFACESIZE], elfFullName, 60, 64, 1);
-    TEST_FIELD(EXTLOGFONTA, BYTE[LF_FACESIZE], elfStyle, 124, 32, 1);
-    TEST_FIELD(EXTLOGFONTA, DWORD, elfVersion, 156, 4, 4);
-    TEST_FIELD(EXTLOGFONTA, DWORD, elfStyleSize, 160, 4, 4);
-    TEST_FIELD(EXTLOGFONTA, DWORD, elfMatch, 164, 4, 4);
-    TEST_FIELD(EXTLOGFONTA, DWORD, elfReserved, 168, 4, 4);
-    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);
+    TEST_FIELD(EXTLOGFONTA, elfLogFont, 0, 60, 4);
+    TEST_FIELD(EXTLOGFONTA, elfFullName, 60, 64, 1);
+    TEST_FIELD(EXTLOGFONTA, elfStyle, 124, 32, 1);
+    TEST_FIELD(EXTLOGFONTA, elfVersion, 156, 4, 4);
+    TEST_FIELD(EXTLOGFONTA, elfStyleSize, 160, 4, 4);
+    TEST_FIELD(EXTLOGFONTA, elfMatch, 164, 4, 4);
+    TEST_FIELD(EXTLOGFONTA, elfReserved, 168, 4, 4);
+    TEST_FIELD(EXTLOGFONTA, elfVendorId, 172, 4, 1);
+    TEST_FIELD(EXTLOGFONTA, elfCulture, 176, 4, 4);
+    TEST_FIELD(EXTLOGFONTA, 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);
-    TEST_FIELD(EXTLOGFONTW, WCHAR[LF_FULLFACESIZE], elfFullName, 92, 128, 2);
-    TEST_FIELD(EXTLOGFONTW, WCHAR[LF_FACESIZE], elfStyle, 220, 64, 2);
-    TEST_FIELD(EXTLOGFONTW, DWORD, elfVersion, 284, 4, 4);
-    TEST_FIELD(EXTLOGFONTW, DWORD, elfStyleSize, 288, 4, 4);
-    TEST_FIELD(EXTLOGFONTW, DWORD, elfMatch, 292, 4, 4);
-    TEST_FIELD(EXTLOGFONTW, DWORD, elfReserved, 296, 4, 4);
-    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);
+    TEST_FIELD(EXTLOGFONTW, elfLogFont, 0, 92, 4);
+    TEST_FIELD(EXTLOGFONTW, elfFullName, 92, 128, 2);
+    TEST_FIELD(EXTLOGFONTW, elfStyle, 220, 64, 2);
+    TEST_FIELD(EXTLOGFONTW, elfVersion, 284, 4, 4);
+    TEST_FIELD(EXTLOGFONTW, elfStyleSize, 288, 4, 4);
+    TEST_FIELD(EXTLOGFONTW, elfMatch, 292, 4, 4);
+    TEST_FIELD(EXTLOGFONTW, elfReserved, 296, 4, 4);
+    TEST_FIELD(EXTLOGFONTW, elfVendorId, 300, 4, 1);
+    TEST_FIELD(EXTLOGFONTW, elfCulture, 304, 4, 4);
+    TEST_FIELD(EXTLOGFONTW, 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);
-    TEST_FIELD(EXTLOGPEN, DWORD, elpWidth, 4, 4, 4);
-    TEST_FIELD(EXTLOGPEN, UINT, elpBrushStyle, 8, 4, 4);
-    TEST_FIELD(EXTLOGPEN, COLORREF, elpColor, 12, 4, 4);
-    TEST_FIELD(EXTLOGPEN, ULONG_PTR, elpHatch, 16, 4, 4);
-    TEST_FIELD(EXTLOGPEN, DWORD, elpNumEntries, 20, 4, 4);
-    TEST_FIELD(EXTLOGPEN, DWORD[1], elpStyleEntry, 24, 4, 4);
+    TEST_FIELD(EXTLOGPEN, elpPenStyle, 0, 4, 4);
+    TEST_FIELD(EXTLOGPEN, elpWidth, 4, 4, 4);
+    TEST_FIELD(EXTLOGPEN, elpBrushStyle, 8, 4, 4);
+    TEST_FIELD(EXTLOGPEN, elpColor, 12, 4, 4);
+    TEST_FIELD(EXTLOGPEN, elpHatch, 16, 4, 4);
+    TEST_FIELD(EXTLOGPEN, elpNumEntries, 20, 4, 4);
+    TEST_FIELD(EXTLOGPEN, 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);
+    TEST_FIELD(FIXED, fract, 0, 2, 2);
+    TEST_FIELD(FIXED, value, 2, 2, 2);
 }
 
 static void test_pack_FONTENUMPROCA(void)
@@ -1607,8 +1607,8 @@ 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);
+    TEST_FIELD(FONTSIGNATURE, fsUsb, 0, 16, 4);
+    TEST_FIELD(FONTSIGNATURE, fsCsb, 16, 8, 4);
 }
 
 static void test_pack_FXPT16DOT16(void)
@@ -1627,52 +1627,52 @@ 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);
+    TEST_FIELD(GCP_RESULTSA, lStructSize, 0, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, lpOutString, 4, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, lpOrder, 8, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, lpDx, 12, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, lpCaretPos, 16, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, lpClass, 20, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, lpGlyphs, 24, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, nGlyphs, 28, 4, 4);
+    TEST_FIELD(GCP_RESULTSA, 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);
+    TEST_FIELD(GCP_RESULTSW, lStructSize, 0, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, lpOutString, 4, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, lpOrder, 8, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, lpDx, 12, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, lpCaretPos, 16, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, lpClass, 20, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, lpGlyphs, 24, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, nGlyphs, 28, 4, 4);
+    TEST_FIELD(GCP_RESULTSW, 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);
-    TEST_FIELD(GLYPHMETRICS, UINT, gmBlackBoxY, 4, 4, 4);
-    TEST_FIELD(GLYPHMETRICS, POINT, gmptGlyphOrigin, 8, 8, 4);
-    TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncX, 16, 2, 2);
-    TEST_FIELD(GLYPHMETRICS, SHORT, gmCellIncY, 18, 2, 2);
+    TEST_FIELD(GLYPHMETRICS, gmBlackBoxX, 0, 4, 4);
+    TEST_FIELD(GLYPHMETRICS, gmBlackBoxY, 4, 4, 4);
+    TEST_FIELD(GLYPHMETRICS, gmptGlyphOrigin, 8, 8, 4);
+    TEST_FIELD(GLYPHMETRICS, gmCellIncX, 16, 2, 2);
+    TEST_FIELD(GLYPHMETRICS, gmCellIncY, 18, 2, 2);
 }
 
 static void test_pack_GLYPHMETRICSFLOAT(void)
 {
     /* GLYPHMETRICSFLOAT (pack 4) */
     TEST_TYPE(GLYPHMETRICSFLOAT, 24, 4);
-    TEST_FIELD(GLYPHMETRICSFLOAT, FLOAT, gmfBlackBoxX, 0, 4, 4);
-    TEST_FIELD(GLYPHMETRICSFLOAT, FLOAT, gmfBlackBoxY, 4, 4, 4);
-    TEST_FIELD(GLYPHMETRICSFLOAT, POINTFLOAT, gmfptGlyphOrigin, 8, 8, 4);
-    TEST_FIELD(GLYPHMETRICSFLOAT, FLOAT, gmfCellIncX, 16, 4, 4);
-    TEST_FIELD(GLYPHMETRICSFLOAT, FLOAT, gmfCellIncY, 20, 4, 4);
+    TEST_FIELD(GLYPHMETRICSFLOAT, gmfBlackBoxX, 0, 4, 4);
+    TEST_FIELD(GLYPHMETRICSFLOAT, gmfBlackBoxY, 4, 4, 4);
+    TEST_FIELD(GLYPHMETRICSFLOAT, gmfptGlyphOrigin, 8, 8, 4);
+    TEST_FIELD(GLYPHMETRICSFLOAT, gmfCellIncX, 16, 4, 4);
+    TEST_FIELD(GLYPHMETRICSFLOAT, gmfCellIncY, 20, 4, 4);
 }
 
 static void test_pack_GOBJENUMPROC(void)
@@ -1685,24 +1685,24 @@ 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);
+    TEST_FIELD(GRADIENT_RECT, UpperLeft, 0, 4, 4);
+    TEST_FIELD(GRADIENT_RECT, 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);
+    TEST_FIELD(GRADIENT_TRIANGLE, Vertex1, 0, 4, 4);
+    TEST_FIELD(GRADIENT_TRIANGLE, Vertex2, 4, 4, 4);
+    TEST_FIELD(GRADIENT_TRIANGLE, 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);
+    TEST_FIELD(HANDLETABLE, objectHandle, 0, 4, 4);
 }
 
 static void test_pack_ICMENUMPROCA(void)
@@ -1721,39 +1721,39 @@ 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);
+    TEST_FIELD(KERNINGPAIR, wFirst, 0, 2, 2);
+    TEST_FIELD(KERNINGPAIR, wSecond, 2, 2, 2);
+    TEST_FIELD(KERNINGPAIR, iKernAmount, 4, 4, 4);
 }
 
 static void test_pack_LAYERPLANEDESCRIPTOR(void)
 {
     /* LAYERPLANEDESCRIPTOR (pack 4) */
     TEST_TYPE(LAYERPLANEDESCRIPTOR, 32, 4);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, WORD, nSize, 0, 2, 2);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, WORD, nVersion, 2, 2, 2);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, iPixelType, 8, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cColorBits, 9, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cRedBits, 10, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cRedShift, 11, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cGreenBits, 12, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cGreenShift, 13, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cBlueBits, 14, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cBlueShift, 15, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAlphaBits, 16, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAlphaShift, 17, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAccumBits, 18, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAccumRedBits, 19, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAccumGreenBits, 20, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAccumBlueBits, 21, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAccumAlphaBits, 22, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cDepthBits, 23, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cStencilBits, 24, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, cAuxBuffers, 25, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, iLayerPlane, 26, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, BYTE, bReserved, 27, 1, 1);
-    TEST_FIELD(LAYERPLANEDESCRIPTOR, COLORREF, crTransparent, 28, 4, 4);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, nSize, 0, 2, 2);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, nVersion, 2, 2, 2);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, dwFlags, 4, 4, 4);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, iPixelType, 8, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cColorBits, 9, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cRedBits, 10, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cRedShift, 11, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cGreenBits, 12, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cGreenShift, 13, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cBlueBits, 14, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cBlueShift, 15, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAlphaBits, 16, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAlphaShift, 17, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAccumBits, 18, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAccumRedBits, 19, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAccumGreenBits, 20, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAccumBlueBits, 21, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAccumAlphaBits, 22, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cDepthBits, 23, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cStencilBits, 24, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, cAuxBuffers, 25, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, iLayerPlane, 26, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, bReserved, 27, 1, 1);
+    TEST_FIELD(LAYERPLANEDESCRIPTOR, crTransparent, 28, 4, 4);
 }
 
 static void test_pack_LCSCSTYPE(void)
@@ -1778,99 +1778,99 @@ 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);
+    TEST_FIELD(LOCALESIGNATURE, lsUsb, 0, 16, 4);
+    TEST_FIELD(LOCALESIGNATURE, lsCsbDefault, 16, 8, 4);
+    TEST_FIELD(LOCALESIGNATURE, 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, ULONG_PTR, lbHatch, 8, 4, 4);
+    TEST_FIELD(LOGBRUSH, lbStyle, 0, 4, 4);
+    TEST_FIELD(LOGBRUSH, lbColor, 4, 4, 4);
+    TEST_FIELD(LOGBRUSH, 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);
-    TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsVersion, 4, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsSize, 8, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEA, LCSCSTYPE, lcsCSType, 12, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEA, LCSGAMUTMATCH, lcsIntent, 16, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEA, CIEXYZTRIPLE, lcsEndpoints, 20, 36, 4);
-    TEST_FIELD(LOGCOLORSPACEA, DWORD, lcsGammaRed, 56, 4, 4);
-    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);
+    TEST_FIELD(LOGCOLORSPACEA, lcsSignature, 0, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsVersion, 4, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsSize, 8, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsCSType, 12, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsIntent, 16, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsEndpoints, 20, 36, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsGammaRed, 56, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsGammaGreen, 60, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, lcsGammaBlue, 64, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEA, 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);
-    TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsVersion, 4, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsSize, 8, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEW, LCSCSTYPE, lcsCSType, 12, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEW, LCSGAMUTMATCH, lcsIntent, 16, 4, 4);
-    TEST_FIELD(LOGCOLORSPACEW, CIEXYZTRIPLE, lcsEndpoints, 20, 36, 4);
-    TEST_FIELD(LOGCOLORSPACEW, DWORD, lcsGammaRed, 56, 4, 4);
-    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);
+    TEST_FIELD(LOGCOLORSPACEW, lcsSignature, 0, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsVersion, 4, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsSize, 8, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsCSType, 12, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsIntent, 16, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsEndpoints, 20, 36, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsGammaRed, 56, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsGammaGreen, 60, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, lcsGammaBlue, 64, 4, 4);
+    TEST_FIELD(LOGCOLORSPACEW, 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);
-    TEST_FIELD(LOGFONTA, LONG, lfWidth, 4, 4, 4);
-    TEST_FIELD(LOGFONTA, LONG, lfEscapement, 8, 4, 4);
-    TEST_FIELD(LOGFONTA, LONG, lfOrientation, 12, 4, 4);
-    TEST_FIELD(LOGFONTA, LONG, lfWeight, 16, 4, 4);
-    TEST_FIELD(LOGFONTA, BYTE, lfItalic, 20, 1, 1);
-    TEST_FIELD(LOGFONTA, BYTE, lfUnderline, 21, 1, 1);
-    TEST_FIELD(LOGFONTA, BYTE, lfStrikeOut, 22, 1, 1);
-    TEST_FIELD(LOGFONTA, BYTE, lfCharSet, 23, 1, 1);
-    TEST_FIELD(LOGFONTA, BYTE, lfOutPrecision, 24, 1, 1);
-    TEST_FIELD(LOGFONTA, BYTE, lfClipPrecision, 25, 1, 1);
-    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);
+    TEST_FIELD(LOGFONTA, lfHeight, 0, 4, 4);
+    TEST_FIELD(LOGFONTA, lfWidth, 4, 4, 4);
+    TEST_FIELD(LOGFONTA, lfEscapement, 8, 4, 4);
+    TEST_FIELD(LOGFONTA, lfOrientation, 12, 4, 4);
+    TEST_FIELD(LOGFONTA, lfWeight, 16, 4, 4);
+    TEST_FIELD(LOGFONTA, lfItalic, 20, 1, 1);
+    TEST_FIELD(LOGFONTA, lfUnderline, 21, 1, 1);
+    TEST_FIELD(LOGFONTA, lfStrikeOut, 22, 1, 1);
+    TEST_FIELD(LOGFONTA, lfCharSet, 23, 1, 1);
+    TEST_FIELD(LOGFONTA, lfOutPrecision, 24, 1, 1);
+    TEST_FIELD(LOGFONTA, lfClipPrecision, 25, 1, 1);
+    TEST_FIELD(LOGFONTA, lfQuality, 26, 1, 1);
+    TEST_FIELD(LOGFONTA, lfPitchAndFamily, 27, 1, 1);
+    TEST_FIELD(LOGFONTA, 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);
-    TEST_FIELD(LOGFONTW, LONG, lfWidth, 4, 4, 4);
-    TEST_FIELD(LOGFONTW, LONG, lfEscapement, 8, 4, 4);
-    TEST_FIELD(LOGFONTW, LONG, lfOrientation, 12, 4, 4);
-    TEST_FIELD(LOGFONTW, LONG, lfWeight, 16, 4, 4);
-    TEST_FIELD(LOGFONTW, BYTE, lfItalic, 20, 1, 1);
-    TEST_FIELD(LOGFONTW, BYTE, lfUnderline, 21, 1, 1);
-    TEST_FIELD(LOGFONTW, BYTE, lfStrikeOut, 22, 1, 1);
-    TEST_FIELD(LOGFONTW, BYTE, lfCharSet, 23, 1, 1);
-    TEST_FIELD(LOGFONTW, BYTE, lfOutPrecision, 24, 1, 1);
-    TEST_FIELD(LOGFONTW, BYTE, lfClipPrecision, 25, 1, 1);
-    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);
+    TEST_FIELD(LOGFONTW, lfHeight, 0, 4, 4);
+    TEST_FIELD(LOGFONTW, lfWidth, 4, 4, 4);
+    TEST_FIELD(LOGFONTW, lfEscapement, 8, 4, 4);
+    TEST_FIELD(LOGFONTW, lfOrientation, 12, 4, 4);
+    TEST_FIELD(LOGFONTW, lfWeight, 16, 4, 4);
+    TEST_FIELD(LOGFONTW, lfItalic, 20, 1, 1);
+    TEST_FIELD(LOGFONTW, lfUnderline, 21, 1, 1);
+    TEST_FIELD(LOGFONTW, lfStrikeOut, 22, 1, 1);
+    TEST_FIELD(LOGFONTW, lfCharSet, 23, 1, 1);
+    TEST_FIELD(LOGFONTW, lfOutPrecision, 24, 1, 1);
+    TEST_FIELD(LOGFONTW, lfClipPrecision, 25, 1, 1);
+    TEST_FIELD(LOGFONTW, lfQuality, 26, 1, 1);
+    TEST_FIELD(LOGFONTW, lfPitchAndFamily, 27, 1, 1);
+    TEST_FIELD(LOGFONTW, 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);
+    TEST_FIELD(LOGPEN, lopnStyle, 0, 4, 4);
+    TEST_FIELD(LOGPEN, lopnWidth, 4, 8, 4);
+    TEST_FIELD(LOGPEN, lopnColor, 12, 4, 4);
 }
 
 static void test_pack_LPABC(void)
@@ -2358,42 +2358,42 @@ 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);
+    TEST_FIELD(MAT2, eM11, 0, 4, 2);
+    TEST_FIELD(MAT2, eM12, 4, 4, 2);
+    TEST_FIELD(MAT2, eM21, 8, 4, 2);
+    TEST_FIELD(MAT2, 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);
+    TEST_FIELD(METAFILEPICT, mm, 0, 4, 4);
+    TEST_FIELD(METAFILEPICT, xExt, 4, 4, 4);
+    TEST_FIELD(METAFILEPICT, yExt, 8, 4, 4);
+    TEST_FIELD(METAFILEPICT, 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);
-    TEST_FIELD(METAHEADER, WORD, mtHeaderSize, 2, 2, 2);
-    TEST_FIELD(METAHEADER, WORD, mtVersion, 4, 2, 2);
-    TEST_FIELD(METAHEADER, DWORD, mtSize, 6, 4, 2);
-    TEST_FIELD(METAHEADER, WORD, mtNoObjects, 10, 2, 2);
-    TEST_FIELD(METAHEADER, DWORD, mtMaxRecord, 12, 4, 2);
-    TEST_FIELD(METAHEADER, WORD, mtNoParameters, 16, 2, 2);
+    TEST_FIELD(METAHEADER, mtType, 0, 2, 2);
+    TEST_FIELD(METAHEADER, mtHeaderSize, 2, 2, 2);
+    TEST_FIELD(METAHEADER, mtVersion, 4, 2, 2);
+    TEST_FIELD(METAHEADER, mtSize, 6, 4, 2);
+    TEST_FIELD(METAHEADER, mtNoObjects, 10, 2, 2);
+    TEST_FIELD(METAHEADER, mtMaxRecord, 12, 4, 2);
+    TEST_FIELD(METAHEADER, 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);
+    TEST_FIELD(METARECORD, rdSize, 0, 4, 4);
+    TEST_FIELD(METARECORD, rdFunction, 4, 2, 2);
+    TEST_FIELD(METARECORD, rdParm, 6, 2, 2);
 }
 
 static void test_pack_MFENUMPROC(void)
@@ -2406,76 +2406,76 @@ static void test_pack_NEWTEXTMETRICA(void)
 {
     /* NEWTEXTMETRICA (pack 4) */
     TEST_TYPE(NEWTEXTMETRICA, 72, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmHeight, 0, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmAscent, 4, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmDescent, 8, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmInternalLeading, 12, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmExternalLeading, 16, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmAveCharWidth, 20, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmMaxCharWidth, 24, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmWeight, 28, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmOverhang, 32, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmDigitizedAspectX, 36, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, LONG, tmDigitizedAspectY, 40, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmFirstChar, 44, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmLastChar, 45, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmDefaultChar, 46, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmBreakChar, 47, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmItalic, 48, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmUnderlined, 49, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICA, DWORD, ntmFlags, 56, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, UINT, ntmSizeEM, 60, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, UINT, ntmCellHeight, 64, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICA, UINT, ntmAvgWidth, 68, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmHeight, 0, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmAscent, 4, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmDescent, 8, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmInternalLeading, 12, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmExternalLeading, 16, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmAveCharWidth, 20, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmMaxCharWidth, 24, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmWeight, 28, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmOverhang, 32, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmDigitizedAspectX, 36, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmDigitizedAspectY, 40, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, tmFirstChar, 44, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmLastChar, 45, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmDefaultChar, 46, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmBreakChar, 47, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmItalic, 48, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmUnderlined, 49, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmStruckOut, 50, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmPitchAndFamily, 51, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, tmCharSet, 52, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICA, ntmFlags, 56, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, ntmSizeEM, 60, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, ntmCellHeight, 64, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICA, 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);
+    TEST_FIELD(NEWTEXTMETRICEXA, ntmTm, 0, 72, 4);
+    TEST_FIELD(NEWTEXTMETRICEXA, 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);
+    TEST_FIELD(NEWTEXTMETRICEXW, ntmTm, 0, 76, 4);
+    TEST_FIELD(NEWTEXTMETRICEXW, 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);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmAscent, 4, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmDescent, 8, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmInternalLeading, 12, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmExternalLeading, 16, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmAveCharWidth, 20, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmMaxCharWidth, 24, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmWeight, 28, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmOverhang, 32, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmDigitizedAspectX, 36, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, LONG, tmDigitizedAspectY, 40, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmFirstChar, 44, 2, 2);
-    TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmLastChar, 46, 2, 2);
-    TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmDefaultChar, 48, 2, 2);
-    TEST_FIELD(NEWTEXTMETRICW, WCHAR, tmBreakChar, 50, 2, 2);
-    TEST_FIELD(NEWTEXTMETRICW, BYTE, tmItalic, 52, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICW, BYTE, tmUnderlined, 53, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
-    TEST_FIELD(NEWTEXTMETRICW, DWORD, ntmFlags, 60, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, UINT, ntmSizeEM, 64, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, UINT, ntmCellHeight, 68, 4, 4);
-    TEST_FIELD(NEWTEXTMETRICW, UINT, ntmAvgWidth, 72, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmHeight, 0, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmAscent, 4, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmDescent, 8, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmInternalLeading, 12, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmExternalLeading, 16, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmAveCharWidth, 20, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmMaxCharWidth, 24, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmWeight, 28, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmOverhang, 32, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmDigitizedAspectX, 36, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmDigitizedAspectY, 40, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, tmFirstChar, 44, 2, 2);
+    TEST_FIELD(NEWTEXTMETRICW, tmLastChar, 46, 2, 2);
+    TEST_FIELD(NEWTEXTMETRICW, tmDefaultChar, 48, 2, 2);
+    TEST_FIELD(NEWTEXTMETRICW, tmBreakChar, 50, 2, 2);
+    TEST_FIELD(NEWTEXTMETRICW, tmItalic, 52, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICW, tmUnderlined, 53, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICW, tmStruckOut, 54, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICW, tmPitchAndFamily, 55, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICW, tmCharSet, 56, 1, 1);
+    TEST_FIELD(NEWTEXTMETRICW, ntmFlags, 60, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, ntmSizeEM, 64, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, ntmCellHeight, 68, 4, 4);
+    TEST_FIELD(NEWTEXTMETRICW, ntmAvgWidth, 72, 4, 4);
 }
 
 static void test_pack_NPEXTLOGPEN(void)
@@ -2507,76 +2507,76 @@ 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);
-    TEST_FIELD(OUTLINETEXTMETRICA, PANOSE, otmPanoseNumber, 61, 10, 1);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmfsSelection, 72, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmfsType, 76, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsCharSlopeRise, 80, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmsCharSlopeRun, 84, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmItalicAngle, 88, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmEMSquare, 92, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmAscent, 96, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmDescent, 100, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmLineGap, 104, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsCapEmHeight, 108, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsXHeight, 112, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, RECT, otmrcFontBox, 116, 16, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmMacAscent, 132, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, INT, otmMacDescent, 136, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmMacLineGap, 140, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmusMinimumPPEM, 144, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSubscriptSize, 148, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSubscriptOffset, 156, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSuperscriptSize, 164, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, POINT, otmptSuperscriptOffset, 172, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICA, UINT, otmsStrikeoutSize, 180, 4, 4);
-    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);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmSize, 0, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmTextMetrics, 4, 56, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmFiller, 60, 1, 1);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmPanoseNumber, 61, 10, 1);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmfsSelection, 72, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmfsType, 76, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsCharSlopeRise, 80, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsCharSlopeRun, 84, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmItalicAngle, 88, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmEMSquare, 92, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmAscent, 96, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmDescent, 100, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmLineGap, 104, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsCapEmHeight, 108, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsXHeight, 112, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmrcFontBox, 116, 16, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmMacAscent, 132, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmMacDescent, 136, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmMacLineGap, 140, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmusMinimumPPEM, 144, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmptSubscriptSize, 148, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmptSubscriptOffset, 156, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmptSuperscriptSize, 164, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmptSuperscriptOffset, 172, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsStrikeoutSize, 180, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsStrikeoutPosition, 184, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsUnderscoreSize, 188, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmsUnderscorePosition, 192, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmpFamilyName, 196, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmpFaceName, 200, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, otmpStyleName, 204, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICA, 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);
-    TEST_FIELD(OUTLINETEXTMETRICW, PANOSE, otmPanoseNumber, 65, 10, 1);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmfsSelection, 76, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmfsType, 80, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsCharSlopeRise, 84, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmsCharSlopeRun, 88, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmItalicAngle, 92, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmEMSquare, 96, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmAscent, 100, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmDescent, 104, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmLineGap, 108, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsCapEmHeight, 112, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsXHeight, 116, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, RECT, otmrcFontBox, 120, 16, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmMacAscent, 136, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, INT, otmMacDescent, 140, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmMacLineGap, 144, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmusMinimumPPEM, 148, 4, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSubscriptSize, 152, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSubscriptOffset, 160, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSuperscriptSize, 168, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, POINT, otmptSuperscriptOffset, 176, 8, 4);
-    TEST_FIELD(OUTLINETEXTMETRICW, UINT, otmsStrikeoutSize, 184, 4, 4);
-    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);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmSize, 0, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmTextMetrics, 4, 60, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmFiller, 64, 1, 1);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmPanoseNumber, 65, 10, 1);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmfsSelection, 76, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmfsType, 80, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsCharSlopeRise, 84, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsCharSlopeRun, 88, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmItalicAngle, 92, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmEMSquare, 96, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmAscent, 100, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmDescent, 104, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmLineGap, 108, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsCapEmHeight, 112, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsXHeight, 116, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmrcFontBox, 120, 16, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmMacAscent, 136, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmMacDescent, 140, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmMacLineGap, 144, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmusMinimumPPEM, 148, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmptSubscriptSize, 152, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmptSubscriptOffset, 160, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmptSuperscriptSize, 168, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmptSuperscriptOffset, 176, 8, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsStrikeoutSize, 184, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsStrikeoutPosition, 188, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsUnderscoreSize, 192, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmsUnderscorePosition, 196, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmpFamilyName, 200, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmpFaceName, 204, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmpStyleName, 208, 4, 4);
+    TEST_FIELD(OUTLINETEXTMETRICW, otmpFullName, 212, 4, 4);
 }
 
 static void test_pack_PABC(void)
@@ -2597,16 +2597,16 @@ static void test_pack_PANOSE(void)
 {
     /* PANOSE (pack 4) */
     TEST_TYPE(PANOSE, 10, 1);
-    TEST_FIELD(PANOSE, BYTE, bFamilyType, 0, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bSerifStyle, 1, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bWeight, 2, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bProportion, 3, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bContrast, 4, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bStrokeVariation, 5, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bArmStyle, 6, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bLetterform, 7, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bMidline, 8, 1, 1);
-    TEST_FIELD(PANOSE, BYTE, bXHeight, 9, 1, 1);
+    TEST_FIELD(PANOSE, bFamilyType, 0, 1, 1);
+    TEST_FIELD(PANOSE, bSerifStyle, 1, 1, 1);
+    TEST_FIELD(PANOSE, bWeight, 2, 1, 1);
+    TEST_FIELD(PANOSE, bProportion, 3, 1, 1);
+    TEST_FIELD(PANOSE, bContrast, 4, 1, 1);
+    TEST_FIELD(PANOSE, bStrokeVariation, 5, 1, 1);
+    TEST_FIELD(PANOSE, bArmStyle, 6, 1, 1);
+    TEST_FIELD(PANOSE, bLetterform, 7, 1, 1);
+    TEST_FIELD(PANOSE, bMidline, 8, 1, 1);
+    TEST_FIELD(PANOSE, bXHeight, 9, 1, 1);
 }
 
 static void test_pack_PATTERN(void)
@@ -2729,11 +2729,11 @@ static void test_pack_PELARRAY(void)
 {
     /* PELARRAY (pack 4) */
     TEST_TYPE(PELARRAY, 20, 4);
-    TEST_FIELD(PELARRAY, LONG, paXCount, 0, 4, 4);
-    TEST_FIELD(PELARRAY, LONG, paYCount, 4, 4, 4);
-    TEST_FIELD(PELARRAY, LONG, paXExt, 8, 4, 4);
-    TEST_FIELD(PELARRAY, LONG, paYExt, 12, 4, 4);
-    TEST_FIELD(PELARRAY, BYTE, paRGBs, 16, 1, 1);
+    TEST_FIELD(PELARRAY, paXCount, 0, 4, 4);
+    TEST_FIELD(PELARRAY, paYCount, 4, 4, 4);
+    TEST_FIELD(PELARRAY, paXExt, 8, 4, 4);
+    TEST_FIELD(PELARRAY, paYExt, 12, 4, 4);
+    TEST_FIELD(PELARRAY, paRGBs, 16, 1, 1);
 }
 
 static void test_pack_PEMR(void)
@@ -3559,32 +3559,32 @@ static void test_pack_PIXELFORMATDESCRIPTOR(void)
 {
     /* PIXELFORMATDESCRIPTOR (pack 4) */
     TEST_TYPE(PIXELFORMATDESCRIPTOR, 40, 4);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nSize, 0, 2, 2);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, WORD, nVersion, 2, 2, 2);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, iPixelType, 8, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cColorBits, 9, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cRedBits, 10, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cRedShift, 11, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cGreenBits, 12, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cGreenShift, 13, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cBlueBits, 14, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cBlueShift, 15, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAlphaBits, 16, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAlphaShift, 17, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumBits, 18, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumRedBits, 19, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumGreenBits, 20, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumBlueBits, 21, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAccumAlphaBits, 22, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cDepthBits, 23, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cStencilBits, 24, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, cAuxBuffers, 25, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, iLayerType, 26, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, BYTE, bReserved, 27, 1, 1);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwLayerMask, 28, 4, 4);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwVisibleMask, 32, 4, 4);
-    TEST_FIELD(PIXELFORMATDESCRIPTOR, DWORD, dwDamageMask, 36, 4, 4);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, nSize, 0, 2, 2);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, nVersion, 2, 2, 2);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, dwFlags, 4, 4, 4);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, iPixelType, 8, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cColorBits, 9, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cRedBits, 10, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cRedShift, 11, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cGreenBits, 12, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cGreenShift, 13, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cBlueBits, 14, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cBlueShift, 15, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAlphaBits, 16, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAlphaShift, 17, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAccumBits, 18, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAccumRedBits, 19, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAccumGreenBits, 20, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAccumBlueBits, 21, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAccumAlphaBits, 22, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cDepthBits, 23, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cStencilBits, 24, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, cAuxBuffers, 25, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, iLayerType, 26, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, bReserved, 27, 1, 1);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, dwLayerMask, 28, 4, 4);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, dwVisibleMask, 32, 4, 4);
+    TEST_FIELD(PIXELFORMATDESCRIPTOR, dwDamageMask, 36, 4, 4);
 }
 
 static void test_pack_PLAYERPLANEDESCRIPTOR(void)
@@ -3654,42 +3654,42 @@ static void test_pack_POINTFLOAT(void)
 {
     /* POINTFLOAT (pack 4) */
     TEST_TYPE(POINTFLOAT, 8, 4);
-    TEST_FIELD(POINTFLOAT, FLOAT, x, 0, 4, 4);
-    TEST_FIELD(POINTFLOAT, FLOAT, y, 4, 4, 4);
+    TEST_FIELD(POINTFLOAT, x, 0, 4, 4);
+    TEST_FIELD(POINTFLOAT, y, 4, 4, 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);
+    TEST_FIELD(POINTFX, x, 0, 4, 2);
+    TEST_FIELD(POINTFX, 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);
-    TEST_FIELD(POLYTEXTA, INT, y, 4, 4, 4);
-    TEST_FIELD(POLYTEXTA, UINT, n, 8, 4, 4);
-    TEST_FIELD(POLYTEXTA, LPCSTR, lpstr, 12, 4, 4);
-    TEST_FIELD(POLYTEXTA, UINT, uiFlags, 16, 4, 4);
-    TEST_FIELD(POLYTEXTA, RECT, rcl, 20, 16, 4);
-    TEST_FIELD(POLYTEXTA, INT *, pdx, 36, 4, 4);
+    TEST_FIELD(POLYTEXTA, x, 0, 4, 4);
+    TEST_FIELD(POLYTEXTA, y, 4, 4, 4);
+    TEST_FIELD(POLYTEXTA, n, 8, 4, 4);
+    TEST_FIELD(POLYTEXTA, lpstr, 12, 4, 4);
+    TEST_FIELD(POLYTEXTA, uiFlags, 16, 4, 4);
+    TEST_FIELD(POLYTEXTA, rcl, 20, 16, 4);
+    TEST_FIELD(POLYTEXTA, 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);
-    TEST_FIELD(POLYTEXTW, INT, y, 4, 4, 4);
-    TEST_FIELD(POLYTEXTW, UINT, n, 8, 4, 4);
-    TEST_FIELD(POLYTEXTW, LPCWSTR, lpstr, 12, 4, 4);
-    TEST_FIELD(POLYTEXTW, UINT, uiFlags, 16, 4, 4);
-    TEST_FIELD(POLYTEXTW, RECT, rcl, 20, 16, 4);
-    TEST_FIELD(POLYTEXTW, INT *, pdx, 36, 4, 4);
+    TEST_FIELD(POLYTEXTW, x, 0, 4, 4);
+    TEST_FIELD(POLYTEXTW, y, 4, 4, 4);
+    TEST_FIELD(POLYTEXTW, n, 8, 4, 4);
+    TEST_FIELD(POLYTEXTW, lpstr, 12, 4, 4);
+    TEST_FIELD(POLYTEXTW, uiFlags, 16, 4, 4);
+    TEST_FIELD(POLYTEXTW, rcl, 20, 16, 4);
+    TEST_FIELD(POLYTEXTW, pdx, 36, 4, 4);
 }
 
 static void test_pack_POUTLINETEXTMETRICA(void)
@@ -3787,141 +3787,141 @@ 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);
+    TEST_FIELD(RASTERIZER_STATUS, nSize, 0, 2, 2);
+    TEST_FIELD(RASTERIZER_STATUS, wFlags, 2, 2, 2);
+    TEST_FIELD(RASTERIZER_STATUS, 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);
+    TEST_FIELD(RGBQUAD, rgbBlue, 0, 1, 1);
+    TEST_FIELD(RGBQUAD, rgbGreen, 1, 1, 1);
+    TEST_FIELD(RGBQUAD, rgbRed, 2, 1, 1);
+    TEST_FIELD(RGBQUAD, 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);
+    TEST_FIELD(RGBTRIPLE, rgbtBlue, 0, 1, 1);
+    TEST_FIELD(RGBTRIPLE, rgbtGreen, 1, 1, 1);
+    TEST_FIELD(RGBTRIPLE, 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);
+    TEST_FIELD(RGNDATA, rdh, 0, 32, 4);
+    TEST_FIELD(RGNDATA, 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);
-    TEST_FIELD(RGNDATAHEADER, DWORD, iType, 4, 4, 4);
-    TEST_FIELD(RGNDATAHEADER, DWORD, nCount, 8, 4, 4);
-    TEST_FIELD(RGNDATAHEADER, DWORD, nRgnSize, 12, 4, 4);
-    TEST_FIELD(RGNDATAHEADER, RECT, rcBound, 16, 16, 4);
+    TEST_FIELD(RGNDATAHEADER, dwSize, 0, 4, 4);
+    TEST_FIELD(RGNDATAHEADER, iType, 4, 4, 4);
+    TEST_FIELD(RGNDATAHEADER, nCount, 8, 4, 4);
+    TEST_FIELD(RGNDATAHEADER, nRgnSize, 12, 4, 4);
+    TEST_FIELD(RGNDATAHEADER, 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);
-    TEST_FIELD(TEXTMETRICA, LONG, tmAscent, 4, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmDescent, 8, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmInternalLeading, 12, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmExternalLeading, 16, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmAveCharWidth, 20, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmMaxCharWidth, 24, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmWeight, 28, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmOverhang, 32, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmDigitizedAspectX, 36, 4, 4);
-    TEST_FIELD(TEXTMETRICA, LONG, tmDigitizedAspectY, 40, 4, 4);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmFirstChar, 44, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmLastChar, 45, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmDefaultChar, 46, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmBreakChar, 47, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmItalic, 48, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmUnderlined, 49, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmStruckOut, 50, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmPitchAndFamily, 51, 1, 1);
-    TEST_FIELD(TEXTMETRICA, BYTE, tmCharSet, 52, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmHeight, 0, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmAscent, 4, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmDescent, 8, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmInternalLeading, 12, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmExternalLeading, 16, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmAveCharWidth, 20, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmMaxCharWidth, 24, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmWeight, 28, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmOverhang, 32, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmDigitizedAspectX, 36, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmDigitizedAspectY, 40, 4, 4);
+    TEST_FIELD(TEXTMETRICA, tmFirstChar, 44, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmLastChar, 45, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmDefaultChar, 46, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmBreakChar, 47, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmItalic, 48, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmUnderlined, 49, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmStruckOut, 50, 1, 1);
+    TEST_FIELD(TEXTMETRICA, tmPitchAndFamily, 51, 1, 1);
+    TEST_FIELD(TEXTMETRICA, 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);
-    TEST_FIELD(TEXTMETRICW, LONG, tmAscent, 4, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmDescent, 8, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmInternalLeading, 12, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmExternalLeading, 16, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmAveCharWidth, 20, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmMaxCharWidth, 24, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmWeight, 28, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmOverhang, 32, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmDigitizedAspectX, 36, 4, 4);
-    TEST_FIELD(TEXTMETRICW, LONG, tmDigitizedAspectY, 40, 4, 4);
-    TEST_FIELD(TEXTMETRICW, WCHAR, tmFirstChar, 44, 2, 2);
-    TEST_FIELD(TEXTMETRICW, WCHAR, tmLastChar, 46, 2, 2);
-    TEST_FIELD(TEXTMETRICW, WCHAR, tmDefaultChar, 48, 2, 2);
-    TEST_FIELD(TEXTMETRICW, WCHAR, tmBreakChar, 50, 2, 2);
-    TEST_FIELD(TEXTMETRICW, BYTE, tmItalic, 52, 1, 1);
-    TEST_FIELD(TEXTMETRICW, BYTE, tmUnderlined, 53, 1, 1);
-    TEST_FIELD(TEXTMETRICW, BYTE, tmStruckOut, 54, 1, 1);
-    TEST_FIELD(TEXTMETRICW, BYTE, tmPitchAndFamily, 55, 1, 1);
-    TEST_FIELD(TEXTMETRICW, BYTE, tmCharSet, 56, 1, 1);
+    TEST_FIELD(TEXTMETRICW, tmHeight, 0, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmAscent, 4, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmDescent, 8, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmInternalLeading, 12, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmExternalLeading, 16, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmAveCharWidth, 20, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmMaxCharWidth, 24, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmWeight, 28, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmOverhang, 32, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmDigitizedAspectX, 36, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmDigitizedAspectY, 40, 4, 4);
+    TEST_FIELD(TEXTMETRICW, tmFirstChar, 44, 2, 2);
+    TEST_FIELD(TEXTMETRICW, tmLastChar, 46, 2, 2);
+    TEST_FIELD(TEXTMETRICW, tmDefaultChar, 48, 2, 2);
+    TEST_FIELD(TEXTMETRICW, tmBreakChar, 50, 2, 2);
+    TEST_FIELD(TEXTMETRICW, tmItalic, 52, 1, 1);
+    TEST_FIELD(TEXTMETRICW, tmUnderlined, 53, 1, 1);
+    TEST_FIELD(TEXTMETRICW, tmStruckOut, 54, 1, 1);
+    TEST_FIELD(TEXTMETRICW, tmPitchAndFamily, 55, 1, 1);
+    TEST_FIELD(TEXTMETRICW, 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);
-    TEST_FIELD(TRIVERTEX, LONG, y, 4, 4, 4);
-    TEST_FIELD(TRIVERTEX, COLOR16, Red, 8, 2, 2);
-    TEST_FIELD(TRIVERTEX, COLOR16, Green, 10, 2, 2);
-    TEST_FIELD(TRIVERTEX, COLOR16, Blue, 12, 2, 2);
-    TEST_FIELD(TRIVERTEX, COLOR16, Alpha, 14, 2, 2);
+    TEST_FIELD(TRIVERTEX, x, 0, 4, 4);
+    TEST_FIELD(TRIVERTEX, y, 4, 4, 4);
+    TEST_FIELD(TRIVERTEX, Red, 8, 2, 2);
+    TEST_FIELD(TRIVERTEX, Green, 10, 2, 2);
+    TEST_FIELD(TRIVERTEX, Blue, 12, 2, 2);
+    TEST_FIELD(TRIVERTEX, 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);
+    TEST_FIELD(TTPOLYCURVE, wType, 0, 2, 2);
+    TEST_FIELD(TTPOLYCURVE, cpfx, 2, 2, 2);
+    TEST_FIELD(TTPOLYCURVE, 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);
+    TEST_FIELD(TTPOLYGONHEADER, cb, 0, 4, 4);
+    TEST_FIELD(TTPOLYGONHEADER, dwType, 4, 4, 4);
+    TEST_FIELD(TTPOLYGONHEADER, 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);
-    TEST_FIELD(XFORM, FLOAT, eM12, 4, 4, 4);
-    TEST_FIELD(XFORM, FLOAT, eM21, 8, 4, 4);
-    TEST_FIELD(XFORM, FLOAT, eM22, 12, 4, 4);
-    TEST_FIELD(XFORM, FLOAT, eDx, 16, 4, 4);
-    TEST_FIELD(XFORM, FLOAT, eDy, 20, 4, 4);
+    TEST_FIELD(XFORM, eM11, 0, 4, 4);
+    TEST_FIELD(XFORM, eM12, 4, 4, 4);
+    TEST_FIELD(XFORM, eM21, 8, 4, 4);
+    TEST_FIELD(XFORM, eM22, 12, 4, 4);
+    TEST_FIELD(XFORM, eDx, 16, 4, 4);
+    TEST_FIELD(XFORM, eDy, 20, 4, 4);
 }
 
 static void test_pack(void)
diff --git a/dlls/kernel32/tests/generated.c b/dlls/kernel32/tests/generated.c
index a5a84c4e78e..34e76e8ff49 100644
--- a/dlls/kernel32/tests/generated.c
+++ b/dlls/kernel32/tests/generated.c
@@ -86,10 +86,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -137,58 +137,58 @@ static void test_pack_OSVERSIONINFOA(void)
 {
     /* OSVERSIONINFOA (pack 4) */
     TEST_TYPE(OSVERSIONINFOA, 148, 4);
-    TEST_FIELD(OSVERSIONINFOA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
-    TEST_FIELD(OSVERSIONINFOA, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(OSVERSIONINFOA, DWORD, dwMinorVersion, 8, 4, 4);
-    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);
+    TEST_FIELD(OSVERSIONINFOA, dwOSVersionInfoSize, 0, 4, 4);
+    TEST_FIELD(OSVERSIONINFOA, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(OSVERSIONINFOA, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(OSVERSIONINFOA, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(OSVERSIONINFOA, dwPlatformId, 16, 4, 4);
+    TEST_FIELD(OSVERSIONINFOA, szCSDVersion, 20, 128, 1);
 }
 
 static void test_pack_OSVERSIONINFOEXA(void)
 {
     /* OSVERSIONINFOEXA (pack 4) */
     TEST_TYPE(OSVERSIONINFOEXA, 156, 4);
-    TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMinorVersion, 8, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwBuildNumber, 12, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwPlatformId, 16, 4, 4);
-    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);
-    TEST_FIELD(OSVERSIONINFOEXA, WORD, wSuiteMask, 152, 2, 2);
-    TEST_FIELD(OSVERSIONINFOEXA, BYTE, wProductType, 154, 1, 1);
-    TEST_FIELD(OSVERSIONINFOEXA, BYTE, wReserved, 155, 1, 1);
+    TEST_FIELD(OSVERSIONINFOEXA, dwOSVersionInfoSize, 0, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXA, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXA, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXA, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXA, dwPlatformId, 16, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXA, szCSDVersion, 20, 128, 1);
+    TEST_FIELD(OSVERSIONINFOEXA, wServicePackMajor, 148, 2, 2);
+    TEST_FIELD(OSVERSIONINFOEXA, wServicePackMinor, 150, 2, 2);
+    TEST_FIELD(OSVERSIONINFOEXA, wSuiteMask, 152, 2, 2);
+    TEST_FIELD(OSVERSIONINFOEXA, wProductType, 154, 1, 1);
+    TEST_FIELD(OSVERSIONINFOEXA, wReserved, 155, 1, 1);
 }
 
 static void test_pack_OSVERSIONINFOEXW(void)
 {
     /* OSVERSIONINFOEXW (pack 4) */
     TEST_TYPE(OSVERSIONINFOEXW, 284, 4);
-    TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
-    TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
-    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);
-    TEST_FIELD(OSVERSIONINFOEXW, WORD, wSuiteMask, 280, 2, 2);
-    TEST_FIELD(OSVERSIONINFOEXW, BYTE, wProductType, 282, 1, 1);
-    TEST_FIELD(OSVERSIONINFOEXW, BYTE, wReserved, 283, 1, 1);
+    TEST_FIELD(OSVERSIONINFOEXW, dwOSVersionInfoSize, 0, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXW, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXW, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXW, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXW, dwPlatformId, 16, 4, 4);
+    TEST_FIELD(OSVERSIONINFOEXW, szCSDVersion, 20, 256, 2);
+    TEST_FIELD(OSVERSIONINFOEXW, wServicePackMajor, 276, 2, 2);
+    TEST_FIELD(OSVERSIONINFOEXW, wServicePackMinor, 278, 2, 2);
+    TEST_FIELD(OSVERSIONINFOEXW, wSuiteMask, 280, 2, 2);
+    TEST_FIELD(OSVERSIONINFOEXW, wProductType, 282, 1, 1);
+    TEST_FIELD(OSVERSIONINFOEXW, wReserved, 283, 1, 1);
 }
 
 static void test_pack_OSVERSIONINFOW(void)
 {
     /* OSVERSIONINFOW (pack 4) */
     TEST_TYPE(OSVERSIONINFOW, 276, 4);
-    TEST_FIELD(OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
-    TEST_FIELD(OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
-    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);
+    TEST_FIELD(OSVERSIONINFOW, dwOSVersionInfoSize, 0, 4, 4);
+    TEST_FIELD(OSVERSIONINFOW, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(OSVERSIONINFOW, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(OSVERSIONINFOW, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(OSVERSIONINFOW, dwPlatformId, 16, 4, 4);
+    TEST_FIELD(OSVERSIONINFOW, szCSDVersion, 20, 256, 2);
 }
 
 static void test_pack_POSVERSIONINFOA(void)
@@ -241,181 +241,181 @@ static void test_pack_ACTCTXA(void)
 {
     /* ACTCTXA (pack 4) */
     TEST_TYPE(ACTCTXA, 32, 4);
-    TEST_FIELD(ACTCTXA, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(ACTCTXA, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(ACTCTXA, LPCSTR, lpSource, 8, 4, 4);
-    TEST_FIELD(ACTCTXA, USHORT, wProcessorArchitecture, 12, 2, 2);
-    TEST_FIELD(ACTCTXA, LANGID, wLangId, 14, 2, 2);
-    TEST_FIELD(ACTCTXA, LPCSTR, lpAssemblyDirectory, 16, 4, 4);
-    TEST_FIELD(ACTCTXA, LPCSTR, lpResourceName, 20, 4, 4);
-    TEST_FIELD(ACTCTXA, LPCSTR, lpApplicationName, 24, 4, 4);
-    TEST_FIELD(ACTCTXA, HMODULE, hModule, 28, 4, 4);
+    TEST_FIELD(ACTCTXA, cbSize, 0, 4, 4);
+    TEST_FIELD(ACTCTXA, dwFlags, 4, 4, 4);
+    TEST_FIELD(ACTCTXA, lpSource, 8, 4, 4);
+    TEST_FIELD(ACTCTXA, wProcessorArchitecture, 12, 2, 2);
+    TEST_FIELD(ACTCTXA, wLangId, 14, 2, 2);
+    TEST_FIELD(ACTCTXA, lpAssemblyDirectory, 16, 4, 4);
+    TEST_FIELD(ACTCTXA, lpResourceName, 20, 4, 4);
+    TEST_FIELD(ACTCTXA, lpApplicationName, 24, 4, 4);
+    TEST_FIELD(ACTCTXA, hModule, 28, 4, 4);
 }
 
 static void test_pack_ACTCTXW(void)
 {
     /* ACTCTXW (pack 4) */
     TEST_TYPE(ACTCTXW, 32, 4);
-    TEST_FIELD(ACTCTXW, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(ACTCTXW, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(ACTCTXW, LPCWSTR, lpSource, 8, 4, 4);
-    TEST_FIELD(ACTCTXW, USHORT, wProcessorArchitecture, 12, 2, 2);
-    TEST_FIELD(ACTCTXW, LANGID, wLangId, 14, 2, 2);
-    TEST_FIELD(ACTCTXW, LPCWSTR, lpAssemblyDirectory, 16, 4, 4);
-    TEST_FIELD(ACTCTXW, LPCWSTR, lpResourceName, 20, 4, 4);
-    TEST_FIELD(ACTCTXW, LPCWSTR, lpApplicationName, 24, 4, 4);
-    TEST_FIELD(ACTCTXW, HMODULE, hModule, 28, 4, 4);
+    TEST_FIELD(ACTCTXW, cbSize, 0, 4, 4);
+    TEST_FIELD(ACTCTXW, dwFlags, 4, 4, 4);
+    TEST_FIELD(ACTCTXW, lpSource, 8, 4, 4);
+    TEST_FIELD(ACTCTXW, wProcessorArchitecture, 12, 2, 2);
+    TEST_FIELD(ACTCTXW, wLangId, 14, 2, 2);
+    TEST_FIELD(ACTCTXW, lpAssemblyDirectory, 16, 4, 4);
+    TEST_FIELD(ACTCTXW, lpResourceName, 20, 4, 4);
+    TEST_FIELD(ACTCTXW, lpApplicationName, 24, 4, 4);
+    TEST_FIELD(ACTCTXW, hModule, 28, 4, 4);
 }
 
 static void test_pack_ACTCTX_SECTION_KEYED_DATA(void)
 {
     /* ACTCTX_SECTION_KEYED_DATA (pack 4) */
     TEST_TYPE(ACTCTX_SECTION_KEYED_DATA, 64, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulDataFormatVersion, 4, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpData, 8, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulLength, 12, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpSectionGlobalData, 16, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulSectionGlobalDataLength, 20, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpSectionBase, 24, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulSectionTotalLength, 28, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, HANDLE, hActCtx, 32, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulAssemblyRosterIndex, 36, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulFlags, 40, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, AssemblyMetadata, 44, 20, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, cbSize, 0, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ulDataFormatVersion, 4, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, lpData, 8, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ulLength, 12, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, lpSectionGlobalData, 16, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ulSectionGlobalDataLength, 20, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, lpSectionBase, 24, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ulSectionTotalLength, 28, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, hActCtx, 32, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ulAssemblyRosterIndex, 36, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ulFlags, 40, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, AssemblyMetadata, 44, 20, 4);
 }
 
 static void test_pack_ACTCTX_SECTION_KEYED_DATA_2600(void)
 {
     /* ACTCTX_SECTION_KEYED_DATA_2600 (pack 4) */
     TEST_TYPE(ACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulDataFormatVersion, 4, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpData, 8, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulLength, 12, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpSectionGlobalData, 16, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulSectionGlobalDataLength, 20, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpSectionBase, 24, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulSectionTotalLength, 28, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, HANDLE, hActCtx, 32, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulAssemblyRosterIndex, 36, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, cbSize, 0, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ulDataFormatVersion, 4, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, lpData, 8, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ulLength, 12, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, lpSectionGlobalData, 16, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ulSectionGlobalDataLength, 20, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, lpSectionBase, 24, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ulSectionTotalLength, 28, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, hActCtx, 32, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ulAssemblyRosterIndex, 36, 4, 4);
 }
 
 static void test_pack_ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
 {
     /* ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA (pack 4) */
     TEST_TYPE(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpInformation, 0, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpSectionBase, 4, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ULONG, ulSectionLength, 8, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpSectionGlobalDataBase, 12, 4, 4);
-    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ULONG, ulSectionGlobalDataLength, 16, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, lpInformation, 0, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, lpSectionBase, 4, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ulSectionLength, 8, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, lpSectionGlobalDataBase, 12, 4, 4);
+    TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ulSectionGlobalDataLength, 16, 4, 4);
 }
 
 static void test_pack_ACTIVATION_CONTEXT_BASIC_INFORMATION(void)
 {
     /* ACTIVATION_CONTEXT_BASIC_INFORMATION (pack 4) */
     TEST_TYPE(ACTIVATION_CONTEXT_BASIC_INFORMATION, 8, 4);
-    TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, HANDLE, hActCtx, 0, 4, 4);
-    TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, DWORD, dwFlags, 4, 4, 4);
+    TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, hActCtx, 0, 4, 4);
+    TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, dwFlags, 4, 4, 4);
 }
 
 static void test_pack_BY_HANDLE_FILE_INFORMATION(void)
 {
     /* BY_HANDLE_FILE_INFORMATION (pack 4) */
     TEST_TYPE(BY_HANDLE_FILE_INFORMATION, 52, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, dwFileAttributes, 0, 4, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, FILETIME, ftCreationTime, 4, 8, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, FILETIME, ftLastAccessTime, 12, 8, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, FILETIME, ftLastWriteTime, 20, 8, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, dwVolumeSerialNumber, 28, 4, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileSizeHigh, 32, 4, 4);
-    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileSizeLow, 36, 4, 4);
-    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);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, dwFileAttributes, 0, 4, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, ftCreationTime, 4, 8, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, ftLastAccessTime, 12, 8, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, ftLastWriteTime, 20, 8, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, dwVolumeSerialNumber, 28, 4, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, nFileSizeHigh, 32, 4, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, nFileSizeLow, 36, 4, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, nNumberOfLinks, 40, 4, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, nFileIndexHigh, 44, 4, 4);
+    TEST_FIELD(BY_HANDLE_FILE_INFORMATION, nFileIndexLow, 48, 4, 4);
 }
 
 static void test_pack_COMMCONFIG(void)
 {
     /* COMMCONFIG (pack 4) */
     TEST_TYPE(COMMCONFIG, 52, 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);
-    TEST_FIELD(COMMCONFIG, DCB, dcb, 8, 28, 4);
-    TEST_FIELD(COMMCONFIG, DWORD, dwProviderSubType, 36, 4, 4);
-    TEST_FIELD(COMMCONFIG, DWORD, dwProviderOffset, 40, 4, 4);
-    TEST_FIELD(COMMCONFIG, DWORD, dwProviderSize, 44, 4, 4);
-    TEST_FIELD(COMMCONFIG, DWORD[1], wcProviderData, 48, 4, 4);
+    TEST_FIELD(COMMCONFIG, dwSize, 0, 4, 4);
+    TEST_FIELD(COMMCONFIG, wVersion, 4, 2, 2);
+    TEST_FIELD(COMMCONFIG, wReserved, 6, 2, 2);
+    TEST_FIELD(COMMCONFIG, dcb, 8, 28, 4);
+    TEST_FIELD(COMMCONFIG, dwProviderSubType, 36, 4, 4);
+    TEST_FIELD(COMMCONFIG, dwProviderOffset, 40, 4, 4);
+    TEST_FIELD(COMMCONFIG, dwProviderSize, 44, 4, 4);
+    TEST_FIELD(COMMCONFIG, wcProviderData, 48, 4, 4);
 }
 
 static void test_pack_COMMPROP(void)
 {
     /* COMMPROP (pack 4) */
     TEST_TYPE(COMMPROP, 64, 4);
-    TEST_FIELD(COMMPROP, WORD, wPacketLength, 0, 2, 2);
-    TEST_FIELD(COMMPROP, WORD, wPacketVersion, 2, 2, 2);
-    TEST_FIELD(COMMPROP, DWORD, dwServiceMask, 4, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwReserved1, 8, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwMaxTxQueue, 12, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwMaxRxQueue, 16, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwMaxBaud, 20, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwProvSubType, 24, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwProvCapabilities, 28, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwSettableParams, 32, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwSettableBaud, 36, 4, 4);
-    TEST_FIELD(COMMPROP, WORD, wSettableData, 40, 2, 2);
-    TEST_FIELD(COMMPROP, WORD, wSettableStopParity, 42, 2, 2);
-    TEST_FIELD(COMMPROP, DWORD, dwCurrentTxQueue, 44, 4, 4);
-    TEST_FIELD(COMMPROP, DWORD, dwCurrentRxQueue, 48, 4, 4);
-    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);
+    TEST_FIELD(COMMPROP, wPacketLength, 0, 2, 2);
+    TEST_FIELD(COMMPROP, wPacketVersion, 2, 2, 2);
+    TEST_FIELD(COMMPROP, dwServiceMask, 4, 4, 4);
+    TEST_FIELD(COMMPROP, dwReserved1, 8, 4, 4);
+    TEST_FIELD(COMMPROP, dwMaxTxQueue, 12, 4, 4);
+    TEST_FIELD(COMMPROP, dwMaxRxQueue, 16, 4, 4);
+    TEST_FIELD(COMMPROP, dwMaxBaud, 20, 4, 4);
+    TEST_FIELD(COMMPROP, dwProvSubType, 24, 4, 4);
+    TEST_FIELD(COMMPROP, dwProvCapabilities, 28, 4, 4);
+    TEST_FIELD(COMMPROP, dwSettableParams, 32, 4, 4);
+    TEST_FIELD(COMMPROP, dwSettableBaud, 36, 4, 4);
+    TEST_FIELD(COMMPROP, wSettableData, 40, 2, 2);
+    TEST_FIELD(COMMPROP, wSettableStopParity, 42, 2, 2);
+    TEST_FIELD(COMMPROP, dwCurrentTxQueue, 44, 4, 4);
+    TEST_FIELD(COMMPROP, dwCurrentRxQueue, 48, 4, 4);
+    TEST_FIELD(COMMPROP, dwProvSpec1, 52, 4, 4);
+    TEST_FIELD(COMMPROP, dwProvSpec2, 56, 4, 4);
+    TEST_FIELD(COMMPROP, 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);
-    TEST_FIELD(COMMTIMEOUTS, DWORD, ReadTotalTimeoutMultiplier, 4, 4, 4);
-    TEST_FIELD(COMMTIMEOUTS, DWORD, ReadTotalTimeoutConstant, 8, 4, 4);
-    TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutMultiplier, 12, 4, 4);
-    TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutConstant, 16, 4, 4);
+    TEST_FIELD(COMMTIMEOUTS, ReadIntervalTimeout, 0, 4, 4);
+    TEST_FIELD(COMMTIMEOUTS, ReadTotalTimeoutMultiplier, 4, 4, 4);
+    TEST_FIELD(COMMTIMEOUTS, ReadTotalTimeoutConstant, 8, 4, 4);
+    TEST_FIELD(COMMTIMEOUTS, WriteTotalTimeoutMultiplier, 12, 4, 4);
+    TEST_FIELD(COMMTIMEOUTS, 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);
+    TEST_FIELD(COMSTAT, cbInQue, 4, 4, 4);
+    TEST_FIELD(COMSTAT, 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);
-    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, HANDLE, hProcess, 4, 4, 4);
-    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, HANDLE, hThread, 8, 4, 4);
-    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPVOID, lpBaseOfImage, 12, 4, 4);
-    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, DWORD, dwDebugInfoFileOffset, 16, 4, 4);
-    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, DWORD, nDebugInfoSize, 20, 4, 4);
-    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, LPVOID, lpThreadLocalBase, 24, 4, 4);
-    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);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, hFile, 0, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, hProcess, 4, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, hThread, 8, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, lpBaseOfImage, 12, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, dwDebugInfoFileOffset, 16, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, nDebugInfoSize, 20, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, lpThreadLocalBase, 24, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, lpStartAddress, 28, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, lpImageName, 32, 4, 4);
+    TEST_FIELD(CREATE_PROCESS_DEBUG_INFO, 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);
+    TEST_FIELD(CREATE_THREAD_DEBUG_INFO, hThread, 0, 4, 4);
+    TEST_FIELD(CREATE_THREAD_DEBUG_INFO, lpThreadLocalBase, 4, 4, 4);
+    TEST_FIELD(CREATE_THREAD_DEBUG_INFO, lpStartAddress, 8, 4, 4);
 }
 
 static void test_pack_CRITICAL_SECTION(void)
@@ -433,28 +433,28 @@ static void test_pack_DCB(void)
 {
     /* DCB (pack 4) */
     TEST_TYPE(DCB, 28, 4);
-    TEST_FIELD(DCB, DWORD, DCBlength, 0, 4, 4);
-    TEST_FIELD(DCB, DWORD, BaudRate, 4, 4, 4);
-    TEST_FIELD(DCB, WORD, wReserved, 12, 2, 2);
-    TEST_FIELD(DCB, WORD, XonLim, 14, 2, 2);
-    TEST_FIELD(DCB, WORD, XoffLim, 16, 2, 2);
-    TEST_FIELD(DCB, BYTE, ByteSize, 18, 1, 1);
-    TEST_FIELD(DCB, BYTE, Parity, 19, 1, 1);
-    TEST_FIELD(DCB, BYTE, StopBits, 20, 1, 1);
-    TEST_FIELD(DCB, char, XonChar, 21, 1, 1);
-    TEST_FIELD(DCB, char, XoffChar, 22, 1, 1);
-    TEST_FIELD(DCB, char, ErrorChar, 23, 1, 1);
-    TEST_FIELD(DCB, char, EofChar, 24, 1, 1);
-    TEST_FIELD(DCB, char, EvtChar, 25, 1, 1);
-    TEST_FIELD(DCB, WORD, wReserved1, 26, 2, 2);
+    TEST_FIELD(DCB, DCBlength, 0, 4, 4);
+    TEST_FIELD(DCB, BaudRate, 4, 4, 4);
+    TEST_FIELD(DCB, wReserved, 12, 2, 2);
+    TEST_FIELD(DCB, XonLim, 14, 2, 2);
+    TEST_FIELD(DCB, XoffLim, 16, 2, 2);
+    TEST_FIELD(DCB, ByteSize, 18, 1, 1);
+    TEST_FIELD(DCB, Parity, 19, 1, 1);
+    TEST_FIELD(DCB, StopBits, 20, 1, 1);
+    TEST_FIELD(DCB, XonChar, 21, 1, 1);
+    TEST_FIELD(DCB, XoffChar, 22, 1, 1);
+    TEST_FIELD(DCB, ErrorChar, 23, 1, 1);
+    TEST_FIELD(DCB, EofChar, 24, 1, 1);
+    TEST_FIELD(DCB, EvtChar, 25, 1, 1);
+    TEST_FIELD(DCB, wReserved1, 26, 2, 2);
 }
 
 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);
+    TEST_FIELD(DEBUG_EVENT, dwDebugEventCode, 0, 4, 4);
+    TEST_FIELD(DEBUG_EVENT, dwProcessId, 4, 4, 4);
+    TEST_FIELD(DEBUG_EVENT, dwThreadId, 8, 4, 4);
 }
 
 static void test_pack_ENUMRESLANGPROCA(void)
@@ -497,52 +497,52 @@ 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);
+    TEST_FIELD(EXCEPTION_DEBUG_INFO, ExceptionRecord, 0, 80, 4);
+    TEST_FIELD(EXCEPTION_DEBUG_INFO, 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);
+    TEST_FIELD(EXIT_PROCESS_DEBUG_INFO, 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);
+    TEST_FIELD(EXIT_THREAD_DEBUG_INFO, 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);
+    TEST_FIELD(HW_PROFILE_INFOA, dwDockInfo, 0, 4, 4);
+    TEST_FIELD(HW_PROFILE_INFOA, szHwProfileGuid, 4, 39, 1);
+    TEST_FIELD(HW_PROFILE_INFOA, 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);
+    TEST_FIELD(HW_PROFILE_INFOW, dwDockInfo, 0, 4, 4);
+    TEST_FIELD(HW_PROFILE_INFOW, szHwProfileGuid, 4, 78, 2);
+    TEST_FIELD(HW_PROFILE_INFOW, szHwProfileName, 82, 160, 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);
-    TEST_FIELD(LOAD_DLL_DEBUG_INFO, LPVOID, lpBaseOfDll, 4, 4, 4);
-    TEST_FIELD(LOAD_DLL_DEBUG_INFO, DWORD, dwDebugInfoFileOffset, 8, 4, 4);
-    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);
+    TEST_FIELD(LOAD_DLL_DEBUG_INFO, hFile, 0, 4, 4);
+    TEST_FIELD(LOAD_DLL_DEBUG_INFO, lpBaseOfDll, 4, 4, 4);
+    TEST_FIELD(LOAD_DLL_DEBUG_INFO, dwDebugInfoFileOffset, 8, 4, 4);
+    TEST_FIELD(LOAD_DLL_DEBUG_INFO, nDebugInfoSize, 12, 4, 4);
+    TEST_FIELD(LOAD_DLL_DEBUG_INFO, lpImageName, 16, 4, 4);
+    TEST_FIELD(LOAD_DLL_DEBUG_INFO, fUnicode, 20, 2, 2);
 }
 
 static void test_pack_LPBY_HANDLE_FILE_INFORMATION(void)
@@ -775,50 +775,50 @@ static void test_pack_MEMORYSTATUS(void)
 {
     /* MEMORYSTATUS (pack 4) */
     TEST_TYPE(MEMORYSTATUS, 32, 4);
-    TEST_FIELD(MEMORYSTATUS, DWORD, dwLength, 0, 4, 4);
-    TEST_FIELD(MEMORYSTATUS, DWORD, dwMemoryLoad, 4, 4, 4);
-    TEST_FIELD(MEMORYSTATUS, SIZE_T, dwTotalPhys, 8, 4, 4);
-    TEST_FIELD(MEMORYSTATUS, SIZE_T, dwAvailPhys, 12, 4, 4);
-    TEST_FIELD(MEMORYSTATUS, SIZE_T, dwTotalPageFile, 16, 4, 4);
-    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);
+    TEST_FIELD(MEMORYSTATUS, dwLength, 0, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwMemoryLoad, 4, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwTotalPhys, 8, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwAvailPhys, 12, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwTotalPageFile, 16, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwAvailPageFile, 20, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwTotalVirtual, 24, 4, 4);
+    TEST_FIELD(MEMORYSTATUS, dwAvailVirtual, 28, 4, 4);
 }
 
 static void test_pack_MEMORYSTATUSEX(void)
 {
     /* MEMORYSTATUSEX (pack 8) */
     TEST_TYPE(MEMORYSTATUSEX, 64, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORD, dwLength, 0, 4, 4);
-    TEST_FIELD(MEMORYSTATUSEX, DWORD, dwMemoryLoad, 4, 4, 4);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullTotalPhys, 8, 8, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailPhys, 16, 8, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullTotalPageFile, 24, 8, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailPageFile, 32, 8, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullTotalVirtual, 40, 8, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailVirtual, 48, 8, 8);
-    TEST_FIELD(MEMORYSTATUSEX, DWORDLONG, ullAvailExtendedVirtual, 56, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, dwLength, 0, 4, 4);
+    TEST_FIELD(MEMORYSTATUSEX, dwMemoryLoad, 4, 4, 4);
+    TEST_FIELD(MEMORYSTATUSEX, ullTotalPhys, 8, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, ullAvailPhys, 16, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, ullTotalPageFile, 24, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, ullAvailPageFile, 32, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, ullTotalVirtual, 40, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, ullAvailVirtual, 48, 8, 8);
+    TEST_FIELD(MEMORYSTATUSEX, ullAvailExtendedVirtual, 56, 8, 8);
 }
 
 static void test_pack_OFSTRUCT(void)
 {
     /* OFSTRUCT (pack 4) */
     TEST_TYPE(OFSTRUCT, 136, 2);
-    TEST_FIELD(OFSTRUCT, BYTE, cBytes, 0, 1, 1);
-    TEST_FIELD(OFSTRUCT, BYTE, fFixedDisk, 1, 1, 1);
-    TEST_FIELD(OFSTRUCT, WORD, nErrCode, 2, 2, 2);
-    TEST_FIELD(OFSTRUCT, WORD, Reserved1, 4, 2, 2);
-    TEST_FIELD(OFSTRUCT, WORD, Reserved2, 6, 2, 2);
-    TEST_FIELD(OFSTRUCT, CHAR[OFS_MAXPATHNAME], szPathName, 8, 128, 1);
+    TEST_FIELD(OFSTRUCT, cBytes, 0, 1, 1);
+    TEST_FIELD(OFSTRUCT, fFixedDisk, 1, 1, 1);
+    TEST_FIELD(OFSTRUCT, nErrCode, 2, 2, 2);
+    TEST_FIELD(OFSTRUCT, Reserved1, 4, 2, 2);
+    TEST_FIELD(OFSTRUCT, Reserved2, 6, 2, 2);
+    TEST_FIELD(OFSTRUCT, szPathName, 8, 128, 1);
 }
 
 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);
+    TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, lpDebugStringData, 0, 4, 4);
+    TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, fUnicode, 4, 2, 2);
+    TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, nDebugStringLength, 6, 2, 2);
 }
 
 static void test_pack_PACTCTXA(void)
@@ -958,21 +958,21 @@ static void test_pack_PQUERYACTCTXW_FUNC(void)
 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);
+    TEST_FIELD(PROCESS_HEAP_ENTRY, lpData, 0, 4, 4);
+    TEST_FIELD(PROCESS_HEAP_ENTRY, cbData, 4, 4, 4);
+    TEST_FIELD(PROCESS_HEAP_ENTRY, cbOverhead, 8, 1, 1);
+    TEST_FIELD(PROCESS_HEAP_ENTRY, iRegionIndex, 9, 1, 1);
+    TEST_FIELD(PROCESS_HEAP_ENTRY, 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);
+    TEST_FIELD(PROCESS_INFORMATION, hProcess, 0, 4, 4);
+    TEST_FIELD(PROCESS_INFORMATION, hThread, 4, 4, 4);
+    TEST_FIELD(PROCESS_INFORMATION, dwProcessId, 8, 4, 4);
+    TEST_FIELD(PROCESS_INFORMATION, dwThreadId, 12, 4, 4);
 }
 
 static void test_pack_PSECURITY_ATTRIBUTES(void)
@@ -1020,79 +1020,79 @@ 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);
+    TEST_FIELD(RIP_INFO, dwError, 0, 4, 4);
+    TEST_FIELD(RIP_INFO, 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);
+    TEST_FIELD(SECURITY_ATTRIBUTES, nLength, 0, 4, 4);
+    TEST_FIELD(SECURITY_ATTRIBUTES, lpSecurityDescriptor, 4, 4, 4);
+    TEST_FIELD(SECURITY_ATTRIBUTES, 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);
+    TEST_FIELD(STARTUPINFOA, cb, 0, 4, 4);
+    TEST_FIELD(STARTUPINFOA, lpReserved, 4, 4, 4);
+    TEST_FIELD(STARTUPINFOA, lpDesktop, 8, 4, 4);
+    TEST_FIELD(STARTUPINFOA, lpTitle, 12, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwX, 16, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwY, 20, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwXSize, 24, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwYSize, 28, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwXCountChars, 32, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwYCountChars, 36, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwFillAttribute, 40, 4, 4);
+    TEST_FIELD(STARTUPINFOA, dwFlags, 44, 4, 4);
+    TEST_FIELD(STARTUPINFOA, wShowWindow, 48, 2, 2);
+    TEST_FIELD(STARTUPINFOA, cbReserved2, 50, 2, 2);
+    TEST_FIELD(STARTUPINFOA, lpReserved2, 52, 4, 4);
+    TEST_FIELD(STARTUPINFOA, hStdInput, 56, 4, 4);
+    TEST_FIELD(STARTUPINFOA, hStdOutput, 60, 4, 4);
+    TEST_FIELD(STARTUPINFOA, 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);
-    TEST_FIELD(STARTUPINFOW, LPWSTR, lpReserved, 4, 4, 4);
-    TEST_FIELD(STARTUPINFOW, LPWSTR, lpDesktop, 8, 4, 4);
-    TEST_FIELD(STARTUPINFOW, LPWSTR, lpTitle, 12, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwX, 16, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwY, 20, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwXSize, 24, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwYSize, 28, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwXCountChars, 32, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwYCountChars, 36, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwFillAttribute, 40, 4, 4);
-    TEST_FIELD(STARTUPINFOW, DWORD, dwFlags, 44, 4, 4);
-    TEST_FIELD(STARTUPINFOW, WORD, wShowWindow, 48, 2, 2);
-    TEST_FIELD(STARTUPINFOW, WORD, cbReserved2, 50, 2, 2);
-    TEST_FIELD(STARTUPINFOW, BYTE *, lpReserved2, 52, 4, 4);
-    TEST_FIELD(STARTUPINFOW, HANDLE, hStdInput, 56, 4, 4);
-    TEST_FIELD(STARTUPINFOW, HANDLE, hStdOutput, 60, 4, 4);
-    TEST_FIELD(STARTUPINFOW, HANDLE, hStdError, 64, 4, 4);
+    TEST_FIELD(STARTUPINFOW, cb, 0, 4, 4);
+    TEST_FIELD(STARTUPINFOW, lpReserved, 4, 4, 4);
+    TEST_FIELD(STARTUPINFOW, lpDesktop, 8, 4, 4);
+    TEST_FIELD(STARTUPINFOW, lpTitle, 12, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwX, 16, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwY, 20, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwXSize, 24, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwYSize, 28, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwXCountChars, 32, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwYCountChars, 36, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwFillAttribute, 40, 4, 4);
+    TEST_FIELD(STARTUPINFOW, dwFlags, 44, 4, 4);
+    TEST_FIELD(STARTUPINFOW, wShowWindow, 48, 2, 2);
+    TEST_FIELD(STARTUPINFOW, cbReserved2, 50, 2, 2);
+    TEST_FIELD(STARTUPINFOW, lpReserved2, 52, 4, 4);
+    TEST_FIELD(STARTUPINFOW, hStdInput, 56, 4, 4);
+    TEST_FIELD(STARTUPINFOW, hStdOutput, 60, 4, 4);
+    TEST_FIELD(STARTUPINFOW, 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);
-    TEST_FIELD(SYSTEMTIME, WORD, wMonth, 2, 2, 2);
-    TEST_FIELD(SYSTEMTIME, WORD, wDayOfWeek, 4, 2, 2);
-    TEST_FIELD(SYSTEMTIME, WORD, wDay, 6, 2, 2);
-    TEST_FIELD(SYSTEMTIME, WORD, wHour, 8, 2, 2);
-    TEST_FIELD(SYSTEMTIME, WORD, wMinute, 10, 2, 2);
-    TEST_FIELD(SYSTEMTIME, WORD, wSecond, 12, 2, 2);
-    TEST_FIELD(SYSTEMTIME, WORD, wMilliseconds, 14, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wYear, 0, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wMonth, 2, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wDayOfWeek, 4, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wDay, 6, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wHour, 8, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wMinute, 10, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wSecond, 12, 2, 2);
+    TEST_FIELD(SYSTEMTIME, wMilliseconds, 14, 2, 2);
 }
 
 static void test_pack_SYSTEM_INFO(void)
@@ -1104,32 +1104,32 @@ 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);
-    TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, BatteryFlag, 1, 1, 1);
-    TEST_FIELD(SYSTEM_POWER_STATUS, BYTE, BatteryLifePercent, 2, 1, 1);
-    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);
+    TEST_FIELD(SYSTEM_POWER_STATUS, ACLineStatus, 0, 1, 1);
+    TEST_FIELD(SYSTEM_POWER_STATUS, BatteryFlag, 1, 1, 1);
+    TEST_FIELD(SYSTEM_POWER_STATUS, BatteryLifePercent, 2, 1, 1);
+    TEST_FIELD(SYSTEM_POWER_STATUS, Reserved1, 3, 1, 1);
+    TEST_FIELD(SYSTEM_POWER_STATUS, BatteryLifeTime, 4, 4, 4);
+    TEST_FIELD(SYSTEM_POWER_STATUS, 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);
-    TEST_FIELD(TIME_ZONE_INFORMATION, WCHAR[32], StandardName, 4, 64, 2);
-    TEST_FIELD(TIME_ZONE_INFORMATION, SYSTEMTIME, StandardDate, 68, 16, 2);
-    TEST_FIELD(TIME_ZONE_INFORMATION, LONG, StandardBias, 84, 4, 4);
-    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);
+    TEST_FIELD(TIME_ZONE_INFORMATION, Bias, 0, 4, 4);
+    TEST_FIELD(TIME_ZONE_INFORMATION, StandardName, 4, 64, 2);
+    TEST_FIELD(TIME_ZONE_INFORMATION, StandardDate, 68, 16, 2);
+    TEST_FIELD(TIME_ZONE_INFORMATION, StandardBias, 84, 4, 4);
+    TEST_FIELD(TIME_ZONE_INFORMATION, DaylightName, 88, 64, 2);
+    TEST_FIELD(TIME_ZONE_INFORMATION, DaylightDate, 152, 16, 2);
+    TEST_FIELD(TIME_ZONE_INFORMATION, 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);
+    TEST_FIELD(UNLOAD_DLL_DEBUG_INFO, lpBaseOfDll, 0, 4, 4);
 }
 
 static void test_pack_WAITORTIMERCALLBACK(void)
@@ -1142,55 +1142,55 @@ 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);
-    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, FILETIME, ftCreationTime, 4, 8, 4);
-    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, FILETIME, ftLastAccessTime, 12, 8, 4);
-    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);
+    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, dwFileAttributes, 0, 4, 4);
+    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, ftCreationTime, 4, 8, 4);
+    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, ftLastAccessTime, 12, 8, 4);
+    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, ftLastWriteTime, 20, 8, 4);
+    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeHigh, 28, 4, 4);
+    TEST_FIELD(WIN32_FILE_ATTRIBUTE_DATA, 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);
-    TEST_FIELD(WIN32_FIND_DATAA, FILETIME, ftCreationTime, 4, 8, 4);
-    TEST_FIELD(WIN32_FIND_DATAA, FILETIME, ftLastAccessTime, 12, 8, 4);
-    TEST_FIELD(WIN32_FIND_DATAA, FILETIME, ftLastWriteTime, 20, 8, 4);
-    TEST_FIELD(WIN32_FIND_DATAA, DWORD, nFileSizeHigh, 28, 4, 4);
-    TEST_FIELD(WIN32_FIND_DATAA, DWORD, nFileSizeLow, 32, 4, 4);
-    TEST_FIELD(WIN32_FIND_DATAA, DWORD, dwReserved0, 36, 4, 4);
-    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);
+    TEST_FIELD(WIN32_FIND_DATAA, dwFileAttributes, 0, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, ftCreationTime, 4, 8, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, ftLastAccessTime, 12, 8, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, ftLastWriteTime, 20, 8, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, nFileSizeHigh, 28, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, nFileSizeLow, 32, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, dwReserved0, 36, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, dwReserved1, 40, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAA, cFileName, 44, 260, 1);
+    TEST_FIELD(WIN32_FIND_DATAA, 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);
-    TEST_FIELD(WIN32_FIND_DATAW, FILETIME, ftCreationTime, 4, 8, 4);
-    TEST_FIELD(WIN32_FIND_DATAW, FILETIME, ftLastAccessTime, 12, 8, 4);
-    TEST_FIELD(WIN32_FIND_DATAW, FILETIME, ftLastWriteTime, 20, 8, 4);
-    TEST_FIELD(WIN32_FIND_DATAW, DWORD, nFileSizeHigh, 28, 4, 4);
-    TEST_FIELD(WIN32_FIND_DATAW, DWORD, nFileSizeLow, 32, 4, 4);
-    TEST_FIELD(WIN32_FIND_DATAW, DWORD, dwReserved0, 36, 4, 4);
-    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);
+    TEST_FIELD(WIN32_FIND_DATAW, dwFileAttributes, 0, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, ftCreationTime, 4, 8, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, ftLastAccessTime, 12, 8, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, ftLastWriteTime, 20, 8, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, nFileSizeHigh, 28, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, nFileSizeLow, 32, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, dwReserved0, 36, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, dwReserved1, 40, 4, 4);
+    TEST_FIELD(WIN32_FIND_DATAW, cFileName, 44, 520, 2);
+    TEST_FIELD(WIN32_FIND_DATAW, cAlternateFileName, 564, 28, 2);
 }
 
 static void test_pack_WIN32_STREAM_ID(void)
 {
     /* WIN32_STREAM_ID (pack 8) */
     TEST_TYPE(WIN32_STREAM_ID, 24, 8);
-    TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamId, 0, 4, 4);
-    TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamAttributes, 4, 4, 4);
-    TEST_FIELD(WIN32_STREAM_ID, LARGE_INTEGER, Size, 8, 8, 8);
-    TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamNameSize, 16, 4, 4);
-    TEST_FIELD(WIN32_STREAM_ID, WCHAR[ANYSIZE_ARRAY], cStreamName, 20, 2, 2);
+    TEST_FIELD(WIN32_STREAM_ID, dwStreamId, 0, 4, 4);
+    TEST_FIELD(WIN32_STREAM_ID, dwStreamAttributes, 4, 4, 4);
+    TEST_FIELD(WIN32_STREAM_ID, Size, 8, 8, 8);
+    TEST_FIELD(WIN32_STREAM_ID, dwStreamNameSize, 16, 4, 4);
+    TEST_FIELD(WIN32_STREAM_ID, cStreamName, 20, 2, 2);
 }
 
 static void test_pack(void)
diff --git a/dlls/ntdll/tests/generated.c b/dlls/ntdll/tests/generated.c
index 08195222c15..a362fd30042 100644
--- a/dlls/ntdll/tests/generated.c
+++ b/dlls/ntdll/tests/generated.c
@@ -86,10 +86,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -267,18 +267,18 @@ 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);
+    TEST_FIELD(ACCESS_ALLOWED_ACE, Header, 0, 4, 2);
+    TEST_FIELD(ACCESS_ALLOWED_ACE, Mask, 4, 4, 4);
+    TEST_FIELD(ACCESS_ALLOWED_ACE, 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);
+    TEST_FIELD(ACCESS_DENIED_ACE, Header, 0, 4, 2);
+    TEST_FIELD(ACCESS_DENIED_ACE, Mask, 4, 4, 4);
+    TEST_FIELD(ACCESS_DENIED_ACE, SidStart, 8, 4, 4);
 }
 
 static void test_pack_ACCESS_MASK(void)
@@ -292,36 +292,36 @@ 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);
+    TEST_FIELD(ACE_HEADER, AceType, 0, 1, 1);
+    TEST_FIELD(ACE_HEADER, AceFlags, 1, 1, 1);
+    TEST_FIELD(ACE_HEADER, 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);
-    TEST_FIELD(ACL, BYTE, Sbz1, 1, 1, 1);
-    TEST_FIELD(ACL, WORD, AclSize, 2, 2, 2);
-    TEST_FIELD(ACL, WORD, AceCount, 4, 2, 2);
-    TEST_FIELD(ACL, WORD, Sbz2, 6, 2, 2);
+    TEST_FIELD(ACL, AclRevision, 0, 1, 1);
+    TEST_FIELD(ACL, Sbz1, 1, 1, 1);
+    TEST_FIELD(ACL, AclSize, 2, 2, 2);
+    TEST_FIELD(ACL, AceCount, 4, 2, 2);
+    TEST_FIELD(ACL, Sbz2, 6, 2, 2);
 }
 
 static void test_pack_ACL_REVISION_INFORMATION(void)
 {
     /* ACL_REVISION_INFORMATION (pack 4) */
     TEST_TYPE(ACL_REVISION_INFORMATION, 4, 4);
-    TEST_FIELD(ACL_REVISION_INFORMATION, DWORD, AclRevision, 0, 4, 4);
+    TEST_FIELD(ACL_REVISION_INFORMATION, AclRevision, 0, 4, 4);
 }
 
 static void test_pack_ACL_SIZE_INFORMATION(void)
 {
     /* ACL_SIZE_INFORMATION (pack 4) */
     TEST_TYPE(ACL_SIZE_INFORMATION, 12, 4);
-    TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AceCount, 0, 4, 4);
-    TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AclBytesInUse, 4, 4, 4);
-    TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AclBytesFree, 8, 4, 4);
+    TEST_FIELD(ACL_SIZE_INFORMATION, AceCount, 0, 4, 4);
+    TEST_FIELD(ACL_SIZE_INFORMATION, AclBytesInUse, 4, 4, 4);
+    TEST_FIELD(ACL_SIZE_INFORMATION, AclBytesFree, 8, 4, 4);
 }
 
 static void test_pack_BOOLEAN(void)
@@ -356,20 +356,20 @@ 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);
+    TEST_FIELD(EXCEPTION_POINTERS, ExceptionRecord, 0, 4, 4);
+    TEST_FIELD(EXCEPTION_POINTERS, 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);
-    TEST_FIELD(EXCEPTION_RECORD, DWORD, ExceptionFlags, 4, 4, 4);
-    TEST_FIELD(EXCEPTION_RECORD, struct _EXCEPTION_RECORD *, ExceptionRecord, 8, 4, 4);
-    TEST_FIELD(EXCEPTION_RECORD, PVOID, ExceptionAddress, 12, 4, 4);
-    TEST_FIELD(EXCEPTION_RECORD, DWORD, NumberParameters, 16, 4, 4);
-    TEST_FIELD(EXCEPTION_RECORD, ULONG_PTR[EXCEPTION_MAXIMUM_PARAMETERS], ExceptionInformation, 20, 60, 4);
+    TEST_FIELD(EXCEPTION_RECORD, ExceptionCode, 0, 4, 4);
+    TEST_FIELD(EXCEPTION_RECORD, ExceptionFlags, 4, 4, 4);
+    TEST_FIELD(EXCEPTION_RECORD, ExceptionRecord, 8, 4, 4);
+    TEST_FIELD(EXCEPTION_RECORD, ExceptionAddress, 12, 4, 4);
+    TEST_FIELD(EXCEPTION_RECORD, NumberParameters, 16, 4, 4);
+    TEST_FIELD(EXCEPTION_RECORD, ExceptionInformation, 20, 60, 4);
 }
 
 static void test_pack_EXECUTION_STATE(void)
@@ -383,35 +383,35 @@ 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);
-    TEST_FIELD(FLOATING_SAVE_AREA, DWORD, StatusWord, 4, 4, 4);
-    TEST_FIELD(FLOATING_SAVE_AREA, DWORD, TagWord, 8, 4, 4);
-    TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ErrorOffset, 12, 4, 4);
-    TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ErrorSelector, 16, 4, 4);
-    TEST_FIELD(FLOATING_SAVE_AREA, DWORD, DataOffset, 20, 4, 4);
-    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);
+    TEST_FIELD(FLOATING_SAVE_AREA, ControlWord, 0, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, StatusWord, 4, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, TagWord, 8, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, ErrorOffset, 12, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, ErrorSelector, 16, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, DataOffset, 20, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, DataSelector, 24, 4, 4);
+    TEST_FIELD(FLOATING_SAVE_AREA, RegisterArea, 28, 80, 1);
+    TEST_FIELD(FLOATING_SAVE_AREA, Cr0NpxState, 108, 4, 4);
 }
 
 static void test_pack_FPO_DATA(void)
 {
     /* FPO_DATA (pack 4) */
     TEST_TYPE(FPO_DATA, 16, 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);
+    TEST_FIELD(FPO_DATA, ulOffStart, 0, 4, 4);
+    TEST_FIELD(FPO_DATA, cbProcSize, 4, 4, 4);
+    TEST_FIELD(FPO_DATA, cdwLocals, 8, 4, 4);
+    TEST_FIELD(FPO_DATA, 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);
+    TEST_FIELD(GENERIC_MAPPING, GenericRead, 0, 4, 4);
+    TEST_FIELD(GENERIC_MAPPING, GenericWrite, 4, 4, 4);
+    TEST_FIELD(GENERIC_MAPPING, GenericExecute, 8, 4, 4);
+    TEST_FIELD(GENERIC_MAPPING, GenericAll, 12, 4, 4);
 }
 
 static void test_pack_HANDLE(void)
@@ -430,13 +430,13 @@ 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);
-    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[12], Date, 16, 12, 1);
-    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[6], UserID, 28, 6, 1);
-    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[6], GroupID, 34, 6, 1);
-    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);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, Name, 0, 16, 1);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, Date, 16, 12, 1);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, UserID, 28, 6, 1);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, GroupID, 34, 6, 1);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, Mode, 40, 8, 1);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, Size, 48, 10, 1);
+    TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, EndHeader, 58, 2, 1);
 }
 
 static void test_pack_IMAGE_AUX_SYMBOL(void)
@@ -448,145 +448,145 @@ 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);
+    TEST_FIELD(IMAGE_BASE_RELOCATION, VirtualAddress, 0, 4, 4);
+    TEST_FIELD(IMAGE_BASE_RELOCATION, 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);
+    TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, TimeDateStamp, 0, 4, 4);
+    TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, OffsetModuleName, 4, 2, 2);
+    TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, 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);
+    TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, TimeDateStamp, 0, 4, 4);
+    TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, OffsetModuleName, 4, 2, 2);
+    TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, 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);
-    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, LvaToFirstSymbol, 4, 4, 4);
-    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, NumberOfLinenumbers, 8, 4, 4);
-    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, LvaToFirstLinenumber, 12, 4, 4);
-    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToFirstByteOfCode, 16, 4, 4);
-    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);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, NumberOfSymbols, 0, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, LvaToFirstSymbol, 4, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, NumberOfLinenumbers, 8, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, LvaToFirstLinenumber, 12, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, RvaToFirstByteOfCode, 16, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, RvaToLastByteOfCode, 20, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, RvaToFirstByteOfData, 24, 4, 4);
+    TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, 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);
+    TEST_FIELD(IMAGE_DATA_DIRECTORY, VirtualAddress, 0, 4, 4);
+    TEST_FIELD(IMAGE_DATA_DIRECTORY, 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);
-    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
-    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
-    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
-    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, Type, 12, 4, 4);
-    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);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, Characteristics, 0, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, TimeDateStamp, 4, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, MajorVersion, 8, 2, 2);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, MinorVersion, 10, 2, 2);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, Type, 12, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, SizeOfData, 16, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, AddressOfRawData, 20, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_DIRECTORY, 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);
-    TEST_FIELD(IMAGE_DEBUG_MISC, DWORD, Length, 4, 4, 4);
-    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);
+    TEST_FIELD(IMAGE_DEBUG_MISC, DataType, 0, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_MISC, Length, 4, 4, 4);
+    TEST_FIELD(IMAGE_DEBUG_MISC, Unicode, 8, 1, 1);
+    TEST_FIELD(IMAGE_DEBUG_MISC, Reserved, 9, 3, 1);
+    TEST_FIELD(IMAGE_DEBUG_MISC, 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);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cblp, 2, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cp, 4, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_crlc, 6, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cparhdr, 8, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_minalloc, 10, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_maxalloc, 12, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ss, 14, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_sp, 16, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_csum, 18, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ip, 20, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cs, 22, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_lfarlc, 24, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ovno, 26, 2, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD[4], e_res, 28, 8, 2);
-    TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_oemid, 36, 2, 2);
-    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);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_magic, 0, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_cblp, 2, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_cp, 4, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_crlc, 6, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_cparhdr, 8, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_minalloc, 10, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_maxalloc, 12, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_ss, 14, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_sp, 16, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_csum, 18, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_ip, 20, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_cs, 22, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_lfarlc, 24, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_ovno, 26, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_res, 28, 8, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_oemid, 36, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_oeminfo, 38, 2, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, e_res2, 40, 20, 2);
+    TEST_FIELD(IMAGE_DOS_HEADER, 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);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Name, 12, 4, 4);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Base, 16, 4, 4);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, NumberOfFunctions, 20, 4, 4);
-    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, NumberOfNames, 24, 4, 4);
-    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);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, Characteristics, 0, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, TimeDateStamp, 4, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, MajorVersion, 8, 2, 2);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, MinorVersion, 10, 2, 2);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, Name, 12, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, Base, 16, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, NumberOfFunctions, 20, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, NumberOfNames, 24, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, AddressOfFunctions, 28, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, AddressOfNames, 32, 4, 4);
+    TEST_FIELD(IMAGE_EXPORT_DIRECTORY, 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);
-    TEST_FIELD(IMAGE_FILE_HEADER, WORD, NumberOfSections, 2, 2, 2);
-    TEST_FIELD(IMAGE_FILE_HEADER, DWORD, TimeDateStamp, 4, 4, 4);
-    TEST_FIELD(IMAGE_FILE_HEADER, DWORD, PointerToSymbolTable, 8, 4, 4);
-    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);
+    TEST_FIELD(IMAGE_FILE_HEADER, Machine, 0, 2, 2);
+    TEST_FIELD(IMAGE_FILE_HEADER, NumberOfSections, 2, 2, 2);
+    TEST_FIELD(IMAGE_FILE_HEADER, TimeDateStamp, 4, 4, 4);
+    TEST_FIELD(IMAGE_FILE_HEADER, PointerToSymbolTable, 8, 4, 4);
+    TEST_FIELD(IMAGE_FILE_HEADER, NumberOfSymbols, 12, 4, 4);
+    TEST_FIELD(IMAGE_FILE_HEADER, SizeOfOptionalHeader, 16, 2, 2);
+    TEST_FIELD(IMAGE_FILE_HEADER, 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);
+    TEST_FIELD(IMAGE_FUNCTION_ENTRY, StartingAddress, 0, 4, 4);
+    TEST_FIELD(IMAGE_FUNCTION_ENTRY, EndingAddress, 4, 4, 4);
+    TEST_FIELD(IMAGE_FUNCTION_ENTRY, 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);
+    TEST_FIELD(IMAGE_IMPORT_BY_NAME, Hint, 0, 2, 2);
+    TEST_FIELD(IMAGE_IMPORT_BY_NAME, Name, 2, 1, 1);
 }
 
 static void test_pack_IMAGE_IMPORT_DESCRIPTOR(void)
@@ -603,26 +603,26 @@ static void test_pack_IMAGE_LOAD_CONFIG_DIRECTORY(void)
 {
     /* IMAGE_LOAD_CONFIG_DIRECTORY (pack 4) */
     TEST_TYPE(IMAGE_LOAD_CONFIG_DIRECTORY, 72, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, Size, 0, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, GlobalFlagsClear, 12, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, GlobalFlagsSet, 16, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, CriticalSectionDefaultTimeout, 20, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, DeCommitFreeBlockThreshold, 24, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, DeCommitTotalFreeThreshold, 28, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, PVOID, LockPrefixTable, 32, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, MaximumAllocationSize, 36, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, VirtualMemoryThreshold, 40, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, ProcessHeapFlags, 44, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, ProcessAffinityMask, 48, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, CSDVersion, 52, 2, 2);
-    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, SecurityCookie, 60, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SEHandlerTable, 64, 4, 4);
-    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SEHandlerCount, 68, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, Size, 0, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, TimeDateStamp, 4, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, MajorVersion, 8, 2, 2);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, MinorVersion, 10, 2, 2);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, GlobalFlagsClear, 12, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, GlobalFlagsSet, 16, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, CriticalSectionDefaultTimeout, 20, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DeCommitFreeBlockThreshold, 24, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DeCommitTotalFreeThreshold, 28, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, LockPrefixTable, 32, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, MaximumAllocationSize, 36, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, VirtualMemoryThreshold, 40, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, ProcessHeapFlags, 44, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, ProcessAffinityMask, 48, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, CSDVersion, 52, 2, 2);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, Reserved1, 54, 2, 2);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, EditList, 56, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, SecurityCookie, 60, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, SEHandlerTable, 64, 4, 4);
+    TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, SEHandlerCount, 68, 4, 4);
 }
 
 static void test_pack_IMAGE_NT_HEADERS(void)
@@ -635,36 +635,36 @@ 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);
-    TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_ver, 2, 1, 1);
-    TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_rev, 3, 1, 1);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_enttab, 4, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cbenttab, 6, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, LONG, ne_crc, 8, 4, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_flags, 12, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_autodata, 14, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_heap, 16, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_stack, 18, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_csip, 20, 4, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_sssp, 24, 4, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cseg, 28, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cmod, 30, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cbnrestab, 32, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_segtab, 34, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_rsrctab, 36, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_restab, 38, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_modtab, 40, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_imptab, 42, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_nrestab, 44, 4, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cmovent, 48, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_align, 50, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cres, 52, 2, 2);
-    TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_exetyp, 54, 1, 1);
-    TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_flagsothers, 55, 1, 1);
-    TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_pretthunks, 56, 2, 2);
-    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);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_magic, 0, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_ver, 2, 1, 1);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_rev, 3, 1, 1);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_enttab, 4, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_cbenttab, 6, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_crc, 8, 4, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_flags, 12, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_autodata, 14, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_heap, 16, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_stack, 18, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_csip, 20, 4, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_sssp, 24, 4, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_cseg, 28, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_cmod, 30, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_cbnrestab, 32, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_segtab, 34, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_rsrctab, 36, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_restab, 38, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_modtab, 40, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_imptab, 42, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_nrestab, 44, 4, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_cmovent, 48, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_align, 50, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_cres, 52, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_exetyp, 54, 1, 1);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_flagsothers, 55, 1, 1);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_pretthunks, 56, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_psegrefbytes, 58, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_swaparea, 60, 2, 2);
+    TEST_FIELD(IMAGE_OS2_HEADER, ne_expver, 62, 2, 2);
 }
 
 static void test_pack_IMAGE_RELOCATION(void)
@@ -676,22 +676,22 @@ static void test_pack_IMAGE_RESOURCE_DATA_ENTRY(void)
 {
     /* IMAGE_RESOURCE_DATA_ENTRY (pack 4) */
     TEST_TYPE(IMAGE_RESOURCE_DATA_ENTRY, 16, 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);
-    TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, Reserved, 12, 4, 4);
+    TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, OffsetToData, 0, 4, 4);
+    TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, Size, 4, 4, 4);
+    TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, CodePage, 8, 4, 4);
+    TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, Reserved, 12, 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);
-    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
-    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
-    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);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, Characteristics, 0, 4, 4);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, TimeDateStamp, 4, 4, 4);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, MajorVersion, 8, 2, 2);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, MinorVersion, 10, 2, 2);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, NumberOfNamedEntries, 12, 2, 2);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, NumberOfIdEntries, 14, 2, 2);
 }
 
 static void test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY(void)
@@ -703,41 +703,41 @@ 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);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, Length, 0, 2, 2);
+    TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, 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);
+    TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, Length, 0, 2, 2);
+    TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, NameString, 2, 2, 2);
 }
 
 static void test_pack_IMAGE_SECTION_HEADER(void)
 {
     /* IMAGE_SECTION_HEADER (pack 4) */
-    TEST_FIELD(IMAGE_SECTION_HEADER, BYTE[IMAGE_SIZEOF_SHORT_NAME], Name, 0, 8, 1);
+    TEST_FIELD(IMAGE_SECTION_HEADER, Name, 0, 8, 1);
 }
 
 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);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Flags, 2, 2, 2);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Machine, 4, 2, 2);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Characteristics, 6, 2, 2);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, TimeDateStamp, 8, 4, 4);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, CheckSum, 12, 4, 4);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, ImageBase, 16, 4, 4);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, SizeOfImage, 20, 4, 4);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, NumberOfSections, 24, 4, 4);
-    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, ExportedNamesSize, 28, 4, 4);
-    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);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, Signature, 0, 2, 2);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, Flags, 2, 2, 2);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, Machine, 4, 2, 2);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, Characteristics, 6, 2, 2);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, TimeDateStamp, 8, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, CheckSum, 12, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, ImageBase, 16, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, SizeOfImage, 20, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, NumberOfSections, 24, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, ExportedNamesSize, 28, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DebugDirectorySize, 32, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, SectionAlignment, 36, 4, 4);
+    TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, Reserved, 40, 8, 4);
 }
 
 static void test_pack_IMAGE_SYMBOL(void)
@@ -760,69 +760,69 @@ 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);
-    TEST_FIELD(IMAGE_VXD_HEADER, BYTE, e32_border, 2, 1, 1);
-    TEST_FIELD(IMAGE_VXD_HEADER, BYTE, e32_worder, 3, 1, 1);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_level, 4, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_cpu, 8, 2, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_os, 10, 2, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ver, 12, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mflags, 16, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mpages, 20, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_startobj, 24, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_eip, 28, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_stackobj, 32, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_esp, 36, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesize, 40, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_lastpagesize, 44, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsize, 48, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsum, 52, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsize, 56, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsum, 60, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objtab, 64, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objcnt, 68, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objmap, 72, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_itermap, 76, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrctab, 80, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrccnt, 84, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_restab, 88, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_enttab, 92, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dirtab, 96, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dircnt, 100, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fpagetab, 104, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_frectab, 108, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmod, 112, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmodcnt, 116, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impproc, 120, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesum, 124, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_datapage, 128, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_preload, 132, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nrestab, 136, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_cbnrestab, 140, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nressum, 144, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_autodata, 148, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuginfo, 152, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuglen, 156, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instpreload, 160, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instdemand, 164, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_heapsize, 168, 4, 2);
-    TEST_FIELD(IMAGE_VXD_HEADER, BYTE[12], e32_res3, 172, 12, 1);
-    TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winresoff, 184, 4, 2);
-    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);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_magic, 0, 2, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_border, 2, 1, 1);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_worder, 3, 1, 1);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_level, 4, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_cpu, 8, 2, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_os, 10, 2, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_ver, 12, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_mflags, 16, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_mpages, 20, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_startobj, 24, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_eip, 28, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_stackobj, 32, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_esp, 36, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_pagesize, 40, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_lastpagesize, 44, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_fixupsize, 48, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_fixupsum, 52, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_ldrsize, 56, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_ldrsum, 60, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_objtab, 64, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_objcnt, 68, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_objmap, 72, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_itermap, 76, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_rsrctab, 80, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_rsrccnt, 84, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_restab, 88, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_enttab, 92, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_dirtab, 96, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_dircnt, 100, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_fpagetab, 104, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_frectab, 108, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_impmod, 112, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_impmodcnt, 116, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_impproc, 120, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_pagesum, 124, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_datapage, 128, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_preload, 132, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_nrestab, 136, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_cbnrestab, 140, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_nressum, 144, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_autodata, 148, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_debuginfo, 152, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_debuglen, 156, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_instpreload, 160, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_instdemand, 164, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_heapsize, 168, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_res3, 172, 12, 1);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_winresoff, 184, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_winreslen, 188, 4, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_devid, 192, 2, 2);
+    TEST_FIELD(IMAGE_VXD_HEADER, e32_ddkver, 194, 2, 2);
 }
 
 static void test_pack_IO_COUNTERS(void)
 {
     /* IO_COUNTERS (pack 8) */
     TEST_TYPE(IO_COUNTERS, 48, 8);
-    TEST_FIELD(IO_COUNTERS, ULONGLONG, ReadOperationCount, 0, 8, 8);
-    TEST_FIELD(IO_COUNTERS, ULONGLONG, WriteOperationCount, 8, 8, 8);
-    TEST_FIELD(IO_COUNTERS, ULONGLONG, OtherOperationCount, 16, 8, 8);
-    TEST_FIELD(IO_COUNTERS, ULONGLONG, ReadTransferCount, 24, 8, 8);
-    TEST_FIELD(IO_COUNTERS, ULONGLONG, WriteTransferCount, 32, 8, 8);
-    TEST_FIELD(IO_COUNTERS, ULONGLONG, OtherTransferCount, 40, 8, 8);
+    TEST_FIELD(IO_COUNTERS, ReadOperationCount, 0, 8, 8);
+    TEST_FIELD(IO_COUNTERS, WriteOperationCount, 8, 8, 8);
+    TEST_FIELD(IO_COUNTERS, OtherOperationCount, 16, 8, 8);
+    TEST_FIELD(IO_COUNTERS, ReadTransferCount, 24, 8, 8);
+    TEST_FIELD(IO_COUNTERS, WriteTransferCount, 32, 8, 8);
+    TEST_FIELD(IO_COUNTERS, OtherTransferCount, 40, 8, 8);
 }
 
 static void test_pack_LANGID(void)
@@ -848,8 +848,8 @@ 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);
+    TEST_FIELD(LIST_ENTRY, Flink, 0, 4, 4);
+    TEST_FIELD(LIST_ENTRY, Blink, 4, 4, 4);
 }
 
 static void test_pack_LONG(void)
@@ -870,73 +870,73 @@ 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);
+    TEST_FIELD(LUID, LowPart, 0, 4, 4);
+    TEST_FIELD(LUID, 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);
+    TEST_FIELD(LUID_AND_ATTRIBUTES, Luid, 0, 8, 4);
+    TEST_FIELD(LUID_AND_ATTRIBUTES, 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);
-    TEST_FIELD(MEMORY_BASIC_INFORMATION, LPVOID, AllocationBase, 4, 4, 4);
-    TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, AllocationProtect, 8, 4, 4);
-    TEST_FIELD(MEMORY_BASIC_INFORMATION, SIZE_T, RegionSize, 12, 4, 4);
-    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);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, BaseAddress, 0, 4, 4);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, AllocationBase, 4, 4, 4);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, AllocationProtect, 8, 4, 4);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, RegionSize, 12, 4, 4);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, State, 16, 4, 4);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, Protect, 20, 4, 4);
+    TEST_FIELD(MEMORY_BASIC_INFORMATION, 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);
+    TEST_FIELD(MESSAGE_RESOURCE_BLOCK, LowId, 0, 4, 4);
+    TEST_FIELD(MESSAGE_RESOURCE_BLOCK, HighId, 4, 4, 4);
+    TEST_FIELD(MESSAGE_RESOURCE_BLOCK, 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);
+    TEST_FIELD(MESSAGE_RESOURCE_DATA, NumberOfBlocks, 0, 4, 4);
+    TEST_FIELD(MESSAGE_RESOURCE_DATA, 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);
+    TEST_FIELD(MESSAGE_RESOURCE_ENTRY, Length, 0, 2, 2);
+    TEST_FIELD(MESSAGE_RESOURCE_ENTRY, Flags, 2, 2, 2);
+    TEST_FIELD(MESSAGE_RESOURCE_ENTRY, Text, 4, 1, 1);
 }
 
 static void test_pack_NT_TIB(void)
 {
     /* NT_TIB (pack 4) */
-    TEST_FIELD(NT_TIB, struct _EXCEPTION_REGISTRATION_RECORD *, ExceptionList, 0, 4, 4);
-    TEST_FIELD(NT_TIB, PVOID, StackBase, 4, 4, 4);
-    TEST_FIELD(NT_TIB, PVOID, StackLimit, 8, 4, 4);
-    TEST_FIELD(NT_TIB, PVOID, SubSystemTib, 12, 4, 4);
+    TEST_FIELD(NT_TIB, ExceptionList, 0, 4, 4);
+    TEST_FIELD(NT_TIB, StackBase, 4, 4, 4);
+    TEST_FIELD(NT_TIB, StackLimit, 8, 4, 4);
+    TEST_FIELD(NT_TIB, SubSystemTib, 12, 4, 4);
 }
 
 static void test_pack_OBJECT_TYPE_LIST(void)
 {
     /* OBJECT_TYPE_LIST (pack 4) */
     TEST_TYPE(OBJECT_TYPE_LIST, 8, 4);
-    TEST_FIELD(OBJECT_TYPE_LIST, WORD, Level, 0, 2, 2);
-    TEST_FIELD(OBJECT_TYPE_LIST, WORD, Sbz, 2, 2, 2);
-    TEST_FIELD(OBJECT_TYPE_LIST, GUID *, ObjectType, 4, 4, 4);
+    TEST_FIELD(OBJECT_TYPE_LIST, Level, 0, 2, 2);
+    TEST_FIELD(OBJECT_TYPE_LIST, Sbz, 2, 2, 2);
+    TEST_FIELD(OBJECT_TYPE_LIST, ObjectType, 4, 4, 4);
 }
 
 static void test_pack_PACCESS_ALLOWED_ACE(void)
@@ -1396,9 +1396,9 @@ 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);
+    TEST_FIELD(PRIVILEGE_SET, PrivilegeCount, 0, 4, 4);
+    TEST_FIELD(PRIVILEGE_SET, Control, 4, 4, 4);
+    TEST_FIELD(PRIVILEGE_SET, Privilege, 8, 12, 4);
 }
 
 static void test_pack_PRLIST_ENTRY(void)
@@ -1557,63 +1557,63 @@ 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);
-    TEST_FIELD(RTL_CRITICAL_SECTION, LONG, LockCount, 4, 4, 4);
-    TEST_FIELD(RTL_CRITICAL_SECTION, LONG, RecursionCount, 8, 4, 4);
-    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);
+    TEST_FIELD(RTL_CRITICAL_SECTION, DebugInfo, 0, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION, LockCount, 4, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION, RecursionCount, 8, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION, OwningThread, 12, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION, LockSemaphore, 16, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION, SpinCount, 20, 4, 4);
 }
 
 static void test_pack_RTL_CRITICAL_SECTION_DEBUG(void)
 {
     /* RTL_CRITICAL_SECTION_DEBUG (pack 4) */
-    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, Type, 0, 2, 2);
-    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, CreatorBackTraceIndex, 2, 2, 2);
-    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, struct _RTL_CRITICAL_SECTION *, CriticalSection, 4, 4, 4);
-    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, LIST_ENTRY, ProcessLocksList, 8, 8, 4);
-    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, Type, 0, 2, 2);
+    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, CreatorBackTraceIndex, 2, 2, 2);
+    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, CriticalSection, 4, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, ProcessLocksList, 8, 8, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, EntryCount, 16, 4, 4);
+    TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, ContentionCount, 20, 4, 4);
 }
 
 static void test_pack_RTL_OSVERSIONINFOEXW(void)
 {
     /* RTL_OSVERSIONINFOEXW (pack 4) */
     TEST_TYPE(RTL_OSVERSIONINFOEXW, 284, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wSuiteMask, 280, 2, 2);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, BYTE, wProductType, 282, 1, 1);
-    TEST_FIELD(RTL_OSVERSIONINFOEXW, BYTE, wReserved, 283, 1, 1);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, dwOSVersionInfoSize, 0, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, dwPlatformId, 16, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, szCSDVersion, 20, 256, 2);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, wServicePackMajor, 276, 2, 2);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, wServicePackMinor, 278, 2, 2);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, wSuiteMask, 280, 2, 2);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, wProductType, 282, 1, 1);
+    TEST_FIELD(RTL_OSVERSIONINFOEXW, wReserved, 283, 1, 1);
 }
 
 static void test_pack_RTL_OSVERSIONINFOW(void)
 {
     /* RTL_OSVERSIONINFOW (pack 4) */
     TEST_TYPE(RTL_OSVERSIONINFOW, 276, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
-    TEST_FIELD(RTL_OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
+    TEST_FIELD(RTL_OSVERSIONINFOW, dwOSVersionInfoSize, 0, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOW, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOW, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOW, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOW, dwPlatformId, 16, 4, 4);
+    TEST_FIELD(RTL_OSVERSIONINFOW, szCSDVersion, 20, 256, 2);
 }
 
 static void test_pack_RTL_RESOURCE_DEBUG(void)
 {
     /* RTL_RESOURCE_DEBUG (pack 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, Type, 0, 2, 2);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, CreatorBackTraceIndex, 2, 2, 2);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, CriticalSection, 4, 4, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, ProcessLocksList, 8, 8, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, EntryCount, 16, 4, 4);
+    TEST_FIELD(RTL_RESOURCE_DEBUG, ContentionCount, 20, 4, 4);
 }
 
 static void test_pack_SECURITY_CONTEXT_TRACKING_MODE(void)
@@ -1626,13 +1626,13 @@ 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);
-    TEST_FIELD(SECURITY_DESCRIPTOR, BYTE, Sbz1, 1, 1, 1);
-    TEST_FIELD(SECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, Control, 2, 2, 2);
-    TEST_FIELD(SECURITY_DESCRIPTOR, PSID, Owner, 4, 4, 4);
-    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);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Revision, 0, 1, 1);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Sbz1, 1, 1, 1);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Control, 2, 2, 2);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Owner, 4, 4, 4);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Group, 8, 4, 4);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Sacl, 12, 4, 4);
+    TEST_FIELD(SECURITY_DESCRIPTOR, Dacl, 16, 4, 4);
 }
 
 static void test_pack_SECURITY_DESCRIPTOR_CONTROL(void)
@@ -1646,13 +1646,13 @@ 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);
-    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, BYTE, Sbz1, 1, 1, 1);
-    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, SECURITY_DESCRIPTOR_CONTROL, Control, 2, 2, 2);
-    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Owner, 4, 4, 4);
-    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);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Revision, 0, 1, 1);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Sbz1, 1, 1, 1);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Control, 2, 2, 2);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Owner, 4, 4, 4);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Group, 8, 4, 4);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Sacl, 12, 4, 4);
+    TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, Dacl, 16, 4, 4);
 }
 
 static void test_pack_SECURITY_INFORMATION(void)
@@ -1665,7 +1665,7 @@ static void test_pack_SECURITY_INFORMATION(void)
 static void test_pack_SECURITY_QUALITY_OF_SERVICE(void)
 {
     /* SECURITY_QUALITY_OF_SERVICE (pack 4) */
-    TEST_FIELD(SECURITY_QUALITY_OF_SERVICE, DWORD, Length, 0, 4, 4);
+    TEST_FIELD(SECURITY_QUALITY_OF_SERVICE, Length, 0, 4, 4);
 }
 
 static void test_pack_SHORT(void)
@@ -1679,50 +1679,50 @@ 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);
+    TEST_FIELD(SID, Revision, 0, 1, 1);
+    TEST_FIELD(SID, SubAuthorityCount, 1, 1, 1);
+    TEST_FIELD(SID, IdentifierAuthority, 2, 6, 1);
+    TEST_FIELD(SID, 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);
+    TEST_FIELD(SID_AND_ATTRIBUTES, Sid, 0, 4, 4);
+    TEST_FIELD(SID_AND_ATTRIBUTES, 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);
+    TEST_FIELD(SID_IDENTIFIER_AUTHORITY, 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);
+    TEST_FIELD(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);
+    TEST_FIELD(SYSTEM_ALARM_ACE, Header, 0, 4, 2);
+    TEST_FIELD(SYSTEM_ALARM_ACE, Mask, 4, 4, 4);
+    TEST_FIELD(SYSTEM_ALARM_ACE, 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);
+    TEST_FIELD(SYSTEM_AUDIT_ACE, Header, 0, 4, 2);
+    TEST_FIELD(SYSTEM_AUDIT_ACE, Mask, 4, 4, 4);
+    TEST_FIELD(SYSTEM_AUDIT_ACE, SidStart, 8, 4, 4);
 }
 
 static void test_pack_TCHAR(void)
@@ -1735,60 +1735,60 @@ 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);
+    TEST_FIELD(TOKEN_DEFAULT_DACL, 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);
+    TEST_FIELD(TOKEN_GROUPS, GroupCount, 0, 4, 4);
+    TEST_FIELD(TOKEN_GROUPS, 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);
+    TEST_FIELD(TOKEN_OWNER, 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);
+    TEST_FIELD(TOKEN_PRIMARY_GROUP, 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);
+    TEST_FIELD(TOKEN_PRIVILEGES, PrivilegeCount, 0, 4, 4);
+    TEST_FIELD(TOKEN_PRIVILEGES, 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);
+    TEST_FIELD(TOKEN_SOURCE, SourceName, 0, 8, 1);
+    TEST_FIELD(TOKEN_SOURCE, SourceIdentifier, 8, 8, 4);
 }
 
 static void test_pack_TOKEN_STATISTICS(void)
 {
     /* TOKEN_STATISTICS (pack 4) */
-    TEST_FIELD(TOKEN_STATISTICS, LUID, TokenId, 0, 8, 4);
-    TEST_FIELD(TOKEN_STATISTICS, LUID, AuthenticationId, 8, 8, 4);
-    TEST_FIELD(TOKEN_STATISTICS, LARGE_INTEGER, ExpirationTime, 16, 8, 4);
+    TEST_FIELD(TOKEN_STATISTICS, TokenId, 0, 8, 4);
+    TEST_FIELD(TOKEN_STATISTICS, AuthenticationId, 8, 8, 4);
+    TEST_FIELD(TOKEN_STATISTICS, ExpirationTime, 16, 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);
+    TEST_FIELD(TOKEN_USER, User, 0, 8, 4);
 }
 
 static void test_pack_ULARGE_INTEGER(void)
@@ -1985,16 +1985,16 @@ 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);
+    TEST_FIELD(POINT, x, 0, 4, 4);
+    TEST_FIELD(POINT, 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);
+    TEST_FIELD(POINTL, x, 0, 4, 4);
+    TEST_FIELD(POINTL, y, 4, 4, 4);
 }
 
 static void test_pack_PPOINT(void)
@@ -2048,28 +2048,28 @@ static void test_pack_RECT(void)
 {
     /* RECT (pack 4) */
     TEST_TYPE(RECT, 16, 4);
-    TEST_FIELD(RECT, LONG, left, 0, 4, 4);
-    TEST_FIELD(RECT, LONG, top, 4, 4, 4);
-    TEST_FIELD(RECT, LONG, right, 8, 4, 4);
-    TEST_FIELD(RECT, LONG, bottom, 12, 4, 4);
+    TEST_FIELD(RECT, left, 0, 4, 4);
+    TEST_FIELD(RECT, top, 4, 4, 4);
+    TEST_FIELD(RECT, right, 8, 4, 4);
+    TEST_FIELD(RECT, 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);
+    TEST_FIELD(RECTL, left, 0, 4, 4);
+    TEST_FIELD(RECTL, top, 4, 4, 4);
+    TEST_FIELD(RECTL, right, 8, 4, 4);
+    TEST_FIELD(RECTL, 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);
+    TEST_FIELD(SIZE, cx, 0, 4, 4);
+    TEST_FIELD(SIZE, cy, 4, 4, 4);
 }
 
 static void test_pack_SIZEL(void)
diff --git a/dlls/rpcrt4/tests/generated.c b/dlls/rpcrt4/tests/generated.c
index 7296970cfb1..c066550f57f 100644
--- a/dlls/rpcrt4/tests/generated.c
+++ b/dlls/rpcrt4/tests/generated.c
@@ -91,10 +91,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -156,8 +156,8 @@ static void test_pack_RPC_BINDING_VECTOR(void)
 {
     /* RPC_BINDING_VECTOR (pack 4) */
     TEST_TYPE(RPC_BINDING_VECTOR, 8, 4);
-    TEST_FIELD(RPC_BINDING_VECTOR, ULONG, Count, 0, 4, 4);
-    TEST_FIELD(RPC_BINDING_VECTOR, RPC_BINDING_HANDLE[1], BindingH, 4, 4, 4);
+    TEST_FIELD(RPC_BINDING_VECTOR, Count, 0, 4, 4);
+    TEST_FIELD(RPC_BINDING_VECTOR, BindingH, 4, 4, 4);
 }
 
 static void test_pack_RPC_IF_HANDLE(void)
@@ -170,26 +170,26 @@ static void test_pack_RPC_IF_ID(void)
 {
     /* RPC_IF_ID (pack 4) */
     TEST_TYPE(RPC_IF_ID, 20, 4);
-    TEST_FIELD(RPC_IF_ID, UUID, Uuid, 0, 16, 4);
-    TEST_FIELD(RPC_IF_ID, unsigned short, VersMajor, 16, 2, 2);
-    TEST_FIELD(RPC_IF_ID, unsigned short, VersMinor, 18, 2, 2);
+    TEST_FIELD(RPC_IF_ID, Uuid, 0, 16, 4);
+    TEST_FIELD(RPC_IF_ID, VersMajor, 16, 2, 2);
+    TEST_FIELD(RPC_IF_ID, VersMinor, 18, 2, 2);
 }
 
 static void test_pack_RPC_POLICY(void)
 {
     /* RPC_POLICY (pack 4) */
     TEST_TYPE(RPC_POLICY, 12, 4);
-    TEST_FIELD(RPC_POLICY, unsigned int, Length, 0, 4, 4);
-    TEST_FIELD(RPC_POLICY, ULONG, EndpointFlags, 4, 4, 4);
-    TEST_FIELD(RPC_POLICY, ULONG, NICFlags, 8, 4, 4);
+    TEST_FIELD(RPC_POLICY, Length, 0, 4, 4);
+    TEST_FIELD(RPC_POLICY, EndpointFlags, 4, 4, 4);
+    TEST_FIELD(RPC_POLICY, NICFlags, 8, 4, 4);
 }
 
 static void test_pack_UUID_VECTOR(void)
 {
     /* UUID_VECTOR (pack 4) */
     TEST_TYPE(UUID_VECTOR, 8, 4);
-    TEST_FIELD(UUID_VECTOR, ULONG, Count, 0, 4, 4);
-    TEST_FIELD(UUID_VECTOR, UUID *[1], Uuid, 4, 4, 4);
+    TEST_FIELD(UUID_VECTOR, Count, 0, 4, 4);
+    TEST_FIELD(UUID_VECTOR, Uuid, 4, 4, 4);
 }
 
 static void test_pack_PRPC_CLIENT_INTERFACE(void)
@@ -238,15 +238,15 @@ static void test_pack_RPC_CLIENT_INTERFACE(void)
 {
     /* RPC_CLIENT_INTERFACE (pack 4) */
     TEST_TYPE(RPC_CLIENT_INTERFACE, 68, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, unsigned int, Length, 0, 4, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, RPC_SYNTAX_IDENTIFIER, InterfaceId, 4, 20, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, RPC_SYNTAX_IDENTIFIER, TransferSyntax, 24, 20, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, PRPC_DISPATCH_TABLE, DispatchTable, 44, 4, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, unsigned int, RpcProtseqEndpointCount, 48, 4, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, PRPC_PROTSEQ_ENDPOINT, RpcProtseqEndpoint, 52, 4, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, ULONG_PTR, Reserved, 56, 4, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, void const*, InterpreterInfo, 60, 4, 4);
-    TEST_FIELD(RPC_CLIENT_INTERFACE, unsigned int, Flags, 64, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, Length, 0, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, InterfaceId, 4, 20, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, TransferSyntax, 24, 20, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, DispatchTable, 44, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, RpcProtseqEndpointCount, 48, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, RpcProtseqEndpoint, 52, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, Reserved, 56, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, InterpreterInfo, 60, 4, 4);
+    TEST_FIELD(RPC_CLIENT_INTERFACE, Flags, 64, 4, 4);
 }
 
 static void test_pack_RPC_DISPATCH_FUNCTION(void)
@@ -258,94 +258,94 @@ static void test_pack_RPC_DISPATCH_TABLE(void)
 {
     /* RPC_DISPATCH_TABLE (pack 4) */
     TEST_TYPE(RPC_DISPATCH_TABLE, 12, 4);
-    TEST_FIELD(RPC_DISPATCH_TABLE, unsigned int, DispatchTableCount, 0, 4, 4);
-    TEST_FIELD(RPC_DISPATCH_TABLE, RPC_DISPATCH_FUNCTION*, DispatchTable, 4, 4, 4);
-    TEST_FIELD(RPC_DISPATCH_TABLE, LONG_PTR, Reserved, 8, 4, 4);
+    TEST_FIELD(RPC_DISPATCH_TABLE, DispatchTableCount, 0, 4, 4);
+    TEST_FIELD(RPC_DISPATCH_TABLE, DispatchTable, 4, 4, 4);
+    TEST_FIELD(RPC_DISPATCH_TABLE, Reserved, 8, 4, 4);
 }
 
 static void test_pack_RPC_MESSAGE(void)
 {
     /* RPC_MESSAGE (pack 4) */
     TEST_TYPE(RPC_MESSAGE, 44, 4);
-    TEST_FIELD(RPC_MESSAGE, RPC_BINDING_HANDLE, Handle, 0, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, unsigned long, DataRepresentation, 4, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, void*, Buffer, 8, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, unsigned int, BufferLength, 12, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, unsigned int, ProcNum, 16, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, PRPC_SYNTAX_IDENTIFIER, TransferSyntax, 20, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, void*, RpcInterfaceInformation, 24, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, void*, ReservedForRuntime, 28, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, RPC_MGR_EPV*, ManagerEpv, 32, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, void*, ImportContext, 36, 4, 4);
-    TEST_FIELD(RPC_MESSAGE, unsigned long, RpcFlags, 40, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, Handle, 0, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, DataRepresentation, 4, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, Buffer, 8, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, BufferLength, 12, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, ProcNum, 16, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, TransferSyntax, 20, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, RpcInterfaceInformation, 24, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, ReservedForRuntime, 28, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, ManagerEpv, 32, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, ImportContext, 36, 4, 4);
+    TEST_FIELD(RPC_MESSAGE, RpcFlags, 40, 4, 4);
 }
 
 static void test_pack_RPC_PROTSEQ_ENDPOINT(void)
 {
     /* RPC_PROTSEQ_ENDPOINT (pack 4) */
     TEST_TYPE(RPC_PROTSEQ_ENDPOINT, 8, 4);
-    TEST_FIELD(RPC_PROTSEQ_ENDPOINT, unsigned char*, RpcProtocolSequence, 0, 4, 4);
-    TEST_FIELD(RPC_PROTSEQ_ENDPOINT, unsigned char*, Endpoint, 4, 4, 4);
+    TEST_FIELD(RPC_PROTSEQ_ENDPOINT, RpcProtocolSequence, 0, 4, 4);
+    TEST_FIELD(RPC_PROTSEQ_ENDPOINT, Endpoint, 4, 4, 4);
 }
 
 static void test_pack_RPC_SERVER_INTERFACE(void)
 {
     /* RPC_SERVER_INTERFACE (pack 4) */
     TEST_TYPE(RPC_SERVER_INTERFACE, 68, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, unsigned int, Length, 0, 4, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, RPC_SYNTAX_IDENTIFIER, InterfaceId, 4, 20, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, RPC_SYNTAX_IDENTIFIER, TransferSyntax, 24, 20, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, PRPC_DISPATCH_TABLE, DispatchTable, 44, 4, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, unsigned int, RpcProtseqEndpointCount, 48, 4, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, PRPC_PROTSEQ_ENDPOINT, RpcProtseqEndpoint, 52, 4, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, RPC_MGR_EPV*, DefaultManagerEpv, 56, 4, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, void const*, InterpreterInfo, 60, 4, 4);
-    TEST_FIELD(RPC_SERVER_INTERFACE, unsigned int, Flags, 64, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, Length, 0, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, InterfaceId, 4, 20, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, TransferSyntax, 24, 20, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, DispatchTable, 44, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, RpcProtseqEndpointCount, 48, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, RpcProtseqEndpoint, 52, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, DefaultManagerEpv, 56, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, InterpreterInfo, 60, 4, 4);
+    TEST_FIELD(RPC_SERVER_INTERFACE, Flags, 64, 4, 4);
 }
 
 static void test_pack_RPC_SYNTAX_IDENTIFIER(void)
 {
     /* RPC_SYNTAX_IDENTIFIER (pack 4) */
     TEST_TYPE(RPC_SYNTAX_IDENTIFIER, 20, 4);
-    TEST_FIELD(RPC_SYNTAX_IDENTIFIER, GUID, SyntaxGUID, 0, 16, 4);
-    TEST_FIELD(RPC_SYNTAX_IDENTIFIER, RPC_VERSION, SyntaxVersion, 16, 4, 2);
+    TEST_FIELD(RPC_SYNTAX_IDENTIFIER, SyntaxGUID, 0, 16, 4);
+    TEST_FIELD(RPC_SYNTAX_IDENTIFIER, SyntaxVersion, 16, 4, 2);
 }
 
 static void test_pack_RPC_VERSION(void)
 {
     /* RPC_VERSION (pack 4) */
     TEST_TYPE(RPC_VERSION, 4, 2);
-    TEST_FIELD(RPC_VERSION, unsigned short, MajorVersion, 0, 2, 2);
-    TEST_FIELD(RPC_VERSION, unsigned short, MinorVersion, 2, 2, 2);
+    TEST_FIELD(RPC_VERSION, MajorVersion, 0, 2, 2);
+    TEST_FIELD(RPC_VERSION, MinorVersion, 2, 2, 2);
 }
 
 static void test_pack_ARRAY_INFO(void)
 {
     /* ARRAY_INFO (pack 4) */
     TEST_TYPE(ARRAY_INFO, 24, 4);
-    TEST_FIELD(ARRAY_INFO, LONG, Dimension, 0, 4, 4);
-    TEST_FIELD(ARRAY_INFO, ULONG *, BufferConformanceMark, 4, 4, 4);
-    TEST_FIELD(ARRAY_INFO, ULONG *, BufferVarianceMark, 8, 4, 4);
-    TEST_FIELD(ARRAY_INFO, ULONG *, MaxCountArray, 12, 4, 4);
-    TEST_FIELD(ARRAY_INFO, ULONG *, OffsetArray, 16, 4, 4);
-    TEST_FIELD(ARRAY_INFO, ULONG *, ActualCountArray, 20, 4, 4);
+    TEST_FIELD(ARRAY_INFO, Dimension, 0, 4, 4);
+    TEST_FIELD(ARRAY_INFO, BufferConformanceMark, 4, 4, 4);
+    TEST_FIELD(ARRAY_INFO, BufferVarianceMark, 8, 4, 4);
+    TEST_FIELD(ARRAY_INFO, MaxCountArray, 12, 4, 4);
+    TEST_FIELD(ARRAY_INFO, OffsetArray, 16, 4, 4);
+    TEST_FIELD(ARRAY_INFO, ActualCountArray, 20, 4, 4);
 }
 
 static void test_pack_COMM_FAULT_OFFSETS(void)
 {
     /* COMM_FAULT_OFFSETS (pack 4) */
     TEST_TYPE(COMM_FAULT_OFFSETS, 4, 2);
-    TEST_FIELD(COMM_FAULT_OFFSETS, short, CommOffset, 0, 2, 2);
-    TEST_FIELD(COMM_FAULT_OFFSETS, short, FaultOffset, 2, 2, 2);
+    TEST_FIELD(COMM_FAULT_OFFSETS, CommOffset, 0, 2, 2);
+    TEST_FIELD(COMM_FAULT_OFFSETS, FaultOffset, 2, 2, 2);
 }
 
 static void test_pack_CS_STUB_INFO(void)
 {
     /* CS_STUB_INFO (pack 4) */
     TEST_TYPE(CS_STUB_INFO, 12, 4);
-    TEST_FIELD(CS_STUB_INFO, ULONG, WireCodeset, 0, 4, 4);
-    TEST_FIELD(CS_STUB_INFO, ULONG, DesiredReceivingCodeset, 4, 4, 4);
-    TEST_FIELD(CS_STUB_INFO, void *, CSArrayInfo, 8, 4, 4);
+    TEST_FIELD(CS_STUB_INFO, WireCodeset, 0, 4, 4);
+    TEST_FIELD(CS_STUB_INFO, DesiredReceivingCodeset, 4, 4, 4);
+    TEST_FIELD(CS_STUB_INFO, CSArrayInfo, 8, 4, 4);
 }
 
 static void test_pack_EXPR_EVAL(void)
@@ -357,10 +357,10 @@ static void test_pack_FULL_PTR_TO_REFID_ELEMENT(void)
 {
     /* FULL_PTR_TO_REFID_ELEMENT (pack 4) */
     TEST_TYPE(FULL_PTR_TO_REFID_ELEMENT, 16, 4);
-    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, struct _FULL_PTR_TO_REFID_ELEMENT *, Next, 0, 4, 4);
-    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, void *, Pointer, 4, 4, 4);
-    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, ULONG, RefId, 8, 4, 4);
-    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, unsigned char, State, 12, 1, 1);
+    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, Next, 0, 4, 4);
+    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, Pointer, 4, 4, 4);
+    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, RefId, 8, 4, 4);
+    TEST_FIELD(FULL_PTR_TO_REFID_ELEMENT, State, 12, 1, 1);
 }
 
 static void test_pack_FULL_PTR_XLAT_TABLES(void)
@@ -371,8 +371,8 @@ static void test_pack_FULL_PTR_XLAT_TABLES(void)
 static void test_pack_GENERIC_BINDING_INFO(void)
 {
     /* GENERIC_BINDING_INFO (pack 4) */
-    TEST_FIELD(GENERIC_BINDING_INFO, void *, pObj, 0, 4, 4);
-    TEST_FIELD(GENERIC_BINDING_INFO, unsigned int, Size, 4, 4, 4);
+    TEST_FIELD(GENERIC_BINDING_INFO, pObj, 0, 4, 4);
+    TEST_FIELD(GENERIC_BINDING_INFO, Size, 4, 4, 4);
 }
 
 static void test_pack_GENERIC_BINDING_ROUTINE_PAIR(void)
@@ -388,76 +388,76 @@ static void test_pack_MALLOC_FREE_STRUCT(void)
 static void test_pack_MIDL_FORMAT_STRING(void)
 {
     /* MIDL_FORMAT_STRING (pack 4) */
-    TEST_FIELD(MIDL_FORMAT_STRING, short, Pad, 0, 2, 2);
+    TEST_FIELD(MIDL_FORMAT_STRING, Pad, 0, 2, 2);
 }
 
 static void test_pack_MIDL_SERVER_INFO(void)
 {
     /* MIDL_SERVER_INFO (pack 4) */
     TEST_TYPE(MIDL_SERVER_INFO, 32, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, PMIDL_STUB_DESC, pStubDesc, 0, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, SERVER_ROUTINE *, DispatchTable, 4, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, PFORMAT_STRING, ProcString, 8, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, unsigned short *, FmtStringOffset, 12, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, STUB_THUNK *, ThunkTable, 16, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, PRPC_SYNTAX_IDENTIFIER, pTransferSyntax, 20, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, ULONG_PTR, nCount, 24, 4, 4);
-    TEST_FIELD(MIDL_SERVER_INFO, PMIDL_SYNTAX_INFO, pSyntaxInfo, 28, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, pStubDesc, 0, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, DispatchTable, 4, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, ProcString, 8, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, FmtStringOffset, 12, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, ThunkTable, 16, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, pTransferSyntax, 20, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, nCount, 24, 4, 4);
+    TEST_FIELD(MIDL_SERVER_INFO, pSyntaxInfo, 28, 4, 4);
 }
 
 static void test_pack_MIDL_STUB_DESC(void)
 {
     /* MIDL_STUB_DESC (pack 4) */
-    TEST_FIELD(MIDL_STUB_DESC, void *, RpcInterfaceInformation, 0, 4, 4);
+    TEST_FIELD(MIDL_STUB_DESC, RpcInterfaceInformation, 0, 4, 4);
 }
 
 static void test_pack_MIDL_STUB_MESSAGE(void)
 {
     /* MIDL_STUB_MESSAGE (pack 4) */
-    TEST_FIELD(MIDL_STUB_MESSAGE, PRPC_MESSAGE, RpcMsg, 0, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char *, Buffer, 4, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char *, BufferStart, 8, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char *, BufferEnd, 12, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char *, BufferMark, 16, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, ULONG, BufferLength, 20, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, ULONG, MemorySize, 24, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char *, Memory, 28, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, int, ReuseBuffer, 36, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, struct NDR_ALLOC_ALL_NODES_CONTEXT *, pAllocAllNodesContext, 40, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, struct NDR_POINTER_QUEUE_STATE *, pPointerQueueState, 44, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, int, IgnoreEmbeddedPointers, 48, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char *, PointerBufferMark, 52, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char, CorrDespIncrement, 56, 1, 1);
-    TEST_FIELD(MIDL_STUB_MESSAGE, unsigned char, uFlags, 57, 1, 1);
-    TEST_FIELD(MIDL_STUB_MESSAGE, ULONG_PTR, MaxCount, 60, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, ULONG, Offset, 64, 4, 4);
-    TEST_FIELD(MIDL_STUB_MESSAGE, ULONG, ActualCount, 68, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, RpcMsg, 0, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, Buffer, 4, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, BufferStart, 8, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, BufferEnd, 12, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, BufferMark, 16, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, BufferLength, 20, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, MemorySize, 24, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, Memory, 28, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, ReuseBuffer, 36, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, pAllocAllNodesContext, 40, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, pPointerQueueState, 44, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, IgnoreEmbeddedPointers, 48, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, PointerBufferMark, 52, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, CorrDespIncrement, 56, 1, 1);
+    TEST_FIELD(MIDL_STUB_MESSAGE, uFlags, 57, 1, 1);
+    TEST_FIELD(MIDL_STUB_MESSAGE, MaxCount, 60, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, Offset, 64, 4, 4);
+    TEST_FIELD(MIDL_STUB_MESSAGE, ActualCount, 68, 4, 4);
 }
 
 static void test_pack_MIDL_STUBLESS_PROXY_INFO(void)
 {
     /* MIDL_STUBLESS_PROXY_INFO (pack 4) */
     TEST_TYPE(MIDL_STUBLESS_PROXY_INFO, 24, 4);
-    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, PMIDL_STUB_DESC, pStubDesc, 0, 4, 4);
-    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, PFORMAT_STRING, ProcFormatString, 4, 4, 4);
-    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, unsigned short *, FormatStringOffset, 8, 4, 4);
-    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, PRPC_SYNTAX_IDENTIFIER, pTransferSyntax, 12, 4, 4);
-    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, ULONG_PTR, nCount, 16, 4, 4);
-    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, PMIDL_SYNTAX_INFO, pSyntaxInfo, 20, 4, 4);
+    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, pStubDesc, 0, 4, 4);
+    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, ProcFormatString, 4, 4, 4);
+    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, FormatStringOffset, 8, 4, 4);
+    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, pTransferSyntax, 12, 4, 4);
+    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, nCount, 16, 4, 4);
+    TEST_FIELD(MIDL_STUBLESS_PROXY_INFO, pSyntaxInfo, 20, 4, 4);
 }
 
 static void test_pack_MIDL_SYNTAX_INFO(void)
 {
     /* MIDL_SYNTAX_INFO (pack 4) */
     TEST_TYPE(MIDL_SYNTAX_INFO, 48, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, RPC_SYNTAX_IDENTIFIER, TransferSyntax, 0, 20, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, RPC_DISPATCH_TABLE*, DispatchTable, 20, 4, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, PFORMAT_STRING, ProcString, 24, 4, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, unsigned short*, FmtStringOffset, 28, 4, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, PFORMAT_STRING, TypeString, 32, 4, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, void*, aUserMarshalQuadruple, 36, 4, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, ULONG_PTR, pReserved1, 40, 4, 4);
-    TEST_FIELD(MIDL_SYNTAX_INFO, ULONG_PTR, pReserved2, 44, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, TransferSyntax, 0, 20, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, DispatchTable, 20, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, ProcString, 24, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, FmtStringOffset, 28, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, TypeString, 32, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, aUserMarshalQuadruple, 36, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, pReserved1, 40, 4, 4);
+    TEST_FIELD(MIDL_SYNTAX_INFO, pReserved2, 44, 4, 4);
 }
 
 static void test_pack_NDR_CCONTEXT(void)
@@ -490,14 +490,14 @@ static void test_pack_NDR_SCONTEXT(void)
 static void test_pack_NDR_USER_MARSHAL_INFO(void)
 {
     /* NDR_USER_MARSHAL_INFO (pack 4) */
-    TEST_FIELD(NDR_USER_MARSHAL_INFO, ULONG, InformationLevel, 0, 4, 4);
+    TEST_FIELD(NDR_USER_MARSHAL_INFO, InformationLevel, 0, 4, 4);
 }
 
 static void test_pack_NDR_USER_MARSHAL_INFO_LEVEL1(void)
 {
     /* NDR_USER_MARSHAL_INFO_LEVEL1 (pack 4) */
-    TEST_FIELD(NDR_USER_MARSHAL_INFO_LEVEL1, void *, Buffer, 0, 4, 4);
-    TEST_FIELD(NDR_USER_MARSHAL_INFO_LEVEL1, ULONG, BufferSize, 4, 4, 4);
+    TEST_FIELD(NDR_USER_MARSHAL_INFO_LEVEL1, Buffer, 0, 4, 4);
+    TEST_FIELD(NDR_USER_MARSHAL_INFO_LEVEL1, BufferSize, 4, 4, 4);
 }
 
 static void test_pack_PARRAY_INFO(void)
@@ -600,8 +600,8 @@ static void test_pack_SCONTEXT_QUEUE(void)
 {
     /* SCONTEXT_QUEUE (pack 4) */
     TEST_TYPE(SCONTEXT_QUEUE, 8, 4);
-    TEST_FIELD(SCONTEXT_QUEUE, ULONG, NumberOfObjects, 0, 4, 4);
-    TEST_FIELD(SCONTEXT_QUEUE, NDR_SCONTEXT *, ArrayOfObjects, 4, 4, 4);
+    TEST_FIELD(SCONTEXT_QUEUE, NumberOfObjects, 0, 4, 4);
+    TEST_FIELD(SCONTEXT_QUEUE, ArrayOfObjects, 4, 4, 4);
 }
 
 static void test_pack_SERVER_ROUTINE(void)
@@ -617,10 +617,10 @@ static void test_pack_STUB_THUNK(void)
 static void test_pack_USER_MARSHAL_CB(void)
 {
     /* USER_MARSHAL_CB (pack 4) */
-    TEST_FIELD(USER_MARSHAL_CB, ULONG, Flags, 0, 4, 4);
-    TEST_FIELD(USER_MARSHAL_CB, PMIDL_STUB_MESSAGE, pStubMsg, 4, 4, 4);
-    TEST_FIELD(USER_MARSHAL_CB, PFORMAT_STRING, pReserve, 8, 4, 4);
-    TEST_FIELD(USER_MARSHAL_CB, ULONG, Signature, 12, 4, 4);
+    TEST_FIELD(USER_MARSHAL_CB, Flags, 0, 4, 4);
+    TEST_FIELD(USER_MARSHAL_CB, pStubMsg, 4, 4, 4);
+    TEST_FIELD(USER_MARSHAL_CB, pReserve, 8, 4, 4);
+    TEST_FIELD(USER_MARSHAL_CB, Signature, 12, 4, 4);
 }
 
 static void test_pack_USER_MARSHAL_FREEING_ROUTINE(void)
diff --git a/dlls/shell32/tests/generated.c b/dlls/shell32/tests/generated.c
index a3c9727f5b9..bdcdfa00511 100644
--- a/dlls/shell32/tests/generated.c
+++ b/dlls/shell32/tests/generated.c
@@ -93,10 +93,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -116,8 +116,8 @@ static void test_pack_BLOB(void)
 {
     /* BLOB (pack 4) */
     TEST_TYPE(BLOB, 8, 4);
-    TEST_FIELD(BLOB, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(BLOB, BYTE *, pBlobData, 4, 4, 4);
+    TEST_FIELD(BLOB, cbSize, 0, 4, 4);
+    TEST_FIELD(BLOB, pBlobData, 4, 4, 4);
 }
 
 static void test_pack_BSTR(void)
@@ -131,33 +131,33 @@ static void test_pack_BSTRBLOB(void)
 {
     /* BSTRBLOB (pack 4) */
     TEST_TYPE(BSTRBLOB, 8, 4);
-    TEST_FIELD(BSTRBLOB, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(BSTRBLOB, BYTE *, pData, 4, 4, 4);
+    TEST_FIELD(BSTRBLOB, cbSize, 0, 4, 4);
+    TEST_FIELD(BSTRBLOB, pData, 4, 4, 4);
 }
 
 static void test_pack_BYTE_BLOB(void)
 {
     /* BYTE_BLOB (pack 4) */
     TEST_TYPE(BYTE_BLOB, 8, 4);
-    TEST_FIELD(BYTE_BLOB, unsigned long, clSize, 0, 4, 4);
-    TEST_FIELD(BYTE_BLOB, byte[1], abData, 4, 1, 1);
+    TEST_FIELD(BYTE_BLOB, clSize, 0, 4, 4);
+    TEST_FIELD(BYTE_BLOB, abData, 4, 1, 1);
 }
 
 static void test_pack_BYTE_SIZEDARR(void)
 {
     /* BYTE_SIZEDARR (pack 4) */
     TEST_TYPE(BYTE_SIZEDARR, 8, 4);
-    TEST_FIELD(BYTE_SIZEDARR, unsigned long, clSize, 0, 4, 4);
-    TEST_FIELD(BYTE_SIZEDARR, byte *, pData, 4, 4, 4);
+    TEST_FIELD(BYTE_SIZEDARR, clSize, 0, 4, 4);
+    TEST_FIELD(BYTE_SIZEDARR, pData, 4, 4, 4);
 }
 
 static void test_pack_CLIPDATA(void)
 {
     /* CLIPDATA (pack 4) */
     TEST_TYPE(CLIPDATA, 12, 4);
-    TEST_FIELD(CLIPDATA, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(CLIPDATA, long, ulClipFmt, 4, 4, 4);
-    TEST_FIELD(CLIPDATA, BYTE *, pClipData, 8, 4, 4);
+    TEST_FIELD(CLIPDATA, cbSize, 0, 4, 4);
+    TEST_FIELD(CLIPDATA, ulClipFmt, 4, 4, 4);
+    TEST_FIELD(CLIPDATA, pClipData, 8, 4, 4);
 }
 
 static void test_pack_CLIPFORMAT(void)
@@ -171,26 +171,26 @@ static void test_pack_COAUTHIDENTITY(void)
 {
     /* COAUTHIDENTITY (pack 4) */
     TEST_TYPE(COAUTHIDENTITY, 28, 4);
-    TEST_FIELD(COAUTHIDENTITY, USHORT *, User, 0, 4, 4);
-    TEST_FIELD(COAUTHIDENTITY, ULONG, UserLength, 4, 4, 4);
-    TEST_FIELD(COAUTHIDENTITY, USHORT *, Domain, 8, 4, 4);
-    TEST_FIELD(COAUTHIDENTITY, ULONG, DomainLength, 12, 4, 4);
-    TEST_FIELD(COAUTHIDENTITY, USHORT *, Password, 16, 4, 4);
-    TEST_FIELD(COAUTHIDENTITY, ULONG, PasswordLength, 20, 4, 4);
-    TEST_FIELD(COAUTHIDENTITY, ULONG, Flags, 24, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, User, 0, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, UserLength, 4, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, Domain, 8, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, DomainLength, 12, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, Password, 16, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, PasswordLength, 20, 4, 4);
+    TEST_FIELD(COAUTHIDENTITY, Flags, 24, 4, 4);
 }
 
 static void test_pack_COAUTHINFO(void)
 {
     /* COAUTHINFO (pack 4) */
     TEST_TYPE(COAUTHINFO, 28, 4);
-    TEST_FIELD(COAUTHINFO, DWORD, dwAuthnSvc, 0, 4, 4);
-    TEST_FIELD(COAUTHINFO, DWORD, dwAuthzSvc, 4, 4, 4);
-    TEST_FIELD(COAUTHINFO, LPWSTR, pwszServerPrincName, 8, 4, 4);
-    TEST_FIELD(COAUTHINFO, DWORD, dwAuthnLevel, 12, 4, 4);
-    TEST_FIELD(COAUTHINFO, DWORD, dwImpersonationLevel, 16, 4, 4);
-    TEST_FIELD(COAUTHINFO, COAUTHIDENTITY *, pAuthIdentityData, 20, 4, 4);
-    TEST_FIELD(COAUTHINFO, DWORD, dwCapabilities, 24, 4, 4);
+    TEST_FIELD(COAUTHINFO, dwAuthnSvc, 0, 4, 4);
+    TEST_FIELD(COAUTHINFO, dwAuthzSvc, 4, 4, 4);
+    TEST_FIELD(COAUTHINFO, pwszServerPrincName, 8, 4, 4);
+    TEST_FIELD(COAUTHINFO, dwAuthnLevel, 12, 4, 4);
+    TEST_FIELD(COAUTHINFO, dwImpersonationLevel, 16, 4, 4);
+    TEST_FIELD(COAUTHINFO, pAuthIdentityData, 20, 4, 4);
+    TEST_FIELD(COAUTHINFO, dwCapabilities, 24, 4, 4);
 }
 
 static void test_pack_DATE(void)
@@ -209,26 +209,26 @@ static void test_pack_DWORD_SIZEDARR(void)
 {
     /* DWORD_SIZEDARR (pack 4) */
     TEST_TYPE(DWORD_SIZEDARR, 8, 4);
-    TEST_FIELD(DWORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
-    TEST_FIELD(DWORD_SIZEDARR, unsigned long *, pData, 4, 4, 4);
+    TEST_FIELD(DWORD_SIZEDARR, clSize, 0, 4, 4);
+    TEST_FIELD(DWORD_SIZEDARR, pData, 4, 4, 4);
 }
 
 static void test_pack_FLAGGED_BYTE_BLOB(void)
 {
     /* FLAGGED_BYTE_BLOB (pack 4) */
     TEST_TYPE(FLAGGED_BYTE_BLOB, 12, 4);
-    TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, fFlags, 0, 4, 4);
-    TEST_FIELD(FLAGGED_BYTE_BLOB, unsigned long, clSize, 4, 4, 4);
-    TEST_FIELD(FLAGGED_BYTE_BLOB, byte[1], abData, 8, 1, 1);
+    TEST_FIELD(FLAGGED_BYTE_BLOB, fFlags, 0, 4, 4);
+    TEST_FIELD(FLAGGED_BYTE_BLOB, clSize, 4, 4, 4);
+    TEST_FIELD(FLAGGED_BYTE_BLOB, abData, 8, 1, 1);
 }
 
 static void test_pack_FLAGGED_WORD_BLOB(void)
 {
     /* FLAGGED_WORD_BLOB (pack 4) */
     TEST_TYPE(FLAGGED_WORD_BLOB, 12, 4);
-    TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, fFlags, 0, 4, 4);
-    TEST_FIELD(FLAGGED_WORD_BLOB, unsigned long, clSize, 4, 4, 4);
-    TEST_FIELD(FLAGGED_WORD_BLOB, unsigned short[1], asData, 8, 2, 2);
+    TEST_FIELD(FLAGGED_WORD_BLOB, fFlags, 0, 4, 4);
+    TEST_FIELD(FLAGGED_WORD_BLOB, clSize, 4, 4, 4);
+    TEST_FIELD(FLAGGED_WORD_BLOB, asData, 8, 2, 2);
 }
 
 static void test_pack_HMETAFILEPICT(void)
@@ -241,8 +241,8 @@ static void test_pack_HYPER_SIZEDARR(void)
 {
     /* HYPER_SIZEDARR (pack 4) */
     TEST_TYPE(HYPER_SIZEDARR, 8, 4);
-    TEST_FIELD(HYPER_SIZEDARR, unsigned long, clSize, 0, 4, 4);
-    TEST_FIELD(HYPER_SIZEDARR, hyper *, pData, 4, 4, 4);
+    TEST_FIELD(HYPER_SIZEDARR, clSize, 0, 4, 4);
+    TEST_FIELD(HYPER_SIZEDARR, pData, 4, 4, 4);
 }
 
 static void test_pack_LPBLOB(void)
@@ -306,44 +306,44 @@ static void test_pack_RemHBITMAP(void)
 {
     /* RemHBITMAP (pack 4) */
     TEST_TYPE(RemHBITMAP, 8, 4);
-    TEST_FIELD(RemHBITMAP, unsigned long, cbData, 0, 4, 4);
-    TEST_FIELD(RemHBITMAP, byte[1], data, 4, 1, 1);
+    TEST_FIELD(RemHBITMAP, cbData, 0, 4, 4);
+    TEST_FIELD(RemHBITMAP, data, 4, 1, 1);
 }
 
 static void test_pack_RemHENHMETAFILE(void)
 {
     /* RemHENHMETAFILE (pack 4) */
     TEST_TYPE(RemHENHMETAFILE, 8, 4);
-    TEST_FIELD(RemHENHMETAFILE, unsigned long, cbData, 0, 4, 4);
-    TEST_FIELD(RemHENHMETAFILE, byte[1], data, 4, 1, 1);
+    TEST_FIELD(RemHENHMETAFILE, cbData, 0, 4, 4);
+    TEST_FIELD(RemHENHMETAFILE, data, 4, 1, 1);
 }
 
 static void test_pack_RemHGLOBAL(void)
 {
     /* RemHGLOBAL (pack 4) */
     TEST_TYPE(RemHGLOBAL, 12, 4);
-    TEST_FIELD(RemHGLOBAL, long, fNullHGlobal, 0, 4, 4);
-    TEST_FIELD(RemHGLOBAL, unsigned long, cbData, 4, 4, 4);
-    TEST_FIELD(RemHGLOBAL, byte[1], data, 8, 1, 1);
+    TEST_FIELD(RemHGLOBAL, fNullHGlobal, 0, 4, 4);
+    TEST_FIELD(RemHGLOBAL, cbData, 4, 4, 4);
+    TEST_FIELD(RemHGLOBAL, data, 8, 1, 1);
 }
 
 static void test_pack_RemHMETAFILEPICT(void)
 {
     /* RemHMETAFILEPICT (pack 4) */
     TEST_TYPE(RemHMETAFILEPICT, 20, 4);
-    TEST_FIELD(RemHMETAFILEPICT, long, mm, 0, 4, 4);
-    TEST_FIELD(RemHMETAFILEPICT, long, xExt, 4, 4, 4);
-    TEST_FIELD(RemHMETAFILEPICT, long, yExt, 8, 4, 4);
-    TEST_FIELD(RemHMETAFILEPICT, unsigned long, cbData, 12, 4, 4);
-    TEST_FIELD(RemHMETAFILEPICT, byte[1], data, 16, 1, 1);
+    TEST_FIELD(RemHMETAFILEPICT, mm, 0, 4, 4);
+    TEST_FIELD(RemHMETAFILEPICT, xExt, 4, 4, 4);
+    TEST_FIELD(RemHMETAFILEPICT, yExt, 8, 4, 4);
+    TEST_FIELD(RemHMETAFILEPICT, cbData, 12, 4, 4);
+    TEST_FIELD(RemHMETAFILEPICT, data, 16, 1, 1);
 }
 
 static void test_pack_RemHPALETTE(void)
 {
     /* RemHPALETTE (pack 4) */
     TEST_TYPE(RemHPALETTE, 8, 4);
-    TEST_FIELD(RemHPALETTE, unsigned long, cbData, 0, 4, 4);
-    TEST_FIELD(RemHPALETTE, byte[1], data, 4, 1, 1);
+    TEST_FIELD(RemHPALETTE, cbData, 0, 4, 4);
+    TEST_FIELD(RemHPALETTE, data, 4, 1, 1);
 }
 
 static void test_pack_SCODE(void)
@@ -391,74 +391,74 @@ static void test_pack_WORD_SIZEDARR(void)
 {
     /* WORD_SIZEDARR (pack 4) */
     TEST_TYPE(WORD_SIZEDARR, 8, 4);
-    TEST_FIELD(WORD_SIZEDARR, unsigned long, clSize, 0, 4, 4);
-    TEST_FIELD(WORD_SIZEDARR, unsigned short *, pData, 4, 4, 4);
+    TEST_FIELD(WORD_SIZEDARR, clSize, 0, 4, 4);
+    TEST_FIELD(WORD_SIZEDARR, pData, 4, 4, 4);
 }
 
 static void test_pack_remoteMETAFILEPICT(void)
 {
     /* remoteMETAFILEPICT (pack 4) */
     TEST_TYPE(remoteMETAFILEPICT, 16, 4);
-    TEST_FIELD(remoteMETAFILEPICT, long, mm, 0, 4, 4);
-    TEST_FIELD(remoteMETAFILEPICT, long, xExt, 4, 4, 4);
-    TEST_FIELD(remoteMETAFILEPICT, long, yExt, 8, 4, 4);
-    TEST_FIELD(remoteMETAFILEPICT, userHMETAFILE *, hMF, 12, 4, 4);
+    TEST_FIELD(remoteMETAFILEPICT, mm, 0, 4, 4);
+    TEST_FIELD(remoteMETAFILEPICT, xExt, 4, 4, 4);
+    TEST_FIELD(remoteMETAFILEPICT, yExt, 8, 4, 4);
+    TEST_FIELD(remoteMETAFILEPICT, hMF, 12, 4, 4);
 }
 
 static void test_pack_userBITMAP(void)
 {
     /* userBITMAP (pack 4) */
     TEST_TYPE(userBITMAP, 28, 4);
-    TEST_FIELD(userBITMAP, LONG, bmType, 0, 4, 4);
-    TEST_FIELD(userBITMAP, LONG, bmWidth, 4, 4, 4);
-    TEST_FIELD(userBITMAP, LONG, bmHeight, 8, 4, 4);
-    TEST_FIELD(userBITMAP, LONG, bmWidthBytes, 12, 4, 4);
-    TEST_FIELD(userBITMAP, WORD, bmPlanes, 16, 2, 2);
-    TEST_FIELD(userBITMAP, WORD, bmBitsPixel, 18, 2, 2);
-    TEST_FIELD(userBITMAP, ULONG, cbSize, 20, 4, 4);
-    TEST_FIELD(userBITMAP, byte[1], pBuffer, 24, 1, 1);
+    TEST_FIELD(userBITMAP, bmType, 0, 4, 4);
+    TEST_FIELD(userBITMAP, bmWidth, 4, 4, 4);
+    TEST_FIELD(userBITMAP, bmHeight, 8, 4, 4);
+    TEST_FIELD(userBITMAP, bmWidthBytes, 12, 4, 4);
+    TEST_FIELD(userBITMAP, bmPlanes, 16, 2, 2);
+    TEST_FIELD(userBITMAP, bmBitsPixel, 18, 2, 2);
+    TEST_FIELD(userBITMAP, cbSize, 20, 4, 4);
+    TEST_FIELD(userBITMAP, pBuffer, 24, 1, 1);
 }
 
 static void test_pack_userCLIPFORMAT(void)
 {
     /* userCLIPFORMAT (pack 4) */
-    TEST_FIELD(userCLIPFORMAT, long, fContext, 0, 4, 4);
+    TEST_FIELD(userCLIPFORMAT, fContext, 0, 4, 4);
 }
 
 static void test_pack_userHBITMAP(void)
 {
     /* userHBITMAP (pack 4) */
-    TEST_FIELD(userHBITMAP, long, fContext, 0, 4, 4);
+    TEST_FIELD(userHBITMAP, fContext, 0, 4, 4);
 }
 
 static void test_pack_userHENHMETAFILE(void)
 {
     /* userHENHMETAFILE (pack 4) */
-    TEST_FIELD(userHENHMETAFILE, long, fContext, 0, 4, 4);
+    TEST_FIELD(userHENHMETAFILE, fContext, 0, 4, 4);
 }
 
 static void test_pack_userHGLOBAL(void)
 {
     /* userHGLOBAL (pack 4) */
-    TEST_FIELD(userHGLOBAL, long, fContext, 0, 4, 4);
+    TEST_FIELD(userHGLOBAL, fContext, 0, 4, 4);
 }
 
 static void test_pack_userHMETAFILE(void)
 {
     /* userHMETAFILE (pack 4) */
-    TEST_FIELD(userHMETAFILE, long, fContext, 0, 4, 4);
+    TEST_FIELD(userHMETAFILE, fContext, 0, 4, 4);
 }
 
 static void test_pack_userHMETAFILEPICT(void)
 {
     /* userHMETAFILEPICT (pack 4) */
-    TEST_FIELD(userHMETAFILEPICT, long, fContext, 0, 4, 4);
+    TEST_FIELD(userHMETAFILEPICT, fContext, 0, 4, 4);
 }
 
 static void test_pack_userHPALETTE(void)
 {
     /* userHPALETTE (pack 4) */
-    TEST_FIELD(userHPALETTE, long, fContext, 0, 4, 4);
+    TEST_FIELD(userHPALETTE, fContext, 0, 4, 4);
 }
 
 static void test_pack_wireBSTR(void)
@@ -532,34 +532,34 @@ static void test_pack_APPBARDATA(void)
 {
     /* APPBARDATA (pack 1) */
     TEST_TYPE(APPBARDATA, 36, 1);
-    TEST_FIELD(APPBARDATA, DWORD, cbSize, 0, 4, 1);
-    TEST_FIELD(APPBARDATA, HWND, hWnd, 4, 4, 1);
-    TEST_FIELD(APPBARDATA, UINT, uCallbackMessage, 8, 4, 1);
-    TEST_FIELD(APPBARDATA, UINT, uEdge, 12, 4, 1);
-    TEST_FIELD(APPBARDATA, RECT, rc, 16, 16, 1);
-    TEST_FIELD(APPBARDATA, LPARAM, lParam, 32, 4, 1);
+    TEST_FIELD(APPBARDATA, cbSize, 0, 4, 1);
+    TEST_FIELD(APPBARDATA, hWnd, 4, 4, 1);
+    TEST_FIELD(APPBARDATA, uCallbackMessage, 8, 4, 1);
+    TEST_FIELD(APPBARDATA, uEdge, 12, 4, 1);
+    TEST_FIELD(APPBARDATA, rc, 16, 16, 1);
+    TEST_FIELD(APPBARDATA, lParam, 32, 4, 1);
 }
 
 static void test_pack_DRAGINFOA(void)
 {
     /* DRAGINFOA (pack 1) */
     TEST_TYPE(DRAGINFOA, 24, 1);
-    TEST_FIELD(DRAGINFOA, UINT, uSize, 0, 4, 1);
-    TEST_FIELD(DRAGINFOA, POINT, pt, 4, 8, 1);
-    TEST_FIELD(DRAGINFOA, BOOL, fNC, 12, 4, 1);
-    TEST_FIELD(DRAGINFOA, LPSTR, lpFileList, 16, 4, 1);
-    TEST_FIELD(DRAGINFOA, DWORD, grfKeyState, 20, 4, 1);
+    TEST_FIELD(DRAGINFOA, uSize, 0, 4, 1);
+    TEST_FIELD(DRAGINFOA, pt, 4, 8, 1);
+    TEST_FIELD(DRAGINFOA, fNC, 12, 4, 1);
+    TEST_FIELD(DRAGINFOA, lpFileList, 16, 4, 1);
+    TEST_FIELD(DRAGINFOA, grfKeyState, 20, 4, 1);
 }
 
 static void test_pack_DRAGINFOW(void)
 {
     /* DRAGINFOW (pack 1) */
     TEST_TYPE(DRAGINFOW, 24, 1);
-    TEST_FIELD(DRAGINFOW, UINT, uSize, 0, 4, 1);
-    TEST_FIELD(DRAGINFOW, POINT, pt, 4, 8, 1);
-    TEST_FIELD(DRAGINFOW, BOOL, fNC, 12, 4, 1);
-    TEST_FIELD(DRAGINFOW, LPWSTR, lpFileList, 16, 4, 1);
-    TEST_FIELD(DRAGINFOW, DWORD, grfKeyState, 20, 4, 1);
+    TEST_FIELD(DRAGINFOW, uSize, 0, 4, 1);
+    TEST_FIELD(DRAGINFOW, pt, 4, 8, 1);
+    TEST_FIELD(DRAGINFOW, fNC, 12, 4, 1);
+    TEST_FIELD(DRAGINFOW, lpFileList, 16, 4, 1);
+    TEST_FIELD(DRAGINFOW, grfKeyState, 20, 4, 1);
 }
 
 static void test_pack_FILEOP_FLAGS(void)
@@ -626,31 +626,31 @@ static void test_pack_LPSHNAMEMAPPINGW(void)
 static void test_pack_NOTIFYICONDATAA(void)
 {
     /* NOTIFYICONDATAA (pack 1) */
-    TEST_FIELD(NOTIFYICONDATAA, DWORD, cbSize, 0, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, HWND, hWnd, 4, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, UINT, uID, 8, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, UINT, uFlags, 12, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, UINT, uCallbackMessage, 16, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, HICON, hIcon, 20, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, CHAR[128], szTip, 24, 128, 1);
-    TEST_FIELD(NOTIFYICONDATAA, DWORD, dwState, 152, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, DWORD, dwStateMask, 156, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAA, CHAR[256], szInfo, 160, 256, 1);
+    TEST_FIELD(NOTIFYICONDATAA, cbSize, 0, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, hWnd, 4, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, uID, 8, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, uFlags, 12, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, uCallbackMessage, 16, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, hIcon, 20, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, szTip, 24, 128, 1);
+    TEST_FIELD(NOTIFYICONDATAA, dwState, 152, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, dwStateMask, 156, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAA, szInfo, 160, 256, 1);
 }
 
 static void test_pack_NOTIFYICONDATAW(void)
 {
     /* NOTIFYICONDATAW (pack 1) */
-    TEST_FIELD(NOTIFYICONDATAW, DWORD, cbSize, 0, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, HWND, hWnd, 4, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, UINT, uID, 8, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, UINT, uFlags, 12, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, UINT, uCallbackMessage, 16, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, HICON, hIcon, 20, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, WCHAR[128], szTip, 24, 256, 1);
-    TEST_FIELD(NOTIFYICONDATAW, DWORD, dwState, 280, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, DWORD, dwStateMask, 284, 4, 1);
-    TEST_FIELD(NOTIFYICONDATAW, WCHAR[256], szInfo, 288, 512, 1);
+    TEST_FIELD(NOTIFYICONDATAW, cbSize, 0, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, hWnd, 4, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, uID, 8, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, uFlags, 12, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, uCallbackMessage, 16, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, hIcon, 20, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, szTip, 24, 256, 1);
+    TEST_FIELD(NOTIFYICONDATAW, dwState, 280, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, dwStateMask, 284, 4, 1);
+    TEST_FIELD(NOTIFYICONDATAW, szInfo, 288, 512, 1);
 }
 
 static void test_pack_PAPPBARDATA(void)
@@ -682,114 +682,114 @@ static void test_pack_PRINTEROP_FLAGS(void)
 static void test_pack_SHELLEXECUTEINFOA(void)
 {
     /* SHELLEXECUTEINFOA (pack 1) */
-    TEST_FIELD(SHELLEXECUTEINFOA, DWORD, cbSize, 0, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, ULONG, fMask, 4, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, HWND, hwnd, 8, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpVerb, 12, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpFile, 16, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpParameters, 20, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpDirectory, 24, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, INT, nShow, 28, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, HINSTANCE, hInstApp, 32, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, LPVOID, lpIDList, 36, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, LPCSTR, lpClass, 40, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, HKEY, hkeyClass, 44, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOA, DWORD, dwHotKey, 48, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, cbSize, 0, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, fMask, 4, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, hwnd, 8, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, lpVerb, 12, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, lpFile, 16, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, lpParameters, 20, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, lpDirectory, 24, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, nShow, 28, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, hInstApp, 32, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, lpIDList, 36, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, lpClass, 40, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, hkeyClass, 44, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOA, dwHotKey, 48, 4, 1);
 }
 
 static void test_pack_SHELLEXECUTEINFOW(void)
 {
     /* SHELLEXECUTEINFOW (pack 1) */
-    TEST_FIELD(SHELLEXECUTEINFOW, DWORD, cbSize, 0, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, ULONG, fMask, 4, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, HWND, hwnd, 8, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpVerb, 12, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpFile, 16, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpParameters, 20, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpDirectory, 24, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, INT, nShow, 28, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, HINSTANCE, hInstApp, 32, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, LPVOID, lpIDList, 36, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, LPCWSTR, lpClass, 40, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, HKEY, hkeyClass, 44, 4, 1);
-    TEST_FIELD(SHELLEXECUTEINFOW, DWORD, dwHotKey, 48, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, cbSize, 0, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, fMask, 4, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, hwnd, 8, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, lpVerb, 12, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, lpFile, 16, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, lpParameters, 20, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, lpDirectory, 24, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, nShow, 28, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, hInstApp, 32, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, lpIDList, 36, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, lpClass, 40, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, hkeyClass, 44, 4, 1);
+    TEST_FIELD(SHELLEXECUTEINFOW, dwHotKey, 48, 4, 1);
 }
 
 static void test_pack_SHFILEINFOA(void)
 {
     /* SHFILEINFOA (pack 1) */
     TEST_TYPE(SHFILEINFOA, 352, 1);
-    TEST_FIELD(SHFILEINFOA, HICON, hIcon, 0, 4, 1);
-    TEST_FIELD(SHFILEINFOA, int, iIcon, 4, 4, 1);
-    TEST_FIELD(SHFILEINFOA, DWORD, dwAttributes, 8, 4, 1);
-    TEST_FIELD(SHFILEINFOA, CHAR[MAX_PATH], szDisplayName, 12, 260, 1);
-    TEST_FIELD(SHFILEINFOA, CHAR[80], szTypeName, 272, 80, 1);
+    TEST_FIELD(SHFILEINFOA, hIcon, 0, 4, 1);
+    TEST_FIELD(SHFILEINFOA, iIcon, 4, 4, 1);
+    TEST_FIELD(SHFILEINFOA, dwAttributes, 8, 4, 1);
+    TEST_FIELD(SHFILEINFOA, szDisplayName, 12, 260, 1);
+    TEST_FIELD(SHFILEINFOA, szTypeName, 272, 80, 1);
 }
 
 static void test_pack_SHFILEINFOW(void)
 {
     /* SHFILEINFOW (pack 1) */
     TEST_TYPE(SHFILEINFOW, 692, 1);
-    TEST_FIELD(SHFILEINFOW, HICON, hIcon, 0, 4, 1);
-    TEST_FIELD(SHFILEINFOW, int, iIcon, 4, 4, 1);
-    TEST_FIELD(SHFILEINFOW, DWORD, dwAttributes, 8, 4, 1);
-    TEST_FIELD(SHFILEINFOW, WCHAR[MAX_PATH], szDisplayName, 12, 520, 1);
-    TEST_FIELD(SHFILEINFOW, WCHAR[80], szTypeName, 532, 160, 1);
+    TEST_FIELD(SHFILEINFOW, hIcon, 0, 4, 1);
+    TEST_FIELD(SHFILEINFOW, iIcon, 4, 4, 1);
+    TEST_FIELD(SHFILEINFOW, dwAttributes, 8, 4, 1);
+    TEST_FIELD(SHFILEINFOW, szDisplayName, 12, 520, 1);
+    TEST_FIELD(SHFILEINFOW, szTypeName, 532, 160, 1);
 }
 
 static void test_pack_SHFILEOPSTRUCTA(void)
 {
     /* SHFILEOPSTRUCTA (pack 1) */
     TEST_TYPE(SHFILEOPSTRUCTA, 30, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, HWND, hwnd, 0, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, UINT, wFunc, 4, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pFrom, 8, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, pTo, 12, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, FILEOP_FLAGS, fFlags, 16, 2, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, BOOL, fAnyOperationsAborted, 18, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, LPVOID, hNameMappings, 22, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTA, LPCSTR, lpszProgressTitle, 26, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, hwnd, 0, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, wFunc, 4, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, pFrom, 8, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, pTo, 12, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, fFlags, 16, 2, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, fAnyOperationsAborted, 18, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, hNameMappings, 22, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTA, lpszProgressTitle, 26, 4, 1);
 }
 
 static void test_pack_SHFILEOPSTRUCTW(void)
 {
     /* SHFILEOPSTRUCTW (pack 1) */
     TEST_TYPE(SHFILEOPSTRUCTW, 30, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, HWND, hwnd, 0, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, UINT, wFunc, 4, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pFrom, 8, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, pTo, 12, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, FILEOP_FLAGS, fFlags, 16, 2, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, BOOL, fAnyOperationsAborted, 18, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, LPVOID, hNameMappings, 22, 4, 1);
-    TEST_FIELD(SHFILEOPSTRUCTW, LPCWSTR, lpszProgressTitle, 26, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, hwnd, 0, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, wFunc, 4, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, pFrom, 8, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, pTo, 12, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, fFlags, 16, 2, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, fAnyOperationsAborted, 18, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, hNameMappings, 22, 4, 1);
+    TEST_FIELD(SHFILEOPSTRUCTW, lpszProgressTitle, 26, 4, 1);
 }
 
 static void test_pack_SHNAMEMAPPINGA(void)
 {
     /* SHNAMEMAPPINGA (pack 1) */
     TEST_TYPE(SHNAMEMAPPINGA, 16, 1);
-    TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszOldPath, 0, 4, 1);
-    TEST_FIELD(SHNAMEMAPPINGA, LPSTR, pszNewPath, 4, 4, 1);
-    TEST_FIELD(SHNAMEMAPPINGA, int, cchOldPath, 8, 4, 1);
-    TEST_FIELD(SHNAMEMAPPINGA, int, cchNewPath, 12, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGA, pszOldPath, 0, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGA, pszNewPath, 4, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGA, cchOldPath, 8, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGA, cchNewPath, 12, 4, 1);
 }
 
 static void test_pack_SHNAMEMAPPINGW(void)
 {
     /* SHNAMEMAPPINGW (pack 1) */
     TEST_TYPE(SHNAMEMAPPINGW, 16, 1);
-    TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszOldPath, 0, 4, 1);
-    TEST_FIELD(SHNAMEMAPPINGW, LPWSTR, pszNewPath, 4, 4, 1);
-    TEST_FIELD(SHNAMEMAPPINGW, int, cchOldPath, 8, 4, 1);
-    TEST_FIELD(SHNAMEMAPPINGW, int, cchNewPath, 12, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGW, pszOldPath, 0, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGW, pszNewPath, 4, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGW, cchOldPath, 8, 4, 1);
+    TEST_FIELD(SHNAMEMAPPINGW, cchNewPath, 12, 4, 1);
 }
 
 static void test_pack_ITEMIDLIST(void)
 {
     /* ITEMIDLIST (pack 1) */
     TEST_TYPE(ITEMIDLIST, 3, 1);
-    TEST_FIELD(ITEMIDLIST, SHITEMID, mkid, 0, 3, 1);
+    TEST_FIELD(ITEMIDLIST, mkid, 0, 3, 1);
 }
 
 static void test_pack_LPCITEMIDLIST(void)
@@ -833,33 +833,33 @@ static void test_pack_LPSTRRET(void)
 static void test_pack_SHELLDETAILS(void)
 {
     /* SHELLDETAILS (pack 1) */
-    TEST_FIELD(SHELLDETAILS, int, fmt, 0, 4, 1);
-    TEST_FIELD(SHELLDETAILS, int, cxChar, 4, 4, 1);
+    TEST_FIELD(SHELLDETAILS, fmt, 0, 4, 1);
+    TEST_FIELD(SHELLDETAILS, cxChar, 4, 4, 1);
 }
 
 static void test_pack_SHITEMID(void)
 {
     /* SHITEMID (pack 1) */
     TEST_TYPE(SHITEMID, 3, 1);
-    TEST_FIELD(SHITEMID, WORD, cb, 0, 2, 1);
-    TEST_FIELD(SHITEMID, BYTE[1], abID, 2, 1, 1);
+    TEST_FIELD(SHITEMID, cb, 0, 2, 1);
+    TEST_FIELD(SHITEMID, abID, 2, 1, 1);
 }
 
 static void test_pack_STRRET(void)
 {
     /* STRRET (pack 4) */
-    TEST_FIELD(STRRET, UINT, uType, 0, 4, 4);
+    TEST_FIELD(STRRET, uType, 0, 4, 4);
 }
 
 static void test_pack_AUTO_SCROLL_DATA(void)
 {
     /* AUTO_SCROLL_DATA (pack 1) */
     TEST_TYPE(AUTO_SCROLL_DATA, 48, 1);
-    TEST_FIELD(AUTO_SCROLL_DATA, int, iNextSample, 0, 4, 1);
-    TEST_FIELD(AUTO_SCROLL_DATA, DWORD, dwLastScroll, 4, 4, 1);
-    TEST_FIELD(AUTO_SCROLL_DATA, BOOL, bFull, 8, 4, 1);
-    TEST_FIELD(AUTO_SCROLL_DATA, POINT[NUM_POINTS], pts, 12, 24, 1);
-    TEST_FIELD(AUTO_SCROLL_DATA, DWORD[NUM_POINTS], dwTimes, 36, 12, 1);
+    TEST_FIELD(AUTO_SCROLL_DATA, iNextSample, 0, 4, 1);
+    TEST_FIELD(AUTO_SCROLL_DATA, dwLastScroll, 4, 4, 1);
+    TEST_FIELD(AUTO_SCROLL_DATA, bFull, 8, 4, 1);
+    TEST_FIELD(AUTO_SCROLL_DATA, pts, 12, 24, 1);
+    TEST_FIELD(AUTO_SCROLL_DATA, dwTimes, 36, 12, 1);
 }
 
 static void test_pack_BFFCALLBACK(void)
@@ -872,116 +872,116 @@ static void test_pack_BROWSEINFOA(void)
 {
     /* BROWSEINFOA (pack 8) */
     TEST_TYPE(BROWSEINFOA, 32, 4);
-    TEST_FIELD(BROWSEINFOA, HWND, hwndOwner, 0, 4, 4);
-    TEST_FIELD(BROWSEINFOA, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
-    TEST_FIELD(BROWSEINFOA, LPSTR, pszDisplayName, 8, 4, 4);
-    TEST_FIELD(BROWSEINFOA, LPCSTR, lpszTitle, 12, 4, 4);
-    TEST_FIELD(BROWSEINFOA, UINT, ulFlags, 16, 4, 4);
-    TEST_FIELD(BROWSEINFOA, BFFCALLBACK, lpfn, 20, 4, 4);
-    TEST_FIELD(BROWSEINFOA, LPARAM, lParam, 24, 4, 4);
-    TEST_FIELD(BROWSEINFOA, INT, iImage, 28, 4, 4);
+    TEST_FIELD(BROWSEINFOA, hwndOwner, 0, 4, 4);
+    TEST_FIELD(BROWSEINFOA, pidlRoot, 4, 4, 4);
+    TEST_FIELD(BROWSEINFOA, pszDisplayName, 8, 4, 4);
+    TEST_FIELD(BROWSEINFOA, lpszTitle, 12, 4, 4);
+    TEST_FIELD(BROWSEINFOA, ulFlags, 16, 4, 4);
+    TEST_FIELD(BROWSEINFOA, lpfn, 20, 4, 4);
+    TEST_FIELD(BROWSEINFOA, lParam, 24, 4, 4);
+    TEST_FIELD(BROWSEINFOA, iImage, 28, 4, 4);
 }
 
 static void test_pack_BROWSEINFOW(void)
 {
     /* BROWSEINFOW (pack 8) */
     TEST_TYPE(BROWSEINFOW, 32, 4);
-    TEST_FIELD(BROWSEINFOW, HWND, hwndOwner, 0, 4, 4);
-    TEST_FIELD(BROWSEINFOW, LPCITEMIDLIST, pidlRoot, 4, 4, 4);
-    TEST_FIELD(BROWSEINFOW, LPWSTR, pszDisplayName, 8, 4, 4);
-    TEST_FIELD(BROWSEINFOW, LPCWSTR, lpszTitle, 12, 4, 4);
-    TEST_FIELD(BROWSEINFOW, UINT, ulFlags, 16, 4, 4);
-    TEST_FIELD(BROWSEINFOW, BFFCALLBACK, lpfn, 20, 4, 4);
-    TEST_FIELD(BROWSEINFOW, LPARAM, lParam, 24, 4, 4);
-    TEST_FIELD(BROWSEINFOW, INT, iImage, 28, 4, 4);
+    TEST_FIELD(BROWSEINFOW, hwndOwner, 0, 4, 4);
+    TEST_FIELD(BROWSEINFOW, pidlRoot, 4, 4, 4);
+    TEST_FIELD(BROWSEINFOW, pszDisplayName, 8, 4, 4);
+    TEST_FIELD(BROWSEINFOW, lpszTitle, 12, 4, 4);
+    TEST_FIELD(BROWSEINFOW, ulFlags, 16, 4, 4);
+    TEST_FIELD(BROWSEINFOW, lpfn, 20, 4, 4);
+    TEST_FIELD(BROWSEINFOW, lParam, 24, 4, 4);
+    TEST_FIELD(BROWSEINFOW, iImage, 28, 4, 4);
 }
 
 static void test_pack_CABINETSTATE(void)
 {
     /* CABINETSTATE (pack 1) */
     TEST_TYPE(CABINETSTATE, 12, 1);
-    TEST_FIELD(CABINETSTATE, WORD, cLength, 0, 2, 1);
-    TEST_FIELD(CABINETSTATE, WORD, nVersion, 2, 2, 1);
-    TEST_FIELD(CABINETSTATE, UINT, fMenuEnumFilter, 8, 4, 1);
+    TEST_FIELD(CABINETSTATE, cLength, 0, 2, 1);
+    TEST_FIELD(CABINETSTATE, nVersion, 2, 2, 1);
+    TEST_FIELD(CABINETSTATE, fMenuEnumFilter, 8, 4, 1);
 }
 
 static void test_pack_CIDA(void)
 {
     /* CIDA (pack 1) */
     TEST_TYPE(CIDA, 8, 1);
-    TEST_FIELD(CIDA, UINT, cidl, 0, 4, 1);
-    TEST_FIELD(CIDA, UINT[1], aoffset, 4, 4, 1);
+    TEST_FIELD(CIDA, cidl, 0, 4, 1);
+    TEST_FIELD(CIDA, aoffset, 4, 4, 1);
 }
 
 static void test_pack_CSFV(void)
 {
     /* CSFV (pack 1) */
-    TEST_FIELD(CSFV, UINT, cbSize, 0, 4, 1);
-    TEST_FIELD(CSFV, IShellFolder*, pshf, 4, 4, 1);
-    TEST_FIELD(CSFV, IShellView*, psvOuter, 8, 4, 1);
-    TEST_FIELD(CSFV, LPCITEMIDLIST, pidl, 12, 4, 1);
-    TEST_FIELD(CSFV, LONG, lEvents, 16, 4, 1);
-    TEST_FIELD(CSFV, LPFNVIEWCALLBACK, pfnCallback, 20, 4, 1);
+    TEST_FIELD(CSFV, cbSize, 0, 4, 1);
+    TEST_FIELD(CSFV, pshf, 4, 4, 1);
+    TEST_FIELD(CSFV, psvOuter, 8, 4, 1);
+    TEST_FIELD(CSFV, pidl, 12, 4, 1);
+    TEST_FIELD(CSFV, lEvents, 16, 4, 1);
+    TEST_FIELD(CSFV, pfnCallback, 20, 4, 1);
 }
 
 static void test_pack_DROPFILES(void)
 {
     /* DROPFILES (pack 1) */
     TEST_TYPE(DROPFILES, 20, 1);
-    TEST_FIELD(DROPFILES, DWORD, pFiles, 0, 4, 1);
-    TEST_FIELD(DROPFILES, POINT, pt, 4, 8, 1);
-    TEST_FIELD(DROPFILES, BOOL, fNC, 12, 4, 1);
-    TEST_FIELD(DROPFILES, BOOL, fWide, 16, 4, 1);
+    TEST_FIELD(DROPFILES, pFiles, 0, 4, 1);
+    TEST_FIELD(DROPFILES, pt, 4, 8, 1);
+    TEST_FIELD(DROPFILES, fNC, 12, 4, 1);
+    TEST_FIELD(DROPFILES, fWide, 16, 4, 1);
 }
 
 static void test_pack_FILEDESCRIPTORA(void)
 {
     /* FILEDESCRIPTORA (pack 1) */
     TEST_TYPE(FILEDESCRIPTORA, 332, 1);
-    TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFlags, 0, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORA, CLSID, clsid, 4, 16, 1);
-    TEST_FIELD(FILEDESCRIPTORA, SIZEL, sizel, 20, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORA, POINTL, pointl, 28, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORA, DWORD, dwFileAttributes, 36, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftCreationTime, 40, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastAccessTime, 48, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORA, FILETIME, ftLastWriteTime, 56, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeHigh, 64, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORA, DWORD, nFileSizeLow, 68, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORA, CHAR[MAX_PATH], cFileName, 72, 260, 1);
+    TEST_FIELD(FILEDESCRIPTORA, dwFlags, 0, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORA, clsid, 4, 16, 1);
+    TEST_FIELD(FILEDESCRIPTORA, sizel, 20, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORA, pointl, 28, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORA, dwFileAttributes, 36, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORA, ftCreationTime, 40, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORA, ftLastAccessTime, 48, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORA, ftLastWriteTime, 56, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORA, nFileSizeHigh, 64, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORA, nFileSizeLow, 68, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORA, cFileName, 72, 260, 1);
 }
 
 static void test_pack_FILEDESCRIPTORW(void)
 {
     /* FILEDESCRIPTORW (pack 1) */
     TEST_TYPE(FILEDESCRIPTORW, 592, 1);
-    TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFlags, 0, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORW, CLSID, clsid, 4, 16, 1);
-    TEST_FIELD(FILEDESCRIPTORW, SIZEL, sizel, 20, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORW, POINTL, pointl, 28, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORW, DWORD, dwFileAttributes, 36, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftCreationTime, 40, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastAccessTime, 48, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORW, FILETIME, ftLastWriteTime, 56, 8, 1);
-    TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeHigh, 64, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORW, DWORD, nFileSizeLow, 68, 4, 1);
-    TEST_FIELD(FILEDESCRIPTORW, WCHAR[MAX_PATH], cFileName, 72, 520, 1);
+    TEST_FIELD(FILEDESCRIPTORW, dwFlags, 0, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORW, clsid, 4, 16, 1);
+    TEST_FIELD(FILEDESCRIPTORW, sizel, 20, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORW, pointl, 28, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORW, dwFileAttributes, 36, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORW, ftCreationTime, 40, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORW, ftLastAccessTime, 48, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORW, ftLastWriteTime, 56, 8, 1);
+    TEST_FIELD(FILEDESCRIPTORW, nFileSizeHigh, 64, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORW, nFileSizeLow, 68, 4, 1);
+    TEST_FIELD(FILEDESCRIPTORW, cFileName, 72, 520, 1);
 }
 
 static void test_pack_FILEGROUPDESCRIPTORA(void)
 {
     /* FILEGROUPDESCRIPTORA (pack 1) */
     TEST_TYPE(FILEGROUPDESCRIPTORA, 336, 1);
-    TEST_FIELD(FILEGROUPDESCRIPTORA, UINT, cItems, 0, 4, 1);
-    TEST_FIELD(FILEGROUPDESCRIPTORA, FILEDESCRIPTORA[1], fgd, 4, 332, 1);
+    TEST_FIELD(FILEGROUPDESCRIPTORA, cItems, 0, 4, 1);
+    TEST_FIELD(FILEGROUPDESCRIPTORA, fgd, 4, 332, 1);
 }
 
 static void test_pack_FILEGROUPDESCRIPTORW(void)
 {
     /* FILEGROUPDESCRIPTORW (pack 1) */
     TEST_TYPE(FILEGROUPDESCRIPTORW, 596, 1);
-    TEST_FIELD(FILEGROUPDESCRIPTORW, UINT, cItems, 0, 4, 1);
-    TEST_FIELD(FILEGROUPDESCRIPTORW, FILEDESCRIPTORW[1], fgd, 4, 592, 1);
+    TEST_FIELD(FILEGROUPDESCRIPTORW, cItems, 0, 4, 1);
+    TEST_FIELD(FILEGROUPDESCRIPTORW, fgd, 4, 592, 1);
 }
 
 static void test_pack_LPBROWSEINFOA(void)
@@ -1126,62 +1126,62 @@ static void test_pack_QCMINFO(void)
 {
     /* QCMINFO (pack 8) */
     TEST_TYPE(QCMINFO, 20, 4);
-    TEST_FIELD(QCMINFO, HMENU, hmenu, 0, 4, 4);
-    TEST_FIELD(QCMINFO, UINT, indexMenu, 4, 4, 4);
-    TEST_FIELD(QCMINFO, UINT, idCmdFirst, 8, 4, 4);
-    TEST_FIELD(QCMINFO, UINT, idCmdLast, 12, 4, 4);
-    TEST_FIELD(QCMINFO, QCMINFO_IDMAP const*, pIdMap, 16, 4, 4);
+    TEST_FIELD(QCMINFO, hmenu, 0, 4, 4);
+    TEST_FIELD(QCMINFO, indexMenu, 4, 4, 4);
+    TEST_FIELD(QCMINFO, idCmdFirst, 8, 4, 4);
+    TEST_FIELD(QCMINFO, idCmdLast, 12, 4, 4);
+    TEST_FIELD(QCMINFO, pIdMap, 16, 4, 4);
 }
 
 static void test_pack_QCMINFO_IDMAP(void)
 {
     /* QCMINFO_IDMAP (pack 8) */
     TEST_TYPE(QCMINFO_IDMAP, 12, 4);
-    TEST_FIELD(QCMINFO_IDMAP, UINT, nMaxIds, 0, 4, 4);
-    TEST_FIELD(QCMINFO_IDMAP, QCMINFO_IDMAP_PLACEMENT[1], pIdList, 4, 8, 4);
+    TEST_FIELD(QCMINFO_IDMAP, nMaxIds, 0, 4, 4);
+    TEST_FIELD(QCMINFO_IDMAP, pIdList, 4, 8, 4);
 }
 
 static void test_pack_QCMINFO_IDMAP_PLACEMENT(void)
 {
     /* QCMINFO_IDMAP_PLACEMENT (pack 8) */
     TEST_TYPE(QCMINFO_IDMAP_PLACEMENT, 8, 4);
-    TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, UINT, id, 0, 4, 4);
-    TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, UINT, fFlags, 4, 4, 4);
+    TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, id, 0, 4, 4);
+    TEST_FIELD(QCMINFO_IDMAP_PLACEMENT, fFlags, 4, 4, 4);
 }
 
 static void test_pack_SHChangeDWORDAsIDList(void)
 {
     /* SHChangeDWORDAsIDList (pack 1) */
     TEST_TYPE(SHChangeDWORDAsIDList, 12, 1);
-    TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cb, 0, 2, 1);
-    TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem1, 2, 4, 1);
-    TEST_FIELD(SHChangeDWORDAsIDList, DWORD, dwItem2, 6, 4, 1);
-    TEST_FIELD(SHChangeDWORDAsIDList, USHORT, cbZero, 10, 2, 1);
+    TEST_FIELD(SHChangeDWORDAsIDList, cb, 0, 2, 1);
+    TEST_FIELD(SHChangeDWORDAsIDList, dwItem1, 2, 4, 1);
+    TEST_FIELD(SHChangeDWORDAsIDList, dwItem2, 6, 4, 1);
+    TEST_FIELD(SHChangeDWORDAsIDList, cbZero, 10, 2, 1);
 }
 
 static void test_pack_SHChangeNotifyEntry(void)
 {
     /* SHChangeNotifyEntry (pack 1) */
     TEST_TYPE(SHChangeNotifyEntry, 8, 1);
-    TEST_FIELD(SHChangeNotifyEntry, LPCITEMIDLIST, pidl, 0, 4, 1);
-    TEST_FIELD(SHChangeNotifyEntry, BOOL, fRecursive, 4, 4, 1);
+    TEST_FIELD(SHChangeNotifyEntry, pidl, 0, 4, 1);
+    TEST_FIELD(SHChangeNotifyEntry, fRecursive, 4, 4, 1);
 }
 
 static void test_pack_SHChangeProductKeyAsIDList(void)
 {
     /* SHChangeProductKeyAsIDList (pack 1) */
     TEST_TYPE(SHChangeProductKeyAsIDList, 82, 1);
-    TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cb, 0, 2, 1);
-    TEST_FIELD(SHChangeProductKeyAsIDList, WCHAR[39], wszProductKey, 2, 78, 1);
-    TEST_FIELD(SHChangeProductKeyAsIDList, USHORT, cbZero, 80, 2, 1);
+    TEST_FIELD(SHChangeProductKeyAsIDList, cb, 0, 2, 1);
+    TEST_FIELD(SHChangeProductKeyAsIDList, wszProductKey, 2, 78, 1);
+    TEST_FIELD(SHChangeProductKeyAsIDList, cbZero, 80, 2, 1);
 }
 
 static void test_pack_SHDESCRIPTIONID(void)
 {
     /* SHDESCRIPTIONID (pack 8) */
     TEST_TYPE(SHDESCRIPTIONID, 20, 4);
-    TEST_FIELD(SHDESCRIPTIONID, DWORD, dwDescriptionId, 0, 4, 4);
-    TEST_FIELD(SHDESCRIPTIONID, CLSID, clsid, 4, 16, 4);
+    TEST_FIELD(SHDESCRIPTIONID, dwDescriptionId, 0, 4, 4);
+    TEST_FIELD(SHDESCRIPTIONID, clsid, 4, 16, 4);
 }
 
 static void test_pack_SHELLFLAGSTATE(void)
@@ -1194,20 +1194,20 @@ static void test_pack_SHELLSTATE(void)
 {
     /* SHELLSTATE (pack 1) */
     TEST_TYPE(SHELLSTATE, 32, 1);
-    TEST_FIELD(SHELLSTATE, DWORD, dwWin95Unused, 4, 4, 1);
-    TEST_FIELD(SHELLSTATE, UINT, uWin95Unused, 8, 4, 1);
-    TEST_FIELD(SHELLSTATE, LONG, lParamSort, 12, 4, 1);
-    TEST_FIELD(SHELLSTATE, int, iSortDirection, 16, 4, 1);
-    TEST_FIELD(SHELLSTATE, UINT, version, 20, 4, 1);
-    TEST_FIELD(SHELLSTATE, UINT, uNotUsed, 24, 4, 1);
+    TEST_FIELD(SHELLSTATE, dwWin95Unused, 4, 4, 1);
+    TEST_FIELD(SHELLSTATE, uWin95Unused, 8, 4, 1);
+    TEST_FIELD(SHELLSTATE, lParamSort, 12, 4, 1);
+    TEST_FIELD(SHELLSTATE, iSortDirection, 16, 4, 1);
+    TEST_FIELD(SHELLSTATE, version, 20, 4, 1);
+    TEST_FIELD(SHELLSTATE, uNotUsed, 24, 4, 1);
 }
 
 static void test_pack_TBINFO(void)
 {
     /* TBINFO (pack 8) */
     TEST_TYPE(TBINFO, 8, 4);
-    TEST_FIELD(TBINFO, UINT, cbuttons, 0, 4, 4);
-    TEST_FIELD(TBINFO, UINT, uFlags, 4, 4, 4);
+    TEST_FIELD(TBINFO, cbuttons, 0, 4, 4);
+    TEST_FIELD(TBINFO, uFlags, 4, 4, 4);
 }
 
 static void test_pack(void)
diff --git a/dlls/shlwapi/tests/generated.c b/dlls/shlwapi/tests/generated.c
index 0b52d65fb15..e6581ae124c 100644
--- a/dlls/shlwapi/tests/generated.c
+++ b/dlls/shlwapi/tests/generated.c
@@ -91,10 +91,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -127,20 +127,20 @@ static void test_pack_DLLVERSIONINFO(void)
 {
     /* DLLVERSIONINFO (pack 8) */
     TEST_TYPE(DLLVERSIONINFO, 20, 4);
-    TEST_FIELD(DLLVERSIONINFO, DWORD, cbSize, 0, 4, 4);
-    TEST_FIELD(DLLVERSIONINFO, DWORD, dwMajorVersion, 4, 4, 4);
-    TEST_FIELD(DLLVERSIONINFO, DWORD, dwMinorVersion, 8, 4, 4);
-    TEST_FIELD(DLLVERSIONINFO, DWORD, dwBuildNumber, 12, 4, 4);
-    TEST_FIELD(DLLVERSIONINFO, DWORD, dwPlatformID, 16, 4, 4);
+    TEST_FIELD(DLLVERSIONINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(DLLVERSIONINFO, dwMajorVersion, 4, 4, 4);
+    TEST_FIELD(DLLVERSIONINFO, dwMinorVersion, 8, 4, 4);
+    TEST_FIELD(DLLVERSIONINFO, dwBuildNumber, 12, 4, 4);
+    TEST_FIELD(DLLVERSIONINFO, dwPlatformID, 16, 4, 4);
 }
 
 static void test_pack_DLLVERSIONINFO2(void)
 {
     /* DLLVERSIONINFO2 (pack 8) */
     TEST_TYPE(DLLVERSIONINFO2, 32, 8);
-    TEST_FIELD(DLLVERSIONINFO2, DLLVERSIONINFO, info1, 0, 20, 4);
-    TEST_FIELD(DLLVERSIONINFO2, DWORD, dwFlags, 20, 4, 4);
-    TEST_FIELD(DLLVERSIONINFO2, ULONGLONG, ullVersion, 24, 8, 8);
+    TEST_FIELD(DLLVERSIONINFO2, info1, 0, 20, 4);
+    TEST_FIELD(DLLVERSIONINFO2, dwFlags, 20, 4, 4);
+    TEST_FIELD(DLLVERSIONINFO2, ullVersion, 24, 8, 8);
 }
 
 static void test_pack_HUSKEY(void)
diff --git a/dlls/urlmon/tests/generated.c b/dlls/urlmon/tests/generated.c
index 61233cd1247..add2035bf0d 100644
--- a/dlls/urlmon/tests/generated.c
+++ b/dlls/urlmon/tests/generated.c
@@ -89,10 +89,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -111,8 +111,8 @@
 static void test_pack_BINDINFO(void)
 {
     /* BINDINFO (pack 4) */
-    TEST_FIELD(BINDINFO, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(BINDINFO, LPWSTR, szExtraInfo, 4, 4, 4);
+    TEST_FIELD(BINDINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(BINDINFO, szExtraInfo, 4, 4, 4);
 }
 
 static void test_pack_IBindHost(void)
@@ -265,39 +265,39 @@ static void test_pack_REMSECURITY_ATTRIBUTES(void)
 {
     /* REMSECURITY_ATTRIBUTES (pack 4) */
     TEST_TYPE(REMSECURITY_ATTRIBUTES, 12, 4);
-    TEST_FIELD(REMSECURITY_ATTRIBUTES, DWORD, nLength, 0, 4, 4);
-    TEST_FIELD(REMSECURITY_ATTRIBUTES, DWORD, lpSecurityDescriptor, 4, 4, 4);
-    TEST_FIELD(REMSECURITY_ATTRIBUTES, BOOL, bInheritHandle, 8, 4, 4);
+    TEST_FIELD(REMSECURITY_ATTRIBUTES, nLength, 0, 4, 4);
+    TEST_FIELD(REMSECURITY_ATTRIBUTES, lpSecurityDescriptor, 4, 4, 4);
+    TEST_FIELD(REMSECURITY_ATTRIBUTES, bInheritHandle, 8, 4, 4);
 }
 
 static void test_pack_RemBINDINFO(void)
 {
     /* RemBINDINFO (pack 4) */
     TEST_TYPE(RemBINDINFO, 72, 4);
-    TEST_FIELD(RemBINDINFO, ULONG, cbSize, 0, 4, 4);
-    TEST_FIELD(RemBINDINFO, LPWSTR, szExtraInfo, 4, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, grfBindInfoF, 8, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, dwBindVerb, 12, 4, 4);
-    TEST_FIELD(RemBINDINFO, LPWSTR, szCustomVerb, 16, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, cbstgmedData, 20, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, dwOptions, 24, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, dwOptionsFlags, 28, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, dwCodePage, 32, 4, 4);
-    TEST_FIELD(RemBINDINFO, REMSECURITY_ATTRIBUTES, securityAttributes, 36, 12, 4);
-    TEST_FIELD(RemBINDINFO, IID, iid, 48, 16, 4);
-    TEST_FIELD(RemBINDINFO, IUnknown *, pUnk, 64, 4, 4);
-    TEST_FIELD(RemBINDINFO, DWORD, dwReserved, 68, 4, 4);
+    TEST_FIELD(RemBINDINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(RemBINDINFO, szExtraInfo, 4, 4, 4);
+    TEST_FIELD(RemBINDINFO, grfBindInfoF, 8, 4, 4);
+    TEST_FIELD(RemBINDINFO, dwBindVerb, 12, 4, 4);
+    TEST_FIELD(RemBINDINFO, szCustomVerb, 16, 4, 4);
+    TEST_FIELD(RemBINDINFO, cbstgmedData, 20, 4, 4);
+    TEST_FIELD(RemBINDINFO, dwOptions, 24, 4, 4);
+    TEST_FIELD(RemBINDINFO, dwOptionsFlags, 28, 4, 4);
+    TEST_FIELD(RemBINDINFO, dwCodePage, 32, 4, 4);
+    TEST_FIELD(RemBINDINFO, securityAttributes, 36, 12, 4);
+    TEST_FIELD(RemBINDINFO, iid, 48, 16, 4);
+    TEST_FIELD(RemBINDINFO, pUnk, 64, 4, 4);
+    TEST_FIELD(RemBINDINFO, dwReserved, 68, 4, 4);
 }
 
 static void test_pack_RemFORMATETC(void)
 {
     /* RemFORMATETC (pack 4) */
     TEST_TYPE(RemFORMATETC, 20, 4);
-    TEST_FIELD(RemFORMATETC, DWORD, cfFormat, 0, 4, 4);
-    TEST_FIELD(RemFORMATETC, DWORD, ptd, 4, 4, 4);
-    TEST_FIELD(RemFORMATETC, DWORD, dwAspect, 8, 4, 4);
-    TEST_FIELD(RemFORMATETC, LONG, lindex, 12, 4, 4);
-    TEST_FIELD(RemFORMATETC, DWORD, tymed, 16, 4, 4);
+    TEST_FIELD(RemFORMATETC, cfFormat, 0, 4, 4);
+    TEST_FIELD(RemFORMATETC, ptd, 4, 4, 4);
+    TEST_FIELD(RemFORMATETC, dwAspect, 8, 4, 4);
+    TEST_FIELD(RemFORMATETC, lindex, 12, 4, 4);
+    TEST_FIELD(RemFORMATETC, tymed, 16, 4, 4);
 }
 
 static void test_pack(void)
diff --git a/dlls/user32/tests/generated.c b/dlls/user32/tests/generated.c
index be1796f387d..a38771e9719 100644
--- a/dlls/user32/tests/generated.c
+++ b/dlls/user32/tests/generated.c
@@ -86,10 +86,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -109,174 +109,174 @@ 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);
+    TEST_FIELD(ACCESSTIMEOUT, cbSize, 0, 4, 4);
+    TEST_FIELD(ACCESSTIMEOUT, dwFlags, 4, 4, 4);
+    TEST_FIELD(ACCESSTIMEOUT, 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);
+    TEST_FIELD(ANIMATIONINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(ANIMATIONINFO, 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);
+    TEST_FIELD(CBTACTIVATESTRUCT, fMouse, 0, 4, 4);
+    TEST_FIELD(CBTACTIVATESTRUCT, 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);
+    TEST_FIELD(CBT_CREATEWNDA, lpcs, 0, 4, 4);
+    TEST_FIELD(CBT_CREATEWNDA, 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);
+    TEST_FIELD(CBT_CREATEWNDW, lpcs, 0, 4, 4);
+    TEST_FIELD(CBT_CREATEWNDW, 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);
+    TEST_FIELD(CLIENTCREATESTRUCT, hWindowMenu, 0, 4, 4);
+    TEST_FIELD(CLIENTCREATESTRUCT, 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);
+    TEST_FIELD(COMBOBOXINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, rcItem, 4, 16, 4);
+    TEST_FIELD(COMBOBOXINFO, rcButton, 20, 16, 4);
+    TEST_FIELD(COMBOBOXINFO, stateButton, 36, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, hwndCombo, 40, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, hwndItem, 44, 4, 4);
+    TEST_FIELD(COMBOBOXINFO, 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);
-    TEST_FIELD(COMPAREITEMSTRUCT, UINT, CtlID, 4, 4, 4);
-    TEST_FIELD(COMPAREITEMSTRUCT, HWND, hwndItem, 8, 4, 4);
-    TEST_FIELD(COMPAREITEMSTRUCT, UINT, itemID1, 12, 4, 4);
-    TEST_FIELD(COMPAREITEMSTRUCT, ULONG_PTR, itemData1, 16, 4, 4);
-    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);
+    TEST_FIELD(COMPAREITEMSTRUCT, CtlType, 0, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, CtlID, 4, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, hwndItem, 8, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, itemID1, 12, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, itemData1, 16, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, itemID2, 20, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, itemData2, 24, 4, 4);
+    TEST_FIELD(COMPAREITEMSTRUCT, 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);
+    TEST_FIELD(COPYDATASTRUCT, dwData, 0, 4, 4);
+    TEST_FIELD(COPYDATASTRUCT, cbData, 4, 4, 4);
+    TEST_FIELD(COPYDATASTRUCT, 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);
-    TEST_FIELD(CREATESTRUCTA, HINSTANCE, hInstance, 4, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, HMENU, hMenu, 8, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, HWND, hwndParent, 12, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, INT, cy, 16, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, INT, cx, 20, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, INT, y, 24, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, INT, x, 28, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, LONG, style, 32, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, LPCSTR, lpszName, 36, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, LPCSTR, lpszClass, 40, 4, 4);
-    TEST_FIELD(CREATESTRUCTA, DWORD, dwExStyle, 44, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, lpCreateParams, 0, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, hInstance, 4, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, hMenu, 8, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, hwndParent, 12, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, cy, 16, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, cx, 20, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, y, 24, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, x, 28, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, style, 32, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, lpszName, 36, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, lpszClass, 40, 4, 4);
+    TEST_FIELD(CREATESTRUCTA, 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);
-    TEST_FIELD(CREATESTRUCTW, HINSTANCE, hInstance, 4, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, HMENU, hMenu, 8, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, HWND, hwndParent, 12, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, INT, cy, 16, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, INT, cx, 20, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, INT, y, 24, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, INT, x, 28, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, LONG, style, 32, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, LPCWSTR, lpszName, 36, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, LPCWSTR, lpszClass, 40, 4, 4);
-    TEST_FIELD(CREATESTRUCTW, DWORD, dwExStyle, 44, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, lpCreateParams, 0, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, hInstance, 4, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, hMenu, 8, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, hwndParent, 12, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, cy, 16, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, cx, 20, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, y, 24, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, x, 28, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, style, 32, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, lpszName, 36, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, lpszClass, 40, 4, 4);
+    TEST_FIELD(CREATESTRUCTW, 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);
+    TEST_FIELD(CURSORINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(CURSORINFO, flags, 4, 4, 4);
+    TEST_FIELD(CURSORINFO, hCursor, 8, 4, 4);
+    TEST_FIELD(CURSORINFO, 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);
-    TEST_FIELD(CWPRETSTRUCT, LPARAM, lParam, 4, 4, 4);
-    TEST_FIELD(CWPRETSTRUCT, WPARAM, wParam, 8, 4, 4);
-    TEST_FIELD(CWPRETSTRUCT, DWORD, message, 12, 4, 4);
-    TEST_FIELD(CWPRETSTRUCT, HWND, hwnd, 16, 4, 4);
+    TEST_FIELD(CWPRETSTRUCT, lResult, 0, 4, 4);
+    TEST_FIELD(CWPRETSTRUCT, lParam, 4, 4, 4);
+    TEST_FIELD(CWPRETSTRUCT, wParam, 8, 4, 4);
+    TEST_FIELD(CWPRETSTRUCT, message, 12, 4, 4);
+    TEST_FIELD(CWPRETSTRUCT, 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);
+    TEST_FIELD(CWPSTRUCT, lParam, 0, 4, 4);
+    TEST_FIELD(CWPSTRUCT, wParam, 4, 4, 4);
+    TEST_FIELD(CWPSTRUCT, message, 8, 4, 4);
+    TEST_FIELD(CWPSTRUCT, 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);
-    TEST_FIELD(DEBUGHOOKINFO, DWORD, idThreadInstaller, 4, 4, 4);
-    TEST_FIELD(DEBUGHOOKINFO, LPARAM, lParam, 8, 4, 4);
-    TEST_FIELD(DEBUGHOOKINFO, WPARAM, wParam, 12, 4, 4);
-    TEST_FIELD(DEBUGHOOKINFO, INT, code, 16, 4, 4);
+    TEST_FIELD(DEBUGHOOKINFO, idThread, 0, 4, 4);
+    TEST_FIELD(DEBUGHOOKINFO, idThreadInstaller, 4, 4, 4);
+    TEST_FIELD(DEBUGHOOKINFO, lParam, 8, 4, 4);
+    TEST_FIELD(DEBUGHOOKINFO, wParam, 12, 4, 4);
+    TEST_FIELD(DEBUGHOOKINFO, 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);
-    TEST_FIELD(DELETEITEMSTRUCT, UINT, CtlID, 4, 4, 4);
-    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);
+    TEST_FIELD(DELETEITEMSTRUCT, CtlType, 0, 4, 4);
+    TEST_FIELD(DELETEITEMSTRUCT, CtlID, 4, 4, 4);
+    TEST_FIELD(DELETEITEMSTRUCT, itemID, 8, 4, 4);
+    TEST_FIELD(DELETEITEMSTRUCT, hwndItem, 12, 4, 4);
+    TEST_FIELD(DELETEITEMSTRUCT, itemData, 16, 4, 4);
 }
 
 static void test_pack_DESKTOPENUMPROCA(void)
@@ -295,13 +295,13 @@ static void test_pack_DLGITEMTEMPLATE(void)
 {
     /* DLGITEMTEMPLATE (pack 2) */
     TEST_TYPE(DLGITEMTEMPLATE, 18, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, DWORD, style, 0, 4, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, DWORD, dwExtendedStyle, 4, 4, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, short, x, 8, 2, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, short, y, 10, 2, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, short, cx, 12, 2, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, short, cy, 14, 2, 2);
-    TEST_FIELD(DLGITEMTEMPLATE, WORD, id, 16, 2, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, style, 0, 4, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, dwExtendedStyle, 4, 4, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, x, 8, 2, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, y, 10, 2, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, cx, 12, 2, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, cy, 14, 2, 2);
+    TEST_FIELD(DLGITEMTEMPLATE, id, 16, 2, 2);
 }
 
 static void test_pack_DLGPROC(void)
@@ -314,28 +314,28 @@ static void test_pack_DLGTEMPLATE(void)
 {
     /* DLGTEMPLATE (pack 2) */
     TEST_TYPE(DLGTEMPLATE, 18, 2);
-    TEST_FIELD(DLGTEMPLATE, DWORD, style, 0, 4, 2);
-    TEST_FIELD(DLGTEMPLATE, DWORD, dwExtendedStyle, 4, 4, 2);
-    TEST_FIELD(DLGTEMPLATE, WORD, cdit, 8, 2, 2);
-    TEST_FIELD(DLGTEMPLATE, short, x, 10, 2, 2);
-    TEST_FIELD(DLGTEMPLATE, short, y, 12, 2, 2);
-    TEST_FIELD(DLGTEMPLATE, short, cx, 14, 2, 2);
-    TEST_FIELD(DLGTEMPLATE, short, cy, 16, 2, 2);
+    TEST_FIELD(DLGTEMPLATE, style, 0, 4, 2);
+    TEST_FIELD(DLGTEMPLATE, dwExtendedStyle, 4, 4, 2);
+    TEST_FIELD(DLGTEMPLATE, cdit, 8, 2, 2);
+    TEST_FIELD(DLGTEMPLATE, x, 10, 2, 2);
+    TEST_FIELD(DLGTEMPLATE, y, 12, 2, 2);
+    TEST_FIELD(DLGTEMPLATE, cx, 14, 2, 2);
+    TEST_FIELD(DLGTEMPLATE, cy, 16, 2, 2);
 }
 
 static void test_pack_DRAWITEMSTRUCT(void)
 {
     /* DRAWITEMSTRUCT (pack 4) */
     TEST_TYPE(DRAWITEMSTRUCT, 48, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, UINT, CtlType, 0, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, UINT, CtlID, 4, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, UINT, itemID, 8, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, UINT, itemAction, 12, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, UINT, itemState, 16, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, HWND, hwndItem, 20, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, HDC, hDC, 24, 4, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, RECT, rcItem, 28, 16, 4);
-    TEST_FIELD(DRAWITEMSTRUCT, ULONG_PTR, itemData, 44, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, CtlType, 0, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, CtlID, 4, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, itemID, 8, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, itemAction, 12, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, itemState, 16, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, hwndItem, 20, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, hDC, 24, 4, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, rcItem, 28, 16, 4);
+    TEST_FIELD(DRAWITEMSTRUCT, itemData, 44, 4, 4);
 }
 
 static void test_pack_DRAWSTATEPROC(void)
@@ -348,11 +348,11 @@ static void test_pack_DRAWTEXTPARAMS(void)
 {
     /* DRAWTEXTPARAMS (pack 4) */
     TEST_TYPE(DRAWTEXTPARAMS, 20, 4);
-    TEST_FIELD(DRAWTEXTPARAMS, UINT, cbSize, 0, 4, 4);
-    TEST_FIELD(DRAWTEXTPARAMS, INT, iTabLength, 4, 4, 4);
-    TEST_FIELD(DRAWTEXTPARAMS, INT, iLeftMargin, 8, 4, 4);
-    TEST_FIELD(DRAWTEXTPARAMS, INT, iRightMargin, 12, 4, 4);
-    TEST_FIELD(DRAWTEXTPARAMS, UINT, uiLengthDrawn, 16, 4, 4);
+    TEST_FIELD(DRAWTEXTPARAMS, cbSize, 0, 4, 4);
+    TEST_FIELD(DRAWTEXTPARAMS, iTabLength, 4, 4, 4);
+    TEST_FIELD(DRAWTEXTPARAMS, iLeftMargin, 8, 4, 4);
+    TEST_FIELD(DRAWTEXTPARAMS, iRightMargin, 12, 4, 4);
+    TEST_FIELD(DRAWTEXTPARAMS, uiLengthDrawn, 16, 4, 4);
 }
 
 static void test_pack_EDITWORDBREAKPROCA(void)
@@ -371,34 +371,34 @@ static void test_pack_EVENTMSG(void)
 {
     /* EVENTMSG (pack 4) */
     TEST_TYPE(EVENTMSG, 20, 4);
-    TEST_FIELD(EVENTMSG, UINT, message, 0, 4, 4);
-    TEST_FIELD(EVENTMSG, UINT, paramL, 4, 4, 4);
-    TEST_FIELD(EVENTMSG, UINT, paramH, 8, 4, 4);
-    TEST_FIELD(EVENTMSG, DWORD, time, 12, 4, 4);
-    TEST_FIELD(EVENTMSG, HWND, hwnd, 16, 4, 4);
+    TEST_FIELD(EVENTMSG, message, 0, 4, 4);
+    TEST_FIELD(EVENTMSG, paramL, 4, 4, 4);
+    TEST_FIELD(EVENTMSG, paramH, 8, 4, 4);
+    TEST_FIELD(EVENTMSG, time, 12, 4, 4);
+    TEST_FIELD(EVENTMSG, 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);
-    TEST_FIELD(FILTERKEYS, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(FILTERKEYS, DWORD, iWaitMSec, 8, 4, 4);
-    TEST_FIELD(FILTERKEYS, DWORD, iDelayMSec, 12, 4, 4);
-    TEST_FIELD(FILTERKEYS, DWORD, iRepeatMSec, 16, 4, 4);
-    TEST_FIELD(FILTERKEYS, DWORD, iBounceMSec, 20, 4, 4);
+    TEST_FIELD(FILTERKEYS, cbSize, 0, 4, 4);
+    TEST_FIELD(FILTERKEYS, dwFlags, 4, 4, 4);
+    TEST_FIELD(FILTERKEYS, iWaitMSec, 8, 4, 4);
+    TEST_FIELD(FILTERKEYS, iDelayMSec, 12, 4, 4);
+    TEST_FIELD(FILTERKEYS, iRepeatMSec, 16, 4, 4);
+    TEST_FIELD(FILTERKEYS, iBounceMSec, 20, 4, 4);
 }
 
 static void test_pack_FLASHWINFO(void)
 {
     /* FLASHWINFO (pack 4) */
     TEST_TYPE(FLASHWINFO, 20, 4);
-    TEST_FIELD(FLASHWINFO, UINT, cbSize, 0, 4, 4);
-    TEST_FIELD(FLASHWINFO, HWND, hwnd, 4, 4, 4);
-    TEST_FIELD(FLASHWINFO, DWORD, dwFlags, 8, 4, 4);
-    TEST_FIELD(FLASHWINFO, UINT, uCount, 12, 4, 4);
-    TEST_FIELD(FLASHWINFO, DWORD, dwTimeout, 16, 4, 4);
+    TEST_FIELD(FLASHWINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(FLASHWINFO, hwnd, 4, 4, 4);
+    TEST_FIELD(FLASHWINFO, dwFlags, 8, 4, 4);
+    TEST_FIELD(FLASHWINFO, uCount, 12, 4, 4);
+    TEST_FIELD(FLASHWINFO, dwTimeout, 16, 4, 4);
 }
 
 static void test_pack_GRAYSTRINGPROC(void)
@@ -411,34 +411,34 @@ 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);
+    TEST_FIELD(GUITHREADINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(GUITHREADINFO, flags, 4, 4, 4);
+    TEST_FIELD(GUITHREADINFO, hwndActive, 8, 4, 4);
+    TEST_FIELD(GUITHREADINFO, hwndFocus, 12, 4, 4);
+    TEST_FIELD(GUITHREADINFO, hwndCapture, 16, 4, 4);
+    TEST_FIELD(GUITHREADINFO, hwndMenuOwner, 20, 4, 4);
+    TEST_FIELD(GUITHREADINFO, hwndMoveSize, 24, 4, 4);
+    TEST_FIELD(GUITHREADINFO, hwndCaret, 28, 4, 4);
+    TEST_FIELD(GUITHREADINFO, rcCaret, 32, 16, 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);
+    TEST_FIELD(HARDWAREHOOKSTRUCT, hwnd, 0, 4, 4);
+    TEST_FIELD(HARDWAREHOOKSTRUCT, message, 4, 4, 4);
+    TEST_FIELD(HARDWAREHOOKSTRUCT, wParam, 8, 4, 4);
+    TEST_FIELD(HARDWAREHOOKSTRUCT, 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);
+    TEST_FIELD(HARDWAREINPUT, uMsg, 0, 4, 4);
+    TEST_FIELD(HARDWAREINPUT, wParamL, 4, 2, 2);
+    TEST_FIELD(HARDWAREINPUT, wParamH, 6, 2, 2);
 }
 
 static void test_pack_HDEVNOTIFY(void)
@@ -457,56 +457,56 @@ static void test_pack_HELPINFO(void)
 {
     /* HELPINFO (pack 4) */
     TEST_TYPE(HELPINFO, 28, 4);
-    TEST_FIELD(HELPINFO, UINT, cbSize, 0, 4, 4);
-    TEST_FIELD(HELPINFO, INT, iContextType, 4, 4, 4);
-    TEST_FIELD(HELPINFO, INT, iCtrlId, 8, 4, 4);
-    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);
+    TEST_FIELD(HELPINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(HELPINFO, iContextType, 4, 4, 4);
+    TEST_FIELD(HELPINFO, iCtrlId, 8, 4, 4);
+    TEST_FIELD(HELPINFO, hItemHandle, 12, 4, 4);
+    TEST_FIELD(HELPINFO, dwContextId, 16, 4, 4);
+    TEST_FIELD(HELPINFO, 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);
-    TEST_FIELD(HELPWININFOA, int, x, 4, 4, 4);
-    TEST_FIELD(HELPWININFOA, int, y, 8, 4, 4);
-    TEST_FIELD(HELPWININFOA, int, dx, 12, 4, 4);
-    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);
+    TEST_FIELD(HELPWININFOA, wStructSize, 0, 4, 4);
+    TEST_FIELD(HELPWININFOA, x, 4, 4, 4);
+    TEST_FIELD(HELPWININFOA, y, 8, 4, 4);
+    TEST_FIELD(HELPWININFOA, dx, 12, 4, 4);
+    TEST_FIELD(HELPWININFOA, dy, 16, 4, 4);
+    TEST_FIELD(HELPWININFOA, wMax, 20, 4, 4);
+    TEST_FIELD(HELPWININFOA, 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);
-    TEST_FIELD(HELPWININFOW, int, x, 4, 4, 4);
-    TEST_FIELD(HELPWININFOW, int, y, 8, 4, 4);
-    TEST_FIELD(HELPWININFOW, int, dx, 12, 4, 4);
-    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);
+    TEST_FIELD(HELPWININFOW, wStructSize, 0, 4, 4);
+    TEST_FIELD(HELPWININFOW, x, 4, 4, 4);
+    TEST_FIELD(HELPWININFOW, y, 8, 4, 4);
+    TEST_FIELD(HELPWININFOW, dx, 12, 4, 4);
+    TEST_FIELD(HELPWININFOW, dy, 16, 4, 4);
+    TEST_FIELD(HELPWININFOW, wMax, 20, 4, 4);
+    TEST_FIELD(HELPWININFOW, 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);
+    TEST_FIELD(HIGHCONTRASTA, cbSize, 0, 4, 4);
+    TEST_FIELD(HIGHCONTRASTA, dwFlags, 4, 4, 4);
+    TEST_FIELD(HIGHCONTRASTA, 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);
+    TEST_FIELD(HIGHCONTRASTW, cbSize, 0, 4, 4);
+    TEST_FIELD(HIGHCONTRASTW, dwFlags, 4, 4, 4);
+    TEST_FIELD(HIGHCONTRASTW, lpszDefaultScheme, 8, 4, 4);
 }
 
 static void test_pack_HOOKPROC(void)
@@ -519,61 +519,61 @@ static void test_pack_ICONINFO(void)
 {
     /* ICONINFO (pack 4) */
     TEST_TYPE(ICONINFO, 20, 4);
-    TEST_FIELD(ICONINFO, BOOL, fIcon, 0, 4, 4);
-    TEST_FIELD(ICONINFO, DWORD, xHotspot, 4, 4, 4);
-    TEST_FIELD(ICONINFO, DWORD, yHotspot, 8, 4, 4);
-    TEST_FIELD(ICONINFO, HBITMAP, hbmMask, 12, 4, 4);
-    TEST_FIELD(ICONINFO, HBITMAP, hbmColor, 16, 4, 4);
+    TEST_FIELD(ICONINFO, fIcon, 0, 4, 4);
+    TEST_FIELD(ICONINFO, xHotspot, 4, 4, 4);
+    TEST_FIELD(ICONINFO, yHotspot, 8, 4, 4);
+    TEST_FIELD(ICONINFO, hbmMask, 12, 4, 4);
+    TEST_FIELD(ICONINFO, 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);
-    TEST_FIELD(ICONMETRICSA, int, iHorzSpacing, 4, 4, 4);
-    TEST_FIELD(ICONMETRICSA, int, iVertSpacing, 8, 4, 4);
-    TEST_FIELD(ICONMETRICSA, int, iTitleWrap, 12, 4, 4);
-    TEST_FIELD(ICONMETRICSA, LOGFONTA, lfFont, 16, 60, 4);
+    TEST_FIELD(ICONMETRICSA, cbSize, 0, 4, 4);
+    TEST_FIELD(ICONMETRICSA, iHorzSpacing, 4, 4, 4);
+    TEST_FIELD(ICONMETRICSA, iVertSpacing, 8, 4, 4);
+    TEST_FIELD(ICONMETRICSA, iTitleWrap, 12, 4, 4);
+    TEST_FIELD(ICONMETRICSA, 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);
-    TEST_FIELD(ICONMETRICSW, int, iHorzSpacing, 4, 4, 4);
-    TEST_FIELD(ICONMETRICSW, int, iVertSpacing, 8, 4, 4);
-    TEST_FIELD(ICONMETRICSW, int, iTitleWrap, 12, 4, 4);
-    TEST_FIELD(ICONMETRICSW, LOGFONTW, lfFont, 16, 92, 4);
+    TEST_FIELD(ICONMETRICSW, cbSize, 0, 4, 4);
+    TEST_FIELD(ICONMETRICSW, iHorzSpacing, 4, 4, 4);
+    TEST_FIELD(ICONMETRICSW, iVertSpacing, 8, 4, 4);
+    TEST_FIELD(ICONMETRICSW, iTitleWrap, 12, 4, 4);
+    TEST_FIELD(ICONMETRICSW, lfFont, 16, 92, 4);
 }
 
 static void test_pack_INPUT(void)
 {
     /* INPUT (pack 4) */
-    TEST_FIELD(INPUT, DWORD, type, 0, 4, 4);
+    TEST_FIELD(INPUT, 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);
-    TEST_FIELD(KBDLLHOOKSTRUCT, DWORD, scanCode, 4, 4, 4);
-    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);
+    TEST_FIELD(KBDLLHOOKSTRUCT, vkCode, 0, 4, 4);
+    TEST_FIELD(KBDLLHOOKSTRUCT, scanCode, 4, 4, 4);
+    TEST_FIELD(KBDLLHOOKSTRUCT, flags, 8, 4, 4);
+    TEST_FIELD(KBDLLHOOKSTRUCT, time, 12, 4, 4);
+    TEST_FIELD(KBDLLHOOKSTRUCT, 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);
-    TEST_FIELD(KEYBDINPUT, WORD, wScan, 2, 2, 2);
-    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);
+    TEST_FIELD(KEYBDINPUT, wVk, 0, 2, 2);
+    TEST_FIELD(KEYBDINPUT, wScan, 2, 2, 2);
+    TEST_FIELD(KEYBDINPUT, dwFlags, 4, 4, 4);
+    TEST_FIELD(KEYBDINPUT, time, 8, 4, 4);
+    TEST_FIELD(KEYBDINPUT, dwExtraInfo, 12, 4, 4);
 }
 
 static void test_pack_LPACCESSTIMEOUT(void)
@@ -1181,139 +1181,139 @@ static void test_pack_MDICREATESTRUCTA(void)
 {
     /* MDICREATESTRUCTA (pack 4) */
     TEST_TYPE(MDICREATESTRUCTA, 36, 4);
-    TEST_FIELD(MDICREATESTRUCTA, LPCSTR, szClass, 0, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, LPCSTR, szTitle, 4, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, HINSTANCE, hOwner, 8, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, INT, x, 12, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, INT, y, 16, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, INT, cx, 20, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, INT, cy, 24, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, DWORD, style, 28, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTA, LPARAM, lParam, 32, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, szClass, 0, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, szTitle, 4, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, hOwner, 8, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, x, 12, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, y, 16, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, cx, 20, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, cy, 24, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, style, 28, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTA, 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);
-    TEST_FIELD(MDICREATESTRUCTW, LPCWSTR, szTitle, 4, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, HINSTANCE, hOwner, 8, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, INT, x, 12, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, INT, y, 16, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, INT, cx, 20, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, INT, cy, 24, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, DWORD, style, 28, 4, 4);
-    TEST_FIELD(MDICREATESTRUCTW, LPARAM, lParam, 32, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, szClass, 0, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, szTitle, 4, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, hOwner, 8, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, x, 12, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, y, 16, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, cx, 20, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, cy, 24, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, style, 28, 4, 4);
+    TEST_FIELD(MDICREATESTRUCTW, 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);
+    TEST_FIELD(MDINEXTMENU, hmenuIn, 0, 4, 4);
+    TEST_FIELD(MDINEXTMENU, hmenuNext, 4, 4, 4);
+    TEST_FIELD(MDINEXTMENU, 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);
-    TEST_FIELD(MEASUREITEMSTRUCT, UINT, CtlID, 4, 4, 4);
-    TEST_FIELD(MEASUREITEMSTRUCT, UINT, itemID, 8, 4, 4);
-    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);
+    TEST_FIELD(MEASUREITEMSTRUCT, CtlType, 0, 4, 4);
+    TEST_FIELD(MEASUREITEMSTRUCT, CtlID, 4, 4, 4);
+    TEST_FIELD(MEASUREITEMSTRUCT, itemID, 8, 4, 4);
+    TEST_FIELD(MEASUREITEMSTRUCT, itemWidth, 12, 4, 4);
+    TEST_FIELD(MEASUREITEMSTRUCT, itemHeight, 16, 4, 4);
+    TEST_FIELD(MEASUREITEMSTRUCT, 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);
-    TEST_FIELD(MENUINFO, DWORD, fMask, 4, 4, 4);
-    TEST_FIELD(MENUINFO, DWORD, dwStyle, 8, 4, 4);
-    TEST_FIELD(MENUINFO, UINT, cyMax, 12, 4, 4);
-    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);
+    TEST_FIELD(MENUINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(MENUINFO, fMask, 4, 4, 4);
+    TEST_FIELD(MENUINFO, dwStyle, 8, 4, 4);
+    TEST_FIELD(MENUINFO, cyMax, 12, 4, 4);
+    TEST_FIELD(MENUINFO, hbrBack, 16, 4, 4);
+    TEST_FIELD(MENUINFO, dwContextHelpID, 20, 4, 4);
+    TEST_FIELD(MENUINFO, 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);
-    TEST_FIELD(MENUITEMINFOA, UINT, fState, 12, 4, 4);
-    TEST_FIELD(MENUITEMINFOA, UINT, wID, 16, 4, 4);
-    TEST_FIELD(MENUITEMINFOA, HMENU, hSubMenu, 20, 4, 4);
-    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);
+    TEST_FIELD(MENUITEMINFOA, cbSize, 0, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, fMask, 4, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, fType, 8, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, fState, 12, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, wID, 16, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, hSubMenu, 20, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, hbmpChecked, 24, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, hbmpUnchecked, 28, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, dwItemData, 32, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, dwTypeData, 36, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, cch, 40, 4, 4);
+    TEST_FIELD(MENUITEMINFOA, 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);
-    TEST_FIELD(MENUITEMINFOW, UINT, fMask, 4, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, UINT, fType, 8, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, UINT, fState, 12, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, UINT, wID, 16, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, HMENU, hSubMenu, 20, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, HBITMAP, hbmpChecked, 24, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, HBITMAP, hbmpUnchecked, 28, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, ULONG_PTR, dwItemData, 32, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, LPWSTR, dwTypeData, 36, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, UINT, cch, 40, 4, 4);
-    TEST_FIELD(MENUITEMINFOW, HBITMAP, hbmpItem, 44, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, cbSize, 0, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, fMask, 4, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, fType, 8, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, fState, 12, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, wID, 16, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, hSubMenu, 20, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, hbmpChecked, 24, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, hbmpUnchecked, 28, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, dwItemData, 32, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, dwTypeData, 36, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, cch, 40, 4, 4);
+    TEST_FIELD(MENUITEMINFOW, 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);
+    TEST_FIELD(MENUITEMTEMPLATE, mtOption, 0, 2, 2);
+    TEST_FIELD(MENUITEMTEMPLATE, mtID, 2, 2, 2);
+    TEST_FIELD(MENUITEMTEMPLATE, 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);
+    TEST_FIELD(MENUITEMTEMPLATEHEADER, versionNumber, 0, 2, 2);
+    TEST_FIELD(MENUITEMTEMPLATEHEADER, offset, 2, 2, 2);
 }
 
 static void test_pack_MINIMIZEDMETRICS(void)
 {
     /* MINIMIZEDMETRICS (pack 4) */
     TEST_TYPE(MINIMIZEDMETRICS, 20, 4);
-    TEST_FIELD(MINIMIZEDMETRICS, UINT, cbSize, 0, 4, 4);
-    TEST_FIELD(MINIMIZEDMETRICS, int, iWidth, 4, 4, 4);
-    TEST_FIELD(MINIMIZEDMETRICS, int, iHorzGap, 8, 4, 4);
-    TEST_FIELD(MINIMIZEDMETRICS, int, iVertGap, 12, 4, 4);
-    TEST_FIELD(MINIMIZEDMETRICS, int, iArrange, 16, 4, 4);
+    TEST_FIELD(MINIMIZEDMETRICS, cbSize, 0, 4, 4);
+    TEST_FIELD(MINIMIZEDMETRICS, iWidth, 4, 4, 4);
+    TEST_FIELD(MINIMIZEDMETRICS, iHorzGap, 8, 4, 4);
+    TEST_FIELD(MINIMIZEDMETRICS, iVertGap, 12, 4, 4);
+    TEST_FIELD(MINIMIZEDMETRICS, 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);
-    TEST_FIELD(MINMAXINFO, POINT, ptMaxSize, 8, 8, 4);
-    TEST_FIELD(MINMAXINFO, POINT, ptMaxPosition, 16, 8, 4);
-    TEST_FIELD(MINMAXINFO, POINT, ptMinTrackSize, 24, 8, 4);
-    TEST_FIELD(MINMAXINFO, POINT, ptMaxTrackSize, 32, 8, 4);
+    TEST_FIELD(MINMAXINFO, ptReserved, 0, 8, 4);
+    TEST_FIELD(MINMAXINFO, ptMaxSize, 8, 8, 4);
+    TEST_FIELD(MINMAXINFO, ptMaxPosition, 16, 8, 4);
+    TEST_FIELD(MINMAXINFO, ptMinTrackSize, 24, 8, 4);
+    TEST_FIELD(MINMAXINFO, ptMaxTrackSize, 32, 8, 4);
 }
 
 static void test_pack_MONITORENUMPROC(void)
@@ -1326,79 +1326,79 @@ 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);
+    TEST_FIELD(MONITORINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(MONITORINFO, rcMonitor, 4, 16, 4);
+    TEST_FIELD(MONITORINFO, rcWork, 20, 16, 4);
+    TEST_FIELD(MONITORINFO, dwFlags, 36, 4, 4);
 }
 
 static void test_pack_MONITORINFOEXA(void)
 {
     /* MONITORINFOEXA (pack 4) */
     TEST_TYPE(MONITORINFOEXA, 72, 4);
-    TEST_FIELD(MONITORINFOEXA, DWORD, cbSize, 0, 4, 4);
-    TEST_FIELD(MONITORINFOEXA, RECT, rcMonitor, 4, 16, 4);
-    TEST_FIELD(MONITORINFOEXA, RECT, rcWork, 20, 16, 4);
-    TEST_FIELD(MONITORINFOEXA, DWORD, dwFlags, 36, 4, 4);
-    TEST_FIELD(MONITORINFOEXA, CHAR[CCHDEVICENAME], szDevice, 40, 32, 1);
+    TEST_FIELD(MONITORINFOEXA, cbSize, 0, 4, 4);
+    TEST_FIELD(MONITORINFOEXA, rcMonitor, 4, 16, 4);
+    TEST_FIELD(MONITORINFOEXA, rcWork, 20, 16, 4);
+    TEST_FIELD(MONITORINFOEXA, dwFlags, 36, 4, 4);
+    TEST_FIELD(MONITORINFOEXA, szDevice, 40, 32, 1);
 }
 
 static void test_pack_MONITORINFOEXW(void)
 {
     /* MONITORINFOEXW (pack 4) */
     TEST_TYPE(MONITORINFOEXW, 104, 4);
-    TEST_FIELD(MONITORINFOEXW, DWORD, cbSize, 0, 4, 4);
-    TEST_FIELD(MONITORINFOEXW, RECT, rcMonitor, 4, 16, 4);
-    TEST_FIELD(MONITORINFOEXW, RECT, rcWork, 20, 16, 4);
-    TEST_FIELD(MONITORINFOEXW, DWORD, dwFlags, 36, 4, 4);
-    TEST_FIELD(MONITORINFOEXW, WCHAR[CCHDEVICENAME], szDevice, 40, 64, 2);
+    TEST_FIELD(MONITORINFOEXW, cbSize, 0, 4, 4);
+    TEST_FIELD(MONITORINFOEXW, rcMonitor, 4, 16, 4);
+    TEST_FIELD(MONITORINFOEXW, rcWork, 20, 16, 4);
+    TEST_FIELD(MONITORINFOEXW, dwFlags, 36, 4, 4);
+    TEST_FIELD(MONITORINFOEXW, 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);
+    TEST_FIELD(MOUSEHOOKSTRUCT, pt, 0, 8, 4);
+    TEST_FIELD(MOUSEHOOKSTRUCT, hwnd, 8, 4, 4);
+    TEST_FIELD(MOUSEHOOKSTRUCT, wHitTestCode, 12, 4, 4);
+    TEST_FIELD(MOUSEHOOKSTRUCT, 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);
-    TEST_FIELD(MOUSEINPUT, LONG, dy, 4, 4, 4);
-    TEST_FIELD(MOUSEINPUT, DWORD, mouseData, 8, 4, 4);
-    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);
+    TEST_FIELD(MOUSEINPUT, dx, 0, 4, 4);
+    TEST_FIELD(MOUSEINPUT, dy, 4, 4, 4);
+    TEST_FIELD(MOUSEINPUT, mouseData, 8, 4, 4);
+    TEST_FIELD(MOUSEINPUT, dwFlags, 12, 4, 4);
+    TEST_FIELD(MOUSEINPUT, time, 16, 4, 4);
+    TEST_FIELD(MOUSEINPUT, 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);
-    TEST_FIELD(MOUSEKEYS, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(MOUSEKEYS, DWORD, iMaxSpeed, 8, 4, 4);
-    TEST_FIELD(MOUSEKEYS, DWORD, iTimeToMaxSpeed, 12, 4, 4);
-    TEST_FIELD(MOUSEKEYS, DWORD, iCtrlSpeed, 16, 4, 4);
-    TEST_FIELD(MOUSEKEYS, DWORD, dwReserved1, 20, 4, 4);
-    TEST_FIELD(MOUSEKEYS, DWORD, dwReserved2, 24, 4, 4);
+    TEST_FIELD(MOUSEKEYS, cbSize, 0, 4, 4);
+    TEST_FIELD(MOUSEKEYS, dwFlags, 4, 4, 4);
+    TEST_FIELD(MOUSEKEYS, iMaxSpeed, 8, 4, 4);
+    TEST_FIELD(MOUSEKEYS, iTimeToMaxSpeed, 12, 4, 4);
+    TEST_FIELD(MOUSEKEYS, iCtrlSpeed, 16, 4, 4);
+    TEST_FIELD(MOUSEKEYS, dwReserved1, 20, 4, 4);
+    TEST_FIELD(MOUSEKEYS, 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);
-    TEST_FIELD(MSG, UINT, message, 4, 4, 4);
-    TEST_FIELD(MSG, WPARAM, wParam, 8, 4, 4);
-    TEST_FIELD(MSG, LPARAM, lParam, 12, 4, 4);
-    TEST_FIELD(MSG, DWORD, time, 16, 4, 4);
-    TEST_FIELD(MSG, POINT, pt, 20, 8, 4);
+    TEST_FIELD(MSG, hwnd, 0, 4, 4);
+    TEST_FIELD(MSG, message, 4, 4, 4);
+    TEST_FIELD(MSG, wParam, 8, 4, 4);
+    TEST_FIELD(MSG, lParam, 12, 4, 4);
+    TEST_FIELD(MSG, time, 16, 4, 4);
+    TEST_FIELD(MSG, pt, 20, 8, 4);
 }
 
 static void test_pack_MSGBOXCALLBACK(void)
@@ -1411,61 +1411,61 @@ static void test_pack_MSGBOXPARAMSA(void)
 {
     /* MSGBOXPARAMSA (pack 4) */
     TEST_TYPE(MSGBOXPARAMSA, 40, 4);
-    TEST_FIELD(MSGBOXPARAMSA, UINT, cbSize, 0, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSA, HWND, hwndOwner, 4, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSA, HINSTANCE, hInstance, 8, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSA, LPCSTR, lpszText, 12, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSA, LPCSTR, lpszCaption, 16, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSA, DWORD, dwStyle, 20, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSA, LPCSTR, lpszIcon, 24, 4, 4);
-    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);
+    TEST_FIELD(MSGBOXPARAMSA, cbSize, 0, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, hwndOwner, 4, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, hInstance, 8, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, lpszText, 12, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, lpszCaption, 16, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, dwStyle, 20, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, lpszIcon, 24, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, dwContextHelpId, 28, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, lpfnMsgBoxCallback, 32, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSA, 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);
-    TEST_FIELD(MSGBOXPARAMSW, HWND, hwndOwner, 4, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSW, HINSTANCE, hInstance, 8, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSW, LPCWSTR, lpszText, 12, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSW, LPCWSTR, lpszCaption, 16, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSW, DWORD, dwStyle, 20, 4, 4);
-    TEST_FIELD(MSGBOXPARAMSW, LPCWSTR, lpszIcon, 24, 4, 4);
-    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);
+    TEST_FIELD(MSGBOXPARAMSW, cbSize, 0, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, hwndOwner, 4, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, hInstance, 8, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, lpszText, 12, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, lpszCaption, 16, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, dwStyle, 20, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, lpszIcon, 24, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, dwContextHelpId, 28, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, lpfnMsgBoxCallback, 32, 4, 4);
+    TEST_FIELD(MSGBOXPARAMSW, 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);
-    TEST_FIELD(MSLLHOOKSTRUCT, DWORD, mouseData, 8, 4, 4);
-    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);
+    TEST_FIELD(MSLLHOOKSTRUCT, pt, 0, 8, 4);
+    TEST_FIELD(MSLLHOOKSTRUCT, mouseData, 8, 4, 4);
+    TEST_FIELD(MSLLHOOKSTRUCT, flags, 12, 4, 4);
+    TEST_FIELD(MSLLHOOKSTRUCT, time, 16, 4, 4);
+    TEST_FIELD(MSLLHOOKSTRUCT, 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);
+    TEST_FIELD(MULTIKEYHELPA, mkSize, 0, 4, 4);
+    TEST_FIELD(MULTIKEYHELPA, mkKeylist, 4, 1, 1);
+    TEST_FIELD(MULTIKEYHELPA, 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);
+    TEST_FIELD(MULTIKEYHELPW, mkSize, 0, 4, 4);
+    TEST_FIELD(MULTIKEYHELPW, mkKeylist, 4, 2, 2);
+    TEST_FIELD(MULTIKEYHELPW, szKeyphrase, 6, 2, 2);
 }
 
 static void test_pack_NAMEENUMPROCA(void)
@@ -1484,71 +1484,71 @@ 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);
+    TEST_FIELD(NCCALCSIZE_PARAMS, rgrc, 0, 48, 4);
+    TEST_FIELD(NCCALCSIZE_PARAMS, 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);
+    TEST_FIELD(NMHDR, hwndFrom, 0, 4, 4);
+    TEST_FIELD(NMHDR, idFrom, 4, 4, 4);
+    TEST_FIELD(NMHDR, 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);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iBorderWidth, 4, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iScrollWidth, 8, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iScrollHeight, 12, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iCaptionWidth, 16, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iCaptionHeight, 20, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfCaptionFont, 24, 60, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iSmCaptionWidth, 84, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iSmCaptionHeight, 88, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfSmCaptionFont, 92, 60, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iMenuWidth, 152, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, INT, iMenuHeight, 156, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfMenuFont, 160, 60, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfStatusFont, 220, 60, 4);
-    TEST_FIELD(NONCLIENTMETRICSA, LOGFONTA, lfMessageFont, 280, 60, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, cbSize, 0, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iBorderWidth, 4, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iScrollWidth, 8, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iScrollHeight, 12, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iCaptionWidth, 16, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iCaptionHeight, 20, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, lfCaptionFont, 24, 60, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iSmCaptionWidth, 84, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iSmCaptionHeight, 88, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, lfSmCaptionFont, 92, 60, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iMenuWidth, 152, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, iMenuHeight, 156, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, lfMenuFont, 160, 60, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, lfStatusFont, 220, 60, 4);
+    TEST_FIELD(NONCLIENTMETRICSA, 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);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iBorderWidth, 4, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iScrollWidth, 8, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iScrollHeight, 12, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iCaptionWidth, 16, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iCaptionHeight, 20, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfCaptionFont, 24, 92, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iSmCaptionWidth, 116, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iSmCaptionHeight, 120, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfSmCaptionFont, 124, 92, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iMenuWidth, 216, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, INT, iMenuHeight, 220, 4, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfMenuFont, 224, 92, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfStatusFont, 316, 92, 4);
-    TEST_FIELD(NONCLIENTMETRICSW, LOGFONTW, lfMessageFont, 408, 92, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, cbSize, 0, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iBorderWidth, 4, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iScrollWidth, 8, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iScrollHeight, 12, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iCaptionWidth, 16, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iCaptionHeight, 20, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, lfCaptionFont, 24, 92, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iSmCaptionWidth, 116, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iSmCaptionHeight, 120, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, lfSmCaptionFont, 124, 92, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iMenuWidth, 216, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, iMenuHeight, 220, 4, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, lfMenuFont, 224, 92, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, lfStatusFont, 316, 92, 4);
+    TEST_FIELD(NONCLIENTMETRICSW, 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);
-    TEST_FIELD(PAINTSTRUCT, BOOL, fErase, 4, 4, 4);
-    TEST_FIELD(PAINTSTRUCT, RECT, rcPaint, 8, 16, 4);
-    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);
+    TEST_FIELD(PAINTSTRUCT, hdc, 0, 4, 4);
+    TEST_FIELD(PAINTSTRUCT, fErase, 4, 4, 4);
+    TEST_FIELD(PAINTSTRUCT, rcPaint, 8, 16, 4);
+    TEST_FIELD(PAINTSTRUCT, fRestore, 24, 4, 4);
+    TEST_FIELD(PAINTSTRUCT, fIncUpdate, 28, 4, 4);
+    TEST_FIELD(PAINTSTRUCT, rgbReserved, 32, 32, 1);
 }
 
 static void test_pack_PCOMBOBOXINFO(void)
@@ -1935,13 +1935,13 @@ static void test_pack_SCROLLINFO(void)
 {
     /* SCROLLINFO (pack 4) */
     TEST_TYPE(SCROLLINFO, 28, 4);
-    TEST_FIELD(SCROLLINFO, UINT, cbSize, 0, 4, 4);
-    TEST_FIELD(SCROLLINFO, UINT, fMask, 4, 4, 4);
-    TEST_FIELD(SCROLLINFO, INT, nMin, 8, 4, 4);
-    TEST_FIELD(SCROLLINFO, INT, nMax, 12, 4, 4);
-    TEST_FIELD(SCROLLINFO, UINT, nPage, 16, 4, 4);
-    TEST_FIELD(SCROLLINFO, INT, nPos, 20, 4, 4);
-    TEST_FIELD(SCROLLINFO, INT, nTrackPos, 24, 4, 4);
+    TEST_FIELD(SCROLLINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(SCROLLINFO, fMask, 4, 4, 4);
+    TEST_FIELD(SCROLLINFO, nMin, 8, 4, 4);
+    TEST_FIELD(SCROLLINFO, nMax, 12, 4, 4);
+    TEST_FIELD(SCROLLINFO, nPage, 16, 4, 4);
+    TEST_FIELD(SCROLLINFO, nPos, 20, 4, 4);
+    TEST_FIELD(SCROLLINFO, nTrackPos, 24, 4, 4);
 }
 
 static void test_pack_SENDASYNCPROC(void)
@@ -1954,78 +1954,78 @@ 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);
+    TEST_FIELD(SERIALKEYSA, cbSize, 0, 4, 4);
+    TEST_FIELD(SERIALKEYSA, dwFlags, 4, 4, 4);
+    TEST_FIELD(SERIALKEYSA, lpszActivePort, 8, 4, 4);
+    TEST_FIELD(SERIALKEYSA, lpszPort, 12, 4, 4);
+    TEST_FIELD(SERIALKEYSA, iBaudRate, 16, 4, 4);
+    TEST_FIELD(SERIALKEYSA, iPortState, 20, 4, 4);
+    TEST_FIELD(SERIALKEYSA, 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);
-    TEST_FIELD(SERIALKEYSW, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(SERIALKEYSW, LPWSTR, lpszActivePort, 8, 4, 4);
-    TEST_FIELD(SERIALKEYSW, LPWSTR, lpszPort, 12, 4, 4);
-    TEST_FIELD(SERIALKEYSW, UINT, iBaudRate, 16, 4, 4);
-    TEST_FIELD(SERIALKEYSW, UINT, iPortState, 20, 4, 4);
-    TEST_FIELD(SERIALKEYSW, UINT, iActive, 24, 4, 4);
+    TEST_FIELD(SERIALKEYSW, cbSize, 0, 4, 4);
+    TEST_FIELD(SERIALKEYSW, dwFlags, 4, 4, 4);
+    TEST_FIELD(SERIALKEYSW, lpszActivePort, 8, 4, 4);
+    TEST_FIELD(SERIALKEYSW, lpszPort, 12, 4, 4);
+    TEST_FIELD(SERIALKEYSW, iBaudRate, 16, 4, 4);
+    TEST_FIELD(SERIALKEYSW, iPortState, 20, 4, 4);
+    TEST_FIELD(SERIALKEYSW, 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);
-    TEST_FIELD(SOUNDSENTRYA, DWORD, iFSTextEffectMSec, 12, 4, 4);
-    TEST_FIELD(SOUNDSENTRYA, DWORD, iFSTextEffectColorBits, 16, 4, 4);
-    TEST_FIELD(SOUNDSENTRYA, DWORD, iFSGrafEffect, 20, 4, 4);
-    TEST_FIELD(SOUNDSENTRYA, DWORD, iFSGrafEffectMSec, 24, 4, 4);
-    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);
+    TEST_FIELD(SOUNDSENTRYA, cbSize, 0, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, dwFlags, 4, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iFSTextEffect, 8, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iFSTextEffectMSec, 12, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iFSTextEffectColorBits, 16, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iFSGrafEffect, 20, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iFSGrafEffectMSec, 24, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iFSGrafEffectColor, 28, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iWindowsEffect, 32, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, iWindowsEffectMSec, 36, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, lpszWindowsEffectDLL, 40, 4, 4);
+    TEST_FIELD(SOUNDSENTRYA, 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);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, dwFlags, 4, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iFSTextEffect, 8, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iFSTextEffectMSec, 12, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iFSTextEffectColorBits, 16, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iFSGrafEffect, 20, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iFSGrafEffectMSec, 24, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iFSGrafEffectColor, 28, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iWindowsEffect, 32, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iWindowsEffectMSec, 36, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, LPWSTR, lpszWindowsEffectDLL, 40, 4, 4);
-    TEST_FIELD(SOUNDSENTRYW, DWORD, iWindowsEffectOrdinal, 44, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, cbSize, 0, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, dwFlags, 4, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iFSTextEffect, 8, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iFSTextEffectMSec, 12, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iFSTextEffectColorBits, 16, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iFSGrafEffect, 20, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iFSGrafEffectMSec, 24, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iFSGrafEffectColor, 28, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iWindowsEffect, 32, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, iWindowsEffectMSec, 36, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, lpszWindowsEffectDLL, 40, 4, 4);
+    TEST_FIELD(SOUNDSENTRYW, 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);
+    TEST_FIELD(STICKYKEYS, cbSize, 0, 4, 4);
+    TEST_FIELD(STICKYKEYS, 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);
+    TEST_FIELD(STYLESTRUCT, styleOld, 0, 4, 4);
+    TEST_FIELD(STYLESTRUCT, styleNew, 4, 4, 4);
 }
 
 static void test_pack_TIMERPROC(void)
@@ -2038,85 +2038,85 @@ static void test_pack_TITLEBARINFO(void)
 {
     /* TITLEBARINFO (pack 4) */
     TEST_TYPE(TITLEBARINFO, 44, 4);
-    TEST_FIELD(TITLEBARINFO, DWORD, cbSize, 0, 4, 4);
-    TEST_FIELD(TITLEBARINFO, RECT, rcTitleBar, 4, 16, 4);
-    TEST_FIELD(TITLEBARINFO, DWORD[CCHILDREN_TITLEBAR+1], rgstate, 20, 24, 4);
+    TEST_FIELD(TITLEBARINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(TITLEBARINFO, rcTitleBar, 4, 16, 4);
+    TEST_FIELD(TITLEBARINFO, rgstate, 20, 24, 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);
+    TEST_FIELD(TOGGLEKEYS, cbSize, 0, 4, 4);
+    TEST_FIELD(TOGGLEKEYS, 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);
+    TEST_FIELD(TPMPARAMS, cbSize, 0, 4, 4);
+    TEST_FIELD(TPMPARAMS, 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);
+    TEST_FIELD(TRACKMOUSEEVENT, cbSize, 0, 4, 4);
+    TEST_FIELD(TRACKMOUSEEVENT, dwFlags, 4, 4, 4);
+    TEST_FIELD(TRACKMOUSEEVENT, hwndTrack, 8, 4, 4);
+    TEST_FIELD(TRACKMOUSEEVENT, dwHoverTime, 12, 4, 4);
 }
 
 static void test_pack_USEROBJECTFLAGS(void)
 {
     /* USEROBJECTFLAGS (pack 4) */
     TEST_TYPE(USEROBJECTFLAGS, 12, 4);
-    TEST_FIELD(USEROBJECTFLAGS, BOOL, fInherit, 0, 4, 4);
-    TEST_FIELD(USEROBJECTFLAGS, BOOL, fReserved, 4, 4, 4);
-    TEST_FIELD(USEROBJECTFLAGS, DWORD, dwFlags, 8, 4, 4);
+    TEST_FIELD(USEROBJECTFLAGS, fInherit, 0, 4, 4);
+    TEST_FIELD(USEROBJECTFLAGS, fReserved, 4, 4, 4);
+    TEST_FIELD(USEROBJECTFLAGS, dwFlags, 8, 4, 4);
 }
 
 static void test_pack_WINDOWINFO(void)
 {
     /* WINDOWINFO (pack 4) */
     TEST_TYPE(WINDOWINFO, 60, 4);
-    TEST_FIELD(WINDOWINFO, DWORD, cbSize, 0, 4, 4);
-    TEST_FIELD(WINDOWINFO, RECT, rcWindow, 4, 16, 4);
-    TEST_FIELD(WINDOWINFO, RECT, rcClient, 20, 16, 4);
-    TEST_FIELD(WINDOWINFO, DWORD, dwStyle, 36, 4, 4);
-    TEST_FIELD(WINDOWINFO, DWORD, dwExStyle, 40, 4, 4);
-    TEST_FIELD(WINDOWINFO, DWORD, dwWindowStatus, 44, 4, 4);
-    TEST_FIELD(WINDOWINFO, UINT, cxWindowBorders, 48, 4, 4);
-    TEST_FIELD(WINDOWINFO, UINT, cyWindowBorders, 52, 4, 4);
-    TEST_FIELD(WINDOWINFO, ATOM, atomWindowType, 56, 2, 2);
-    TEST_FIELD(WINDOWINFO, WORD, wCreatorVersion, 58, 2, 2);
+    TEST_FIELD(WINDOWINFO, cbSize, 0, 4, 4);
+    TEST_FIELD(WINDOWINFO, rcWindow, 4, 16, 4);
+    TEST_FIELD(WINDOWINFO, rcClient, 20, 16, 4);
+    TEST_FIELD(WINDOWINFO, dwStyle, 36, 4, 4);
+    TEST_FIELD(WINDOWINFO, dwExStyle, 40, 4, 4);
+    TEST_FIELD(WINDOWINFO, dwWindowStatus, 44, 4, 4);
+    TEST_FIELD(WINDOWINFO, cxWindowBorders, 48, 4, 4);
+    TEST_FIELD(WINDOWINFO, cyWindowBorders, 52, 4, 4);
+    TEST_FIELD(WINDOWINFO, atomWindowType, 56, 2, 2);
+    TEST_FIELD(WINDOWINFO, wCreatorVersion, 58, 2, 2);
 }
 
 static void test_pack_WINDOWPLACEMENT(void)
 {
     /* WINDOWPLACEMENT (pack 4) */
     TEST_TYPE(WINDOWPLACEMENT, 44, 4);
-    TEST_FIELD(WINDOWPLACEMENT, UINT, length, 0, 4, 4);
-    TEST_FIELD(WINDOWPLACEMENT, UINT, flags, 4, 4, 4);
-    TEST_FIELD(WINDOWPLACEMENT, UINT, showCmd, 8, 4, 4);
-    TEST_FIELD(WINDOWPLACEMENT, POINT, ptMinPosition, 12, 8, 4);
-    TEST_FIELD(WINDOWPLACEMENT, POINT, ptMaxPosition, 20, 8, 4);
-    TEST_FIELD(WINDOWPLACEMENT, RECT, rcNormalPosition, 28, 16, 4);
+    TEST_FIELD(WINDOWPLACEMENT, length, 0, 4, 4);
+    TEST_FIELD(WINDOWPLACEMENT, flags, 4, 4, 4);
+    TEST_FIELD(WINDOWPLACEMENT, showCmd, 8, 4, 4);
+    TEST_FIELD(WINDOWPLACEMENT, ptMinPosition, 12, 8, 4);
+    TEST_FIELD(WINDOWPLACEMENT, ptMaxPosition, 20, 8, 4);
+    TEST_FIELD(WINDOWPLACEMENT, rcNormalPosition, 28, 16, 4);
 }
 
 static void test_pack_WINDOWPOS(void)
 {
     /* WINDOWPOS (pack 4) */
     TEST_TYPE(WINDOWPOS, 28, 4);
-    TEST_FIELD(WINDOWPOS, HWND, hwnd, 0, 4, 4);
-    TEST_FIELD(WINDOWPOS, HWND, hwndInsertAfter, 4, 4, 4);
-    TEST_FIELD(WINDOWPOS, INT, x, 8, 4, 4);
-    TEST_FIELD(WINDOWPOS, INT, y, 12, 4, 4);
-    TEST_FIELD(WINDOWPOS, INT, cx, 16, 4, 4);
-    TEST_FIELD(WINDOWPOS, INT, cy, 20, 4, 4);
-    TEST_FIELD(WINDOWPOS, UINT, flags, 24, 4, 4);
+    TEST_FIELD(WINDOWPOS, hwnd, 0, 4, 4);
+    TEST_FIELD(WINDOWPOS, hwndInsertAfter, 4, 4, 4);
+    TEST_FIELD(WINDOWPOS, x, 8, 4, 4);
+    TEST_FIELD(WINDOWPOS, y, 12, 4, 4);
+    TEST_FIELD(WINDOWPOS, cx, 16, 4, 4);
+    TEST_FIELD(WINDOWPOS, cy, 20, 4, 4);
+    TEST_FIELD(WINDOWPOS, flags, 24, 4, 4);
 }
 
 static void test_pack_WINEVENTPROC(void)
@@ -2141,68 +2141,68 @@ static void test_pack_WNDCLASSA(void)
 {
     /* WNDCLASSA (pack 4) */
     TEST_TYPE(WNDCLASSA, 40, 4);
-    TEST_FIELD(WNDCLASSA, UINT, style, 0, 4, 4);
-    TEST_FIELD(WNDCLASSA, WNDPROC, lpfnWndProc, 4, 4, 4);
-    TEST_FIELD(WNDCLASSA, INT, cbClsExtra, 8, 4, 4);
-    TEST_FIELD(WNDCLASSA, INT, cbWndExtra, 12, 4, 4);
-    TEST_FIELD(WNDCLASSA, HINSTANCE, hInstance, 16, 4, 4);
-    TEST_FIELD(WNDCLASSA, HICON, hIcon, 20, 4, 4);
-    TEST_FIELD(WNDCLASSA, HCURSOR, hCursor, 24, 4, 4);
-    TEST_FIELD(WNDCLASSA, HBRUSH, hbrBackground, 28, 4, 4);
-    TEST_FIELD(WNDCLASSA, LPCSTR, lpszMenuName, 32, 4, 4);
-    TEST_FIELD(WNDCLASSA, LPCSTR, lpszClassName, 36, 4, 4);
+    TEST_FIELD(WNDCLASSA, style, 0, 4, 4);
+    TEST_FIELD(WNDCLASSA, lpfnWndProc, 4, 4, 4);
+    TEST_FIELD(WNDCLASSA, cbClsExtra, 8, 4, 4);
+    TEST_FIELD(WNDCLASSA, cbWndExtra, 12, 4, 4);
+    TEST_FIELD(WNDCLASSA, hInstance, 16, 4, 4);
+    TEST_FIELD(WNDCLASSA, hIcon, 20, 4, 4);
+    TEST_FIELD(WNDCLASSA, hCursor, 24, 4, 4);
+    TEST_FIELD(WNDCLASSA, hbrBackground, 28, 4, 4);
+    TEST_FIELD(WNDCLASSA, lpszMenuName, 32, 4, 4);
+    TEST_FIELD(WNDCLASSA, 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);
-    TEST_FIELD(WNDCLASSEXA, UINT, style, 4, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, WNDPROC, lpfnWndProc, 8, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, INT, cbClsExtra, 12, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, INT, cbWndExtra, 16, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, HINSTANCE, hInstance, 20, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, HICON, hIcon, 24, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, HCURSOR, hCursor, 28, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, HBRUSH, hbrBackground, 32, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, LPCSTR, lpszMenuName, 36, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, LPCSTR, lpszClassName, 40, 4, 4);
-    TEST_FIELD(WNDCLASSEXA, HICON, hIconSm, 44, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, cbSize, 0, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, style, 4, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, lpfnWndProc, 8, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, cbClsExtra, 12, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, cbWndExtra, 16, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, hInstance, 20, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, hIcon, 24, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, hCursor, 28, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, hbrBackground, 32, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, lpszMenuName, 36, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, lpszClassName, 40, 4, 4);
+    TEST_FIELD(WNDCLASSEXA, 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);
-    TEST_FIELD(WNDCLASSEXW, UINT, style, 4, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, WNDPROC, lpfnWndProc, 8, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, INT, cbClsExtra, 12, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, INT, cbWndExtra, 16, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, HINSTANCE, hInstance, 20, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, HICON, hIcon, 24, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, HCURSOR, hCursor, 28, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, HBRUSH, hbrBackground, 32, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, LPCWSTR, lpszMenuName, 36, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, LPCWSTR, lpszClassName, 40, 4, 4);
-    TEST_FIELD(WNDCLASSEXW, HICON, hIconSm, 44, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, cbSize, 0, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, style, 4, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, lpfnWndProc, 8, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, cbClsExtra, 12, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, cbWndExtra, 16, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, hInstance, 20, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, hIcon, 24, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, hCursor, 28, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, hbrBackground, 32, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, lpszMenuName, 36, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, lpszClassName, 40, 4, 4);
+    TEST_FIELD(WNDCLASSEXW, 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);
-    TEST_FIELD(WNDCLASSW, WNDPROC, lpfnWndProc, 4, 4, 4);
-    TEST_FIELD(WNDCLASSW, INT, cbClsExtra, 8, 4, 4);
-    TEST_FIELD(WNDCLASSW, INT, cbWndExtra, 12, 4, 4);
-    TEST_FIELD(WNDCLASSW, HINSTANCE, hInstance, 16, 4, 4);
-    TEST_FIELD(WNDCLASSW, HICON, hIcon, 20, 4, 4);
-    TEST_FIELD(WNDCLASSW, HCURSOR, hCursor, 24, 4, 4);
-    TEST_FIELD(WNDCLASSW, HBRUSH, hbrBackground, 28, 4, 4);
-    TEST_FIELD(WNDCLASSW, LPCWSTR, lpszMenuName, 32, 4, 4);
-    TEST_FIELD(WNDCLASSW, LPCWSTR, lpszClassName, 36, 4, 4);
+    TEST_FIELD(WNDCLASSW, style, 0, 4, 4);
+    TEST_FIELD(WNDCLASSW, lpfnWndProc, 4, 4, 4);
+    TEST_FIELD(WNDCLASSW, cbClsExtra, 8, 4, 4);
+    TEST_FIELD(WNDCLASSW, cbWndExtra, 12, 4, 4);
+    TEST_FIELD(WNDCLASSW, hInstance, 16, 4, 4);
+    TEST_FIELD(WNDCLASSW, hIcon, 20, 4, 4);
+    TEST_FIELD(WNDCLASSW, hCursor, 24, 4, 4);
+    TEST_FIELD(WNDCLASSW, hbrBackground, 28, 4, 4);
+    TEST_FIELD(WNDCLASSW, lpszMenuName, 32, 4, 4);
+    TEST_FIELD(WNDCLASSW, lpszClassName, 36, 4, 4);
 }
 
 static void test_pack_WNDENUMPROC(void)
diff --git a/dlls/wininet/tests/generated.c b/dlls/wininet/tests/generated.c
index 3fd7be41632..5d8dcdd0dc5 100644
--- a/dlls/wininet/tests/generated.c
+++ b/dlls/wininet/tests/generated.c
@@ -90,10 +90,10 @@
  * Test macros
  */
 
-#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
-  TEST_TYPE_SIZE(field_type, field_size); \
-  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
-  TEST_FIELD_OFFSET(type, field_name, field_offset); \
+#define TEST_FIELD(type, field, field_offset, field_size, field_align) \
+  TEST_TYPE_SIZE((((type*)0)->field), field_size); \
+  TEST_FIELD_ALIGNMENT(type, field, field_align); \
+  TEST_FIELD_OFFSET(type, field, field_offset)
 
 #define TEST_TYPE(type, size, align) \
   TEST_TYPE_ALIGNMENT(type, align); \
@@ -113,48 +113,48 @@ static void test_pack_GOPHER_ABSTRACT_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_ABSTRACT_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_ABSTRACT_ATTRIBUTE_TYPEA, 8, 4);
-    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEA, LPCSTR, ShortAbstract, 0, 4, 4);
-    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEA, LPCSTR, AbstractFile, 4, 4, 4);
+    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEA, ShortAbstract, 0, 4, 4);
+    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEA, AbstractFile, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ABSTRACT_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_ABSTRACT_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_ABSTRACT_ATTRIBUTE_TYPEW, 8, 4);
-    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEW, LPCWSTR, ShortAbstract, 0, 4, 4);
-    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEW, LPCWSTR, AbstractFile, 4, 4, 4);
+    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEW, ShortAbstract, 0, 4, 4);
+    TEST_FIELD(GOPHER_ABSTRACT_ATTRIBUTE_TYPEW, AbstractFile, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ADMIN_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_ADMIN_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_ADMIN_ATTRIBUTE_TYPEA, 8, 4);
-    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEA, LPCSTR, Comment, 0, 4, 4);
-    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEA, LPCSTR, EmailAddress, 4, 4, 4);
+    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEA, Comment, 0, 4, 4);
+    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEA, EmailAddress, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ADMIN_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_ADMIN_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_ADMIN_ATTRIBUTE_TYPEW, 8, 4);
-    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEW, LPCWSTR, Comment, 0, 4, 4);
-    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEW, LPCWSTR, EmailAddress, 4, 4, 4);
+    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEW, Comment, 0, 4, 4);
+    TEST_FIELD(GOPHER_ADMIN_ATTRIBUTE_TYPEW, EmailAddress, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ASK_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_ASK_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_ASK_ATTRIBUTE_TYPEA, 8, 4);
-    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEA, LPCSTR, QuestionType, 0, 4, 4);
-    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEA, LPCSTR, QuestionText, 4, 4, 4);
+    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEA, QuestionType, 0, 4, 4);
+    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEA, QuestionText, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ASK_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_ASK_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_ASK_ATTRIBUTE_TYPEW, 8, 4);
-    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEW, LPCWSTR, QuestionType, 0, 4, 4);
-    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEW, LPCWSTR, QuestionText, 4, 4, 4);
+    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEW, QuestionType, 0, 4, 4);
+    TEST_FIELD(GOPHER_ASK_ATTRIBUTE_TYPEW, QuestionText, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ATTRIBUTE_ENUMERATORA(void)
@@ -172,196 +172,196 @@ static void test_pack_GOPHER_ATTRIBUTE_ENUMERATORW(void)
 static void test_pack_GOPHER_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_ATTRIBUTE_TYPEA (pack 4) */
-    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEA, DWORD, CategoryId, 0, 4, 4);
-    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEA, DWORD, AttributeId, 4, 4, 4);
+    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEA, CategoryId, 0, 4, 4);
+    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEA, AttributeId, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_ATTRIBUTE_TYPEW (pack 4) */
-    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEW, DWORD, CategoryId, 0, 4, 4);
-    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEW, DWORD, AttributeId, 4, 4, 4);
+    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEW, CategoryId, 0, 4, 4);
+    TEST_FIELD(GOPHER_ATTRIBUTE_TYPEW, AttributeId, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_FIND_DATAA(void)
 {
     /* GOPHER_FIND_DATAA (pack 4) */
     TEST_TYPE(GOPHER_FIND_DATAA, 808, 4);
-    TEST_FIELD(GOPHER_FIND_DATAA, CHAR[MAX_GOPHER_DISPLAY_TEXT + 1], DisplayString, 0, 129, 1);
-    TEST_FIELD(GOPHER_FIND_DATAA, DWORD, GopherType, 132, 4, 4);
-    TEST_FIELD(GOPHER_FIND_DATAA, DWORD, SizeLow, 136, 4, 4);
-    TEST_FIELD(GOPHER_FIND_DATAA, DWORD, SizeHigh, 140, 4, 4);
-    TEST_FIELD(GOPHER_FIND_DATAA, FILETIME, LastModificationTime, 144, 8, 4);
-    TEST_FIELD(GOPHER_FIND_DATAA, CHAR[MAX_GOPHER_LOCATOR_LENGTH + 1], Locator, 152, 654, 1);
+    TEST_FIELD(GOPHER_FIND_DATAA, DisplayString, 0, 129, 1);
+    TEST_FIELD(GOPHER_FIND_DATAA, GopherType, 132, 4, 4);
+    TEST_FIELD(GOPHER_FIND_DATAA, SizeLow, 136, 4, 4);
+    TEST_FIELD(GOPHER_FIND_DATAA, SizeHigh, 140, 4, 4);
+    TEST_FIELD(GOPHER_FIND_DATAA, LastModificationTime, 144, 8, 4);
+    TEST_FIELD(GOPHER_FIND_DATAA, Locator, 152, 654, 1);
 }
 
 static void test_pack_GOPHER_FIND_DATAW(void)
 {
     /* GOPHER_FIND_DATAW (pack 4) */
     TEST_TYPE(GOPHER_FIND_DATAW, 1588, 4);
-    TEST_FIELD(GOPHER_FIND_DATAW, WCHAR[MAX_GOPHER_DISPLAY_TEXT + 1], DisplayString, 0, 258, 2);
-    TEST_FIELD(GOPHER_FIND_DATAW, DWORD, GopherType, 260, 4, 4);
-    TEST_FIELD(GOPHER_FIND_DATAW, DWORD, SizeLow, 264, 4, 4);
-    TEST_FIELD(GOPHER_FIND_DATAW, DWORD, SizeHigh, 268, 4, 4);
-    TEST_FIELD(GOPHER_FIND_DATAW, FILETIME, LastModificationTime, 272, 8, 4);
-    TEST_FIELD(GOPHER_FIND_DATAW, WCHAR[MAX_GOPHER_LOCATOR_LENGTH + 1], Locator, 280, 1308, 2);
+    TEST_FIELD(GOPHER_FIND_DATAW, DisplayString, 0, 258, 2);
+    TEST_FIELD(GOPHER_FIND_DATAW, GopherType, 260, 4, 4);
+    TEST_FIELD(GOPHER_FIND_DATAW, SizeLow, 264, 4, 4);
+    TEST_FIELD(GOPHER_FIND_DATAW, SizeHigh, 268, 4, 4);
+    TEST_FIELD(GOPHER_FIND_DATAW, LastModificationTime, 272, 8, 4);
+    TEST_FIELD(GOPHER_FIND_DATAW, Locator, 280, 1308, 2);
 }
 
 static void test_pack_GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, 24, 4);
-    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, INT, DegreesNorth, 0, 4, 4);
-    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, INT, MinutesNorth, 4, 4, 4);
-    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, INT, SecondsNorth, 8, 4, 4);
-    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, INT, DegreesEast, 12, 4, 4);
-    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, INT, MinutesEast, 16, 4, 4);
-    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, INT, SecondsEast, 20, 4, 4);
+    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, DegreesNorth, 0, 4, 4);
+    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, MinutesNorth, 4, 4, 4);
+    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, SecondsNorth, 8, 4, 4);
+    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, DegreesEast, 12, 4, 4);
+    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, MinutesEast, 16, 4, 4);
+    TEST_FIELD(GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE, SecondsEast, 20, 4, 4);
 }
 
 static void test_pack_GOPHER_LOCATION_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_LOCATION_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_LOCATION_ATTRIBUTE_TYPEA, 4, 4);
-    TEST_FIELD(GOPHER_LOCATION_ATTRIBUTE_TYPEA, LPCSTR, Location, 0, 4, 4);
+    TEST_FIELD(GOPHER_LOCATION_ATTRIBUTE_TYPEA, Location, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_LOCATION_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_LOCATION_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_LOCATION_ATTRIBUTE_TYPEW, 4, 4);
-    TEST_FIELD(GOPHER_LOCATION_ATTRIBUTE_TYPEW, LPCWSTR, Location, 0, 4, 4);
+    TEST_FIELD(GOPHER_LOCATION_ATTRIBUTE_TYPEW, Location, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_MOD_DATE_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_MOD_DATE_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_MOD_DATE_ATTRIBUTE_TYPE, 8, 4);
-    TEST_FIELD(GOPHER_MOD_DATE_ATTRIBUTE_TYPE, FILETIME, DateAndTime, 0, 8, 4);
+    TEST_FIELD(GOPHER_MOD_DATE_ATTRIBUTE_TYPE, DateAndTime, 0, 8, 4);
 }
 
 static void test_pack_GOPHER_ORGANIZATION_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_ORGANIZATION_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_ORGANIZATION_ATTRIBUTE_TYPEA, 4, 4);
-    TEST_FIELD(GOPHER_ORGANIZATION_ATTRIBUTE_TYPEA, LPCSTR, Organization, 0, 4, 4);
+    TEST_FIELD(GOPHER_ORGANIZATION_ATTRIBUTE_TYPEA, Organization, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_ORGANIZATION_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_ORGANIZATION_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_ORGANIZATION_ATTRIBUTE_TYPEW, 4, 4);
-    TEST_FIELD(GOPHER_ORGANIZATION_ATTRIBUTE_TYPEW, LPCWSTR, Organization, 0, 4, 4);
+    TEST_FIELD(GOPHER_ORGANIZATION_ATTRIBUTE_TYPEW, Organization, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_PROVIDER_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_PROVIDER_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_PROVIDER_ATTRIBUTE_TYPEA, 4, 4);
-    TEST_FIELD(GOPHER_PROVIDER_ATTRIBUTE_TYPEA, LPCSTR, Provider, 0, 4, 4);
+    TEST_FIELD(GOPHER_PROVIDER_ATTRIBUTE_TYPEA, Provider, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_PROVIDER_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_PROVIDER_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_PROVIDER_ATTRIBUTE_TYPEW, 4, 4);
-    TEST_FIELD(GOPHER_PROVIDER_ATTRIBUTE_TYPEW, LPCWSTR, Provider, 0, 4, 4);
+    TEST_FIELD(GOPHER_PROVIDER_ATTRIBUTE_TYPEW, Provider, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_SCORE_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_SCORE_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_SCORE_ATTRIBUTE_TYPE, 4, 4);
-    TEST_FIELD(GOPHER_SCORE_ATTRIBUTE_TYPE, INT, Score, 0, 4, 4);
+    TEST_FIELD(GOPHER_SCORE_ATTRIBUTE_TYPE, Score, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE, 8, 4);
-    TEST_FIELD(GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE, INT, LowerBound, 0, 4, 4);
-    TEST_FIELD(GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE, INT, UpperBound, 4, 4, 4);
+    TEST_FIELD(GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE, LowerBound, 0, 4, 4);
+    TEST_FIELD(GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE, UpperBound, 4, 4, 4);
 }
 
 static void test_pack_GOPHER_SITE_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_SITE_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_SITE_ATTRIBUTE_TYPEA, 4, 4);
-    TEST_FIELD(GOPHER_SITE_ATTRIBUTE_TYPEA, LPCSTR, Site, 0, 4, 4);
+    TEST_FIELD(GOPHER_SITE_ATTRIBUTE_TYPEA, Site, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_SITE_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_SITE_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_SITE_ATTRIBUTE_TYPEW, 4, 4);
-    TEST_FIELD(GOPHER_SITE_ATTRIBUTE_TYPEW, LPCWSTR, Site, 0, 4, 4);
+    TEST_FIELD(GOPHER_SITE_ATTRIBUTE_TYPEW, Site, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_TIMEZONE_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_TIMEZONE_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_TIMEZONE_ATTRIBUTE_TYPE, 4, 4);
-    TEST_FIELD(GOPHER_TIMEZONE_ATTRIBUTE_TYPE, INT, Zone, 0, 4, 4);
+    TEST_FIELD(GOPHER_TIMEZONE_ATTRIBUTE_TYPE, Zone, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_TTL_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_TTL_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_TTL_ATTRIBUTE_TYPE, 4, 4);
-    TEST_FIELD(GOPHER_TTL_ATTRIBUTE_TYPE, DWORD, Ttl, 0, 4, 4);
+    TEST_FIELD(GOPHER_TTL_ATTRIBUTE_TYPE, Ttl, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_UNKNOWN_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_UNKNOWN_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_UNKNOWN_ATTRIBUTE_TYPEA, 4, 4);
-    TEST_FIELD(GOPHER_UNKNOWN_ATTRIBUTE_TYPEA, LPCSTR, Text, 0, 4, 4);
+    TEST_FIELD(GOPHER_UNKNOWN_ATTRIBUTE_TYPEA, Text, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_UNKNOWN_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_UNKNOWN_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_UNKNOWN_ATTRIBUTE_TYPEW, 4, 4);
-    TEST_FIELD(GOPHER_UNKNOWN_ATTRIBUTE_TYPEW, LPCWSTR, Text, 0, 4, 4);
+    TEST_FIELD(GOPHER_UNKNOWN_ATTRIBUTE_TYPEW, Text, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_VERONICA_ATTRIBUTE_TYPE(void)
 {
     /* GOPHER_VERONICA_ATTRIBUTE_TYPE (pack 4) */
     TEST_TYPE(GOPHER_VERONICA_ATTRIBUTE_TYPE, 4, 4);
-    TEST_FIELD(GOPHER_VERONICA_ATTRIBUTE_TYPE, BOOL, TreeWalk, 0, 4, 4);
+    TEST_FIELD(GOPHER_VERONICA_ATTRIBUTE_TYPE, TreeWalk, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_VERSION_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_VERSION_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_VERSION_ATTRIBUTE_TYPEA, 4, 4);
-    TEST_FIELD(GOPHER_VERSION_ATTRIBUTE_TYPEA, LPCSTR, Version, 0, 4, 4);
+    TEST_FIELD(GOPHER_VERSION_ATTRIBUTE_TYPEA, Version, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_VERSION_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_VERSION_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_VERSION_ATTRIBUTE_TYPEW, 4, 4);
-    TEST_FIELD(GOPHER_VERSION_ATTRIBUTE_TYPEW, LPCWSTR, Version, 0, 4, 4);
+    TEST_FIELD(GOPHER_VERSION_ATTRIBUTE_TYPEW, Version, 0, 4, 4);
 }
 
 static void test_pack_GOPHER_VIEW_ATTRIBUTE_TYPEA(void)
 {
     /* GOPHER_VIEW_ATTRIBUTE_TYPEA (pack 4) */
     TEST_TYPE(GOPHER_VIEW_ATTRIBUTE_TYPEA, 12, 4);
-    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEA, LPCSTR, ContentType, 0, 4, 4);
-    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEA, LPCSTR, Language, 4, 4, 4);
-    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEA, DWORD, Size, 8, 4, 4);
+    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEA, ContentType, 0, 4, 4);
+    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEA, Language, 4, 4, 4);
+    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEA, Size, 8, 4, 4);
 }
 
 static void test_pack_GOPHER_VIEW_ATTRIBUTE_TYPEW(void)
 {
     /* GOPHER_VIEW_ATTRIBUTE_TYPEW (pack 4) */
     TEST_TYPE(GOPHER_VIEW_ATTRIBUTE_TYPEW, 12, 4);
-    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEW, LPCWSTR, ContentType, 0, 4, 4);
-    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEW, LPCWSTR, Language, 4, 4, 4);
-    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEW, DWORD, Size, 8, 4, 4);
+    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEW, ContentType, 0, 4, 4);
+    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEW, Language, 4, 4, 4);
+    TEST_FIELD(GOPHER_VIEW_ATTRIBUTE_TYPEW, Size, 8, 4, 4);
 }
 
 static void test_pack_GROUPID(void)
@@ -381,134 +381,134 @@ static void test_pack_HTTP_VERSION_INFO(void)
 {
     /* HTTP_VERSION_INFO (pack 4) */
     TEST_TYPE(HTTP_VERSION_INFO, 8, 4);
-    TEST_FIELD(HTTP_VERSION_INFO, DWORD, dwMajorVersion, 0, 4, 4);
-    TEST_FIELD(HTTP_VERSION_INFO, DWORD, dwMinorVersion, 4, 4, 4);
+    TEST_FIELD(HTTP_VERSION_INFO, dwMajorVersion, 0, 4, 4);
+    TEST_FIELD(HTTP_VERSION_INFO, dwMinorVersion, 4, 4, 4);
 }
 
 static void test_pack_INTERNET_ASYNC_RESULT(void)
 {
     /* INTERNET_ASYNC_RESULT (pack 4) */
     TEST_TYPE(INTERNET_ASYNC_RESULT, 8, 4);
-    TEST_FIELD(INTERNET_ASYNC_RESULT, DWORD_PTR, dwResult, 0, 4, 4);
-    TEST_FIELD(INTERNET_ASYNC_RESULT, DWORD, dwError, 4, 4, 4);
+    TEST_FIELD(INTERNET_ASYNC_RESULT, dwResult, 0, 4, 4);
+    TEST_FIELD(INTERNET_ASYNC_RESULT, dwError, 4, 4, 4);
 }
 
 static void test_pack_INTERNET_AUTH_NOTIFY_DATA(void)
 {
     /* INTERNET_AUTH_NOTIFY_DATA (pack 4) */
     TEST_TYPE(INTERNET_AUTH_NOTIFY_DATA, 16, 4);
-    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, DWORD, cbStruct, 0, 4, 4);
-    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, DWORD, dwOptions, 4, 4, 4);
-    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, PFN_AUTH_NOTIFY, pfnNotify, 8, 4, 4);
-    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, DWORD_PTR, dwContext, 12, 4, 4);
+    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, cbStruct, 0, 4, 4);
+    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, dwOptions, 4, 4, 4);
+    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, pfnNotify, 8, 4, 4);
+    TEST_FIELD(INTERNET_AUTH_NOTIFY_DATA, dwContext, 12, 4, 4);
 }
 
 static void test_pack_INTERNET_BUFFERSA(void)
 {
     /* INTERNET_BUFFERSA (pack 4) */
     TEST_TYPE(INTERNET_BUFFERSA, 40, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwStructSize, 0, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, struct _INTERNET_BUFFERSA *, Next, 4, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, LPCSTR, lpcszHeader, 8, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwHeadersLength, 12, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwHeadersTotal, 16, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, LPVOID, lpvBuffer, 20, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwBufferLength, 24, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwBufferTotal, 28, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwOffsetLow, 32, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSA, DWORD, dwOffsetHigh, 36, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwStructSize, 0, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, Next, 4, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, lpcszHeader, 8, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwHeadersLength, 12, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwHeadersTotal, 16, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, lpvBuffer, 20, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwBufferLength, 24, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwBufferTotal, 28, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwOffsetLow, 32, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSA, dwOffsetHigh, 36, 4, 4);
 }
 
 static void test_pack_INTERNET_BUFFERSW(void)
 {
     /* INTERNET_BUFFERSW (pack 4) */
     TEST_TYPE(INTERNET_BUFFERSW, 40, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwStructSize, 0, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, struct _INTERNET_BUFFERSW *, Next, 4, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, LPCWSTR, lpcszHeader, 8, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwHeadersLength, 12, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwHeadersTotal, 16, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, LPVOID, lpvBuffer, 20, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwBufferLength, 24, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwBufferTotal, 28, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwOffsetLow, 32, 4, 4);
-    TEST_FIELD(INTERNET_BUFFERSW, DWORD, dwOffsetHigh, 36, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwStructSize, 0, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, Next, 4, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, lpcszHeader, 8, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwHeadersLength, 12, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwHeadersTotal, 16, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, lpvBuffer, 20, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwBufferLength, 24, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwBufferTotal, 28, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwOffsetLow, 32, 4, 4);
+    TEST_FIELD(INTERNET_BUFFERSW, dwOffsetHigh, 36, 4, 4);
 }
 
 static void test_pack_INTERNET_CACHE_ENTRY_INFOA(void)
 {
     /* INTERNET_CACHE_ENTRY_INFOA (pack 4) */
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, dwStructSize, 0, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LPSTR, lpszSourceUrlName, 4, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LPSTR, lpszLocalFileName, 8, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, CacheEntryType, 12, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, dwUseCount, 16, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, dwHitRate, 20, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, dwSizeLow, 24, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, dwSizeHigh, 28, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, FILETIME, LastModifiedTime, 32, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, FILETIME, ExpireTime, 40, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, FILETIME, LastAccessTime, 48, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, FILETIME, LastSyncTime, 56, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LPBYTE, lpHeaderInfo, 64, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, DWORD, dwHeaderInfoSize, 68, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LPSTR, lpszFileExtension, 72, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, dwStructSize, 0, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, lpszSourceUrlName, 4, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, lpszLocalFileName, 8, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, CacheEntryType, 12, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, dwUseCount, 16, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, dwHitRate, 20, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, dwSizeLow, 24, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, dwSizeHigh, 28, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LastModifiedTime, 32, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, ExpireTime, 40, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LastAccessTime, 48, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, LastSyncTime, 56, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, lpHeaderInfo, 64, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, dwHeaderInfoSize, 68, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOA, lpszFileExtension, 72, 4, 4);
 }
 
 static void test_pack_INTERNET_CACHE_ENTRY_INFOW(void)
 {
     /* INTERNET_CACHE_ENTRY_INFOW (pack 4) */
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, dwStructSize, 0, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LPWSTR, lpszSourceUrlName, 4, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LPWSTR, lpszLocalFileName, 8, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, CacheEntryType, 12, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, dwUseCount, 16, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, dwHitRate, 20, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, dwSizeLow, 24, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, dwSizeHigh, 28, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, FILETIME, LastModifiedTime, 32, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, FILETIME, ExpireTime, 40, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, FILETIME, LastAccessTime, 48, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, FILETIME, LastSyncTime, 56, 8, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LPBYTE, lpHeaderInfo, 64, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, DWORD, dwHeaderInfoSize, 68, 4, 4);
-    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LPWSTR, lpszFileExtension, 72, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, dwStructSize, 0, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, lpszSourceUrlName, 4, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, lpszLocalFileName, 8, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, CacheEntryType, 12, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, dwUseCount, 16, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, dwHitRate, 20, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, dwSizeLow, 24, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, dwSizeHigh, 28, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LastModifiedTime, 32, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, ExpireTime, 40, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LastAccessTime, 48, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, LastSyncTime, 56, 8, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, lpHeaderInfo, 64, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, dwHeaderInfoSize, 68, 4, 4);
+    TEST_FIELD(INTERNET_CACHE_ENTRY_INFOW, lpszFileExtension, 72, 4, 4);
 }
 
 static void test_pack_INTERNET_CERTIFICATE_INFOA(void)
 {
     /* INTERNET_CERTIFICATE_INFOA (pack 4) */
     TEST_TYPE(INTERNET_CERTIFICATE_INFOA, 40, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, FILETIME, ftExpiry, 0, 8, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, FILETIME, ftStart, 8, 8, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, LPSTR, lpszSubjectInfo, 16, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, LPSTR, lpszIssuerInfo, 20, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, LPSTR, lpszProtocolName, 24, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, LPSTR, lpszSignatureAlgName, 28, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, LPSTR, lpszEncryptionAlgName, 32, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, DWORD, dwKeySize, 36, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, ftExpiry, 0, 8, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, ftStart, 8, 8, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, lpszSubjectInfo, 16, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, lpszIssuerInfo, 20, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, lpszProtocolName, 24, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, lpszSignatureAlgName, 28, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, lpszEncryptionAlgName, 32, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOA, dwKeySize, 36, 4, 4);
 }
 
 static void test_pack_INTERNET_CERTIFICATE_INFOW(void)
 {
     /* INTERNET_CERTIFICATE_INFOW (pack 4) */
     TEST_TYPE(INTERNET_CERTIFICATE_INFOW, 40, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, FILETIME, ftExpiry, 0, 8, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, FILETIME, ftStart, 8, 8, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, LPWSTR, lpszSubjectInfo, 16, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, LPWSTR, lpszIssuerInfo, 20, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, LPWSTR, lpszProtocolName, 24, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, LPWSTR, lpszSignatureAlgName, 28, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, LPWSTR, lpszEncryptionAlgName, 32, 4, 4);
-    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, DWORD, dwKeySize, 36, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, ftExpiry, 0, 8, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, ftStart, 8, 8, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, lpszSubjectInfo, 16, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, lpszIssuerInfo, 20, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, lpszProtocolName, 24, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, lpszSignatureAlgName, 28, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, lpszEncryptionAlgName, 32, 4, 4);
+    TEST_FIELD(INTERNET_CERTIFICATE_INFOW, dwKeySize, 36, 4, 4);
 }
 
 static void test_pack_INTERNET_CONNECTED_INFO(void)
 {
     /* INTERNET_CONNECTED_INFO (pack 4) */
     TEST_TYPE(INTERNET_CONNECTED_INFO, 8, 4);
-    TEST_FIELD(INTERNET_CONNECTED_INFO, DWORD, dwConnectedState, 0, 4, 4);
-    TEST_FIELD(INTERNET_CONNECTED_INFO, DWORD, dwFlags, 4, 4, 4);
+    TEST_FIELD(INTERNET_CONNECTED_INFO, dwConnectedState, 0, 4, 4);
+    TEST_FIELD(INTERNET_CONNECTED_INFO, dwFlags, 4, 4, 4);
 }
 
 static void test_pack_INTERNET_PORT(void)
@@ -522,18 +522,18 @@ static void test_pack_INTERNET_PROXY_INFOA(void)
 {
     /* INTERNET_PROXY_INFOA (pack 4) */
     TEST_TYPE(INTERNET_PROXY_INFOA, 12, 4);
-    TEST_FIELD(INTERNET_PROXY_INFOA, DWORD, dwAccessType, 0, 4, 4);
-    TEST_FIELD(INTERNET_PROXY_INFOA, LPCSTR, lpszProxy, 4, 4, 4);
-    TEST_FIELD(INTERNET_PROXY_INFOA, LPCSTR, lpszProxyBypass, 8, 4, 4);
+    TEST_FIELD(INTERNET_PROXY_INFOA, dwAccessType, 0, 4, 4);
+    TEST_FIELD(INTERNET_PROXY_INFOA, lpszProxy, 4, 4, 4);
+    TEST_FIELD(INTERNET_PROXY_INFOA, lpszProxyBypass, 8, 4, 4);
 }
 
 static void test_pack_INTERNET_PROXY_INFOW(void)
 {
     /* INTERNET_PROXY_INFOW (pack 4) */
     TEST_TYPE(INTERNET_PROXY_INFOW, 12, 4);
-    TEST_FIELD(INTERNET_PROXY_INFOW, DWORD, dwAccessType, 0, 4, 4);
-    TEST_FIELD(INTERNET_PROXY_INFOW, LPCWSTR, lpszProxy, 4, 4, 4);
-    TEST_FIELD(INTERNET_PROXY_INFOW, LPCWSTR, lpszProxyBypass, 8, 4, 4);
+    TEST_FIELD(INTERNET_PROXY_INFOW, dwAccessType, 0, 4, 4);
+    TEST_FIELD(INTERNET_PROXY_INFOW, lpszProxy, 4, 4, 4);
+    TEST_FIELD(INTERNET_PROXY_INFOW, lpszProxyBypass, 8, 4, 4);
 }
 
 static void test_pack_INTERNET_STATUS_CALLBACK(void)
@@ -546,8 +546,8 @@ static void test_pack_INTERNET_VERSION_INFO(void)
 {
     /* INTERNET_VERSION_INFO (pack 4) */
     TEST_TYPE(INTERNET_VERSION_INFO, 8, 4);
-    TEST_FIELD(INTERNET_VERSION_INFO, DWORD, dwMajorVersion, 0, 4, 4);
-    TEST_FIELD(INTERNET_VERSION_INFO, DWORD, dwMinorVersion, 4, 4, 4);
+    TEST_FIELD(INTERNET_VERSION_INFO, dwMajorVersion, 0, 4, 4);
+    TEST_FIELD(INTERNET_VERSION_INFO, dwMinorVersion, 4, 4, 4);
 }
 
 static void test_pack_LPGOPHER_ABSTRACT_ATTRIBUTE_TYPEA(void)
@@ -895,17 +895,17 @@ static void test_pack_PFN_DIAL_HANDLER(void)
 static void test_pack_URL_COMPONENTSA(void)
 {
     /* URL_COMPONENTSA (pack 4) */
-    TEST_FIELD(URL_COMPONENTSA, DWORD, dwStructSize, 0, 4, 4);
-    TEST_FIELD(URL_COMPONENTSA, LPSTR, lpszScheme, 4, 4, 4);
-    TEST_FIELD(URL_COMPONENTSA, DWORD, dwSchemeLength, 8, 4, 4);
+    TEST_FIELD(URL_COMPONENTSA, dwStructSize, 0, 4, 4);
+    TEST_FIELD(URL_COMPONENTSA, lpszScheme, 4, 4, 4);
+    TEST_FIELD(URL_COMPONENTSA, dwSchemeLength, 8, 4, 4);
 }
 
 static void test_pack_URL_COMPONENTSW(void)
 {
     /* URL_COMPONENTSW (pack 4) */
-    TEST_FIELD(URL_COMPONENTSW, DWORD, dwStructSize, 0, 4, 4);
-    TEST_FIELD(URL_COMPONENTSW, LPWSTR, lpszScheme, 4, 4, 4);
-    TEST_FIELD(URL_COMPONENTSW, DWORD, dwSchemeLength, 8, 4, 4);
+    TEST_FIELD(URL_COMPONENTSW, dwStructSize, 0, 4, 4);
+    TEST_FIELD(URL_COMPONENTSW, lpszScheme, 4, 4, 4);
+    TEST_FIELD(URL_COMPONENTSW, dwSchemeLength, 8, 4, 4);
 }
 
 static void test_pack(void)
diff --git a/tools/winapi/winapi_test b/tools/winapi/winapi_test
index 36ddfa90515..8b6c9c29c72 100755
--- a/tools/winapi/winapi_test
+++ b/tools/winapi/winapi_test
@@ -571,10 +571,10 @@ sub output_header($$$) {
     print OUT " * Test macros\n";
     print OUT " */\n";
     print OUT "\n";
-    print OUT "#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \\\n";
-    print OUT "  TEST_TYPE_SIZE(field_type, field_size); \\\n";
-    print OUT "  TEST_FIELD_ALIGNMENT(type, field_name, field_align); \\\n";
-    print OUT "  TEST_FIELD_OFFSET(type, field_name, field_offset); \\\n";
+    print OUT "#define TEST_FIELD(type, field, field_offset, field_size, field_align) \\\n";
+    print OUT "  TEST_TYPE_SIZE((((type*)0)->field), field_size); \\\n";
+    print OUT "  TEST_FIELD_ALIGNMENT(type, field, field_align); \\\n";
+    print OUT "  TEST_FIELD_OFFSET(type, field, field_offset)\n";
     print OUT "\n";
     print OUT "#define TEST_TYPE(type, size, align) \\\n";
     print OUT "  TEST_TYPE_ALIGNMENT(type, align); \\\n";
@@ -727,14 +727,14 @@ sub output_test_pack_fields($$$$$$$) {
 	    $field_offset += $offset;
 	    if ($field_name eq "DUMMYSTRUCTNAME") {
 		print OUT "#ifdef NONAMELESSSTRUCT\n";
-		print OUT "    TEST_FIELD($type_name, $field_type_name, $field_name, ";
+		print OUT "    TEST_FIELD($type_name, $field_name, ";
 		print OUT "$field_offset, $field_size, $field_align);\n";
 		print OUT "#else\n";
 		output_test_pack_fields(\*OUT, $type_name2type, $type_name2optional, $type_name2optional_fields,
 					$type_name, $$type_name2type{$field_type_name}, $field_offset);	
 		print OUT "#endif\n";
 	    } else {
-		print OUT "    TEST_FIELD($type_name, $field_type_name, $field_name, ";
+		print OUT "    TEST_FIELD($type_name, $field_name, ";
 		print OUT "$field_offset, $field_size, $field_align);\n";
 	    }
 	} else {