add_executable(ntdll_winetest ${SOURCE})
set_module_type(ntdll_winetest win32cui)
-add_importlibs(ntdll_winetest user32 msvcrt kernel32 ntdll)
+add_importlibs(ntdll_winetest user32 ole32 advapi32 msvcrt kernel32 ntdll)
add_cd_file(TARGET ntdll_winetest DESTINATION reactos/bin FOR all)
if(NOT MSVC)
cmp(STATUS_DATATYPE_MISALIGNMENT, ERROR_NOACCESS);
cmp(STATUS_ACCESS_VIOLATION, ERROR_NOACCESS);
cmp2(STATUS_DATATYPE_MISALIGNMENT_ERROR, ERROR_NOACCESS);
+ cmp2(STATUS_MULTIPLE_FAULT_VIOLATION, ERROR_MULTIPLE_FAULT_VIOLATION);
cmp(STATUS_CTL_FILE_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(STATUS_PORT_ALREADY_SET, ERROR_INVALID_PARAMETER);
+ cmp2(STATUS_PORT_NOT_SET, ERROR_PORT_NOT_SET);
cmp(STATUS_SECTION_NOT_IMAGE, ERROR_INVALID_PARAMETER);
cmp(STATUS_BAD_WORKING_SET_LIMIT, ERROR_INVALID_PARAMETER);
cmp(STATUS_WORKING_SET_LIMIT_RANGE, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_CID, ERROR_INVALID_PARAMETER);
cmp(STATUS_STACK_OVERFLOW, ERROR_STACK_OVERFLOW);
cmp(STATUS_BAD_INITIAL_STACK, ERROR_STACK_OVERFLOW);
+ cmp4(STATUS_STACK_OVERFLOW_READ, ERROR_STACK_OVERFLOW_READ, ERROR_STACK_OVERFLOW);
cmp(STATUS_INVALID_VOLUME_LABEL, ERROR_LABEL_TOO_LONG);
cmp(STATUS_SECTION_NOT_EXTENDED, ERROR_OUTOFMEMORY);
cmp(STATUS_NOT_MAPPED_DATA, ERROR_INVALID_ADDRESS);
cmp(STATUS_INVALID_INFO_CLASS, ERROR_INVALID_PARAMETER);
cmp(STATUS_SUSPEND_COUNT_EXCEEDED, ERROR_SIGNAL_REFUSED);
cmp(STATUS_NOTIFY_ENUM_DIR, ERROR_NOTIFY_ENUM_DIR);
+ cmp2(STATUS_BAD_CURRENT_DIRECTORY, ERROR_BAD_CURRENT_DIRECTORY);
cmp(STATUS_REGISTRY_RECOVERED, ERROR_REGISTRY_RECOVERED);
+ cmp2(STATUS_REGISTRY_HIVE_RECOVERED, ERROR_REGISTRY_HIVE_RECOVERED);
cmp(STATUS_REGISTRY_IO_FAILED, ERROR_REGISTRY_IO_FAILED);
cmp(STATUS_NOT_REGISTRY_FILE, ERROR_NOT_REGISTRY_FILE);
+ cmp2(STATUS_CANNOT_LOAD_REGISTRY_FILE, ERROR_CANNOT_LOAD_REGISTRY_FILE);
+ cmp2(STATUS_SYSTEM_HIVE_TOO_LARGE, ERROR_SYSTEM_HIVE_TOO_LARGE);
cmp(STATUS_KEY_DELETED, ERROR_KEY_DELETED);
cmp(STATUS_NO_LOG_SPACE, ERROR_NO_LOG_SPACE);
cmp(STATUS_KEY_HAS_CHILDREN, ERROR_KEY_HAS_CHILDREN);
cmp(STATUS_CHILD_MUST_BE_VOLATILE, ERROR_CHILD_MUST_BE_VOLATILE);
cmp(STATUS_REGISTRY_CORRUPT, ERROR_BADDB);
+ cmp2(STATUS_REGISTRY_QUOTA_LIMIT, ERROR_REGISTRY_QUOTA_LIMIT);
cmp(STATUS_DLL_NOT_FOUND, ERROR_MOD_NOT_FOUND);
cmp2(STATUS_OPEN_FAILED, ERROR_NET_OPEN_FAILED);
cmp2(STATUS_IO_PRIVILEGE_FAILED, ERROR_IO_PRIVILEGE_FAILED);
cmp(STATUS_DLL_INIT_FAILED, ERROR_DLL_INIT_FAILED);
+ cmp2(STATUS_DLL_INIT_FAILED_LOGOFF, ERROR_DLL_INIT_FAILED_LOGOFF);
cmp2(STATUS_INVALID_IMPORT_OF_NON_DLL, ERROR_INVALID_IMPORT_OF_NON_DLL);
cmp(STATUS_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL);
cmp(STATUS_DRIVER_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL);
cmp2(STATUS_DRIVER_UNABLE_TO_LOAD, ERROR_BAD_DRIVER);
cmp(STATUS_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND);
cmp(STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND);
+ cmp2(STATUS_BAD_DLL_ENTRYPOINT, ERROR_BAD_DLL_ENTRYPOINT);
+ cmp2(STATUS_BAD_SERVICE_ENTRYPOINT, ERROR_BAD_SERVICE_ENTRYPOINT);
+ cmp2(STATUS_FAILED_DRIVER_ENTRY, ERROR_FAILED_DRIVER_ENTRY);
+ cmp2(STATUS_DLL_MIGHT_BE_INSECURE, ERROR_DLL_MIGHT_BE_INSECURE);
+ cmp2(STATUS_DLL_MIGHT_BE_INCOMPATIBLE, ERROR_DLL_MIGHT_BE_INCOMPATIBLE);
+ cmp2(STATUS_ILLEGAL_DLL_RELOCATION, ERROR_ILLEGAL_DLL_RELOCATION);
+ cmp2(STATUS_NOT_SAFE_MODE_DRIVER, ERROR_NOT_SAFE_MODE_DRIVER);
+ cmp2(STATUS_DRIVER_DATABASE_ERROR, ERROR_DRIVER_DATABASE_ERROR);
cmp(STATUS_PENDING, ERROR_IO_PENDING);
cmp(STATUS_MORE_ENTRIES, ERROR_MORE_DATA);
cmp(STATUS_INTEGER_OVERFLOW, ERROR_ARITHMETIC_OVERFLOW);
cmp(STATUS_BUFFER_OVERFLOW, ERROR_MORE_DATA);
+ cmp2(STATUS_MARSHALL_OVERFLOW, ERROR_MARSHALL_OVERFLOW);
cmp(STATUS_NO_MORE_FILES, ERROR_NO_MORE_FILES);
+ cmp2(STATUS_REDIRECTOR_HAS_OPEN_HANDLES, ERROR_REDIRECTOR_HAS_OPEN_HANDLES);
+ cmp2(STATUS_SERVER_HAS_OPEN_HANDLES, ERROR_SERVER_HAS_OPEN_HANDLES);
cmp2(STATUS_HANDLES_CLOSED, ERROR_HANDLES_CLOSED);
cmp(STATUS_NO_INHERITANCE, ERROR_NO_INHERITANCE);
cmp(STATUS_NO_MORE_EAS, ERROR_NO_MORE_ITEMS);
cmp(STATUS_ILLEGAL_FUNCTION, ERROR_INVALID_FUNCTION);
cmp(STATUS_IN_PAGE_ERROR, ERROR_SWAPERROR);
cmp(STATUS_PAGEFILE_QUOTA, ERROR_PAGEFILE_QUOTA);
+ cmp2(STATUS_PAGEFILE_QUOTA_EXCEEDED, ERROR_PAGEFILE_QUOTA_EXCEEDED);
+ cmp2(STATUS_PAGE_FAULT_TRANSITION, ERROR_PAGE_FAULT_TRANSITION);
+ cmp2(STATUS_PAGE_FAULT_DEMAND_ZERO, ERROR_PAGE_FAULT_DEMAND_ZERO);
+ cmp2(STATUS_PAGE_FAULT_COPY_ON_WRITE, ERROR_PAGE_FAULT_COPY_ON_WRITE);
+ cmp2(STATUS_PAGE_FAULT_GUARD_PAGE, ERROR_PAGE_FAULT_GUARD_PAGE);
+ cmp2(STATUS_PAGE_FAULT_PAGING_FILE, ERROR_PAGE_FAULT_PAGING_FILE);
+ cmp2(STATUS_CACHE_PAGE_LOCKED, ERROR_CACHE_PAGE_LOCKED);
+ cmp2(STATUS_PAGEFILE_CREATE_FAILED, ERROR_PAGEFILE_CREATE_FAILED);
+ cmp2(STATUS_NO_PAGEFILE, ERROR_NO_PAGEFILE);
cmp(STATUS_COMMITMENT_LIMIT, ERROR_COMMITMENT_LIMIT);
+ cmp2(STATUS_COMMITMENT_MINIMUM, ERROR_COMMITMENT_MINIMUM);
cmp(STATUS_SECTION_TOO_BIG, ERROR_NOT_ENOUGH_MEMORY);
+ cmp2(STATUS_SEGMENT_NOTIFICATION, ERROR_SEGMENT_NOTIFICATION);
cmp(RPC_NT_SS_IN_NULL_CONTEXT, ERROR_INVALID_HANDLE);
cmp(RPC_NT_INVALID_BINDING, ERROR_INVALID_HANDLE);
cmp(STATUS_INVALID_HANDLE, ERROR_INVALID_HANDLE);
cmp(STATUS_NOT_COMMITTED, ERROR_INVALID_ADDRESS);
cmp(STATUS_PARTIAL_COPY, ERROR_PARTIAL_COPY);
cmp3(STATUS_LPC_REPLY_LOST, ERROR_CONNECTION_ABORTED, ERROR_INTERNAL_ERROR);
+ cmp2(STATUS_INVALID_VARIANT, ERROR_INVALID_VARIANT);
cmp(STATUS_INVALID_PARAMETER, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_1, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_2, ERROR_INVALID_PARAMETER);
cmp(STATUS_NO_SUCH_FILE, ERROR_FILE_NOT_FOUND);
cmp(STATUS_INVALID_DEVICE_REQUEST, ERROR_INVALID_FUNCTION);
cmp2(STATUS_VOLUME_NOT_UPGRADED, ERROR_INVALID_FUNCTION);
+ cmp2(STATUS_CONVERT_TO_LARGE, ERROR_CONVERT_TO_LARGE);
cmp(STATUS_END_OF_FILE, ERROR_HANDLE_EOF);
cmp(STATUS_FILE_FORCED_CLOSED, ERROR_HANDLE_EOF);
cmp(STATUS_WRONG_VOLUME, ERROR_WRONG_DISK);
cmp(STATUS_NO_MEDIA, ERROR_NO_MEDIA_IN_DRIVE);
cmp(STATUS_NO_MEDIA_IN_DEVICE, ERROR_NOT_READY);
cmp2(STATUS_VOLUME_DISMOUNTED, ERROR_NOT_READY);
+ cmp2(STATUS_VOLUME_MOUNTED, ERROR_VOLUME_MOUNTED);
+ cmp2(STATUS_MOUNT_POINT_NOT_RESOLVED, ERROR_MOUNT_POINT_NOT_RESOLVED);
cmp(STATUS_NONEXISTENT_SECTOR, ERROR_SECTOR_NOT_FOUND);
cmp(STATUS_WORKING_SET_QUOTA, ERROR_WORKING_SET_QUOTA);
cmp(STATUS_NO_MEMORY, ERROR_NOT_ENOUGH_MEMORY);
cmp(STATUS_CONFLICTING_ADDRESSES, ERROR_INVALID_ADDRESS);
cmp(STATUS_INVALID_SYSTEM_SERVICE, ERROR_INVALID_FUNCTION);
+ cmp2(STATUS_THREAD_WAS_SUSPENDED, ERROR_THREAD_WAS_SUSPENDED);
+ cmp2(STATUS_TOO_MANY_THREADS, ERROR_TOO_MANY_THREADS);
+ cmp2(STATUS_THREAD_NOT_IN_PROCESS, ERROR_THREAD_NOT_IN_PROCESS);
cmp(STATUS_THREAD_IS_TERMINATING, ERROR_ACCESS_DENIED);
cmp(STATUS_PROCESS_IS_TERMINATING, ERROR_ACCESS_DENIED);
+ cmp2(STATUS_SYSTEM_PROCESS_TERMINATED, ERROR_SYSTEM_PROCESS_TERMINATED);
cmp(STATUS_INVALID_LOCK_SEQUENCE, ERROR_ACCESS_DENIED);
cmp(STATUS_INVALID_VIEW_SIZE, ERROR_ACCESS_DENIED);
cmp(STATUS_ALREADY_COMMITTED, ERROR_ACCESS_DENIED);
cmp(STATUS_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER);
cmp(STATUS_UNABLE_TO_DECOMMIT_VM, ERROR_INVALID_ADDRESS);
cmp(STATUS_DISK_CORRUPT_ERROR, ERROR_DISK_CORRUPT);
+ cmp2(STATUS_FT_READ_RECOVERY_FROM_BACKUP, ERROR_FT_READ_RECOVERY_FROM_BACKUP);
+ cmp2(STATUS_FT_WRITE_RECOVERY, ERROR_FT_WRITE_RECOVERY);
cmp(STATUS_FT_MISSING_MEMBER, ERROR_IO_DEVICE);
cmp(STATUS_FT_ORPHANING, ERROR_IO_DEVICE);
+ cmp2(STATUS_BACKUP_CONTROLLER, ERROR_BACKUP_CONTROLLER);
cmp(STATUS_VARIABLE_NOT_FOUND, ERROR_ENVVAR_NOT_FOUND);
cmp(STATUS_OBJECT_NAME_INVALID, ERROR_INVALID_NAME);
cmp(STATUS_OBJECT_NAME_NOT_FOUND, ERROR_FILE_NOT_FOUND);
cmp(STATUS_OBJECT_NAME_COLLISION, ERROR_ALREADY_EXISTS);
+ cmp2(STATUS_OBJECT_NAME_EXISTS, ERROR_OBJECT_NAME_EXISTS);
cmp(STATUS_OBJECT_PATH_INVALID, ERROR_BAD_PATHNAME);
cmp(STATUS_OBJECT_PATH_NOT_FOUND, ERROR_PATH_NOT_FOUND);
cmp(STATUS_DFS_EXIT_PATH_FOUND, ERROR_PATH_NOT_FOUND);
cmp(STATUS_DATA_OVERRUN, ERROR_IO_DEVICE);
cmp(STATUS_DATA_LATE_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DATA_ERROR, ERROR_CRC);
+ cmp2(STATUS_DATA_NOT_ACCEPTED, ERROR_DATA_NOT_ACCEPTED);
+ cmp2(STATUS_LOST_WRITEBEHIND_DATA, ERROR_LOST_WRITEBEHIND_DATA);
cmp(STATUS_CRC_ERROR, ERROR_CRC);
cmp(STATUS_SHARING_VIOLATION, ERROR_SHARING_VIOLATION);
cmp(STATUS_QUOTA_EXCEEDED, ERROR_NOT_ENOUGH_QUOTA);
+ cmp2(STATUS_FS_DRIVER_REQUIRED, ERROR_FS_DRIVER_REQUIRED);
cmp(STATUS_MUTANT_NOT_OWNED, ERROR_NOT_OWNER);
+ cmp2(STATUS_MUTANT_LIMIT_EXCEEDED, ERROR_MUTANT_LIMIT_EXCEEDED);
cmp(STATUS_SEMAPHORE_LIMIT_EXCEEDED, ERROR_TOO_MANY_POSTS);
cmp(STATUS_DISK_FULL, ERROR_DISK_FULL);
cmp(STATUS_LOCK_NOT_GRANTED, ERROR_LOCK_VIOLATION);
cmp(STATUS_FILE_LOCK_CONFLICT, ERROR_LOCK_VIOLATION);
+ cmp2(STATUS_NOT_TINY_STREAM, ERROR_NOT_TINY_STREAM);
cmp(STATUS_NOT_A_DIRECTORY, ERROR_DIRECTORY);
cmp2(STATUS_CANNOT_MAKE, ERROR_CANNOT_MAKE);
cmp(STATUS_UNKNOWN_REVISION, ERROR_UNKNOWN_REVISION);
cmp(STATUS_PASSWORD_RESTRICTION, ERROR_PASSWORD_RESTRICTION);
cmp(STATUS_PASSWORD_EXPIRED, ERROR_PASSWORD_EXPIRED);
cmp(STATUS_PASSWORD_MUST_CHANGE, ERROR_PASSWORD_MUST_CHANGE);
+ cmp2(STATUS_PWD_TOO_SHORT, ERROR_PWD_TOO_SHORT);
+ cmp2(STATUS_PWD_TOO_RECENT, ERROR_PWD_TOO_RECENT);
+ cmp2(STATUS_PWD_HISTORY_CONFLICT, ERROR_PWD_HISTORY_CONFLICT);
cmp(STATUS_ACCOUNT_DISABLED, ERROR_ACCOUNT_DISABLED);
cmp(STATUS_ACCOUNT_LOCKED_OUT, ERROR_ACCOUNT_LOCKED_OUT);
cmp(STATUS_NONE_MAPPED, ERROR_NONE_MAPPED);
cmp(STATUS_INVALID_SID, ERROR_INVALID_SID);
cmp(STATUS_INVALID_SECURITY_DESCR, ERROR_INVALID_SECURITY_DESCR);
cmp(STATUS_PROCEDURE_NOT_FOUND, ERROR_PROC_NOT_FOUND);
+ cmp2(STATUS_VDM_HARD_ERROR, ERROR_VDM_HARD_ERROR);
cmp2(STATUS_INVALID_LDT_SIZE, ERROR_INVALID_LDT_SIZE);
cmp2(STATUS_INVALID_LDT_OFFSET, ERROR_INVALID_LDT_OFFSET);
cmp2(STATUS_INVALID_LDT_DESCRIPTOR, ERROR_INVALID_LDT_DESCRIPTOR);
cmp2(STATUS_INVALID_IMAGE_WIN_64, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_NO_TOKEN, ERROR_NO_TOKEN);
cmp(STATUS_RANGE_NOT_LOCKED, ERROR_NOT_LOCKED);
+ cmp2(STATUS_RANGE_LIST_CONFLICT, ERROR_RANGE_LIST_CONFLICT);
+ cmp2(STATUS_RANGE_NOT_FOUND, ERROR_RANGE_NOT_FOUND);
cmp(STATUS_SERVER_DISABLED, ERROR_SERVER_DISABLED);
cmp(STATUS_SERVER_NOT_DISABLED, ERROR_SERVER_NOT_DISABLED);
cmp(STATUS_INVALID_ID_AUTHORITY, ERROR_INVALID_ID_AUTHORITY);
cmp(STATUS_ALLOTTED_SPACE_EXCEEDED, ERROR_ALLOTTED_SPACE_EXCEEDED);
cmp(STATUS_TOO_MANY_PAGING_FILES, ERROR_NOT_ENOUGH_MEMORY);
+ cmp2(STATUS_RESOURCE_REQUIREMENTS_CHANGED, ERROR_RESOURCE_REQUIREMENTS_CHANGED);
cmp(STATUS_INSUFFICIENT_RESOURCES, ERROR_NO_SYSTEM_RESOURCES);
cmp(STATUS_INSUFF_SERVER_RESOURCES, ERROR_NOT_ENOUGH_SERVER_MEMORY);
cmp(STATUS_FILE_INVALID, ERROR_FILE_INVALID);
cmp(STATUS_DEVICE_NOT_READY, ERROR_NOT_READY);
cmp3(STATUS_DEVICE_NOT_CONNECTED, ERROR_DEVICE_NOT_CONNECTED, ERROR_NOT_READY);
cmp(STATUS_DEVICE_POWER_FAILURE, ERROR_NOT_READY);
+ cmp2(STATUS_INSUFFICIENT_POWER, ERROR_INSUFFICIENT_POWER);
+ cmp2(STATUS_DRIVER_FAILED_SLEEP, ERROR_DRIVER_FAILED_SLEEP);
cmp2(STATUS_NOT_FOUND, ERROR_NOT_FOUND);
cmp2(STATUS_NO_MATCH, ERROR_NO_MATCH);
+ cmp2(STATUS_NO_MORE_MATCHES, ERROR_NO_MORE_MATCHES);
cmp2(STATUS_PROPSET_NOT_FOUND, ERROR_SET_NOT_FOUND);
+ cmp2(STATUS_FOUND_OUT_OF_SCOPE, ERROR_FOUND_OUT_OF_SCOPE);
cmp(STATUS_DEVICE_BUSY, ERROR_BUSY);
cmp(STATUS_FREE_VM_NOT_AT_BASE, ERROR_INVALID_ADDRESS);
cmp(STATUS_MEMORY_NOT_ALLOCATED, ERROR_INVALID_ADDRESS);
+ cmp2(STATUS_ALLOCATE_BUCKET, ERROR_ALLOCATE_BUCKET);
cmp(STATUS_NOT_SAME_DEVICE, ERROR_NOT_SAME_DEVICE);
cmp(STATUS_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(STATUS_REMOTE_NOT_LISTENING, ERROR_REM_NOT_LIST);
cmp(STATUS_DEVICE_DOES_NOT_EXIST, ERROR_DEV_NOT_EXIST);
cmp(STATUS_TOO_MANY_COMMANDS, ERROR_TOO_MANY_CMDS);
cmp(STATUS_ADAPTER_HARDWARE_ERROR, ERROR_ADAP_HDW_ERR);
+ cmp2(STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT,ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT);
cmp(STATUS_REDIRECTOR_NOT_STARTED, ERROR_PATH_NOT_FOUND);
cmp(STATUS_INVALID_EA_NAME, ERROR_INVALID_EA_NAME);
cmp(STATUS_EA_LIST_INCONSISTENT, ERROR_EA_LIST_INCONSISTENT);
cmp(STATUS_EA_CORRUPT_ERROR, ERROR_FILE_CORRUPT);
cmp(STATUS_NONEXISTENT_EA_ENTRY, ERROR_FILE_CORRUPT);
cmp(STATUS_NO_EAS_ON_FILE, ERROR_FILE_CORRUPT);
+ cmp2(STATUS_REPARSE, ERROR_REPARSE);
+ cmp2(STATUS_REPARSE_OBJECT, ERROR_REPARSE_OBJECT);
cmp2(STATUS_NOT_A_REPARSE_POINT, ERROR_NOT_A_REPARSE_POINT);
cmp4(STATUS_IO_REPARSE_TAG_INVALID, ERROR_REPARSE_TAG_INVALID, ERROR_INVALID_PARAMETER);
cmp4(STATUS_IO_REPARSE_TAG_MISMATCH, ERROR_REPARSE_TAG_MISMATCH, ERROR_INVALID_PARAMETER);
cmp2(STATUS_JOURNAL_DELETE_IN_PROGRESS, ERROR_JOURNAL_DELETE_IN_PROGRESS);
cmp2(STATUS_JOURNAL_NOT_ACTIVE, ERROR_JOURNAL_NOT_ACTIVE);
cmp2(STATUS_JOURNAL_ENTRY_DELETED, ERROR_JOURNAL_ENTRY_DELETED);
+ cmp2(STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED,ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED);
cmp(STATUS_INVALID_NETWORK_RESPONSE, ERROR_BAD_NET_RESP);
cmp(STATUS_USER_SESSION_DELETED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_UNEXPECTED_NETWORK_ERROR, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TOO_MANY_NODES, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_SESSIONS, ERROR_TOO_MANY_SESS);
cmp(STATUS_SHARING_PAUSED, ERROR_SHARING_PAUSED);
+ cmp2(STATUS_CANT_ENABLE_DENY_ONLY, ERROR_CANT_ENABLE_DENY_ONLY);
cmp(STATUS_REQUEST_NOT_ACCEPTED, ERROR_REQ_NOT_ACCEP);
cmp(STATUS_REDIRECTOR_PAUSED, ERROR_REDIR_PAUSED);
cmp(STATUS_NET_WRITE_FAULT, ERROR_NET_WRITE_FAULT);
cmp(STATUS_END_OF_MEDIA, ERROR_END_OF_MEDIA);
cmp(STATUS_EOM_OVERFLOW, ERROR_EOM_OVERFLOW);
cmp(STATUS_BEGINNING_OF_MEDIA, ERROR_BEGINNING_OF_MEDIA);
+ cmp2(STATUS_MEDIA_CHECK, ERROR_MEDIA_CHECK);
cmp(STATUS_MEDIA_CHANGED, ERROR_MEDIA_CHANGED);
cmp(STATUS_BUS_RESET, ERROR_BUS_RESET);
cmp(STATUS_FILEMARK_DETECTED, ERROR_FILEMARK_DETECTED);
cmp(STATUS_DEVICE_NOT_PARTITIONED, ERROR_DEVICE_NOT_PARTITIONED);
cmp(STATUS_UNABLE_TO_LOCK_MEDIA, ERROR_UNABLE_TO_LOCK_MEDIA);
cmp(STATUS_UNABLE_TO_UNLOAD_MEDIA, ERROR_UNABLE_TO_UNLOAD_MEDIA);
+ cmp2(STATUS_ILLEGAL_CHARACTER, ERROR_ILLEGAL_CHARACTER);
cmp(STATUS_UNMAPPABLE_CHARACTER, ERROR_NO_UNICODE_TRANSLATION);
+ cmp2(STATUS_UNDEFINED_CHARACTER, ERROR_UNDEFINED_CHARACTER);
+ cmp2(STATUS_TRANSLATION_COMPLETE, ERROR_TRANSLATION_COMPLETE);
cmp(STATUS_NOT_ALL_ASSIGNED, ERROR_NOT_ALL_ASSIGNED);
cmp(STATUS_SOME_NOT_MAPPED, ERROR_SOME_NOT_MAPPED);
cmp(STATUS_NO_QUOTAS_FOR_ACCOUNT, ERROR_NO_QUOTAS_FOR_ACCOUNT);
+ cmp2(STATUS_QUOTA_LIST_INCONSISTENT, ERROR_QUOTA_LIST_INCONSISTENT);
cmp(STATUS_LOCAL_USER_SESSION_KEY, ERROR_LOCAL_USER_SESSION_KEY);
cmp(STATUS_NULL_LM_PASSWORD, ERROR_NULL_LM_PASSWORD);
+ cmp2(STATUS_SYNCHRONIZATION_REQUIRED, ERROR_SYNCHRONIZATION_REQUIRED);
+ cmp2(STATUS_WAKE_SYSTEM_DEBUGGER, ERROR_WAKE_SYSTEM_DEBUGGER);
+ cmp2(DBG_EXCEPTION_HANDLED, ERROR_DBG_EXCEPTION_HANDLED);
+ cmp2(DBG_CONTINUE, ERROR_DBG_CONTINUE);
+ cmp2(DBG_TERMINATE_THREAD, ERROR_DBG_TERMINATE_THREAD);
+ cmp2(DBG_TERMINATE_PROCESS, ERROR_DBG_TERMINATE_PROCESS);
+ cmp2(DBG_CONTROL_C, ERROR_DBG_CONTROL_C);
+ cmp2(DBG_PRINTEXCEPTION_C, ERROR_DBG_PRINTEXCEPTION_C);
+ cmp2(DBG_RIPEXCEPTION, ERROR_DBG_RIPEXCEPTION);
+ cmp2(DBG_CONTROL_BREAK, ERROR_DBG_CONTROL_BREAK);
+ cmp2(DBG_COMMAND_EXCEPTION, ERROR_DBG_COMMAND_EXCEPTION);
+ cmp2(DBG_EXCEPTION_NOT_HANDLED, ERROR_DBG_EXCEPTION_NOT_HANDLED);
+ cmp2(STATUS_DEBUG_ATTACH_FAILED, ERROR_DEBUG_ATTACH_FAILED);
+ cmp2(STATUS_VALIDATE_CONTINUE, ERROR_VALIDATE_CONTINUE);
+ cmp2(STATUS_EXTRANEOUS_INFORMATION, ERROR_EXTRANEOUS_INFORMATION);
+ cmp2(STATUS_GUID_SUBSTITUTION_MADE, ERROR_GUID_SUBSTITUTION_MADE);
cmp2(STATUS_IMAGE_MACHINE_TYPE_MISMATCH, ERROR_IMAGE_MACHINE_TYPE_MISMATCH);
cmp2(STATUS_RECEIVE_PARTIAL, ERROR_RECEIVE_PARTIAL);
cmp2(STATUS_RECEIVE_EXPEDITED, ERROR_RECEIVE_EXPEDITED);
cmp2(STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE, ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE);
cmp2(STATUS_NO_YIELD_PERFORMED, ERROR_NO_YIELD_PERFORMED);
cmp2(STATUS_TIMER_RESUME_IGNORED, ERROR_TIMER_RESUME_IGNORED);
+ cmp2(STATUS_TIMER_RESOLUTION_NOT_SET, ERROR_TIMER_RESOLUTION_NOT_SET);
+ cmp2(STATUS_ARBITRATION_UNHANDLED, ERROR_ARBITRATION_UNHANDLED);
+ cmp2(STATUS_CARDBUS_NOT_SUPPORTED, ERROR_CARDBUS_NOT_SUPPORTED);
+ cmp2(STATUS_MP_PROCESSOR_MISMATCH, ERROR_MP_PROCESSOR_MISMATCH);
+ cmp2(STATUS_HIBERNATED, ERROR_HIBERNATED);
+ cmp2(STATUS_RESUME_HIBERNATION, ERROR_RESUME_HIBERNATION);
+ cmp2(STATUS_FIRMWARE_UPDATED, ERROR_FIRMWARE_UPDATED);
+ cmp2(STATUS_WAKE_SYSTEM, ERROR_WAKE_SYSTEM);
+ cmp2(STATUS_WAIT_1, ERROR_WAIT_1);
+ cmp2(STATUS_WAIT_2, ERROR_WAIT_2);
+ cmp2(STATUS_WAIT_3, ERROR_WAIT_3);
+ cmp2(STATUS_WAIT_63, ERROR_WAIT_63);
+ cmp2(STATUS_ABANDONED_WAIT_0, ERROR_WAIT_NO_CHILDREN);
+ cmp2(STATUS_ABANDONED_WAIT_63, ERROR_ABANDONED_WAIT_63);
+ cmp2(STATUS_USER_APC, ERROR_USER_APC);
+ cmp2(STATUS_KERNEL_APC, ERROR_KERNEL_APC);
+ cmp2(STATUS_ALERTED, ERROR_ALERTED);
+ cmp2(STATUS_NOTIFY_CLEANUP, ERROR_NOTIFY_CLEANUP);
+ cmp2(STATUS_NO_CALLBACK_ACTIVE, ERROR_NO_CALLBACK_ACTIVE);
+ cmp4(STATUS_NOINTERFACE, ERROR_NOINTERFACE, E_NOINTERFACE);
cmp(STATUS_BAD_INHERITANCE_ACL, ERROR_BAD_INHERITANCE_ACL);
cmp(STATUS_INVALID_GROUP_ATTRIBUTES, ERROR_INVALID_GROUP_ATTRIBUTES);
cmp(STATUS_BAD_IMPERSONATION_LEVEL, ERROR_BAD_IMPERSONATION_LEVEL);
+ cmp2(STATUS_ELEVATION_REQUIRED, ERROR_ELEVATION_REQUIRED);
cmp(STATUS_CANT_OPEN_ANONYMOUS, ERROR_CANT_OPEN_ANONYMOUS);
cmp(STATUS_BAD_VALIDATION_CLASS, ERROR_BAD_VALIDATION_CLASS);
cmp(STATUS_BAD_TOKEN_TYPE, ERROR_BAD_TOKEN_TYPE);
cmp(STATUS_DOMAIN_LIMIT_EXCEEDED, ERROR_DOMAIN_LIMIT_EXCEEDED);
cmp2(STATUS_OPLOCK_NOT_GRANTED, ERROR_OPLOCK_NOT_GRANTED);
cmp2(STATUS_INVALID_OPLOCK_PROTOCOL, ERROR_INVALID_OPLOCK_PROTOCOL);
+ cmp2(STATUS_OPLOCK_BREAK_IN_PROGRESS, ERROR_OPLOCK_BREAK_IN_PROGRESS);
cmp(STATUS_INTERNAL_DB_CORRUPTION, ERROR_INTERNAL_DB_CORRUPTION);
cmp(STATUS_INTERNAL_ERROR, ERROR_INTERNAL_ERROR);
cmp(STATUS_GENERIC_NOT_MAPPED, ERROR_GENERIC_NOT_MAPPED);
cmp(STATUS_BAD_LOGON_SESSION_STATE, ERROR_BAD_LOGON_SESSION_STATE);
cmp(STATUS_LOGON_SESSION_COLLISION, ERROR_LOGON_SESSION_COLLISION);
cmp(STATUS_INVALID_LOGON_TYPE, ERROR_INVALID_LOGON_TYPE);
+ cmp2(STATUS_LOGON_SERVER_CONFLICT, ERROR_LOGON_SERVER_CONFLICT);
+ cmp2(STATUS_SERVER_SID_MISMATCH, ERROR_SERVER_SID_MISMATCH);
+ cmp2(STATUS_RXACT_STATE_CREATED, ERROR_RXACT_STATE_CREATED);
cmp(STATUS_RXACT_INVALID_STATE, ERROR_RXACT_INVALID_STATE);
+ cmp2(STATUS_RXACT_COMMITTED, ERROR_RXACT_COMMITTED);
+ cmp2(STATUS_RXACT_COMMIT_NECESSARY, ERROR_RXACT_COMMIT_NECESSARY);
cmp(STATUS_RXACT_COMMIT_FAILURE, ERROR_RXACT_COMMIT_FAILURE);
cmp(STATUS_SPECIAL_ACCOUNT, ERROR_SPECIAL_ACCOUNT);
cmp(STATUS_SPECIAL_USER, ERROR_SPECIAL_USER);
cmp(STATUS_NO_SUCH_MEMBER, ERROR_NO_SUCH_MEMBER);
cmp(STATUS_INVALID_MEMBER, ERROR_INVALID_MEMBER);
cmp(STATUS_TOO_MANY_SIDS, ERROR_TOO_MANY_SIDS);
+ cmp2(STATUS_ALL_SIDS_FILTERED, ERROR_ALL_SIDS_FILTERED);
+ cmp2(STATUS_INSUFFICIENT_LOGON_INFO, ERROR_INSUFFICIENT_LOGON_INFO);
cmp(STATUS_LM_CROSS_ENCRYPTION_REQUIRED, ERROR_LM_CROSS_ENCRYPTION_REQUIRED);
cmp(STATUS_MESSAGE_NOT_FOUND, ERROR_MR_MID_NOT_FOUND);
cmp2(STATUS_CONTROL_C_EXIT, ERROR_CONTROL_C_EXIT);
cmp(STATUS_LINK_TIMEOUT, ERROR_UNEXP_NET_ERR);
cmp(STATUS_INVALID_CONNECTION, ERROR_UNEXP_NET_ERR);
cmp(STATUS_INVALID_ADDRESS, ERROR_UNEXP_NET_ERR);
+ cmp2(STATUS_IP_ADDRESS_CONFLICT1, ERROR_IP_ADDRESS_CONFLICT1);
+ cmp2(STATUS_IP_ADDRESS_CONFLICT2, ERROR_IP_ADDRESS_CONFLICT2);
cmp2(STATUS_MISSING_SYSTEMFILE, ERROR_MISSING_SYSTEMFILE);
- cmp2(STATUS_PAGEFILE_CREATE_FAILED, ERROR_PAGEFILE_CREATE_FAILED);
+ cmp2(STATUS_CORRUPT_SYSTEM_FILE, ERROR_CORRUPT_SYSTEM_FILE);
+ cmp2(STATUS_SYSTEM_IMAGE_BAD_SIGNATURE, ERROR_SYSTEM_IMAGE_BAD_SIGNATURE);
+ cmp2(STATUS_CRASH_DUMP, ERROR_CRASH_DUMP);
+ cmp2(STATUS_LONGJUMP, ERROR_LONGJUMP);
+ cmp2(STATUS_UNWIND_CONSOLIDATE, ERROR_UNWIND_CONSOLIDATE);
cmp2(STATUS_UNHANDLED_EXCEPTION, ERROR_UNHANDLED_EXCEPTION);
+ cmp2(STATUS_MCA_OCCURED, ERROR_MCA_OCCURED);
cmp2(STATUS_APP_INIT_FAILURE, ERROR_APP_INIT_FAILURE);
- cmp2(STATUS_NO_PAGEFILE, ERROR_NO_PAGEFILE);
cmp2(STATUS_ILLEGAL_FLOAT_CONTEXT, ERROR_ILLEGAL_FLOAT_CONTEXT);
+ cmp2(STATUS_FLOAT_MULTIPLE_FAULTS, ERROR_FLOAT_MULTIPLE_FAULTS);
+ cmp2(STATUS_FLOAT_MULTIPLE_TRAPS, ERROR_FLOAT_MULTIPLE_TRAPS);
cmp2(STATUS_NO_EVENT_PAIR, ERROR_NO_EVENT_PAIR);
cmp2(STATUS_DOMAIN_CTRLR_CONFIG_ERROR, ERROR_DOMAIN_CTRLR_CONFIG_ERROR);
cmp(STATUS_IO_DEVICE_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DRIVER_INTERNAL_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_INVALID_DEVICE_STATE, ERROR_BAD_COMMAND);
cmp(STATUS_DEVICE_CONFIGURATION_ERROR, ERROR_INVALID_PARAMETER);
+ cmp2(STATUS_DEVICE_ENUMERATION_ERROR, ERROR_DEVICE_ENUMERATION_ERROR);
+ cmp2(STATUS_INVALID_DEVICE_OBJECT_PARAMETER, ERROR_INVALID_DEVICE_OBJECT_PARAMETER);
cmp2(STATUS_SOURCE_ELEMENT_EMPTY, ERROR_SOURCE_ELEMENT_EMPTY);
cmp2(STATUS_DESTINATION_ELEMENT_FULL, ERROR_DESTINATION_ELEMENT_FULL);
cmp2(STATUS_ILLEGAL_ELEMENT_ADDRESS, ERROR_ILLEGAL_ELEMENT_ADDRESS);
cmp2(STATUS_NOT_EXPORT_FORMAT, ERROR_NOT_EXPORT_FORMAT);
cmp2(STATUS_FILE_ENCRYPTED, ERROR_FILE_ENCRYPTED);
cmp2(STATUS_EFS_ALG_BLOB_TOO_BIG, ERROR_EFS_ALG_BLOB_TOO_BIG);
+ cmp2(STATUS_BUFFER_ALL_ZEROS, ERROR_BUFFER_ALL_ZEROS);
cmp(STATUS_INVALID_USER_BUFFER, ERROR_INVALID_USER_BUFFER);
+ cmp2(STATUS_BAD_COMPRESSION_BUFFER, ERROR_BAD_COMPRESSION_BUFFER);
+ cmp2(STATUS_UNSUPPORTED_COMPRESSION, ERROR_UNSUPPORTED_COMPRESSION);
cmp(STATUS_SERIAL_NO_DEVICE_INITED, ERROR_SERIAL_NO_DEVICE);
cmp(STATUS_SHARED_IRQ_BUSY, ERROR_IRQ_BUSY);
cmp(STATUS_SERIAL_MORE_WRITES, ERROR_MORE_WRITES);
cmp(STATUS_FLOPPY_WRONG_CYLINDER, ERROR_FLOPPY_WRONG_CYLINDER);
cmp(STATUS_FLOPPY_UNKNOWN_ERROR, ERROR_FLOPPY_UNKNOWN_ERROR);
cmp(STATUS_FLOPPY_BAD_REGISTERS, ERROR_FLOPPY_BAD_REGISTERS);
+ cmp2(STATUS_FLOPPY_VOLUME, ERROR_FLOPPY_VOLUME);
cmp(STATUS_DISK_RECALIBRATE_FAILED, ERROR_DISK_RECALIBRATE_FAILED);
cmp(STATUS_DISK_OPERATION_FAILED, ERROR_DISK_OPERATION_FAILED);
cmp(STATUS_DISK_RESET_FAILED, ERROR_DISK_RESET_FAILED);
cmp(STATUS_TRANSACTION_INVALID_TYPE, ERROR_UNEXP_NET_ERR);
cmp(STATUS_NOT_SERVER_SESSION, ERROR_NOT_SUPPORTED);
cmp(STATUS_NOT_CLIENT_SESSION, ERROR_NOT_SUPPORTED);
+ cmp2(STATUS_CLIENT_SERVER_PARAMETERS_INVALID,ERROR_CLIENT_SERVER_PARAMETERS_INVALID);
cmp(STATUS_USER_MAPPED_FILE, ERROR_USER_MAPPED_FILE);
+ cmp2(STATUS_INVALID_HW_PROFILE, ERROR_INVALID_HW_PROFILE);
cmp(STATUS_PLUGPLAY_NO_DEVICE, ERROR_SERVICE_DISABLED);
+ cmp2(STATUS_PLUGPLAY_QUERY_VETOED, ERROR_PLUGPLAY_QUERY_VETOED);
+ cmp2(STATUS_INVALID_PLUGPLAY_DEVICE_PATH, ERROR_INVALID_PLUGPLAY_DEVICE_PATH);
+ cmp2(STATUS_PNP_RESTART_ENUMERATION, ERROR_PNP_RESTART_ENUMERATION);
+ cmp2(STATUS_PNP_REBOOT_REQUIRED, ERROR_PNP_REBOOT_REQUIRED);
cmp2(STATUS_WMI_GUID_NOT_FOUND, ERROR_WMI_GUID_NOT_FOUND);
cmp2(STATUS_WMI_INSTANCE_NOT_FOUND, ERROR_WMI_INSTANCE_NOT_FOUND);
cmp2(STATUS_WMI_ITEMID_NOT_FOUND, ERROR_WMI_ITEMID_NOT_FOUND);
cmp2(CRYPT_E_REVOCATION_OFFLINE, ERROR_MUTUAL_AUTH_FAILED);
cmp2(STATUS_SHUTDOWN_IN_PROGRESS, ERROR_SHUTDOWN_IN_PROGRESS);
cmp2(STATUS_SERVER_SHUTDOWN_IN_PROGRESS, ERROR_SERVER_SHUTDOWN_IN_PROGRESS);
+ cmp2(STATUS_SYSTEM_SHUTDOWN, ERROR_SYSTEM_SHUTDOWN);
cmp4(STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY, 1922);
cmp4(STATUS_DS_NO_ATTRIBUTE_OR_VALUE, ERROR_DS_NO_ATTRIBUTE_OR_VALUE, 1923);
cmp4(STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, ERROR_DS_INVALID_ATTRIBUTE_SYNTAX, 1924);
cmp2(STATUS_SAM_NEED_BOOTKEY_FLOPPY, ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY);
cmp2(STATUS_DS_INIT_FAILURE_CONSOLE, ERROR_DS_INIT_FAILURE_CONSOLE);
cmp2(STATUS_DS_SAM_INIT_FAILURE_CONSOLE, ERROR_DS_SAM_INIT_FAILURE_CONSOLE);
+ cmp2(STATUS_DS_VERSION_CHECK_FAILURE, ERROR_DS_VERSION_CHECK_FAILURE);
cmp2(STATUS_UNFINISHED_CONTEXT_DELETED, SEC_E_UNFINISHED_CONTEXT_DELETED);
cmp2(STATUS_NO_TGT_REPLY, SEC_E_NO_TGT_REPLY);
cmp2(STATUS_NO_IP_ADDRESSES, SEC_E_NO_IP_ADDRESSES);
cmp2(STATUS_NOT_SUPPORTED_ON_SBS, ERROR_NOT_SUPPORTED_ON_SBS);
cmp2(STATUS_DRIVER_BLOCKED_CRITICAL, ERROR_DRIVER_BLOCKED);
cmp2(STATUS_DRIVER_BLOCKED, ERROR_DRIVER_BLOCKED);
+ cmp2(STATUS_DRIVER_CANCEL_TIMEOUT, ERROR_DRIVER_CANCEL_TIMEOUT);
cmp2(STATUS_PRENT4_MACHINE_ACCOUNT, ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4);
cmp2(STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER,ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER);
cmp2(STATUS_DS_SHUTTING_DOWN, ERROR_DS_SHUTTING_DOWN);
cmp2(STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE);
cmp2(STATUS_CTX_SHADOW_NOT_RUNNING, ERROR_CTX_SHADOW_NOT_RUNNING);
cmp2(STATUS_LICENSE_VIOLATION, ERROR_CTX_LICENSE_NOT_AVAILABLE);
+ cmp2(STATUS_EVALUATION_EXPIRATION, ERROR_EVALUATION_EXPIRATION);
cmp2(STATUS_NETWORK_SESSION_EXPIRED, ERROR_NO_USER_SESSION_KEY);
cmp2(STATUS_FILES_OPEN, ERROR_OPEN_FILES);
cmp2(STATUS_SXS_SECTION_NOT_FOUND, ERROR_SXS_SECTION_NOT_FOUND);
cmp2(STATUS_SXS_FILE_HASH_MISSING, ERROR_SXS_FILE_HASH_MISSING);
cmp2(STATUS_REDIRECTOR_STARTED, ERROR_SERVICE_ALREADY_RUNNING);
cmp2(STATUS_AUDITING_DISABLED, ERROR_AUDITING_DISABLED);
+ cmp2(STATUS_AUDIT_FAILED, ERROR_AUDIT_FAILED);
cmp2(STATUS_CLUSTER_NODE_ALREADY_UP, ERROR_CLUSTER_NODE_ALREADY_UP);
cmp2(STATUS_CLUSTER_NODE_ALREADY_DOWN, ERROR_CLUSTER_NODE_ALREADY_DOWN);
cmp2(STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, ERROR_CLUSTER_NETWORK_ALREADY_ONLINE);
apc_count = 0;
U(iosb).Status = 0xdeadbabe;
iosb.Information = 0xdeadbeef;
- ok( !is_signaled( read ), "read handle is not signaled\n" );
+ ok( !is_signaled( read ), "read handle is signaled\n" );
status = pNtReadFile( read, 0, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
ok( status == STATUS_PENDING, "wrong status %x\n", status );
ok( !is_signaled( read ), "read handle is signaled\n" );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( read ), "read handle is signaled\n" );
+ ok( is_signaled( read ), "read handle is not signaled\n" );
ok( !apc_count, "apc was called\n" );
apc_count = 0;
SleepEx( 1, FALSE ); /* non-alertable sleep */
ok(ret && written == 1, "WriteFile error %d\n", GetLastError());
/* partial read is good enough */
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
ok( !apc_count, "apc was called\n" );
ok( status == STATUS_INVALID_HANDLE, "wrong status %x\n", status );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" ); /* not reset on invalid handle */
+ ok( is_signaled( event ), "event is not signaled\n" ); /* not reset on invalid handle */
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( !apc_count, "apc was called\n" );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == STATUS_PIPE_BROKEN, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
Sleep(1); /* FIXME: needed for wine to run the i/o apc */
ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 2, "apc was not called\n" );
if (status == STATUS_PENDING) WaitForSingleObject( event, 1000 );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
if (status == STATUS_PENDING) WaitForSingleObject( event, 1000 );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
WaitForSingleObject( event, 1000 );
ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
if (status == STATUS_PENDING) WaitForSingleObject( event, 1000 );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
- ok( is_signaled( event ), "event is signaled\n" );
+ ok( is_signaled( event ), "event is not signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
todo_wine ok( !apc_count, "apc was called\n" );
if ( rc == STATUS_SUCCESS ) pNtClose(hslot);
- /*
- * Test that the length field is checked properly
- */
- attr.Length = 0;
- rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
- &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
- &TimeOut);
- todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
-
- if (rc == STATUS_SUCCESS) pNtClose(hslot);
-
- attr.Length = sizeof(OBJECT_ATTRIBUTES)+1;
- rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
- &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
- &TimeOut);
- todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
-
- if (rc == STATUS_SUCCESS) pNtClose(hslot);
-
- /*
- * Test handling of a NULL unicode string in ObjectName
- */
- InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
- attr.ObjectName = NULL;
- rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
- &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
- &TimeOut);
- ok( rc == STATUS_OBJECT_PATH_SYNTAX_BAD ||
- rc == STATUS_INVALID_PARAMETER,
- "rc = %x not STATUS_OBJECT_PATH_SYNTAX_BAD or STATUS_INVALID_PARAMETER\n", rc);
-
- if (rc == STATUS_SUCCESS) pNtClose(hslot);
-
/*
* Test a valid call
*/
dwret = NtQueryInformationFile(hJunction, &iosb, &new_attrib, sizeof(new_attrib), FileBasicInformation);
ok(dwret == STATUS_SUCCESS, "Failed to get junction point folder's attributes (0x%x).\n", dwret);
ok(old_attrib.LastAccessTime.QuadPart == new_attrib.LastAccessTime.QuadPart,
- "Junction point folder's access time does not match (0x%llx != 0x%llx).\n",
- new_attrib.LastAccessTime.QuadPart, old_attrib.LastAccessTime.QuadPart);
+ "Junction point folder's access time does not match.\n");
CloseHandle(hJunction);
/* Check deleting a junction point as if it were a directory */
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
- timeout.QuadPart = -100000000000ll;
+ timeout.QuadPart = -100000000;
res = pNtCreateNamedPipeFile(handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, sharing, 2 /*FILE_CREATE*/,
options, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
- timeout.QuadPart = -100000000000ll;
+ timeout.QuadPart = -100000000;
/* create a pipe with FILE_OVERWRITE */
res = pNtCreateNamedPipeFile(&handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, FILE_SHARE_READ, 4 /*FILE_OVERWRITE*/,
ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
memset(&iosb, 0x55, sizeof(iosb));
-
-/* try with event and apc */
res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
ok(res == STATUS_PENDING, "NtFsControlFile returned %x\n", res);
+ ok(U(iosb).Status == 0x55555555, "iosb.Status got changed to %x\n", U(iosb).Status);
hClient = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
ok(hClient != INVALID_HANDLE_VALUE, "can't open pipe, GetLastError: %x\n", GetLastError());
ok(ioapc_called, "IOAPC didn't run\n");
- CloseHandle(hEvent);
CloseHandle(hPipe);
CloseHandle(hClient);
+
+ res = create_pipe(&hPipe, FILE_SHARE_READ | FILE_SHARE_WRITE, 0 /* OVERLAPPED */);
+ ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
+
+ hClient = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
+ ok(hClient != INVALID_HANDLE_VALUE || broken(GetLastError() == ERROR_PIPE_BUSY) /* > Win 8 */,
+ "can't open pipe, GetLastError: %x\n", GetLastError());
+
+ if (hClient != INVALID_HANDLE_VALUE)
+ {
+ memset(&iosb, 0x55, sizeof(iosb));
+ res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
+ ok(res == STATUS_PIPE_CONNECTED, "NtFsControlFile returned %x\n", res);
+ ok(U(iosb).Status == 0x55555555, "iosb.Status got changed to %x\n", U(iosb).Status);
+
+ CloseHandle(hClient);
+ }
+
+ CloseHandle(hPipe);
+ CloseHandle(hEvent);
}
static BOOL userapc_called;
todo_wine ok(res == STATUS_CANCELLED, "NtFsControlFile returned %x\n", res);
ok(userapc_called, "user apc didn't run\n");
- todo_wine ok(U(iosb).Status == 0x55555555, "iosb.Status got changed to %x\n", U(iosb).Status);
+ ok(U(iosb).Status == 0x55555555, "iosb.Status got changed to %x\n", U(iosb).Status);
ok(WaitForSingleObjectEx(hEvent, 0, TRUE) == WAIT_TIMEOUT, "hEvent signaled\n");
ok(!ioapc_called, "IOAPC ran\n");
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
- timeout.QuadPart = -100000000000ll;
+ timeout.QuadPart = -100000000;
/* test with INVALID_HANDLE_VALUE */
res = pNtQueryInformationFile(INVALID_HANDLE_VALUE, &iosb, &fpi, sizeof(fpi), (FILE_INFORMATION_CLASS)23);
check_pipe_handle_state(hServer, 0, 1);
hClient = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
- ok(hClient != INVALID_HANDLE_VALUE, "can't open pipe, GetLastError: %x\n", GetLastError());
+ ok(hClient != INVALID_HANDLE_VALUE || broken(GetLastError() == ERROR_PIPE_BUSY) /* > Win 8 */,
+ "can't open pipe, GetLastError: %x\n", GetLastError());
check_pipe_handle_state(hServer, 0, 1);
check_pipe_handle_state(hClient, 0, 0);
check_pipe_handle_state(hServer, 1, 0);
hClient = CreateFileW(testpipe, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
- ok(hClient != INVALID_HANDLE_VALUE, "can't open pipe, GetLastError: %x\n", GetLastError());
+ ok(hClient != INVALID_HANDLE_VALUE || broken(GetLastError() == ERROR_PIPE_BUSY) /* > Win 8 */,
+ "can't open pipe, GetLastError: %x\n", GetLastError());
check_pipe_handle_state(hServer, 1, 0);
check_pipe_handle_state(hClient, 0, 0);
NTSTATUS status;
OBJECT_ATTRIBUTES attr;
ACCESS_MASK am = KEY_READ;
+ UNICODE_STRING str;
/* All NULL */
status = pNtOpenKey(NULL, 0, NULL);
status = pNtOpenKey(&key, am, &attr);
ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got: 0x%08x\n", status);
+ /* Zero accessmask */
+ attr.Length = sizeof(attr);
+ status = pNtOpenKey(&key, 0, &attr);
+todo_wine
+ ok(status == STATUS_ACCESS_DENIED, "Expected STATUS_ACCESS_DENIED, got: 0x%08x\n", status);
+ if (status == STATUS_SUCCESS) NtClose(key);
+
+ /* Calling without parent key requres full registry path. */
+ pRtlCreateUnicodeStringFromAsciiz( &str, "Machine" );
+ InitializeObjectAttributes(&attr, &str, 0, 0, 0);
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenKey Failed: 0x%08x\n", status);
+ pRtlFreeUnicodeString( &str );
+
+ /* Open is case sensitive unless OBJ_CASE_INSENSITIVE is specified. */
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry\\Machine" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine ok(status == STATUS_OBJECT_PATH_NOT_FOUND, "NtOpenKey Failed: 0x%08x\n", status);
+
+ attr.Attributes = OBJ_CASE_INSENSITIVE;
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ ok(status == STATUS_SUCCESS, "NtOpenKey Failed: 0x%08x\n", status);
+ pNtClose(key);
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
+ pNtClose( key );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry\\" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
+ pNtClose( key );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Foobar" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Foobar\\Machine" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Machine\\Software\\Classes" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "Machine\\Software\\Classes" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Device\\Null" );
+ status = pNtOpenKey(&key, KEY_READ, &attr);
+ todo_wine
+ ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtOpenKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
if (!pNtOpenKeyEx)
{
win_skip("NtOpenKeyEx not available\n");
pNtDeleteKey( subkey );
pNtClose( subkey );
+ attr.RootDirectory = 0;
+ attr.Attributes = OBJ_CASE_INSENSITIVE;
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
+ "NtCreateKey failed: 0x%08x\n", status );
+ if (!status) pNtClose( subkey );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry\\" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
+ "NtCreateKey failed: 0x%08x\n", status );
+ if (!status) pNtClose( subkey );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Foobar" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Foobar\\Machine" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Machine\\Software\\Classes" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "Machine\\Software\\Classes" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Device\\Null" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry\\Machine\\Software\\Classes" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
+ "NtCreateKey failed: 0x%08x\n", status );
+ if (!status) pNtClose( subkey );
+ pRtlFreeUnicodeString( &str );
+
+ /* the REGISTRY part is case-sensitive unless OBJ_CASE_INSENSITIVE is specified */
+ attr.Attributes = 0;
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry\\Machine\\Software\\Classes" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ todo_wine
+ ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\REGISTRY\\Machine\\Software\\Classes" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
+ "NtCreateKey failed: 0x%08x\n", status );
+ if (!status) pNtClose( subkey );
+ pRtlFreeUnicodeString( &str );
+
+ pRtlCreateUnicodeStringFromAsciiz( &str, "\\REGISTRY\\MACHINE\\SOFTWARE\\CLASSES" );
+ status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
+ ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
+ "NtCreateKey failed: 0x%08x\n", status );
+ if (!status) pNtClose( subkey );
+ pRtlFreeUnicodeString( &str );
+
pNtClose(key);
}
ok(status == STATUS_SUCCESS, "NtSetValueKey Failed: 0x%08x\n", status);
status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, &pi, sizeof(pi), &len);
- ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_BUFFER_TOO_SMALL instead of 0x%08x\n", status);
+ ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
ok(pi.Type == 0xff00ff00, "Type=%x\n", pi.Type);
ok(pi.DataLength == 0, "DataLength=%u\n", pi.DataLength);
pRtlFreeUnicodeString(&ValName);
pRtlCreateUnicodeStringFromAsciiz(&str, "test_subkey");
status = pNtCreateKey(&subkey, GENERIC_ALL, &attr, 0, 0, 0, 0);
ok(status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status);
+ pRtlFreeUnicodeString(&str);
status = pNtQueryKey(subkey, KeyCachedInformation, &cached_info, sizeof(cached_info), &len);
ok(status == STATUS_SUCCESS, "NtQueryKey Failed: 0x%08x\n", status);
pRtlCreateUnicodeStringFromAsciiz(&str, "test_subkey2");
status = pNtCreateKey(&subkey2, GENERIC_ALL, &attr, 0, 0, 0, 0);
ok(status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status);
+ pRtlFreeUnicodeString(&str);
pRtlCreateUnicodeStringFromAsciiz(&str, "val");
dw = 64;
status = pNtSetValueKey( subkey, &str, 0, REG_DWORD, &dw, sizeof(dw) );
ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
+ pRtlFreeUnicodeString(&str);
if (!winetest_interactive)
skip("ROSTESTS-198: Causes an assert in Cm.\n");
pRtlCreateUnicodeStringFromAsciiz(&str, "test_subkey");
status = pNtCreateKey(&subkey, GENERIC_ALL, &attr, 0, 0, 0, 0);
ok(status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status);
+ pRtlFreeUnicodeString(&str);
status = pNtWaitForSingleObject(events[0], FALSE, &timeout);
ok(status == STATUS_SUCCESS, "NtWaitForSingleObject returned %x\n", status);
pRtlCreateUnicodeStringFromAsciiz(&str, "test_subkey");
status = pNtCreateKey(&subkey, GENERIC_ALL, &attr, 0, 0, 0, 0);
ok(status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status);
+ pRtlFreeUnicodeString(&str);
status = pNtWaitForSingleObject(events[0], FALSE, &timeout);
ok(status == STATUS_SUCCESS, "NtWaitForSingleObject returned %x\n", status);
#include "ntdll_test.h"
#include "inaddr.h"
#include "in6addr.h"
+#include "initguid.h"
+#define COBJMACROS
+#include "shobjidl.h"
#ifndef __WINE_WINTERNL_H
/* Function ptrs for ntdll calls */
static HMODULE hntdll = 0;
-static PVOID (WINAPI *pWinSqmStartSession)(PVOID unknown1, DWORD unknown2, DWORD unknown3);
-static BOOL (WINAPI *pWinSqmIsOptedIn)(void);
-static NTSTATUS (WINAPI *pWinSqmEndSession)(PVOID unknown1);
static SIZE_T (WINAPI *pRtlCompareMemory)(LPCVOID,LPCVOID,SIZE_T);
static SIZE_T (WINAPI *pRtlCompareMemoryUlong)(PULONG, SIZE_T, ULONG);
static NTSTATUS (WINAPI *pRtlDeleteTimer)(HANDLE, HANDLE, HANDLE);
static NTSTATUS (WINAPI *pRtlCompressBuffer)(USHORT, const UCHAR*, ULONG, PUCHAR, ULONG, ULONG, PULONG, PVOID);
static BOOL (WINAPI *pRtlIsCriticalSectionLocked)(CRITICAL_SECTION *);
static BOOL (WINAPI *pRtlIsCriticalSectionLockedByThread)(CRITICAL_SECTION *);
+static NTSTATUS (WINAPI *pRtlInitializeCriticalSectionEx)(CRITICAL_SECTION *, ULONG, ULONG);
+static NTSTATUS (WINAPI *pRtlQueryPackageIdentity)(HANDLE, WCHAR*, SIZE_T*, WCHAR*, SIZE_T*, BOOLEAN*);
static HMODULE hkernel32 = 0;
static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL);
hntdll = LoadLibraryA("ntdll.dll");
ok(hntdll != 0, "LoadLibrary failed\n");
if (hntdll) {
- pWinSqmStartSession = (void *)GetProcAddress(hntdll, "WinSqmStartSession");
- pWinSqmIsOptedIn = (void *)GetProcAddress(hntdll, "WinSqmIsOptedIn");
- pWinSqmEndSession = (void *)GetProcAddress(hntdll, "WinSqmEndSession");
pRtlCompareMemory = (void *)GetProcAddress(hntdll, "RtlCompareMemory");
pRtlCompareMemoryUlong = (void *)GetProcAddress(hntdll, "RtlCompareMemoryUlong");
pRtlDeleteTimer = (void *)GetProcAddress(hntdll, "RtlDeleteTimer");
pRtlCompressBuffer = (void *)GetProcAddress(hntdll, "RtlCompressBuffer");
pRtlIsCriticalSectionLocked = (void *)GetProcAddress(hntdll, "RtlIsCriticalSectionLocked");
pRtlIsCriticalSectionLockedByThread = (void *)GetProcAddress(hntdll, "RtlIsCriticalSectionLockedByThread");
+ pRtlInitializeCriticalSectionEx = (void *)GetProcAddress(hntdll, "RtlInitializeCriticalSectionEx");
+ pRtlQueryPackageIdentity = (void *)GetProcAddress(hntdll, "RtlQueryPackageIdentity");
}
hkernel32 = LoadLibraryA("kernel32.dll");
ok(hkernel32 != 0, "LoadLibrary failed\n");
ok(strlen(src) == 15, "Source must be 16 bytes long!\n");
}
-#ifdef __i386__
-const char stdcall3_thunk[] =
- "\x56" /* push %esi */
- "\x89\xE6" /* mov %esp, %esi */
- "\xFF\x74\x24\x14" /* pushl 20(%esp) */
- "\xFF\x74\x24\x14" /* pushl 20(%esp) */
- "\xFF\x74\x24\x14" /* pushl 20(%esp) */
- "\xFF\x54\x24\x14" /* calll 20(%esp) */
- "\x89\xF0" /* mov %esi, %eax */
- "\x29\xE0" /* sub %esp, %eax */
- "\x89\xF4" /* mov %esi, %esp */
- "\x5E" /* pop %esi */
- "\xC2\x10\x00" /* ret $16 */
-;
-
-static INT (WINAPI *call_stdcall_func3)(PVOID func, PVOID arg0, DWORD arg1, DWORD arg2) = NULL;
-
-static void test_WinSqm(void)
-{
- INT args;
-
- if (!pWinSqmStartSession)
- {
- win_skip("WinSqmStartSession() is not available\n");
- return;
- }
-
- call_stdcall_func3 = (void*) VirtualAlloc( NULL, sizeof(stdcall3_thunk) - 1, MEM_COMMIT,
- PAGE_EXECUTE_READWRITE );
- memcpy( call_stdcall_func3, stdcall3_thunk, sizeof(stdcall3_thunk) - 1 );
-
- args = 3 - call_stdcall_func3( pWinSqmStartSession, NULL, 0, 0 ) / 4;
- ok(args == 3, "WinSqmStartSession expected to take %d arguments instead of 3\n", args);
- args = 3 - call_stdcall_func3( pWinSqmIsOptedIn, NULL, 0, 0 ) / 4;
- ok(args == 0, "WinSqmIsOptedIn expected to take %d arguments instead of 0\n", args);
- args = 3 - call_stdcall_func3( pWinSqmEndSession, NULL, 0, 0 ) / 4;
- ok(args == 1, "WinSqmEndSession expected to take %d arguments instead of 1\n", args);
-
- VirtualFree( call_stdcall_func3, 0, MEM_RELEASE );
-}
-#endif
-
#define COMP(str1,str2,cmplen,len) size = pRtlCompareMemory(str1, str2, cmplen); \
ok(size == len, "Expected %ld, got %ld\n", size, (SIZE_T)len)
ok(res == STATUS_SUCCESS, "[validate] res = 0x%08x, expected STATUS_SUCCESS\n", res);
ok(len == (strlen(tests[i].address) + 1) && !strcmp(buffer, tests[i].address),
- "got len %d with '%s' (expected %d with '%s')\n", len, buffer, strlen(tests[i].address), tests[i].address);
+ "got len %d with '%s' (expected %d with '%s')\n", len, buffer, (int)strlen(tests[i].address), tests[i].address);
}
}
DeleteCriticalSection(&info.crit);
}
+static void test_RtlInitializeCriticalSectionEx(void)
+{
+ static const CRITICAL_SECTION_DEBUG *no_debug = (void *)~(ULONG_PTR)0;
+ CRITICAL_SECTION cs;
+
+ if (!pRtlInitializeCriticalSectionEx)
+ {
+ win_skip("RtlInitializeCriticalSectionEx is not available\n");
+ return;
+ }
+
+ memset(&cs, 0x11, sizeof(cs));
+ pRtlInitializeCriticalSectionEx(&cs, 0, 0);
+ ok((cs.DebugInfo != NULL && cs.DebugInfo != no_debug) || broken(cs.DebugInfo == no_debug) /* >= Win 8 */,
+ "expected DebugInfo != NULL and DebugInfo != ~0, got %p\n", cs.DebugInfo);
+ ok(cs.LockCount == -1, "expected LockCount == -1, got %d\n", cs.LockCount);
+ ok(cs.RecursionCount == 0, "expected RecursionCount == 0, got %d\n", cs.RecursionCount);
+ ok(cs.LockSemaphore == NULL, "expected LockSemaphore == NULL, got %p\n", cs.LockSemaphore);
+ ok(cs.SpinCount == 0 || broken(cs.SpinCount != 0) /* >= Win 8 */,
+ "expected SpinCount == 0, got %ld\n", cs.SpinCount);
+ RtlDeleteCriticalSection((PRTL_CRITICAL_SECTION)&cs);
+
+ memset(&cs, 0x11, sizeof(cs));
+ pRtlInitializeCriticalSectionEx(&cs, 0, RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO);
+ todo_wine
+ ok(cs.DebugInfo == no_debug, "expected DebugInfo == ~0, got %p\n", cs.DebugInfo);
+ ok(cs.LockCount == -1, "expected LockCount == -1, got %d\n", cs.LockCount);
+ ok(cs.RecursionCount == 0, "expected RecursionCount == 0, got %d\n", cs.RecursionCount);
+ ok(cs.LockSemaphore == NULL, "expected LockSemaphore == NULL, got %p\n", cs.LockSemaphore);
+ ok(cs.SpinCount == 0 || broken(cs.SpinCount != 0) /* >= Win 8 */,
+ "expected SpinCount == 0, got %ld\n", cs.SpinCount);
+ RtlDeleteCriticalSection((PRTL_CRITICAL_SECTION)&cs);
+}
+
+static void test_RtlQueryPackageIdentity(void)
+{
+ const WCHAR programW[] = {'M','i','c','r','o','s','o','f','t','.','W','i','n','d','o','w','s','.',
+ 'P','h','o','t','o','s','_','8','w','e','k','y','b','3','d','8','b','b','w','e','!','A','p','p',0};
+ const WCHAR fullnameW[] = {'M','i','c','r','o','s','o','f','t','.','W','i','n','d','o','w','s','.',
+ 'P','h','o','t','o','s', 0};
+ const WCHAR appidW[] = {'A','p','p',0};
+ IApplicationActivationManager *manager;
+ WCHAR buf1[MAX_PATH], buf2[MAX_PATH];
+ HANDLE process, token;
+ SIZE_T size1, size2;
+ NTSTATUS status;
+ DWORD processid;
+ HRESULT hr;
+ BOOL ret;
+
+ if (!pRtlQueryPackageIdentity)
+ {
+ win_skip("RtlQueryPackageIdentity not available\n");
+ return;
+ }
+
+ size1 = size2 = MAX_PATH * sizeof(WCHAR);
+ status = pRtlQueryPackageIdentity((HANDLE)~(ULONG_PTR)3, buf1, &size1, buf2, &size2, NULL);
+ ok(status == STATUS_NOT_FOUND, "expected STATUS_NOT_FOUND, got %08x\n", status);
+
+ CoInitializeEx(0, COINIT_APARTMENTTHREADED);
+ hr = CoCreateInstance(&CLSID_ApplicationActivationManager, NULL, CLSCTX_LOCAL_SERVER,
+ &IID_IApplicationActivationManager, (void **)&manager);
+ if (FAILED(hr))
+ {
+ todo_wine win_skip("Failed to create ApplicationActivationManager (%x)\n", hr);
+ goto done;
+ }
+
+ hr = IApplicationActivationManager_ActivateApplication(manager, programW, NULL,
+ AO_NOERRORUI, &processid);
+ if (FAILED(hr))
+ {
+ todo_wine win_skip("Failed to start program (%x)\n", hr);
+ IApplicationActivationManager_Release(manager);
+ goto done;
+ }
+
+ process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_TERMINATE, FALSE, processid);
+ ok(process != NULL, "OpenProcess failed with %u\n", GetLastError());
+ ret = OpenProcessToken(process, TOKEN_QUERY, &token);
+ ok(ret, "OpenProcessToken failed with error %u\n", GetLastError());
+
+ size1 = size2 = MAX_PATH * sizeof(WCHAR);
+ status = pRtlQueryPackageIdentity(token, buf1, &size1, buf2, &size2, NULL);
+ ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
+
+ ok(!memcmp(buf1, fullnameW, sizeof(fullnameW) - sizeof(WCHAR)),
+ "Expected buf1 to begin with %s, got %s\n", wine_dbgstr_w(fullnameW), wine_dbgstr_w(buf1));
+ ok(size1 >= sizeof(WCHAR) && !(size1 % sizeof(WCHAR)), "Unexpected size1 = %lu\n", size1);
+ ok(buf1[size1 / sizeof(WCHAR) - 1] == 0, "Expected buf1[%lu] == 0\n", size1 / sizeof(WCHAR) - 1);
+
+ ok(!lstrcmpW(buf2, appidW), "Expected buf2 to be %s, got %s\n", wine_dbgstr_w(appidW), wine_dbgstr_w(buf2));
+ ok(size2 >= sizeof(WCHAR) && !(size2 % sizeof(WCHAR)), "Unexpected size2 = %lu\n", size2);
+ ok(buf2[size2 / sizeof(WCHAR) - 1] == 0, "Expected buf2[%lu] == 0\n", size2 / sizeof(WCHAR) - 1);
+
+ CloseHandle(token);
+ TerminateProcess(process, 0);
+ CloseHandle(process);
+
+done:
+ CoUninitialize();
+}
+
START_TEST(rtl)
{
InitFunctionPtrs();
-#ifdef __i386__
- test_WinSqm();
-#else
- skip("stdcall-style parameter checks are not supported on this platform.\n");
-#endif
-
test_RtlCompareMemory();
test_RtlCompareMemoryUlong();
test_RtlMoveMemory();
test_RtlGetCompressionWorkSpaceSize();
test_RtlDecompressBuffer();
test_RtlIsCriticalSectionLocked();
+ test_RtlInitializeCriticalSectionEx();
+ test_RtlQueryPackageIdentity();
}
static NTSTATUS (WINAPI *pRtlAppendUnicodeStringToString)(UNICODE_STRING *, const UNICODE_STRING *);
static NTSTATUS (WINAPI *pRtlAppendUnicodeToString)(UNICODE_STRING *, LPCWSTR);
static NTSTATUS (WINAPI *pRtlCharToInteger)(PCSZ, ULONG, int *);
+static LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING*, const UNICODE_STRING*, BOOLEAN);
+static LONG (WINAPI *pRtlCompareUnicodeStrings)(const WCHAR *,SIZE_T,const WCHAR *,SIZE_T,BOOLEAN);
static VOID (WINAPI *pRtlCopyString)(STRING *, const STRING *);
static BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING, LPCWSTR);
static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR);
/*static VOID (WINAPI *pRtlCopyUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *);*/
/*static VOID (WINAPI *pRtlEraseUnicodeString)(UNICODE_STRING *);*/
/*static LONG (WINAPI *pRtlCompareString)(const STRING *,const STRING *,BOOLEAN);*/
-/*static LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING *,const UNICODE_STRING *,BOOLEAN);*/
/*static BOOLEAN (WINAPI *pRtlEqualString)(const STRING *,const STRING *,BOOLEAN);*/
/*static BOOLEAN (WINAPI *pRtlPrefixString)(const STRING *, const STRING *, BOOLEAN);*/
/*static BOOLEAN (WINAPI *pRtlPrefixUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);*/
pRtlAppendUnicodeStringToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeStringToString");
pRtlAppendUnicodeToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeToString");
pRtlCharToInteger = (void *)GetProcAddress(hntdll, "RtlCharToInteger");
+ pRtlCompareUnicodeString = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeString");
+ pRtlCompareUnicodeStrings = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeStrings");
pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString");
pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString");
pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz");
HeapFree(GetProcessHeap(), 0, be_unicode_no_controls);
}
+static void test_RtlCompareUnicodeString(void)
+{
+ WCHAR ch1, ch2;
+ UNICODE_STRING str1, str2;
+
+ str1.Buffer = &ch1;
+ str1.Length = str1.MaximumLength = sizeof(WCHAR);
+ str2.Buffer = &ch2;
+ str2.Length = str2.MaximumLength = sizeof(WCHAR);
+ for (ch1 = 0; ch1 < 512; ch1++)
+ {
+ for (ch2 = 0; ch2 < 1024; ch2++)
+ {
+ LONG res = pRtlCompareUnicodeString( &str1, &str2, FALSE );
+ ok( res == (ch1 - ch2), "wrong result %d %04x %04x\n", res, ch1, ch2 );
+ res = pRtlCompareUnicodeString( &str1, &str2, TRUE );
+ ok( res == (pRtlUpcaseUnicodeChar(ch1) - pRtlUpcaseUnicodeChar(ch2)),
+ "wrong result %d %04x %04x\n", res, ch1, ch2 );
+ if (pRtlCompareUnicodeStrings)
+ {
+ res = pRtlCompareUnicodeStrings( &ch1, 1, &ch2, 1, FALSE );
+ ok( res == (ch1 - ch2), "wrong result %d %04x %04x\n", res, ch1, ch2 );
+ res = pRtlCompareUnicodeStrings( &ch1, 1, &ch2, 1, TRUE );
+ ok( res == (pRtlUpcaseUnicodeChar(ch1) - pRtlUpcaseUnicodeChar(ch2)),
+ "wrong result %d %04x %04x\n", res, ch1, ch2 );
+ }
+ }
+ }
+}
+
static const WCHAR szGuid[] = { '{','0','1','0','2','0','3','0','4','-',
'0','5','0','6','-' ,'0','7','0','8','-','0','9','0','A','-',
'0','B','0','C','0','D','0','E','0','F','0','A','}','\0' };
test_RtlGUIDFromString();
test_RtlStringFromGUID();
test_RtlIsTextUnicode();
+ test_RtlCompareUnicodeString();
if(0)
{
test_RtlUpcaseUnicodeChar();
projects / reactos.git / commitdiff