reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-26 21:20:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
54daeae72a
wine/dlls/ntdll/tests/error.c

945 lines
64 KiB
C
Raw Normal View History

RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
/*
* Unit tests for RtlNtStatusToDosError function
*
* Copyright (c) 2002 Andriy Palamarchuk
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
Move all STATUS_* and RPC_NT_* to ntstatus.h as per Windows SDK. Add some missing constants. Include ntstatus.h in winnt.h.
2002-09-17 00:03:39 +00:00
#include <stdio.h>
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "wine/test.h"
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
#include "winbase.h"
#include "rpcnterr.h"
Moved all the content of the DDK files ntdef.h and ntddk.h to winternl.h.
2002-09-12 22:07:02 +00:00
#include "winternl.h"
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
#include "ntsecapi.h"
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
/* FIXME!!! this test checks only mappings, defined by MSDN:
* http://support.microsoft.com/default.aspx?scid=KB;EN-US;q113996&
* It is necessary to add other mappings and to test them up to Windows XP.
*
* Some Windows platforms don't know about all the mappings, and in such
* cases they return somewhat strange results (Win98) or a generic error
* like ERROR_MR_MID_NOT_FOUND (NT4). Our tests have to know about these to
* not fail, but we would very much prefer Wine not to return such garbage.
* To you can pass the 'strict' option to this test to force it to only check
* results against the first listed value. This test should pass in strict
* mode on the latest Windows platform (currently XP) and in Wine.
* (of course older Windows platforms will fail to pass the strict mode)
*/
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
static ULONG (WINAPI *statustodoserror)(NTSTATUS Status);
static int strict;
static int prepare_test(void)
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
{
HMODULE ntdll;
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
int argc;
char** argv;
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
ntdll = LoadLibraryA("ntdll.dll");
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
statustodoserror = (void*)GetProcAddress(ntdll, "RtlNtStatusToDosError");
if (!statustodoserror)
return 0;
argc = winetest_get_mainargs(&argv);
strict=(argc >= 3 && strcmp(argv[2],"strict")==0);
return 1;
}
static void cmp_call(NTSTATUS win_nt, ULONG win32, char* message)
{
ULONG err;
err = statustodoserror(win_nt);
ok(err == win32,
"%s (%lx): got %ld, expected %ld",
message, win_nt, err, win32);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
}
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
static void cmp_call2(NTSTATUS win_nt, ULONG win32, char* message)
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
{
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
ULONG err;
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
err = statustodoserror(win_nt);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
ok(err == win32 ||
(!strict && err == ERROR_MR_MID_NOT_FOUND),
"%s (%lx): got %ld, expected %ld (or MID_NOT_FOUND)",
message, win_nt, err, win32);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
}
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
static void cmp_call3(NTSTATUS win_nt, ULONG win32_1, ULONG win32_2, char* message)
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
{
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
ULONG err;
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
err = statustodoserror(win_nt);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
ok(err == win32_1 || (!strict && err == win32_2),
"%s (%lx): got %ld, expected %ld or %ld",
message, win_nt, err, win32_1, win32_2);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
}
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
static void cmp_call4(NTSTATUS win_nt, ULONG win32_1, ULONG win32_2, char* message)
{
ULONG err;
err = statustodoserror(win_nt);
ok(err == win32_1 ||
(!strict && (err == win32_2 || err == ERROR_MR_MID_NOT_FOUND)),
"%s (%lx): got %ld, expected %ld or %ld",
message, win_nt, err, win32_1, win32_2);
}
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
#define cmp(status, error) \
cmp_call(status, error, #status)
#define cmp2(status, error) \
cmp_call2(status, error, #status)
#define cmp3(status, error1, error2) \
cmp_call3(status, error1, error2, #status)
#define cmp4(status, error1, error2) \
cmp_call4(status, error1, error2, #status)
static void run_error_tests(void)
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
{
cmp(STATUS_DATATYPE_MISALIGNMENT, ERROR_NOACCESS);
cmp(STATUS_ACCESS_VIOLATION, ERROR_NOACCESS);
cmp2(STATUS_DATATYPE_MISALIGNMENT_ERROR, ERROR_NOACCESS);
cmp(STATUS_CTL_FILE_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(STATUS_PORT_ALREADY_SET, ERROR_INVALID_PARAMETER);
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_INCOMPATIBLE_FILE_MAP, ERROR_INVALID_PARAMETER);
cmp(STATUS_PORT_DISCONNECTED, ERROR_INVALID_HANDLE);
cmp(STATUS_NOT_LOCKED, ERROR_NOT_LOCKED);
cmp(STATUS_NOT_MAPPED_VIEW, ERROR_INVALID_ADDRESS);
cmp(STATUS_UNABLE_TO_FREE_VM, ERROR_INVALID_PARAMETER);
cmp(STATUS_UNABLE_TO_DELETE_SECTION, ERROR_INVALID_PARAMETER);
cmp(STATUS_MORE_PROCESSING_REQUIRED, ERROR_MORE_DATA);
cmp(STATUS_INVALID_CID, ERROR_INVALID_PARAMETER);
cmp(STATUS_STACK_OVERFLOW, ERROR_STACK_OVERFLOW);
cmp(STATUS_BAD_INITIAL_STACK, 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);
cmp2(STATUS_NO_LDT, ERROR_INVALID_THREAD_ID);
cmp(STATUS_INFO_LENGTH_MISMATCH, ERROR_BAD_LENGTH);
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);
cmp(STATUS_REGISTRY_RECOVERED, ERROR_REGISTRY_RECOVERED);
cmp(STATUS_REGISTRY_IO_FAILED, ERROR_REGISTRY_IO_FAILED);
cmp(STATUS_NOT_REGISTRY_FILE, ERROR_NOT_REGISTRY_FILE);
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);
cmp(STATUS_DLL_NOT_FOUND, ERROR_MOD_NOT_FOUND);
cmp(STATUS_DLL_INIT_FAILED, ERROR_DLL_INIT_FAILED);
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);
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);
cmp(STATUS_NO_MORE_FILES, ERROR_NO_MORE_FILES);
cmp(STATUS_NO_INHERITANCE, ERROR_NO_INHERITANCE);
cmp(STATUS_NO_MORE_EAS, ERROR_NO_MORE_ITEMS);
cmp(STATUS_NO_MORE_ENTRIES, ERROR_NO_MORE_ITEMS);
cmp(STATUS_GUIDS_EXHAUSTED, ERROR_NO_MORE_ITEMS);
cmp(STATUS_AGENTS_EXHAUSTED, ERROR_NO_MORE_ITEMS);
cmp(STATUS_UNSUCCESSFUL, ERROR_GEN_FAILURE);
cmp(STATUS_TOO_MANY_LINKS, ERROR_TOO_MANY_LINKS);
cmp(STATUS_NOT_IMPLEMENTED, ERROR_INVALID_FUNCTION);
cmp(STATUS_ILLEGAL_FUNCTION, ERROR_INVALID_FUNCTION);
cmp(STATUS_IN_PAGE_ERROR, ERROR_SWAPERROR);
cmp(STATUS_PAGEFILE_QUOTA, ERROR_PAGEFILE_QUOTA);
cmp(STATUS_COMMITMENT_LIMIT, ERROR_COMMITMENT_LIMIT);
cmp(STATUS_SECTION_TOO_BIG, ERROR_NOT_ENOUGH_MEMORY);
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_OBJECT_TYPE_MISMATCH, ERROR_INVALID_HANDLE);
cmp(STATUS_FILE_CLOSED, ERROR_INVALID_HANDLE);
cmp(STATUS_INVALID_PORT_HANDLE, ERROR_INVALID_HANDLE);
cmp(STATUS_HANDLE_NOT_CLOSABLE, ERROR_INVALID_HANDLE);
cmp(STATUS_NOT_COMMITTED, ERROR_INVALID_ADDRESS);
cmp(STATUS_PARTIAL_COPY, ERROR_PARTIAL_COPY);
cmp(STATUS_LPC_REPLY_LOST, ERROR_INTERNAL_ERROR);
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_INVALID_PARAMETER_3, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_4, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_5, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_6, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_7, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_8, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_9, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_10, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_11, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_12, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_MIX, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PAGE_PROTECTION, ERROR_INVALID_PARAMETER);
cmp(STATUS_SECTION_PROTECTION, ERROR_INVALID_PARAMETER);
cmp(STATUS_RESOURCE_DATA_NOT_FOUND, ERROR_RESOURCE_DATA_NOT_FOUND);
cmp(STATUS_RESOURCE_TYPE_NOT_FOUND, ERROR_RESOURCE_TYPE_NOT_FOUND);
cmp(STATUS_RESOURCE_NAME_NOT_FOUND, ERROR_RESOURCE_NAME_NOT_FOUND);
cmp(STATUS_RESOURCE_LANG_NOT_FOUND, ERROR_RESOURCE_LANG_NOT_FOUND);
cmp(STATUS_NO_SUCH_DEVICE, ERROR_FILE_NOT_FOUND);
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);
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);
cmp(STATUS_VOLUME_DISMOUNTED, ERROR_NOT_READY);
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);
cmp(STATUS_THREAD_IS_TERMINATING, ERROR_ACCESS_DENIED);
cmp(STATUS_PROCESS_IS_TERMINATING, ERROR_ACCESS_DENIED);
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_ACCESS_DENIED, ERROR_ACCESS_DENIED);
cmp(STATUS_FILE_IS_A_DIRECTORY, ERROR_ACCESS_DENIED);
cmp(STATUS_CANNOT_DELETE, ERROR_ACCESS_DENIED);
cmp(STATUS_INVALID_COMPUTER_NAME, ERROR_INVALID_COMPUTERNAME);
cmp(STATUS_FILE_DELETED, ERROR_ACCESS_DENIED);
cmp2(STATUS_FILE_RENAMED, ERROR_ACCESS_DENIED);
cmp(STATUS_DELETE_PENDING, ERROR_ACCESS_DENIED);
cmp(STATUS_PORT_CONNECTION_REFUSED, ERROR_ACCESS_DENIED);
cmp(STATUS_NO_SUCH_PRIVILEGE, ERROR_NO_SUCH_PRIVILEGE);
cmp(STATUS_PRIVILEGE_NOT_HELD, ERROR_PRIVILEGE_NOT_HELD);
cmp(STATUS_CANNOT_IMPERSONATE, ERROR_CANNOT_IMPERSONATE);
cmp(STATUS_LOGON_FAILURE, ERROR_LOGON_FAILURE);
cmp2(STATUS_MUTUAL_AUTHENTICATION_FAILED, ERROR_MUTUAL_AUTH_FAILED);
cmp2(STATUS_TIME_DIFFERENCE_AT_DC, ERROR_TIME_SKEW);
cmp2(STATUS_PKINIT_FAILURE, ERROR_PKINIT_FAILURE);
cmp2(STATUS_SMARTCARD_SUBSYSTEM_FAILURE, ERROR_SMARTCARD_SUBSYSTEM_FAILURE);
cmp2(STATUS_DOWNGRADE_DETECTED, ERROR_DOWNGRADE_DETECTED);
cmp2(STATUS_SMARTCARD_CERT_REVOKED, SEC_E_SMARTCARD_CERT_REVOKED);
cmp2(STATUS_ISSUING_CA_UNTRUSTED, SEC_E_ISSUING_CA_UNTRUSTED);
cmp2(STATUS_REVOCATION_OFFLINE_C, SEC_E_REVOCATION_OFFLINE_C);
cmp2(STATUS_PKINIT_CLIENT_FAILURE, SEC_E_PKINIT_CLIENT_FAILURE);
cmp2(STATUS_SMARTCARD_CERT_EXPIRED, SEC_E_SMARTCARD_CERT_EXPIRED);
cmp2(STATUS_NO_KERB_KEY, SEC_E_NO_KERB_KEY);
cmp2(STATUS_CURRENT_DOMAIN_NOT_ALLOWED, ERROR_CURRENT_DOMAIN_NOT_ALLOWED);
cmp2(STATUS_SMARTCARD_WRONG_PIN, SCARD_W_WRONG_CHV);
cmp2(STATUS_SMARTCARD_CARD_BLOCKED, SCARD_W_CHV_BLOCKED);
cmp2(STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED,SCARD_W_CARD_NOT_AUTHENTICATED);
cmp2(STATUS_SMARTCARD_NO_CARD, SCARD_E_NO_SMARTCARD);
cmp2(STATUS_SMARTCARD_NO_KEY_CONTAINER, NTE_NO_KEY);
cmp2(STATUS_SMARTCARD_NO_CERTIFICATE, SCARD_E_NO_SUCH_CERTIFICATE);
cmp2(STATUS_SMARTCARD_NO_KEYSET, NTE_BAD_KEYSET);
cmp2(STATUS_SMARTCARD_IO_ERROR, SCARD_E_COMM_DATA_LOST);
cmp(STATUS_ACCOUNT_RESTRICTION, ERROR_ACCOUNT_RESTRICTION);
cmp(STATUS_INVALID_LOGON_HOURS, ERROR_INVALID_LOGON_HOURS);
cmp(STATUS_INVALID_WORKSTATION, ERROR_INVALID_WORKSTATION);
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);
cmp(STATUS_FT_MISSING_MEMBER, ERROR_IO_DEVICE);
cmp(STATUS_FT_ORPHANING, ERROR_IO_DEVICE);
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);
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);
cmp2(STATUS_DFS_UNAVAILABLE, ERROR_CONNECTION_UNAVAIL);
cmp(STATUS_OBJECT_PATH_SYNTAX_BAD, ERROR_BAD_PATHNAME);
cmp(STATUS_NAME_TOO_LONG, ERROR_FILENAME_EXCED_RANGE);
cmp(STATUS_DATA_OVERRUN, ERROR_IO_DEVICE);
cmp(STATUS_DATA_LATE_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DATA_ERROR, ERROR_CRC);
cmp(STATUS_CRC_ERROR, ERROR_CRC);
cmp(STATUS_SHARING_VIOLATION, ERROR_SHARING_VIOLATION);
cmp(STATUS_QUOTA_EXCEEDED, ERROR_NOT_ENOUGH_QUOTA);
cmp(STATUS_MUTANT_NOT_OWNED, ERROR_NOT_OWNER);
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);
cmp(STATUS_NOT_A_DIRECTORY, ERROR_DIRECTORY);
cmp2(STATUS_CANNOT_MAKE, ERROR_CANNOT_MAKE);
cmp(STATUS_UNKNOWN_REVISION, ERROR_UNKNOWN_REVISION);
cmp(STATUS_REVISION_MISMATCH, ERROR_REVISION_MISMATCH);
cmp(STATUS_INVALID_OWNER, ERROR_INVALID_OWNER);
cmp(STATUS_INVALID_PRIMARY_GROUP, ERROR_INVALID_PRIMARY_GROUP);
cmp(STATUS_NO_IMPERSONATION_TOKEN, ERROR_NO_IMPERSONATION_TOKEN);
cmp(STATUS_CANT_DISABLE_MANDATORY, ERROR_CANT_DISABLE_MANDATORY);
cmp(STATUS_NO_LOGON_SERVERS, ERROR_NO_LOGON_SERVERS);
cmp(STATUS_DOMAIN_CONTROLLER_NOT_FOUND, ERROR_DOMAIN_CONTROLLER_NOT_FOUND);
cmp(STATUS_NO_SUCH_LOGON_SESSION, ERROR_NO_SUCH_LOGON_SESSION);
cmp(STATUS_INVALID_ACCOUNT_NAME, ERROR_INVALID_ACCOUNT_NAME);
cmp(STATUS_USER_EXISTS, ERROR_USER_EXISTS);
cmp(STATUS_NO_SUCH_USER, ERROR_NO_SUCH_USER);
cmp(STATUS_GROUP_EXISTS, ERROR_GROUP_EXISTS);
cmp(STATUS_NO_SUCH_GROUP, ERROR_NO_SUCH_GROUP);
cmp(STATUS_SPECIAL_GROUP, ERROR_SPECIAL_GROUP);
cmp(STATUS_MEMBER_IN_GROUP, ERROR_MEMBER_IN_GROUP);
cmp(STATUS_MEMBER_NOT_IN_GROUP, ERROR_MEMBER_NOT_IN_GROUP);
cmp(STATUS_LAST_ADMIN, ERROR_LAST_ADMIN);
cmp(STATUS_WRONG_PASSWORD, ERROR_INVALID_PASSWORD);
cmp(STATUS_WRONG_PASSWORD_CORE, ERROR_INVALID_PASSWORD);
cmp(STATUS_ILL_FORMED_PASSWORD, ERROR_ILL_FORMED_PASSWORD);
cmp(STATUS_PASSWORD_RESTRICTION, ERROR_PASSWORD_RESTRICTION);
cmp(STATUS_PASSWORD_EXPIRED, ERROR_PASSWORD_EXPIRED);
cmp(STATUS_PASSWORD_MUST_CHANGE, ERROR_PASSWORD_MUST_CHANGE);
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_TOO_MANY_LUIDS_REQUESTED, ERROR_TOO_MANY_LUIDS_REQUESTED);
cmp(STATUS_LUIDS_EXHAUSTED, ERROR_LUIDS_EXHAUSTED);
cmp(STATUS_INVALID_SUB_AUTHORITY, ERROR_INVALID_SUB_AUTHORITY);
cmp(STATUS_INVALID_ACL, ERROR_INVALID_ACL);
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);
cmp(STATUS_BAD_INITIAL_PC, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_FILE_FOR_SECTION, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_FORMAT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_IMAGE_MP_UP_MISMATCH, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_NOT_MZ, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_IMAGE_CHECKSUM_MISMATCH, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_PROTECT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_LE_FORMAT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_NE_FORMAT, ERROR_BAD_EXE_FORMAT);
cmp(STATUS_INVALID_IMAGE_WIN_16, ERROR_BAD_EXE_FORMAT);
cmp2(STATUS_INVALID_IMAGE_WIN_32, ERROR_BAD_EXE_FORMAT);
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);
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);
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_MAPPED_FILE_SIZE_ZERO, ERROR_FILE_INVALID);
cmp(STATUS_DEVICE_PAPER_EMPTY, ERROR_OUT_OF_PAPER);
cmp(STATUS_DEVICE_POWERED_OFF, ERROR_NOT_READY);
cmp(STATUS_DEVICE_OFF_LINE, ERROR_NOT_READY);
cmp(STATUS_DEVICE_DATA_ERROR, ERROR_CRC);
cmp(STATUS_DEVICE_NOT_READY, ERROR_NOT_READY);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
cmp3(STATUS_DEVICE_NOT_CONNECTED, ERROR_DEVICE_NOT_CONNECTED, ERROR_NOT_READY);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp(STATUS_DEVICE_POWER_FAILURE, ERROR_NOT_READY);
cmp2(STATUS_NOT_FOUND, ERROR_NOT_FOUND);
cmp2(STATUS_NO_MATCH, ERROR_NO_MATCH);
cmp2(STATUS_PROPSET_NOT_FOUND, ERROR_SET_NOT_FOUND);
cmp(STATUS_DEVICE_BUSY, ERROR_BUSY);
cmp(STATUS_FREE_VM_NOT_AT_BASE, ERROR_INVALID_ADDRESS);
cmp(STATUS_MEMORY_NOT_ALLOCATED, ERROR_INVALID_ADDRESS);
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_DUPLICATE_NAME, ERROR_DUP_NAME);
cmp(STATUS_BAD_NETWORK_PATH, ERROR_BAD_NETPATH);
cmp(STATUS_NETWORK_BUSY, ERROR_NETWORK_BUSY);
cmp2(STATUS_ONLY_IF_CONNECTED, ERROR_ONLY_IF_CONNECTED);
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);
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_TOO_LARGE, ERROR_EA_LIST_INCONSISTENT);
cmp(STATUS_INVALID_EA_FLAG, ERROR_EA_LIST_INCONSISTENT);
cmp2(STATUS_EAS_NOT_SUPPORTED, ERROR_EAS_NOT_SUPPORTED);
cmp(STATUS_FILE_CORRUPT_ERROR, ERROR_FILE_CORRUPT);
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_NOT_A_REPARSE_POINT, ERROR_NOT_A_REPARSE_POINT);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
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);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp2(STATUS_IO_REPARSE_TAG_NOT_HANDLED, ERROR_CANT_ACCESS_FILE);
cmp2(STATUS_REPARSE_POINT_NOT_RESOLVED, ERROR_CANT_RESOLVE_FILENAME);
cmp2(STATUS_DIRECTORY_IS_A_REPARSE_POINT, ERROR_BAD_PATHNAME);
cmp2(STATUS_REPARSE_ATTRIBUTE_CONFLICT, ERROR_REPARSE_ATTRIBUTE_CONFLICT);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
cmp4(STATUS_IO_REPARSE_DATA_INVALID, ERROR_INVALID_REPARSE_DATA, ERROR_INVALID_PARAMETER);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp2(STATUS_FILE_IS_OFFLINE, ERROR_FILE_OFFLINE);
cmp2(STATUS_REMOTE_STORAGE_NOT_ACTIVE, ERROR_REMOTE_STORAGE_NOT_ACTIVE);
cmp2(STATUS_REMOTE_STORAGE_MEDIA_ERROR, ERROR_REMOTE_STORAGE_MEDIA_ERROR);
cmp2(STATUS_NO_TRACKING_SERVICE, ERROR_NO_TRACKING_SERVICE);
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);
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_BAD_REMOTE_ADAPTER, ERROR_BAD_REM_ADAP);
cmp(STATUS_PRINT_QUEUE_FULL, ERROR_PRINTQ_FULL);
cmp(STATUS_NO_SPOOL_SPACE, ERROR_NO_SPOOL_SPACE);
cmp(STATUS_PRINT_CANCELLED, ERROR_PRINT_CANCELLED);
cmp(STATUS_NETWORK_NAME_DELETED, ERROR_NETNAME_DELETED);
cmp(STATUS_NETWORK_ACCESS_DENIED, ERROR_NETWORK_ACCESS_DENIED);
cmp(STATUS_BAD_DEVICE_TYPE, ERROR_BAD_DEV_TYPE);
cmp(STATUS_BAD_NETWORK_NAME, ERROR_BAD_NET_NAME);
cmp(STATUS_TOO_MANY_NAMES, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_GUIDS_REQUESTED, ERROR_TOO_MANY_NAMES);
cmp(STATUS_TOO_MANY_ADDRESSES, ERROR_TOO_MANY_NAMES);
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);
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_VIRTUAL_CIRCUIT_CLOSED, ERROR_VC_DISCONNECTED);
cmp(STATUS_INVALID_PIPE_STATE, ERROR_BAD_PIPE);
cmp(STATUS_INVALID_READ_MODE, ERROR_BAD_PIPE);
cmp(STATUS_PIPE_CLOSING, ERROR_NO_DATA);
cmp(STATUS_PIPE_EMPTY, ERROR_NO_DATA);
cmp(STATUS_PIPE_CONNECTED, ERROR_PIPE_CONNECTED);
cmp(STATUS_PIPE_DISCONNECTED, ERROR_PIPE_NOT_CONNECTED);
cmp(STATUS_PIPE_LISTENING, ERROR_PIPE_LISTENING);
cmp(STATUS_PIPE_NOT_AVAILABLE, ERROR_PIPE_BUSY);
cmp(STATUS_INSTANCE_NOT_AVAILABLE, ERROR_PIPE_BUSY);
cmp(STATUS_PIPE_BUSY, ERROR_PIPE_BUSY);
cmp(STATUS_PIPE_BROKEN, ERROR_BROKEN_PIPE);
cmp(STATUS_DIRECTORY_NOT_EMPTY, ERROR_DIR_NOT_EMPTY);
cmp(STATUS_TOO_MANY_OPENED_FILES, ERROR_TOO_MANY_OPEN_FILES);
cmp(STATUS_IO_TIMEOUT, ERROR_SEM_TIMEOUT);
cmp(STATUS_CANCELLED, ERROR_OPERATION_ABORTED);
cmp(STATUS_UNRECOGNIZED_MEDIA, ERROR_UNRECOGNIZED_MEDIA);
cmp(STATUS_INVALID_LEVEL, ERROR_INVALID_LEVEL);
cmp(STATUS_UNRECOGNIZED_VOLUME, ERROR_UNRECOGNIZED_VOLUME);
cmp(STATUS_MEDIA_WRITE_PROTECTED, ERROR_WRITE_PROTECT);
cmp(STATUS_TOO_LATE, ERROR_WRITE_PROTECT);
cmp(STATUS_SUCCESS, NO_ERROR);
cmp(STATUS_FULLSCREEN_MODE, ERROR_FULLSCREEN_MODE);
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);
cmp(STATUS_MEDIA_CHANGED, ERROR_MEDIA_CHANGED);
cmp(STATUS_BUS_RESET, ERROR_BUS_RESET);
cmp(STATUS_FILEMARK_DETECTED, ERROR_FILEMARK_DETECTED);
cmp(STATUS_SETMARK_DETECTED, ERROR_SETMARK_DETECTED);
cmp(STATUS_NO_DATA_DETECTED, ERROR_NO_DATA_DETECTED);
cmp(STATUS_PARTITION_FAILURE, ERROR_PARTITION_FAILURE);
cmp(STATUS_INVALID_BLOCK_LENGTH, ERROR_INVALID_BLOCK_LENGTH);
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);
cmp(STATUS_UNMAPPABLE_CHARACTER, ERROR_NO_UNICODE_TRANSLATION);
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);
cmp(STATUS_LOCAL_USER_SESSION_KEY, ERROR_LOCAL_USER_SESSION_KEY);
cmp(STATUS_NULL_LM_PASSWORD, ERROR_NULL_LM_PASSWORD);
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);
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);
cmp2(STATUS_BAD_MASTER_BOOT_RECORD, ERROR_INVALID_PARAMETER);
cmp(STATUS_NO_SECURITY_ON_OBJECT, ERROR_NO_SECURITY_ON_OBJECT);
cmp(STATUS_CANT_ACCESS_DOMAIN_INFO, ERROR_CANT_ACCESS_DOMAIN_INFO);
cmp(STATUS_INVALID_SERVER_STATE, ERROR_INVALID_SERVER_STATE);
cmp(STATUS_INVALID_DOMAIN_STATE, ERROR_INVALID_DOMAIN_STATE);
cmp(STATUS_INVALID_DOMAIN_ROLE, ERROR_INVALID_DOMAIN_ROLE);
cmp(STATUS_NO_SUCH_DOMAIN, ERROR_NO_SUCH_DOMAIN);
cmp(STATUS_DOMAIN_EXISTS, ERROR_DOMAIN_EXISTS);
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);
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_DESCRIPTOR_FORMAT, ERROR_BAD_DESCRIPTOR_FORMAT);
cmp(STATUS_NOT_LOGON_PROCESS, ERROR_NOT_LOGON_PROCESS);
cmp(STATUS_LOGON_SESSION_EXISTS, ERROR_LOGON_SESSION_EXISTS);
cmp(STATUS_NO_SUCH_PACKAGE, ERROR_NO_SUCH_PACKAGE);
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);
cmp(STATUS_RXACT_INVALID_STATE, ERROR_RXACT_INVALID_STATE);
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_MEMBERS_PRIMARY_GROUP, ERROR_MEMBERS_PRIMARY_GROUP);
cmp(STATUS_TOKEN_ALREADY_IN_USE, ERROR_TOKEN_ALREADY_IN_USE);
cmp(STATUS_NO_SUCH_ALIAS, ERROR_NO_SUCH_ALIAS);
cmp(STATUS_MEMBER_NOT_IN_ALIAS, ERROR_MEMBER_NOT_IN_ALIAS);
cmp(STATUS_MEMBER_IN_ALIAS, ERROR_MEMBER_IN_ALIAS);
cmp(STATUS_ALIAS_EXISTS, ERROR_ALIAS_EXISTS);
cmp(STATUS_LOGON_NOT_GRANTED, ERROR_LOGON_NOT_GRANTED);
cmp(STATUS_TOO_MANY_SECRETS, ERROR_TOO_MANY_SECRETS);
cmp(STATUS_SECRET_TOO_LONG, ERROR_SECRET_TOO_LONG);
cmp(STATUS_INTERNAL_DB_ERROR, ERROR_INTERNAL_DB_ERROR);
cmp(STATUS_TOO_MANY_CONTEXT_IDS, ERROR_TOO_MANY_CONTEXT_IDS);
cmp(STATUS_LOGON_TYPE_NOT_GRANTED, ERROR_LOGON_TYPE_NOT_GRANTED);
cmp(STATUS_NT_CROSS_ENCRYPTION_REQUIRED, ERROR_NT_CROSS_ENCRYPTION_REQUIRED);
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);
cmp(STATUS_LM_CROSS_ENCRYPTION_REQUIRED, ERROR_LM_CROSS_ENCRYPTION_REQUIRED);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
cmp(STATUS_MESSAGE_NOT_FOUND, ERROR_MR_MID_NOT_FOUND);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp(STATUS_LOCAL_DISCONNECT, ERROR_NETNAME_DELETED);
cmp(STATUS_REMOTE_DISCONNECT, ERROR_NETNAME_DELETED);
cmp(STATUS_REMOTE_RESOURCES, ERROR_REM_NOT_LIST);
cmp(STATUS_LINK_FAILED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_LINK_TIMEOUT, ERROR_UNEXP_NET_ERR);
cmp(STATUS_INVALID_CONNECTION, ERROR_UNEXP_NET_ERR);
cmp(STATUS_INVALID_ADDRESS, ERROR_UNEXP_NET_ERR);
cmp(STATUS_IO_DEVICE_ERROR, ERROR_IO_DEVICE);
cmp(STATUS_DEVICE_PROTOCOL_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_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_MAGAZINE_NOT_PRESENT, ERROR_MAGAZINE_NOT_PRESENT);
cmp2(STATUS_REINITIALIZATION_NEEDED, ERROR_DEVICE_REINITIALIZATION_NEEDED);
cmp2(STATUS_DEVICE_REQUIRES_CLEANING, ERROR_DEVICE_REQUIRES_CLEANING);
cmp2(STATUS_DEVICE_DOOR_OPEN, ERROR_DEVICE_DOOR_OPEN);
cmp2(STATUS_TRANSPORT_FULL, ERROR_TRANSPORT_FULL);
cmp2(STATUS_CLEANER_CARTRIDGE_INSTALLED, ERROR_CLEANER_CARTRIDGE_INSTALLED);
cmp2(STATUS_REG_NAT_CONSUMPTION, ERROR_REG_NAT_CONSUMPTION);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
cmp4(STATUS_ENCRYPTION_FAILED, ERROR_ACCESS_DENIED, ERROR_ENCRYPTION_FAILED);
cmp4(STATUS_DECRYPTION_FAILED, ERROR_ACCESS_DENIED, ERROR_DECRYPTION_FAILED);
cmp4(STATUS_NO_RECOVERY_POLICY, ERROR_ACCESS_DENIED, ERROR_NO_RECOVERY_POLICY);
cmp4(STATUS_NO_EFS, ERROR_ACCESS_DENIED, ERROR_NO_EFS);
cmp4(STATUS_WRONG_EFS, ERROR_ACCESS_DENIED, ERROR_WRONG_EFS);
cmp4(STATUS_NO_USER_KEYS, ERROR_ACCESS_DENIED, ERROR_NO_USER_KEYS);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp2(STATUS_FILE_NOT_ENCRYPTED, ERROR_FILE_NOT_ENCRYPTED);
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);
cmp(STATUS_INVALID_USER_BUFFER, ERROR_INVALID_USER_BUFFER);
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_SERIAL_COUNTER_TIMEOUT, ERROR_COUNTER_TIMEOUT);
cmp(STATUS_FLOPPY_ID_MARK_NOT_FOUND, ERROR_FLOPPY_ID_MARK_NOT_FOUND);
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);
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_EVENTLOG_FILE_CORRUPT, ERROR_EVENTLOG_FILE_CORRUPT);
cmp(STATUS_EVENTLOG_CANT_START, ERROR_EVENTLOG_CANT_START);
cmp(STATUS_NETLOGON_NOT_STARTED, ERROR_NETLOGON_NOT_STARTED);
cmp(STATUS_ACCOUNT_EXPIRED, ERROR_ACCOUNT_EXPIRED);
cmp(STATUS_NETWORK_CREDENTIAL_CONFLICT, ERROR_SESSION_CREDENTIAL_CONFLICT);
cmp(STATUS_REMOTE_SESSION_LIMIT, ERROR_REMOTE_SESSION_LIMIT_EXCEEDED);
cmp(STATUS_INVALID_BUFFER_SIZE, ERROR_INVALID_USER_BUFFER);
cmp(STATUS_INVALID_ADDRESS_COMPONENT, ERROR_INVALID_NETNAME);
cmp(STATUS_INVALID_ADDRESS_WILDCARD, ERROR_INVALID_NETNAME);
cmp(STATUS_ADDRESS_ALREADY_EXISTS, ERROR_DUP_NAME);
cmp(STATUS_ADDRESS_CLOSED, ERROR_NETNAME_DELETED);
cmp(STATUS_CONNECTION_DISCONNECTED, ERROR_NETNAME_DELETED);
cmp(STATUS_CONNECTION_RESET, ERROR_NETNAME_DELETED);
cmp(STATUS_TRANSACTION_ABORTED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_TIMED_OUT, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_NO_RELEASE, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_NO_MATCH, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_RESPONDED, ERROR_UNEXP_NET_ERR);
cmp(STATUS_TRANSACTION_INVALID_ID, ERROR_UNEXP_NET_ERR);
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);
cmp(STATUS_USER_MAPPED_FILE, ERROR_USER_MAPPED_FILE);
cmp(STATUS_PLUGPLAY_NO_DEVICE, ERROR_SERVICE_DISABLED);
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(STATUS_WMI_TRY_AGAIN, ERROR_WMI_TRY_AGAIN);
cmp2(STATUS_WMI_READ_ONLY, ERROR_WMI_READ_ONLY);
cmp2(STATUS_WMI_SET_FAILURE, ERROR_WMI_SET_FAILURE);
cmp2(STATUS_WMI_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp2(STATUS_WMI_GUID_DISCONNECTED, ERROR_WMI_GUID_DISCONNECTED);
cmp2(STATUS_WMI_ALREADY_DISABLED, ERROR_WMI_ALREADY_DISABLED);
cmp2(STATUS_WMI_ALREADY_ENABLED, ERROR_WMI_ALREADY_ENABLED);
cmp2(STATUS_COPY_PROTECTION_FAILURE, STG_E_STATUS_COPY_PROTECTION_FAILURE);
cmp2(STATUS_CSS_AUTHENTICATION_FAILURE, STG_E_CSS_AUTHENTICATION_FAILURE);
cmp2(STATUS_CSS_KEY_NOT_PRESENT, STG_E_CSS_KEY_NOT_PRESENT);
cmp2(STATUS_CSS_KEY_NOT_ESTABLISHED, STG_E_CSS_KEY_NOT_ESTABLISHED);
cmp2(STATUS_CSS_SCRAMBLED_SECTOR, STG_E_CSS_SCRAMBLED_SECTOR);
cmp2(STATUS_CSS_REGION_MISMATCH, STG_E_CSS_REGION_MISMATCH);
cmp2(STATUS_CSS_RESETS_EXHAUSTED, STG_E_RESETS_EXHAUSTED);
cmp(RPC_NT_SERVER_UNAVAILABLE, RPC_S_SERVER_UNAVAILABLE);
cmp(RPC_NT_INVALID_STRING_BINDING, RPC_S_INVALID_STRING_BINDING);
cmp(RPC_NT_WRONG_KIND_OF_BINDING, RPC_S_WRONG_KIND_OF_BINDING);
cmp(RPC_NT_PROTSEQ_NOT_SUPPORTED, RPC_S_PROTSEQ_NOT_SUPPORTED);
cmp(RPC_NT_INVALID_RPC_PROTSEQ, RPC_S_INVALID_RPC_PROTSEQ);
cmp(RPC_NT_INVALID_STRING_UUID, RPC_S_INVALID_STRING_UUID);
cmp(RPC_NT_INVALID_ENDPOINT_FORMAT, RPC_S_INVALID_ENDPOINT_FORMAT);
cmp(RPC_NT_INVALID_NET_ADDR, RPC_S_INVALID_NET_ADDR);
cmp(RPC_NT_NO_ENDPOINT_FOUND, RPC_S_NO_ENDPOINT_FOUND);
cmp(RPC_NT_INVALID_TIMEOUT, RPC_S_INVALID_TIMEOUT);
cmp(RPC_NT_OBJECT_NOT_FOUND, RPC_S_OBJECT_NOT_FOUND);
cmp(RPC_NT_ALREADY_REGISTERED, RPC_S_ALREADY_REGISTERED);
cmp(RPC_NT_TYPE_ALREADY_REGISTERED, RPC_S_TYPE_ALREADY_REGISTERED);
cmp(RPC_NT_ALREADY_LISTENING, RPC_S_ALREADY_LISTENING);
cmp(RPC_NT_NO_PROTSEQS_REGISTERED, RPC_S_NO_PROTSEQS_REGISTERED);
cmp(RPC_NT_NOT_LISTENING, RPC_S_NOT_LISTENING);
cmp(RPC_NT_UNKNOWN_MGR_TYPE, RPC_S_UNKNOWN_MGR_TYPE);
cmp(RPC_NT_UNKNOWN_IF, RPC_S_UNKNOWN_IF);
cmp(RPC_NT_NO_BINDINGS, RPC_S_NO_BINDINGS);
cmp(RPC_NT_NO_MORE_BINDINGS, RPC_S_NO_MORE_BINDINGS);
cmp(RPC_NT_NO_PROTSEQS, RPC_S_NO_PROTSEQS);
cmp(RPC_NT_CANT_CREATE_ENDPOINT, RPC_S_CANT_CREATE_ENDPOINT);
cmp(RPC_NT_OUT_OF_RESOURCES, RPC_S_OUT_OF_RESOURCES);
cmp(RPC_NT_SERVER_TOO_BUSY, RPC_S_SERVER_TOO_BUSY);
cmp(RPC_NT_INVALID_NETWORK_OPTIONS, RPC_S_INVALID_NETWORK_OPTIONS);
cmp(RPC_NT_NO_CALL_ACTIVE, RPC_S_NO_CALL_ACTIVE);
cmp(RPC_NT_CALL_FAILED, RPC_S_CALL_FAILED);
cmp(RPC_NT_CALL_FAILED_DNE, RPC_S_CALL_FAILED_DNE);
cmp(RPC_NT_PROTOCOL_ERROR, RPC_S_PROTOCOL_ERROR);
cmp(RPC_NT_UNSUPPORTED_TRANS_SYN, RPC_S_UNSUPPORTED_TRANS_SYN);
cmp(RPC_NT_UNSUPPORTED_TYPE, RPC_S_UNSUPPORTED_TYPE);
cmp(RPC_NT_INVALID_TAG, RPC_S_INVALID_TAG);
cmp(RPC_NT_INVALID_BOUND, RPC_S_INVALID_BOUND);
cmp(RPC_NT_NO_ENTRY_NAME, RPC_S_NO_ENTRY_NAME);
cmp(RPC_NT_INVALID_NAME_SYNTAX, RPC_S_INVALID_NAME_SYNTAX);
cmp(RPC_NT_UNSUPPORTED_NAME_SYNTAX, RPC_S_UNSUPPORTED_NAME_SYNTAX);
cmp(RPC_NT_UUID_NO_ADDRESS, RPC_S_UUID_NO_ADDRESS);
cmp(RPC_NT_DUPLICATE_ENDPOINT, RPC_S_DUPLICATE_ENDPOINT);
cmp(RPC_NT_UNKNOWN_AUTHN_TYPE, RPC_S_UNKNOWN_AUTHN_TYPE);
cmp(RPC_NT_MAX_CALLS_TOO_SMALL, RPC_S_MAX_CALLS_TOO_SMALL);
cmp(RPC_NT_STRING_TOO_LONG, RPC_S_STRING_TOO_LONG);
cmp(RPC_NT_PROTSEQ_NOT_FOUND, RPC_S_PROTSEQ_NOT_FOUND);
cmp(RPC_NT_PROCNUM_OUT_OF_RANGE, RPC_S_PROCNUM_OUT_OF_RANGE);
cmp(RPC_NT_BINDING_HAS_NO_AUTH, RPC_S_BINDING_HAS_NO_AUTH);
cmp(RPC_NT_UNKNOWN_AUTHN_SERVICE, RPC_S_UNKNOWN_AUTHN_SERVICE);
cmp(RPC_NT_UNKNOWN_AUTHN_LEVEL, RPC_S_UNKNOWN_AUTHN_LEVEL);
cmp(RPC_NT_INVALID_AUTH_IDENTITY, RPC_S_INVALID_AUTH_IDENTITY);
cmp(RPC_NT_UNKNOWN_AUTHZ_SERVICE, RPC_S_UNKNOWN_AUTHZ_SERVICE);
cmp(EPT_NT_INVALID_ENTRY, EPT_S_INVALID_ENTRY);
cmp(EPT_NT_CANT_PERFORM_OP, EPT_S_CANT_PERFORM_OP);
cmp(EPT_NT_NOT_REGISTERED, EPT_S_NOT_REGISTERED);
cmp(RPC_NT_NOTHING_TO_EXPORT, RPC_S_NOTHING_TO_EXPORT);
cmp(RPC_NT_INCOMPLETE_NAME, RPC_S_INCOMPLETE_NAME);
cmp(RPC_NT_INVALID_VERS_OPTION, RPC_S_INVALID_VERS_OPTION);
cmp(RPC_NT_NO_MORE_MEMBERS, RPC_S_NO_MORE_MEMBERS);
cmp(RPC_NT_NOT_ALL_OBJS_UNEXPORTED, RPC_S_NOT_ALL_OBJS_UNEXPORTED);
cmp(RPC_NT_INTERFACE_NOT_FOUND, RPC_S_INTERFACE_NOT_FOUND);
cmp(RPC_NT_ENTRY_ALREADY_EXISTS, RPC_S_ENTRY_ALREADY_EXISTS);
cmp(RPC_NT_ENTRY_NOT_FOUND, RPC_S_ENTRY_NOT_FOUND);
cmp(RPC_NT_NAME_SERVICE_UNAVAILABLE, RPC_S_NAME_SERVICE_UNAVAILABLE);
cmp(RPC_NT_INVALID_NAF_ID, RPC_S_INVALID_NAF_ID);
cmp(RPC_NT_CANNOT_SUPPORT, RPC_S_CANNOT_SUPPORT);
cmp(RPC_NT_NO_CONTEXT_AVAILABLE, RPC_S_NO_CONTEXT_AVAILABLE);
cmp(RPC_NT_INTERNAL_ERROR, RPC_S_INTERNAL_ERROR);
cmp(RPC_NT_ZERO_DIVIDE, RPC_S_ZERO_DIVIDE);
cmp(RPC_NT_ADDRESS_ERROR, RPC_S_ADDRESS_ERROR);
cmp(RPC_NT_FP_DIV_ZERO, RPC_S_FP_DIV_ZERO);
cmp(RPC_NT_FP_UNDERFLOW, RPC_S_FP_UNDERFLOW);
cmp(RPC_NT_FP_OVERFLOW, RPC_S_FP_OVERFLOW);
cmp(RPC_NT_NO_MORE_ENTRIES, RPC_X_NO_MORE_ENTRIES);
cmp(RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, RPC_X_SS_CHAR_TRANS_OPEN_FAIL);
cmp(RPC_NT_SS_CHAR_TRANS_SHORT_FILE, RPC_X_SS_CHAR_TRANS_SHORT_FILE);
cmp(RPC_NT_SS_CONTEXT_MISMATCH, ERROR_INVALID_HANDLE);
cmp(RPC_NT_SS_CONTEXT_DAMAGED, RPC_X_SS_CONTEXT_DAMAGED);
cmp(RPC_NT_SS_HANDLES_MISMATCH, RPC_X_SS_HANDLES_MISMATCH);
cmp(RPC_NT_SS_CANNOT_GET_CALL_HANDLE, RPC_X_SS_CANNOT_GET_CALL_HANDLE);
cmp(RPC_NT_NULL_REF_POINTER, RPC_X_NULL_REF_POINTER);
cmp(RPC_NT_ENUM_VALUE_OUT_OF_RANGE, RPC_X_ENUM_VALUE_OUT_OF_RANGE);
cmp(RPC_NT_BYTE_COUNT_TOO_SMALL, RPC_X_BYTE_COUNT_TOO_SMALL);
cmp(RPC_NT_BAD_STUB_DATA, RPC_X_BAD_STUB_DATA);
cmp(RPC_NT_INVALID_OBJECT, RPC_S_INVALID_OBJECT);
cmp(STATUS_NO_TRUST_LSA_SECRET, ERROR_NO_TRUST_LSA_SECRET);
cmp(STATUS_NO_TRUST_SAM_ACCOUNT, ERROR_NO_TRUST_SAM_ACCOUNT);
cmp(STATUS_TRUSTED_DOMAIN_FAILURE, ERROR_TRUSTED_DOMAIN_FAILURE);
cmp(STATUS_TRUSTED_RELATIONSHIP_FAILURE, ERROR_TRUSTED_RELATIONSHIP_FAILURE);
cmp(STATUS_TRUST_FAILURE, ERROR_TRUST_FAILURE);
cmp(RPC_NT_CALL_IN_PROGRESS, RPC_S_CALL_IN_PROGRESS);
cmp(STATUS_LOG_FILE_FULL, ERROR_LOG_FILE_FULL);
cmp(STATUS_EVENTLOG_FILE_CHANGED, ERROR_EVENTLOG_FILE_CHANGED);
cmp(STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT);
cmp(STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT);
cmp(STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, ERROR_NOLOGON_SERVER_TRUST_ACCOUNT);
cmp(STATUS_DOMAIN_TRUST_INCONSISTENT, ERROR_DOMAIN_TRUST_INCONSISTENT);
cmp(STATUS_NO_USER_SESSION_KEY, ERROR_NO_USER_SESSION_KEY);
cmp(STATUS_POSSIBLE_DEADLOCK, ERROR_POSSIBLE_DEADLOCK);
cmp(STATUS_IMAGE_ALREADY_LOADED, ERROR_SERVICE_ALREADY_RUNNING);
cmp(RPC_NT_GROUP_MEMBER_NOT_FOUND, RPC_S_GROUP_MEMBER_NOT_FOUND);
cmp(RPC_NT_NO_INTERFACES, RPC_S_NO_INTERFACES);
cmp(RPC_NT_CALL_CANCELLED, RPC_S_CALL_CANCELLED);
cmp(RPC_NT_BINDING_INCOMPLETE, RPC_S_BINDING_INCOMPLETE);
cmp(RPC_NT_COMM_FAILURE, RPC_S_COMM_FAILURE);
cmp(RPC_NT_UNSUPPORTED_AUTHN_LEVEL, RPC_S_UNSUPPORTED_AUTHN_LEVEL);
cmp(RPC_NT_NO_PRINC_NAME, RPC_S_NO_PRINC_NAME);
cmp(RPC_NT_NOT_RPC_ERROR, RPC_S_NOT_RPC_ERROR);
cmp(RPC_NT_UUID_LOCAL_ONLY, RPC_S_UUID_LOCAL_ONLY);
cmp(RPC_NT_SEC_PKG_ERROR, RPC_S_SEC_PKG_ERROR);
cmp(RPC_NT_NOT_CANCELLED, RPC_S_NOT_CANCELLED);
cmp(RPC_NT_INVALID_ES_ACTION, RPC_X_INVALID_ES_ACTION);
cmp(RPC_NT_WRONG_ES_VERSION, RPC_X_WRONG_ES_VERSION);
cmp(RPC_NT_WRONG_STUB_VERSION, RPC_X_WRONG_STUB_VERSION);
cmp(RPC_NT_INVALID_PIPE_OBJECT, RPC_X_INVALID_PIPE_OBJECT);
cmp(RPC_NT_INVALID_PIPE_OPERATION, RPC_X_INVALID_PIPE_OPERATION);
cmp(RPC_NT_WRONG_PIPE_VERSION, RPC_X_WRONG_PIPE_VERSION);
cmp(EPT_NT_CANT_CREATE, EPT_S_CANT_CREATE);
cmp(RPC_NT_SEND_INCOMPLETE, RPC_S_SEND_INCOMPLETE);
cmp2(RPC_NT_INVALID_ASYNC_HANDLE, RPC_S_INVALID_ASYNC_HANDLE);
cmp2(RPC_NT_INVALID_ASYNC_CALL, RPC_S_INVALID_ASYNC_CALL);
cmp2(RPC_NT_PIPE_CLOSED, RPC_X_PIPE_CLOSED);
cmp2(RPC_NT_PIPE_EMPTY, RPC_X_PIPE_EMPTY);
cmp2(RPC_NT_PIPE_DISCIPLINE_ERROR, RPC_X_PIPE_DISCIPLINE_ERROR);
cmp(STATUS_NO_BROWSER_SERVERS_FOUND, ERROR_NO_BROWSER_SERVERS_FOUND);
cmp(STATUS_MAPPED_ALIGNMENT, ERROR_MAPPED_ALIGNMENT);
cmp(STATUS_CONNECTION_IN_USE, ERROR_DEVICE_IN_USE);
cmp(STATUS_VERIFY_REQUIRED, ERROR_MEDIA_CHANGED);
cmp(STATUS_ALREADY_DISCONNECTED, ERROR_ACTIVE_CONNECTIONS);
cmp(STATUS_CONNECTION_REFUSED, ERROR_CONNECTION_REFUSED);
cmp(STATUS_GRACEFUL_DISCONNECT, ERROR_GRACEFUL_DISCONNECT);
cmp(STATUS_ADDRESS_ALREADY_ASSOCIATED, ERROR_ADDRESS_ALREADY_ASSOCIATED);
cmp(STATUS_ADDRESS_NOT_ASSOCIATED, ERROR_ADDRESS_NOT_ASSOCIATED);
cmp(STATUS_CONNECTION_INVALID, ERROR_CONNECTION_INVALID);
cmp(STATUS_CONNECTION_ACTIVE, ERROR_CONNECTION_ACTIVE);
cmp(STATUS_NETWORK_UNREACHABLE, ERROR_NETWORK_UNREACHABLE);
cmp(STATUS_HOST_UNREACHABLE, ERROR_HOST_UNREACHABLE);
cmp2(STATUS_HOST_DOWN, ERROR_HOST_DOWN);
cmp(STATUS_PROTOCOL_UNREACHABLE, ERROR_PROTOCOL_UNREACHABLE);
cmp(STATUS_PORT_UNREACHABLE, ERROR_PORT_UNREACHABLE);
cmp(STATUS_REQUEST_ABORTED, ERROR_REQUEST_ABORTED);
cmp(STATUS_CONNECTION_ABORTED, ERROR_CONNECTION_ABORTED);
cmp(STATUS_CONNECTION_COUNT_LIMIT, ERROR_CONNECTION_COUNT_LIMIT);
cmp(STATUS_PATH_NOT_COVERED, ERROR_HOST_UNREACHABLE);
cmp(STATUS_LOGIN_TIME_RESTRICTION, ERROR_LOGIN_TIME_RESTRICTION);
cmp(STATUS_LOGIN_WKSTA_RESTRICTION, ERROR_LOGIN_WKSTA_RESTRICTION);
cmp(STATUS_LICENSE_QUOTA_EXCEEDED, ERROR_LICENSE_QUOTA_EXCEEDED);
cmp(STATUS_RESOURCE_NOT_OWNED, ERROR_NOT_OWNER);
cmp(STATUS_DUPLICATE_OBJECTID, STATUS_DUPLICATE_OBJECTID);
cmp(STATUS_OBJECTID_EXISTS, STATUS_OBJECTID_EXISTS);
cmp2(STATUS_OBJECTID_NOT_FOUND, ERROR_FILE_NOT_FOUND);
cmp2(STATUS_MFT_TOO_FRAGMENTED, ERROR_DISK_TOO_FRAGMENTED);
cmp(SEC_E_INSUFFICIENT_MEMORY, ERROR_NO_SYSTEM_RESOURCES);
cmp(SEC_E_INVALID_HANDLE, ERROR_INVALID_HANDLE);
cmp(SEC_E_UNSUPPORTED_FUNCTION, ERROR_INVALID_FUNCTION);
cmp(SEC_E_TARGET_UNKNOWN, ERROR_BAD_NETPATH);
cmp(SEC_E_INTERNAL_ERROR, ERROR_INTERNAL_ERROR);
cmp(SEC_E_SECPKG_NOT_FOUND, ERROR_NO_SUCH_PACKAGE);
cmp(SEC_E_NOT_OWNER, ERROR_NOT_OWNER);
cmp(SEC_E_CANNOT_INSTALL, ERROR_NO_SUCH_PACKAGE);
cmp(SEC_E_INVALID_TOKEN, ERROR_INVALID_PARAMETER);
cmp(SEC_E_CANNOT_PACK, ERROR_INVALID_PARAMETER);
cmp(SEC_E_QOP_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
cmp(SEC_E_NO_IMPERSONATION, ERROR_CANNOT_IMPERSONATE);
cmp2(SEC_E_MULTIPLE_ACCOUNTS, ERROR_CANNOT_IMPERSONATE);
cmp(SEC_E_LOGON_DENIED, ERROR_LOGON_FAILURE);
cmp(SEC_E_UNKNOWN_CREDENTIALS, ERROR_INVALID_PARAMETER);
cmp2(SEC_E_INCOMPLETE_CREDENTIALS, ERROR_INVALID_PARAMETER);
cmp(SEC_E_NO_CREDENTIALS, ERROR_NO_SUCH_LOGON_SESSION);
cmp(SEC_E_MESSAGE_ALTERED, ERROR_ACCESS_DENIED);
cmp(SEC_E_OUT_OF_SEQUENCE, ERROR_ACCESS_DENIED);
cmp(SEC_E_NO_AUTHENTICATING_AUTHORITY, ERROR_NO_LOGON_SERVERS);
cmp(SEC_E_BAD_PKGID, ERROR_NO_SUCH_PACKAGE);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
cmp4(SEC_E_WRONG_PRINCIPAL, ERROR_WRONG_TARGET_NAME, 1462);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp2(SEC_E_INCOMPLETE_MESSAGE, ERROR_INVALID_USER_BUFFER);
cmp2(SEC_E_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER);
cmp2(SEC_E_UNTRUSTED_ROOT, ERROR_TRUST_FAILURE);
cmp2(SEC_E_ILLEGAL_MESSAGE, ERROR_INVALID_PARAMETER);
cmp2(SEC_E_CERT_UNKNOWN, ERROR_INVALID_PARAMETER);
cmp2(SEC_E_CERT_EXPIRED, ERROR_PASSWORD_EXPIRED);
cmp2(SEC_E_ENCRYPT_FAILURE, ERROR_ENCRYPTION_FAILED);
cmp2(SEC_E_DECRYPT_FAILURE, ERROR_DECRYPTION_FAILED);
cmp2(SEC_E_ALGORITHM_MISMATCH, ERROR_INVALID_FUNCTION);
cmp2(SEC_E_CONTEXT_EXPIRED, ERROR_CONTEXT_EXPIRED);
cmp2(STATUS_BAD_BINDINGS, SEC_E_BAD_BINDINGS);
cmp2(TRUST_E_CERT_SIGNATURE, ERROR_MUTUAL_AUTH_FAILED);
cmp2(CRYPT_E_REVOKED, ERROR_MUTUAL_AUTH_FAILED);
cmp2(CRYPT_E_NO_REVOCATION_CHECK, ERROR_MUTUAL_AUTH_FAILED);
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);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
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);
cmp4(STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED, 1925);
cmp4(STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS, 1926);
cmp4(STATUS_DS_BUSY, ERROR_DS_BUSY, 1927);
cmp4(STATUS_DS_UNAVAILABLE, ERROR_DS_UNAVAILABLE, 1928);
cmp4(STATUS_DS_NO_RIDS_ALLOCATED, ERROR_DS_NO_RIDS_ALLOCATED, 1929);
cmp4(STATUS_DS_NO_MORE_RIDS, ERROR_DS_NO_MORE_RIDS, 1930);
cmp4(STATUS_DS_INCORRECT_ROLE_OWNER, ERROR_DS_INCORRECT_ROLE_OWNER, 1931);
cmp4(STATUS_DS_RIDMGR_INIT_ERROR, ERROR_DS_RIDMGR_INIT_ERROR, 1932);
cmp4(STATUS_DS_OBJ_CLASS_VIOLATION, ERROR_DS_OBJ_CLASS_VIOLATION, 1933);
cmp4(STATUS_DS_CANT_ON_NON_LEAF, ERROR_DS_CANT_ON_NON_LEAF, 1934);
cmp4(STATUS_DS_CANT_ON_RDN, ERROR_DS_CANT_ON_RDN, 1935);
cmp4(STATUS_DS_CROSS_DOM_MOVE_FAILED, ERROR_DS_CROSS_DOM_MOVE_ERROR, 1937);
cmp4(STATUS_DS_GC_NOT_AVAILABLE, ERROR_DS_GC_NOT_AVAILABLE, 1938);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp2(STATUS_DS_CANT_MOD_OBJ_CLASS, ERROR_DS_CANT_MOD_OBJ_CLASS);
cmp2(STATUS_DS_ADMIN_LIMIT_EXCEEDED, ERROR_DS_ADMIN_LIMIT_EXCEEDED);
cmp2(STATUS_DIRECTORY_SERVICE_REQUIRED, ERROR_DS_DS_REQUIRED);
cmp2(STATUS_DS_SAM_INIT_FAILURE, ERROR_DS_SAM_INIT_FAILURE);
cmp2(STATUS_DS_CANT_START, ERROR_DS_CANT_START);
cmp2(STATUS_DS_INIT_FAILURE, ERROR_DS_INIT_FAILURE);
cmp2(STATUS_SAM_INIT_FAILURE, ERROR_SAM_INIT_FAILURE);
cmp2(STATUS_DS_SENSITIVE_GROUP_VIOLATION, ERROR_DS_SENSITIVE_GROUP_VIOLATION);
cmp2(STATUS_DS_CANT_MOD_PRIMARYGROUPID, ERROR_DS_CANT_MOD_PRIMARYGROUPID);
cmp2(STATUS_DS_INVALID_GROUP_TYPE, ERROR_DS_INVALID_GROUP_TYPE);
cmp2(STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN);
cmp2(STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN);
cmp2(STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER);
cmp2(STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER);
cmp2(STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER);
cmp2(STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER);
cmp2(STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER);
cmp2(STATUS_DS_HAVE_PRIMARY_MEMBERS, ERROR_DS_HAVE_PRIMARY_MEMBERS);
cmp2(STATUS_DS_GC_REQUIRED, ERROR_DS_GC_REQUIRED);
cmp2(STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY);
cmp2(STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS);
cmp2(STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED,ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED);
cmp2(STATUS_SAM_NEED_BOOTKEY_PASSWORD, ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD);
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_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_WRONG_CREDENTIAL_HANDLE, SEC_E_WRONG_CREDENTIAL_HANDLE);
cmp2(STATUS_CRYPTO_SYSTEM_INVALID, SEC_E_CRYPTO_SYSTEM_INVALID);
cmp2(STATUS_MAX_REFERRALS_EXCEEDED, SEC_E_MAX_REFERRALS_EXCEEDED);
cmp2(STATUS_MUST_BE_KDC, SEC_E_MUST_BE_KDC);
cmp2(STATUS_STRONG_CRYPTO_NOT_SUPPORTED, SEC_E_STRONG_CRYPTO_NOT_SUPPORTED);
cmp2(STATUS_TOO_MANY_PRINCIPALS, SEC_E_TOO_MANY_PRINCIPALS);
cmp2(STATUS_NO_PA_DATA, SEC_E_NO_PA_DATA);
cmp2(STATUS_PKINIT_NAME_MISMATCH, SEC_E_PKINIT_NAME_MISMATCH);
cmp2(STATUS_SMARTCARD_LOGON_REQUIRED, SEC_E_SMARTCARD_LOGON_REQUIRED);
cmp2(STATUS_KDC_INVALID_REQUEST, SEC_E_KDC_INVALID_REQUEST);
cmp2(STATUS_KDC_UNABLE_TO_REFER, SEC_E_KDC_UNABLE_TO_REFER);
cmp2(STATUS_KDC_UNKNOWN_ETYPE, SEC_E_KDC_UNKNOWN_ETYPE);
cmp2(STATUS_UNSUPPORTED_PREAUTH, SEC_E_UNSUPPORTED_PREAUTH);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
cmp4(STATUS_SHARED_POLICY, ERROR_SHARED_POLICY, 1939);
cmp4(STATUS_POLICY_OBJECT_NOT_FOUND, ERROR_POLICY_OBJECT_NOT_FOUND, 1940);
cmp4(STATUS_POLICY_ONLY_IN_DS, ERROR_POLICY_ONLY_IN_DS, 1941);
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
cmp2(STATUS_DEVICE_REMOVED, ERROR_DEVICE_REMOVED);
cmp2(STATUS_RETRY, ERROR_RETRY);
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_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_ACCESS_DISABLED_BY_POLICY_DEFAULT, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_PATH, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, ERROR_ACCESS_DISABLED_BY_POLICY);
cmp2(STATUS_FAIL_CHECK, ERROR_INVALID_PARAMETER);
cmp2(STATUS_CTX_CLOSE_PENDING, ERROR_CTX_CLOSE_PENDING);
cmp2(STATUS_CTX_NO_OUTBUF, ERROR_CTX_NO_OUTBUF);
cmp2(STATUS_CTX_MODEM_INF_NOT_FOUND, ERROR_CTX_MODEM_INF_NOT_FOUND);
cmp2(STATUS_CTX_INVALID_MODEMNAME, ERROR_CTX_INVALID_MODEMNAME);
cmp2(STATUS_CTX_RESPONSE_ERROR, ERROR_CTX_MODEM_RESPONSE_ERROR);
cmp2(STATUS_CTX_MODEM_RESPONSE_TIMEOUT, ERROR_CTX_MODEM_RESPONSE_TIMEOUT);
cmp2(STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, ERROR_CTX_MODEM_RESPONSE_NO_CARRIER);
cmp2(STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE);
cmp2(STATUS_CTX_MODEM_RESPONSE_BUSY, ERROR_CTX_MODEM_RESPONSE_BUSY);
cmp2(STATUS_CTX_MODEM_RESPONSE_VOICE, ERROR_CTX_MODEM_RESPONSE_VOICE);
cmp2(STATUS_CTX_TD_ERROR, ERROR_CTX_TD_ERROR);
cmp2(STATUS_CTX_WINSTATION_NAME_INVALID, ERROR_CTX_WINSTATION_NAME_INVALID);
cmp2(STATUS_CTX_WINSTATION_NOT_FOUND, ERROR_CTX_WINSTATION_NOT_FOUND);
cmp2(STATUS_CTX_WINSTATION_NAME_COLLISION, ERROR_CTX_WINSTATION_ALREADY_EXISTS);
cmp2(STATUS_CTX_WINSTATION_BUSY, ERROR_CTX_WINSTATION_BUSY);
cmp2(STATUS_CTX_GRAPHICS_INVALID, ERROR_CTX_GRAPHICS_INVALID);
cmp2(STATUS_CTX_BAD_VIDEO_MODE, ERROR_CTX_BAD_VIDEO_MODE);
cmp2(STATUS_CTX_NOT_CONSOLE, ERROR_CTX_NOT_CONSOLE);
cmp2(STATUS_CTX_CLIENT_QUERY_TIMEOUT, ERROR_CTX_CLIENT_QUERY_TIMEOUT);
cmp2(STATUS_CTX_CONSOLE_DISCONNECT, ERROR_CTX_CONSOLE_DISCONNECT);
cmp2(STATUS_CTX_CONSOLE_CONNECT, ERROR_CTX_CONSOLE_CONNECT);
cmp2(STATUS_CTX_SHADOW_DENIED, ERROR_CTX_SHADOW_DENIED);
cmp2(STATUS_CTX_SHADOW_INVALID, ERROR_CTX_SHADOW_INVALID);
cmp2(STATUS_CTX_SHADOW_DISABLED, ERROR_CTX_SHADOW_DISABLED);
cmp2(STATUS_CTX_WINSTATION_ACCESS_DENIED, ERROR_CTX_WINSTATION_ACCESS_DENIED);
cmp2(STATUS_CTX_INVALID_PD, ERROR_CTX_INVALID_PD);
cmp2(STATUS_CTX_PD_NOT_FOUND, ERROR_CTX_PD_NOT_FOUND);
cmp2(STATUS_CTX_INVALID_WD, ERROR_CTX_INVALID_WD);
cmp2(STATUS_CTX_WD_NOT_FOUND, ERROR_CTX_WD_NOT_FOUND);
cmp2(STATUS_CTX_CLIENT_LICENSE_IN_USE, ERROR_CTX_CLIENT_LICENSE_IN_USE);
cmp2(STATUS_CTX_CLIENT_LICENSE_NOT_SET, ERROR_CTX_CLIENT_LICENSE_NOT_SET);
cmp2(STATUS_CTX_LICENSE_NOT_AVAILABLE, ERROR_CTX_LICENSE_NOT_AVAILABLE);
cmp2(STATUS_CTX_LICENSE_CLIENT_INVALID, ERROR_CTX_LICENSE_CLIENT_INVALID);
cmp2(STATUS_CTX_LICENSE_EXPIRED, ERROR_CTX_LICENSE_EXPIRED);
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);
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
#if 0
/* FIXME - unknown STATUS values, see bug 1001 */
cmp(STATUS_ENDPOINT_CLOSED, ERROR_DEV_NOT_EXIST);
cmp(STATUS_DISCONNECTED, ERROR_DEV_NOT_EXIST);
cmp(STATUS_NONEXISTENT_NET_NAME, ERROR_DEV_NOT_EXIST);
#endif
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
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_CANT_GEN_ACTCTX, ERROR_SXS_CANT_GEN_ACTCTX);
cmp2(STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, ERROR_SXS_INVALID_ACTCTXDATA_FORMAT);
cmp2(STATUS_SXS_ASSEMBLY_NOT_FOUND, ERROR_SXS_ASSEMBLY_NOT_FOUND);
cmp2(STATUS_SXS_MANIFEST_FORMAT_ERROR, ERROR_SXS_MANIFEST_FORMAT_ERROR);
cmp2(STATUS_SXS_MANIFEST_PARSE_ERROR, ERROR_SXS_MANIFEST_PARSE_ERROR);
cmp2(STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, ERROR_SXS_ACTIVATION_CONTEXT_DISABLED);
cmp2(STATUS_SXS_KEY_NOT_FOUND, ERROR_SXS_KEY_NOT_FOUND);
cmp2(STATUS_SXS_WRONG_SECTION_TYPE, ERROR_SXS_WRONG_SECTION_TYPE);
cmp2(STATUS_SXS_THREAD_QUERIES_DISABLED, ERROR_SXS_THREAD_QUERIES_DISABLED);
cmp2(STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET);
cmp2(STATUS_REDIRECTOR_STARTED, ERROR_SERVICE_ALREADY_RUNNING);
cmp2(STATUS_AUDITING_DISABLED, ERROR_AUDITING_DISABLED);
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);
cmp2(STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE);
cmp2(STATUS_CLUSTER_NODE_ALREADY_MEMBER, ERROR_CLUSTER_NODE_ALREADY_MEMBER);
cmp2(STATUS_CLUSTER_INVALID_NODE, ERROR_CLUSTER_INVALID_NODE);
cmp2(STATUS_CLUSTER_NODE_EXISTS, ERROR_CLUSTER_NODE_EXISTS);
cmp2(STATUS_CLUSTER_JOIN_IN_PROGRESS, ERROR_CLUSTER_JOIN_IN_PROGRESS);
cmp2(STATUS_CLUSTER_NODE_NOT_FOUND, ERROR_CLUSTER_NODE_NOT_FOUND);
cmp2(STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND);
cmp2(STATUS_CLUSTER_NETWORK_EXISTS, ERROR_CLUSTER_NETWORK_EXISTS);
cmp2(STATUS_CLUSTER_NETWORK_NOT_FOUND, ERROR_CLUSTER_NETWORK_NOT_FOUND);
cmp2(STATUS_CLUSTER_NETINTERFACE_EXISTS, ERROR_CLUSTER_NETINTERFACE_EXISTS);
cmp2(STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, ERROR_CLUSTER_NETINTERFACE_NOT_FOUND);
cmp2(STATUS_CLUSTER_INVALID_REQUEST, ERROR_CLUSTER_INVALID_REQUEST);
cmp2(STATUS_CLUSTER_INVALID_NETWORK_PROVIDER,ERROR_CLUSTER_INVALID_NETWORK_PROVIDER);
cmp2(STATUS_CLUSTER_NODE_DOWN, ERROR_CLUSTER_NODE_DOWN);
cmp2(STATUS_CLUSTER_NODE_UNREACHABLE, ERROR_CLUSTER_NODE_UNREACHABLE);
cmp2(STATUS_CLUSTER_NODE_NOT_MEMBER, ERROR_CLUSTER_NODE_NOT_MEMBER);
cmp2(STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS);
cmp2(STATUS_CLUSTER_INVALID_NETWORK, ERROR_CLUSTER_INVALID_NETWORK);
cmp2(STATUS_CLUSTER_NODE_UP, ERROR_CLUSTER_NODE_UP);
cmp2(STATUS_CLUSTER_NODE_PAUSED, ERROR_CLUSTER_NODE_PAUSED);
cmp2(STATUS_CLUSTER_NODE_NOT_PAUSED, ERROR_CLUSTER_NODE_NOT_PAUSED);
cmp2(STATUS_CLUSTER_NO_SECURITY_CONTEXT, ERROR_CLUSTER_NO_SECURITY_CONTEXT);
cmp2(STATUS_CLUSTER_NETWORK_NOT_INTERNAL, ERROR_CLUSTER_NETWORK_NOT_INTERNAL);
}
START_TEST(error)
{
Fix mapping of STATUS_DEVICE_NOT_CONNECTED to match XP. Fixed the prototype of statustodoserror to make the test work on NT4. Added alternate return values to make the test work on Win98. Check whether RtlNtStatusToDosError ismissing to make the test work on Win95. Added a strict option to cause the test to only accept the standard mapping.
2003-01-02 17:50:48 +00:00
if (prepare_test())
RtlNtStatusToDosError: Added new NT status to error codes mapping, added missed definitions of the used constants, created unit test for subset of the mappings.
2002-09-09 19:25:29 +00:00
run_error_tests();
}
Reference in New Issue Copy Permalink