Skip to content

W
wine-winehq
Commit ebf582cd authored by Patrik Stridvall's avatar Patrik Stridvall Committed by Alexandre Julliard
Browse files
Options

Updated the generated tests.

parent 90fb0460
Show whitespace changes
Inline Side-by-side
Showing with 1051 additions and 827 deletions
dlls/gdi/tests/generated.c
View file @ ebf582cd
This source diff could not be displayed because it is too large. You can view the blob instead.
dlls/kernel/tests/generated.c
View file @ ebf582cd
......@@ -8,837 +8,420 @@
#include <stdio.h>
#include "wine/test.h"
#include "basetsd.h"
#include "winnt.h"
#include "windef.h"
#include "winbase.h"
/***********************************************************************
* Windows API extension
*/
#if (_MSC_VER >= 1300) && defined(__cplusplus)
# define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
#elif defined(__GNUC__)
# define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
#else
/* FIXME: Not sure if is possible to do without compiler extension */
#endif
/***********************************************************************
* Test helper macros
*/
#ifdef FIELD_ALIGNMENT
# define TEST_FIELD_ALIGNMENT(type, field, align) \
ok(FIELD_ALIGNMENT(type, field) == align, \
"FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")", \
FIELD_ALIGNMENT(type, field))
#else
# define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
#endif
#define TEST_FIELD_OFFSET(type, field, offset) \
ok(FIELD_OFFSET(type, field) == offset, \
"FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")", \
FIELD_OFFSET(type, field))
#define TEST_TYPE_ALIGNMENT(type, align) \
ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", TYPE_ALIGNMENT(type))
#define TEST_TYPE_SIZE(type, size) \
ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")", sizeof(type))
/***********************************************************************
* 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_TYPE(type, size, align) \
TEST_TYPE_ALIGNMENT(type, align); \
TEST_TYPE_SIZE(type, size)
void test_pack(void)
{
/* BY_HANDLE_FILE_INFORMATION */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, dwFileAttributes) == 0,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, dwFileAttributes) == %ld (expected 0)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, dwFileAttributes)); /* DWORD */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftCreationTime) == 4,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftCreationTime) == %ld (expected 4)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftCreationTime)); /* FILETIME */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftLastAccessTime) == 12,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftLastAccessTime) == %ld (expected 12)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftLastAccessTime)); /* FILETIME */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftLastWriteTime) == 20,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftLastWriteTime) == %ld (expected 20)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, ftLastWriteTime)); /* FILETIME */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, dwVolumeSerialNumber) == 28,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, dwVolumeSerialNumber) == %ld (expected 28)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, dwVolumeSerialNumber)); /* DWORD */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileSizeHigh) == 32,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileSizeHigh) == %ld (expected 32)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileSizeHigh)); /* DWORD */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileSizeLow) == 36,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileSizeLow) == %ld (expected 36)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileSizeLow)); /* DWORD */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nNumberOfLinks) == 40,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nNumberOfLinks) == %ld (expected 40)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nNumberOfLinks)); /* DWORD */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileIndexHigh) == 44,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileIndexHigh) == %ld (expected 44)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileIndexHigh)); /* DWORD */
ok(FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileIndexLow) == 48,
"FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileIndexLow) == %ld (expected 48)",
FIELD_OFFSET(BY_HANDLE_FILE_INFORMATION, nFileIndexLow)); /* DWORD */
ok(sizeof(BY_HANDLE_FILE_INFORMATION) == 52, "sizeof(BY_HANDLE_FILE_INFORMATION) == %d (expected 52)", sizeof(BY_HANDLE_FILE_INFORMATION));
/* COMMCONFIG */
ok(FIELD_OFFSET(COMMCONFIG, dwSize) == 0,
"FIELD_OFFSET(COMMCONFIG, dwSize) == %ld (expected 0)",
FIELD_OFFSET(COMMCONFIG, dwSize)); /* DWORD */
ok(FIELD_OFFSET(COMMCONFIG, wVersion) == 4,
"FIELD_OFFSET(COMMCONFIG, wVersion) == %ld (expected 4)",
FIELD_OFFSET(COMMCONFIG, wVersion)); /* WORD */
ok(FIELD_OFFSET(COMMCONFIG, wReserved) == 6,
"FIELD_OFFSET(COMMCONFIG, wReserved) == %ld (expected 6)",
FIELD_OFFSET(COMMCONFIG, wReserved)); /* WORD */
ok(FIELD_OFFSET(COMMCONFIG, dcb) == 8,
"FIELD_OFFSET(COMMCONFIG, dcb) == %ld (expected 8)",
FIELD_OFFSET(COMMCONFIG, dcb)); /* DCB */
ok(FIELD_OFFSET(COMMCONFIG, dwProviderSubType) == 36,
"FIELD_OFFSET(COMMCONFIG, dwProviderSubType) == %ld (expected 36)",
FIELD_OFFSET(COMMCONFIG, dwProviderSubType)); /* DWORD */
ok(FIELD_OFFSET(COMMCONFIG, dwProviderOffset) == 40,
"FIELD_OFFSET(COMMCONFIG, dwProviderOffset) == %ld (expected 40)",
FIELD_OFFSET(COMMCONFIG, dwProviderOffset)); /* DWORD */
ok(FIELD_OFFSET(COMMCONFIG, dwProviderSize) == 44,
"FIELD_OFFSET(COMMCONFIG, dwProviderSize) == %ld (expected 44)",
FIELD_OFFSET(COMMCONFIG, dwProviderSize)); /* DWORD */
ok(FIELD_OFFSET(COMMCONFIG, wcProviderData) == 48,
"FIELD_OFFSET(COMMCONFIG, wcProviderData) == %ld (expected 48)",
FIELD_OFFSET(COMMCONFIG, wcProviderData)); /* DWORD[1] */
ok(sizeof(COMMCONFIG) == 52, "sizeof(COMMCONFIG) == %d (expected 52)", sizeof(COMMCONFIG));
/* COMMPROP */
ok(FIELD_OFFSET(COMMPROP, wPacketLength) == 0,
"FIELD_OFFSET(COMMPROP, wPacketLength) == %ld (expected 0)",
FIELD_OFFSET(COMMPROP, wPacketLength)); /* WORD */
ok(FIELD_OFFSET(COMMPROP, wPacketVersion) == 2,
"FIELD_OFFSET(COMMPROP, wPacketVersion) == %ld (expected 2)",
FIELD_OFFSET(COMMPROP, wPacketVersion)); /* WORD */
ok(FIELD_OFFSET(COMMPROP, dwServiceMask) == 4,
"FIELD_OFFSET(COMMPROP, dwServiceMask) == %ld (expected 4)",
FIELD_OFFSET(COMMPROP, dwServiceMask)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwReserved1) == 8,
"FIELD_OFFSET(COMMPROP, dwReserved1) == %ld (expected 8)",
FIELD_OFFSET(COMMPROP, dwReserved1)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwMaxTxQueue) == 12,
"FIELD_OFFSET(COMMPROP, dwMaxTxQueue) == %ld (expected 12)",
FIELD_OFFSET(COMMPROP, dwMaxTxQueue)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwMaxRxQueue) == 16,
"FIELD_OFFSET(COMMPROP, dwMaxRxQueue) == %ld (expected 16)",
FIELD_OFFSET(COMMPROP, dwMaxRxQueue)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwMaxBaud) == 20,
"FIELD_OFFSET(COMMPROP, dwMaxBaud) == %ld (expected 20)",
FIELD_OFFSET(COMMPROP, dwMaxBaud)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwProvSubType) == 24,
"FIELD_OFFSET(COMMPROP, dwProvSubType) == %ld (expected 24)",
FIELD_OFFSET(COMMPROP, dwProvSubType)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwProvCapabilities) == 28,
"FIELD_OFFSET(COMMPROP, dwProvCapabilities) == %ld (expected 28)",
FIELD_OFFSET(COMMPROP, dwProvCapabilities)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwSettableParams) == 32,
"FIELD_OFFSET(COMMPROP, dwSettableParams) == %ld (expected 32)",
FIELD_OFFSET(COMMPROP, dwSettableParams)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwSettableBaud) == 36,
"FIELD_OFFSET(COMMPROP, dwSettableBaud) == %ld (expected 36)",
FIELD_OFFSET(COMMPROP, dwSettableBaud)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, wSettableData) == 40,
"FIELD_OFFSET(COMMPROP, wSettableData) == %ld (expected 40)",
FIELD_OFFSET(COMMPROP, wSettableData)); /* WORD */
ok(FIELD_OFFSET(COMMPROP, wSettableStopParity) == 42,
"FIELD_OFFSET(COMMPROP, wSettableStopParity) == %ld (expected 42)",
FIELD_OFFSET(COMMPROP, wSettableStopParity)); /* WORD */
ok(FIELD_OFFSET(COMMPROP, dwCurrentTxQueue) == 44,
"FIELD_OFFSET(COMMPROP, dwCurrentTxQueue) == %ld (expected 44)",
FIELD_OFFSET(COMMPROP, dwCurrentTxQueue)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwCurrentRxQueue) == 48,
"FIELD_OFFSET(COMMPROP, dwCurrentRxQueue) == %ld (expected 48)",
FIELD_OFFSET(COMMPROP, dwCurrentRxQueue)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwProvSpec1) == 52,
"FIELD_OFFSET(COMMPROP, dwProvSpec1) == %ld (expected 52)",
FIELD_OFFSET(COMMPROP, dwProvSpec1)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, dwProvSpec2) == 56,
"FIELD_OFFSET(COMMPROP, dwProvSpec2) == %ld (expected 56)",
FIELD_OFFSET(COMMPROP, dwProvSpec2)); /* DWORD */
ok(FIELD_OFFSET(COMMPROP, wcProvChar) == 60,
"FIELD_OFFSET(COMMPROP, wcProvChar) == %ld (expected 60)",
FIELD_OFFSET(COMMPROP, wcProvChar)); /* WCHAR[1] */
ok(sizeof(COMMPROP) == 64, "sizeof(COMMPROP) == %d (expected 64)", sizeof(COMMPROP));
/* COMMTIMEOUTS */
ok(FIELD_OFFSET(COMMTIMEOUTS, ReadIntervalTimeout) == 0,
"FIELD_OFFSET(COMMTIMEOUTS, ReadIntervalTimeout) == %ld (expected 0)",
FIELD_OFFSET(COMMTIMEOUTS, ReadIntervalTimeout)); /* DWORD */
ok(FIELD_OFFSET(COMMTIMEOUTS, ReadTotalTimeoutMultiplier) == 4,
"FIELD_OFFSET(COMMTIMEOUTS, ReadTotalTimeoutMultiplier) == %ld (expected 4)",
FIELD_OFFSET(COMMTIMEOUTS, ReadTotalTimeoutMultiplier)); /* DWORD */
ok(FIELD_OFFSET(COMMTIMEOUTS, ReadTotalTimeoutConstant) == 8,
"FIELD_OFFSET(COMMTIMEOUTS, ReadTotalTimeoutConstant) == %ld (expected 8)",
FIELD_OFFSET(COMMTIMEOUTS, ReadTotalTimeoutConstant)); /* DWORD */
ok(FIELD_OFFSET(COMMTIMEOUTS, WriteTotalTimeoutMultiplier) == 12,
"FIELD_OFFSET(COMMTIMEOUTS, WriteTotalTimeoutMultiplier) == %ld (expected 12)",
FIELD_OFFSET(COMMTIMEOUTS, WriteTotalTimeoutMultiplier)); /* DWORD */
ok(FIELD_OFFSET(COMMTIMEOUTS, WriteTotalTimeoutConstant) == 16,
"FIELD_OFFSET(COMMTIMEOUTS, WriteTotalTimeoutConstant) == %ld (expected 16)",
FIELD_OFFSET(COMMTIMEOUTS, WriteTotalTimeoutConstant)); /* DWORD */
ok(sizeof(COMMTIMEOUTS) == 20, "sizeof(COMMTIMEOUTS) == %d (expected 20)", sizeof(COMMTIMEOUTS));
/* COMSTAT */
ok(FIELD_OFFSET(COMSTAT, status) == 0,
"FIELD_OFFSET(COMSTAT, status) == %ld (expected 0)",
FIELD_OFFSET(COMSTAT, status)); /* DWORD */
ok(FIELD_OFFSET(COMSTAT, cbInQue) == 4,
"FIELD_OFFSET(COMSTAT, cbInQue) == %ld (expected 4)",
FIELD_OFFSET(COMSTAT, cbInQue)); /* DWORD */
ok(FIELD_OFFSET(COMSTAT, cbOutQue) == 8,
"FIELD_OFFSET(COMSTAT, cbOutQue) == %ld (expected 8)",
FIELD_OFFSET(COMSTAT, cbOutQue)); /* DWORD */
ok(sizeof(COMSTAT) == 12, "sizeof(COMSTAT) == %d (expected 12)", sizeof(COMSTAT));
/* CREATE_PROCESS_DEBUG_INFO */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hFile) == 0,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hFile) == %ld (expected 0)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hFile)); /* HANDLE */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hProcess) == 4,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hProcess) == %ld (expected 4)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hProcess)); /* HANDLE */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hThread) == 8,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hThread) == %ld (expected 8)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, hThread)); /* HANDLE */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpBaseOfImage) == 12,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpBaseOfImage) == %ld (expected 12)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpBaseOfImage)); /* LPVOID */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, dwDebugInfoFileOffset) == 16,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, dwDebugInfoFileOffset) == %ld (expected 16)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, dwDebugInfoFileOffset)); /* DWORD */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, nDebugInfoSize) == 20,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, nDebugInfoSize) == %ld (expected 20)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, nDebugInfoSize)); /* DWORD */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpThreadLocalBase) == 24,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpThreadLocalBase) == %ld (expected 24)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpThreadLocalBase)); /* LPVOID */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpStartAddress) == 28,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpStartAddress) == %ld (expected 28)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpStartAddress)); /* LPTHREAD_START_ROUTINE */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpImageName) == 32,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpImageName) == %ld (expected 32)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, lpImageName)); /* LPVOID */
ok(FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, fUnicode) == 36,
"FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, fUnicode) == %ld (expected 36)",
FIELD_OFFSET(CREATE_PROCESS_DEBUG_INFO, fUnicode)); /* WORD */
ok(sizeof(CREATE_PROCESS_DEBUG_INFO) == 40, "sizeof(CREATE_PROCESS_DEBUG_INFO) == %d (expected 40)", sizeof(CREATE_PROCESS_DEBUG_INFO));
/* CREATE_THREAD_DEBUG_INFO */
ok(FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, hThread) == 0,
"FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, hThread) == %ld (expected 0)",
FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, hThread)); /* HANDLE */
ok(FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, lpThreadLocalBase) == 4,
"FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, lpThreadLocalBase) == %ld (expected 4)",
FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, lpThreadLocalBase)); /* LPVOID */
ok(FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, lpStartAddress) == 8,
"FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, lpStartAddress) == %ld (expected 8)",
FIELD_OFFSET(CREATE_THREAD_DEBUG_INFO, lpStartAddress)); /* LPTHREAD_START_ROUTINE */
ok(sizeof(CREATE_THREAD_DEBUG_INFO) == 12, "sizeof(CREATE_THREAD_DEBUG_INFO) == %d (expected 12)", sizeof(CREATE_THREAD_DEBUG_INFO));
/* DCB */
ok(FIELD_OFFSET(DCB, DCBlength) == 0,
"FIELD_OFFSET(DCB, DCBlength) == %ld (expected 0)",
FIELD_OFFSET(DCB, DCBlength)); /* DWORD */
ok(FIELD_OFFSET(DCB, BaudRate) == 4,
"FIELD_OFFSET(DCB, BaudRate) == %ld (expected 4)",
FIELD_OFFSET(DCB, BaudRate)); /* DWORD */
ok(FIELD_OFFSET(DCB, wReserved) == 12,
"FIELD_OFFSET(DCB, wReserved) == %ld (expected 12)",
FIELD_OFFSET(DCB, wReserved)); /* WORD */
ok(FIELD_OFFSET(DCB, XonLim) == 14,
"FIELD_OFFSET(DCB, XonLim) == %ld (expected 14)",
FIELD_OFFSET(DCB, XonLim)); /* WORD */
ok(FIELD_OFFSET(DCB, XoffLim) == 16,
"FIELD_OFFSET(DCB, XoffLim) == %ld (expected 16)",
FIELD_OFFSET(DCB, XoffLim)); /* WORD */
ok(FIELD_OFFSET(DCB, ByteSize) == 18,
"FIELD_OFFSET(DCB, ByteSize) == %ld (expected 18)",
FIELD_OFFSET(DCB, ByteSize)); /* BYTE */
ok(FIELD_OFFSET(DCB, Parity) == 19,
"FIELD_OFFSET(DCB, Parity) == %ld (expected 19)",
FIELD_OFFSET(DCB, Parity)); /* BYTE */
ok(FIELD_OFFSET(DCB, StopBits) == 20,
"FIELD_OFFSET(DCB, StopBits) == %ld (expected 20)",
FIELD_OFFSET(DCB, StopBits)); /* BYTE */
ok(FIELD_OFFSET(DCB, XonChar) == 21,
"FIELD_OFFSET(DCB, XonChar) == %ld (expected 21)",
FIELD_OFFSET(DCB, XonChar)); /* char */
ok(FIELD_OFFSET(DCB, XoffChar) == 22,
"FIELD_OFFSET(DCB, XoffChar) == %ld (expected 22)",
FIELD_OFFSET(DCB, XoffChar)); /* char */
ok(FIELD_OFFSET(DCB, ErrorChar) == 23,
"FIELD_OFFSET(DCB, ErrorChar) == %ld (expected 23)",
FIELD_OFFSET(DCB, ErrorChar)); /* char */
ok(FIELD_OFFSET(DCB, EofChar) == 24,
"FIELD_OFFSET(DCB, EofChar) == %ld (expected 24)",
FIELD_OFFSET(DCB, EofChar)); /* char */
ok(FIELD_OFFSET(DCB, EvtChar) == 25,
"FIELD_OFFSET(DCB, EvtChar) == %ld (expected 25)",
FIELD_OFFSET(DCB, EvtChar)); /* char */
ok(sizeof(DCB) == 28, "sizeof(DCB) == %d (expected 28)", sizeof(DCB));
/* EXCEPTION_DEBUG_INFO */
ok(FIELD_OFFSET(EXCEPTION_DEBUG_INFO, ExceptionRecord) == 0,
"FIELD_OFFSET(EXCEPTION_DEBUG_INFO, ExceptionRecord) == %ld (expected 0)",
FIELD_OFFSET(EXCEPTION_DEBUG_INFO, ExceptionRecord)); /* EXCEPTION_RECORD */
ok(FIELD_OFFSET(EXCEPTION_DEBUG_INFO, dwFirstChance) == 80,
"FIELD_OFFSET(EXCEPTION_DEBUG_INFO, dwFirstChance) == %ld (expected 80)",
FIELD_OFFSET(EXCEPTION_DEBUG_INFO, dwFirstChance)); /* DWORD */
ok(sizeof(EXCEPTION_DEBUG_INFO) == 84, "sizeof(EXCEPTION_DEBUG_INFO) == %d (expected 84)", sizeof(EXCEPTION_DEBUG_INFO));
/* EXIT_PROCESS_DEBUG_INFO */
ok(FIELD_OFFSET(EXIT_PROCESS_DEBUG_INFO, dwExitCode) == 0,
"FIELD_OFFSET(EXIT_PROCESS_DEBUG_INFO, dwExitCode) == %ld (expected 0)",
FIELD_OFFSET(EXIT_PROCESS_DEBUG_INFO, dwExitCode)); /* DWORD */
ok(sizeof(EXIT_PROCESS_DEBUG_INFO) == 4, "sizeof(EXIT_PROCESS_DEBUG_INFO) == %d (expected 4)", sizeof(EXIT_PROCESS_DEBUG_INFO));
/* EXIT_THREAD_DEBUG_INFO */
ok(FIELD_OFFSET(EXIT_THREAD_DEBUG_INFO, dwExitCode) == 0,
"FIELD_OFFSET(EXIT_THREAD_DEBUG_INFO, dwExitCode) == %ld (expected 0)",
FIELD_OFFSET(EXIT_THREAD_DEBUG_INFO, dwExitCode)); /* DWORD */
ok(sizeof(EXIT_THREAD_DEBUG_INFO) == 4, "sizeof(EXIT_THREAD_DEBUG_INFO) == %d (expected 4)", sizeof(EXIT_THREAD_DEBUG_INFO));
/* LDT_ENTRY */
ok(FIELD_OFFSET(LDT_ENTRY, LimitLow) == 0,
"FIELD_OFFSET(LDT_ENTRY, LimitLow) == %ld (expected 0)",
FIELD_OFFSET(LDT_ENTRY, LimitLow)); /* WORD */
ok(FIELD_OFFSET(LDT_ENTRY, BaseLow) == 2,
"FIELD_OFFSET(LDT_ENTRY, BaseLow) == %ld (expected 2)",
FIELD_OFFSET(LDT_ENTRY, BaseLow)); /* WORD */
ok(sizeof(LDT_ENTRY) == 8, "sizeof(LDT_ENTRY) == %d (expected 8)", sizeof(LDT_ENTRY));
/* LOAD_DLL_DEBUG_INFO */
ok(FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, hFile) == 0,
"FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, hFile) == %ld (expected 0)",
FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, hFile)); /* HANDLE */
ok(FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, lpBaseOfDll) == 4,
"FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, lpBaseOfDll) == %ld (expected 4)",
FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, lpBaseOfDll)); /* LPVOID */
ok(FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, dwDebugInfoFileOffset) == 8,
"FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, dwDebugInfoFileOffset) == %ld (expected 8)",
FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, dwDebugInfoFileOffset)); /* DWORD */
ok(FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, nDebugInfoSize) == 12,
"FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, nDebugInfoSize) == %ld (expected 12)",
FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, nDebugInfoSize)); /* DWORD */
ok(FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, lpImageName) == 16,
"FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, lpImageName) == %ld (expected 16)",
FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, lpImageName)); /* LPVOID */
ok(FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, fUnicode) == 20,
"FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, fUnicode) == %ld (expected 20)",
FIELD_OFFSET(LOAD_DLL_DEBUG_INFO, fUnicode)); /* WORD */
ok(sizeof(LOAD_DLL_DEBUG_INFO) == 24, "sizeof(LOAD_DLL_DEBUG_INFO) == %d (expected 24)", sizeof(LOAD_DLL_DEBUG_INFO));
/* MEMORYSTATUS */
ok(FIELD_OFFSET(MEMORYSTATUS, dwLength) == 0,
"FIELD_OFFSET(MEMORYSTATUS, dwLength) == %ld (expected 0)",
FIELD_OFFSET(MEMORYSTATUS, dwLength)); /* DWORD */
ok(FIELD_OFFSET(MEMORYSTATUS, dwMemoryLoad) == 4,
"FIELD_OFFSET(MEMORYSTATUS, dwMemoryLoad) == %ld (expected 4)",
FIELD_OFFSET(MEMORYSTATUS, dwMemoryLoad)); /* DWORD */
ok(FIELD_OFFSET(MEMORYSTATUS, dwTotalPhys) == 8,
"FIELD_OFFSET(MEMORYSTATUS, dwTotalPhys) == %ld (expected 8)",
FIELD_OFFSET(MEMORYSTATUS, dwTotalPhys)); /* SIZE_T */
ok(FIELD_OFFSET(MEMORYSTATUS, dwAvailPhys) == 12,
"FIELD_OFFSET(MEMORYSTATUS, dwAvailPhys) == %ld (expected 12)",
FIELD_OFFSET(MEMORYSTATUS, dwAvailPhys)); /* SIZE_T */
ok(FIELD_OFFSET(MEMORYSTATUS, dwTotalPageFile) == 16,
"FIELD_OFFSET(MEMORYSTATUS, dwTotalPageFile) == %ld (expected 16)",
FIELD_OFFSET(MEMORYSTATUS, dwTotalPageFile)); /* SIZE_T */
ok(FIELD_OFFSET(MEMORYSTATUS, dwAvailPageFile) == 20,
"FIELD_OFFSET(MEMORYSTATUS, dwAvailPageFile) == %ld (expected 20)",
FIELD_OFFSET(MEMORYSTATUS, dwAvailPageFile)); /* SIZE_T */
ok(FIELD_OFFSET(MEMORYSTATUS, dwTotalVirtual) == 24,
"FIELD_OFFSET(MEMORYSTATUS, dwTotalVirtual) == %ld (expected 24)",
FIELD_OFFSET(MEMORYSTATUS, dwTotalVirtual)); /* SIZE_T */
ok(FIELD_OFFSET(MEMORYSTATUS, dwAvailVirtual) == 28,
"FIELD_OFFSET(MEMORYSTATUS, dwAvailVirtual) == %ld (expected 28)",
FIELD_OFFSET(MEMORYSTATUS, dwAvailVirtual)); /* SIZE_T */
ok(sizeof(MEMORYSTATUS) == 32, "sizeof(MEMORYSTATUS) == %d (expected 32)", sizeof(MEMORYSTATUS));
/* OSVERSIONINFOA */
ok(FIELD_OFFSET(OSVERSIONINFOA, dwOSVersionInfoSize) == 0,
"FIELD_OFFSET(OSVERSIONINFOA, dwOSVersionInfoSize) == %ld (expected 0)",
FIELD_OFFSET(OSVERSIONINFOA, dwOSVersionInfoSize)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOA, dwMajorVersion) == 4,
"FIELD_OFFSET(OSVERSIONINFOA, dwMajorVersion) == %ld (expected 4)",
FIELD_OFFSET(OSVERSIONINFOA, dwMajorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOA, dwMinorVersion) == 8,
"FIELD_OFFSET(OSVERSIONINFOA, dwMinorVersion) == %ld (expected 8)",
FIELD_OFFSET(OSVERSIONINFOA, dwMinorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOA, dwBuildNumber) == 12,
"FIELD_OFFSET(OSVERSIONINFOA, dwBuildNumber) == %ld (expected 12)",
FIELD_OFFSET(OSVERSIONINFOA, dwBuildNumber)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOA, dwPlatformId) == 16,
"FIELD_OFFSET(OSVERSIONINFOA, dwPlatformId) == %ld (expected 16)",
FIELD_OFFSET(OSVERSIONINFOA, dwPlatformId)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOA, szCSDVersion) == 20,
"FIELD_OFFSET(OSVERSIONINFOA, szCSDVersion) == %ld (expected 20)",
FIELD_OFFSET(OSVERSIONINFOA, szCSDVersion)); /* CHAR[128] */
ok(sizeof(OSVERSIONINFOA) == 148, "sizeof(OSVERSIONINFOA) == %d (expected 148)", sizeof(OSVERSIONINFOA));
/* OSVERSIONINFOEXA */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, dwOSVersionInfoSize) == 0,
"FIELD_OFFSET(OSVERSIONINFOEXA, dwOSVersionInfoSize) == %ld (expected 0)",
FIELD_OFFSET(OSVERSIONINFOEXA, dwOSVersionInfoSize)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, dwMajorVersion) == 4,
"FIELD_OFFSET(OSVERSIONINFOEXA, dwMajorVersion) == %ld (expected 4)",
FIELD_OFFSET(OSVERSIONINFOEXA, dwMajorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, dwMinorVersion) == 8,
"FIELD_OFFSET(OSVERSIONINFOEXA, dwMinorVersion) == %ld (expected 8)",
FIELD_OFFSET(OSVERSIONINFOEXA, dwMinorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, dwBuildNumber) == 12,
"FIELD_OFFSET(OSVERSIONINFOEXA, dwBuildNumber) == %ld (expected 12)",
FIELD_OFFSET(OSVERSIONINFOEXA, dwBuildNumber)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, dwPlatformId) == 16,
"FIELD_OFFSET(OSVERSIONINFOEXA, dwPlatformId) == %ld (expected 16)",
FIELD_OFFSET(OSVERSIONINFOEXA, dwPlatformId)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, szCSDVersion) == 20,
"FIELD_OFFSET(OSVERSIONINFOEXA, szCSDVersion) == %ld (expected 20)",
FIELD_OFFSET(OSVERSIONINFOEXA, szCSDVersion)); /* CHAR[128] */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, wServicePackMajor) == 148,
"FIELD_OFFSET(OSVERSIONINFOEXA, wServicePackMajor) == %ld (expected 148)",
FIELD_OFFSET(OSVERSIONINFOEXA, wServicePackMajor)); /* WORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, wServicePackMinor) == 150,
"FIELD_OFFSET(OSVERSIONINFOEXA, wServicePackMinor) == %ld (expected 150)",
FIELD_OFFSET(OSVERSIONINFOEXA, wServicePackMinor)); /* WORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, wSuiteMask) == 152,
"FIELD_OFFSET(OSVERSIONINFOEXA, wSuiteMask) == %ld (expected 152)",
FIELD_OFFSET(OSVERSIONINFOEXA, wSuiteMask)); /* WORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, wProductType) == 154,
"FIELD_OFFSET(OSVERSIONINFOEXA, wProductType) == %ld (expected 154)",
FIELD_OFFSET(OSVERSIONINFOEXA, wProductType)); /* BYTE */
ok(FIELD_OFFSET(OSVERSIONINFOEXA, wReserved) == 155,
"FIELD_OFFSET(OSVERSIONINFOEXA, wReserved) == %ld (expected 155)",
FIELD_OFFSET(OSVERSIONINFOEXA, wReserved)); /* BYTE */
ok(sizeof(OSVERSIONINFOEXA) == 156, "sizeof(OSVERSIONINFOEXA) == %d (expected 156)", sizeof(OSVERSIONINFOEXA));
/* OSVERSIONINFOEXW */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, dwOSVersionInfoSize) == 0,
"FIELD_OFFSET(OSVERSIONINFOEXW, dwOSVersionInfoSize) == %ld (expected 0)",
FIELD_OFFSET(OSVERSIONINFOEXW, dwOSVersionInfoSize)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, dwMajorVersion) == 4,
"FIELD_OFFSET(OSVERSIONINFOEXW, dwMajorVersion) == %ld (expected 4)",
FIELD_OFFSET(OSVERSIONINFOEXW, dwMajorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, dwMinorVersion) == 8,
"FIELD_OFFSET(OSVERSIONINFOEXW, dwMinorVersion) == %ld (expected 8)",
FIELD_OFFSET(OSVERSIONINFOEXW, dwMinorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, dwBuildNumber) == 12,
"FIELD_OFFSET(OSVERSIONINFOEXW, dwBuildNumber) == %ld (expected 12)",
FIELD_OFFSET(OSVERSIONINFOEXW, dwBuildNumber)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, dwPlatformId) == 16,
"FIELD_OFFSET(OSVERSIONINFOEXW, dwPlatformId) == %ld (expected 16)",
FIELD_OFFSET(OSVERSIONINFOEXW, dwPlatformId)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, szCSDVersion) == 20,
"FIELD_OFFSET(OSVERSIONINFOEXW, szCSDVersion) == %ld (expected 20)",
FIELD_OFFSET(OSVERSIONINFOEXW, szCSDVersion)); /* WCHAR[128] */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, wServicePackMajor) == 276,
"FIELD_OFFSET(OSVERSIONINFOEXW, wServicePackMajor) == %ld (expected 276)",
FIELD_OFFSET(OSVERSIONINFOEXW, wServicePackMajor)); /* WORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, wServicePackMinor) == 278,
"FIELD_OFFSET(OSVERSIONINFOEXW, wServicePackMinor) == %ld (expected 278)",
FIELD_OFFSET(OSVERSIONINFOEXW, wServicePackMinor)); /* WORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, wSuiteMask) == 280,
"FIELD_OFFSET(OSVERSIONINFOEXW, wSuiteMask) == %ld (expected 280)",
FIELD_OFFSET(OSVERSIONINFOEXW, wSuiteMask)); /* WORD */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, wProductType) == 282,
"FIELD_OFFSET(OSVERSIONINFOEXW, wProductType) == %ld (expected 282)",
FIELD_OFFSET(OSVERSIONINFOEXW, wProductType)); /* BYTE */
ok(FIELD_OFFSET(OSVERSIONINFOEXW, wReserved) == 283,
"FIELD_OFFSET(OSVERSIONINFOEXW, wReserved) == %ld (expected 283)",
FIELD_OFFSET(OSVERSIONINFOEXW, wReserved)); /* BYTE */
ok(sizeof(OSVERSIONINFOEXW) == 284, "sizeof(OSVERSIONINFOEXW) == %d (expected 284)", sizeof(OSVERSIONINFOEXW));
/* OSVERSIONINFOW */
ok(FIELD_OFFSET(OSVERSIONINFOW, dwOSVersionInfoSize) == 0,
"FIELD_OFFSET(OSVERSIONINFOW, dwOSVersionInfoSize) == %ld (expected 0)",
FIELD_OFFSET(OSVERSIONINFOW, dwOSVersionInfoSize)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOW, dwMajorVersion) == 4,
"FIELD_OFFSET(OSVERSIONINFOW, dwMajorVersion) == %ld (expected 4)",
FIELD_OFFSET(OSVERSIONINFOW, dwMajorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOW, dwMinorVersion) == 8,
"FIELD_OFFSET(OSVERSIONINFOW, dwMinorVersion) == %ld (expected 8)",
FIELD_OFFSET(OSVERSIONINFOW, dwMinorVersion)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOW, dwBuildNumber) == 12,
"FIELD_OFFSET(OSVERSIONINFOW, dwBuildNumber) == %ld (expected 12)",
FIELD_OFFSET(OSVERSIONINFOW, dwBuildNumber)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOW, dwPlatformId) == 16,
"FIELD_OFFSET(OSVERSIONINFOW, dwPlatformId) == %ld (expected 16)",
FIELD_OFFSET(OSVERSIONINFOW, dwPlatformId)); /* DWORD */
ok(FIELD_OFFSET(OSVERSIONINFOW, szCSDVersion) == 20,
"FIELD_OFFSET(OSVERSIONINFOW, szCSDVersion) == %ld (expected 20)",
FIELD_OFFSET(OSVERSIONINFOW, szCSDVersion)); /* WCHAR[128] */
ok(sizeof(OSVERSIONINFOW) == 276, "sizeof(OSVERSIONINFOW) == %d (expected 276)", sizeof(OSVERSIONINFOW));
/* OUTPUT_DEBUG_STRING_INFO */
ok(FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, lpDebugStringData) == 0,
"FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, lpDebugStringData) == %ld (expected 0)",
FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, lpDebugStringData)); /* LPSTR */
ok(FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, fUnicode) == 4,
"FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, fUnicode) == %ld (expected 4)",
FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, fUnicode)); /* WORD */
ok(FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, nDebugStringLength) == 6,
"FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, nDebugStringLength) == %ld (expected 6)",
FIELD_OFFSET(OUTPUT_DEBUG_STRING_INFO, nDebugStringLength)); /* WORD */
ok(sizeof(OUTPUT_DEBUG_STRING_INFO) == 8, "sizeof(OUTPUT_DEBUG_STRING_INFO) == %d (expected 8)", sizeof(OUTPUT_DEBUG_STRING_INFO));
/* OVERLAPPED */
ok(FIELD_OFFSET(OVERLAPPED, Internal) == 0,
"FIELD_OFFSET(OVERLAPPED, Internal) == %ld (expected 0)",
FIELD_OFFSET(OVERLAPPED, Internal)); /* DWORD */
ok(FIELD_OFFSET(OVERLAPPED, InternalHigh) == 4,
"FIELD_OFFSET(OVERLAPPED, InternalHigh) == %ld (expected 4)",
FIELD_OFFSET(OVERLAPPED, InternalHigh)); /* DWORD */
ok(FIELD_OFFSET(OVERLAPPED, Offset) == 8,
"FIELD_OFFSET(OVERLAPPED, Offset) == %ld (expected 8)",
FIELD_OFFSET(OVERLAPPED, Offset)); /* DWORD */
ok(FIELD_OFFSET(OVERLAPPED, OffsetHigh) == 12,
"FIELD_OFFSET(OVERLAPPED, OffsetHigh) == %ld (expected 12)",
FIELD_OFFSET(OVERLAPPED, OffsetHigh)); /* DWORD */
ok(FIELD_OFFSET(OVERLAPPED, hEvent) == 16,
"FIELD_OFFSET(OVERLAPPED, hEvent) == %ld (expected 16)",
FIELD_OFFSET(OVERLAPPED, hEvent)); /* HANDLE */
ok(sizeof(OVERLAPPED) == 20, "sizeof(OVERLAPPED) == %d (expected 20)", sizeof(OVERLAPPED));
/* PROCESS_INFORMATION */
ok(FIELD_OFFSET(PROCESS_INFORMATION, hProcess) == 0,
"FIELD_OFFSET(PROCESS_INFORMATION, hProcess) == %ld (expected 0)",
FIELD_OFFSET(PROCESS_INFORMATION, hProcess)); /* HANDLE */
ok(FIELD_OFFSET(PROCESS_INFORMATION, hThread) == 4,
"FIELD_OFFSET(PROCESS_INFORMATION, hThread) == %ld (expected 4)",
FIELD_OFFSET(PROCESS_INFORMATION, hThread)); /* HANDLE */
ok(FIELD_OFFSET(PROCESS_INFORMATION, dwProcessId) == 8,
"FIELD_OFFSET(PROCESS_INFORMATION, dwProcessId) == %ld (expected 8)",
FIELD_OFFSET(PROCESS_INFORMATION, dwProcessId)); /* DWORD */
ok(FIELD_OFFSET(PROCESS_INFORMATION, dwThreadId) == 12,
"FIELD_OFFSET(PROCESS_INFORMATION, dwThreadId) == %ld (expected 12)",
FIELD_OFFSET(PROCESS_INFORMATION, dwThreadId)); /* DWORD */
ok(sizeof(PROCESS_INFORMATION) == 16, "sizeof(PROCESS_INFORMATION) == %d (expected 16)", sizeof(PROCESS_INFORMATION));
/* RIP_INFO */
ok(FIELD_OFFSET(RIP_INFO, dwError) == 0,
"FIELD_OFFSET(RIP_INFO, dwError) == %ld (expected 0)",
FIELD_OFFSET(RIP_INFO, dwError)); /* DWORD */
ok(FIELD_OFFSET(RIP_INFO, dwType) == 4,
"FIELD_OFFSET(RIP_INFO, dwType) == %ld (expected 4)",
FIELD_OFFSET(RIP_INFO, dwType)); /* DWORD */
ok(sizeof(RIP_INFO) == 8, "sizeof(RIP_INFO) == %d (expected 8)", sizeof(RIP_INFO));
/* SECURITY_ATTRIBUTES */
ok(FIELD_OFFSET(SECURITY_ATTRIBUTES, nLength) == 0,
"FIELD_OFFSET(SECURITY_ATTRIBUTES, nLength) == %ld (expected 0)",
FIELD_OFFSET(SECURITY_ATTRIBUTES, nLength)); /* DWORD */
ok(FIELD_OFFSET(SECURITY_ATTRIBUTES, lpSecurityDescriptor) == 4,
"FIELD_OFFSET(SECURITY_ATTRIBUTES, lpSecurityDescriptor) == %ld (expected 4)",
FIELD_OFFSET(SECURITY_ATTRIBUTES, lpSecurityDescriptor)); /* LPVOID */
ok(FIELD_OFFSET(SECURITY_ATTRIBUTES, bInheritHandle) == 8,
"FIELD_OFFSET(SECURITY_ATTRIBUTES, bInheritHandle) == %ld (expected 8)",
FIELD_OFFSET(SECURITY_ATTRIBUTES, bInheritHandle)); /* BOOL */
ok(sizeof(SECURITY_ATTRIBUTES) == 12, "sizeof(SECURITY_ATTRIBUTES) == %d (expected 12)", sizeof(SECURITY_ATTRIBUTES));
/* STARTUPINFOA */
ok(FIELD_OFFSET(STARTUPINFOA, cb) == 0,
"FIELD_OFFSET(STARTUPINFOA, cb) == %ld (expected 0)",
FIELD_OFFSET(STARTUPINFOA, cb)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, lpReserved) == 4,
"FIELD_OFFSET(STARTUPINFOA, lpReserved) == %ld (expected 4)",
FIELD_OFFSET(STARTUPINFOA, lpReserved)); /* LPSTR */
ok(FIELD_OFFSET(STARTUPINFOA, lpDesktop) == 8,
"FIELD_OFFSET(STARTUPINFOA, lpDesktop) == %ld (expected 8)",
FIELD_OFFSET(STARTUPINFOA, lpDesktop)); /* LPSTR */
ok(FIELD_OFFSET(STARTUPINFOA, lpTitle) == 12,
"FIELD_OFFSET(STARTUPINFOA, lpTitle) == %ld (expected 12)",
FIELD_OFFSET(STARTUPINFOA, lpTitle)); /* LPSTR */
ok(FIELD_OFFSET(STARTUPINFOA, dwX) == 16,
"FIELD_OFFSET(STARTUPINFOA, dwX) == %ld (expected 16)",
FIELD_OFFSET(STARTUPINFOA, dwX)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwY) == 20,
"FIELD_OFFSET(STARTUPINFOA, dwY) == %ld (expected 20)",
FIELD_OFFSET(STARTUPINFOA, dwY)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwXSize) == 24,
"FIELD_OFFSET(STARTUPINFOA, dwXSize) == %ld (expected 24)",
FIELD_OFFSET(STARTUPINFOA, dwXSize)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwYSize) == 28,
"FIELD_OFFSET(STARTUPINFOA, dwYSize) == %ld (expected 28)",
FIELD_OFFSET(STARTUPINFOA, dwYSize)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwXCountChars) == 32,
"FIELD_OFFSET(STARTUPINFOA, dwXCountChars) == %ld (expected 32)",
FIELD_OFFSET(STARTUPINFOA, dwXCountChars)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwYCountChars) == 36,
"FIELD_OFFSET(STARTUPINFOA, dwYCountChars) == %ld (expected 36)",
FIELD_OFFSET(STARTUPINFOA, dwYCountChars)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwFillAttribute) == 40,
"FIELD_OFFSET(STARTUPINFOA, dwFillAttribute) == %ld (expected 40)",
FIELD_OFFSET(STARTUPINFOA, dwFillAttribute)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, dwFlags) == 44,
"FIELD_OFFSET(STARTUPINFOA, dwFlags) == %ld (expected 44)",
FIELD_OFFSET(STARTUPINFOA, dwFlags)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOA, wShowWindow) == 48,
"FIELD_OFFSET(STARTUPINFOA, wShowWindow) == %ld (expected 48)",
FIELD_OFFSET(STARTUPINFOA, wShowWindow)); /* WORD */
ok(FIELD_OFFSET(STARTUPINFOA, cbReserved2) == 50,
"FIELD_OFFSET(STARTUPINFOA, cbReserved2) == %ld (expected 50)",
FIELD_OFFSET(STARTUPINFOA, cbReserved2)); /* WORD */
ok(FIELD_OFFSET(STARTUPINFOA, lpReserved2) == 52,
"FIELD_OFFSET(STARTUPINFOA, lpReserved2) == %ld (expected 52)",
FIELD_OFFSET(STARTUPINFOA, lpReserved2)); /* BYTE * */
ok(FIELD_OFFSET(STARTUPINFOA, hStdInput) == 56,
"FIELD_OFFSET(STARTUPINFOA, hStdInput) == %ld (expected 56)",
FIELD_OFFSET(STARTUPINFOA, hStdInput)); /* HANDLE */
ok(FIELD_OFFSET(STARTUPINFOA, hStdOutput) == 60,
"FIELD_OFFSET(STARTUPINFOA, hStdOutput) == %ld (expected 60)",
FIELD_OFFSET(STARTUPINFOA, hStdOutput)); /* HANDLE */
ok(FIELD_OFFSET(STARTUPINFOA, hStdError) == 64,
"FIELD_OFFSET(STARTUPINFOA, hStdError) == %ld (expected 64)",
FIELD_OFFSET(STARTUPINFOA, hStdError)); /* HANDLE */
ok(sizeof(STARTUPINFOA) == 68, "sizeof(STARTUPINFOA) == %d (expected 68)", sizeof(STARTUPINFOA));
/* STARTUPINFOW */
ok(FIELD_OFFSET(STARTUPINFOW, cb) == 0,
"FIELD_OFFSET(STARTUPINFOW, cb) == %ld (expected 0)",
FIELD_OFFSET(STARTUPINFOW, cb)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, lpReserved) == 4,
"FIELD_OFFSET(STARTUPINFOW, lpReserved) == %ld (expected 4)",
FIELD_OFFSET(STARTUPINFOW, lpReserved)); /* LPWSTR */
ok(FIELD_OFFSET(STARTUPINFOW, lpDesktop) == 8,
"FIELD_OFFSET(STARTUPINFOW, lpDesktop) == %ld (expected 8)",
FIELD_OFFSET(STARTUPINFOW, lpDesktop)); /* LPWSTR */
ok(FIELD_OFFSET(STARTUPINFOW, lpTitle) == 12,
"FIELD_OFFSET(STARTUPINFOW, lpTitle) == %ld (expected 12)",
FIELD_OFFSET(STARTUPINFOW, lpTitle)); /* LPWSTR */
ok(FIELD_OFFSET(STARTUPINFOW, dwX) == 16,
"FIELD_OFFSET(STARTUPINFOW, dwX) == %ld (expected 16)",
FIELD_OFFSET(STARTUPINFOW, dwX)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwY) == 20,
"FIELD_OFFSET(STARTUPINFOW, dwY) == %ld (expected 20)",
FIELD_OFFSET(STARTUPINFOW, dwY)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwXSize) == 24,
"FIELD_OFFSET(STARTUPINFOW, dwXSize) == %ld (expected 24)",
FIELD_OFFSET(STARTUPINFOW, dwXSize)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwYSize) == 28,
"FIELD_OFFSET(STARTUPINFOW, dwYSize) == %ld (expected 28)",
FIELD_OFFSET(STARTUPINFOW, dwYSize)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwXCountChars) == 32,
"FIELD_OFFSET(STARTUPINFOW, dwXCountChars) == %ld (expected 32)",
FIELD_OFFSET(STARTUPINFOW, dwXCountChars)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwYCountChars) == 36,
"FIELD_OFFSET(STARTUPINFOW, dwYCountChars) == %ld (expected 36)",
FIELD_OFFSET(STARTUPINFOW, dwYCountChars)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwFillAttribute) == 40,
"FIELD_OFFSET(STARTUPINFOW, dwFillAttribute) == %ld (expected 40)",
FIELD_OFFSET(STARTUPINFOW, dwFillAttribute)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, dwFlags) == 44,
"FIELD_OFFSET(STARTUPINFOW, dwFlags) == %ld (expected 44)",
FIELD_OFFSET(STARTUPINFOW, dwFlags)); /* DWORD */
ok(FIELD_OFFSET(STARTUPINFOW, wShowWindow) == 48,
"FIELD_OFFSET(STARTUPINFOW, wShowWindow) == %ld (expected 48)",
FIELD_OFFSET(STARTUPINFOW, wShowWindow)); /* WORD */
ok(FIELD_OFFSET(STARTUPINFOW, cbReserved2) == 50,
"FIELD_OFFSET(STARTUPINFOW, cbReserved2) == %ld (expected 50)",
FIELD_OFFSET(STARTUPINFOW, cbReserved2)); /* WORD */
ok(FIELD_OFFSET(STARTUPINFOW, lpReserved2) == 52,
"FIELD_OFFSET(STARTUPINFOW, lpReserved2) == %ld (expected 52)",
FIELD_OFFSET(STARTUPINFOW, lpReserved2)); /* BYTE * */
ok(FIELD_OFFSET(STARTUPINFOW, hStdInput) == 56,
"FIELD_OFFSET(STARTUPINFOW, hStdInput) == %ld (expected 56)",
FIELD_OFFSET(STARTUPINFOW, hStdInput)); /* HANDLE */
ok(FIELD_OFFSET(STARTUPINFOW, hStdOutput) == 60,
"FIELD_OFFSET(STARTUPINFOW, hStdOutput) == %ld (expected 60)",
FIELD_OFFSET(STARTUPINFOW, hStdOutput)); /* HANDLE */
ok(FIELD_OFFSET(STARTUPINFOW, hStdError) == 64,
"FIELD_OFFSET(STARTUPINFOW, hStdError) == %ld (expected 64)",
FIELD_OFFSET(STARTUPINFOW, hStdError)); /* HANDLE */
ok(sizeof(STARTUPINFOW) == 68, "sizeof(STARTUPINFOW) == %d (expected 68)", sizeof(STARTUPINFOW));
/* SYSLEVEL */
ok(FIELD_OFFSET(SYSLEVEL, crst) == 0,
"FIELD_OFFSET(SYSLEVEL, crst) == %ld (expected 0)",
FIELD_OFFSET(SYSLEVEL, crst)); /* CRITICAL_SECTION */
ok(FIELD_OFFSET(SYSLEVEL, level) == 24,
"FIELD_OFFSET(SYSLEVEL, level) == %ld (expected 24)",
FIELD_OFFSET(SYSLEVEL, level)); /* INT */
ok(sizeof(SYSLEVEL) == 28, "sizeof(SYSLEVEL) == %d (expected 28)", sizeof(SYSLEVEL));
/* SYSTEMTIME */
ok(FIELD_OFFSET(SYSTEMTIME, wYear) == 0,
"FIELD_OFFSET(SYSTEMTIME, wYear) == %ld (expected 0)",
FIELD_OFFSET(SYSTEMTIME, wYear)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wMonth) == 2,
"FIELD_OFFSET(SYSTEMTIME, wMonth) == %ld (expected 2)",
FIELD_OFFSET(SYSTEMTIME, wMonth)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wDayOfWeek) == 4,
"FIELD_OFFSET(SYSTEMTIME, wDayOfWeek) == %ld (expected 4)",
FIELD_OFFSET(SYSTEMTIME, wDayOfWeek)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wDay) == 6,
"FIELD_OFFSET(SYSTEMTIME, wDay) == %ld (expected 6)",
FIELD_OFFSET(SYSTEMTIME, wDay)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wHour) == 8,
"FIELD_OFFSET(SYSTEMTIME, wHour) == %ld (expected 8)",
FIELD_OFFSET(SYSTEMTIME, wHour)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wMinute) == 10,
"FIELD_OFFSET(SYSTEMTIME, wMinute) == %ld (expected 10)",
FIELD_OFFSET(SYSTEMTIME, wMinute)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wSecond) == 12,
"FIELD_OFFSET(SYSTEMTIME, wSecond) == %ld (expected 12)",
FIELD_OFFSET(SYSTEMTIME, wSecond)); /* WORD */
ok(FIELD_OFFSET(SYSTEMTIME, wMilliseconds) == 14,
"FIELD_OFFSET(SYSTEMTIME, wMilliseconds) == %ld (expected 14)",
FIELD_OFFSET(SYSTEMTIME, wMilliseconds)); /* WORD */
ok(sizeof(SYSTEMTIME) == 16, "sizeof(SYSTEMTIME) == %d (expected 16)", sizeof(SYSTEMTIME));
/* SYSTEM_INFO */
ok(FIELD_OFFSET(SYSTEM_INFO, dwPageSize) == 4,
"FIELD_OFFSET(SYSTEM_INFO, dwPageSize) == %ld (expected 4)",
FIELD_OFFSET(SYSTEM_INFO, dwPageSize)); /* DWORD */
ok(FIELD_OFFSET(SYSTEM_INFO, lpMinimumApplicationAddress) == 8,
"FIELD_OFFSET(SYSTEM_INFO, lpMinimumApplicationAddress) == %ld (expected 8)",
FIELD_OFFSET(SYSTEM_INFO, lpMinimumApplicationAddress)); /* LPVOID */
ok(FIELD_OFFSET(SYSTEM_INFO, lpMaximumApplicationAddress) == 12,
"FIELD_OFFSET(SYSTEM_INFO, lpMaximumApplicationAddress) == %ld (expected 12)",
FIELD_OFFSET(SYSTEM_INFO, lpMaximumApplicationAddress)); /* LPVOID */
ok(FIELD_OFFSET(SYSTEM_INFO, dwActiveProcessorMask) == 16,
"FIELD_OFFSET(SYSTEM_INFO, dwActiveProcessorMask) == %ld (expected 16)",
FIELD_OFFSET(SYSTEM_INFO, dwActiveProcessorMask)); /* DWORD */
ok(FIELD_OFFSET(SYSTEM_INFO, dwNumberOfProcessors) == 20,
"FIELD_OFFSET(SYSTEM_INFO, dwNumberOfProcessors) == %ld (expected 20)",
FIELD_OFFSET(SYSTEM_INFO, dwNumberOfProcessors)); /* DWORD */
ok(FIELD_OFFSET(SYSTEM_INFO, dwProcessorType) == 24,
"FIELD_OFFSET(SYSTEM_INFO, dwProcessorType) == %ld (expected 24)",
FIELD_OFFSET(SYSTEM_INFO, dwProcessorType)); /* DWORD */
ok(FIELD_OFFSET(SYSTEM_INFO, dwAllocationGranularity) == 28,
"FIELD_OFFSET(SYSTEM_INFO, dwAllocationGranularity) == %ld (expected 28)",
FIELD_OFFSET(SYSTEM_INFO, dwAllocationGranularity)); /* DWORD */
ok(FIELD_OFFSET(SYSTEM_INFO, wProcessorLevel) == 32,
"FIELD_OFFSET(SYSTEM_INFO, wProcessorLevel) == %ld (expected 32)",
FIELD_OFFSET(SYSTEM_INFO, wProcessorLevel)); /* WORD */
ok(FIELD_OFFSET(SYSTEM_INFO, wProcessorRevision) == 34,
"FIELD_OFFSET(SYSTEM_INFO, wProcessorRevision) == %ld (expected 34)",
FIELD_OFFSET(SYSTEM_INFO, wProcessorRevision)); /* WORD */
ok(sizeof(SYSTEM_INFO) == 36, "sizeof(SYSTEM_INFO) == %d (expected 36)", sizeof(SYSTEM_INFO));
/* SYSTEM_POWER_STATUS */
ok(FIELD_OFFSET(SYSTEM_POWER_STATUS, ACLineStatus) == 0,
"FIELD_OFFSET(SYSTEM_POWER_STATUS, ACLineStatus) == %ld (expected 0)",
FIELD_OFFSET(SYSTEM_POWER_STATUS, ACLineStatus)); /* BYTE */
ok(FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryFlag) == 1,
"FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryFlag) == %ld (expected 1)",
FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryFlag)); /* BYTE */
ok(FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryLifePercent) == 2,
"FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryLifePercent) == %ld (expected 2)",
FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryLifePercent)); /* BYTE */
ok(FIELD_OFFSET(SYSTEM_POWER_STATUS, reserved) == 3,
"FIELD_OFFSET(SYSTEM_POWER_STATUS, reserved) == %ld (expected 3)",
FIELD_OFFSET(SYSTEM_POWER_STATUS, reserved)); /* BYTE */
ok(FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryLifeTime) == 4,
"FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryLifeTime) == %ld (expected 4)",
FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryLifeTime)); /* DWORD */
ok(FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryFullLifeTime) == 8,
"FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryFullLifeTime) == %ld (expected 8)",
FIELD_OFFSET(SYSTEM_POWER_STATUS, BatteryFullLifeTime)); /* DWORD */
ok(sizeof(SYSTEM_POWER_STATUS) == 12, "sizeof(SYSTEM_POWER_STATUS) == %d (expected 12)", sizeof(SYSTEM_POWER_STATUS));
/* TIME_ZONE_INFORMATION */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, Bias) == 0,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, Bias) == %ld (expected 0)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, Bias)); /* LONG */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardName) == 4,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardName) == %ld (expected 4)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardName)); /* WCHAR[32] */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardDate) == 68,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardDate) == %ld (expected 68)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardDate)); /* SYSTEMTIME */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardBias) == 84,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardBias) == %ld (expected 84)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, StandardBias)); /* LONG */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightName) == 88,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightName) == %ld (expected 88)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightName)); /* WCHAR[32] */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightDate) == 152,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightDate) == %ld (expected 152)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightDate)); /* SYSTEMTIME */
ok(FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightBias) == 168,
"FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightBias) == %ld (expected 168)",
FIELD_OFFSET(TIME_ZONE_INFORMATION, DaylightBias)); /* LONG */
ok(sizeof(TIME_ZONE_INFORMATION) == 172, "sizeof(TIME_ZONE_INFORMATION) == %d (expected 172)", sizeof(TIME_ZONE_INFORMATION));
/* UNLOAD_DLL_DEBUG_INFO */
ok(FIELD_OFFSET(UNLOAD_DLL_DEBUG_INFO, lpBaseOfDll) == 0,
"FIELD_OFFSET(UNLOAD_DLL_DEBUG_INFO, lpBaseOfDll) == %ld (expected 0)",
FIELD_OFFSET(UNLOAD_DLL_DEBUG_INFO, lpBaseOfDll)); /* LPVOID */
ok(sizeof(UNLOAD_DLL_DEBUG_INFO) == 4, "sizeof(UNLOAD_DLL_DEBUG_INFO) == %d (expected 4)", sizeof(UNLOAD_DLL_DEBUG_INFO));
/* WIN32_FILE_ATTRIBUTE_DATA */
ok(FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, dwFileAttributes) == 0,
"FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, dwFileAttributes) == %ld (expected 0)",
FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, dwFileAttributes)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftCreationTime) == 4,
"FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftCreationTime) == %ld (expected 4)",
FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftCreationTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftLastAccessTime) == 12,
"FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftLastAccessTime) == %ld (expected 12)",
FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftLastAccessTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftLastWriteTime) == 20,
"FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftLastWriteTime) == %ld (expected 20)",
FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, ftLastWriteTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeHigh) == 28,
"FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeHigh) == %ld (expected 28)",
FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeHigh)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeLow) == 32,
"FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeLow) == %ld (expected 32)",
FIELD_OFFSET(WIN32_FILE_ATTRIBUTE_DATA, nFileSizeLow)); /* DWORD */
ok(sizeof(WIN32_FILE_ATTRIBUTE_DATA) == 36, "sizeof(WIN32_FILE_ATTRIBUTE_DATA) == %d (expected 36)", sizeof(WIN32_FILE_ATTRIBUTE_DATA));
/* WIN32_FIND_DATAA */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, dwFileAttributes) == 0,
"FIELD_OFFSET(WIN32_FIND_DATAA, dwFileAttributes) == %ld (expected 0)",
FIELD_OFFSET(WIN32_FIND_DATAA, dwFileAttributes)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, ftCreationTime) == 4,
"FIELD_OFFSET(WIN32_FIND_DATAA, ftCreationTime) == %ld (expected 4)",
FIELD_OFFSET(WIN32_FIND_DATAA, ftCreationTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, ftLastAccessTime) == 12,
"FIELD_OFFSET(WIN32_FIND_DATAA, ftLastAccessTime) == %ld (expected 12)",
FIELD_OFFSET(WIN32_FIND_DATAA, ftLastAccessTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, ftLastWriteTime) == 20,
"FIELD_OFFSET(WIN32_FIND_DATAA, ftLastWriteTime) == %ld (expected 20)",
FIELD_OFFSET(WIN32_FIND_DATAA, ftLastWriteTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, nFileSizeHigh) == 28,
"FIELD_OFFSET(WIN32_FIND_DATAA, nFileSizeHigh) == %ld (expected 28)",
FIELD_OFFSET(WIN32_FIND_DATAA, nFileSizeHigh)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, nFileSizeLow) == 32,
"FIELD_OFFSET(WIN32_FIND_DATAA, nFileSizeLow) == %ld (expected 32)",
FIELD_OFFSET(WIN32_FIND_DATAA, nFileSizeLow)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, dwReserved0) == 36,
"FIELD_OFFSET(WIN32_FIND_DATAA, dwReserved0) == %ld (expected 36)",
FIELD_OFFSET(WIN32_FIND_DATAA, dwReserved0)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, dwReserved1) == 40,
"FIELD_OFFSET(WIN32_FIND_DATAA, dwReserved1) == %ld (expected 40)",
FIELD_OFFSET(WIN32_FIND_DATAA, dwReserved1)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, cFileName) == 44,
"FIELD_OFFSET(WIN32_FIND_DATAA, cFileName) == %ld (expected 44)",
FIELD_OFFSET(WIN32_FIND_DATAA, cFileName)); /* CHAR[260] */
ok(FIELD_OFFSET(WIN32_FIND_DATAA, cAlternateFileName) == 304,
"FIELD_OFFSET(WIN32_FIND_DATAA, cAlternateFileName) == %ld (expected 304)",
FIELD_OFFSET(WIN32_FIND_DATAA, cAlternateFileName)); /* CHAR[14] */
ok(sizeof(WIN32_FIND_DATAA) == 320, "sizeof(WIN32_FIND_DATAA) == %d (expected 320)", sizeof(WIN32_FIND_DATAA));
/* WIN32_FIND_DATAW */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, dwFileAttributes) == 0,
"FIELD_OFFSET(WIN32_FIND_DATAW, dwFileAttributes) == %ld (expected 0)",
FIELD_OFFSET(WIN32_FIND_DATAW, dwFileAttributes)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, ftCreationTime) == 4,
"FIELD_OFFSET(WIN32_FIND_DATAW, ftCreationTime) == %ld (expected 4)",
FIELD_OFFSET(WIN32_FIND_DATAW, ftCreationTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, ftLastAccessTime) == 12,
"FIELD_OFFSET(WIN32_FIND_DATAW, ftLastAccessTime) == %ld (expected 12)",
FIELD_OFFSET(WIN32_FIND_DATAW, ftLastAccessTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, ftLastWriteTime) == 20,
"FIELD_OFFSET(WIN32_FIND_DATAW, ftLastWriteTime) == %ld (expected 20)",
FIELD_OFFSET(WIN32_FIND_DATAW, ftLastWriteTime)); /* FILETIME */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, nFileSizeHigh) == 28,
"FIELD_OFFSET(WIN32_FIND_DATAW, nFileSizeHigh) == %ld (expected 28)",
FIELD_OFFSET(WIN32_FIND_DATAW, nFileSizeHigh)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, nFileSizeLow) == 32,
"FIELD_OFFSET(WIN32_FIND_DATAW, nFileSizeLow) == %ld (expected 32)",
FIELD_OFFSET(WIN32_FIND_DATAW, nFileSizeLow)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, dwReserved0) == 36,
"FIELD_OFFSET(WIN32_FIND_DATAW, dwReserved0) == %ld (expected 36)",
FIELD_OFFSET(WIN32_FIND_DATAW, dwReserved0)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, dwReserved1) == 40,
"FIELD_OFFSET(WIN32_FIND_DATAW, dwReserved1) == %ld (expected 40)",
FIELD_OFFSET(WIN32_FIND_DATAW, dwReserved1)); /* DWORD */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, cFileName) == 44,
"FIELD_OFFSET(WIN32_FIND_DATAW, cFileName) == %ld (expected 44)",
FIELD_OFFSET(WIN32_FIND_DATAW, cFileName)); /* WCHAR[260] */
ok(FIELD_OFFSET(WIN32_FIND_DATAW, cAlternateFileName) == 564,
"FIELD_OFFSET(WIN32_FIND_DATAW, cAlternateFileName) == %ld (expected 564)",
FIELD_OFFSET(WIN32_FIND_DATAW, cAlternateFileName)); /* WCHAR[14] */
ok(sizeof(WIN32_FIND_DATAW) == 592, "sizeof(WIN32_FIND_DATAW) == %d (expected 592)", sizeof(WIN32_FIND_DATAW));
/* WIN32_STREAM_ID */
ok(FIELD_OFFSET(WIN32_STREAM_ID, dwStreamID) == 0,
"FIELD_OFFSET(WIN32_STREAM_ID, dwStreamID) == %ld (expected 0)",
FIELD_OFFSET(WIN32_STREAM_ID, dwStreamID)); /* DWORD */
ok(FIELD_OFFSET(WIN32_STREAM_ID, dwStreamAttributes) == 4,
"FIELD_OFFSET(WIN32_STREAM_ID, dwStreamAttributes) == %ld (expected 4)",
FIELD_OFFSET(WIN32_STREAM_ID, dwStreamAttributes)); /* DWORD */
ok(FIELD_OFFSET(WIN32_STREAM_ID, Size) == 8,
"FIELD_OFFSET(WIN32_STREAM_ID, Size) == %ld (expected 8)",
FIELD_OFFSET(WIN32_STREAM_ID, Size)); /* LARGE_INTEGER */
ok(FIELD_OFFSET(WIN32_STREAM_ID, dwStreamNameSize) == 16,
"FIELD_OFFSET(WIN32_STREAM_ID, dwStreamNameSize) == %ld (expected 16)",
FIELD_OFFSET(WIN32_STREAM_ID, dwStreamNameSize)); /* DWORD */
ok(FIELD_OFFSET(WIN32_STREAM_ID, cStreamName) == 20,
"FIELD_OFFSET(WIN32_STREAM_ID, cStreamName) == %ld (expected 20)",
FIELD_OFFSET(WIN32_STREAM_ID, cStreamName)); /* WCHAR[ANYSIZE_ARRAY] */
ok(sizeof(WIN32_STREAM_ID) == 24, "sizeof(WIN32_STREAM_ID) == %d (expected 24)", sizeof(WIN32_STREAM_ID));
/* 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);
/* 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);
/* 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);
/* 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);
/* COMSTAT (pack 4) */
TEST_TYPE(COMSTAT, 12, 4);
TEST_FIELD(COMSTAT, DWORD, status, 0, 4, 4);
TEST_FIELD(COMSTAT, DWORD, cbInQue, 4, 4, 4);
TEST_FIELD(COMSTAT, DWORD, cbOutQue, 8, 4, 4);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* LDT_ENTRY (pack 4) */
TEST_FIELD(LDT_ENTRY, WORD, LimitLow, 0, 2, 2);
TEST_FIELD(LDT_ENTRY, WORD, BaseLow, 2, 2, 2);
/* 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);
/* 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);
/* 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, BYTE[4], reserved, 4, 4, 1);
TEST_FIELD(OFSTRUCT, BYTE[OFS_MAXPATHNAME], szPathName, 8, 128, 1);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* OVERLAPPED (pack 4) */
TEST_TYPE(OVERLAPPED, 20, 4);
TEST_FIELD(OVERLAPPED, DWORD, Internal, 0, 4, 4);
TEST_FIELD(OVERLAPPED, DWORD, InternalHigh, 4, 4, 4);
TEST_FIELD(OVERLAPPED, DWORD, Offset, 8, 4, 4);
TEST_FIELD(OVERLAPPED, DWORD, OffsetHigh, 12, 4, 4);
TEST_FIELD(OVERLAPPED, HANDLE, hEvent, 16, 4, 4);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* SYSLEVEL (pack 4) */
TEST_TYPE(SYSLEVEL, 28, 4);
TEST_FIELD(SYSLEVEL, CRITICAL_SECTION, crst, 0, 24, 4);
TEST_FIELD(SYSLEVEL, INT, level, 24, 4, 4);
/* 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);
/* 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, reserved, 3, 1, 1);
TEST_FIELD(SYSTEM_POWER_STATUS, DWORD, BatteryLifeTime, 4, 4, 4);
TEST_FIELD(SYSTEM_POWER_STATUS, DWORD, BatteryFullLifeTime, 8, 4, 4);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* WIN32_STREAM_ID (pack 4) */
TEST_TYPE(WIN32_STREAM_ID, 24, 4);
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, 4);
TEST_FIELD(WIN32_STREAM_ID, DWORD, dwStreamNameSize, 16, 4, 4);
TEST_FIELD(WIN32_STREAM_ID, WCHAR[ANYSIZE_ARRAY], cStreamName, 20, 2, 2);
}
......
dlls/ntdll/tests/.cvsignore
View file @ ebf582cd
Makefile
error.ok
generated.ok
ntdll_test.exe.spec.c
rtlbitmap.ok
testlist.c
dlls/ntdll/tests/Makefile.in
View file @ ebf582cd
......@@ -7,6 +7,7 @@ IMPORTS = ntdll
CTESTS = \
error.c \
generated.c \
rtlbitmap.c
@MAKE_TEST_RULES@
......
dlls/ntdll/tests/generated.c 0 → 100644
View file @ ebf582cd
/* File generated automatically from tools/winapi/test.dat; do not edit! */
/* This file can be copied, modified and distributed without restriction. */
/*
* Unit tests for data structure packing
*/
#include <stdio.h>
#include "wine/test.h"
#include "basetsd.h"
#include "winnt.h"
#include "windef.h"
/***********************************************************************
* Windows API extension
*/
#if (_MSC_VER >= 1300) && defined(__cplusplus)
# define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
#elif defined(__GNUC__)
# define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
#else
/* FIXME: Not sure if is possible to do without compiler extension */
#endif
/***********************************************************************
* Test helper macros
*/
#ifdef FIELD_ALIGNMENT
# define TEST_FIELD_ALIGNMENT(type, field, align) \
ok(FIELD_ALIGNMENT(type, field) == align, \
"FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")", \
FIELD_ALIGNMENT(type, field))
#else
# define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
#endif
#define TEST_FIELD_OFFSET(type, field, offset) \
ok(FIELD_OFFSET(type, field) == offset, \
"FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")", \
FIELD_OFFSET(type, field))
#define TEST_TYPE_ALIGNMENT(type, align) \
ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")", TYPE_ALIGNMENT(type))
#define TEST_TYPE_SIZE(type, size) \
ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")", sizeof(type))
/***********************************************************************
* 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_TYPE(type, size, align) \
TEST_TYPE_ALIGNMENT(type, align); \
TEST_TYPE_SIZE(type, size)
void test_pack(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);
/* 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);
/* 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);
/* 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);
/* CONTEXT86 (pack 4) */
TEST_TYPE(CONTEXT86, 716, 4);
TEST_FIELD(CONTEXT86, DWORD, ContextFlags, 0, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Dr0, 4, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Dr1, 8, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Dr2, 12, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Dr3, 16, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Dr6, 20, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Dr7, 24, 4, 4);
TEST_FIELD(CONTEXT86, FLOATING_SAVE_AREA, FloatSave, 28, 112, 4);
TEST_FIELD(CONTEXT86, DWORD, SegGs, 140, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, SegFs, 144, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, SegEs, 148, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, SegDs, 152, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Edi, 156, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Esi, 160, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Ebx, 164, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Edx, 168, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Ecx, 172, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Eax, 176, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Ebp, 180, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Eip, 184, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, SegCs, 188, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, EFlags, 192, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, Esp, 196, 4, 4);
TEST_FIELD(CONTEXT86, DWORD, SegSs, 200, 4, 4);
TEST_FIELD(CONTEXT86, BYTE[MAXIMUM_SUPPORTED_EXTENSION], ExtendedRegisters, 204, 512, 1);
/* 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);
/* 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, LPVOID, ExceptionAddress, 12, 4, 4);
TEST_FIELD(EXCEPTION_RECORD, DWORD, NumberParameters, 16, 4, 4);
TEST_FIELD(EXCEPTION_RECORD, DWORD[EXCEPTION_MAXIMUM_PARAMETERS], ExceptionInformation, 20, 60, 4);
/* 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);
/* 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);
/* 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);
/* 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);
/* IMAGE_AUX_SYMBOL (pack 2) */
/* IMAGE_BASE_RELOCATION (pack 2) */
TEST_TYPE(IMAGE_BASE_RELOCATION, 8, 2);
TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, VirtualAddress, 0, 4, 2);
TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, SizeOfBlock, 4, 4, 2);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* IMAGE_DOS_HEADER (pack 4) */
TEST_TYPE(IMAGE_DOS_HEADER, 64, 4);
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, 4);
/* 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);
/* 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);
/* 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);
/* 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);
/* IMAGE_LOAD_CONFIG_DIRECTORY (pack 4) */
TEST_TYPE(IMAGE_LOAD_CONFIG_DIRECTORY, 64, 4);
TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
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[1], Reserved, 60, 4, 4);
/* IMAGE_NT_HEADERS (pack 4) */
TEST_TYPE(IMAGE_NT_HEADERS, 248, 4);
TEST_FIELD(IMAGE_NT_HEADERS, DWORD, Signature, 0, 4, 4);
TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_FILE_HEADER, FileHeader, 4, 20, 4);
TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_OPTIONAL_HEADER, OptionalHeader, 24, 224, 4);
/* IMAGE_OPTIONAL_HEADER (pack 4) */
TEST_TYPE(IMAGE_OPTIONAL_HEADER, 224, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Magic, 0, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, BYTE, MajorLinkerVersion, 2, 1, 1);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, BYTE, MinorLinkerVersion, 3, 1, 1);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfCode, 4, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfInitializedData, 8, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfUninitializedData, 12, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, AddressOfEntryPoint, 16, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, BaseOfCode, 20, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, BaseOfData, 24, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, ImageBase, 28, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SectionAlignment, 32, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, FileAlignment, 36, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorOperatingSystemVersion, 40, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorOperatingSystemVersion, 42, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorImageVersion, 44, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorImageVersion, 46, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorSubsystemVersion, 48, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorSubsystemVersion, 50, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, Win32VersionValue, 52, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfImage, 56, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeaders, 60, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, CheckSum, 64, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Subsystem, 68, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, DllCharacteristics, 70, 2, 2);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfStackReserve, 72, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfStackCommit, 76, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeapReserve, 80, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeapCommit, 84, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, LoaderFlags, 88, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, NumberOfRvaAndSizes, 92, 4, 4);
TEST_FIELD(IMAGE_OPTIONAL_HEADER, IMAGE_DATA_DIRECTORY[IMAGE_NUMBEROF_DIRECTORY_ENTRIES], DataDirectory, 96, 128, 4);
/* IMAGE_OS2_HEADER (pack 4) */
TEST_TYPE(IMAGE_OS2_HEADER, 64, 4);
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, 4);
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, 4);
TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_sssp, 24, 4, 4);
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, 4);
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, fastload_offset, 56, 2, 2);
TEST_FIELD(IMAGE_OS2_HEADER, WORD, fastload_length, 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);
/* 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, ResourceHandle, 12, 4, 4);
/* 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);
/* IMAGE_RESOURCE_DIRECTORY_ENTRY (pack 4) */
/* 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);
/* 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);
/* 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);
/* IMAGE_THUNK_DATA (pack 4) */
/* IMAGE_TLS_DIRECTORY (pack 4) */
TEST_TYPE(IMAGE_TLS_DIRECTORY, 24, 4);
TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, StartAddressOfRawData, 0, 4, 4);
TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, EndAddressOfRawData, 4, 4, 4);
TEST_FIELD(IMAGE_TLS_DIRECTORY, LPDWORD, AddressOfIndex, 8, 4, 4);
TEST_FIELD(IMAGE_TLS_DIRECTORY, PIMAGE_TLS_CALLBACK *, AddressOfCallBacks, 12, 4, 4);
TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, SizeOfZeroFill, 16, 4, 4);
TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, Characteristics, 20, 4, 4);
/* IMAGE_VXD_HEADER (pack 4) */
TEST_TYPE(IMAGE_VXD_HEADER, 196, 4);
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, 4);
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, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mflags, 16, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mpages, 20, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_startobj, 24, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_eip, 28, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_stackobj, 32, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_esp, 36, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesize, 40, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_lastpagesize, 44, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsize, 48, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsum, 52, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsize, 56, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsum, 60, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objtab, 64, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objcnt, 68, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objmap, 72, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_itermap, 76, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrctab, 80, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrccnt, 84, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_restab, 88, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_enttab, 92, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dirtab, 96, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dircnt, 100, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fpagetab, 104, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_frectab, 108, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmod, 112, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmodcnt, 116, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impproc, 120, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesum, 124, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_datapage, 128, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_preload, 132, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nrestab, 136, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_cbnrestab, 140, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nressum, 144, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_autodata, 148, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuginfo, 152, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuglen, 156, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instpreload, 160, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instdemand, 164, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_heapsize, 168, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, BYTE[12], e32_res3, 172, 12, 1);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winresoff, 184, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winreslen, 188, 4, 4);
TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_devid, 192, 2, 2);
TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_ddkver, 194, 2, 2);
/* 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);
/* LUID (pack 4) */
TEST_TYPE(LUID, 8, 4);
TEST_FIELD(LUID, DWORD, LowPart, 0, 4, 4);
TEST_FIELD(LUID, LONG, HighPart, 4, 4, 4);
/* 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);
/* 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, DWORD, 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* RTL_CRITICAL_SECTION_DEBUG (pack 4) */
TEST_TYPE(RTL_CRITICAL_SECTION_DEBUG, 32, 4);
TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, Type, 0, 2, 2);
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, DWORD[ 2 ], Spare, 24, 8, 4);
/* 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);
/* 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);
/* 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);
/* 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);
/* SID_IDENTIFIER_AUTHORITY (pack 4) */
TEST_TYPE(SID_IDENTIFIER_AUTHORITY, 6, 1);
TEST_FIELD(SID_IDENTIFIER_AUTHORITY, BYTE[6], Value, 0, 6, 1);
/* 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);
/* 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);
/* 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);
/* TOKEN_DEFAULT_DACL (pack 4) */
TEST_TYPE(TOKEN_DEFAULT_DACL, 4, 4);
TEST_FIELD(TOKEN_DEFAULT_DACL, PACL, DefaultDacl, 0, 4, 4);
/* 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);
/* TOKEN_OWNER (pack 4) */
TEST_TYPE(TOKEN_OWNER, 4, 4);
TEST_FIELD(TOKEN_OWNER, PSID, Owner, 0, 4, 4);
/* TOKEN_PRIMARY_GROUP (pack 4) */
TEST_TYPE(TOKEN_PRIMARY_GROUP, 4, 4);
TEST_FIELD(TOKEN_PRIMARY_GROUP, PSID, PrimaryGroup, 0, 4, 4);
/* 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);
/* TOKEN_SOURCE (pack 4) */
TEST_TYPE(TOKEN_SOURCE, 16, 4);
TEST_FIELD(TOKEN_SOURCE, char[8], Sourcename, 0, 8, 1);
TEST_FIELD(TOKEN_SOURCE, LUID, SourceIdentifier, 8, 8, 4);
/* TOKEN_USER (pack 4) */
TEST_TYPE(TOKEN_USER, 8, 4);
TEST_FIELD(TOKEN_USER, SID_AND_ATTRIBUTES, User, 0, 8, 4);
}
START_TEST(generated)
{
test_pack();
}
dlls/user/tests/generated.c
View file @ ebf582cd
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment