// ignore_for_file: deprecated_member_use_from_same_package

import 'package:test/test.dart';
import 'package:win32/win32.dart';
import 'package:win32/winsock2.dart';

void main() {
  test('Constants have correct values', () {
    expect(AF_INET, ADDRESS_FAMILY.AF_INET);
    expect(AF_INET6, ADDRESS_FAMILY.AF_INET6);
    expect(AF_UNSPEC, ADDRESS_FAMILY.AF_UNSPEC);
    expect(SOCK_STREAM, WINSOCK_SOCKET_TYPE.SOCK_STREAM);
    expect(SOCK_DGRAM, WINSOCK_SOCKET_TYPE.SOCK_DGRAM);
    expect(SOCK_RAW, WINSOCK_SOCKET_TYPE.SOCK_RAW);
    expect(SOCK_RDM, WINSOCK_SOCKET_TYPE.SOCK_RDM);
    expect(SOCK_SEQPACKET, WINSOCK_SOCKET_TYPE.SOCK_SEQPACKET);
    expect(FACILITY_NULL, FACILITY_CODE.FACILITY_NULL);
    expect(FACILITY_RPC, FACILITY_CODE.FACILITY_RPC);
    expect(FACILITY_DISPATCH, FACILITY_CODE.FACILITY_DISPATCH);
    expect(FACILITY_STORAGE, FACILITY_CODE.FACILITY_STORAGE);
    expect(FACILITY_ITF, FACILITY_CODE.FACILITY_ITF);
    expect(FACILITY_WIN32, FACILITY_CODE.FACILITY_WIN32);
    expect(FACILITY_WINDOWS, FACILITY_CODE.FACILITY_WINDOWS);
    expect(FACILITY_SSPI, FACILITY_CODE.FACILITY_SSPI);
    expect(FACILITY_SECURITY, FACILITY_CODE.FACILITY_SECURITY);
    expect(FACILITY_CONTROL, FACILITY_CODE.FACILITY_CONTROL);
    expect(FACILITY_CERT, FACILITY_CODE.FACILITY_CERT);
    expect(FACILITY_INTERNET, FACILITY_CODE.FACILITY_INTERNET);
    expect(CLSCTX_INPROC_SERVER, CLSCTX.CLSCTX_INPROC_SERVER);
    expect(CLSCTX_INPROC_HANDLER, CLSCTX.CLSCTX_INPROC_HANDLER);
    expect(CLSCTX_LOCAL_SERVER, CLSCTX.CLSCTX_LOCAL_SERVER);
    expect(CLSCTX_REMOTE_SERVER, CLSCTX.CLSCTX_REMOTE_SERVER);
    expect(CLSCTX_ALL, CLSCTX.CLSCTX_ALL);
    expect(COINITBASE_MULTITHREADED, COINITBASE.COINITBASE_MULTITHREADED);
    expect(COINIT_MULTITHREADED, COINIT.COINIT_MULTITHREADED);
    expect(COINIT_APARTMENTTHREADED, COINIT.COINIT_APARTMENTTHREADED);
    expect(COINIT_DISABLE_OLE1DDE, COINIT.COINIT_DISABLE_OLE1DDE);
    expect(COINIT_SPEED_OVER_MEMORY, COINIT.COINIT_SPEED_OVER_MEMORY);
    expect(PAGE_NOACCESS, PAGE_PROTECTION_FLAGS.PAGE_NOACCESS);
    expect(PAGE_READONLY, PAGE_PROTECTION_FLAGS.PAGE_READONLY);
    expect(PAGE_READWRITE, PAGE_PROTECTION_FLAGS.PAGE_READWRITE);
    expect(PAGE_WRITECOPY, PAGE_PROTECTION_FLAGS.PAGE_WRITECOPY);
    expect(PAGE_EXECUTE, PAGE_PROTECTION_FLAGS.PAGE_EXECUTE);
    expect(PAGE_EXECUTE_READ, PAGE_PROTECTION_FLAGS.PAGE_EXECUTE_READ);
    expect(
        PAGE_EXECUTE_READWRITE, PAGE_PROTECTION_FLAGS.PAGE_EXECUTE_READWRITE);
    expect(
        PAGE_EXECUTE_WRITECOPY, PAGE_PROTECTION_FLAGS.PAGE_EXECUTE_WRITECOPY);
    expect(PAGE_GUARD, PAGE_PROTECTION_FLAGS.PAGE_GUARD);
    expect(PAGE_NOCACHE, PAGE_PROTECTION_FLAGS.PAGE_NOCACHE);
    expect(PAGE_WRITECOMBINE, PAGE_PROTECTION_FLAGS.PAGE_WRITECOMBINE);
    expect(PAGE_ENCLAVE_THREAD_CONTROL,
        PAGE_PROTECTION_FLAGS.PAGE_ENCLAVE_THREAD_CONTROL);
    expect(
        PAGE_TARGETS_NO_UPDATE, PAGE_PROTECTION_FLAGS.PAGE_TARGETS_NO_UPDATE);
    expect(PAGE_TARGETS_INVALID, PAGE_PROTECTION_FLAGS.PAGE_TARGETS_INVALID);
    expect(PAGE_ENCLAVE_UNVALIDATED,
        PAGE_PROTECTION_FLAGS.PAGE_ENCLAVE_UNVALIDATED);
    expect(PAGE_ENCLAVE_DECOMMIT, PAGE_PROTECTION_FLAGS.PAGE_ENCLAVE_DECOMMIT);
    expect(DISPATCH_METHOD, DISPATCH_FLAGS.DISPATCH_METHOD);
    expect(DISPATCH_PROPERTYGET, DISPATCH_FLAGS.DISPATCH_PROPERTYGET);
    expect(DISPATCH_PROPERTYPUT, DISPATCH_FLAGS.DISPATCH_PROPERTYPUT);
    expect(DISPATCH_PROPERTYPUTREF, DISPATCH_FLAGS.DISPATCH_PROPERTYPUTREF);
    expect(ERROR_SUCCESS, WIN32_ERROR.ERROR_SUCCESS);
    expect(ERROR_INVALID_FUNCTION, WIN32_ERROR.ERROR_INVALID_FUNCTION);
    expect(ERROR_FILE_NOT_FOUND, WIN32_ERROR.ERROR_FILE_NOT_FOUND);
    expect(ERROR_PATH_NOT_FOUND, WIN32_ERROR.ERROR_PATH_NOT_FOUND);
    expect(ERROR_TOO_MANY_OPEN_FILES, WIN32_ERROR.ERROR_TOO_MANY_OPEN_FILES);
    expect(ERROR_ACCESS_DENIED, WIN32_ERROR.ERROR_ACCESS_DENIED);
    expect(ERROR_INVALID_HANDLE, WIN32_ERROR.ERROR_INVALID_HANDLE);
    expect(ERROR_ARENA_TRASHED, WIN32_ERROR.ERROR_ARENA_TRASHED);
    expect(ERROR_NOT_ENOUGH_MEMORY, WIN32_ERROR.ERROR_NOT_ENOUGH_MEMORY);
    expect(ERROR_INVALID_BLOCK, WIN32_ERROR.ERROR_INVALID_BLOCK);
    expect(ERROR_BAD_ENVIRONMENT, WIN32_ERROR.ERROR_BAD_ENVIRONMENT);
    expect(ERROR_BAD_FORMAT, WIN32_ERROR.ERROR_BAD_FORMAT);
    expect(ERROR_INVALID_ACCESS, WIN32_ERROR.ERROR_INVALID_ACCESS);
    expect(ERROR_INVALID_DATA, WIN32_ERROR.ERROR_INVALID_DATA);
    expect(ERROR_OUTOFMEMORY, WIN32_ERROR.ERROR_OUTOFMEMORY);
    expect(ERROR_INVALID_DRIVE, WIN32_ERROR.ERROR_INVALID_DRIVE);
    expect(ERROR_CURRENT_DIRECTORY, WIN32_ERROR.ERROR_CURRENT_DIRECTORY);
    expect(ERROR_NOT_SAME_DEVICE, WIN32_ERROR.ERROR_NOT_SAME_DEVICE);
    expect(ERROR_NO_MORE_FILES, WIN32_ERROR.ERROR_NO_MORE_FILES);
    expect(ERROR_WRITE_PROTECT, WIN32_ERROR.ERROR_WRITE_PROTECT);
    expect(ERROR_BAD_UNIT, WIN32_ERROR.ERROR_BAD_UNIT);
    expect(ERROR_NOT_READY, WIN32_ERROR.ERROR_NOT_READY);
    expect(ERROR_BAD_COMMAND, WIN32_ERROR.ERROR_BAD_COMMAND);
    expect(ERROR_CRC, WIN32_ERROR.ERROR_CRC);
    expect(ERROR_BAD_LENGTH, WIN32_ERROR.ERROR_BAD_LENGTH);
    expect(ERROR_SEEK, WIN32_ERROR.ERROR_SEEK);
    expect(ERROR_NOT_DOS_DISK, WIN32_ERROR.ERROR_NOT_DOS_DISK);
    expect(ERROR_SECTOR_NOT_FOUND, WIN32_ERROR.ERROR_SECTOR_NOT_FOUND);
    expect(ERROR_OUT_OF_PAPER, WIN32_ERROR.ERROR_OUT_OF_PAPER);
    expect(ERROR_WRITE_FAULT, WIN32_ERROR.ERROR_WRITE_FAULT);
    expect(ERROR_READ_FAULT, WIN32_ERROR.ERROR_READ_FAULT);
    expect(ERROR_GEN_FAILURE, WIN32_ERROR.ERROR_GEN_FAILURE);
    expect(ERROR_SHARING_VIOLATION, WIN32_ERROR.ERROR_SHARING_VIOLATION);
    expect(ERROR_LOCK_VIOLATION, WIN32_ERROR.ERROR_LOCK_VIOLATION);
    expect(ERROR_WRONG_DISK, WIN32_ERROR.ERROR_WRONG_DISK);
    expect(ERROR_SHARING_BUFFER_EXCEEDED,
        WIN32_ERROR.ERROR_SHARING_BUFFER_EXCEEDED);
    expect(ERROR_HANDLE_EOF, WIN32_ERROR.ERROR_HANDLE_EOF);
    expect(ERROR_HANDLE_DISK_FULL, WIN32_ERROR.ERROR_HANDLE_DISK_FULL);
    expect(ERROR_NOT_SUPPORTED, WIN32_ERROR.ERROR_NOT_SUPPORTED);
    expect(ERROR_REM_NOT_LIST, WIN32_ERROR.ERROR_REM_NOT_LIST);
    expect(ERROR_DUP_NAME, WIN32_ERROR.ERROR_DUP_NAME);
    expect(ERROR_BAD_NETPATH, WIN32_ERROR.ERROR_BAD_NETPATH);
    expect(ERROR_NETWORK_BUSY, WIN32_ERROR.ERROR_NETWORK_BUSY);
    expect(ERROR_DEV_NOT_EXIST, WIN32_ERROR.ERROR_DEV_NOT_EXIST);
    expect(ERROR_TOO_MANY_CMDS, WIN32_ERROR.ERROR_TOO_MANY_CMDS);
    expect(ERROR_ADAP_HDW_ERR, WIN32_ERROR.ERROR_ADAP_HDW_ERR);
    expect(ERROR_BAD_NET_RESP, WIN32_ERROR.ERROR_BAD_NET_RESP);
    expect(ERROR_UNEXP_NET_ERR, WIN32_ERROR.ERROR_UNEXP_NET_ERR);
    expect(ERROR_BAD_REM_ADAP, WIN32_ERROR.ERROR_BAD_REM_ADAP);
    expect(ERROR_PRINTQ_FULL, WIN32_ERROR.ERROR_PRINTQ_FULL);
    expect(ERROR_NO_SPOOL_SPACE, WIN32_ERROR.ERROR_NO_SPOOL_SPACE);
    expect(ERROR_PRINT_CANCELLED, WIN32_ERROR.ERROR_PRINT_CANCELLED);
    expect(ERROR_NETNAME_DELETED, WIN32_ERROR.ERROR_NETNAME_DELETED);
    expect(
        ERROR_NETWORK_ACCESS_DENIED, WIN32_ERROR.ERROR_NETWORK_ACCESS_DENIED);
    expect(ERROR_BAD_DEV_TYPE, WIN32_ERROR.ERROR_BAD_DEV_TYPE);
    expect(ERROR_BAD_NET_NAME, WIN32_ERROR.ERROR_BAD_NET_NAME);
    expect(ERROR_TOO_MANY_NAMES, WIN32_ERROR.ERROR_TOO_MANY_NAMES);
    expect(ERROR_TOO_MANY_SESS, WIN32_ERROR.ERROR_TOO_MANY_SESS);
    expect(ERROR_SHARING_PAUSED, WIN32_ERROR.ERROR_SHARING_PAUSED);
    expect(ERROR_REQ_NOT_ACCEP, WIN32_ERROR.ERROR_REQ_NOT_ACCEP);
    expect(ERROR_REDIR_PAUSED, WIN32_ERROR.ERROR_REDIR_PAUSED);
    expect(ERROR_FILE_EXISTS, WIN32_ERROR.ERROR_FILE_EXISTS);
    expect(ERROR_CANNOT_MAKE, WIN32_ERROR.ERROR_CANNOT_MAKE);
    expect(ERROR_FAIL_I24, WIN32_ERROR.ERROR_FAIL_I24);
    expect(ERROR_OUT_OF_STRUCTURES, WIN32_ERROR.ERROR_OUT_OF_STRUCTURES);
    expect(ERROR_ALREADY_ASSIGNED, WIN32_ERROR.ERROR_ALREADY_ASSIGNED);
    expect(ERROR_INVALID_PASSWORD, WIN32_ERROR.ERROR_INVALID_PASSWORD);
    expect(ERROR_INVALID_PARAMETER, WIN32_ERROR.ERROR_INVALID_PARAMETER);
    expect(ERROR_NET_WRITE_FAULT, WIN32_ERROR.ERROR_NET_WRITE_FAULT);
    expect(ERROR_NO_PROC_SLOTS, WIN32_ERROR.ERROR_NO_PROC_SLOTS);
    expect(ERROR_TOO_MANY_SEMAPHORES, WIN32_ERROR.ERROR_TOO_MANY_SEMAPHORES);
    expect(
        ERROR_EXCL_SEM_ALREADY_OWNED, WIN32_ERROR.ERROR_EXCL_SEM_ALREADY_OWNED);
    expect(ERROR_SEM_IS_SET, WIN32_ERROR.ERROR_SEM_IS_SET);
    expect(
        ERROR_TOO_MANY_SEM_REQUESTS, WIN32_ERROR.ERROR_TOO_MANY_SEM_REQUESTS);
    expect(ERROR_INVALID_AT_INTERRUPT_TIME,
        WIN32_ERROR.ERROR_INVALID_AT_INTERRUPT_TIME);
    expect(ERROR_SERVICE_NOT_ACTIVE, WIN32_ERROR.ERROR_SERVICE_NOT_ACTIVE);
    expect(ERROR_DEVICE_NOT_CONNECTED, WIN32_ERROR.ERROR_DEVICE_NOT_CONNECTED);
    expect(DELETE, FILE_ACCESS_RIGHTS.DELETE);
    expect(READ_CONTROL, FILE_ACCESS_RIGHTS.READ_CONTROL);
    expect(WRITE_DAC, FILE_ACCESS_RIGHTS.WRITE_DAC);
    expect(WRITE_OWNER, FILE_ACCESS_RIGHTS.WRITE_OWNER);
    expect(SYNCHRONIZE, FILE_ACCESS_RIGHTS.SYNCHRONIZE);
    expect(
        STANDARD_RIGHTS_REQUIRED, FILE_ACCESS_RIGHTS.STANDARD_RIGHTS_REQUIRED);
    expect(STANDARD_RIGHTS_READ, FILE_ACCESS_RIGHTS.STANDARD_RIGHTS_READ);
    expect(STANDARD_RIGHTS_WRITE, FILE_ACCESS_RIGHTS.STANDARD_RIGHTS_WRITE);
    expect(STANDARD_RIGHTS_EXECUTE, FILE_ACCESS_RIGHTS.STANDARD_RIGHTS_EXECUTE);
    expect(STANDARD_RIGHTS_ALL, FILE_ACCESS_RIGHTS.STANDARD_RIGHTS_ALL);
    expect(GENERIC_READ, GENERIC_ACCESS_RIGHTS.GENERIC_READ);
    expect(GENERIC_WRITE, GENERIC_ACCESS_RIGHTS.GENERIC_WRITE);
    expect(GENERIC_EXECUTE, GENERIC_ACCESS_RIGHTS.GENERIC_EXECUTE);
    expect(GENERIC_ALL, GENERIC_ACCESS_RIGHTS.GENERIC_ALL);
    expect(CREATE_NEW, FILE_CREATION_DISPOSITION.CREATE_NEW);
    expect(CREATE_ALWAYS, FILE_CREATION_DISPOSITION.CREATE_ALWAYS);
    expect(OPEN_EXISTING, FILE_CREATION_DISPOSITION.OPEN_EXISTING);
    expect(OPEN_ALWAYS, FILE_CREATION_DISPOSITION.OPEN_ALWAYS);
    expect(TRUNCATE_EXISTING, FILE_CREATION_DISPOSITION.TRUNCATE_EXISTING);
    expect(TOKEN_ASSIGN_PRIMARY, TOKEN_ACCESS_MASK.TOKEN_ASSIGN_PRIMARY);
    expect(TOKEN_DUPLICATE, TOKEN_ACCESS_MASK.TOKEN_DUPLICATE);
    expect(TOKEN_IMPERSONATE, TOKEN_ACCESS_MASK.TOKEN_IMPERSONATE);
    expect(TOKEN_QUERY, TOKEN_ACCESS_MASK.TOKEN_QUERY);
    expect(TOKEN_QUERY_SOURCE, TOKEN_ACCESS_MASK.TOKEN_QUERY_SOURCE);
    expect(TOKEN_ADJUST_PRIVILEGES, TOKEN_ACCESS_MASK.TOKEN_ADJUST_PRIVILEGES);
    expect(TOKEN_ADJUST_GROUPS, TOKEN_ACCESS_MASK.TOKEN_ADJUST_GROUPS);
    expect(TOKEN_ADJUST_DEFAULT, TOKEN_ACCESS_MASK.TOKEN_ADJUST_DEFAULT);
    expect(TOKEN_ADJUST_SESSIONID, TOKEN_ACCESS_MASK.TOKEN_ADJUST_SESSIONID);
    expect(TOKEN_ALL_ACCESS, TOKEN_ACCESS_MASK.TOKEN_ALL_ACCESS);
    expect(TOKEN_READ, TOKEN_ACCESS_MASK.TOKEN_READ);
    expect(TOKEN_WRITE, TOKEN_ACCESS_MASK.TOKEN_WRITE);
    expect(TOKEN_EXECUTE, TOKEN_ACCESS_MASK.TOKEN_EXECUTE);
    expect(HEAP_NO_SERIALIZE, HEAP_FLAGS.HEAP_NO_SERIALIZE);
    expect(HEAP_GENERATE_EXCEPTIONS, HEAP_FLAGS.HEAP_GENERATE_EXCEPTIONS);
    expect(HEAP_ZERO_MEMORY, HEAP_FLAGS.HEAP_ZERO_MEMORY);
    expect(HEAP_REALLOC_IN_PLACE_ONLY, HEAP_FLAGS.HEAP_REALLOC_IN_PLACE_ONLY);
    expect(HEAP_CREATE_ENABLE_EXECUTE, HEAP_FLAGS.HEAP_CREATE_ENABLE_EXECUTE);
    expect(ES_SYSTEM_REQUIRED, EXECUTION_STATE.ES_SYSTEM_REQUIRED);
    expect(ES_DISPLAY_REQUIRED, EXECUTION_STATE.ES_DISPLAY_REQUIRED);
    expect(ES_USER_PRESENT, EXECUTION_STATE.ES_USER_PRESENT);
    expect(ES_AWAYMODE_REQUIRED, EXECUTION_STATE.ES_AWAYMODE_REQUIRED);
    expect(ES_CONTINUOUS, EXECUTION_STATE.ES_CONTINUOUS);
    expect(PIPE_ACCESS_INBOUND, FILE_FLAGS_AND_ATTRIBUTES.PIPE_ACCESS_INBOUND);
    expect(
        PIPE_ACCESS_OUTBOUND, FILE_FLAGS_AND_ATTRIBUTES.PIPE_ACCESS_OUTBOUND);
    expect(PIPE_ACCESS_DUPLEX, FILE_FLAGS_AND_ATTRIBUTES.PIPE_ACCESS_DUPLEX);
    expect(PIPE_CLIENT_END, NAMED_PIPE_MODE.PIPE_CLIENT_END);
    expect(PIPE_SERVER_END, NAMED_PIPE_MODE.PIPE_SERVER_END);
    expect(PIPE_WAIT, NAMED_PIPE_MODE.PIPE_WAIT);
    expect(PIPE_NOWAIT, NAMED_PIPE_MODE.PIPE_NOWAIT);
    expect(PIPE_READMODE_BYTE, NAMED_PIPE_MODE.PIPE_READMODE_BYTE);
    expect(PIPE_READMODE_MESSAGE, NAMED_PIPE_MODE.PIPE_READMODE_MESSAGE);
    expect(PIPE_TYPE_BYTE, NAMED_PIPE_MODE.PIPE_TYPE_BYTE);
    expect(PIPE_TYPE_MESSAGE, NAMED_PIPE_MODE.PIPE_TYPE_MESSAGE);
    expect(
        PIPE_ACCEPT_REMOTE_CLIENTS, NAMED_PIPE_MODE.PIPE_ACCEPT_REMOTE_CLIENTS);
    expect(
        PIPE_REJECT_REMOTE_CLIENTS, NAMED_PIPE_MODE.PIPE_REJECT_REMOTE_CLIENTS);
    expect(FILE_FLAG_WRITE_THROUGH,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_WRITE_THROUGH);
    expect(
        FILE_FLAG_OVERLAPPED, FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_OVERLAPPED);
    expect(FILE_FLAG_NO_BUFFERING,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_NO_BUFFERING);
    expect(FILE_FLAG_RANDOM_ACCESS,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_RANDOM_ACCESS);
    expect(FILE_FLAG_SEQUENTIAL_SCAN,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_SEQUENTIAL_SCAN);
    expect(FILE_FLAG_DELETE_ON_CLOSE,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_DELETE_ON_CLOSE);
    expect(FILE_FLAG_BACKUP_SEMANTICS,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_BACKUP_SEMANTICS);
    expect(FILE_FLAG_POSIX_SEMANTICS,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_POSIX_SEMANTICS);
    expect(FILE_FLAG_SESSION_AWARE,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_SESSION_AWARE);
    expect(FILE_FLAG_OPEN_REPARSE_POINT,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_OPEN_REPARSE_POINT);
    expect(FILE_FLAG_OPEN_NO_RECALL,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_OPEN_NO_RECALL);
    expect(FILE_FLAG_FIRST_PIPE_INSTANCE,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_FIRST_PIPE_INSTANCE);
    expect(HANDLE_FLAG_INHERIT, HANDLE_FLAGS.HANDLE_FLAG_INHERIT);
    expect(HANDLE_FLAG_PROTECT_FROM_CLOSE,
        HANDLE_FLAGS.HANDLE_FLAG_PROTECT_FROM_CLOSE);
    expect(NOPARITY, DCB_PARITY.NOPARITY);
    expect(ODDPARITY, DCB_PARITY.ODDPARITY);
    expect(EVENPARITY, DCB_PARITY.EVENPARITY);
    expect(MARKPARITY, DCB_PARITY.MARKPARITY);
    expect(SPACEPARITY, DCB_PARITY.SPACEPARITY);
    expect(ONESTOPBIT, DCB_STOP_BITS.ONESTOPBIT);
    expect(ONE5STOPBITS, DCB_STOP_BITS.ONE5STOPBITS);
    expect(TWOSTOPBITS, DCB_STOP_BITS.TWOSTOPBITS);
    expect(FORMAT_MESSAGE_IGNORE_INSERTS,
        FORMAT_MESSAGE_OPTIONS.FORMAT_MESSAGE_IGNORE_INSERTS);
    expect(FORMAT_MESSAGE_FROM_STRING,
        FORMAT_MESSAGE_OPTIONS.FORMAT_MESSAGE_FROM_STRING);
    expect(FORMAT_MESSAGE_FROM_HMODULE,
        FORMAT_MESSAGE_OPTIONS.FORMAT_MESSAGE_FROM_HMODULE);
    expect(FORMAT_MESSAGE_FROM_SYSTEM,
        FORMAT_MESSAGE_OPTIONS.FORMAT_MESSAGE_FROM_SYSTEM);
    expect(FORMAT_MESSAGE_ARGUMENT_ARRAY,
        FORMAT_MESSAGE_OPTIONS.FORMAT_MESSAGE_ARGUMENT_ARRAY);
    expect(STARTF_USESHOWWINDOW, STARTUPINFOW_FLAGS.STARTF_USESHOWWINDOW);
    expect(STARTF_USESIZE, STARTUPINFOW_FLAGS.STARTF_USESIZE);
    expect(STARTF_USEPOSITION, STARTUPINFOW_FLAGS.STARTF_USEPOSITION);
    expect(STARTF_USECOUNTCHARS, STARTUPINFOW_FLAGS.STARTF_USECOUNTCHARS);
    expect(STARTF_USEFILLATTRIBUTE, STARTUPINFOW_FLAGS.STARTF_USEFILLATTRIBUTE);
    expect(STARTF_RUNFULLSCREEN, STARTUPINFOW_FLAGS.STARTF_RUNFULLSCREEN);
    expect(STARTF_FORCEONFEEDBACK, STARTUPINFOW_FLAGS.STARTF_FORCEONFEEDBACK);
    expect(STARTF_FORCEOFFFEEDBACK, STARTUPINFOW_FLAGS.STARTF_FORCEOFFFEEDBACK);
    expect(STARTF_USESTDHANDLES, STARTUPINFOW_FLAGS.STARTF_USESTDHANDLES);
    expect(STARTF_USEHOTKEY, STARTUPINFOW_FLAGS.STARTF_USEHOTKEY);
    expect(STARTF_TITLEISLINKNAME, STARTUPINFOW_FLAGS.STARTF_TITLEISLINKNAME);
    expect(STARTF_TITLEISAPPID, STARTUPINFOW_FLAGS.STARTF_TITLEISAPPID);
    expect(STARTF_PREVENTPINNING, STARTUPINFOW_FLAGS.STARTF_PREVENTPINNING);
    expect(STARTF_UNTRUSTEDSOURCE, STARTUPINFOW_FLAGS.STARTF_UNTRUSTEDSOURCE);
    expect(WS_ACTIVECAPTION, WINDOW_STYLE.WS_ACTIVECAPTION);
    expect(WS_BORDER, WINDOW_STYLE.WS_BORDER);
    expect(WS_CAPTION, WINDOW_STYLE.WS_CAPTION);
    expect(WS_CHILD, WINDOW_STYLE.WS_CHILD);
    expect(WS_CHILDWINDOW, WINDOW_STYLE.WS_CHILDWINDOW);
    expect(WS_CLIPCHILDREN, WINDOW_STYLE.WS_CLIPCHILDREN);
    expect(WS_CLIPSIBLINGS, WINDOW_STYLE.WS_CLIPSIBLINGS);
    expect(WS_DISABLED, WINDOW_STYLE.WS_DISABLED);
    expect(WS_DLGFRAME, WINDOW_STYLE.WS_DLGFRAME);
    expect(WS_GROUP, WINDOW_STYLE.WS_GROUP);
    expect(WS_HSCROLL, WINDOW_STYLE.WS_HSCROLL);
    expect(WS_ICONIC, WINDOW_STYLE.WS_ICONIC);
    expect(WS_MAXIMIZE, WINDOW_STYLE.WS_MAXIMIZE);
    expect(WS_MAXIMIZEBOX, WINDOW_STYLE.WS_MAXIMIZEBOX);
    expect(WS_MINIMIZE, WINDOW_STYLE.WS_MINIMIZE);
    expect(WS_MINIMIZEBOX, WINDOW_STYLE.WS_MINIMIZEBOX);
    expect(WS_OVERLAPPED, WINDOW_STYLE.WS_OVERLAPPED);
    expect(WS_OVERLAPPEDWINDOW, WINDOW_STYLE.WS_OVERLAPPEDWINDOW);
    expect(WS_POPUP, WINDOW_STYLE.WS_POPUP);
    expect(WS_POPUPWINDOW, WINDOW_STYLE.WS_POPUPWINDOW);
    expect(WS_SIZEBOX, WINDOW_STYLE.WS_SIZEBOX);
    expect(WS_SYSMENU, WINDOW_STYLE.WS_SYSMENU);
    expect(WS_TABSTOP, WINDOW_STYLE.WS_TABSTOP);
    expect(WS_THICKFRAME, WINDOW_STYLE.WS_THICKFRAME);
    expect(WS_TILED, WINDOW_STYLE.WS_TILED);
    expect(WS_TILEDWINDOW, WINDOW_STYLE.WS_TILEDWINDOW);
    expect(WS_VISIBLE, WINDOW_STYLE.WS_VISIBLE);
    expect(WS_VSCROLL, WINDOW_STYLE.WS_VSCROLL);
    expect(WS_EX_DLGMODALFRAME, WINDOW_EX_STYLE.WS_EX_DLGMODALFRAME);
    expect(WS_EX_NOPARENTNOTIFY, WINDOW_EX_STYLE.WS_EX_NOPARENTNOTIFY);
    expect(WS_EX_TOPMOST, WINDOW_EX_STYLE.WS_EX_TOPMOST);
    expect(WS_EX_ACCEPTFILES, WINDOW_EX_STYLE.WS_EX_ACCEPTFILES);
    expect(WS_EX_TRANSPARENT, WINDOW_EX_STYLE.WS_EX_TRANSPARENT);
    expect(WS_EX_MDICHILD, WINDOW_EX_STYLE.WS_EX_MDICHILD);
    expect(WS_EX_TOOLWINDOW, WINDOW_EX_STYLE.WS_EX_TOOLWINDOW);
    expect(WS_EX_WINDOWEDGE, WINDOW_EX_STYLE.WS_EX_WINDOWEDGE);
    expect(WS_EX_CLIENTEDGE, WINDOW_EX_STYLE.WS_EX_CLIENTEDGE);
    expect(WS_EX_CONTEXTHELP, WINDOW_EX_STYLE.WS_EX_CONTEXTHELP);
    expect(WS_EX_RIGHT, WINDOW_EX_STYLE.WS_EX_RIGHT);
    expect(WS_EX_LEFT, WINDOW_EX_STYLE.WS_EX_LEFT);
    expect(WS_EX_RTLREADING, WINDOW_EX_STYLE.WS_EX_RTLREADING);
    expect(WS_EX_LTRREADING, WINDOW_EX_STYLE.WS_EX_LTRREADING);
    expect(WS_EX_LEFTSCROLLBAR, WINDOW_EX_STYLE.WS_EX_LEFTSCROLLBAR);
    expect(WS_EX_RIGHTSCROLLBAR, WINDOW_EX_STYLE.WS_EX_RIGHTSCROLLBAR);
    expect(WS_EX_CONTROLPARENT, WINDOW_EX_STYLE.WS_EX_CONTROLPARENT);
    expect(WS_EX_STATICEDGE, WINDOW_EX_STYLE.WS_EX_STATICEDGE);
    expect(WS_EX_APPWINDOW, WINDOW_EX_STYLE.WS_EX_APPWINDOW);
    expect(WS_EX_OVERLAPPEDWINDOW, WINDOW_EX_STYLE.WS_EX_OVERLAPPEDWINDOW);
    expect(WS_EX_PALETTEWINDOW, WINDOW_EX_STYLE.WS_EX_PALETTEWINDOW);
    expect(WS_EX_LAYERED, WINDOW_EX_STYLE.WS_EX_LAYERED);
    expect(WS_EX_NOINHERITLAYOUT, WINDOW_EX_STYLE.WS_EX_NOINHERITLAYOUT);
    expect(
        WS_EX_NOREDIRECTIONBITMAP, WINDOW_EX_STYLE.WS_EX_NOREDIRECTIONBITMAP);
    expect(WS_EX_LAYOUTRTL, WINDOW_EX_STYLE.WS_EX_LAYOUTRTL);
    expect(WS_EX_COMPOSITED, WINDOW_EX_STYLE.WS_EX_COMPOSITED);
    expect(WS_EX_NOACTIVATE, WINDOW_EX_STYLE.WS_EX_NOACTIVATE);
    expect(SMTO_NORMAL, SEND_MESSAGE_TIMEOUT_FLAGS.SMTO_NORMAL);
    expect(SMTO_BLOCK, SEND_MESSAGE_TIMEOUT_FLAGS.SMTO_BLOCK);
    expect(SMTO_ABORTIFHUNG, SEND_MESSAGE_TIMEOUT_FLAGS.SMTO_ABORTIFHUNG);
    expect(SMTO_NOTIMEOUTIFNOTHUNG,
        SEND_MESSAGE_TIMEOUT_FLAGS.SMTO_NOTIMEOUTIFNOTHUNG);
    expect(SMTO_ERRORONEXIT, SEND_MESSAGE_TIMEOUT_FLAGS.SMTO_ERRORONEXIT);
    expect(QS_KEY, QUEUE_STATUS_FLAGS.QS_KEY);
    expect(QS_MOUSEMOVE, QUEUE_STATUS_FLAGS.QS_MOUSEMOVE);
    expect(QS_MOUSEBUTTON, QUEUE_STATUS_FLAGS.QS_MOUSEBUTTON);
    expect(QS_POSTMESSAGE, QUEUE_STATUS_FLAGS.QS_POSTMESSAGE);
    expect(QS_TIMER, QUEUE_STATUS_FLAGS.QS_TIMER);
    expect(QS_PAINT, QUEUE_STATUS_FLAGS.QS_PAINT);
    expect(QS_SENDMESSAGE, QUEUE_STATUS_FLAGS.QS_SENDMESSAGE);
    expect(QS_HOTKEY, QUEUE_STATUS_FLAGS.QS_HOTKEY);
    expect(QS_ALLPOSTMESSAGE, QUEUE_STATUS_FLAGS.QS_ALLPOSTMESSAGE);
    expect(QS_RAWINPUT, QUEUE_STATUS_FLAGS.QS_RAWINPUT);
    expect(QS_MOUSE, QUEUE_STATUS_FLAGS.QS_MOUSE);
    expect(QS_INPUT, QUEUE_STATUS_FLAGS.QS_INPUT);
    expect(QS_ALLEVENTS, QUEUE_STATUS_FLAGS.QS_ALLEVENTS);
    expect(QS_ALLINPUT, QUEUE_STATUS_FLAGS.QS_ALLINPUT);
    expect(WH_MSGFILTER, WINDOWS_HOOK_ID.WH_MSGFILTER);
    expect(WH_JOURNALRECORD, WINDOWS_HOOK_ID.WH_JOURNALRECORD);
    expect(WH_JOURNALPLAYBACK, WINDOWS_HOOK_ID.WH_JOURNALPLAYBACK);
    expect(WH_KEYBOARD, WINDOWS_HOOK_ID.WH_KEYBOARD);
    expect(WH_GETMESSAGE, WINDOWS_HOOK_ID.WH_GETMESSAGE);
    expect(WH_CALLWNDPROC, WINDOWS_HOOK_ID.WH_CALLWNDPROC);
    expect(WH_CBT, WINDOWS_HOOK_ID.WH_CBT);
    expect(WH_SYSMSGFILTER, WINDOWS_HOOK_ID.WH_SYSMSGFILTER);
    expect(WH_MOUSE, WINDOWS_HOOK_ID.WH_MOUSE);
    expect(WH_DEBUG, WINDOWS_HOOK_ID.WH_DEBUG);
    expect(WH_SHELL, WINDOWS_HOOK_ID.WH_SHELL);
    expect(WH_FOREGROUNDIDLE, WINDOWS_HOOK_ID.WH_FOREGROUNDIDLE);
    expect(WH_CALLWNDPROCRET, WINDOWS_HOOK_ID.WH_CALLWNDPROCRET);
    expect(WH_KEYBOARD_LL, WINDOWS_HOOK_ID.WH_KEYBOARD_LL);
    expect(WH_MOUSE_LL, WINDOWS_HOOK_ID.WH_MOUSE_LL);
    expect(LLKHF_EXTENDED, KBDLLHOOKSTRUCT_FLAGS.LLKHF_EXTENDED);
    expect(LLKHF_INJECTED, KBDLLHOOKSTRUCT_FLAGS.LLKHF_INJECTED);
    expect(LLKHF_ALTDOWN, KBDLLHOOKSTRUCT_FLAGS.LLKHF_ALTDOWN);
    expect(LLKHF_UP, KBDLLHOOKSTRUCT_FLAGS.LLKHF_UP);
    expect(
        LLKHF_LOWER_IL_INJECTED, KBDLLHOOKSTRUCT_FLAGS.LLKHF_LOWER_IL_INJECTED);
    expect(COLOR_SCROLLBAR, SYS_COLOR_INDEX.COLOR_SCROLLBAR);
    expect(COLOR_BACKGROUND, SYS_COLOR_INDEX.COLOR_BACKGROUND);
    expect(COLOR_ACTIVECAPTION, SYS_COLOR_INDEX.COLOR_ACTIVECAPTION);
    expect(COLOR_INACTIVECAPTION, SYS_COLOR_INDEX.COLOR_INACTIVECAPTION);
    expect(COLOR_MENU, SYS_COLOR_INDEX.COLOR_MENU);
    expect(COLOR_WINDOW, SYS_COLOR_INDEX.COLOR_WINDOW);
    expect(COLOR_WINDOWFRAME, SYS_COLOR_INDEX.COLOR_WINDOWFRAME);
    expect(COLOR_MENUTEXT, SYS_COLOR_INDEX.COLOR_MENUTEXT);
    expect(COLOR_WINDOWTEXT, SYS_COLOR_INDEX.COLOR_WINDOWTEXT);
    expect(COLOR_CAPTIONTEXT, SYS_COLOR_INDEX.COLOR_CAPTIONTEXT);
    expect(COLOR_ACTIVEBORDER, SYS_COLOR_INDEX.COLOR_ACTIVEBORDER);
    expect(COLOR_INACTIVEBORDER, SYS_COLOR_INDEX.COLOR_INACTIVEBORDER);
    expect(COLOR_APPWORKSPACE, SYS_COLOR_INDEX.COLOR_APPWORKSPACE);
    expect(COLOR_HIGHLIGHT, SYS_COLOR_INDEX.COLOR_HIGHLIGHT);
    expect(COLOR_HIGHLIGHTTEXT, SYS_COLOR_INDEX.COLOR_HIGHLIGHTTEXT);
    expect(COLOR_BTNFACE, SYS_COLOR_INDEX.COLOR_BTNFACE);
    expect(COLOR_BTNSHADOW, SYS_COLOR_INDEX.COLOR_BTNSHADOW);
    expect(COLOR_GRAYTEXT, SYS_COLOR_INDEX.COLOR_GRAYTEXT);
    expect(COLOR_BTNTEXT, SYS_COLOR_INDEX.COLOR_BTNTEXT);
    expect(
        COLOR_INACTIVECAPTIONTEXT, SYS_COLOR_INDEX.COLOR_INACTIVECAPTIONTEXT);
    expect(COLOR_BTNHIGHLIGHT, SYS_COLOR_INDEX.COLOR_BTNHIGHLIGHT);
    expect(GWL_EXSTYLE, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE);
    expect(GWL_HINSTANCE, WINDOW_LONG_PTR_INDEX.GWL_HINSTANCE);
    expect(GWL_ID, WINDOW_LONG_PTR_INDEX.GWL_ID);
    expect(GWL_STYLE, WINDOW_LONG_PTR_INDEX.GWL_STYLE);
    expect(GWL_USERDATA, WINDOW_LONG_PTR_INDEX.GWL_USERDATA);
    expect(GWL_WNDPROC, WINDOW_LONG_PTR_INDEX.GWL_WNDPROC);
    expect(GWLP_WNDPROC, WINDOW_LONG_PTR_INDEX.GWLP_WNDPROC);
    expect(GWLP_HINSTANCE, WINDOW_LONG_PTR_INDEX.GWLP_HINSTANCE);
    expect(GWLP_HWNDPARENT, WINDOW_LONG_PTR_INDEX.GWLP_HWNDPARENT);
    expect(GWLP_USERDATA, WINDOW_LONG_PTR_INDEX.GWLP_USERDATA);
    expect(GWLP_ID, WINDOW_LONG_PTR_INDEX.GWLP_ID);
    expect(SPI_GETBEEP, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETBEEP);
    expect(SPI_SETBEEP, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETBEEP);
    expect(SPI_GETMOUSE, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSE);
    expect(SPI_SETMOUSE, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSE);
    expect(SPI_GETBORDER, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETBORDER);
    expect(SPI_SETBORDER, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETBORDER);
    expect(SPI_GETKEYBOARDSPEED,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETKEYBOARDSPEED);
    expect(SPI_SETKEYBOARDSPEED,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETKEYBOARDSPEED);
    expect(SPI_ICONHORIZONTALSPACING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_ICONHORIZONTALSPACING);
    expect(SPI_GETSCREENSAVETIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSCREENSAVETIMEOUT);
    expect(SPI_SETSCREENSAVETIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSCREENSAVETIMEOUT);
    expect(SPI_GETSCREENSAVEACTIVE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSCREENSAVEACTIVE);
    expect(SPI_SETSCREENSAVEACTIVE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSCREENSAVEACTIVE);
    expect(SPI_GETGRIDGRANULARITY,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETGRIDGRANULARITY);
    expect(SPI_SETGRIDGRANULARITY,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETGRIDGRANULARITY);
    expect(SPI_SETDESKWALLPAPER,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDESKWALLPAPER);
    expect(
        SPI_SETDESKPATTERN, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDESKPATTERN);
    expect(SPI_GETKEYBOARDDELAY,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETKEYBOARDDELAY);
    expect(SPI_SETKEYBOARDDELAY,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETKEYBOARDDELAY);
    expect(SPI_ICONVERTICALSPACING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_ICONVERTICALSPACING);
    expect(SPI_GETICONTITLEWRAP,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETICONTITLEWRAP);
    expect(SPI_SETICONTITLEWRAP,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETICONTITLEWRAP);
    expect(SPI_GETMENUDROPALIGNMENT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMENUDROPALIGNMENT);
    expect(SPI_SETMENUDROPALIGNMENT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMENUDROPALIGNMENT);
    expect(SPI_SETDOUBLECLKWIDTH,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDOUBLECLKWIDTH);
    expect(SPI_SETDOUBLECLKHEIGHT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDOUBLECLKHEIGHT);
    expect(SPI_GETICONTITLELOGFONT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETICONTITLELOGFONT);
    expect(SPI_SETDOUBLECLICKTIME,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDOUBLECLICKTIME);
    expect(SPI_SETMOUSEBUTTONSWAP,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEBUTTONSWAP);
    expect(SPI_SETICONTITLELOGFONT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETICONTITLELOGFONT);
    expect(SPI_GETFASTTASKSWITCH,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETFASTTASKSWITCH);
    expect(SPI_SETFASTTASKSWITCH,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETFASTTASKSWITCH);
    expect(SPI_SETDRAGFULLWINDOWS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDRAGFULLWINDOWS);
    expect(SPI_GETDRAGFULLWINDOWS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETDRAGFULLWINDOWS);
    expect(SPI_GETNONCLIENTMETRICS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETNONCLIENTMETRICS);
    expect(SPI_SETNONCLIENTMETRICS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETNONCLIENTMETRICS);
    expect(SPI_GETMINIMIZEDMETRICS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMINIMIZEDMETRICS);
    expect(SPI_SETMINIMIZEDMETRICS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMINIMIZEDMETRICS);
    expect(
        SPI_GETICONMETRICS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETICONMETRICS);
    expect(
        SPI_SETICONMETRICS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETICONMETRICS);
    expect(SPI_SETWORKAREA, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETWORKAREA);
    expect(SPI_GETWORKAREA, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETWORKAREA);
    expect(SPI_SETPENWINDOWS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETPENWINDOWS);
    expect(
        SPI_GETHIGHCONTRAST, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETHIGHCONTRAST);
    expect(
        SPI_SETHIGHCONTRAST, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETHIGHCONTRAST);
    expect(
        SPI_GETKEYBOARDPREF, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETKEYBOARDPREF);
    expect(
        SPI_SETKEYBOARDPREF, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETKEYBOARDPREF);
    expect(
        SPI_GETSCREENREADER, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSCREENREADER);
    expect(
        SPI_SETSCREENREADER, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSCREENREADER);
    expect(SPI_GETANIMATION, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETANIMATION);
    expect(SPI_SETANIMATION, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETANIMATION);
    expect(SPI_GETFONTSMOOTHING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETFONTSMOOTHING);
    expect(SPI_SETFONTSMOOTHING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETFONTSMOOTHING);
    expect(SPI_SETDRAGWIDTH, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDRAGWIDTH);
    expect(SPI_SETDRAGHEIGHT, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDRAGHEIGHT);
    expect(SPI_SETHANDHELD, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETHANDHELD);
    expect(SPI_GETLOWPOWERTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETLOWPOWERTIMEOUT);
    expect(SPI_GETPOWEROFFTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETPOWEROFFTIMEOUT);
    expect(SPI_SETLOWPOWERTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETLOWPOWERTIMEOUT);
    expect(SPI_SETPOWEROFFTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETPOWEROFFTIMEOUT);
    expect(SPI_GETLOWPOWERACTIVE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETLOWPOWERACTIVE);
    expect(SPI_GETPOWEROFFACTIVE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETPOWEROFFACTIVE);
    expect(SPI_SETLOWPOWERACTIVE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETLOWPOWERACTIVE);
    expect(SPI_SETPOWEROFFACTIVE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETPOWEROFFACTIVE);
    expect(SPI_SETCURSORS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETCURSORS);
    expect(SPI_SETICONS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETICONS);
    expect(SPI_GETDEFAULTINPUTLANG,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETDEFAULTINPUTLANG);
    expect(SPI_SETDEFAULTINPUTLANG,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDEFAULTINPUTLANG);
    expect(SPI_SETLANGTOGGLE, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETLANGTOGGLE);
    expect(SPI_GETWINDOWSEXTENSION,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETWINDOWSEXTENSION);
    expect(
        SPI_SETMOUSETRAILS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSETRAILS);
    expect(
        SPI_GETMOUSETRAILS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSETRAILS);
    expect(SPI_SCREENSAVERRUNNING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SCREENSAVERRUNNING);
    expect(SPI_SCREENSAVERRUNNING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SCREENSAVERRUNNING);
    expect(SPI_GETFILTERKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETFILTERKEYS);
    expect(SPI_SETFILTERKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETFILTERKEYS);
    expect(SPI_GETTOGGLEKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETTOGGLEKEYS);
    expect(SPI_SETTOGGLEKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETTOGGLEKEYS);
    expect(SPI_GETMOUSEKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSEKEYS);
    expect(SPI_SETMOUSEKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEKEYS);
    expect(SW_HIDE, SHOW_WINDOW_CMD.SW_HIDE);
    expect(SW_NORMAL, SHOW_WINDOW_CMD.SW_NORMAL);
    expect(SW_SHOWNORMAL, SHOW_WINDOW_CMD.SW_SHOWNORMAL);
    expect(SW_SHOWMINIMIZED, SHOW_WINDOW_CMD.SW_SHOWMINIMIZED);
    expect(SW_MAXIMIZE, SHOW_WINDOW_CMD.SW_MAXIMIZE);
    expect(SW_SHOWMAXIMIZED, SHOW_WINDOW_CMD.SW_SHOWMAXIMIZED);
    expect(SW_SHOWNOACTIVATE, SHOW_WINDOW_CMD.SW_SHOWNOACTIVATE);
    expect(SW_SHOW, SHOW_WINDOW_CMD.SW_SHOW);
    expect(SW_MINIMIZE, SHOW_WINDOW_CMD.SW_MINIMIZE);
    expect(SW_SHOWMINNOACTIVE, SHOW_WINDOW_CMD.SW_SHOWMINNOACTIVE);
    expect(SW_SHOWNA, SHOW_WINDOW_CMD.SW_SHOWNA);
    expect(SW_RESTORE, SHOW_WINDOW_CMD.SW_RESTORE);
    expect(SW_SHOWDEFAULT, SHOW_WINDOW_CMD.SW_SHOWDEFAULT);
    expect(SW_FORCEMINIMIZE, SHOW_WINDOW_CMD.SW_FORCEMINIMIZE);
    expect(MM_TEXT, HDC_MAP_MODE.MM_TEXT);
    expect(MM_LOMETRIC, HDC_MAP_MODE.MM_LOMETRIC);
    expect(MM_HIMETRIC, HDC_MAP_MODE.MM_HIMETRIC);
    expect(MM_LOENGLISH, HDC_MAP_MODE.MM_LOENGLISH);
    expect(MM_HIENGLISH, HDC_MAP_MODE.MM_HIENGLISH);
    expect(MM_TWIPS, HDC_MAP_MODE.MM_TWIPS);
    expect(MM_ISOTROPIC, HDC_MAP_MODE.MM_ISOTROPIC);
    expect(MM_ANISOTROPIC, HDC_MAP_MODE.MM_ANISOTROPIC);
    expect(SWP_NOSIZE, SET_WINDOW_POS_FLAGS.SWP_NOSIZE);
    expect(SWP_NOMOVE, SET_WINDOW_POS_FLAGS.SWP_NOMOVE);
    expect(SWP_NOZORDER, SET_WINDOW_POS_FLAGS.SWP_NOZORDER);
    expect(SWP_NOREDRAW, SET_WINDOW_POS_FLAGS.SWP_NOREDRAW);
    expect(SWP_NOACTIVATE, SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
    expect(SWP_FRAMECHANGED, SET_WINDOW_POS_FLAGS.SWP_FRAMECHANGED);
    expect(SWP_SHOWWINDOW, SET_WINDOW_POS_FLAGS.SWP_SHOWWINDOW);
    expect(SWP_HIDEWINDOW, SET_WINDOW_POS_FLAGS.SWP_HIDEWINDOW);
    expect(SWP_NOCOPYBITS, SET_WINDOW_POS_FLAGS.SWP_NOCOPYBITS);
    expect(SWP_NOOWNERZORDER, SET_WINDOW_POS_FLAGS.SWP_NOOWNERZORDER);
    expect(SWP_NOSENDCHANGING, SET_WINDOW_POS_FLAGS.SWP_NOSENDCHANGING);
    expect(SWP_DRAWFRAME, SET_WINDOW_POS_FLAGS.SWP_DRAWFRAME);
    expect(SWP_NOREPOSITION, SET_WINDOW_POS_FLAGS.SWP_NOREPOSITION);
    expect(SWP_DEFERERASE, SET_WINDOW_POS_FLAGS.SWP_DEFERERASE);
    expect(SWP_ASYNCWINDOWPOS, SET_WINDOW_POS_FLAGS.SWP_ASYNCWINDOWPOS);
    expect(AW_HOR_POSITIVE, ANIMATE_WINDOW_FLAGS.AW_HOR_POSITIVE);
    expect(AW_HOR_NEGATIVE, ANIMATE_WINDOW_FLAGS.AW_HOR_NEGATIVE);
    expect(AW_VER_POSITIVE, ANIMATE_WINDOW_FLAGS.AW_VER_POSITIVE);
    expect(AW_VER_NEGATIVE, ANIMATE_WINDOW_FLAGS.AW_VER_NEGATIVE);
    expect(AW_CENTER, ANIMATE_WINDOW_FLAGS.AW_CENTER);
    expect(AW_HIDE, ANIMATE_WINDOW_FLAGS.AW_HIDE);
    expect(AW_ACTIVATE, ANIMATE_WINDOW_FLAGS.AW_ACTIVATE);
    expect(AW_SLIDE, ANIMATE_WINDOW_FLAGS.AW_SLIDE);
    expect(AW_BLEND, ANIMATE_WINDOW_FLAGS.AW_BLEND);
    expect(SM_CXSCREEN, SYSTEM_METRICS_INDEX.SM_CXSCREEN);
    expect(SM_CYSCREEN, SYSTEM_METRICS_INDEX.SM_CYSCREEN);
    expect(SM_CXVSCROLL, SYSTEM_METRICS_INDEX.SM_CXVSCROLL);
    expect(SM_CYHSCROLL, SYSTEM_METRICS_INDEX.SM_CYHSCROLL);
    expect(SM_CYCAPTION, SYSTEM_METRICS_INDEX.SM_CYCAPTION);
    expect(SM_CXBORDER, SYSTEM_METRICS_INDEX.SM_CXBORDER);
    expect(SM_CYBORDER, SYSTEM_METRICS_INDEX.SM_CYBORDER);
    expect(SM_CXDLGFRAME, SYSTEM_METRICS_INDEX.SM_CXDLGFRAME);
    expect(SM_CYDLGFRAME, SYSTEM_METRICS_INDEX.SM_CYDLGFRAME);
    expect(SM_CYVTHUMB, SYSTEM_METRICS_INDEX.SM_CYVTHUMB);
    expect(SM_CXHTHUMB, SYSTEM_METRICS_INDEX.SM_CXHTHUMB);
    expect(SM_CXICON, SYSTEM_METRICS_INDEX.SM_CXICON);
    expect(SM_CYICON, SYSTEM_METRICS_INDEX.SM_CYICON);
    expect(SM_CXCURSOR, SYSTEM_METRICS_INDEX.SM_CXCURSOR);
    expect(SM_CYCURSOR, SYSTEM_METRICS_INDEX.SM_CYCURSOR);
    expect(SM_CYMENU, SYSTEM_METRICS_INDEX.SM_CYMENU);
    expect(SM_CXFULLSCREEN, SYSTEM_METRICS_INDEX.SM_CXFULLSCREEN);
    expect(SM_CYFULLSCREEN, SYSTEM_METRICS_INDEX.SM_CYFULLSCREEN);
    expect(SM_CYKANJIWINDOW, SYSTEM_METRICS_INDEX.SM_CYKANJIWINDOW);
    expect(SM_MOUSEPRESENT, SYSTEM_METRICS_INDEX.SM_MOUSEPRESENT);
    expect(SM_CYVSCROLL, SYSTEM_METRICS_INDEX.SM_CYVSCROLL);
    expect(SM_CXHSCROLL, SYSTEM_METRICS_INDEX.SM_CXHSCROLL);
    expect(SM_DEBUG, SYSTEM_METRICS_INDEX.SM_DEBUG);
    expect(SM_SWAPBUTTON, SYSTEM_METRICS_INDEX.SM_SWAPBUTTON);
    expect(SM_CXMIN, SYSTEM_METRICS_INDEX.SM_CXMIN);
    expect(SM_CYMIN, SYSTEM_METRICS_INDEX.SM_CYMIN);
    expect(SM_CXSIZE, SYSTEM_METRICS_INDEX.SM_CXSIZE);
    expect(SM_CYSIZE, SYSTEM_METRICS_INDEX.SM_CYSIZE);
    expect(SM_CXFRAME, SYSTEM_METRICS_INDEX.SM_CXFRAME);
    expect(SM_CYFRAME, SYSTEM_METRICS_INDEX.SM_CYFRAME);
    expect(SM_CXMINTRACK, SYSTEM_METRICS_INDEX.SM_CXMINTRACK);
    expect(SM_CYMINTRACK, SYSTEM_METRICS_INDEX.SM_CYMINTRACK);
    expect(SM_CXDOUBLECLK, SYSTEM_METRICS_INDEX.SM_CXDOUBLECLK);
    expect(SM_CYDOUBLECLK, SYSTEM_METRICS_INDEX.SM_CYDOUBLECLK);
    expect(SM_CXICONSPACING, SYSTEM_METRICS_INDEX.SM_CXICONSPACING);
    expect(SM_CYICONSPACING, SYSTEM_METRICS_INDEX.SM_CYICONSPACING);
    expect(SM_MENUDROPALIGNMENT, SYSTEM_METRICS_INDEX.SM_MENUDROPALIGNMENT);
    expect(SM_PENWINDOWS, SYSTEM_METRICS_INDEX.SM_PENWINDOWS);
    expect(SM_DBCSENABLED, SYSTEM_METRICS_INDEX.SM_DBCSENABLED);
    expect(SM_CMOUSEBUTTONS, SYSTEM_METRICS_INDEX.SM_CMOUSEBUTTONS);
    expect(SM_CXFIXEDFRAME, SYSTEM_METRICS_INDEX.SM_CXFIXEDFRAME);
    expect(SM_CYFIXEDFRAME, SYSTEM_METRICS_INDEX.SM_CYFIXEDFRAME);
    expect(SM_CXSIZEFRAME, SYSTEM_METRICS_INDEX.SM_CXSIZEFRAME);
    expect(SM_CYSIZEFRAME, SYSTEM_METRICS_INDEX.SM_CYSIZEFRAME);
    expect(SM_SECURE, SYSTEM_METRICS_INDEX.SM_SECURE);
    expect(SM_CXEDGE, SYSTEM_METRICS_INDEX.SM_CXEDGE);
    expect(SM_CYEDGE, SYSTEM_METRICS_INDEX.SM_CYEDGE);
    expect(SM_CXMINSPACING, SYSTEM_METRICS_INDEX.SM_CXMINSPACING);
    expect(SM_CYMINSPACING, SYSTEM_METRICS_INDEX.SM_CYMINSPACING);
    expect(SM_CXSMICON, SYSTEM_METRICS_INDEX.SM_CXSMICON);
    expect(SM_CYSMICON, SYSTEM_METRICS_INDEX.SM_CYSMICON);
    expect(SM_CYSMCAPTION, SYSTEM_METRICS_INDEX.SM_CYSMCAPTION);
    expect(SM_CXSMSIZE, SYSTEM_METRICS_INDEX.SM_CXSMSIZE);
    expect(SM_CYSMSIZE, SYSTEM_METRICS_INDEX.SM_CYSMSIZE);
    expect(SM_CXMENUSIZE, SYSTEM_METRICS_INDEX.SM_CXMENUSIZE);
    expect(SM_CYMENUSIZE, SYSTEM_METRICS_INDEX.SM_CYMENUSIZE);
    expect(SM_ARRANGE, SYSTEM_METRICS_INDEX.SM_ARRANGE);
    expect(SM_CXMINIMIZED, SYSTEM_METRICS_INDEX.SM_CXMINIMIZED);
    expect(SM_CYMINIMIZED, SYSTEM_METRICS_INDEX.SM_CYMINIMIZED);
    expect(SM_CXMAXTRACK, SYSTEM_METRICS_INDEX.SM_CXMAXTRACK);
    expect(SM_CYMAXTRACK, SYSTEM_METRICS_INDEX.SM_CYMAXTRACK);
    expect(SM_CXMAXIMIZED, SYSTEM_METRICS_INDEX.SM_CXMAXIMIZED);
    expect(SM_CYMAXIMIZED, SYSTEM_METRICS_INDEX.SM_CYMAXIMIZED);
    expect(SM_NETWORK, SYSTEM_METRICS_INDEX.SM_NETWORK);
    expect(SM_CLEANBOOT, SYSTEM_METRICS_INDEX.SM_CLEANBOOT);
    expect(SM_CXDRAG, SYSTEM_METRICS_INDEX.SM_CXDRAG);
    expect(SM_CYDRAG, SYSTEM_METRICS_INDEX.SM_CYDRAG);
    expect(SM_SHOWSOUNDS, SYSTEM_METRICS_INDEX.SM_SHOWSOUNDS);
    expect(SM_CXMENUCHECK, SYSTEM_METRICS_INDEX.SM_CXMENUCHECK);
    expect(SM_CYMENUCHECK, SYSTEM_METRICS_INDEX.SM_CYMENUCHECK);
    expect(SM_SLOWMACHINE, SYSTEM_METRICS_INDEX.SM_SLOWMACHINE);
    expect(SM_MIDEASTENABLED, SYSTEM_METRICS_INDEX.SM_MIDEASTENABLED);
    expect(SM_MOUSEWHEELPRESENT, SYSTEM_METRICS_INDEX.SM_MOUSEWHEELPRESENT);
    expect(SM_XVIRTUALSCREEN, SYSTEM_METRICS_INDEX.SM_XVIRTUALSCREEN);
    expect(SM_YVIRTUALSCREEN, SYSTEM_METRICS_INDEX.SM_YVIRTUALSCREEN);
    expect(SM_CXVIRTUALSCREEN, SYSTEM_METRICS_INDEX.SM_CXVIRTUALSCREEN);
    expect(SM_CYVIRTUALSCREEN, SYSTEM_METRICS_INDEX.SM_CYVIRTUALSCREEN);
    expect(SM_CMONITORS, SYSTEM_METRICS_INDEX.SM_CMONITORS);
    expect(SM_SAMEDISPLAYFORMAT, SYSTEM_METRICS_INDEX.SM_SAMEDISPLAYFORMAT);
    expect(SM_IMMENABLED, SYSTEM_METRICS_INDEX.SM_IMMENABLED);
    expect(SM_CXFOCUSBORDER, SYSTEM_METRICS_INDEX.SM_CXFOCUSBORDER);
    expect(SM_CYFOCUSBORDER, SYSTEM_METRICS_INDEX.SM_CYFOCUSBORDER);
    expect(SM_TABLETPC, SYSTEM_METRICS_INDEX.SM_TABLETPC);
    expect(SM_MEDIACENTER, SYSTEM_METRICS_INDEX.SM_MEDIACENTER);
    expect(SM_STARTER, SYSTEM_METRICS_INDEX.SM_STARTER);
    expect(SM_SERVERR2, SYSTEM_METRICS_INDEX.SM_SERVERR2);
    expect(SM_MOUSEHORIZONTALWHEELPRESENT,
        SYSTEM_METRICS_INDEX.SM_MOUSEHORIZONTALWHEELPRESENT);
    expect(SM_CXPADDEDBORDER, SYSTEM_METRICS_INDEX.SM_CXPADDEDBORDER);
    expect(SM_DIGITIZER, SYSTEM_METRICS_INDEX.SM_DIGITIZER);
    expect(SM_MAXIMUMTOUCHES, SYSTEM_METRICS_INDEX.SM_MAXIMUMTOUCHES);
    expect(SM_REMOTESESSION, SYSTEM_METRICS_INDEX.SM_REMOTESESSION);
    expect(SM_SHUTTINGDOWN, SYSTEM_METRICS_INDEX.SM_SHUTTINGDOWN);
    expect(SM_REMOTECONTROL, SYSTEM_METRICS_INDEX.SM_REMOTECONTROL);
    expect(
        SM_CONVERTIBLESLATEMODE, SYSTEM_METRICS_INDEX.SM_CONVERTIBLESLATEMODE);
    expect(SM_SYSTEMDOCKED, SYSTEM_METRICS_INDEX.SM_SYSTEMDOCKED);
    expect(SB_HORZ, SCROLLBAR_CONSTANTS.SB_HORZ);
    expect(SB_VERT, SCROLLBAR_CONSTANTS.SB_VERT);
    expect(SB_CTL, SCROLLBAR_CONSTANTS.SB_CTL);
    expect(SB_BOTH, SCROLLBAR_CONSTANTS.SB_BOTH);
    expect(SB_LINEUP, SCROLLBAR_COMMAND.SB_LINEUP);
    expect(SB_LINELEFT, SCROLLBAR_COMMAND.SB_LINELEFT);
    expect(SB_LINEDOWN, SCROLLBAR_COMMAND.SB_LINEDOWN);
    expect(SB_LINERIGHT, SCROLLBAR_COMMAND.SB_LINERIGHT);
    expect(SB_PAGEUP, SCROLLBAR_COMMAND.SB_PAGEUP);
    expect(SB_PAGELEFT, SCROLLBAR_COMMAND.SB_PAGELEFT);
    expect(SB_PAGEDOWN, SCROLLBAR_COMMAND.SB_PAGEDOWN);
    expect(SB_PAGERIGHT, SCROLLBAR_COMMAND.SB_PAGERIGHT);
    expect(SB_THUMBPOSITION, SCROLLBAR_COMMAND.SB_THUMBPOSITION);
    expect(SB_THUMBTRACK, SCROLLBAR_COMMAND.SB_THUMBTRACK);
    expect(SB_TOP, SCROLLBAR_COMMAND.SB_TOP);
    expect(SB_LEFT, SCROLLBAR_COMMAND.SB_LEFT);
    expect(SB_BOTTOM, SCROLLBAR_COMMAND.SB_BOTTOM);
    expect(SB_RIGHT, SCROLLBAR_COMMAND.SB_RIGHT);
    expect(SB_ENDSCROLL, SCROLLBAR_COMMAND.SB_ENDSCROLL);
    expect(CF_TEXT, CLIPBOARD_FORMAT.CF_TEXT);
    expect(CF_BITMAP, CLIPBOARD_FORMAT.CF_BITMAP);
    expect(CF_METAFILEPICT, CLIPBOARD_FORMAT.CF_METAFILEPICT);
    expect(CF_SYLK, CLIPBOARD_FORMAT.CF_SYLK);
    expect(CF_DIF, CLIPBOARD_FORMAT.CF_DIF);
    expect(CF_TIFF, CLIPBOARD_FORMAT.CF_TIFF);
    expect(CF_OEMTEXT, CLIPBOARD_FORMAT.CF_OEMTEXT);
    expect(CF_DIB, CLIPBOARD_FORMAT.CF_DIB);
    expect(CF_PALETTE, CLIPBOARD_FORMAT.CF_PALETTE);
    expect(CF_PENDATA, CLIPBOARD_FORMAT.CF_PENDATA);
    expect(CF_RIFF, CLIPBOARD_FORMAT.CF_RIFF);
    expect(CF_WAVE, CLIPBOARD_FORMAT.CF_WAVE);
    expect(CF_UNICODETEXT, CLIPBOARD_FORMAT.CF_UNICODETEXT);
    expect(CF_ENHMETAFILE, CLIPBOARD_FORMAT.CF_ENHMETAFILE);
    expect(CF_HDROP, CLIPBOARD_FORMAT.CF_HDROP);
    expect(CF_LOCALE, CLIPBOARD_FORMAT.CF_LOCALE);
    expect(CF_DIBV5, CLIPBOARD_FORMAT.CF_DIBV5);
    expect(CF_OWNERDISPLAY, CLIPBOARD_FORMAT.CF_OWNERDISPLAY);
    expect(CF_DSPTEXT, CLIPBOARD_FORMAT.CF_DSPTEXT);
    expect(CF_DSPBITMAP, CLIPBOARD_FORMAT.CF_DSPBITMAP);
    expect(CF_DSPMETAFILEPICT, CLIPBOARD_FORMAT.CF_DSPMETAFILEPICT);
    expect(CF_DSPENHMETAFILE, CLIPBOARD_FORMAT.CF_DSPENHMETAFILE);
    expect(CF_PRIVATEFIRST, CLIPBOARD_FORMAT.CF_PRIVATEFIRST);
    expect(CF_PRIVATELAST, CLIPBOARD_FORMAT.CF_PRIVATELAST);
    expect(CF_GDIOBJFIRST, CLIPBOARD_FORMAT.CF_GDIOBJFIRST);
    expect(CF_GDIOBJLAST, CLIPBOARD_FORMAT.CF_GDIOBJLAST);
    expect(SIF_RANGE, SCROLLINFO_MASK.SIF_RANGE);
    expect(SIF_PAGE, SCROLLINFO_MASK.SIF_PAGE);
    expect(SIF_POS, SCROLLINFO_MASK.SIF_POS);
    expect(SIF_DISABLENOSCROLL, SCROLLINFO_MASK.SIF_DISABLENOSCROLL);
    expect(SIF_TRACKPOS, SCROLLINFO_MASK.SIF_TRACKPOS);
    expect(SIF_ALL, SCROLLINFO_MASK.SIF_ALL);
    expect(PM_NOREMOVE, PEEK_MESSAGE_REMOVE_TYPE.PM_NOREMOVE);
    expect(PM_REMOVE, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE);
    expect(PM_NOYIELD, PEEK_MESSAGE_REMOVE_TYPE.PM_NOYIELD);
    expect(DT_TOP, DRAW_TEXT_FORMAT.DT_TOP);
    expect(DT_LEFT, DRAW_TEXT_FORMAT.DT_LEFT);
    expect(DT_CENTER, DRAW_TEXT_FORMAT.DT_CENTER);
    expect(DT_RIGHT, DRAW_TEXT_FORMAT.DT_RIGHT);
    expect(DT_VCENTER, DRAW_TEXT_FORMAT.DT_VCENTER);
    expect(DT_BOTTOM, DRAW_TEXT_FORMAT.DT_BOTTOM);
    expect(DT_WORDBREAK, DRAW_TEXT_FORMAT.DT_WORDBREAK);
    expect(DT_SINGLELINE, DRAW_TEXT_FORMAT.DT_SINGLELINE);
    expect(DT_EXPANDTABS, DRAW_TEXT_FORMAT.DT_EXPANDTABS);
    expect(DT_TABSTOP, DRAW_TEXT_FORMAT.DT_TABSTOP);
    expect(DT_NOCLIP, DRAW_TEXT_FORMAT.DT_NOCLIP);
    expect(DT_EXTERNALLEADING, DRAW_TEXT_FORMAT.DT_EXTERNALLEADING);
    expect(DT_CALCRECT, DRAW_TEXT_FORMAT.DT_CALCRECT);
    expect(DT_NOPREFIX, DRAW_TEXT_FORMAT.DT_NOPREFIX);
    expect(DT_INTERNAL, DRAW_TEXT_FORMAT.DT_INTERNAL);
    expect(DT_EDITCONTROL, DRAW_TEXT_FORMAT.DT_EDITCONTROL);
    expect(DT_PATH_ELLIPSIS, DRAW_TEXT_FORMAT.DT_PATH_ELLIPSIS);
    expect(DT_END_ELLIPSIS, DRAW_TEXT_FORMAT.DT_END_ELLIPSIS);
    expect(DT_MODIFYSTRING, DRAW_TEXT_FORMAT.DT_MODIFYSTRING);
    expect(DT_RTLREADING, DRAW_TEXT_FORMAT.DT_RTLREADING);
    expect(DT_WORD_ELLIPSIS, DRAW_TEXT_FORMAT.DT_WORD_ELLIPSIS);
    expect(DT_NOFULLWIDTHCHARBREAK, DRAW_TEXT_FORMAT.DT_NOFULLWIDTHCHARBREAK);
    expect(DT_HIDEPREFIX, DRAW_TEXT_FORMAT.DT_HIDEPREFIX);
    expect(DT_PREFIXONLY, DRAW_TEXT_FORMAT.DT_PREFIXONLY);
    expect(CS_VREDRAW, WNDCLASS_STYLES.CS_VREDRAW);
    expect(CS_HREDRAW, WNDCLASS_STYLES.CS_HREDRAW);
    expect(CS_DBLCLKS, WNDCLASS_STYLES.CS_DBLCLKS);
    expect(CS_OWNDC, WNDCLASS_STYLES.CS_OWNDC);
    expect(CS_CLASSDC, WNDCLASS_STYLES.CS_CLASSDC);
    expect(CS_PARENTDC, WNDCLASS_STYLES.CS_PARENTDC);
    expect(CS_NOCLOSE, WNDCLASS_STYLES.CS_NOCLOSE);
    expect(CS_SAVEBITS, WNDCLASS_STYLES.CS_SAVEBITS);
    expect(CS_BYTEALIGNCLIENT, WNDCLASS_STYLES.CS_BYTEALIGNCLIENT);
    expect(CS_BYTEALIGNWINDOW, WNDCLASS_STYLES.CS_BYTEALIGNWINDOW);
    expect(CS_GLOBALCLASS, WNDCLASS_STYLES.CS_GLOBALCLASS);
    expect(CS_IME, WNDCLASS_STYLES.CS_IME);
    expect(CS_DROPSHADOW, WNDCLASS_STYLES.CS_DROPSHADOW);
    expect(MB_OK, MESSAGEBOX_STYLE.MB_OK);
    expect(MB_OKCANCEL, MESSAGEBOX_STYLE.MB_OKCANCEL);
    expect(MB_ABORTRETRYIGNORE, MESSAGEBOX_STYLE.MB_ABORTRETRYIGNORE);
    expect(MB_YESNOCANCEL, MESSAGEBOX_STYLE.MB_YESNOCANCEL);
    expect(MB_YESNO, MESSAGEBOX_STYLE.MB_YESNO);
    expect(MB_RETRYCANCEL, MESSAGEBOX_STYLE.MB_RETRYCANCEL);
    expect(MB_CANCELTRYCONTINUE, MESSAGEBOX_STYLE.MB_CANCELTRYCONTINUE);
    expect(MB_ICONHAND, MESSAGEBOX_STYLE.MB_ICONHAND);
    expect(MB_ICONQUESTION, MESSAGEBOX_STYLE.MB_ICONQUESTION);
    expect(MB_ICONEXCLAMATION, MESSAGEBOX_STYLE.MB_ICONEXCLAMATION);
    expect(MB_ICONASTERISK, MESSAGEBOX_STYLE.MB_ICONASTERISK);
    expect(MB_ICONWARNING, MESSAGEBOX_STYLE.MB_ICONWARNING);
    expect(MB_ICONERROR, MESSAGEBOX_STYLE.MB_ICONERROR);
    expect(MB_ICONINFORMATION, MESSAGEBOX_STYLE.MB_ICONINFORMATION);
    expect(MB_ICONSTOP, MESSAGEBOX_STYLE.MB_ICONSTOP);
    expect(MB_DEFBUTTON1, MESSAGEBOX_STYLE.MB_DEFBUTTON1);
    expect(MB_DEFBUTTON2, MESSAGEBOX_STYLE.MB_DEFBUTTON2);
    expect(MB_DEFBUTTON3, MESSAGEBOX_STYLE.MB_DEFBUTTON3);
    expect(MB_DEFBUTTON4, MESSAGEBOX_STYLE.MB_DEFBUTTON4);
    expect(MB_APPLMODAL, MESSAGEBOX_STYLE.MB_APPLMODAL);
    expect(MB_SYSTEMMODAL, MESSAGEBOX_STYLE.MB_SYSTEMMODAL);
    expect(MB_TASKMODAL, MESSAGEBOX_STYLE.MB_TASKMODAL);
    expect(MB_HELP, MESSAGEBOX_STYLE.MB_HELP);
    expect(MB_SETFOREGROUND, MESSAGEBOX_STYLE.MB_SETFOREGROUND);
    expect(MB_DEFAULT_DESKTOP_ONLY, MESSAGEBOX_STYLE.MB_DEFAULT_DESKTOP_ONLY);
    expect(MB_TOPMOST, MESSAGEBOX_STYLE.MB_TOPMOST);
    expect(MB_RIGHT, MESSAGEBOX_STYLE.MB_RIGHT);
    expect(MB_RTLREADING, MESSAGEBOX_STYLE.MB_RTLREADING);
    expect(MB_SERVICE_NOTIFICATION, MESSAGEBOX_STYLE.MB_SERVICE_NOTIFICATION);
    expect(MF_BYCOMMAND, MENU_ITEM_FLAGS.MF_BYCOMMAND);
    expect(MF_BYPOSITION, MENU_ITEM_FLAGS.MF_BYPOSITION);
    expect(MF_SEPARATOR, MENU_ITEM_FLAGS.MF_SEPARATOR);
    expect(MF_ENABLED, MENU_ITEM_FLAGS.MF_ENABLED);
    expect(MF_GRAYED, MENU_ITEM_FLAGS.MF_GRAYED);
    expect(MF_DISABLED, MENU_ITEM_FLAGS.MF_DISABLED);
    expect(MF_UNCHECKED, MENU_ITEM_FLAGS.MF_UNCHECKED);
    expect(MF_CHECKED, MENU_ITEM_FLAGS.MF_CHECKED);
    expect(MF_STRING, MENU_ITEM_FLAGS.MF_STRING);
    expect(MF_BITMAP, MENU_ITEM_FLAGS.MF_BITMAP);
    expect(MF_OWNERDRAW, MENU_ITEM_FLAGS.MF_OWNERDRAW);
    expect(MF_POPUP, MENU_ITEM_FLAGS.MF_POPUP);
    expect(MF_MENUBARBREAK, MENU_ITEM_FLAGS.MF_MENUBARBREAK);
    expect(MF_MENUBREAK, MENU_ITEM_FLAGS.MF_MENUBREAK);
    expect(MF_UNHILITE, MENU_ITEM_FLAGS.MF_UNHILITE);
    expect(MF_HILITE, MENU_ITEM_FLAGS.MF_HILITE);
    expect(SS_LEFT, STATIC_STYLES.SS_LEFT);
    expect(SS_CENTER, STATIC_STYLES.SS_CENTER);
    expect(SS_RIGHT, STATIC_STYLES.SS_RIGHT);
    expect(SS_ICON, STATIC_STYLES.SS_ICON);
    expect(SS_BLACKRECT, STATIC_STYLES.SS_BLACKRECT);
    expect(SS_GRAYRECT, STATIC_STYLES.SS_GRAYRECT);
    expect(SS_WHITERECT, STATIC_STYLES.SS_WHITERECT);
    expect(SS_BLACKFRAME, STATIC_STYLES.SS_BLACKFRAME);
    expect(SS_GRAYFRAME, STATIC_STYLES.SS_GRAYFRAME);
    expect(SS_WHITEFRAME, STATIC_STYLES.SS_WHITEFRAME);
    expect(SS_USERITEM, STATIC_STYLES.SS_USERITEM);
    expect(SS_SIMPLE, STATIC_STYLES.SS_SIMPLE);
    expect(SS_LEFTNOWORDWRAP, STATIC_STYLES.SS_LEFTNOWORDWRAP);
    expect(SS_OWNERDRAW, STATIC_STYLES.SS_OWNERDRAW);
    expect(SS_BITMAP, STATIC_STYLES.SS_BITMAP);
    expect(SS_ENHMETAFILE, STATIC_STYLES.SS_ENHMETAFILE);
    expect(SS_ETCHEDHORZ, STATIC_STYLES.SS_ETCHEDHORZ);
    expect(SS_ETCHEDVERT, STATIC_STYLES.SS_ETCHEDVERT);
    expect(SS_ETCHEDFRAME, STATIC_STYLES.SS_ETCHEDFRAME);
    expect(SS_TYPEMASK, STATIC_STYLES.SS_TYPEMASK);
    expect(SS_REALSIZECONTROL, STATIC_STYLES.SS_REALSIZECONTROL);
    expect(SS_NOPREFIX, STATIC_STYLES.SS_NOPREFIX);
    expect(SS_NOTIFY, STATIC_STYLES.SS_NOTIFY);
    expect(SS_CENTERIMAGE, STATIC_STYLES.SS_CENTERIMAGE);
    expect(SS_RIGHTJUST, STATIC_STYLES.SS_RIGHTJUST);
    expect(SS_REALSIZEIMAGE, STATIC_STYLES.SS_REALSIZEIMAGE);
    expect(SS_SUNKEN, STATIC_STYLES.SS_SUNKEN);
    expect(SS_EDITCONTROL, STATIC_STYLES.SS_EDITCONTROL);
    expect(SS_ENDELLIPSIS, STATIC_STYLES.SS_ENDELLIPSIS);
    expect(SS_PATHELLIPSIS, STATIC_STYLES.SS_PATHELLIPSIS);
    expect(SS_WORDELLIPSIS, STATIC_STYLES.SS_WORDELLIPSIS);
    expect(SS_ELLIPSISMASK, STATIC_STYLES.SS_ELLIPSISMASK);
    expect(PS_SOLID, PEN_STYLE.PS_SOLID);
    expect(PS_DASH, PEN_STYLE.PS_DASH);
    expect(PS_DOT, PEN_STYLE.PS_DOT);
    expect(PS_DASHDOT, PEN_STYLE.PS_DASHDOT);
    expect(PS_DASHDOTDOT, PEN_STYLE.PS_DASHDOTDOT);
    expect(PS_NULL, PEN_STYLE.PS_NULL);
    expect(PS_INSIDEFRAME, PEN_STYLE.PS_INSIDEFRAME);
    expect(PS_USERSTYLE, PEN_STYLE.PS_USERSTYLE);
    expect(PS_ALTERNATE, PEN_STYLE.PS_ALTERNATE);
    expect(PS_STYLE_MASK, PEN_STYLE.PS_STYLE_MASK);
    expect(PS_ENDCAP_ROUND, PEN_STYLE.PS_ENDCAP_ROUND);
    expect(PS_ENDCAP_SQUARE, PEN_STYLE.PS_ENDCAP_SQUARE);
    expect(PS_ENDCAP_FLAT, PEN_STYLE.PS_ENDCAP_FLAT);
    expect(PS_ENDCAP_MASK, PEN_STYLE.PS_ENDCAP_MASK);
    expect(PS_JOIN_ROUND, PEN_STYLE.PS_JOIN_ROUND);
    expect(PS_JOIN_BEVEL, PEN_STYLE.PS_JOIN_BEVEL);
    expect(PS_JOIN_MITER, PEN_STYLE.PS_JOIN_MITER);
    expect(PS_JOIN_MASK, PEN_STYLE.PS_JOIN_MASK);
    expect(PS_COSMETIC, PEN_STYLE.PS_COSMETIC);
    expect(PS_GEOMETRIC, PEN_STYLE.PS_GEOMETRIC);
    expect(PS_TYPE_MASK, PEN_STYLE.PS_TYPE_MASK);
    expect(BS_SOLID, BRUSH_STYLE.BS_SOLID);
    expect(BS_NULL, BRUSH_STYLE.BS_NULL);
    expect(BS_HOLLOW, BRUSH_STYLE.BS_HOLLOW);
    expect(BS_HATCHED, BRUSH_STYLE.BS_HATCHED);
    expect(BS_PATTERN, BRUSH_STYLE.BS_PATTERN);
    expect(BS_DIBPATTERN, BRUSH_STYLE.BS_DIBPATTERN);
    expect(BS_DIBPATTERNPT, BRUSH_STYLE.BS_DIBPATTERNPT);
    expect(BS_PATTERN8X8, BRUSH_STYLE.BS_PATTERN8X8);
    expect(BS_DIBPATTERN8X8, BRUSH_STYLE.BS_DIBPATTERN8X8);
    expect(HS_HORIZONTAL, HATCH_BRUSH_STYLE.HS_HORIZONTAL);
    expect(HS_VERTICAL, HATCH_BRUSH_STYLE.HS_VERTICAL);
    expect(HS_FDIAGONAL, HATCH_BRUSH_STYLE.HS_FDIAGONAL);
    expect(HS_BDIAGONAL, HATCH_BRUSH_STYLE.HS_BDIAGONAL);
    expect(HS_CROSS, HATCH_BRUSH_STYLE.HS_CROSS);
    expect(HS_DIAGCROSS, HATCH_BRUSH_STYLE.HS_DIAGCROSS);
    expect(BLACKONWHITE, STRETCH_BLT_MODE.BLACKONWHITE);
    expect(WHITEONBLACK, STRETCH_BLT_MODE.WHITEONBLACK);
    expect(COLORONCOLOR, STRETCH_BLT_MODE.COLORONCOLOR);
    expect(HALFTONE, STRETCH_BLT_MODE.HALFTONE);
    expect(STRETCH_ANDSCANS, STRETCH_BLT_MODE.STRETCH_ANDSCANS);
    expect(STRETCH_ORSCANS, STRETCH_BLT_MODE.STRETCH_ORSCANS);
    expect(STRETCH_DELETESCANS, STRETCH_BLT_MODE.STRETCH_DELETESCANS);
    expect(STRETCH_HALFTONE, STRETCH_BLT_MODE.STRETCH_HALFTONE);
    expect(STD_INPUT_HANDLE, STD_HANDLE.STD_INPUT_HANDLE);
    expect(STD_OUTPUT_HANDLE, STD_HANDLE.STD_OUTPUT_HANDLE);
    expect(STD_ERROR_HANDLE, STD_HANDLE.STD_ERROR_HANDLE);
    expect(ENABLE_ECHO_INPUT, CONSOLE_MODE.ENABLE_ECHO_INPUT);
    expect(ENABLE_EXTENDED_FLAGS, CONSOLE_MODE.ENABLE_EXTENDED_FLAGS);
    expect(ENABLE_INSERT_MODE, CONSOLE_MODE.ENABLE_INSERT_MODE);
    expect(ENABLE_LINE_INPUT, CONSOLE_MODE.ENABLE_LINE_INPUT);
    expect(ENABLE_MOUSE_INPUT, CONSOLE_MODE.ENABLE_MOUSE_INPUT);
    expect(ENABLE_PROCESSED_INPUT, CONSOLE_MODE.ENABLE_PROCESSED_INPUT);
    expect(ENABLE_QUICK_EDIT_MODE, CONSOLE_MODE.ENABLE_QUICK_EDIT_MODE);
    expect(ENABLE_WINDOW_INPUT, CONSOLE_MODE.ENABLE_WINDOW_INPUT);
    expect(ENABLE_VIRTUAL_TERMINAL_INPUT,
        CONSOLE_MODE.ENABLE_VIRTUAL_TERMINAL_INPUT);
    expect(ENABLE_PROCESSED_OUTPUT, CONSOLE_MODE.ENABLE_PROCESSED_OUTPUT);
    expect(ENABLE_WRAP_AT_EOL_OUTPUT, CONSOLE_MODE.ENABLE_WRAP_AT_EOL_OUTPUT);
    expect(ENABLE_VIRTUAL_TERMINAL_PROCESSING,
        CONSOLE_MODE.ENABLE_VIRTUAL_TERMINAL_PROCESSING);
    expect(
        DISABLE_NEWLINE_AUTO_RETURN, CONSOLE_MODE.DISABLE_NEWLINE_AUTO_RETURN);
    expect(ENABLE_LVB_GRID_WORLDWIDE, CONSOLE_MODE.ENABLE_LVB_GRID_WORLDWIDE);
    expect(RID_INPUT, RAW_INPUT_DATA_COMMAND_FLAGS.RID_INPUT);
    expect(RID_HEADER, RAW_INPUT_DATA_COMMAND_FLAGS.RID_HEADER);
    expect(
        RIDI_PREPARSEDDATA, RAW_INPUT_DEVICE_INFO_COMMAND.RIDI_PREPARSEDDATA);
    expect(RIDI_DEVICENAME, RAW_INPUT_DEVICE_INFO_COMMAND.RIDI_DEVICENAME);
    expect(RIDI_DEVICEINFO, RAW_INPUT_DEVICE_INFO_COMMAND.RIDI_DEVICEINFO);
    expect(RIDEV_REMOVE, RAWINPUTDEVICE_FLAGS.RIDEV_REMOVE);
    expect(RIDEV_EXCLUDE, RAWINPUTDEVICE_FLAGS.RIDEV_EXCLUDE);
    expect(RIDEV_PAGEONLY, RAWINPUTDEVICE_FLAGS.RIDEV_PAGEONLY);
    expect(RIDEV_NOLEGACY, RAWINPUTDEVICE_FLAGS.RIDEV_NOLEGACY);
    expect(RIDEV_INPUTSINK, RAWINPUTDEVICE_FLAGS.RIDEV_INPUTSINK);
    expect(RIDEV_CAPTUREMOUSE, RAWINPUTDEVICE_FLAGS.RIDEV_CAPTUREMOUSE);
    expect(RIDEV_NOHOTKEYS, RAWINPUTDEVICE_FLAGS.RIDEV_NOHOTKEYS);
    expect(RIDEV_APPKEYS, RAWINPUTDEVICE_FLAGS.RIDEV_APPKEYS);
    expect(RIDEV_EXINPUTSINK, RAWINPUTDEVICE_FLAGS.RIDEV_EXINPUTSINK);
    expect(RIDEV_DEVNOTIFY, RAWINPUTDEVICE_FLAGS.RIDEV_DEVNOTIFY);
    expect(MEM_COMMIT, VIRTUAL_ALLOCATION_TYPE.MEM_COMMIT);
    expect(MEM_RESERVE, VIRTUAL_ALLOCATION_TYPE.MEM_RESERVE);
    expect(MEM_REPLACE_PLACEHOLDER,
        VIRTUAL_ALLOCATION_TYPE.MEM_REPLACE_PLACEHOLDER);
    expect(MEM_RESERVE_PLACEHOLDER,
        VIRTUAL_ALLOCATION_TYPE.MEM_RESERVE_PLACEHOLDER);
    expect(MEM_RESET, VIRTUAL_ALLOCATION_TYPE.MEM_RESET);
    expect(MEM_RESET_UNDO, VIRTUAL_ALLOCATION_TYPE.MEM_RESET_UNDO);
    expect(MEM_LARGE_PAGES, VIRTUAL_ALLOCATION_TYPE.MEM_LARGE_PAGES);
    expect(MEM_UNMAP_WITH_TRANSIENT_BOOST,
        UNMAP_VIEW_OF_FILE_FLAGS.MEM_UNMAP_WITH_TRANSIENT_BOOST);
    expect(MEM_PRESERVE_PLACEHOLDER,
        UNMAP_VIEW_OF_FILE_FLAGS.MEM_PRESERVE_PLACEHOLDER);
    expect(MEM_DECOMMIT, VIRTUAL_FREE_TYPE.MEM_DECOMMIT);
    expect(MEM_RELEASE, VIRTUAL_FREE_TYPE.MEM_RELEASE);
    expect(MEM_FREE, VIRTUAL_ALLOCATION_TYPE.MEM_FREE);
    expect(MEM_IMAGE, PAGE_TYPE.MEM_IMAGE);
    expect(MEM_MAPPED, PAGE_TYPE.MEM_MAPPED);
    expect(MEM_PRIVATE, PAGE_TYPE.MEM_PRIVATE);
    expect(SEM_FAILCRITICALERRORS, THREAD_ERROR_MODE.SEM_FAILCRITICALERRORS);
    expect(SEM_NOGPFAULTERRORBOX, THREAD_ERROR_MODE.SEM_NOGPFAULTERRORBOX);
    expect(SEM_NOALIGNMENTFAULTEXCEPT,
        THREAD_ERROR_MODE.SEM_NOALIGNMENTFAULTEXCEPT);
    expect(SEM_NOOPENFILEERRORBOX, THREAD_ERROR_MODE.SEM_NOOPENFILEERRORBOX);
    expect(CALLBACK_NULL, MIDI_WAVE_OPEN_TYPE.CALLBACK_NULL);
    expect(CALLBACK_WINDOW, MIDI_WAVE_OPEN_TYPE.CALLBACK_WINDOW);
    expect(CALLBACK_THREAD, MIDI_WAVE_OPEN_TYPE.CALLBACK_THREAD);
    expect(CALLBACK_FUNCTION, MIDI_WAVE_OPEN_TYPE.CALLBACK_FUNCTION);
    expect(CALLBACK_EVENT, MIDI_WAVE_OPEN_TYPE.CALLBACK_EVENT);
    expect(LWA_COLORKEY, LAYERED_WINDOW_ATTRIBUTES_FLAGS.LWA_COLORKEY);
    expect(LWA_ALPHA, LAYERED_WINDOW_ATTRIBUTES_FLAGS.LWA_ALPHA);
    expect(MW_FILTERMODE_EXCLUDE, MW_FILTERMODE.MW_FILTERMODE_EXCLUDE);
    expect(MW_FILTERMODE_INCLUDE, MW_FILTERMODE.MW_FILTERMODE_INCLUDE);
    expect(DRIVERVERSION, GET_DEVICE_CAPS_INDEX.DRIVERVERSION);
    expect(TECHNOLOGY, GET_DEVICE_CAPS_INDEX.TECHNOLOGY);
    expect(HORZSIZE, GET_DEVICE_CAPS_INDEX.HORZSIZE);
    expect(VERTSIZE, GET_DEVICE_CAPS_INDEX.VERTSIZE);
    expect(HORZRES, GET_DEVICE_CAPS_INDEX.HORZRES);
    expect(VERTRES, GET_DEVICE_CAPS_INDEX.VERTRES);
    expect(BITSPIXEL, GET_DEVICE_CAPS_INDEX.BITSPIXEL);
    expect(PLANES, GET_DEVICE_CAPS_INDEX.PLANES);
    expect(NUMBRUSHES, GET_DEVICE_CAPS_INDEX.NUMBRUSHES);
    expect(NUMPENS, GET_DEVICE_CAPS_INDEX.NUMPENS);
    expect(NUMMARKERS, GET_DEVICE_CAPS_INDEX.NUMMARKERS);
    expect(NUMFONTS, GET_DEVICE_CAPS_INDEX.NUMFONTS);
    expect(NUMCOLORS, GET_DEVICE_CAPS_INDEX.NUMCOLORS);
    expect(PDEVICESIZE, GET_DEVICE_CAPS_INDEX.PDEVICESIZE);
    expect(CURVECAPS, GET_DEVICE_CAPS_INDEX.CURVECAPS);
    expect(LINECAPS, GET_DEVICE_CAPS_INDEX.LINECAPS);
    expect(POLYGONALCAPS, GET_DEVICE_CAPS_INDEX.POLYGONALCAPS);
    expect(TEXTCAPS, GET_DEVICE_CAPS_INDEX.TEXTCAPS);
    expect(CLIPCAPS, GET_DEVICE_CAPS_INDEX.CLIPCAPS);
    expect(RASTERCAPS, GET_DEVICE_CAPS_INDEX.RASTERCAPS);
    expect(ASPECTX, GET_DEVICE_CAPS_INDEX.ASPECTX);
    expect(ASPECTY, GET_DEVICE_CAPS_INDEX.ASPECTY);
    expect(ASPECTXY, GET_DEVICE_CAPS_INDEX.ASPECTXY);
    expect(LOGPIXELSX, GET_DEVICE_CAPS_INDEX.LOGPIXELSX);
    expect(LOGPIXELSY, GET_DEVICE_CAPS_INDEX.LOGPIXELSY);
    expect(SIZEPALETTE, GET_DEVICE_CAPS_INDEX.SIZEPALETTE);
    expect(NUMRESERVED, GET_DEVICE_CAPS_INDEX.NUMRESERVED);
    expect(COLORRES, GET_DEVICE_CAPS_INDEX.COLORRES);
    expect(PHYSICALWIDTH, GET_DEVICE_CAPS_INDEX.PHYSICALWIDTH);
    expect(PHYSICALHEIGHT, GET_DEVICE_CAPS_INDEX.PHYSICALHEIGHT);
    expect(PHYSICALOFFSETX, GET_DEVICE_CAPS_INDEX.PHYSICALOFFSETX);
    expect(PHYSICALOFFSETY, GET_DEVICE_CAPS_INDEX.PHYSICALOFFSETY);
    expect(SCALINGFACTORX, GET_DEVICE_CAPS_INDEX.SCALINGFACTORX);
    expect(SCALINGFACTORY, GET_DEVICE_CAPS_INDEX.SCALINGFACTORY);
    expect(VREFRESH, GET_DEVICE_CAPS_INDEX.VREFRESH);
    expect(DESKTOPVERTRES, GET_DEVICE_CAPS_INDEX.DESKTOPVERTRES);
    expect(DESKTOPHORZRES, GET_DEVICE_CAPS_INDEX.DESKTOPHORZRES);
    expect(BLTALIGNMENT, GET_DEVICE_CAPS_INDEX.BLTALIGNMENT);
    expect(SHADEBLENDCAPS, GET_DEVICE_CAPS_INDEX.SHADEBLENDCAPS);
    expect(COLORMGMTCAPS, GET_DEVICE_CAPS_INDEX.COLORMGMTCAPS);
    expect(DONT_RESOLVE_DLL_REFERENCES,
        LOAD_LIBRARY_FLAGS.DONT_RESOLVE_DLL_REFERENCES);
    expect(
        LOAD_LIBRARY_AS_DATAFILE, LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_AS_DATAFILE);
    expect(LOAD_WITH_ALTERED_SEARCH_PATH,
        LOAD_LIBRARY_FLAGS.LOAD_WITH_ALTERED_SEARCH_PATH);
    expect(LOAD_IGNORE_CODE_AUTHZ_LEVEL,
        LOAD_LIBRARY_FLAGS.LOAD_IGNORE_CODE_AUTHZ_LEVEL);
    expect(LOAD_LIBRARY_AS_IMAGE_RESOURCE,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_AS_IMAGE_RESOURCE);
    expect(LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE);
    expect(LOAD_LIBRARY_REQUIRE_SIGNED_TARGET,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_REQUIRE_SIGNED_TARGET);
    expect(LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR);
    expect(LOAD_LIBRARY_SEARCH_APPLICATION_DIR,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_SEARCH_APPLICATION_DIR);
    expect(LOAD_LIBRARY_SEARCH_USER_DIRS,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_SEARCH_USER_DIRS);
    expect(LOAD_LIBRARY_SEARCH_SYSTEM32,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_SEARCH_SYSTEM32);
    expect(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
    expect(LOAD_LIBRARY_SAFE_CURRENT_DIRS,
        LOAD_LIBRARY_FLAGS.LOAD_LIBRARY_SAFE_CURRENT_DIRS);
    expect(MONITOR_DEFAULTTONULL, MONITOR_FROM_FLAGS.MONITOR_DEFAULTTONULL);
    expect(
        MONITOR_DEFAULTTOPRIMARY, MONITOR_FROM_FLAGS.MONITOR_DEFAULTTOPRIMARY);
    expect(
        MONITOR_DEFAULTTONEAREST, MONITOR_FROM_FLAGS.MONITOR_DEFAULTTONEAREST);
    expect(BI_RGB, BI_COMPRESSION.BI_RGB);
    expect(BI_RLE8, BI_COMPRESSION.BI_RLE8);
    expect(BI_RLE4, BI_COMPRESSION.BI_RLE4);
    expect(BI_BITFIELDS, BI_COMPRESSION.BI_BITFIELDS);
    expect(BI_JPEG, BI_COMPRESSION.BI_JPEG);
    expect(BI_PNG, BI_COMPRESSION.BI_PNG);
    expect(CC_RGBINIT, CHOOSECOLOR_FLAGS.CC_RGBINIT);
    expect(CC_FULLOPEN, CHOOSECOLOR_FLAGS.CC_FULLOPEN);
    expect(CC_PREVENTFULLOPEN, CHOOSECOLOR_FLAGS.CC_PREVENTFULLOPEN);
    expect(CC_SHOWHELP, CHOOSECOLOR_FLAGS.CC_SHOWHELP);
    expect(CC_ENABLEHOOK, CHOOSECOLOR_FLAGS.CC_ENABLEHOOK);
    expect(CC_ENABLETEMPLATE, CHOOSECOLOR_FLAGS.CC_ENABLETEMPLATE);
    expect(CC_ENABLETEMPLATEHANDLE, CHOOSECOLOR_FLAGS.CC_ENABLETEMPLATEHANDLE);
    expect(CC_SOLIDCOLOR, CHOOSECOLOR_FLAGS.CC_SOLIDCOLOR);
    expect(CC_ANYCOLOR, CHOOSECOLOR_FLAGS.CC_ANYCOLOR);
    expect(CF_SCREENFONTS, CHOOSEFONT_FLAGS.CF_SCREENFONTS);
    expect(CF_PRINTERFONTS, CHOOSEFONT_FLAGS.CF_PRINTERFONTS);
    expect(CF_BOTH, CHOOSEFONT_FLAGS.CF_BOTH);
    expect(CF_SHOWHELP, CHOOSEFONT_FLAGS.CF_SHOWHELP);
    expect(CF_ENABLEHOOK, CHOOSEFONT_FLAGS.CF_ENABLEHOOK);
    expect(CF_ENABLETEMPLATE, CHOOSEFONT_FLAGS.CF_ENABLETEMPLATE);
    expect(CF_ENABLETEMPLATEHANDLE, CHOOSEFONT_FLAGS.CF_ENABLETEMPLATEHANDLE);
    expect(CF_INITTOLOGFONTSTRUCT, CHOOSEFONT_FLAGS.CF_INITTOLOGFONTSTRUCT);
    expect(CF_USESTYLE, CHOOSEFONT_FLAGS.CF_USESTYLE);
    expect(CF_EFFECTS, CHOOSEFONT_FLAGS.CF_EFFECTS);
    expect(CF_APPLY, CHOOSEFONT_FLAGS.CF_APPLY);
    expect(CF_ANSIONLY, CHOOSEFONT_FLAGS.CF_ANSIONLY);
    expect(CF_SCRIPTSONLY, CHOOSEFONT_FLAGS.CF_SCRIPTSONLY);
    expect(CF_NOVECTORFONTS, CHOOSEFONT_FLAGS.CF_NOVECTORFONTS);
    expect(CF_NOOEMFONTS, CHOOSEFONT_FLAGS.CF_NOOEMFONTS);
    expect(CF_NOSIMULATIONS, CHOOSEFONT_FLAGS.CF_NOSIMULATIONS);
    expect(CF_LIMITSIZE, CHOOSEFONT_FLAGS.CF_LIMITSIZE);
    expect(CF_FIXEDPITCHONLY, CHOOSEFONT_FLAGS.CF_FIXEDPITCHONLY);
    expect(CF_WYSIWYG, CHOOSEFONT_FLAGS.CF_WYSIWYG);
    expect(CF_FORCEFONTEXIST, CHOOSEFONT_FLAGS.CF_FORCEFONTEXIST);
    expect(CF_SCALABLEONLY, CHOOSEFONT_FLAGS.CF_SCALABLEONLY);
    expect(CF_TTONLY, CHOOSEFONT_FLAGS.CF_TTONLY);
    expect(CF_NOFACESEL, CHOOSEFONT_FLAGS.CF_NOFACESEL);
    expect(CF_NOSTYLESEL, CHOOSEFONT_FLAGS.CF_NOSTYLESEL);
    expect(CF_NOSIZESEL, CHOOSEFONT_FLAGS.CF_NOSIZESEL);
    expect(CF_SELECTSCRIPT, CHOOSEFONT_FLAGS.CF_SELECTSCRIPT);
    expect(CF_NOSCRIPTSEL, CHOOSEFONT_FLAGS.CF_NOSCRIPTSEL);
    expect(CF_NOVERTFONTS, CHOOSEFONT_FLAGS.CF_NOVERTFONTS);
    expect(CF_INACTIVEFONTS, CHOOSEFONT_FLAGS.CF_INACTIVEFONTS);
    expect(FR_DOWN, FINDREPLACE_FLAGS.FR_DOWN);
    expect(FR_WHOLEWORD, FINDREPLACE_FLAGS.FR_WHOLEWORD);
    expect(FR_MATCHCASE, FINDREPLACE_FLAGS.FR_MATCHCASE);
    expect(FR_FINDNEXT, FINDREPLACE_FLAGS.FR_FINDNEXT);
    expect(FR_REPLACE, FINDREPLACE_FLAGS.FR_REPLACE);
    expect(FR_REPLACEALL, FINDREPLACE_FLAGS.FR_REPLACEALL);
    expect(FR_DIALOGTERM, FINDREPLACE_FLAGS.FR_DIALOGTERM);
    expect(FR_SHOWHELP, FINDREPLACE_FLAGS.FR_SHOWHELP);
    expect(FR_ENABLEHOOK, FINDREPLACE_FLAGS.FR_ENABLEHOOK);
    expect(FR_ENABLETEMPLATE, FINDREPLACE_FLAGS.FR_ENABLETEMPLATE);
    expect(FR_NOUPDOWN, FINDREPLACE_FLAGS.FR_NOUPDOWN);
    expect(FR_NOMATCHCASE, FINDREPLACE_FLAGS.FR_NOMATCHCASE);
    expect(FR_NOWHOLEWORD, FINDREPLACE_FLAGS.FR_NOWHOLEWORD);
    expect(FR_ENABLETEMPLATEHANDLE, FINDREPLACE_FLAGS.FR_ENABLETEMPLATEHANDLE);
    expect(FR_HIDEUPDOWN, FINDREPLACE_FLAGS.FR_HIDEUPDOWN);
    expect(FR_HIDEMATCHCASE, FINDREPLACE_FLAGS.FR_HIDEMATCHCASE);
    expect(FR_HIDEWHOLEWORD, FINDREPLACE_FLAGS.FR_HIDEWHOLEWORD);
    expect(FR_MATCHDIAC, FINDREPLACE_FLAGS.FR_MATCHDIAC);
    expect(FR_MATCHKASHIDA, FINDREPLACE_FLAGS.FR_MATCHKASHIDA);
    expect(FR_MATCHALEFHAMZA, FINDREPLACE_FLAGS.FR_MATCHALEFHAMZA);
    expect(OFN_READONLY, OPEN_FILENAME_FLAGS.OFN_READONLY);
    expect(OFN_OVERWRITEPROMPT, OPEN_FILENAME_FLAGS.OFN_OVERWRITEPROMPT);
    expect(OFN_HIDEREADONLY, OPEN_FILENAME_FLAGS.OFN_HIDEREADONLY);
    expect(OFN_NOCHANGEDIR, OPEN_FILENAME_FLAGS.OFN_NOCHANGEDIR);
    expect(OFN_SHOWHELP, OPEN_FILENAME_FLAGS.OFN_SHOWHELP);
    expect(OFN_ENABLEHOOK, OPEN_FILENAME_FLAGS.OFN_ENABLEHOOK);
    expect(OFN_ENABLETEMPLATE, OPEN_FILENAME_FLAGS.OFN_ENABLETEMPLATE);
    expect(
        OFN_ENABLETEMPLATEHANDLE, OPEN_FILENAME_FLAGS.OFN_ENABLETEMPLATEHANDLE);
    expect(OFN_NOVALIDATE, OPEN_FILENAME_FLAGS.OFN_NOVALIDATE);
    expect(OFN_ALLOWMULTISELECT, OPEN_FILENAME_FLAGS.OFN_ALLOWMULTISELECT);
    expect(OFN_EXTENSIONDIFFERENT, OPEN_FILENAME_FLAGS.OFN_EXTENSIONDIFFERENT);
    expect(OFN_PATHMUSTEXIST, OPEN_FILENAME_FLAGS.OFN_PATHMUSTEXIST);
    expect(OFN_FILEMUSTEXIST, OPEN_FILENAME_FLAGS.OFN_FILEMUSTEXIST);
    expect(OFN_CREATEPROMPT, OPEN_FILENAME_FLAGS.OFN_CREATEPROMPT);
    expect(OFN_SHAREAWARE, OPEN_FILENAME_FLAGS.OFN_SHAREAWARE);
    expect(OFN_NOREADONLYRETURN, OPEN_FILENAME_FLAGS.OFN_NOREADONLYRETURN);
    expect(OFN_NOTESTFILECREATE, OPEN_FILENAME_FLAGS.OFN_NOTESTFILECREATE);
    expect(OFN_NONETWORKBUTTON, OPEN_FILENAME_FLAGS.OFN_NONETWORKBUTTON);
    expect(OFN_NOLONGNAMES, OPEN_FILENAME_FLAGS.OFN_NOLONGNAMES);
    expect(OFN_EXPLORER, OPEN_FILENAME_FLAGS.OFN_EXPLORER);
    expect(OFN_NODEREFERENCELINKS, OPEN_FILENAME_FLAGS.OFN_NODEREFERENCELINKS);
    expect(OFN_LONGNAMES, OPEN_FILENAME_FLAGS.OFN_LONGNAMES);
    expect(
        OFN_ENABLEINCLUDENOTIFY, OPEN_FILENAME_FLAGS.OFN_ENABLEINCLUDENOTIFY);
    expect(OFN_ENABLESIZING, OPEN_FILENAME_FLAGS.OFN_ENABLESIZING);
    expect(OFN_DONTADDTORECENT, OPEN_FILENAME_FLAGS.OFN_DONTADDTORECENT);
    expect(OFN_FORCESHOWHIDDEN, OPEN_FILENAME_FLAGS.OFN_FORCESHOWHIDDEN);
    expect(OFN_EX_NOPLACESBAR, OPEN_FILENAME_FLAGS_EX.OFN_EX_NOPLACESBAR);
    expect(TMT_CAPTIONFONT, THEME_PROPERTY_SYMBOL_ID.TMT_CAPTIONFONT);
    expect(TMT_SMALLCAPTIONFONT, THEME_PROPERTY_SYMBOL_ID.TMT_SMALLCAPTIONFONT);
    expect(TMT_MENUFONT, THEME_PROPERTY_SYMBOL_ID.TMT_MENUFONT);
    expect(TMT_STATUSFONT, THEME_PROPERTY_SYMBOL_ID.TMT_STATUSFONT);
    expect(TMT_MSGBOXFONT, THEME_PROPERTY_SYMBOL_ID.TMT_MSGBOXFONT);
    expect(TMT_ICONTITLEFONT, THEME_PROPERTY_SYMBOL_ID.TMT_ICONTITLEFONT);
    expect(DTT_TEXTCOLOR, DTTOPTS_FLAGS.DTT_TEXTCOLOR);
    expect(DTT_BORDERCOLOR, DTTOPTS_FLAGS.DTT_BORDERCOLOR);
    expect(DTT_SHADOWCOLOR, DTTOPTS_FLAGS.DTT_SHADOWCOLOR);
    expect(DTT_SHADOWTYPE, DTTOPTS_FLAGS.DTT_SHADOWTYPE);
    expect(DTT_SHADOWOFFSET, DTTOPTS_FLAGS.DTT_SHADOWOFFSET);
    expect(DTT_BORDERSIZE, DTTOPTS_FLAGS.DTT_BORDERSIZE);
    expect(DTT_FONTPROP, DTTOPTS_FLAGS.DTT_FONTPROP);
    expect(DTT_COLORPROP, DTTOPTS_FLAGS.DTT_COLORPROP);
    expect(DTT_STATEID, DTTOPTS_FLAGS.DTT_STATEID);
    expect(DTT_CALCRECT, DTTOPTS_FLAGS.DTT_CALCRECT);
    expect(DTT_APPLYOVERLAY, DTTOPTS_FLAGS.DTT_APPLYOVERLAY);
    expect(DTT_GLOWSIZE, DTTOPTS_FLAGS.DTT_GLOWSIZE);
    expect(DTT_CALLBACK, DTTOPTS_FLAGS.DTT_CALLBACK);
    expect(DTT_COMPOSITED, DTTOPTS_FLAGS.DTT_COMPOSITED);
    expect(DTT_VALIDBITS, DTTOPTS_FLAGS.DTT_VALIDBITS);
    expect(PURGE_TXABORT, PURGE_COMM_FLAGS.PURGE_TXABORT);
    expect(PURGE_RXABORT, PURGE_COMM_FLAGS.PURGE_RXABORT);
    expect(PURGE_TXCLEAR, PURGE_COMM_FLAGS.PURGE_TXCLEAR);
    expect(PURGE_RXCLEAR, PURGE_COMM_FLAGS.PURGE_RXCLEAR);
    expect(SHUTDOWN_FORCE_OTHERS, SHUTDOWN_FLAGS.SHUTDOWN_FORCE_OTHERS);
    expect(SHUTDOWN_FORCE_SELF, SHUTDOWN_FLAGS.SHUTDOWN_FORCE_SELF);
    expect(SHUTDOWN_RESTART, SHUTDOWN_FLAGS.SHUTDOWN_RESTART);
    expect(SHUTDOWN_POWEROFF, SHUTDOWN_FLAGS.SHUTDOWN_POWEROFF);
    expect(SHUTDOWN_NOREBOOT, SHUTDOWN_FLAGS.SHUTDOWN_NOREBOOT);
    expect(SHUTDOWN_GRACE_OVERRIDE, SHUTDOWN_FLAGS.SHUTDOWN_GRACE_OVERRIDE);
    expect(SHUTDOWN_INSTALL_UPDATES, SHUTDOWN_FLAGS.SHUTDOWN_INSTALL_UPDATES);
    expect(SHUTDOWN_RESTARTAPPS, SHUTDOWN_FLAGS.SHUTDOWN_RESTARTAPPS);
    expect(SHUTDOWN_HYBRID, SHUTDOWN_FLAGS.SHUTDOWN_HYBRID);
    expect(FOF_MULTIDESTFILES, FILEOPERATION_FLAGS.FOF_MULTIDESTFILES);
    expect(FOF_SILENT, FILEOPERATION_FLAGS.FOF_SILENT);
    expect(FOF_RENAMEONCOLLISION, FILEOPERATION_FLAGS.FOF_RENAMEONCOLLISION);
    expect(FOF_NOCONFIRMATION, FILEOPERATION_FLAGS.FOF_NOCONFIRMATION);
    expect(FOF_WANTMAPPINGHANDLE, FILEOPERATION_FLAGS.FOF_WANTMAPPINGHANDLE);
    expect(FOF_ALLOWUNDO, FILEOPERATION_FLAGS.FOF_ALLOWUNDO);
    expect(FOF_FILESONLY, FILEOPERATION_FLAGS.FOF_FILESONLY);
    expect(FOF_SIMPLEPROGRESS, FILEOPERATION_FLAGS.FOF_SIMPLEPROGRESS);
    expect(FOF_NOCONFIRMMKDIR, FILEOPERATION_FLAGS.FOF_NOCONFIRMMKDIR);
    expect(FOF_NOERRORUI, FILEOPERATION_FLAGS.FOF_NOERRORUI);
    expect(FOF_NOCOPYSECURITYATTRIBS,
        FILEOPERATION_FLAGS.FOF_NOCOPYSECURITYATTRIBS);
    expect(FOF_NORECURSION, FILEOPERATION_FLAGS.FOF_NORECURSION);
    expect(FOF_NO_CONNECTED_ELEMENTS,
        FILEOPERATION_FLAGS.FOF_NO_CONNECTED_ELEMENTS);
    expect(FOF_WANTNUKEWARNING, FILEOPERATION_FLAGS.FOF_WANTNUKEWARNING);
    expect(FOF_NO_UI, FILEOPERATION_FLAGS.FOF_NO_UI);
    expect(NIM_ADD, NOTIFY_ICON_MESSAGE.NIM_ADD);
    expect(NIM_MODIFY, NOTIFY_ICON_MESSAGE.NIM_MODIFY);
    expect(NIM_DELETE, NOTIFY_ICON_MESSAGE.NIM_DELETE);
    expect(NIM_SETFOCUS, NOTIFY_ICON_MESSAGE.NIM_SETFOCUS);
    expect(NIM_SETVERSION, NOTIFY_ICON_MESSAGE.NIM_SETVERSION);
    expect(NIF_MESSAGE, NOTIFY_ICON_DATA_FLAGS.NIF_MESSAGE);
    expect(NIF_ICON, NOTIFY_ICON_DATA_FLAGS.NIF_ICON);
    expect(NIF_TIP, NOTIFY_ICON_DATA_FLAGS.NIF_TIP);
    expect(NIF_STATE, NOTIFY_ICON_DATA_FLAGS.NIF_STATE);
    expect(NIF_INFO, NOTIFY_ICON_DATA_FLAGS.NIF_INFO);
    expect(NIF_GUID, NOTIFY_ICON_DATA_FLAGS.NIF_GUID);
    expect(NIF_REALTIME, NOTIFY_ICON_DATA_FLAGS.NIF_REALTIME);
    expect(NIF_SHOWTIP, NOTIFY_ICON_DATA_FLAGS.NIF_SHOWTIP);
    expect(NIS_HIDDEN, NOTIFY_ICON_STATE.NIS_HIDDEN);
    expect(NIS_SHAREDICON, NOTIFY_ICON_STATE.NIS_SHAREDICON);
    expect(NIIF_NONE, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_NONE);
    expect(NIIF_INFO, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_INFO);
    expect(NIIF_WARNING, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_WARNING);
    expect(NIIF_ERROR, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_ERROR);
    expect(NIIF_USER, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_USER);
    expect(NIIF_ICON_MASK, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_ICON_MASK);
    expect(NIIF_NOSOUND, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_NOSOUND);
    expect(NIIF_LARGE_ICON, NOTIFY_ICON_INFOTIP_FLAGS.NIIF_LARGE_ICON);
    expect(NIIF_RESPECT_QUIET_TIME,
        NOTIFY_ICON_INFOTIP_FLAGS.NIIF_RESPECT_QUIET_TIME);
    expect(DEVICE_NOTIFY_WINDOW_HANDLE,
        REGISTER_NOTIFICATION_FLAGS.DEVICE_NOTIFY_WINDOW_HANDLE);
    expect(DEVICE_NOTIFY_SERVICE_HANDLE,
        REGISTER_NOTIFICATION_FLAGS.DEVICE_NOTIFY_SERVICE_HANDLE);
    expect(TPM_LEFTBUTTON, TRACK_POPUP_MENU_FLAGS.TPM_LEFTBUTTON);
    expect(TPM_RIGHTBUTTON, TRACK_POPUP_MENU_FLAGS.TPM_RIGHTBUTTON);
    expect(TPM_LEFTALIGN, TRACK_POPUP_MENU_FLAGS.TPM_LEFTALIGN);
    expect(TPM_CENTERALIGN, TRACK_POPUP_MENU_FLAGS.TPM_CENTERALIGN);
    expect(TPM_RIGHTALIGN, TRACK_POPUP_MENU_FLAGS.TPM_RIGHTALIGN);
    expect(TPM_TOPALIGN, TRACK_POPUP_MENU_FLAGS.TPM_TOPALIGN);
    expect(TPM_VCENTERALIGN, TRACK_POPUP_MENU_FLAGS.TPM_VCENTERALIGN);
    expect(TPM_BOTTOMALIGN, TRACK_POPUP_MENU_FLAGS.TPM_BOTTOMALIGN);
    expect(TPM_HORIZONTAL, TRACK_POPUP_MENU_FLAGS.TPM_HORIZONTAL);
    expect(TPM_VERTICAL, TRACK_POPUP_MENU_FLAGS.TPM_VERTICAL);
    expect(TPM_NONOTIFY, TRACK_POPUP_MENU_FLAGS.TPM_NONOTIFY);
    expect(TPM_RETURNCMD, TRACK_POPUP_MENU_FLAGS.TPM_RETURNCMD);
    expect(TPM_RECURSE, TRACK_POPUP_MENU_FLAGS.TPM_RECURSE);
    expect(TPM_HORPOSANIMATION, TRACK_POPUP_MENU_FLAGS.TPM_HORPOSANIMATION);
    expect(TPM_HORNEGANIMATION, TRACK_POPUP_MENU_FLAGS.TPM_HORNEGANIMATION);
    expect(TPM_VERPOSANIMATION, TRACK_POPUP_MENU_FLAGS.TPM_VERPOSANIMATION);
    expect(TPM_VERNEGANIMATION, TRACK_POPUP_MENU_FLAGS.TPM_VERNEGANIMATION);
    expect(TPM_NOANIMATION, TRACK_POPUP_MENU_FLAGS.TPM_NOANIMATION);
    expect(TPM_LAYOUTRTL, TRACK_POPUP_MENU_FLAGS.TPM_LAYOUTRTL);
    expect(TPM_WORKAREA, TRACK_POPUP_MENU_FLAGS.TPM_WORKAREA);
    expect(IMAGE_BITMAP, GDI_IMAGE_TYPE.IMAGE_BITMAP);
    expect(IMAGE_ICON, GDI_IMAGE_TYPE.IMAGE_ICON);
    expect(IMAGE_CURSOR, GDI_IMAGE_TYPE.IMAGE_CURSOR);
    expect(LR_DEFAULTCOLOR, IMAGE_FLAGS.LR_DEFAULTCOLOR);
    expect(LR_MONOCHROME, IMAGE_FLAGS.LR_MONOCHROME);
    expect(LR_COPYRETURNORG, IMAGE_FLAGS.LR_COPYRETURNORG);
    expect(LR_COPYDELETEORG, IMAGE_FLAGS.LR_COPYDELETEORG);
    expect(LR_LOADFROMFILE, IMAGE_FLAGS.LR_LOADFROMFILE);
    expect(LR_LOADTRANSPARENT, IMAGE_FLAGS.LR_LOADTRANSPARENT);
    expect(LR_DEFAULTSIZE, IMAGE_FLAGS.LR_DEFAULTSIZE);
    expect(LR_VGACOLOR, IMAGE_FLAGS.LR_VGACOLOR);
    expect(LR_LOADMAP3DCOLORS, IMAGE_FLAGS.LR_LOADMAP3DCOLORS);
    expect(LR_CREATEDIBSECTION, IMAGE_FLAGS.LR_CREATEDIBSECTION);
    expect(LR_COPYFROMRESOURCE, IMAGE_FLAGS.LR_COPYFROMRESOURCE);
    expect(LR_SHARED, IMAGE_FLAGS.LR_SHARED);
    expect(GW_CHILD, GET_WINDOW_CMD.GW_CHILD);
    expect(GW_ENABLEDPOPUP, GET_WINDOW_CMD.GW_ENABLEDPOPUP);
    expect(GW_HWNDFIRST, GET_WINDOW_CMD.GW_HWNDFIRST);
    expect(GW_HWNDLAST, GET_WINDOW_CMD.GW_HWNDLAST);
    expect(GW_HWNDNEXT, GET_WINDOW_CMD.GW_HWNDNEXT);
    expect(GW_HWNDPREV, GET_WINDOW_CMD.GW_HWNDPREV);
    expect(GW_OWNER, GET_WINDOW_CMD.GW_OWNER);
    expect(GCL_MENUNAME, GET_CLASS_LONG_INDEX.GCL_MENUNAME);
    expect(GCL_HBRBACKGROUND, GET_CLASS_LONG_INDEX.GCL_HBRBACKGROUND);
    expect(GCL_HCURSOR, GET_CLASS_LONG_INDEX.GCL_HCURSOR);
    expect(GCL_HICON, GET_CLASS_LONG_INDEX.GCL_HICON);
    expect(GCL_HMODULE, GET_CLASS_LONG_INDEX.GCL_HMODULE);
    expect(GCL_CBWNDEXTRA, GET_CLASS_LONG_INDEX.GCL_CBWNDEXTRA);
    expect(GCL_CBCLSEXTRA, GET_CLASS_LONG_INDEX.GCL_CBCLSEXTRA);
    expect(GCL_WNDPROC, GET_CLASS_LONG_INDEX.GCL_WNDPROC);
    expect(GCL_STYLE, GET_CLASS_LONG_INDEX.GCL_STYLE);
    expect(GCW_ATOM, GET_CLASS_LONG_INDEX.GCW_ATOM);
    expect(DIGCF_DEFAULT, SETUP_DI_GET_CLASS_DEVS_FLAGS.DIGCF_DEFAULT);
    expect(DIGCF_PRESENT, SETUP_DI_GET_CLASS_DEVS_FLAGS.DIGCF_PRESENT);
    expect(DIGCF_ALLCLASSES, SETUP_DI_GET_CLASS_DEVS_FLAGS.DIGCF_ALLCLASSES);
    expect(DIGCF_PROFILE, SETUP_DI_GET_CLASS_DEVS_FLAGS.DIGCF_PROFILE);
    expect(DIGCF_DEVICEINTERFACE,
        SETUP_DI_GET_CLASS_DEVS_FLAGS.DIGCF_DEVICEINTERFACE);
    expect(DICS_FLAG_GLOBAL, SETUP_DI_PROPERTY_CHANGE_SCOPE.DICS_FLAG_GLOBAL);
    expect(DICS_FLAG_CONFIGSPECIFIC,
        SETUP_DI_PROPERTY_CHANGE_SCOPE.DICS_FLAG_CONFIGSPECIFIC);
    expect(DICS_FLAG_CONFIGGENERAL,
        SETUP_DI_PROPERTY_CHANGE_SCOPE.DICS_FLAG_CONFIGGENERAL);
    expect(REG_NONE, REG_VALUE_TYPE.REG_NONE);
    expect(REG_SZ, REG_VALUE_TYPE.REG_SZ);
    expect(REG_EXPAND_SZ, REG_VALUE_TYPE.REG_EXPAND_SZ);
    expect(REG_BINARY, REG_VALUE_TYPE.REG_BINARY);
    expect(REG_DWORD, REG_VALUE_TYPE.REG_DWORD);
    expect(REG_DWORD_LITTLE_ENDIAN, REG_VALUE_TYPE.REG_DWORD_LITTLE_ENDIAN);
    expect(REG_DWORD_BIG_ENDIAN, REG_VALUE_TYPE.REG_DWORD_BIG_ENDIAN);
    expect(REG_LINK, REG_VALUE_TYPE.REG_LINK);
    expect(REG_MULTI_SZ, REG_VALUE_TYPE.REG_MULTI_SZ);
    expect(REG_QWORD, REG_VALUE_TYPE.REG_QWORD);
    expect(REG_QWORD_LITTLE_ENDIAN, REG_VALUE_TYPE.REG_QWORD_LITTLE_ENDIAN);
    expect(KEY_QUERY_VALUE, REG_SAM_FLAGS.KEY_QUERY_VALUE);
    expect(KEY_SET_VALUE, REG_SAM_FLAGS.KEY_SET_VALUE);
    expect(KEY_CREATE_SUB_KEY, REG_SAM_FLAGS.KEY_CREATE_SUB_KEY);
    expect(KEY_ENUMERATE_SUB_KEYS, REG_SAM_FLAGS.KEY_ENUMERATE_SUB_KEYS);
    expect(KEY_NOTIFY, REG_SAM_FLAGS.KEY_NOTIFY);
    expect(KEY_CREATE_LINK, REG_SAM_FLAGS.KEY_CREATE_LINK);
    expect(KEY_WOW64_32KEY, REG_SAM_FLAGS.KEY_WOW64_32KEY);
    expect(KEY_WOW64_64KEY, REG_SAM_FLAGS.KEY_WOW64_64KEY);
    expect(KEY_READ, REG_SAM_FLAGS.KEY_READ);
    expect(KEY_WRITE, REG_SAM_FLAGS.KEY_WRITE);
    expect(KEY_EXECUTE, REG_SAM_FLAGS.KEY_EXECUTE);
    expect(KEY_ALL_ACCESS, REG_SAM_FLAGS.KEY_ALL_ACCESS);
    expect(REG_NOTIFY_CHANGE_NAME, REG_NOTIFY_FILTER.REG_NOTIFY_CHANGE_NAME);
    expect(REG_NOTIFY_CHANGE_ATTRIBUTES,
        REG_NOTIFY_FILTER.REG_NOTIFY_CHANGE_ATTRIBUTES);
    expect(REG_NOTIFY_CHANGE_LAST_SET,
        REG_NOTIFY_FILTER.REG_NOTIFY_CHANGE_LAST_SET);
    expect(REG_NOTIFY_CHANGE_SECURITY,
        REG_NOTIFY_FILTER.REG_NOTIFY_CHANGE_SECURITY);
    expect(REG_NOTIFY_THREAD_AGNOSTIC,
        REG_NOTIFY_FILTER.REG_NOTIFY_THREAD_AGNOSTIC);
    expect(
        SDC_TOPOLOGY_INTERNAL, SET_DISPLAY_CONFIG_FLAGS.SDC_TOPOLOGY_INTERNAL);
    expect(SDC_TOPOLOGY_CLONE, SET_DISPLAY_CONFIG_FLAGS.SDC_TOPOLOGY_CLONE);
    expect(SDC_TOPOLOGY_EXTEND, SET_DISPLAY_CONFIG_FLAGS.SDC_TOPOLOGY_EXTEND);
    expect(
        SDC_TOPOLOGY_EXTERNAL, SET_DISPLAY_CONFIG_FLAGS.SDC_TOPOLOGY_EXTERNAL);
    expect(
        SDC_TOPOLOGY_SUPPLIED, SET_DISPLAY_CONFIG_FLAGS.SDC_TOPOLOGY_SUPPLIED);
    expect(SDC_USE_DATABASE_CURRENT,
        SET_DISPLAY_CONFIG_FLAGS.SDC_USE_DATABASE_CURRENT);
    expect(SDC_USE_SUPPLIED_DISPLAY_CONFIG,
        SET_DISPLAY_CONFIG_FLAGS.SDC_USE_SUPPLIED_DISPLAY_CONFIG);
    expect(SDC_VALIDATE, SET_DISPLAY_CONFIG_FLAGS.SDC_VALIDATE);
    expect(SDC_APPLY, SET_DISPLAY_CONFIG_FLAGS.SDC_APPLY);
    expect(SDC_NO_OPTIMIZATION, SET_DISPLAY_CONFIG_FLAGS.SDC_NO_OPTIMIZATION);
    expect(SDC_SAVE_TO_DATABASE, SET_DISPLAY_CONFIG_FLAGS.SDC_SAVE_TO_DATABASE);
    expect(SDC_ALLOW_CHANGES, SET_DISPLAY_CONFIG_FLAGS.SDC_ALLOW_CHANGES);
    expect(SDC_PATH_PERSIST_IF_REQUIRED,
        SET_DISPLAY_CONFIG_FLAGS.SDC_PATH_PERSIST_IF_REQUIRED);
    expect(SDC_FORCE_MODE_ENUMERATION,
        SET_DISPLAY_CONFIG_FLAGS.SDC_FORCE_MODE_ENUMERATION);
    expect(SDC_ALLOW_PATH_ORDER_CHANGES,
        SET_DISPLAY_CONFIG_FLAGS.SDC_ALLOW_PATH_ORDER_CHANGES);
    expect(SDC_VIRTUAL_MODE_AWARE,
        SET_DISPLAY_CONFIG_FLAGS.SDC_VIRTUAL_MODE_AWARE);
    expect(SDC_VIRTUAL_REFRESH_RATE_AWARE,
        SET_DISPLAY_CONFIG_FLAGS.SDC_VIRTUAL_REFRESH_RATE_AWARE);
    expect(UIA_AnnotationPatternId, UIA_PATTERN_ID.UIA_AnnotationPatternId);
    expect(UIA_CustomNavigationPatternId,
        UIA_PATTERN_ID.UIA_CustomNavigationPatternId);
    expect(UIA_DockPatternId, UIA_PATTERN_ID.UIA_DockPatternId);
    expect(UIA_DragPatternId, UIA_PATTERN_ID.UIA_DragPatternId);
    expect(UIA_DropTargetPatternId, UIA_PATTERN_ID.UIA_DropTargetPatternId);
    expect(UIA_ExpandCollapsePatternId,
        UIA_PATTERN_ID.UIA_ExpandCollapsePatternId);
    expect(UIA_GridItemPatternId, UIA_PATTERN_ID.UIA_GridItemPatternId);
    expect(UIA_GridPatternId, UIA_PATTERN_ID.UIA_GridPatternId);
    expect(UIA_InvokePatternId, UIA_PATTERN_ID.UIA_InvokePatternId);
    expect(
        UIA_ItemContainerPatternId, UIA_PATTERN_ID.UIA_ItemContainerPatternId);
    expect(UIA_LegacyIAccessiblePatternId,
        UIA_PATTERN_ID.UIA_LegacyIAccessiblePatternId);
    expect(UIA_MultipleViewPatternId, UIA_PATTERN_ID.UIA_MultipleViewPatternId);
    expect(UIA_ObjectModelPatternId, UIA_PATTERN_ID.UIA_ObjectModelPatternId);
    expect(UIA_RangeValuePatternId, UIA_PATTERN_ID.UIA_RangeValuePatternId);
    expect(UIA_ScrollItemPatternId, UIA_PATTERN_ID.UIA_ScrollItemPatternId);
    expect(UIA_ScrollPatternId, UIA_PATTERN_ID.UIA_ScrollPatternId);
    expect(
        UIA_SelectionItemPatternId, UIA_PATTERN_ID.UIA_SelectionItemPatternId);
    expect(UIA_SelectionPatternId, UIA_PATTERN_ID.UIA_SelectionPatternId);
    expect(UIA_SpreadsheetPatternId, UIA_PATTERN_ID.UIA_SpreadsheetPatternId);
    expect(UIA_SpreadsheetItemPatternId,
        UIA_PATTERN_ID.UIA_SpreadsheetItemPatternId);
    expect(UIA_StylesPatternId, UIA_PATTERN_ID.UIA_StylesPatternId);
    expect(UIA_SynchronizedInputPatternId,
        UIA_PATTERN_ID.UIA_SynchronizedInputPatternId);
    expect(UIA_TableItemPatternId, UIA_PATTERN_ID.UIA_TableItemPatternId);
    expect(UIA_TablePatternId, UIA_PATTERN_ID.UIA_TablePatternId);
    expect(UIA_TextChildPatternId, UIA_PATTERN_ID.UIA_TextChildPatternId);
    expect(UIA_TextEditPatternId, UIA_PATTERN_ID.UIA_TextEditPatternId);
    expect(UIA_TextPatternId, UIA_PATTERN_ID.UIA_TextPatternId);
    expect(UIA_TextPattern2Id, UIA_PATTERN_ID.UIA_TextPattern2Id);
    expect(UIA_TogglePatternId, UIA_PATTERN_ID.UIA_TogglePatternId);
    expect(UIA_TransformPatternId, UIA_PATTERN_ID.UIA_TransformPatternId);
    expect(UIA_TransformPattern2Id, UIA_PATTERN_ID.UIA_TransformPattern2Id);
    expect(UIA_ValuePatternId, UIA_PATTERN_ID.UIA_ValuePatternId);
    expect(UIA_VirtualizedItemPatternId,
        UIA_PATTERN_ID.UIA_VirtualizedItemPatternId);
    expect(UIA_WindowPatternId, UIA_PATTERN_ID.UIA_WindowPatternId);
    expect(UIA_AppBarControlTypeId, UIA_CONTROLTYPE_ID.UIA_AppBarControlTypeId);
    expect(UIA_ButtonControlTypeId, UIA_CONTROLTYPE_ID.UIA_ButtonControlTypeId);
    expect(UIA_CalendarControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_CalendarControlTypeId);
    expect(UIA_CheckBoxControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_CheckBoxControlTypeId);
    expect(UIA_ComboBoxControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_ComboBoxControlTypeId);
    expect(UIA_CustomControlTypeId, UIA_CONTROLTYPE_ID.UIA_CustomControlTypeId);
    expect(UIA_DataGridControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_DataGridControlTypeId);
    expect(UIA_DataItemControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_DataItemControlTypeId);
    expect(UIA_DocumentControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_DocumentControlTypeId);
    expect(UIA_EditControlTypeId, UIA_CONTROLTYPE_ID.UIA_EditControlTypeId);
    expect(UIA_GroupControlTypeId, UIA_CONTROLTYPE_ID.UIA_GroupControlTypeId);
    expect(UIA_HeaderControlTypeId, UIA_CONTROLTYPE_ID.UIA_HeaderControlTypeId);
    expect(UIA_HeaderItemControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_HeaderItemControlTypeId);
    expect(UIA_HyperlinkControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_HyperlinkControlTypeId);
    expect(UIA_ImageControlTypeId, UIA_CONTROLTYPE_ID.UIA_ImageControlTypeId);
    expect(UIA_ListControlTypeId, UIA_CONTROLTYPE_ID.UIA_ListControlTypeId);
    expect(UIA_ListItemControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_ListItemControlTypeId);
    expect(
        UIA_MenuBarControlTypeId, UIA_CONTROLTYPE_ID.UIA_MenuBarControlTypeId);
    expect(UIA_MenuControlTypeId, UIA_CONTROLTYPE_ID.UIA_MenuControlTypeId);
    expect(UIA_MenuItemControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_MenuItemControlTypeId);
    expect(UIA_PaneControlTypeId, UIA_CONTROLTYPE_ID.UIA_PaneControlTypeId);
    expect(UIA_ProgressBarControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_ProgressBarControlTypeId);
    expect(UIA_RadioButtonControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_RadioButtonControlTypeId);
    expect(UIA_ScrollBarControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_ScrollBarControlTypeId);
    expect(UIA_SemanticZoomControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_SemanticZoomControlTypeId);
    expect(UIA_SeparatorControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_SeparatorControlTypeId);
    expect(UIA_SliderControlTypeId, UIA_CONTROLTYPE_ID.UIA_SliderControlTypeId);
    expect(
        UIA_SpinnerControlTypeId, UIA_CONTROLTYPE_ID.UIA_SpinnerControlTypeId);
    expect(UIA_SplitButtonControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_SplitButtonControlTypeId);
    expect(UIA_StatusBarControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_StatusBarControlTypeId);
    expect(UIA_TabControlTypeId, UIA_CONTROLTYPE_ID.UIA_TabControlTypeId);
    expect(
        UIA_TabItemControlTypeId, UIA_CONTROLTYPE_ID.UIA_TabItemControlTypeId);
    expect(UIA_TableControlTypeId, UIA_CONTROLTYPE_ID.UIA_TableControlTypeId);
    expect(UIA_TextControlTypeId, UIA_CONTROLTYPE_ID.UIA_TextControlTypeId);
    expect(UIA_ThumbControlTypeId, UIA_CONTROLTYPE_ID.UIA_ThumbControlTypeId);
    expect(UIA_TitleBarControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_TitleBarControlTypeId);
    expect(
        UIA_ToolBarControlTypeId, UIA_CONTROLTYPE_ID.UIA_ToolBarControlTypeId);
    expect(
        UIA_ToolTipControlTypeId, UIA_CONTROLTYPE_ID.UIA_ToolTipControlTypeId);
    expect(UIA_TreeControlTypeId, UIA_CONTROLTYPE_ID.UIA_TreeControlTypeId);
    expect(UIA_TreeItemControlTypeId,
        UIA_CONTROLTYPE_ID.UIA_TreeItemControlTypeId);
    expect(UIA_WindowControlTypeId, UIA_CONTROLTYPE_ID.UIA_WindowControlTypeId);
    expect(UIA_AcceleratorKeyPropertyId,
        UIA_PROPERTY_ID.UIA_AcceleratorKeyPropertyId);
    expect(UIA_AccessKeyPropertyId, UIA_PROPERTY_ID.UIA_AccessKeyPropertyId);
    expect(UIA_AnnotationObjectsPropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationObjectsPropertyId);
    expect(UIA_AnnotationTypesPropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationTypesPropertyId);
    expect(UIA_AriaPropertiesPropertyId,
        UIA_PROPERTY_ID.UIA_AriaPropertiesPropertyId);
    expect(UIA_AriaRolePropertyId, UIA_PROPERTY_ID.UIA_AriaRolePropertyId);
    expect(
        UIA_AutomationIdPropertyId, UIA_PROPERTY_ID.UIA_AutomationIdPropertyId);
    expect(UIA_BoundingRectanglePropertyId,
        UIA_PROPERTY_ID.UIA_BoundingRectanglePropertyId);
    expect(
        UIA_CenterPointPropertyId, UIA_PROPERTY_ID.UIA_CenterPointPropertyId);
    expect(UIA_ClassNamePropertyId, UIA_PROPERTY_ID.UIA_ClassNamePropertyId);
    expect(UIA_ClickablePointPropertyId,
        UIA_PROPERTY_ID.UIA_ClickablePointPropertyId);
    expect(UIA_ControllerForPropertyId,
        UIA_PROPERTY_ID.UIA_ControllerForPropertyId);
    expect(
        UIA_ControlTypePropertyId, UIA_PROPERTY_ID.UIA_ControlTypePropertyId);
    expect(UIA_CulturePropertyId, UIA_PROPERTY_ID.UIA_CulturePropertyId);
    expect(
        UIA_DescribedByPropertyId, UIA_PROPERTY_ID.UIA_DescribedByPropertyId);
    expect(UIA_FillColorPropertyId, UIA_PROPERTY_ID.UIA_FillColorPropertyId);
    expect(UIA_FillTypePropertyId, UIA_PROPERTY_ID.UIA_FillTypePropertyId);
    expect(UIA_FlowsFromPropertyId, UIA_PROPERTY_ID.UIA_FlowsFromPropertyId);
    expect(UIA_FlowsToPropertyId, UIA_PROPERTY_ID.UIA_FlowsToPropertyId);
    expect(
        UIA_FrameworkIdPropertyId, UIA_PROPERTY_ID.UIA_FrameworkIdPropertyId);
    expect(UIA_FullDescriptionPropertyId,
        UIA_PROPERTY_ID.UIA_FullDescriptionPropertyId);
    expect(UIA_HasKeyboardFocusPropertyId,
        UIA_PROPERTY_ID.UIA_HasKeyboardFocusPropertyId);
    expect(
        UIA_HeadingLevelPropertyId, UIA_PROPERTY_ID.UIA_HeadingLevelPropertyId);
    expect(UIA_HelpTextPropertyId, UIA_PROPERTY_ID.UIA_HelpTextPropertyId);
    expect(UIA_IsContentElementPropertyId,
        UIA_PROPERTY_ID.UIA_IsContentElementPropertyId);
    expect(UIA_IsControlElementPropertyId,
        UIA_PROPERTY_ID.UIA_IsControlElementPropertyId);
    expect(UIA_IsDataValidForFormPropertyId,
        UIA_PROPERTY_ID.UIA_IsDataValidForFormPropertyId);
    expect(UIA_IsDialogPropertyId, UIA_PROPERTY_ID.UIA_IsDialogPropertyId);
    expect(UIA_IsEnabledPropertyId, UIA_PROPERTY_ID.UIA_IsEnabledPropertyId);
    expect(UIA_IsKeyboardFocusablePropertyId,
        UIA_PROPERTY_ID.UIA_IsKeyboardFocusablePropertyId);
    expect(
        UIA_IsOffscreenPropertyId, UIA_PROPERTY_ID.UIA_IsOffscreenPropertyId);
    expect(UIA_IsPasswordPropertyId, UIA_PROPERTY_ID.UIA_IsPasswordPropertyId);
    expect(
        UIA_IsPeripheralPropertyId, UIA_PROPERTY_ID.UIA_IsPeripheralPropertyId);
    expect(UIA_IsRequiredForFormPropertyId,
        UIA_PROPERTY_ID.UIA_IsRequiredForFormPropertyId);
    expect(UIA_ItemStatusPropertyId, UIA_PROPERTY_ID.UIA_ItemStatusPropertyId);
    expect(UIA_ItemTypePropertyId, UIA_PROPERTY_ID.UIA_ItemTypePropertyId);
    expect(UIA_LabeledByPropertyId, UIA_PROPERTY_ID.UIA_LabeledByPropertyId);
    expect(
        UIA_LandmarkTypePropertyId, UIA_PROPERTY_ID.UIA_LandmarkTypePropertyId);
    expect(UIA_LevelPropertyId, UIA_PROPERTY_ID.UIA_LevelPropertyId);
    expect(
        UIA_LiveSettingPropertyId, UIA_PROPERTY_ID.UIA_LiveSettingPropertyId);
    expect(UIA_LocalizedControlTypePropertyId,
        UIA_PROPERTY_ID.UIA_LocalizedControlTypePropertyId);
    expect(UIA_LocalizedLandmarkTypePropertyId,
        UIA_PROPERTY_ID.UIA_LocalizedLandmarkTypePropertyId);
    expect(UIA_NamePropertyId, UIA_PROPERTY_ID.UIA_NamePropertyId);
    expect(UIA_NativeWindowHandlePropertyId,
        UIA_PROPERTY_ID.UIA_NativeWindowHandlePropertyId);
    expect(UIA_OptimizeForVisualContentPropertyId,
        UIA_PROPERTY_ID.UIA_OptimizeForVisualContentPropertyId);
    expect(
        UIA_OrientationPropertyId, UIA_PROPERTY_ID.UIA_OrientationPropertyId);
    expect(
        UIA_OutlineColorPropertyId, UIA_PROPERTY_ID.UIA_OutlineColorPropertyId);
    expect(UIA_OutlineThicknessPropertyId,
        UIA_PROPERTY_ID.UIA_OutlineThicknessPropertyId);
    expect(UIA_PositionInSetPropertyId,
        UIA_PROPERTY_ID.UIA_PositionInSetPropertyId);
    expect(UIA_ProcessIdPropertyId, UIA_PROPERTY_ID.UIA_ProcessIdPropertyId);
    expect(UIA_ProviderDescriptionPropertyId,
        UIA_PROPERTY_ID.UIA_ProviderDescriptionPropertyId);
    expect(UIA_RotationPropertyId, UIA_PROPERTY_ID.UIA_RotationPropertyId);
    expect(UIA_RuntimeIdPropertyId, UIA_PROPERTY_ID.UIA_RuntimeIdPropertyId);
    expect(UIA_SizePropertyId, UIA_PROPERTY_ID.UIA_SizePropertyId);
    expect(UIA_SizeOfSetPropertyId, UIA_PROPERTY_ID.UIA_SizeOfSetPropertyId);
    expect(UIA_VisualEffectsPropertyId,
        UIA_PROPERTY_ID.UIA_VisualEffectsPropertyId);
    expect(UIA_AnnotationAnnotationTypeIdPropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationAnnotationTypeIdPropertyId);
    expect(UIA_AnnotationAnnotationTypeNamePropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationAnnotationTypeNamePropertyId);
    expect(UIA_AnnotationAuthorPropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationAuthorPropertyId);
    expect(UIA_AnnotationDateTimePropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationDateTimePropertyId);
    expect(UIA_AnnotationTargetPropertyId,
        UIA_PROPERTY_ID.UIA_AnnotationTargetPropertyId);
    expect(UIA_DockDockPositionPropertyId,
        UIA_PROPERTY_ID.UIA_DockDockPositionPropertyId);
    expect(UIA_DragDropEffectPropertyId,
        UIA_PROPERTY_ID.UIA_DragDropEffectPropertyId);
    expect(UIA_DragDropEffectsPropertyId,
        UIA_PROPERTY_ID.UIA_DragDropEffectsPropertyId);
    expect(UIA_DragIsGrabbedPropertyId,
        UIA_PROPERTY_ID.UIA_DragIsGrabbedPropertyId);
    expect(UIA_DragGrabbedItemsPropertyId,
        UIA_PROPERTY_ID.UIA_DragGrabbedItemsPropertyId);
    expect(UIA_DropTargetDropTargetEffectPropertyId,
        UIA_PROPERTY_ID.UIA_DropTargetDropTargetEffectPropertyId);
    expect(UIA_DropTargetDropTargetEffectsPropertyId,
        UIA_PROPERTY_ID.UIA_DropTargetDropTargetEffectsPropertyId);
    expect(UIA_ExpandCollapseExpandCollapseStatePropertyId,
        UIA_PROPERTY_ID.UIA_ExpandCollapseExpandCollapseStatePropertyId);
    expect(UIA_GridColumnCountPropertyId,
        UIA_PROPERTY_ID.UIA_GridColumnCountPropertyId);
    expect(UIA_GridItemColumnPropertyId,
        UIA_PROPERTY_ID.UIA_GridItemColumnPropertyId);
    expect(UIA_GridItemColumnSpanPropertyId,
        UIA_PROPERTY_ID.UIA_GridItemColumnSpanPropertyId);
    expect(UIA_GridItemContainingGridPropertyId,
        UIA_PROPERTY_ID.UIA_GridItemContainingGridPropertyId);
    expect(
        UIA_GridItemRowPropertyId, UIA_PROPERTY_ID.UIA_GridItemRowPropertyId);
    expect(UIA_GridItemRowSpanPropertyId,
        UIA_PROPERTY_ID.UIA_GridItemRowSpanPropertyId);
    expect(
        UIA_GridRowCountPropertyId, UIA_PROPERTY_ID.UIA_GridRowCountPropertyId);
    expect(UIA_LegacyIAccessibleChildIdPropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleChildIdPropertyId);
    expect(UIA_LegacyIAccessibleDefaultActionPropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId);
    expect(UIA_LegacyIAccessibleDescriptionPropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleDescriptionPropertyId);
    expect(UIA_LegacyIAccessibleHelpPropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleHelpPropertyId);
    expect(UIA_LegacyIAccessibleKeyboardShortcutPropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleKeyboardShortcutPropertyId);
    expect(UIA_LegacyIAccessibleNamePropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleNamePropertyId);
    expect(UIA_LegacyIAccessibleRolePropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleRolePropertyId);
    expect(UIA_LegacyIAccessibleSelectionPropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleSelectionPropertyId);
    expect(UIA_LegacyIAccessibleStatePropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleStatePropertyId);
    expect(UIA_LegacyIAccessibleValuePropertyId,
        UIA_PROPERTY_ID.UIA_LegacyIAccessibleValuePropertyId);
    expect(UIA_MultipleViewCurrentViewPropertyId,
        UIA_PROPERTY_ID.UIA_MultipleViewCurrentViewPropertyId);
    expect(UIA_MultipleViewSupportedViewsPropertyId,
        UIA_PROPERTY_ID.UIA_MultipleViewSupportedViewsPropertyId);
    expect(UIA_RangeValueIsReadOnlyPropertyId,
        UIA_PROPERTY_ID.UIA_RangeValueIsReadOnlyPropertyId);
    expect(UIA_RangeValueLargeChangePropertyId,
        UIA_PROPERTY_ID.UIA_RangeValueLargeChangePropertyId);
    expect(UIA_RangeValueMaximumPropertyId,
        UIA_PROPERTY_ID.UIA_RangeValueMaximumPropertyId);
    expect(UIA_RangeValueMinimumPropertyId,
        UIA_PROPERTY_ID.UIA_RangeValueMinimumPropertyId);
    expect(UIA_RangeValueSmallChangePropertyId,
        UIA_PROPERTY_ID.UIA_RangeValueSmallChangePropertyId);
    expect(UIA_RangeValueValuePropertyId,
        UIA_PROPERTY_ID.UIA_RangeValueValuePropertyId);
    expect(UIA_ScrollHorizontallyScrollablePropertyId,
        UIA_PROPERTY_ID.UIA_ScrollHorizontallyScrollablePropertyId);
    expect(UIA_ScrollHorizontalScrollPercentPropertyId,
        UIA_PROPERTY_ID.UIA_ScrollHorizontalScrollPercentPropertyId);
    expect(UIA_ScrollHorizontalViewSizePropertyId,
        UIA_PROPERTY_ID.UIA_ScrollHorizontalViewSizePropertyId);
    expect(UIA_ScrollVerticallyScrollablePropertyId,
        UIA_PROPERTY_ID.UIA_ScrollVerticallyScrollablePropertyId);
    expect(UIA_ScrollVerticalScrollPercentPropertyId,
        UIA_PROPERTY_ID.UIA_ScrollVerticalScrollPercentPropertyId);
    expect(UIA_ScrollVerticalViewSizePropertyId,
        UIA_PROPERTY_ID.UIA_ScrollVerticalViewSizePropertyId);
    expect(UIA_SelectionCanSelectMultiplePropertyId,
        UIA_PROPERTY_ID.UIA_SelectionCanSelectMultiplePropertyId);
    expect(UIA_SelectionIsSelectionRequiredPropertyId,
        UIA_PROPERTY_ID.UIA_SelectionIsSelectionRequiredPropertyId);
    expect(UIA_SelectionSelectionPropertyId,
        UIA_PROPERTY_ID.UIA_SelectionSelectionPropertyId);
    expect(UIA_SelectionItemIsSelectedPropertyId,
        UIA_PROPERTY_ID.UIA_SelectionItemIsSelectedPropertyId);
    expect(UIA_SelectionItemSelectionContainerPropertyId,
        UIA_PROPERTY_ID.UIA_SelectionItemSelectionContainerPropertyId);
    expect(UIA_SpreadsheetItemFormulaPropertyId,
        UIA_PROPERTY_ID.UIA_SpreadsheetItemFormulaPropertyId);
    expect(UIA_SpreadsheetItemAnnotationObjectsPropertyId,
        UIA_PROPERTY_ID.UIA_SpreadsheetItemAnnotationObjectsPropertyId);
    expect(UIA_SpreadsheetItemAnnotationTypesPropertyId,
        UIA_PROPERTY_ID.UIA_SpreadsheetItemAnnotationTypesPropertyId);
    expect(UIA_StylesExtendedPropertiesPropertyId,
        UIA_PROPERTY_ID.UIA_StylesExtendedPropertiesPropertyId);
    expect(UIA_StylesFillColorPropertyId,
        UIA_PROPERTY_ID.UIA_StylesFillColorPropertyId);
    expect(UIA_StylesFillPatternColorPropertyId,
        UIA_PROPERTY_ID.UIA_StylesFillPatternColorPropertyId);
    expect(UIA_StylesFillPatternStylePropertyId,
        UIA_PROPERTY_ID.UIA_StylesFillPatternStylePropertyId);
    expect(
        UIA_StylesShapePropertyId, UIA_PROPERTY_ID.UIA_StylesShapePropertyId);
    expect(UIA_StylesStyleIdPropertyId,
        UIA_PROPERTY_ID.UIA_StylesStyleIdPropertyId);
    expect(UIA_StylesStyleNamePropertyId,
        UIA_PROPERTY_ID.UIA_StylesStyleNamePropertyId);
    expect(UIA_TableColumnHeadersPropertyId,
        UIA_PROPERTY_ID.UIA_TableColumnHeadersPropertyId);
    expect(UIA_TableItemColumnHeaderItemsPropertyId,
        UIA_PROPERTY_ID.UIA_TableItemColumnHeaderItemsPropertyId);
    expect(UIA_TableRowHeadersPropertyId,
        UIA_PROPERTY_ID.UIA_TableRowHeadersPropertyId);
    expect(UIA_TableRowOrColumnMajorPropertyId,
        UIA_PROPERTY_ID.UIA_TableRowOrColumnMajorPropertyId);
    expect(UIA_TableItemRowHeaderItemsPropertyId,
        UIA_PROPERTY_ID.UIA_TableItemRowHeaderItemsPropertyId);
    expect(UIA_ToggleToggleStatePropertyId,
        UIA_PROPERTY_ID.UIA_ToggleToggleStatePropertyId);
    expect(UIA_TransformCanMovePropertyId,
        UIA_PROPERTY_ID.UIA_TransformCanMovePropertyId);
    expect(UIA_TransformCanResizePropertyId,
        UIA_PROPERTY_ID.UIA_TransformCanResizePropertyId);
    expect(UIA_TransformCanRotatePropertyId,
        UIA_PROPERTY_ID.UIA_TransformCanRotatePropertyId);
    expect(UIA_Transform2CanZoomPropertyId,
        UIA_PROPERTY_ID.UIA_Transform2CanZoomPropertyId);
    expect(UIA_Transform2ZoomLevelPropertyId,
        UIA_PROPERTY_ID.UIA_Transform2ZoomLevelPropertyId);
    expect(UIA_Transform2ZoomMaximumPropertyId,
        UIA_PROPERTY_ID.UIA_Transform2ZoomMaximumPropertyId);
    expect(UIA_Transform2ZoomMinimumPropertyId,
        UIA_PROPERTY_ID.UIA_Transform2ZoomMinimumPropertyId);
    expect(UIA_ValueIsReadOnlyPropertyId,
        UIA_PROPERTY_ID.UIA_ValueIsReadOnlyPropertyId);
    expect(UIA_ValueValuePropertyId, UIA_PROPERTY_ID.UIA_ValueValuePropertyId);
    expect(UIA_WindowCanMaximizePropertyId,
        UIA_PROPERTY_ID.UIA_WindowCanMaximizePropertyId);
    expect(UIA_WindowCanMinimizePropertyId,
        UIA_PROPERTY_ID.UIA_WindowCanMinimizePropertyId);
    expect(UIA_WindowIsModalPropertyId,
        UIA_PROPERTY_ID.UIA_WindowIsModalPropertyId);
    expect(UIA_WindowIsTopmostPropertyId,
        UIA_PROPERTY_ID.UIA_WindowIsTopmostPropertyId);
    expect(UIA_WindowWindowInteractionStatePropertyId,
        UIA_PROPERTY_ID.UIA_WindowWindowInteractionStatePropertyId);
    expect(UIA_WindowWindowVisualStatePropertyId,
        UIA_PROPERTY_ID.UIA_WindowWindowVisualStatePropertyId);
    expect(UIA_IsAnnotationPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsAnnotationPatternAvailablePropertyId);
    expect(UIA_IsCustomNavigationPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsCustomNavigationPatternAvailablePropertyId);
    expect(UIA_IsDockPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsDockPatternAvailablePropertyId);
    expect(UIA_IsDragPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsDragPatternAvailablePropertyId);
    expect(UIA_IsDropTargetPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsDropTargetPatternAvailablePropertyId);
    expect(UIA_IsExpandCollapsePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsExpandCollapsePatternAvailablePropertyId);
    expect(UIA_IsGridItemPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsGridItemPatternAvailablePropertyId);
    expect(UIA_IsGridPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsGridPatternAvailablePropertyId);
    expect(UIA_IsInvokePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsInvokePatternAvailablePropertyId);
    expect(UIA_IsItemContainerPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsItemContainerPatternAvailablePropertyId);
    expect(UIA_IsLegacyIAccessiblePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsLegacyIAccessiblePatternAvailablePropertyId);
    expect(UIA_IsMultipleViewPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsMultipleViewPatternAvailablePropertyId);
    expect(UIA_IsObjectModelPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsObjectModelPatternAvailablePropertyId);
    expect(UIA_IsRangeValuePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsRangeValuePatternAvailablePropertyId);
    expect(UIA_IsScrollItemPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsScrollItemPatternAvailablePropertyId);
    expect(UIA_IsScrollPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsScrollPatternAvailablePropertyId);
    expect(UIA_IsSelectionItemPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsSelectionItemPatternAvailablePropertyId);
    expect(UIA_IsSelectionPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsSelectionPatternAvailablePropertyId);
    expect(UIA_IsSpreadsheetPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsSpreadsheetPatternAvailablePropertyId);
    expect(UIA_IsSpreadsheetItemPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsSpreadsheetItemPatternAvailablePropertyId);
    expect(UIA_IsStylesPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsStylesPatternAvailablePropertyId);
    expect(UIA_IsSynchronizedInputPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsSynchronizedInputPatternAvailablePropertyId);
    expect(UIA_IsTableItemPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTableItemPatternAvailablePropertyId);
    expect(UIA_IsTablePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTablePatternAvailablePropertyId);
    expect(UIA_IsTextChildPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTextChildPatternAvailablePropertyId);
    expect(UIA_IsTextEditPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTextEditPatternAvailablePropertyId);
    expect(UIA_IsTextPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTextPatternAvailablePropertyId);
    expect(UIA_IsTextPattern2AvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTextPattern2AvailablePropertyId);
    expect(UIA_IsTogglePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTogglePatternAvailablePropertyId);
    expect(UIA_IsTransformPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTransformPatternAvailablePropertyId);
    expect(UIA_IsTransformPattern2AvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsTransformPattern2AvailablePropertyId);
    expect(UIA_IsValuePatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsValuePatternAvailablePropertyId);
    expect(UIA_IsVirtualizedItemPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsVirtualizedItemPatternAvailablePropertyId);
    expect(UIA_IsWindowPatternAvailablePropertyId,
        UIA_PROPERTY_ID.UIA_IsWindowPatternAvailablePropertyId);
    expect(GMEM_FIXED, GLOBAL_ALLOC_FLAGS.GMEM_FIXED);
    expect(GMEM_MOVABLE, GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE);
    expect(GMEM_ZEROINIT, GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT);
    expect(GPTR, GLOBAL_ALLOC_FLAGS.GPTR);
    expect(GHND, GLOBAL_ALLOC_FLAGS.GHND);
    expect(ERROR_SEM_OWNER_DIED, WIN32_ERROR.ERROR_SEM_OWNER_DIED);
    expect(ERROR_SEM_USER_LIMIT, WIN32_ERROR.ERROR_SEM_USER_LIMIT);
    expect(ERROR_DISK_CHANGE, WIN32_ERROR.ERROR_DISK_CHANGE);
    expect(ERROR_DRIVE_LOCKED, WIN32_ERROR.ERROR_DRIVE_LOCKED);
    expect(ERROR_BROKEN_PIPE, WIN32_ERROR.ERROR_BROKEN_PIPE);
    expect(ERROR_OPEN_FAILED, WIN32_ERROR.ERROR_OPEN_FAILED);
    expect(ERROR_BUFFER_OVERFLOW, WIN32_ERROR.ERROR_BUFFER_OVERFLOW);
    expect(ERROR_DISK_FULL, WIN32_ERROR.ERROR_DISK_FULL);
    expect(
        ERROR_NO_MORE_SEARCH_HANDLES, WIN32_ERROR.ERROR_NO_MORE_SEARCH_HANDLES);
    expect(
        ERROR_INVALID_TARGET_HANDLE, WIN32_ERROR.ERROR_INVALID_TARGET_HANDLE);
    expect(ERROR_INVALID_CATEGORY, WIN32_ERROR.ERROR_INVALID_CATEGORY);
    expect(
        ERROR_INVALID_VERIFY_SWITCH, WIN32_ERROR.ERROR_INVALID_VERIFY_SWITCH);
    expect(ERROR_BAD_DRIVER_LEVEL, WIN32_ERROR.ERROR_BAD_DRIVER_LEVEL);
    expect(ERROR_CALL_NOT_IMPLEMENTED, WIN32_ERROR.ERROR_CALL_NOT_IMPLEMENTED);
    expect(ERROR_SEM_TIMEOUT, WIN32_ERROR.ERROR_SEM_TIMEOUT);
    expect(ERROR_INSUFFICIENT_BUFFER, WIN32_ERROR.ERROR_INSUFFICIENT_BUFFER);
    expect(ERROR_INVALID_NAME, WIN32_ERROR.ERROR_INVALID_NAME);
    expect(ERROR_INVALID_LEVEL, WIN32_ERROR.ERROR_INVALID_LEVEL);
    expect(ERROR_NO_VOLUME_LABEL, WIN32_ERROR.ERROR_NO_VOLUME_LABEL);
    expect(ERROR_MOD_NOT_FOUND, WIN32_ERROR.ERROR_MOD_NOT_FOUND);
    expect(ERROR_PROC_NOT_FOUND, WIN32_ERROR.ERROR_PROC_NOT_FOUND);
    expect(ERROR_WAIT_NO_CHILDREN, WIN32_ERROR.ERROR_WAIT_NO_CHILDREN);
    expect(ERROR_CHILD_NOT_COMPLETE, WIN32_ERROR.ERROR_CHILD_NOT_COMPLETE);
    expect(ERROR_DIRECT_ACCESS_HANDLE, WIN32_ERROR.ERROR_DIRECT_ACCESS_HANDLE);
    expect(ERROR_NEGATIVE_SEEK, WIN32_ERROR.ERROR_NEGATIVE_SEEK);
    expect(ERROR_SEEK_ON_DEVICE, WIN32_ERROR.ERROR_SEEK_ON_DEVICE);
    expect(ERROR_IS_JOIN_TARGET, WIN32_ERROR.ERROR_IS_JOIN_TARGET);
    expect(ERROR_IS_JOINED, WIN32_ERROR.ERROR_IS_JOINED);
    expect(ERROR_IS_SUBSTED, WIN32_ERROR.ERROR_IS_SUBSTED);
    expect(ERROR_NOT_JOINED, WIN32_ERROR.ERROR_NOT_JOINED);
    expect(ERROR_NOT_SUBSTED, WIN32_ERROR.ERROR_NOT_SUBSTED);
    expect(ERROR_JOIN_TO_JOIN, WIN32_ERROR.ERROR_JOIN_TO_JOIN);
    expect(ERROR_SUBST_TO_SUBST, WIN32_ERROR.ERROR_SUBST_TO_SUBST);
    expect(ERROR_JOIN_TO_SUBST, WIN32_ERROR.ERROR_JOIN_TO_SUBST);
    expect(ERROR_SUBST_TO_JOIN, WIN32_ERROR.ERROR_SUBST_TO_JOIN);
    expect(ERROR_BUSY_DRIVE, WIN32_ERROR.ERROR_BUSY_DRIVE);
    expect(ERROR_SAME_DRIVE, WIN32_ERROR.ERROR_SAME_DRIVE);
    expect(ERROR_DIR_NOT_ROOT, WIN32_ERROR.ERROR_DIR_NOT_ROOT);
    expect(ERROR_DIR_NOT_EMPTY, WIN32_ERROR.ERROR_DIR_NOT_EMPTY);
    expect(ERROR_IS_SUBST_PATH, WIN32_ERROR.ERROR_IS_SUBST_PATH);
    expect(ERROR_IS_JOIN_PATH, WIN32_ERROR.ERROR_IS_JOIN_PATH);
    expect(ERROR_PATH_BUSY, WIN32_ERROR.ERROR_PATH_BUSY);
    expect(ERROR_IS_SUBST_TARGET, WIN32_ERROR.ERROR_IS_SUBST_TARGET);
    expect(ERROR_SYSTEM_TRACE, WIN32_ERROR.ERROR_SYSTEM_TRACE);
    expect(ERROR_INVALID_EVENT_COUNT, WIN32_ERROR.ERROR_INVALID_EVENT_COUNT);
    expect(ERROR_TOO_MANY_MUXWAITERS, WIN32_ERROR.ERROR_TOO_MANY_MUXWAITERS);
    expect(ERROR_INVALID_LIST_FORMAT, WIN32_ERROR.ERROR_INVALID_LIST_FORMAT);
    expect(ERROR_LABEL_TOO_LONG, WIN32_ERROR.ERROR_LABEL_TOO_LONG);
    expect(ERROR_TOO_MANY_TCBS, WIN32_ERROR.ERROR_TOO_MANY_TCBS);
    expect(ERROR_SIGNAL_REFUSED, WIN32_ERROR.ERROR_SIGNAL_REFUSED);
    expect(ERROR_DISCARDED, WIN32_ERROR.ERROR_DISCARDED);
    expect(ERROR_NOT_LOCKED, WIN32_ERROR.ERROR_NOT_LOCKED);
    expect(ERROR_BAD_THREADID_ADDR, WIN32_ERROR.ERROR_BAD_THREADID_ADDR);
    expect(ERROR_BAD_ARGUMENTS, WIN32_ERROR.ERROR_BAD_ARGUMENTS);
    expect(ERROR_BAD_PATHNAME, WIN32_ERROR.ERROR_BAD_PATHNAME);
    expect(ERROR_SIGNAL_PENDING, WIN32_ERROR.ERROR_SIGNAL_PENDING);
    expect(ERROR_MAX_THRDS_REACHED, WIN32_ERROR.ERROR_MAX_THRDS_REACHED);
    expect(ERROR_LOCK_FAILED, WIN32_ERROR.ERROR_LOCK_FAILED);
    expect(ERROR_BUSY, WIN32_ERROR.ERROR_BUSY);
    expect(ERROR_DEVICE_SUPPORT_IN_PROGRESS,
        WIN32_ERROR.ERROR_DEVICE_SUPPORT_IN_PROGRESS);
    expect(ERROR_CANCEL_VIOLATION, WIN32_ERROR.ERROR_CANCEL_VIOLATION);
    expect(ERROR_ATOMIC_LOCKS_NOT_SUPPORTED,
        WIN32_ERROR.ERROR_ATOMIC_LOCKS_NOT_SUPPORTED);
    expect(
        ERROR_INVALID_SEGMENT_NUMBER, WIN32_ERROR.ERROR_INVALID_SEGMENT_NUMBER);
    expect(ERROR_INVALID_ORDINAL, WIN32_ERROR.ERROR_INVALID_ORDINAL);
    expect(ERROR_ALREADY_EXISTS, WIN32_ERROR.ERROR_ALREADY_EXISTS);
    expect(ERROR_INVALID_FLAG_NUMBER, WIN32_ERROR.ERROR_INVALID_FLAG_NUMBER);
    expect(ERROR_SEM_NOT_FOUND, WIN32_ERROR.ERROR_SEM_NOT_FOUND);
    expect(ERROR_INVALID_STARTING_CODESEG,
        WIN32_ERROR.ERROR_INVALID_STARTING_CODESEG);
    expect(ERROR_INVALID_STACKSEG, WIN32_ERROR.ERROR_INVALID_STACKSEG);
    expect(ERROR_INVALID_MODULETYPE, WIN32_ERROR.ERROR_INVALID_MODULETYPE);
    expect(
        ERROR_INVALID_EXE_SIGNATURE, WIN32_ERROR.ERROR_INVALID_EXE_SIGNATURE);
    expect(ERROR_EXE_MARKED_INVALID, WIN32_ERROR.ERROR_EXE_MARKED_INVALID);
    expect(ERROR_BAD_EXE_FORMAT, WIN32_ERROR.ERROR_BAD_EXE_FORMAT);
    expect(ERROR_ITERATED_DATA_EXCEEDS_64k,
        WIN32_ERROR.ERROR_ITERATED_DATA_EXCEEDS_64k);
    expect(ERROR_INVALID_MINALLOCSIZE, WIN32_ERROR.ERROR_INVALID_MINALLOCSIZE);
    expect(ERROR_DYNLINK_FROM_INVALID_RING,
        WIN32_ERROR.ERROR_DYNLINK_FROM_INVALID_RING);
    expect(ERROR_IOPL_NOT_ENABLED, WIN32_ERROR.ERROR_IOPL_NOT_ENABLED);
    expect(ERROR_INVALID_SEGDPL, WIN32_ERROR.ERROR_INVALID_SEGDPL);
    expect(ERROR_AUTODATASEG_EXCEEDS_64k,
        WIN32_ERROR.ERROR_AUTODATASEG_EXCEEDS_64k);
    expect(ERROR_MORE_DATA, WIN32_ERROR.ERROR_MORE_DATA);
    expect(ERROR_NO_MORE_ITEMS, WIN32_ERROR.ERROR_NO_MORE_ITEMS);
    expect(ERROR_INVALID_FLAGS, WIN32_ERROR.ERROR_INVALID_FLAGS);
    expect(ERROR_CANCELLED, WIN32_ERROR.ERROR_CANCELLED);
    expect(ERROR_NOT_FOUND, WIN32_ERROR.ERROR_NOT_FOUND);
    expect(ERROR_REVISION_MISMATCH, WIN32_ERROR.ERROR_REVISION_MISMATCH);
    expect(
        ERROR_NO_SUCH_LOGON_SESSION, WIN32_ERROR.ERROR_NO_SUCH_LOGON_SESSION);
    expect(ERROR_BAD_USERNAME, WIN32_ERROR.ERROR_BAD_USERNAME);
    expect(APPMODEL_ERROR_NO_PACKAGE, WIN32_ERROR.APPMODEL_ERROR_NO_PACKAGE);
    expect(APPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPT,
        WIN32_ERROR.APPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPT);
    expect(APPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPT,
        WIN32_ERROR.APPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPT);
    expect(APPMODEL_ERROR_NO_APPLICATION,
        WIN32_ERROR.APPMODEL_ERROR_NO_APPLICATION);
    expect(APPMODEL_ERROR_DYNAMIC_PROPERTY_READ_FAILED,
        WIN32_ERROR.APPMODEL_ERROR_DYNAMIC_PROPERTY_READ_FAILED);
    expect(APPMODEL_ERROR_DYNAMIC_PROPERTY_INVALID,
        WIN32_ERROR.APPMODEL_ERROR_DYNAMIC_PROPERTY_INVALID);
    expect(APPMODEL_ERROR_PACKAGE_NOT_AVAILABLE,
        WIN32_ERROR.APPMODEL_ERROR_PACKAGE_NOT_AVAILABLE);
    expect(APPMODEL_ERROR_NO_MUTABLE_DIRECTORY,
        WIN32_ERROR.APPMODEL_ERROR_NO_MUTABLE_DIRECTORY);
    expect(FVIRTKEY, ACCEL_VIRT_FLAGS.FVIRTKEY);
    expect(FNOINVERT, ACCEL_VIRT_FLAGS.FNOINVERT);
    expect(FSHIFT, ACCEL_VIRT_FLAGS.FSHIFT);
    expect(FCONTROL, ACCEL_VIRT_FLAGS.FCONTROL);
    expect(FALT, ACCEL_VIRT_FLAGS.FALT);
    expect(SPI_GETSHOWSOUNDS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSHOWSOUNDS);
    expect(SPI_SETSHOWSOUNDS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSHOWSOUNDS);
    expect(SPI_GETSTICKYKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSTICKYKEYS);
    expect(SPI_SETSTICKYKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSTICKYKEYS);
    expect(SPI_GETACCESSTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETACCESSTIMEOUT);
    expect(SPI_SETACCESSTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETACCESSTIMEOUT);
    expect(SPI_GETSERIALKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSERIALKEYS);
    expect(SPI_SETSERIALKEYS, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSERIALKEYS);
    expect(
        SPI_GETSOUNDSENTRY, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSOUNDSENTRY);
    expect(
        SPI_SETSOUNDSENTRY, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSOUNDSENTRY);
    expect(SPI_GETSNAPTODEFBUTTON,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSNAPTODEFBUTTON);
    expect(SPI_SETSNAPTODEFBUTTON,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSNAPTODEFBUTTON);
    expect(SPI_GETMOUSEHOVERWIDTH,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSEHOVERWIDTH);
    expect(SPI_SETMOUSEHOVERWIDTH,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEHOVERWIDTH);
    expect(SPI_GETMOUSEHOVERHEIGHT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSEHOVERHEIGHT);
    expect(SPI_SETMOUSEHOVERHEIGHT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEHOVERHEIGHT);
    expect(SPI_GETMOUSEHOVERTIME,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSEHOVERTIME);
    expect(SPI_SETMOUSEHOVERTIME,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEHOVERTIME);
    expect(SPI_GETWHEELSCROLLLINES,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETWHEELSCROLLLINES);
    expect(SPI_SETWHEELSCROLLLINES,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETWHEELSCROLLLINES);
    expect(SPI_GETMENUSHOWDELAY,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMENUSHOWDELAY);
    expect(SPI_SETMENUSHOWDELAY,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMENUSHOWDELAY);
    expect(SPI_SETWHEELSCROLLCHARS,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETWHEELSCROLLCHARS);
    expect(SPI_GETSHOWIMEUI, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSHOWIMEUI);
    expect(SPI_SETSHOWIMEUI, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSHOWIMEUI);
    expect(SPI_GETMOUSESPEED, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSESPEED);
    expect(SPI_SETMOUSESPEED, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSESPEED);
    expect(SPI_GETSCREENSAVERRUNNING,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSCREENSAVERRUNNING);
    expect(SPI_GETDESKWALLPAPER,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETDESKWALLPAPER);
    expect(SPI_GETAUDIODESCRIPTION,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETAUDIODESCRIPTION);
    expect(SPI_SETAUDIODESCRIPTION,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETAUDIODESCRIPTION);
    expect(SPI_GETSCREENSAVESECURE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSCREENSAVESECURE);
    expect(SPI_SETSCREENSAVESECURE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSCREENSAVESECURE);
    expect(SPI_GETHUNGAPPTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETHUNGAPPTIMEOUT);
    expect(SPI_SETHUNGAPPTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETHUNGAPPTIMEOUT);
    expect(SPI_GETWAITTOKILLTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETWAITTOKILLTIMEOUT);
    expect(SPI_SETWAITTOKILLTIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETWAITTOKILLTIMEOUT);
    expect(SPI_GETWAITTOKILLSERVICETIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETWAITTOKILLSERVICETIMEOUT);
    expect(SPI_SETWAITTOKILLSERVICETIMEOUT,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETWAITTOKILLSERVICETIMEOUT);
    expect(SPI_GETMOUSEDOCKTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSEDOCKTHRESHOLD);
    expect(SPI_SETMOUSEDOCKTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEDOCKTHRESHOLD);
    expect(SPI_GETPENDOCKTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETPENDOCKTHRESHOLD);
    expect(SPI_SETPENDOCKTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETPENDOCKTHRESHOLD);
    expect(
        SPI_GETWINARRANGING, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETWINARRANGING);
    expect(
        SPI_SETWINARRANGING, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETWINARRANGING);
    expect(SPI_GETMOUSEDRAGOUTTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSEDRAGOUTTHRESHOLD);
    expect(SPI_SETMOUSEDRAGOUTTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSEDRAGOUTTHRESHOLD);
    expect(SPI_GETPENDRAGOUTTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETPENDRAGOUTTHRESHOLD);
    expect(SPI_SETPENDRAGOUTTHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETPENDRAGOUTTHRESHOLD);
    expect(SPI_GETMOUSESIDEMOVETHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETMOUSESIDEMOVETHRESHOLD);
    expect(SPI_SETMOUSESIDEMOVETHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETMOUSESIDEMOVETHRESHOLD);
    expect(SPI_GETPENSIDEMOVETHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETPENSIDEMOVETHRESHOLD);
    expect(SPI_SETPENSIDEMOVETHRESHOLD,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETPENSIDEMOVETHRESHOLD);
    expect(SPI_GETDRAGFROMMAXIMIZE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETDRAGFROMMAXIMIZE);
    expect(SPI_SETDRAGFROMMAXIMIZE,
        SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDRAGFROMMAXIMIZE);
    expect(SPI_GETSNAPSIZING, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETSNAPSIZING);
    expect(SPI_SETSNAPSIZING, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETSNAPSIZING);
    expect(SPI_GETDOCKMOVING, SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETDOCKMOVING);
    expect(SPI_SETDOCKMOVING, SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETDOCKMOVING);
    expect(MF_INSERT, MENU_ITEM_FLAGS.MF_INSERT);
    expect(MF_CHANGE, MENU_ITEM_FLAGS.MF_CHANGE);
    expect(MF_APPEND, MENU_ITEM_FLAGS.MF_APPEND);
    expect(MF_DELETE, MENU_ITEM_FLAGS.MF_DELETE);
    expect(MF_REMOVE, MENU_ITEM_FLAGS.MF_REMOVE);
    expect(MF_BYCOMMAND, MENU_ITEM_FLAGS.MF_BYCOMMAND);
    expect(MF_DEFAULT, MENU_ITEM_FLAGS.MF_DEFAULT);
    expect(MF_SYSMENU, MENU_ITEM_FLAGS.MF_SYSMENU);
    expect(MF_HELP, MENU_ITEM_FLAGS.MF_HELP);
    expect(MF_RIGHTJUSTIFY, MENU_ITEM_FLAGS.MF_RIGHTJUSTIFY);
    expect(MF_MOUSESELECT, MENU_ITEM_FLAGS.MF_MOUSESELECT);
    expect(MF_END, MENU_ITEM_FLAGS.MF_END);
    expect(ANSI_CHARSET, FONT_CHARSET.ANSI_CHARSET);
    expect(DEFAULT_CHARSET, FONT_CHARSET.DEFAULT_CHARSET);
    expect(SYMBOL_CHARSET, FONT_CHARSET.SYMBOL_CHARSET);
    expect(SHIFTJIS_CHARSET, FONT_CHARSET.SHIFTJIS_CHARSET);
    expect(HANGEUL_CHARSET, FONT_CHARSET.HANGEUL_CHARSET);
    expect(HANGUL_CHARSET, FONT_CHARSET.HANGUL_CHARSET);
    expect(GB2312_CHARSET, FONT_CHARSET.GB2312_CHARSET);
    expect(CHINESEBIG5_CHARSET, FONT_CHARSET.CHINESEBIG5_CHARSET);
    expect(OEM_CHARSET, FONT_CHARSET.OEM_CHARSET);
    expect(JOHAB_CHARSET, FONT_CHARSET.JOHAB_CHARSET);
    expect(HEBREW_CHARSET, FONT_CHARSET.HEBREW_CHARSET);
    expect(ARABIC_CHARSET, FONT_CHARSET.ARABIC_CHARSET);
    expect(GREEK_CHARSET, FONT_CHARSET.GREEK_CHARSET);
    expect(TURKISH_CHARSET, FONT_CHARSET.TURKISH_CHARSET);
    expect(VIETNAMESE_CHARSET, FONT_CHARSET.VIETNAMESE_CHARSET);
    expect(THAI_CHARSET, FONT_CHARSET.THAI_CHARSET);
    expect(EASTEUROPE_CHARSET, FONT_CHARSET.EASTEUROPE_CHARSET);
    expect(RUSSIAN_CHARSET, FONT_CHARSET.RUSSIAN_CHARSET);
    expect(WHITE_BRUSH, GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH);
    expect(LTGRAY_BRUSH, GET_STOCK_OBJECT_FLAGS.LTGRAY_BRUSH);
    expect(GRAY_BRUSH, GET_STOCK_OBJECT_FLAGS.GRAY_BRUSH);
    expect(DKGRAY_BRUSH, GET_STOCK_OBJECT_FLAGS.DKGRAY_BRUSH);
    expect(BLACK_BRUSH, GET_STOCK_OBJECT_FLAGS.BLACK_BRUSH);
    expect(NULL_BRUSH, GET_STOCK_OBJECT_FLAGS.NULL_BRUSH);
    expect(HOLLOW_BRUSH, GET_STOCK_OBJECT_FLAGS.HOLLOW_BRUSH);
    expect(WHITE_PEN, GET_STOCK_OBJECT_FLAGS.WHITE_PEN);
    expect(BLACK_PEN, GET_STOCK_OBJECT_FLAGS.BLACK_PEN);
    expect(NULL_PEN, GET_STOCK_OBJECT_FLAGS.NULL_PEN);
    expect(OEM_FIXED_FONT, GET_STOCK_OBJECT_FLAGS.OEM_FIXED_FONT);
    expect(ANSI_FIXED_FONT, GET_STOCK_OBJECT_FLAGS.ANSI_FIXED_FONT);
    expect(ANSI_VAR_FONT, GET_STOCK_OBJECT_FLAGS.ANSI_VAR_FONT);
    expect(SYSTEM_FONT, GET_STOCK_OBJECT_FLAGS.SYSTEM_FONT);
    expect(DEVICE_DEFAULT_FONT, GET_STOCK_OBJECT_FLAGS.DEVICE_DEFAULT_FONT);
    expect(DEFAULT_PALETTE, GET_STOCK_OBJECT_FLAGS.DEFAULT_PALETTE);
    expect(SYSTEM_FIXED_FONT, GET_STOCK_OBJECT_FLAGS.SYSTEM_FIXED_FONT);
    expect(TRANSPARENT, BACKGROUND_MODE.TRANSPARENT);
    expect(OPAQUE, BACKGROUND_MODE.OPAQUE);
    expect(DIB_RGB_COLORS, DIB_USAGE.DIB_RGB_COLORS);
    expect(DIB_PAL_COLORS, DIB_USAGE.DIB_PAL_COLORS);
    expect(SRCCOPY, ROP_CODE.SRCCOPY);
    expect(SRCPAINT, ROP_CODE.SRCPAINT);
    expect(SRCAND, ROP_CODE.SRCAND);
    expect(SRCINVERT, ROP_CODE.SRCINVERT);
    expect(SRCERASE, ROP_CODE.SRCERASE);
    expect(NOTSRCCOPY, ROP_CODE.NOTSRCCOPY);
    expect(NOTSRCERASE, ROP_CODE.NOTSRCERASE);
    expect(MERGECOPY, ROP_CODE.MERGECOPY);
    expect(MERGEPAINT, ROP_CODE.MERGEPAINT);
    expect(PATCOPY, ROP_CODE.PATCOPY);
    expect(PATPAINT, ROP_CODE.PATPAINT);
    expect(PATINVERT, ROP_CODE.PATINVERT);
    expect(DSTINVERT, ROP_CODE.DSTINVERT);
    expect(BLACKNESS, ROP_CODE.BLACKNESS);
    expect(WHITENESS, ROP_CODE.WHITENESS);
    expect(NOMIRRORBITMAP, ROP_CODE.NOMIRRORBITMAP);
    expect(CAPTUREBLT, ROP_CODE.CAPTUREBLT);
    expect(IDOK, MESSAGEBOX_RESULT.IDOK);
    expect(IDCANCEL, MESSAGEBOX_RESULT.IDCANCEL);
    expect(IDABORT, MESSAGEBOX_RESULT.IDABORT);
    expect(IDRETRY, MESSAGEBOX_RESULT.IDRETRY);
    expect(IDIGNORE, MESSAGEBOX_RESULT.IDIGNORE);
    expect(IDYES, MESSAGEBOX_RESULT.IDYES);
    expect(IDNO, MESSAGEBOX_RESULT.IDNO);
    expect(IDCLOSE, MESSAGEBOX_RESULT.IDCLOSE);
    expect(IDHELP, MESSAGEBOX_RESULT.IDHELP);
    expect(IDTRYAGAIN, MESSAGEBOX_RESULT.IDTRYAGAIN);
    expect(IDCONTINUE, MESSAGEBOX_RESULT.IDCONTINUE);
    expect(VK_LBUTTON, VIRTUAL_KEY.VK_LBUTTON);
    expect(VK_RBUTTON, VIRTUAL_KEY.VK_RBUTTON);
    expect(VK_CANCEL, VIRTUAL_KEY.VK_CANCEL);
    expect(VK_MBUTTON, VIRTUAL_KEY.VK_MBUTTON);
    expect(VK_XBUTTON1, VIRTUAL_KEY.VK_XBUTTON1);
    expect(VK_XBUTTON2, VIRTUAL_KEY.VK_XBUTTON2);
    expect(VK_BACK, VIRTUAL_KEY.VK_BACK);
    expect(VK_TAB, VIRTUAL_KEY.VK_TAB);
    expect(VK_CLEAR, VIRTUAL_KEY.VK_CLEAR);
    expect(VK_RETURN, VIRTUAL_KEY.VK_RETURN);
    expect(VK_SHIFT, VIRTUAL_KEY.VK_SHIFT);
    expect(VK_CONTROL, VIRTUAL_KEY.VK_CONTROL);
    expect(VK_MENU, VIRTUAL_KEY.VK_MENU);
    expect(VK_PAUSE, VIRTUAL_KEY.VK_PAUSE);
    expect(VK_CAPITAL, VIRTUAL_KEY.VK_CAPITAL);
    expect(VK_KANA, VIRTUAL_KEY.VK_KANA);
    expect(VK_HANGEUL, VIRTUAL_KEY.VK_HANGEUL);
    expect(VK_HANGUL, VIRTUAL_KEY.VK_HANGUL);
    expect(VK_JUNJA, VIRTUAL_KEY.VK_JUNJA);
    expect(VK_FINAL, VIRTUAL_KEY.VK_FINAL);
    expect(VK_HANJA, VIRTUAL_KEY.VK_HANJA);
    expect(VK_KANJI, VIRTUAL_KEY.VK_KANJI);
    expect(VK_ESCAPE, VIRTUAL_KEY.VK_ESCAPE);
    expect(VK_CONVERT, VIRTUAL_KEY.VK_CONVERT);
    expect(VK_NONCONVERT, VIRTUAL_KEY.VK_NONCONVERT);
    expect(VK_ACCEPT, VIRTUAL_KEY.VK_ACCEPT);
    expect(VK_MODECHANGE, VIRTUAL_KEY.VK_MODECHANGE);
    expect(VK_SPACE, VIRTUAL_KEY.VK_SPACE);
    expect(VK_PRIOR, VIRTUAL_KEY.VK_PRIOR);
    expect(VK_NEXT, VIRTUAL_KEY.VK_NEXT);
    expect(VK_END, VIRTUAL_KEY.VK_END);
    expect(VK_HOME, VIRTUAL_KEY.VK_HOME);
    expect(VK_LEFT, VIRTUAL_KEY.VK_LEFT);
    expect(VK_UP, VIRTUAL_KEY.VK_UP);
    expect(VK_RIGHT, VIRTUAL_KEY.VK_RIGHT);
    expect(VK_DOWN, VIRTUAL_KEY.VK_DOWN);
    expect(VK_SELECT, VIRTUAL_KEY.VK_SELECT);
    expect(VK_PRINT, VIRTUAL_KEY.VK_PRINT);
    expect(VK_EXECUTE, VIRTUAL_KEY.VK_EXECUTE);
    expect(VK_SNAPSHOT, VIRTUAL_KEY.VK_SNAPSHOT);
    expect(VK_INSERT, VIRTUAL_KEY.VK_INSERT);
    expect(VK_DELETE, VIRTUAL_KEY.VK_DELETE);
    expect(VK_HELP, VIRTUAL_KEY.VK_HELP);
    expect(VK_LWIN, VIRTUAL_KEY.VK_LWIN);
    expect(VK_RWIN, VIRTUAL_KEY.VK_RWIN);
    expect(VK_APPS, VIRTUAL_KEY.VK_APPS);
    expect(VK_SLEEP, VIRTUAL_KEY.VK_SLEEP);
    expect(VK_NUMPAD0, VIRTUAL_KEY.VK_NUMPAD0);
    expect(VK_NUMPAD1, VIRTUAL_KEY.VK_NUMPAD1);
    expect(VK_NUMPAD2, VIRTUAL_KEY.VK_NUMPAD2);
    expect(VK_NUMPAD3, VIRTUAL_KEY.VK_NUMPAD3);
    expect(VK_NUMPAD4, VIRTUAL_KEY.VK_NUMPAD4);
    expect(VK_NUMPAD5, VIRTUAL_KEY.VK_NUMPAD5);
    expect(VK_NUMPAD6, VIRTUAL_KEY.VK_NUMPAD6);
    expect(VK_NUMPAD7, VIRTUAL_KEY.VK_NUMPAD7);
    expect(VK_NUMPAD8, VIRTUAL_KEY.VK_NUMPAD8);
    expect(VK_NUMPAD9, VIRTUAL_KEY.VK_NUMPAD9);
    expect(VK_MULTIPLY, VIRTUAL_KEY.VK_MULTIPLY);
    expect(VK_ADD, VIRTUAL_KEY.VK_ADD);
    expect(VK_SEPARATOR, VIRTUAL_KEY.VK_SEPARATOR);
    expect(VK_SUBTRACT, VIRTUAL_KEY.VK_SUBTRACT);
    expect(VK_DECIMAL, VIRTUAL_KEY.VK_DECIMAL);
    expect(VK_DIVIDE, VIRTUAL_KEY.VK_DIVIDE);
    expect(VK_F1, VIRTUAL_KEY.VK_F1);
    expect(VK_F2, VIRTUAL_KEY.VK_F2);
    expect(VK_F3, VIRTUAL_KEY.VK_F3);
    expect(VK_F4, VIRTUAL_KEY.VK_F4);
    expect(VK_F5, VIRTUAL_KEY.VK_F5);
    expect(VK_F6, VIRTUAL_KEY.VK_F6);
    expect(VK_F7, VIRTUAL_KEY.VK_F7);
    expect(VK_F8, VIRTUAL_KEY.VK_F8);
    expect(VK_F9, VIRTUAL_KEY.VK_F9);
    expect(VK_F10, VIRTUAL_KEY.VK_F10);
    expect(VK_F11, VIRTUAL_KEY.VK_F11);
    expect(VK_F12, VIRTUAL_KEY.VK_F12);
    expect(VK_F13, VIRTUAL_KEY.VK_F13);
    expect(VK_F14, VIRTUAL_KEY.VK_F14);
    expect(VK_F15, VIRTUAL_KEY.VK_F15);
    expect(VK_F16, VIRTUAL_KEY.VK_F16);
    expect(VK_F17, VIRTUAL_KEY.VK_F17);
    expect(VK_F18, VIRTUAL_KEY.VK_F18);
    expect(VK_F19, VIRTUAL_KEY.VK_F19);
    expect(VK_F20, VIRTUAL_KEY.VK_F20);
    expect(VK_F21, VIRTUAL_KEY.VK_F21);
    expect(VK_F22, VIRTUAL_KEY.VK_F22);
    expect(VK_F23, VIRTUAL_KEY.VK_F23);
    expect(VK_F24, VIRTUAL_KEY.VK_F24);
    expect(VK_NUMLOCK, VIRTUAL_KEY.VK_NUMLOCK);
    expect(VK_SCROLL, VIRTUAL_KEY.VK_SCROLL);
    expect(VK_LSHIFT, VIRTUAL_KEY.VK_LSHIFT);
    expect(VK_RSHIFT, VIRTUAL_KEY.VK_RSHIFT);
    expect(VK_LCONTROL, VIRTUAL_KEY.VK_LCONTROL);
    expect(VK_RCONTROL, VIRTUAL_KEY.VK_RCONTROL);
    expect(VK_LMENU, VIRTUAL_KEY.VK_LMENU);
    expect(VK_RMENU, VIRTUAL_KEY.VK_RMENU);
    expect(VK_BROWSER_BACK, VIRTUAL_KEY.VK_BROWSER_BACK);
    expect(VK_BROWSER_FORWARD, VIRTUAL_KEY.VK_BROWSER_FORWARD);
    expect(VK_BROWSER_REFRESH, VIRTUAL_KEY.VK_BROWSER_REFRESH);
    expect(VK_BROWSER_STOP, VIRTUAL_KEY.VK_BROWSER_STOP);
    expect(VK_BROWSER_SEARCH, VIRTUAL_KEY.VK_BROWSER_SEARCH);
    expect(VK_BROWSER_FAVORITES, VIRTUAL_KEY.VK_BROWSER_FAVORITES);
    expect(VK_BROWSER_HOME, VIRTUAL_KEY.VK_BROWSER_HOME);
    expect(VK_VOLUME_MUTE, VIRTUAL_KEY.VK_VOLUME_MUTE);
    expect(VK_VOLUME_DOWN, VIRTUAL_KEY.VK_VOLUME_DOWN);
    expect(VK_VOLUME_UP, VIRTUAL_KEY.VK_VOLUME_UP);
    expect(VK_MEDIA_NEXT_TRACK, VIRTUAL_KEY.VK_MEDIA_NEXT_TRACK);
    expect(VK_MEDIA_PREV_TRACK, VIRTUAL_KEY.VK_MEDIA_PREV_TRACK);
    expect(VK_MEDIA_STOP, VIRTUAL_KEY.VK_MEDIA_STOP);
    expect(VK_MEDIA_PLAY_PAUSE, VIRTUAL_KEY.VK_MEDIA_PLAY_PAUSE);
    expect(VK_LAUNCH_MAIL, VIRTUAL_KEY.VK_LAUNCH_MAIL);
    expect(VK_LAUNCH_MEDIA_SELECT, VIRTUAL_KEY.VK_LAUNCH_MEDIA_SELECT);
    expect(VK_LAUNCH_APP1, VIRTUAL_KEY.VK_LAUNCH_APP1);
    expect(VK_LAUNCH_APP2, VIRTUAL_KEY.VK_LAUNCH_APP2);
    expect(VK_OEM_1, VIRTUAL_KEY.VK_OEM_1);
    expect(VK_OEM_PLUS, VIRTUAL_KEY.VK_OEM_PLUS);
    expect(VK_OEM_COMMA, VIRTUAL_KEY.VK_OEM_COMMA);
    expect(VK_OEM_MINUS, VIRTUAL_KEY.VK_OEM_MINUS);
    expect(VK_OEM_PERIOD, VIRTUAL_KEY.VK_OEM_PERIOD);
    expect(VK_OEM_2, VIRTUAL_KEY.VK_OEM_2);
    expect(VK_OEM_3, VIRTUAL_KEY.VK_OEM_3);
    expect(VK_OEM_4, VIRTUAL_KEY.VK_OEM_4);
    expect(VK_OEM_5, VIRTUAL_KEY.VK_OEM_5);
    expect(VK_OEM_6, VIRTUAL_KEY.VK_OEM_6);
    expect(VK_OEM_7, VIRTUAL_KEY.VK_OEM_7);
    expect(VK_OEM_8, VIRTUAL_KEY.VK_OEM_8);
    expect(VK_OEM_102, VIRTUAL_KEY.VK_OEM_102);
    expect(VK_ICO_HELP, VIRTUAL_KEY.VK_ICO_HELP);
    expect(VK_ICO_HELP, VIRTUAL_KEY.VK_ICO_HELP);
    expect(VK_ICO_00, VIRTUAL_KEY.VK_ICO_00);
    expect(VK_PROCESSKEY, VIRTUAL_KEY.VK_PROCESSKEY);
    expect(VK_ICO_CLEAR, VIRTUAL_KEY.VK_ICO_CLEAR);
    expect(VK_PACKET, VIRTUAL_KEY.VK_PACKET);
    expect(INPUT_MOUSE, INPUT_TYPE.INPUT_MOUSE);
    expect(INPUT_KEYBOARD, INPUT_TYPE.INPUT_KEYBOARD);
    expect(INPUT_HARDWARE, INPUT_TYPE.INPUT_HARDWARE);
    expect(KEYEVENTF_EXTENDEDKEY, KEYBD_EVENT_FLAGS.KEYEVENTF_EXTENDEDKEY);
    expect(KEYEVENTF_KEYUP, KEYBD_EVENT_FLAGS.KEYEVENTF_KEYUP);
    expect(KEYEVENTF_UNICODE, KEYBD_EVENT_FLAGS.KEYEVENTF_UNICODE);
    expect(KEYEVENTF_SCANCODE, KEYBD_EVENT_FLAGS.KEYEVENTF_SCANCODE);
    expect(MOUSEEVENTF_MOVE, MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE);
    expect(MOUSEEVENTF_LEFTDOWN, MOUSE_EVENT_FLAGS.MOUSEEVENTF_LEFTDOWN);
    expect(MOUSEEVENTF_LEFTUP, MOUSE_EVENT_FLAGS.MOUSEEVENTF_LEFTUP);
    expect(MOUSEEVENTF_RIGHTDOWN, MOUSE_EVENT_FLAGS.MOUSEEVENTF_RIGHTDOWN);
    expect(MOUSEEVENTF_RIGHTUP, MOUSE_EVENT_FLAGS.MOUSEEVENTF_RIGHTUP);
    expect(MOUSEEVENTF_MIDDLEDOWN, MOUSE_EVENT_FLAGS.MOUSEEVENTF_MIDDLEDOWN);
    expect(MOUSEEVENTF_MIDDLEUP, MOUSE_EVENT_FLAGS.MOUSEEVENTF_MIDDLEUP);
    expect(MOUSEEVENTF_XDOWN, MOUSE_EVENT_FLAGS.MOUSEEVENTF_XDOWN);
    expect(MOUSEEVENTF_XUP, MOUSE_EVENT_FLAGS.MOUSEEVENTF_XUP);
    expect(MOUSEEVENTF_WHEEL, MOUSE_EVENT_FLAGS.MOUSEEVENTF_WHEEL);
    expect(MOUSEEVENTF_HWHEEL, MOUSE_EVENT_FLAGS.MOUSEEVENTF_HWHEEL);
    expect(MOUSEEVENTF_MOVE_NOCOALESCE,
        MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE_NOCOALESCE);
    expect(MOUSEEVENTF_VIRTUALDESK, MOUSE_EVENT_FLAGS.MOUSEEVENTF_VIRTUALDESK);
    expect(MOUSEEVENTF_ABSOLUTE, MOUSE_EVENT_FLAGS.MOUSEEVENTF_ABSOLUTE);
    expect(FILE_VER_GET_LOCALISED,
        GET_FILE_VERSION_INFO_FLAGS.FILE_VER_GET_LOCALISED);
    expect(
        FILE_VER_GET_NEUTRAL, GET_FILE_VERSION_INFO_FLAGS.FILE_VER_GET_NEUTRAL);
    expect(FILE_VER_GET_PREFETCHED,
        GET_FILE_VERSION_INFO_FLAGS.FILE_VER_GET_PREFETCHED);
    expect(VFFF_ISSHAREDFILE, VER_FIND_FILE_FLAGS.VFFF_ISSHAREDFILE);
    expect(VIFF_FORCEINSTALL, VER_INSTALL_FILE_FLAGS.VIFF_FORCEINSTALL);
    expect(VIFF_DONTDELETEOLD, VER_INSTALL_FILE_FLAGS.VIFF_DONTDELETEOLD);
    expect(PROCESS_TERMINATE, PROCESS_ACCESS_RIGHTS.PROCESS_TERMINATE);
    expect(PROCESS_CREATE_THREAD, PROCESS_ACCESS_RIGHTS.PROCESS_CREATE_THREAD);
    expect(PROCESS_SET_SESSIONID, PROCESS_ACCESS_RIGHTS.PROCESS_SET_SESSIONID);
    expect(PROCESS_VM_OPERATION, PROCESS_ACCESS_RIGHTS.PROCESS_VM_OPERATION);
    expect(PROCESS_VM_READ, PROCESS_ACCESS_RIGHTS.PROCESS_VM_READ);
    expect(PROCESS_VM_WRITE, PROCESS_ACCESS_RIGHTS.PROCESS_VM_WRITE);
    expect(PROCESS_DUP_HANDLE, PROCESS_ACCESS_RIGHTS.PROCESS_DUP_HANDLE);
    expect(
        PROCESS_CREATE_PROCESS, PROCESS_ACCESS_RIGHTS.PROCESS_CREATE_PROCESS);
    expect(PROCESS_SET_QUOTA, PROCESS_ACCESS_RIGHTS.PROCESS_SET_QUOTA);
    expect(
        PROCESS_SET_INFORMATION, PROCESS_ACCESS_RIGHTS.PROCESS_SET_INFORMATION);
    expect(PROCESS_QUERY_INFORMATION,
        PROCESS_ACCESS_RIGHTS.PROCESS_QUERY_INFORMATION);
    expect(
        PROCESS_SUSPEND_RESUME, PROCESS_ACCESS_RIGHTS.PROCESS_SUSPEND_RESUME);
    expect(PROCESS_QUERY_LIMITED_INFORMATION,
        PROCESS_ACCESS_RIGHTS.PROCESS_QUERY_LIMITED_INFORMATION);
    expect(PROCESS_SET_LIMITED_INFORMATION,
        PROCESS_ACCESS_RIGHTS.PROCESS_SET_LIMITED_INFORMATION);
    expect(PROCESS_ALL_ACCESS, PROCESS_ACCESS_RIGHTS.PROCESS_ALL_ACCESS);
    expect(VER_MINORVERSION, VER_FLAGS.VER_MINORVERSION);
    expect(VER_MAJORVERSION, VER_FLAGS.VER_MAJORVERSION);
    expect(VER_BUILDNUMBER, VER_FLAGS.VER_BUILDNUMBER);
    expect(VER_PLATFORMID, VER_FLAGS.VER_PLATFORMID);
    expect(VER_SERVICEPACKMINOR, VER_FLAGS.VER_SERVICEPACKMINOR);
    expect(VER_SERVICEPACKMAJOR, VER_FLAGS.VER_SERVICEPACKMAJOR);
    expect(VER_SUITENAME, VER_FLAGS.VER_SUITENAME);
    expect(VER_PRODUCT_TYPE, VER_FLAGS.VER_PRODUCT_TYPE);
    expect(DEBUG_PROCESS, PROCESS_CREATION_FLAGS.DEBUG_PROCESS);
    expect(DEBUG_ONLY_THIS_PROCESS,
        PROCESS_CREATION_FLAGS.DEBUG_ONLY_THIS_PROCESS);
    expect(CREATE_SUSPENDED, PROCESS_CREATION_FLAGS.CREATE_SUSPENDED);
    expect(DETACHED_PROCESS, PROCESS_CREATION_FLAGS.DETACHED_PROCESS);
    expect(CREATE_NEW_CONSOLE, PROCESS_CREATION_FLAGS.CREATE_NEW_CONSOLE);
    expect(NORMAL_PRIORITY_CLASS, PROCESS_CREATION_FLAGS.NORMAL_PRIORITY_CLASS);
    expect(IDLE_PRIORITY_CLASS, PROCESS_CREATION_FLAGS.IDLE_PRIORITY_CLASS);
    expect(HIGH_PRIORITY_CLASS, PROCESS_CREATION_FLAGS.HIGH_PRIORITY_CLASS);
    expect(REALTIME_PRIORITY_CLASS,
        PROCESS_CREATION_FLAGS.REALTIME_PRIORITY_CLASS);
    expect(CREATE_NEW_PROCESS_GROUP,
        PROCESS_CREATION_FLAGS.CREATE_NEW_PROCESS_GROUP);
    expect(CREATE_UNICODE_ENVIRONMENT,
        PROCESS_CREATION_FLAGS.CREATE_UNICODE_ENVIRONMENT);
    expect(CREATE_SEPARATE_WOW_VDM,
        PROCESS_CREATION_FLAGS.CREATE_SEPARATE_WOW_VDM);
    expect(CREATE_SHARED_WOW_VDM, PROCESS_CREATION_FLAGS.CREATE_SHARED_WOW_VDM);
    expect(CREATE_FORCEDOS, PROCESS_CREATION_FLAGS.CREATE_FORCEDOS);
    expect(BELOW_NORMAL_PRIORITY_CLASS,
        PROCESS_CREATION_FLAGS.BELOW_NORMAL_PRIORITY_CLASS);
    expect(ABOVE_NORMAL_PRIORITY_CLASS,
        PROCESS_CREATION_FLAGS.ABOVE_NORMAL_PRIORITY_CLASS);
    expect(INHERIT_PARENT_AFFINITY,
        PROCESS_CREATION_FLAGS.INHERIT_PARENT_AFFINITY);
    expect(INHERIT_CALLER_PRIORITY,
        PROCESS_CREATION_FLAGS.INHERIT_CALLER_PRIORITY);
    expect(CREATE_PROTECTED_PROCESS,
        PROCESS_CREATION_FLAGS.CREATE_PROTECTED_PROCESS);
    expect(EXTENDED_STARTUPINFO_PRESENT,
        PROCESS_CREATION_FLAGS.EXTENDED_STARTUPINFO_PRESENT);
    expect(PROCESS_MODE_BACKGROUND_BEGIN,
        PROCESS_CREATION_FLAGS.PROCESS_MODE_BACKGROUND_BEGIN);
    expect(PROCESS_MODE_BACKGROUND_END,
        PROCESS_CREATION_FLAGS.PROCESS_MODE_BACKGROUND_END);
    expect(CREATE_SECURE_PROCESS, PROCESS_CREATION_FLAGS.CREATE_SECURE_PROCESS);
    expect(CREATE_BREAKAWAY_FROM_JOB,
        PROCESS_CREATION_FLAGS.CREATE_BREAKAWAY_FROM_JOB);
    expect(CREATE_PRESERVE_CODE_AUTHZ_LEVEL,
        PROCESS_CREATION_FLAGS.CREATE_PRESERVE_CODE_AUTHZ_LEVEL);
    expect(CREATE_DEFAULT_ERROR_MODE,
        PROCESS_CREATION_FLAGS.CREATE_DEFAULT_ERROR_MODE);
    expect(CREATE_NO_WINDOW, PROCESS_CREATION_FLAGS.CREATE_NO_WINDOW);
    expect(PROFILE_USER, PROCESS_CREATION_FLAGS.PROFILE_USER);
    expect(PROFILE_KERNEL, PROCESS_CREATION_FLAGS.PROFILE_KERNEL);
    expect(PROFILE_SERVER, PROCESS_CREATION_FLAGS.PROFILE_SERVER);
    expect(CREATE_IGNORE_SYSTEM_DEFAULT,
        PROCESS_CREATION_FLAGS.CREATE_IGNORE_SYSTEM_DEFAULT);
    expect(RRF_RT_REG_NONE, REG_ROUTINE_FLAGS.RRF_RT_REG_NONE);
    expect(RRF_RT_REG_SZ, REG_ROUTINE_FLAGS.RRF_RT_REG_SZ);
    expect(RRF_RT_REG_EXPAND_SZ, REG_ROUTINE_FLAGS.RRF_RT_REG_EXPAND_SZ);
    expect(RRF_RT_REG_BINARY, REG_ROUTINE_FLAGS.RRF_RT_REG_BINARY);
    expect(RRF_RT_REG_DWORD, REG_ROUTINE_FLAGS.RRF_RT_REG_DWORD);
    expect(RRF_RT_REG_MULTI_SZ, REG_ROUTINE_FLAGS.RRF_RT_REG_MULTI_SZ);
    expect(RRF_RT_REG_QWORD, REG_ROUTINE_FLAGS.RRF_RT_REG_QWORD);
    expect(RRF_RT_DWORD, REG_ROUTINE_FLAGS.RRF_RT_DWORD);
    expect(RRF_RT_QWORD, REG_ROUTINE_FLAGS.RRF_RT_QWORD);
    expect(RRF_RT_ANY, REG_ROUTINE_FLAGS.RRF_RT_ANY);
    expect(RRF_SUBKEY_WOW6464KEY, REG_ROUTINE_FLAGS.RRF_SUBKEY_WOW6464KEY);
    expect(RRF_SUBKEY_WOW6432KEY, REG_ROUTINE_FLAGS.RRF_SUBKEY_WOW6432KEY);
    expect(RRF_WOW64_MASK, REG_ROUTINE_FLAGS.RRF_WOW64_MASK);
    expect(RRF_NOEXPAND, REG_ROUTINE_FLAGS.RRF_NOEXPAND);
    expect(RRF_ZEROONFAILURE, REG_ROUTINE_FLAGS.RRF_ZEROONFAILURE);
    expect(XINPUT_DEVTYPE_GAMEPAD, XINPUT_DEVTYPE.XINPUT_DEVTYPE_GAMEPAD);
    expect(
        XINPUT_DEVSUBTYPE_UNKNOWN, XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_UNKNOWN);
    expect(
        XINPUT_DEVSUBTYPE_GAMEPAD, XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_GAMEPAD);
    expect(XINPUT_DEVSUBTYPE_WHEEL, XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_WHEEL);
    expect(XINPUT_DEVSUBTYPE_ARCADE_STICK,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_ARCADE_STICK);
    expect(XINPUT_DEVSUBTYPE_FLIGHT_STICK,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_FLIGHT_STICK);
    expect(XINPUT_DEVSUBTYPE_DANCE_PAD,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_DANCE_PAD);
    expect(
        XINPUT_DEVSUBTYPE_GUITAR, XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_GUITAR);
    expect(XINPUT_DEVSUBTYPE_GUITAR_ALTERNATE,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_GUITAR_ALTERNATE);
    expect(XINPUT_DEVSUBTYPE_DRUM_KIT,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_DRUM_KIT);
    expect(XINPUT_DEVSUBTYPE_GUITAR_BASS,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_GUITAR_BASS);
    expect(XINPUT_DEVSUBTYPE_ARCADE_PAD,
        XINPUT_DEVSUBTYPE.XINPUT_DEVSUBTYPE_ARCADE_PAD);
    expect(XINPUT_CAPS_VOICE_SUPPORTED,
        XINPUT_CAPABILITIES_FLAGS.XINPUT_CAPS_VOICE_SUPPORTED);
    expect(XINPUT_CAPS_FFB_SUPPORTED,
        XINPUT_CAPABILITIES_FLAGS.XINPUT_CAPS_FFB_SUPPORTED);
    expect(
        XINPUT_CAPS_WIRELESS, XINPUT_CAPABILITIES_FLAGS.XINPUT_CAPS_WIRELESS);
    expect(XINPUT_CAPS_PMD_SUPPORTED,
        XINPUT_CAPABILITIES_FLAGS.XINPUT_CAPS_PMD_SUPPORTED);
    expect(XINPUT_CAPS_NO_NAVIGATION,
        XINPUT_CAPABILITIES_FLAGS.XINPUT_CAPS_NO_NAVIGATION);
    expect(XINPUT_GAMEPAD_DPAD_UP,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_DPAD_UP);
    expect(XINPUT_GAMEPAD_DPAD_DOWN,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_DPAD_DOWN);
    expect(XINPUT_GAMEPAD_DPAD_LEFT,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_DPAD_LEFT);
    expect(XINPUT_GAMEPAD_DPAD_RIGHT,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_DPAD_RIGHT);
    expect(
        XINPUT_GAMEPAD_START, XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_START);
    expect(
        XINPUT_GAMEPAD_BACK, XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_BACK);
    expect(XINPUT_GAMEPAD_LEFT_THUMB,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_LEFT_THUMB);
    expect(XINPUT_GAMEPAD_RIGHT_THUMB,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_RIGHT_THUMB);
    expect(XINPUT_GAMEPAD_LEFT_SHOULDER,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_LEFT_SHOULDER);
    expect(XINPUT_GAMEPAD_RIGHT_SHOULDER,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_RIGHT_SHOULDER);
    expect(XINPUT_GAMEPAD_A, XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_A);
    expect(XINPUT_GAMEPAD_B, XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_B);
    expect(XINPUT_GAMEPAD_X, XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_X);
    expect(XINPUT_GAMEPAD_Y, XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_Y);
    expect(XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE);
    expect(XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE);
    expect(XINPUT_GAMEPAD_TRIGGER_THRESHOLD,
        XINPUT_GAMEPAD_BUTTON_FLAGS.XINPUT_GAMEPAD_TRIGGER_THRESHOLD);
    expect(XINPUT_FLAG_GAMEPAD, XINPUT_FLAG.XINPUT_FLAG_GAMEPAD);
    expect(BATTERY_DEVTYPE_GAMEPAD, BATTERY_DEVTYPE.BATTERY_DEVTYPE_GAMEPAD);
    expect(BATTERY_DEVTYPE_HEADSET, BATTERY_DEVTYPE.BATTERY_DEVTYPE_HEADSET);
    expect(BATTERY_TYPE_DISCONNECTED, BATTERY_TYPE.BATTERY_TYPE_DISCONNECTED);
    expect(BATTERY_TYPE_WIRED, BATTERY_TYPE.BATTERY_TYPE_WIRED);
    expect(BATTERY_TYPE_ALKALINE, BATTERY_TYPE.BATTERY_TYPE_ALKALINE);
    expect(BATTERY_TYPE_NIMH, BATTERY_TYPE.BATTERY_TYPE_NIMH);
    expect(BATTERY_TYPE_UNKNOWN, BATTERY_TYPE.BATTERY_TYPE_UNKNOWN);
    expect(BATTERY_LEVEL_EMPTY, BATTERY_LEVEL.BATTERY_LEVEL_EMPTY);
    expect(BATTERY_LEVEL_LOW, BATTERY_LEVEL.BATTERY_LEVEL_LOW);
    expect(BATTERY_LEVEL_MEDIUM, BATTERY_LEVEL.BATTERY_LEVEL_MEDIUM);
    expect(BATTERY_LEVEL_FULL, BATTERY_LEVEL.BATTERY_LEVEL_FULL);
    expect(VK_PAD_A, XINPUT_VIRTUAL_KEY.VK_PAD_A);
    expect(VK_PAD_B, XINPUT_VIRTUAL_KEY.VK_PAD_B);
    expect(VK_PAD_X, XINPUT_VIRTUAL_KEY.VK_PAD_X);
    expect(VK_PAD_Y, XINPUT_VIRTUAL_KEY.VK_PAD_Y);
    expect(VK_PAD_RSHOULDER, XINPUT_VIRTUAL_KEY.VK_PAD_RSHOULDER);
    expect(VK_PAD_LSHOULDER, XINPUT_VIRTUAL_KEY.VK_PAD_LSHOULDER);
    expect(VK_PAD_LTRIGGER, XINPUT_VIRTUAL_KEY.VK_PAD_LTRIGGER);
    expect(VK_PAD_RTRIGGER, XINPUT_VIRTUAL_KEY.VK_PAD_RTRIGGER);
    expect(VK_PAD_DPAD_UP, XINPUT_VIRTUAL_KEY.VK_PAD_DPAD_UP);
    expect(VK_PAD_DPAD_DOWN, XINPUT_VIRTUAL_KEY.VK_PAD_DPAD_DOWN);
    expect(VK_PAD_DPAD_LEFT, XINPUT_VIRTUAL_KEY.VK_PAD_DPAD_LEFT);
    expect(VK_PAD_DPAD_RIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_DPAD_RIGHT);
    expect(VK_PAD_START, XINPUT_VIRTUAL_KEY.VK_PAD_START);
    expect(VK_PAD_BACK, XINPUT_VIRTUAL_KEY.VK_PAD_BACK);
    expect(VK_PAD_LTHUMB_PRESS, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_PRESS);
    expect(VK_PAD_RTHUMB_PRESS, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_PRESS);
    expect(VK_PAD_LTHUMB_UP, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_UP);
    expect(VK_PAD_LTHUMB_DOWN, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_DOWN);
    expect(VK_PAD_LTHUMB_RIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_RIGHT);
    expect(VK_PAD_LTHUMB_LEFT, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_LEFT);
    expect(VK_PAD_LTHUMB_UPLEFT, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_UPLEFT);
    expect(VK_PAD_LTHUMB_UPRIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_UPRIGHT);
    expect(VK_PAD_LTHUMB_DOWNRIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_DOWNRIGHT);
    expect(VK_PAD_LTHUMB_DOWNLEFT, XINPUT_VIRTUAL_KEY.VK_PAD_LTHUMB_DOWNLEFT);
    expect(VK_PAD_RTHUMB_UP, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_UP);
    expect(VK_PAD_RTHUMB_DOWN, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_DOWN);
    expect(VK_PAD_RTHUMB_RIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_RIGHT);
    expect(VK_PAD_RTHUMB_LEFT, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_LEFT);
    expect(VK_PAD_RTHUMB_UPLEFT, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_UPLEFT);
    expect(VK_PAD_RTHUMB_UPRIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_UPRIGHT);
    expect(VK_PAD_RTHUMB_DOWNRIGHT, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_DOWNRIGHT);
    expect(VK_PAD_RTHUMB_DOWNLEFT, XINPUT_VIRTUAL_KEY.VK_PAD_RTHUMB_DOWNLEFT);
    expect(XINPUT_KEYSTROKE_KEYDOWN,
        XINPUT_KEYSTROKE_FLAGS.XINPUT_KEYSTROKE_KEYDOWN);
    expect(
        XINPUT_KEYSTROKE_KEYUP, XINPUT_KEYSTROKE_FLAGS.XINPUT_KEYSTROKE_KEYUP);
    expect(XINPUT_KEYSTROKE_REPEAT,
        XINPUT_KEYSTROKE_FLAGS.XINPUT_KEYSTROKE_REPEAT);
    expect(FOREGROUND_BLUE, CONSOLE_CHARACTER_ATTRIBUTES.FOREGROUND_BLUE);
    expect(FOREGROUND_GREEN, CONSOLE_CHARACTER_ATTRIBUTES.FOREGROUND_GREEN);
    expect(FOREGROUND_RED, CONSOLE_CHARACTER_ATTRIBUTES.FOREGROUND_RED);
    expect(FOREGROUND_INTENSITY,
        CONSOLE_CHARACTER_ATTRIBUTES.FOREGROUND_INTENSITY);
    expect(BACKGROUND_BLUE, CONSOLE_CHARACTER_ATTRIBUTES.BACKGROUND_BLUE);
    expect(BACKGROUND_GREEN, CONSOLE_CHARACTER_ATTRIBUTES.BACKGROUND_GREEN);
    expect(BACKGROUND_RED, CONSOLE_CHARACTER_ATTRIBUTES.BACKGROUND_RED);
    expect(BACKGROUND_INTENSITY,
        CONSOLE_CHARACTER_ATTRIBUTES.BACKGROUND_INTENSITY);
    expect(CLSCTX_INPROC_SERVER16, CLSCTX.CLSCTX_INPROC_SERVER16);
    expect(CLSCTX_INPROC_HANDLER16, CLSCTX.CLSCTX_INPROC_HANDLER16);
    expect(CLSCTX_RESERVED1, CLSCTX.CLSCTX_RESERVED1);
    expect(CLSCTX_RESERVED2, CLSCTX.CLSCTX_RESERVED2);
    expect(CLSCTX_RESERVED3, CLSCTX.CLSCTX_RESERVED3);
    expect(CLSCTX_RESERVED4, CLSCTX.CLSCTX_RESERVED4);
    expect(CLSCTX_NO_CODE_DOWNLOAD, CLSCTX.CLSCTX_NO_CODE_DOWNLOAD);
    expect(CLSCTX_RESERVED5, CLSCTX.CLSCTX_RESERVED5);
    expect(CLSCTX_NO_CUSTOM_MARSHAL, CLSCTX.CLSCTX_NO_CUSTOM_MARSHAL);
    expect(CLSCTX_ENABLE_CODE_DOWNLOAD, CLSCTX.CLSCTX_ENABLE_CODE_DOWNLOAD);
    expect(CLSCTX_NO_FAILURE_LOG, CLSCTX.CLSCTX_NO_FAILURE_LOG);
    expect(CLSCTX_DISABLE_AAA, CLSCTX.CLSCTX_DISABLE_AAA);
    expect(CLSCTX_ENABLE_AAA, CLSCTX.CLSCTX_ENABLE_AAA);
    expect(CLSCTX_FROM_DEFAULT_CONTEXT, CLSCTX.CLSCTX_FROM_DEFAULT_CONTEXT);
    expect(CLSCTX_ACTIVATE_X86_SERVER, CLSCTX.CLSCTX_ACTIVATE_X86_SERVER);
    expect(CLSCTX_ACTIVATE_32_BIT_SERVER, CLSCTX.CLSCTX_ACTIVATE_32_BIT_SERVER);
    expect(CLSCTX_ACTIVATE_64_BIT_SERVER, CLSCTX.CLSCTX_ACTIVATE_64_BIT_SERVER);
    expect(CLSCTX_ENABLE_CLOAKING, CLSCTX.CLSCTX_ENABLE_CLOAKING);
    expect(CLSCTX_APPCONTAINER, CLSCTX.CLSCTX_APPCONTAINER);
    expect(CLSCTX_ACTIVATE_AAA_AS_IU, CLSCTX.CLSCTX_ACTIVATE_AAA_AS_IU);
    expect(CLSCTX_RESERVED6, CLSCTX.CLSCTX_RESERVED6);
    expect(CLSCTX_ACTIVATE_ARM32_SERVER, CLSCTX.CLSCTX_ACTIVATE_ARM32_SERVER);
    expect(CLSCTX_PS_DLL, CLSCTX.CLSCTX_PS_DLL);
    expect(
        RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_DEFAULT);
    expect(RPC_C_AUTHN_LEVEL_NONE, RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_NONE);
    expect(
        RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_CONNECT);
    expect(RPC_C_AUTHN_LEVEL_CALL, RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_CALL);
    expect(RPC_C_AUTHN_LEVEL_PKT, RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_PKT);
    expect(RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,
        RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_PKT_INTEGRITY);
    expect(RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
        RPC_C_AUTHN_LEVEL.RPC_C_AUTHN_LEVEL_PKT_PRIVACY);
    expect(RPC_C_IMP_LEVEL_DEFAULT, RPC_C_IMP_LEVEL.RPC_C_IMP_LEVEL_DEFAULT);
    expect(
        RPC_C_IMP_LEVEL_ANONYMOUS, RPC_C_IMP_LEVEL.RPC_C_IMP_LEVEL_ANONYMOUS);
    expect(RPC_C_IMP_LEVEL_IDENTIFY, RPC_C_IMP_LEVEL.RPC_C_IMP_LEVEL_IDENTIFY);
    expect(RPC_C_IMP_LEVEL_IMPERSONATE,
        RPC_C_IMP_LEVEL.RPC_C_IMP_LEVEL_IMPERSONATE);
    expect(RPC_C_IMP_LEVEL_DELEGATE, RPC_C_IMP_LEVEL.RPC_C_IMP_LEVEL_DELEGATE);
    expect(KF_FLAG_DEFAULT, KNOWN_FOLDER_FLAG.KF_FLAG_DEFAULT);
    expect(KF_FLAG_FORCE_APP_DATA_REDIRECTION,
        KNOWN_FOLDER_FLAG.KF_FLAG_FORCE_APP_DATA_REDIRECTION);
    expect(KF_FLAG_RETURN_FILTER_REDIRECTION_TARGET,
        KNOWN_FOLDER_FLAG.KF_FLAG_RETURN_FILTER_REDIRECTION_TARGET);
    expect(KF_FLAG_FORCE_PACKAGE_REDIRECTION,
        KNOWN_FOLDER_FLAG.KF_FLAG_FORCE_PACKAGE_REDIRECTION);
    expect(KF_FLAG_NO_PACKAGE_REDIRECTION,
        KNOWN_FOLDER_FLAG.KF_FLAG_NO_PACKAGE_REDIRECTION);
    expect(KF_FLAG_FORCE_APPCONTAINER_REDIRECTION,
        KNOWN_FOLDER_FLAG.KF_FLAG_FORCE_APPCONTAINER_REDIRECTION);
    expect(KF_FLAG_NO_APPCONTAINER_REDIRECTION,
        KNOWN_FOLDER_FLAG.KF_FLAG_NO_APPCONTAINER_REDIRECTION);
    expect(KF_FLAG_CREATE, KNOWN_FOLDER_FLAG.KF_FLAG_CREATE);
    expect(KF_FLAG_DONT_VERIFY, KNOWN_FOLDER_FLAG.KF_FLAG_DONT_VERIFY);
    expect(KF_FLAG_DONT_UNEXPAND, KNOWN_FOLDER_FLAG.KF_FLAG_DONT_UNEXPAND);
    expect(KF_FLAG_NO_ALIAS, KNOWN_FOLDER_FLAG.KF_FLAG_NO_ALIAS);
    expect(KF_FLAG_INIT, KNOWN_FOLDER_FLAG.KF_FLAG_INIT);
    expect(KF_FLAG_DEFAULT_PATH, KNOWN_FOLDER_FLAG.KF_FLAG_DEFAULT_PATH);
    expect(KF_FLAG_NOT_PARENT_RELATIVE,
        KNOWN_FOLDER_FLAG.KF_FLAG_NOT_PARENT_RELATIVE);
    expect(KF_FLAG_SIMPLE_IDLIST, KNOWN_FOLDER_FLAG.KF_FLAG_SIMPLE_IDLIST);
    expect(KF_FLAG_ALIAS_ONLY, KNOWN_FOLDER_FLAG.KF_FLAG_ALIAS_ONLY);
    expect(ICC_LISTVIEW_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_LISTVIEW_CLASSES);
    expect(ICC_TREEVIEW_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_TREEVIEW_CLASSES);
    expect(ICC_BAR_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_BAR_CLASSES);
    expect(ICC_TAB_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_TAB_CLASSES);
    expect(ICC_UPDOWN_CLASS, INITCOMMONCONTROLSEX_ICC.ICC_UPDOWN_CLASS);
    expect(ICC_PROGRESS_CLASS, INITCOMMONCONTROLSEX_ICC.ICC_PROGRESS_CLASS);
    expect(ICC_HOTKEY_CLASS, INITCOMMONCONTROLSEX_ICC.ICC_HOTKEY_CLASS);
    expect(ICC_ANIMATE_CLASS, INITCOMMONCONTROLSEX_ICC.ICC_ANIMATE_CLASS);
    expect(ICC_WIN95_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_WIN95_CLASSES);
    expect(ICC_DATE_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_DATE_CLASSES);
    expect(ICC_USEREX_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_USEREX_CLASSES);
    expect(ICC_COOL_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_COOL_CLASSES);
    expect(ICC_INTERNET_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_INTERNET_CLASSES);
    expect(ICC_PAGESCROLLER_CLASS,
        INITCOMMONCONTROLSEX_ICC.ICC_PAGESCROLLER_CLASS);
    expect(ICC_NATIVEFNTCTL_CLASS,
        INITCOMMONCONTROLSEX_ICC.ICC_NATIVEFNTCTL_CLASS);
    expect(ICC_STANDARD_CLASSES, INITCOMMONCONTROLSEX_ICC.ICC_STANDARD_CLASSES);
    expect(ICC_LINK_CLASS, INITCOMMONCONTROLSEX_ICC.ICC_LINK_CLASS);
    expect(FILE_READ_DATA, FILE_ACCESS_RIGHTS.FILE_READ_DATA);
    expect(FILE_LIST_DIRECTORY, FILE_ACCESS_RIGHTS.FILE_LIST_DIRECTORY);
    expect(FILE_WRITE_DATA, FILE_ACCESS_RIGHTS.FILE_WRITE_DATA);
    expect(FILE_ADD_FILE, FILE_ACCESS_RIGHTS.FILE_ADD_FILE);
    expect(FILE_APPEND_DATA, FILE_ACCESS_RIGHTS.FILE_APPEND_DATA);
    expect(FILE_ADD_SUBDIRECTORY, FILE_ACCESS_RIGHTS.FILE_ADD_SUBDIRECTORY);
    expect(FILE_CREATE_PIPE_INSTANCE,
        FILE_ACCESS_RIGHTS.FILE_CREATE_PIPE_INSTANCE);
    expect(FILE_READ_EA, FILE_ACCESS_RIGHTS.FILE_READ_EA);
    expect(FILE_WRITE_EA, FILE_ACCESS_RIGHTS.FILE_WRITE_EA);
    expect(FILE_EXECUTE, FILE_ACCESS_RIGHTS.FILE_EXECUTE);
    expect(FILE_TRAVERSE, FILE_ACCESS_RIGHTS.FILE_TRAVERSE);
    expect(FILE_DELETE_CHILD, FILE_ACCESS_RIGHTS.FILE_DELETE_CHILD);
    expect(FILE_READ_ATTRIBUTES, FILE_ACCESS_RIGHTS.FILE_READ_ATTRIBUTES);
    expect(FILE_WRITE_ATTRIBUTES, FILE_ACCESS_RIGHTS.FILE_WRITE_ATTRIBUTES);
    expect(FILE_ALL_ACCESS, FILE_ACCESS_RIGHTS.FILE_ALL_ACCESS);
    expect(FILE_GENERIC_READ, FILE_ACCESS_RIGHTS.FILE_GENERIC_READ);
    expect(FILE_GENERIC_WRITE, FILE_ACCESS_RIGHTS.FILE_GENERIC_WRITE);
    expect(FILE_GENERIC_EXECUTE, FILE_ACCESS_RIGHTS.FILE_GENERIC_EXECUTE);
    expect(FILE_SHARE_READ, FILE_SHARE_MODE.FILE_SHARE_READ);
    expect(FILE_SHARE_WRITE, FILE_SHARE_MODE.FILE_SHARE_WRITE);
    expect(FILE_SHARE_DELETE, FILE_SHARE_MODE.FILE_SHARE_DELETE);
    expect(FILE_ATTRIBUTE_READONLY,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_READONLY);
    expect(
        FILE_ATTRIBUTE_HIDDEN, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_HIDDEN);
    expect(
        FILE_ATTRIBUTE_SYSTEM, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_SYSTEM);
    expect(FILE_ATTRIBUTE_DIRECTORY,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_DIRECTORY);
    expect(FILE_ATTRIBUTE_ARCHIVE,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_ARCHIVE);
    expect(
        FILE_ATTRIBUTE_DEVICE, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_DEVICE);
    expect(
        FILE_ATTRIBUTE_NORMAL, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_NORMAL);
    expect(FILE_ATTRIBUTE_TEMPORARY,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_TEMPORARY);
    expect(FILE_ATTRIBUTE_SPARSE_FILE,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_SPARSE_FILE);
    expect(FILE_ATTRIBUTE_REPARSE_POINT,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_REPARSE_POINT);
    expect(FILE_ATTRIBUTE_COMPRESSED,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_COMPRESSED);
    expect(FILE_ATTRIBUTE_OFFLINE,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_OFFLINE);
    expect(FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);
    expect(FILE_ATTRIBUTE_ENCRYPTED,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_ENCRYPTED);
    expect(FILE_ATTRIBUTE_INTEGRITY_STREAM,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_INTEGRITY_STREAM);
    expect(FILE_ATTRIBUTE_VIRTUAL,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_VIRTUAL);
    expect(FILE_ATTRIBUTE_NO_SCRUB_DATA,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_NO_SCRUB_DATA);
    expect(FILE_ATTRIBUTE_EA, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_EA);
    expect(
        FILE_ATTRIBUTE_PINNED, FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_PINNED);
    expect(FILE_ATTRIBUTE_UNPINNED,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_UNPINNED);
    expect(FILE_ATTRIBUTE_RECALL_ON_OPEN,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_RECALL_ON_OPEN);
    expect(FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS,
        FILE_FLAGS_AND_ATTRIBUTES.FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS);
    expect(FILE_NOTIFY_CHANGE_FILE_NAME,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_FILE_NAME);
    expect(FILE_NOTIFY_CHANGE_DIR_NAME,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_DIR_NAME);
    expect(FILE_NOTIFY_CHANGE_ATTRIBUTES,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_ATTRIBUTES);
    expect(FILE_NOTIFY_CHANGE_SIZE, FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_SIZE);
    expect(FILE_NOTIFY_CHANGE_LAST_WRITE,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_LAST_WRITE);
    expect(FILE_NOTIFY_CHANGE_LAST_ACCESS,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_LAST_ACCESS);
    expect(FILE_NOTIFY_CHANGE_CREATION,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_CREATION);
    expect(FILE_NOTIFY_CHANGE_SECURITY,
        FILE_NOTIFY_CHANGE.FILE_NOTIFY_CHANGE_SECURITY);
    expect(FILE_ACTION_ADDED, FILE_ACTION.FILE_ACTION_ADDED);
    expect(FILE_ACTION_REMOVED, FILE_ACTION.FILE_ACTION_REMOVED);
    expect(FILE_ACTION_MODIFIED, FILE_ACTION.FILE_ACTION_MODIFIED);
    expect(
        FILE_ACTION_RENAMED_OLD_NAME, FILE_ACTION.FILE_ACTION_RENAMED_OLD_NAME);
    expect(
        FILE_ACTION_RENAMED_NEW_NAME, FILE_ACTION.FILE_ACTION_RENAMED_NEW_NAME);
    expect(
        PAGE_GRAPHICS_NOACCESS, PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_NOACCESS);
    expect(
        PAGE_GRAPHICS_READONLY, PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_READONLY);
    expect(
        PAGE_GRAPHICS_READWRITE, PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_READWRITE);
    expect(PAGE_GRAPHICS_EXECUTE, PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_EXECUTE);
    expect(PAGE_GRAPHICS_EXECUTE_READ,
        PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_EXECUTE_READ);
    expect(PAGE_GRAPHICS_EXECUTE_READWRITE,
        PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_EXECUTE_READWRITE);
    expect(
        PAGE_GRAPHICS_COHERENT, PAGE_PROTECTION_FLAGS.PAGE_GRAPHICS_COHERENT);
    expect(
        PAGE_REVERT_TO_FILE_MAP, PAGE_PROTECTION_FLAGS.PAGE_REVERT_TO_FILE_MAP);
    expect(PROCESSOR_ARCHITECTURE_INTEL,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_INTEL);
    expect(PROCESSOR_ARCHITECTURE_MIPS,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_MIPS);
    expect(PROCESSOR_ARCHITECTURE_ALPHA,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_ALPHA);
    expect(PROCESSOR_ARCHITECTURE_PPC,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_PPC);
    expect(PROCESSOR_ARCHITECTURE_SHX,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_SHX);
    expect(PROCESSOR_ARCHITECTURE_ARM,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_ARM);
    expect(PROCESSOR_ARCHITECTURE_IA64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_IA64);
    expect(PROCESSOR_ARCHITECTURE_ALPHA64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_ALPHA64);
    expect(PROCESSOR_ARCHITECTURE_MSIL,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_MSIL);
    expect(PROCESSOR_ARCHITECTURE_AMD64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_AMD64);
    expect(PROCESSOR_ARCHITECTURE_IA32_ON_WIN64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_IA32_ON_WIN64);
    expect(PROCESSOR_ARCHITECTURE_NEUTRAL,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_NEUTRAL);
    expect(PROCESSOR_ARCHITECTURE_ARM64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_ARM64);
    expect(PROCESSOR_ARCHITECTURE_ARM32_ON_WIN64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_ARM32_ON_WIN64);
    expect(PROCESSOR_ARCHITECTURE_IA32_ON_ARM64,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_IA32_ON_ARM64);
    expect(PROCESSOR_ARCHITECTURE_UNKNOWN,
        PROCESSOR_ARCHITECTURE.PROCESSOR_ARCHITECTURE_UNKNOWN);
    expect(IMAGE_FILE_MACHINE_UNKNOWN,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_UNKNOWN);
    expect(IMAGE_FILE_MACHINE_TARGET_HOST,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_TARGET_HOST);
    expect(IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_I386);
    expect(
        IMAGE_FILE_MACHINE_R3000, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_R3000);
    expect(
        IMAGE_FILE_MACHINE_R4000, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_R4000);
    expect(IMAGE_FILE_MACHINE_R10000,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_R10000);
    expect(IMAGE_FILE_MACHINE_WCEMIPSV2,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_WCEMIPSV2);
    expect(
        IMAGE_FILE_MACHINE_ALPHA, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_ALPHA);
    expect(IMAGE_FILE_MACHINE_SH3, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_SH3);
    expect(IMAGE_FILE_MACHINE_SH3DSP,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_SH3DSP);
    expect(IMAGE_FILE_MACHINE_SH3E, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_SH3E);
    expect(IMAGE_FILE_MACHINE_SH4, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_SH4);
    expect(IMAGE_FILE_MACHINE_SH5, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_SH5);
    expect(IMAGE_FILE_MACHINE_ARM, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_ARM);
    expect(
        IMAGE_FILE_MACHINE_THUMB, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_THUMB);
    expect(
        IMAGE_FILE_MACHINE_ARMNT, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_ARMNT);
    expect(IMAGE_FILE_MACHINE_AM33, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_AM33);
    expect(IMAGE_FILE_MACHINE_POWERPC,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_POWERPC);
    expect(IMAGE_FILE_MACHINE_POWERPCFP,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_POWERPCFP);
    expect(IMAGE_FILE_MACHINE_IA64, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_IA64);
    expect(IMAGE_FILE_MACHINE_MIPS16,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_MIPS16);
    expect(IMAGE_FILE_MACHINE_ALPHA64,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_ALPHA64);
    expect(IMAGE_FILE_MACHINE_MIPSFPU,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_MIPSFPU);
    expect(IMAGE_FILE_MACHINE_MIPSFPU16,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_MIPSFPU16);
    expect(
        IMAGE_FILE_MACHINE_AXP64, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_AXP64);
    expect(IMAGE_FILE_MACHINE_TRICORE,
        IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_TRICORE);
    expect(IMAGE_FILE_MACHINE_CEF, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_CEF);
    expect(IMAGE_FILE_MACHINE_EBC, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_EBC);
    expect(
        IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_AMD64);
    expect(IMAGE_FILE_MACHINE_M32R, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_M32R);
    expect(
        IMAGE_FILE_MACHINE_ARM64, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_ARM64);
    expect(IMAGE_FILE_MACHINE_CEE, IMAGE_FILE_MACHINE.IMAGE_FILE_MACHINE_CEE);
    expect(PRODUCT_ULTIMATE, OS_PRODUCT_TYPE.PRODUCT_ULTIMATE);
    expect(PRODUCT_HOME_BASIC, OS_PRODUCT_TYPE.PRODUCT_HOME_BASIC);
    expect(PRODUCT_HOME_PREMIUM, OS_PRODUCT_TYPE.PRODUCT_HOME_PREMIUM);
    expect(PRODUCT_ENTERPRISE, OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE);
    expect(PRODUCT_HOME_BASIC_N, OS_PRODUCT_TYPE.PRODUCT_HOME_BASIC_N);
    expect(PRODUCT_BUSINESS, OS_PRODUCT_TYPE.PRODUCT_BUSINESS);
    expect(PRODUCT_STANDARD_SERVER, OS_PRODUCT_TYPE.PRODUCT_STANDARD_SERVER);
    expect(
        PRODUCT_DATACENTER_SERVER, OS_PRODUCT_TYPE.PRODUCT_DATACENTER_SERVER);
    expect(PRODUCT_SMALLBUSINESS_SERVER,
        OS_PRODUCT_TYPE.PRODUCT_SMALLBUSINESS_SERVER);
    expect(
        PRODUCT_ENTERPRISE_SERVER, OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE_SERVER);
    expect(PRODUCT_STARTER, OS_PRODUCT_TYPE.PRODUCT_STARTER);
    expect(PRODUCT_DATACENTER_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_DATACENTER_SERVER_CORE);
    expect(PRODUCT_STANDARD_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_STANDARD_SERVER_CORE_);
    expect(PRODUCT_ENTERPRISE_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE_SERVER_CORE);
    expect(PRODUCT_ENTERPRISE_SERVER_IA64,
        OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE_SERVER_IA64);
    expect(PRODUCT_BUSINESS_N, OS_PRODUCT_TYPE.PRODUCT_BUSINESS_N);
    expect(PRODUCT_WEB_SERVER, OS_PRODUCT_TYPE.PRODUCT_WEB_SERVER);
    expect(PRODUCT_CLUSTER_SERVER, OS_PRODUCT_TYPE.PRODUCT_CLUSTER_SERVER);
    expect(PRODUCT_HOME_SERVER, OS_PRODUCT_TYPE.PRODUCT_HOME_SERVER);
    expect(PRODUCT_STORAGE_EXPRESS_SERVER,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_EXPRESS_SERVER);
    expect(PRODUCT_STORAGE_STANDARD_SERVER,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_STANDARD_SERVER);
    expect(PRODUCT_STORAGE_WORKGROUP_SERVER,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_WORKGROUP_SERVER);
    expect(PRODUCT_STORAGE_ENTERPRISE_SERVER,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_ENTERPRISE_SERVER);
    expect(PRODUCT_SERVER_FOR_SMALLBUSINESS,
        OS_PRODUCT_TYPE.PRODUCT_SERVER_FOR_SMALLBUSINESS);
    expect(PRODUCT_SMALLBUSINESS_SERVER_PREMIUM,
        OS_PRODUCT_TYPE.PRODUCT_SMALLBUSINESS_SERVER_PREMIUM);
    expect(PRODUCT_HOME_PREMIUM_N, OS_PRODUCT_TYPE.PRODUCT_HOME_PREMIUM_N);
    expect(PRODUCT_ENTERPRISE_N, OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE_N);
    expect(PRODUCT_ULTIMATE_N, OS_PRODUCT_TYPE.PRODUCT_ULTIMATE_N);
    expect(PRODUCT_WEB_SERVER_CORE, OS_PRODUCT_TYPE.PRODUCT_WEB_SERVER_CORE);
    expect(PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT,
        OS_PRODUCT_TYPE.PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT);
    expect(PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY,
        OS_PRODUCT_TYPE.PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY);
    expect(PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING,
        OS_PRODUCT_TYPE.PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING);
    expect(
        PRODUCT_SERVER_FOUNDATION, OS_PRODUCT_TYPE.PRODUCT_SERVER_FOUNDATION);
    expect(PRODUCT_HOME_PREMIUM_SERVER,
        OS_PRODUCT_TYPE.PRODUCT_HOME_PREMIUM_SERVER);
    expect(PRODUCT_SERVER_FOR_SMALLBUSINESS_V,
        OS_PRODUCT_TYPE.PRODUCT_SERVER_FOR_SMALLBUSINESS_V);
    expect(
        PRODUCT_STANDARD_SERVER_V, OS_PRODUCT_TYPE.PRODUCT_STANDARD_SERVER_V);
    expect(PRODUCT_DATACENTER_SERVER_V,
        OS_PRODUCT_TYPE.PRODUCT_DATACENTER_SERVER_V);
    expect(PRODUCT_ENTERPRISE_SERVER_V,
        OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE_SERVER_V);
    expect(PRODUCT_DATACENTER_SERVER_CORE_V,
        OS_PRODUCT_TYPE.PRODUCT_DATACENTER_SERVER_CORE_V);
    expect(PRODUCT_STANDARD_SERVER_CORE_V,
        OS_PRODUCT_TYPE.PRODUCT_STANDARD_SERVER_CORE_V);
    expect(PRODUCT_ENTERPRISE_SERVER_CORE_V,
        OS_PRODUCT_TYPE.PRODUCT_ENTERPRISE_SERVER_CORE_V);
    expect(PRODUCT_HYPERV, OS_PRODUCT_TYPE.PRODUCT_HYPERV);
    expect(PRODUCT_STORAGE_EXPRESS_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_EXPRESS_SERVER_CORE);
    expect(PRODUCT_STORAGE_STANDARD_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_STANDARD_SERVER_CORE);
    expect(PRODUCT_STORAGE_WORKGROUP_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_WORKGROUP_SERVER_CORE);
    expect(PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE,
        OS_PRODUCT_TYPE.PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE);
    expect(PRODUCT_STARTER_N, OS_PRODUCT_TYPE.PRODUCT_STARTER_N);
    expect(PRODUCT_PROFESSIONAL, OS_PRODUCT_TYPE.PRODUCT_PROFESSIONAL);
    expect(PRODUCT_PROFESSIONAL_N, OS_PRODUCT_TYPE.PRODUCT_PROFESSIONAL_N);
    expect(
        PRODUCT_SB_SOLUTION_SERVER, OS_PRODUCT_TYPE.PRODUCT_SB_SOLUTION_SERVER);
    expect(PRODUCT_SERVER_FOR_SB_SOLUTIONS,
        OS_PRODUCT_TYPE.PRODUCT_SERVER_FOR_SB_SOLUTIONS);
    expect(PRODUCT_STANDARD_SERVER_SOLUTIONS,
        OS_PRODUCT_TYPE.PRODUCT_STANDARD_SERVER_SOLUTIONS);
    expect(PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE,
        OS_PRODUCT_TYPE.PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE);
    expect(PRODUCT_SB_SOLUTION_SERVER_EM,
        OS_PRODUCT_TYPE.PRODUCT_SB_SOLUTION_SERVER_EM);
    expect(PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM,
        OS_PRODUCT_TYPE.PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM);
    expect(PRODUCT_SOLUTION_EMBEDDEDSERVER,
        OS_PRODUCT_TYPE.PRODUCT_SOLUTION_EMBEDDEDSERVER);
    expect(CRED_FLAGS_PROMPT_NOW, CRED_FLAGS.CRED_FLAGS_PROMPT_NOW);
    expect(CRED_FLAGS_USERNAME_TARGET, CRED_FLAGS.CRED_FLAGS_USERNAME_TARGET);
    expect(CRED_TYPE_GENERIC, CRED_TYPE.CRED_TYPE_GENERIC);
    expect(CRED_TYPE_DOMAIN_PASSWORD, CRED_TYPE.CRED_TYPE_DOMAIN_PASSWORD);
    expect(
        CRED_TYPE_DOMAIN_CERTIFICATE, CRED_TYPE.CRED_TYPE_DOMAIN_CERTIFICATE);
    expect(CRED_TYPE_DOMAIN_VISIBLE_PASSWORD,
        CRED_TYPE.CRED_TYPE_DOMAIN_VISIBLE_PASSWORD);
    expect(
        CRED_TYPE_GENERIC_CERTIFICATE, CRED_TYPE.CRED_TYPE_GENERIC_CERTIFICATE);
    expect(CRED_TYPE_DOMAIN_EXTENDED, CRED_TYPE.CRED_TYPE_DOMAIN_EXTENDED);
    expect(CRED_TYPE_MAXIMUM, CRED_TYPE.CRED_TYPE_MAXIMUM);
    expect(CRED_TYPE_MAXIMUM_EX, CRED_TYPE.CRED_TYPE_MAXIMUM_EX);
    expect(CRED_PERSIST_SESSION, CRED_PERSIST.CRED_PERSIST_SESSION);
    expect(CRED_PERSIST_LOCAL_MACHINE, CRED_PERSIST.CRED_PERSIST_LOCAL_MACHINE);
    expect(CRED_PERSIST_ENTERPRISE, CRED_PERSIST.CRED_PERSIST_ENTERPRISE);
    expect(
        LIST_MODULES_32BIT, ENUM_PROCESS_MODULES_EX_FLAGS.LIST_MODULES_32BIT);
    expect(
        LIST_MODULES_64BIT, ENUM_PROCESS_MODULES_EX_FLAGS.LIST_MODULES_64BIT);
    expect(LIST_MODULES_ALL, ENUM_PROCESS_MODULES_EX_FLAGS.LIST_MODULES_ALL);
    expect(LIST_MODULES_DEFAULT,
        ENUM_PROCESS_MODULES_EX_FLAGS.LIST_MODULES_DEFAULT);
  });
}
