ReactOS  0.4.15-dev-1197-g8081ba9
info.c File Reference
#include "ntdll_test.h"
#include <winnls.h>
#include <stdio.h>
Include dependency graph for info.c:

Go to the source code of this file.

Macros

#define NTDLL_GET_PROC(func)
 

Functions

static NTSTATUS (WINAPI *pRtlDowncaseUnicodeString)(UNICODE_STRING *
 
static ULONG (WINAPI *pNtGetCurrentProcessorNumber)(void)
 
static BOOL (WINAPI *pIsWow64Process)(HANDLE
 
static BOOL InitFunctionPtrs (void)
 
static void test_query_basic (void)
 
static void test_query_cpu (void)
 
static void test_query_performance (void)
 
static void test_query_timeofday (void)
 
static void test_query_process (void)
 
static void test_query_procperf (void)
 
static void test_query_module (void)
 
static void test_query_handle (void)
 
static void test_query_handle_ex (void)
 
static void test_query_cache (void)
 
static void test_query_interrupt (void)
 
static void test_query_kerndebug (void)
 
static void test_query_regquota (void)
 
static void test_query_logicalproc (void)
 
static void test_query_logicalprocex (void)
 
static void test_query_processor_power_info (void)
 
static void test_query_process_wow64 (void)
 
static void test_query_process_basic (void)
 
static void dump_vm_counters (const char *header, const VM_COUNTERS *pvi)
 
static void test_query_process_vm (void)
 
static void test_query_process_io (void)
 
static void test_query_process_times (void)
 
static void test_query_process_debug_port (int argc, char **argv)
 
static void test_query_process_priority (void)
 
static void test_query_process_handlecount (void)
 
static void test_query_process_image_file_name (void)
 
static void test_query_process_debug_object_handle (int argc, char **argv)
 
static void test_query_process_debug_flags (int argc, char **argv)
 
static void test_readvirtualmemory (void)
 
static void test_mapprotection (void)
 
static void test_queryvirtualmemory (void)
 
static void test_affinity (void)
 
static void test_NtGetCurrentProcessorNumber (void)
 
static DWORD WINAPI start_address_thread (void *arg)
 
static void test_thread_start_address (void)
 
static void test_query_data_alignment (void)
 
 START_TEST (info)
 

Variables

static const UNICODE_STRING BOOLEAN
 
static PVOID
 
static ULONG
 
static PULONG
 
static PROCESSINFOCLASS
 
static THREADINFOCLASS
 
static const void void SIZE_T
 
static const void void SIZE_T *static LPCVOID
 
static const void void SIZE_T *static MEMORY_INFORMATION_CLASS
 
static const void void SIZE_T *static SIZE_T *static ACCESS_MASK
 
static const void void SIZE_T *static SIZE_T *static const OBJECT_ATTRIBUTES const LARGE_INTEGER HANDLE
 
static PVOID const LARGE_INTEGER SIZE_T SECTION_INHERIT
 
static PBOOL
 
static SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX DWORD *static BOOL is_wow64
 
static DWORD one_before_last_pid = 0
 

Macro Definition Documentation

◆ NTDLL_GET_PROC

#define NTDLL_GET_PROC (   func)
Value:
do { \
p ## func = (void*)GetProcAddress(hntdll, #func); \
if(!p ## func) { \
trace("GetProcAddress(%s) failed\n", #func); \
return FALSE; \
} \
} while(0)
GLenum func
Definition: glext.h:6028
#define FALSE
Definition: types.h:117
static HINSTANCE hntdll
Definition: process.c:66
#define GetProcAddress(x, y)
Definition: compat.h:501
GLfloat GLfloat p
Definition: glext.h:8902

Definition at line 50 of file info.c.

Function Documentation

◆ BOOL()

static BOOL ( WINAPI pIsWow64Process)
static

◆ dump_vm_counters()

static void dump_vm_counters ( const char header,
const VM_COUNTERS pvi 
)
static

Definition at line 1111 of file info.c.

1112 {
1113  trace("%s:\n", header);
1114  trace("PeakVirtualSize : %lu\n", pvi->PeakVirtualSize);
1115  trace("VirtualSize : %lu\n", pvi->VirtualSize);
1116  trace("PageFaultCount : %u\n", pvi->PageFaultCount);
1117  trace("PeakWorkingSetSize : %lu\n", pvi->PeakWorkingSetSize);
1118  trace("WorkingSetSize : %lu\n", pvi->WorkingSetSize);
1119  trace("QuotaPeakPagedPoolUsage : %lu\n", pvi->QuotaPeakPagedPoolUsage);
1120  trace("QuotaPagedPoolUsage : %lu\n", pvi->QuotaPagedPoolUsage);
1121  trace("QuotaPeakNonPagePoolUsage : %lu\n", pvi->QuotaPeakNonPagedPoolUsage);
1122  trace("QuotaNonPagePoolUsage : %lu\n", pvi->QuotaNonPagedPoolUsage);
1123  trace("PagefileUsage : %lu\n", pvi->PagefileUsage);
1124  trace("PeakPagefileUsage : %lu\n", pvi->PeakPagefileUsage);
1125 }
SIZE_T PeakVirtualSize
Definition: winternl.h:1605
SIZE_T PeakPagefileUsage
Definition: winternl.h:1615
SIZE_T QuotaPagedPoolUsage
Definition: winternl.h:1611
SIZE_T PagefileUsage
Definition: winternl.h:1614
SIZE_T QuotaPeakPagedPoolUsage
Definition: winternl.h:1610
SIZE_T VirtualSize
Definition: winternl.h:1606
SIZE_T QuotaPeakNonPagedPoolUsage
Definition: winternl.h:1612
ULONG PageFaultCount
Definition: winternl.h:1607
SIZE_T QuotaNonPagedPoolUsage
Definition: winternl.h:1613
#define trace
Definition: atltest.h:70
SIZE_T WorkingSetSize
Definition: winternl.h:1609
SIZE_T PeakWorkingSetSize
Definition: winternl.h:1608

Referenced by test_query_process_vm().

◆ InitFunctionPtrs()

static BOOL InitFunctionPtrs ( void  )
static

Definition at line 58 of file info.c.

59 {
60  /* All needed functions are NT based, so using GetModuleHandle is a good check */
61  HMODULE hntdll = GetModuleHandleA("ntdll");
62  HMODULE hkernel32 = GetModuleHandleA("kernel32");
63 
64  if (!hntdll)
65  {
66  win_skip("Not running on NT\n");
67  return FALSE;
68  }
69 
83 
84  /* not present before XP */
85  pNtGetCurrentProcessorNumber = (void *) GetProcAddress(hntdll, "NtGetCurrentProcessorNumber");
86 
87  pIsWow64Process = (void *)GetProcAddress(hkernel32, "IsWow64Process");
88  if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE;
89 
90  /* starting with Win7 */
91  pNtQuerySystemInformationEx = (void *) GetProcAddress(hntdll, "NtQuerySystemInformationEx");
92  if (!pNtQuerySystemInformationEx)
93  win_skip("NtQuerySystemInformationEx() is not supported, some tests will be skipped.\n");
94 
95  pGetLogicalProcessorInformationEx = (void *) GetProcAddress(hkernel32, "GetLogicalProcessorInformationEx");
96 
97  return TRUE;
98 }
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3782
NTSYSAPI NTSTATUS NTAPI NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3373
#define TRUE
Definition: types.h:120
NTSTATUS NTAPI NtQueryInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, OUT PVOID ProcessInformation, IN ULONG ProcessInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:59
static HINSTANCE hkernel32
Definition: process.c:66
NTSTATUS NTAPI NtQueryVirtualMemory(IN HANDLE ProcessHandle, IN PVOID BaseAddress, IN MEMORY_INFORMATION_CLASS MemoryInformationClass, OUT PVOID MemoryInformation, IN SIZE_T MemoryInformationLength, OUT PSIZE_T ReturnLength)
Definition: virtual.c:4284
NTSYSAPI NTSTATUS WINAPI RtlDowncaseUnicodeString(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN)
#define FALSE
Definition: types.h:117
NTSTATUS NTAPI NtMapViewOfSection(IN HANDLE SectionHandle, IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3554
NTSTATUS NTAPI NtSetInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, IN PVOID ThreadInformation, IN ULONG ThreadInformationLength)
Definition: query.c:2018
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2501
NTSTATUS NTAPI NtReadVirtualMemory(IN HANDLE ProcessHandle, IN PVOID BaseAddress, OUT PVOID Buffer, IN SIZE_T NumberOfBytesToRead, OUT PSIZE_T NumberOfBytesRead OPTIONAL)
Definition: virtual.c:2691
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
#define GetCurrentProcess()
Definition: compat.h:507
static SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX DWORD *static BOOL is_wow64
Definition: info.c:41
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength)
Definition: query.c:1107
NTSTATUS NTAPI NtPowerInformation(IN POWER_INFORMATION_LEVEL PowerInformationLevel, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength)
Definition: power.c:771
static HINSTANCE hntdll
Definition: process.c:66
#define GetProcAddress(x, y)
Definition: compat.h:501
#define NTDLL_GET_PROC(func)
Definition: info.c:50
#define win_skip
Definition: test.h:149

Referenced by START_TEST().

◆ NTSTATUS()

static NTSTATUS ( WINAPI pRtlDowncaseUnicodeString)
static

◆ start_address_thread()

static DWORD WINAPI start_address_thread ( void arg)
static

Definition at line 2176 of file info.c.

2177 {
2179  NTSTATUS status;
2180  DWORD ret;
2181 
2182  entry = NULL;
2183  ret = 0xdeadbeef;
2184  status = pNtQueryInformationThread(GetCurrentThread(), ThreadQuerySetWin32StartAddress,
2185  &entry, sizeof(entry), &ret);
2186  ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
2187  ok(ret == sizeof(entry), "NtQueryInformationThread returned %u bytes\n", ret);
2188  ok(entry == (void *)start_address_thread, "expected %p, got %p\n", start_address_thread, entry);
2189  return 0;
2190 }
static DWORD WINAPI start_address_thread(void *arg)
Definition: info.c:2176
LONG NTSTATUS
Definition: precomp.h:26
HANDLE WINAPI GetCurrentThread(VOID)
Definition: proc.c:1148
smooth NULL
Definition: ftsmooth.c:416
void(CALLBACK * PRTL_THREAD_START_ROUTINE)(LPVOID)
Definition: winternl.h:1892
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
uint32_t entry
Definition: isohybrid.c:63
#define ok(value,...)
Definition: atltest.h:57
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by test_thread_start_address().

◆ START_TEST()

START_TEST ( info  )

Definition at line 2252 of file info.c.

2253 {
2254  char **argv;
2255  int argc;
2256 
2258  if (argc >= 3) return; /* Child */
2259 
2260  if (!InitFunctionPtrs())
2261  return;
2262 
2263  /* NtQuerySystemInformation */
2264 
2265  /* 0x0 SystemBasicInformation */
2266  trace("Starting test_query_basic()\n");
2267  test_query_basic();
2268 
2269  /* 0x1 SystemCpuInformation */
2270  trace("Starting test_query_cpu()\n");
2271  test_query_cpu();
2272 
2273  /* 0x2 SystemPerformanceInformation */
2274  trace("Starting test_query_performance()\n");
2276 
2277  /* 0x3 SystemTimeOfDayInformation */
2278  trace("Starting test_query_timeofday()\n");
2280 
2281  /* 0x5 SystemProcessInformation */
2282  trace("Starting test_query_process()\n");
2284 
2285  /* 0x8 SystemProcessorPerformanceInformation */
2286  trace("Starting test_query_procperf()\n");
2288 
2289  /* 0xb SystemModuleInformation */
2290  trace("Starting test_query_module()\n");
2292 
2293  /* 0x10 SystemHandleInformation */
2294  trace("Starting test_query_handle()\n");
2296 
2297  /* 0x40 SystemHandleInformation */
2298  trace("Starting test_query_handle_ex()\n");
2300 
2301  /* 0x15 SystemCacheInformation */
2302  trace("Starting test_query_cache()\n");
2303  test_query_cache();
2304 
2305  /* 0x17 SystemInterruptInformation */
2306  trace("Starting test_query_interrupt()\n");
2308 
2309  /* 0x23 SystemKernelDebuggerInformation */
2310  trace("Starting test_query_kerndebug()\n");
2312 
2313  /* 0x25 SystemRegistryQuotaInformation */
2314  trace("Starting test_query_regquota()\n");
2316 
2317  /* 0x49 SystemLogicalProcessorInformation */
2318  trace("Starting test_query_logicalproc()\n");
2321 
2322  /* NtPowerInformation */
2323 
2324  /* 0xb ProcessorInformation */
2325  trace("Starting test_query_processor_power_info()\n");
2327 
2328  /* NtQueryInformationProcess */
2329 
2330  /* 0x0 ProcessBasicInformation */
2331  trace("Starting test_query_process_basic()\n");
2333 
2334  /* 0x2 ProcessIoCounters */
2335  trace("Starting test_query_process_io()\n");
2337 
2338  /* 0x3 ProcessVmCounters */
2339  trace("Starting test_query_process_vm()\n");
2341 
2342  /* 0x4 ProcessTimes */
2343  trace("Starting test_query_process_times()\n");
2345 
2346  /* 0x7 ProcessDebugPort */
2347  trace("Starting test_process_debug_port()\n");
2349 
2350  /* 0x12 ProcessPriorityClass */
2351  trace("Starting test_query_process_priority()\n");
2353 
2354  /* 0x14 ProcessHandleCount */
2355  trace("Starting test_query_process_handlecount()\n");
2357 
2358  /* 0x1A ProcessWow64Information */
2359  trace("Starting test_query_process_wow64()\n");
2361 
2362  /* 0x1B ProcessImageFileName */
2363  trace("Starting test_query_process_image_file_name()\n");
2365 
2366  /* 0x1E ProcessDebugObjectHandle */
2367  trace("Starting test_query_process_debug_object_handle()\n");
2369 
2370  /* 0x1F ProcessDebugFlags */
2371  trace("Starting test_process_debug_flags()\n");
2373 
2374  /* belongs to its own file */
2375  trace("Starting test_readvirtualmemory()\n");
2377 
2378  trace("Starting test_queryvirtualmemory()\n");
2380 
2381  trace("Starting test_mapprotection()\n");
2383 
2384  trace("Starting test_affinity()\n");
2385  test_affinity();
2386 
2387  trace("Starting test_NtGetCurrentProcessorNumber()\n");
2389 
2390  trace("Starting test_thread_start_address()\n");
2392 
2393  trace("Starting test_query_data_alignment()\n");
2395 }
static void test_query_interrupt(void)
Definition: info.c:675
static void test_queryvirtualmemory(void)
Definition: info.c:1888
static int argc
Definition: ServiceArgs.c:12
static void test_readvirtualmemory(void)
Definition: info.c:1767
static void test_NtGetCurrentProcessorNumber(void)
Definition: info.c:2120
static void test_query_timeofday(void)
Definition: info.c:191
static void test_query_process_debug_object_handle(int argc, char **argv)
Definition: info.c:1516
static void test_query_process_handlecount(void)
Definition: info.c:1433
static void test_thread_start_address(void)
Definition: info.c:2192
static void test_query_handle(void)
Definition: info.c:490
#define argv
Definition: mplay32.c:18
static void test_query_logicalprocex(void)
Definition: info.c:787
static void test_query_process_wow64(void)
Definition: info.c:964
static void test_query_procperf(void)
Definition: info.c:388
static void test_query_data_alignment(void)
Definition: info.c:2239
static void test_query_logicalproc(void)
Definition: info.c:740
static void test_query_cache(void)
Definition: info.c:624
static void test_query_process_vm(void)
Definition: info.c:1127
static void test_query_process_basic(void)
Definition: info.c:1042
#define trace
Definition: atltest.h:70
static void test_affinity(void)
Definition: info.c:2028
static BOOL InitFunctionPtrs(void)
Definition: info.c:58
static void test_query_process_debug_flags(int argc, char **argv)
Definition: info.c:1613
static void test_query_process_debug_port(int argc, char **argv)
Definition: info.c:1327
int winetest_get_mainargs(char ***pargv)
static void test_query_basic(void)
Definition: info.c:100
static void test_query_processor_power_info(void)
Definition: info.c:891
static void test_query_process_io(void)
Definition: info.c:1230
static void test_query_performance(void)
Definition: info.c:163
static void test_query_kerndebug(void)
Definition: info.c:704
static void test_query_cpu(void)
Definition: info.c:148
static void test_mapprotection(void)
Definition: info.c:1818
static void test_query_process(void)
Definition: info.c:270
static void test_query_regquota(void)
Definition: info.c:722
static void test_query_handle_ex(void)
Definition: info.c:568
static void test_query_process_times(void)
Definition: info.c:1270
static void test_query_process_image_file_name(void)
Definition: info.c:1479
static void test_query_module(void)
Definition: info.c:455
static void test_query_process_priority(void)
Definition: info.c:1399

◆ test_affinity()

static void test_affinity ( void  )
static

Definition at line 2028 of file info.c.

2029 {
2030  NTSTATUS status;
2032  DWORD_PTR proc_affinity, thread_affinity;
2034  SYSTEM_INFO si;
2035 
2036  GetSystemInfo(&si);
2037  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL );
2038  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2039  proc_affinity = pbi.AffinityMask;
2040  ok( proc_affinity == (1 << si.dwNumberOfProcessors) - 1, "Unexpected process affinity\n" );
2041  proc_affinity = 1 << si.dwNumberOfProcessors;
2042  status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
2044  "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
2045 
2046  proc_affinity = 0;
2047  status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
2049  "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
2050 
2051  status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
2052  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2053  ok( tbi.AffinityMask == (1 << si.dwNumberOfProcessors) - 1, "Unexpected thread affinity\n" );
2054  thread_affinity = 1 << si.dwNumberOfProcessors;
2055  status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
2057  "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
2058  thread_affinity = 0;
2059  status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
2061  "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
2062 
2063  thread_affinity = 1;
2064  status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
2065  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2066  status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
2067  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2068  ok( tbi.AffinityMask == 1, "Unexpected thread affinity\n" );
2069 
2070  /* NOTE: Pre-Vista does not recognize the "all processors" flag (all bits set) */
2071  thread_affinity = ~(DWORD_PTR)0;
2072  status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
2074  "Expected STATUS_SUCCESS, got %08x\n", status);
2075 
2076  if (si.dwNumberOfProcessors <= 1)
2077  {
2078  skip("only one processor, skipping affinity testing\n");
2079  return;
2080  }
2081 
2082  /* Test thread affinity mask resulting from "all processors" flag */
2083  if (status == STATUS_SUCCESS)
2084  {
2085  status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
2086  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2087  ok( broken(tbi.AffinityMask == 1) || tbi.AffinityMask == (1 << si.dwNumberOfProcessors) - 1,
2088  "Unexpected thread affinity\n" );
2089  }
2090  else
2091  skip("Cannot test thread affinity mask for 'all processors' flag\n");
2092 
2093  proc_affinity = 2;
2094  status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
2095  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2096  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL );
2097  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2098  proc_affinity = pbi.AffinityMask;
2099  ok( proc_affinity == 2, "Unexpected process affinity\n" );
2100  /* Setting the process affinity changes the thread affinity to match */
2101  status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
2102  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2103  ok( tbi.AffinityMask == 2, "Unexpected thread affinity\n" );
2104  /* The thread affinity is restricted to the process affinity */
2105  thread_affinity = 1;
2106  status = pNtSetInformationThread( GetCurrentThread(), ThreadAffinityMask, &thread_affinity, sizeof(thread_affinity) );
2108  "Expected STATUS_INVALID_PARAMETER, got %08x\n", status);
2109 
2110  proc_affinity = (1 << si.dwNumberOfProcessors) - 1;
2111  status = pNtSetInformationProcess( GetCurrentProcess(), ProcessAffinityMask, &proc_affinity, sizeof(proc_affinity) );
2112  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2113  /* Resetting the process affinity also resets the thread affinity */
2114  status = pNtQueryInformationThread( GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL );
2115  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2116  ok( tbi.AffinityMask == (1 << si.dwNumberOfProcessors) - 1,
2117  "Unexpected thread affinity\n" );
2118 }
KAFFINITY AffinityMask
Definition: compat.h:678
#define DWORD_PTR
Definition: treelist.c:76
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
HANDLE WINAPI GetCurrentThread(VOID)
Definition: proc.c:1148
smooth NULL
Definition: ftsmooth.c:416
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917
#define GetCurrentProcess()
Definition: compat.h:507
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define broken(x)
Definition: _sntprintf.h:21
#define ok(value,...)
Definition: atltest.h:57
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:142
#define skip(...)
Definition: atltest.h:64
DWORD dwNumberOfProcessors
Definition: winbase.h:1143
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_mapprotection()

static void test_mapprotection ( void  )
static

Definition at line 1818 of file info.c.

1819 {
1820  HANDLE h;
1821  void* addr;
1823  ULONG oldflags, flagsize, flags = MEM_EXECUTE_OPTION_ENABLE;
1825  NTSTATUS status;
1826  SIZE_T retlen, count;
1827  void (*f)(void);
1828 
1829  if (!pNtClose) {
1830  skip("No NtClose ... Win98\n");
1831  return;
1832  }
1833  /* Switch to being a noexec unaware process */
1834  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &oldflags, sizeof (oldflags), &flagsize);
1836  skip("Invalid Parameter on ProcessExecuteFlags query?\n");
1837  return;
1838  }
1839  ok( (status == STATUS_SUCCESS) || (status == STATUS_INVALID_INFO_CLASS), "Expected STATUS_SUCCESS, got %08x\n", status);
1840  status = pNtSetInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &flags, sizeof(flags) );
1841  ok( (status == STATUS_SUCCESS) || (status == STATUS_INVALID_INFO_CLASS), "Expected STATUS_SUCCESS, got %08x\n", status);
1842 
1843  size.u.LowPart = 0x2000;
1844  size.u.HighPart = 0;
1845  status = pNtCreateSection ( &h,
1847  NULL,
1848  &size,
1851  0
1852  );
1853  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1854 
1855  offset.u.LowPart = 0;
1856  offset.u.HighPart = 0;
1857  count = 0x2000;
1858  addr = NULL;
1859  status = pNtMapViewOfSection ( h, GetCurrentProcess(), &addr, 0, 0, &offset, &count, ViewShare, 0, PAGE_READWRITE);
1860  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1861 
1862 #if defined(__x86_64__) || defined(__i386__)
1863  *(unsigned char*)addr = 0xc3; /* lret ... in both i386 and x86_64 */
1864 #elif defined(__arm__)
1865  *(unsigned long*)addr = 0xe12fff1e; /* bx lr */
1866 #elif defined(__aarch64__)
1867  *(unsigned long*)addr = 0xd65f03c0; /* ret */
1868 #else
1869  ok(0, "Add a return opcode for your architecture or expect a crash in this test\n");
1870 #endif
1871  trace("trying to execute code in the readwrite only mapped anon file...\n");
1872  f = addr;f();
1873  trace("...done.\n");
1874 
1875  status = pNtQueryVirtualMemory( GetCurrentProcess(), addr, MemoryBasicInformation, &info, sizeof(info), &retlen );
1876  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1877  ok( retlen == sizeof(info), "Expected STATUS_SUCCESS, got %08x\n", status);
1878  ok((info.Protect & ~PAGE_NOCACHE) == PAGE_READWRITE, "addr.Protect is not PAGE_READWRITE, but 0x%x\n", info.Protect);
1879 
1880  status = pNtUnmapViewOfSection( GetCurrentProcess(), (char *)addr + 0x1050 );
1881  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1882  pNtClose (h);
1883 
1884  /* Switch back */
1885  pNtSetInformationProcess( GetCurrentProcess(), ProcessExecuteFlags, &oldflags, sizeof(oldflags) );
1886 }
#define PAGE_NOCACHE
Definition: nt_native.h:1311
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define SECTION_QUERY
Definition: nt_native.h:1287
LONG NTSTATUS
Definition: precomp.h:26
GLintptr offset
Definition: glext.h:5920
#define SEC_NOCACHE
Definition: mmtypes.h:100
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
struct _test_info info[]
Definition: SetCursorPos.c:19
#define SEC_COMMIT
Definition: mmtypes.h:99
smooth NULL
Definition: ftsmooth.c:416
#define SECTION_MAP_WRITE
Definition: nt_native.h:1288
#define MEM_EXECUTE_OPTION_ENABLE
Definition: mmtypes.h:74
GLfloat f
Definition: glext.h:7540
GLsizeiptr size
Definition: glext.h:5919
#define trace
Definition: atltest.h:70
GLbitfield flags
Definition: glext.h:7161
GLenum const GLvoid * addr
Definition: glext.h:9621
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define SECTION_MAP_READ
Definition: compat.h:139
#define GetCurrentProcess()
Definition: compat.h:507
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define f
Definition: ke_i.h:83
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define STANDARD_RIGHTS_REQUIRED
Definition: nt_native.h:63
unsigned int ULONG
Definition: retypes.h:1
#define SECTION_MAP_EXECUTE
Definition: nt_native.h:1290
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define PAGE_READWRITE
Definition: nt_native.h:1304
Definition: ps.c:97

Referenced by START_TEST().

◆ test_NtGetCurrentProcessorNumber()

static void test_NtGetCurrentProcessorNumber ( void  )
static

Definition at line 2120 of file info.c.

2121 {
2122  NTSTATUS status;
2123  SYSTEM_INFO si;
2126  DWORD_PTR old_process_mask;
2127  DWORD_PTR old_thread_mask;
2128  DWORD_PTR new_mask;
2129  ULONG current_cpu;
2130  ULONG i;
2131 
2132  if (!pNtGetCurrentProcessorNumber) {
2133  win_skip("NtGetCurrentProcessorNumber not available\n");
2134  return;
2135  }
2136 
2137  GetSystemInfo(&si);
2138  current_cpu = pNtGetCurrentProcessorNumber();
2139  trace("dwNumberOfProcessors: %d, current processor: %d\n", si.dwNumberOfProcessors, current_cpu);
2140 
2141  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
2142  old_process_mask = pbi.AffinityMask;
2143  ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
2144 
2145  status = pNtQueryInformationThread(GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL);
2146  old_thread_mask = tbi.AffinityMask;
2147  ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
2148 
2149  /* allow the test to run on all processors */
2150  new_mask = (1 << si.dwNumberOfProcessors) - 1;
2151  status = pNtSetInformationProcess(GetCurrentProcess(), ProcessAffinityMask, &new_mask, sizeof(new_mask));
2152  ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
2153 
2154  for (i = 0; i < si.dwNumberOfProcessors; i++)
2155  {
2156  new_mask = 1 << i;
2157  status = pNtSetInformationThread(GetCurrentThread(), ThreadAffinityMask, &new_mask, sizeof(new_mask));
2158  ok(status == STATUS_SUCCESS, "%d: got 0x%x (expected STATUS_SUCCESS)\n", i, status);
2159 
2160  status = pNtQueryInformationThread(GetCurrentThread(), ThreadBasicInformation, &tbi, sizeof(tbi), NULL);
2161  ok(status == STATUS_SUCCESS, "%d: got 0x%x (expected STATUS_SUCCESS)\n", i, status);
2162 
2163  current_cpu = pNtGetCurrentProcessorNumber();
2164  ok((current_cpu == i), "%d (new_mask 0x%lx): running on processor %d (AffinityMask: 0x%lx)\n",
2165  i, new_mask, current_cpu, tbi.AffinityMask);
2166  }
2167 
2168  /* restore old values */
2169  status = pNtSetInformationProcess(GetCurrentProcess(), ProcessAffinityMask, &old_process_mask, sizeof(old_process_mask));
2170  ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
2171 
2172  status = pNtSetInformationThread(GetCurrentThread(), ThreadAffinityMask, &old_thread_mask, sizeof(old_thread_mask));
2173  ok(status == STATUS_SUCCESS, "got 0x%x (expected STATUS_SUCCESS)\n", status);
2174 }
KAFFINITY AffinityMask
Definition: compat.h:678
LONG NTSTATUS
Definition: precomp.h:26
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
HANDLE WINAPI GetCurrentThread(VOID)
Definition: proc.c:1148
smooth NULL
Definition: ftsmooth.c:416
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917
#define trace
Definition: atltest.h:70
#define GetCurrentProcess()
Definition: compat.h:507
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define ok(value,...)
Definition: atltest.h:57
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:142
DWORD dwNumberOfProcessors
Definition: winbase.h:1143
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_basic()

static void test_query_basic ( void  )
static

Definition at line 100 of file info.c.

101 {
105 
106  /* This test also covers some basic parameter testing that should be the same for
107  * every information class
108  */
109 
110  /* Use a nonexistent info class */
111  trace("Check nonexistent info class\n");
112  status = pNtQuerySystemInformation(-1, NULL, 0, NULL);
114  "Expected STATUS_INVALID_INFO_CLASS or STATUS_NOT_IMPLEMENTED, got %08x\n", status);
115 
116  /* Use an existing class but with a zero-length buffer */
117  trace("Check zero-length buffer\n");
118  status = pNtQuerySystemInformation(SystemBasicInformation, NULL, 0, NULL);
119  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
120 
121  /* Use an existing class, correct length but no SystemInformation buffer */
122  trace("Check no SystemInformation buffer\n");
123  status = pNtQuerySystemInformation(SystemBasicInformation, NULL, sizeof(sbi), NULL);
125  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER, got %08x\n", status);
126 
127  /* Use an existing class, correct length, a pointer to a buffer but no ReturnLength pointer */
128  trace("Check no ReturnLength pointer\n");
129  status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), NULL);
130  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
131 
132  /* Check a too large buffer size */
133  trace("Check a too large buffer size\n");
134  status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi) * 2, &ReturnLength);
135  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
136 
137  /* Finally some correct calls */
138  trace("Check with correct parameters\n");
139  status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
140  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
141  ok( sizeof(sbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
142 
143  /* Check if we have some return values */
144  trace("Number of Processors : %d\n", sbi.NumberOfProcessors);
145  ok( sbi.NumberOfProcessors > 0, "Expected more than 0 processors, got %d\n", sbi.NumberOfProcessors);
146 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
smooth NULL
Definition: ftsmooth.c:416
#define trace
Definition: atltest.h:70
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_cache()

static void test_query_cache ( void  )
static

Definition at line 624 of file info.c.

625 {
628  BYTE buffer[128];
630  ULONG expected;
631  INT i;
632 
633  /* the large SYSTEM_CACHE_INFORMATION on WIN64 is not documented */
635  for (i = sizeof(buffer); i>= expected; i--)
636  {
637  ReturnLength = 0xdeadbeef;
638  status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
639  ok(!status && (ReturnLength == expected),
640  "%d: got 0x%x and %u (expected STATUS_SUCCESS and %u)\n", i, status, ReturnLength, expected);
641  }
642 
643  /* buffer too small for the full result.
644  Up to win7, the function succeeds with a partial result. */
645  status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
646  if (!status)
647  {
648  expected = offsetof(SYSTEM_CACHE_INFORMATION, MinimumWorkingSet);
649  for (; i>= expected; i--)
650  {
651  ReturnLength = 0xdeadbeef;
652  status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
653  ok(!status && (ReturnLength == expected),
654  "%d: got 0x%x and %u (expected STATUS_SUCCESS and %u)\n", i, status, ReturnLength, expected);
655  }
656  }
657 
658  /* buffer too small for the result, this call will always fail */
659  ReturnLength = 0xdeadbeef;
660  status = pNtQuerySystemInformation(SystemCacheInformation, sci, i, &ReturnLength);
662  ((ReturnLength == expected) || broken(!ReturnLength) || broken(ReturnLength == 0xfffffff0)),
663  "%d: got 0x%x and %u (expected STATUS_INFO_LENGTH_MISMATCH and %u)\n", i, status, ReturnLength, expected);
664 
665  if (0) {
666  /* this crashes on some vista / win7 machines */
667  ReturnLength = 0xdeadbeef;
668  status = pNtQuerySystemInformation(SystemCacheInformation, sci, 0, &ReturnLength);
670  ((ReturnLength == expected) || broken(!ReturnLength) || broken(ReturnLength == 0xfffffff0)),
671  "0: got 0x%x and %u (expected STATUS_INFO_LENGTH_MISMATCH and %u)\n", status, ReturnLength, expected);
672  }
673 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
GLuint buffer
Definition: glext.h:5915
int32_t INT
Definition: typedefs.h:58
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define offsetof(TYPE, MEMBER)
unsigned char BYTE
Definition: xxhash.c:193
#define broken(x)
Definition: _sntprintf.h:21
#define ok(value,...)
Definition: atltest.h:57
struct _SYSTEM_CACHE_INFORMATION SYSTEM_CACHE_INFORMATION
unsigned int ULONG
Definition: retypes.h:1
static SERVICE_STATUS status
Definition: service.c:31
BOOL expected
Definition: store.c:2063
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_cpu()

static void test_query_cpu ( void  )
static

Definition at line 148 of file info.c.

149 {
150  DWORD status;
153 
154  status = pNtQuerySystemInformation(SystemCpuInformation, &sci, sizeof(sci), &ReturnLength);
155  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
156  ok( sizeof(sci) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
157 
158  /* Check if we have some return values */
159  trace("Processor FeatureSet : %08x\n", sci.FeatureSet);
160  ok( sci.FeatureSet != 0, "Expected some features for this processor, got %08x\n", sci.FeatureSet);
161 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define trace
Definition: atltest.h:70
unsigned long DWORD
Definition: ntddk_ex.h:95
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_data_alignment()

static void test_query_data_alignment ( void  )
static

Definition at line 2239 of file info.c.

2240 {
2242  NTSTATUS status;
2243  DWORD value;
2244 
2245  value = 0xdeadbeef;
2246  status = pNtQuerySystemInformation(SystemRecommendedSharedDataAlignment, &value, sizeof(value), &ReturnLength);
2247  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
2248  ok(sizeof(value) == ReturnLength, "Inconsistent length %u\n", ReturnLength);
2249  ok(value == 64, "Expected 64, got %u\n", value);
2250 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
LONG NTSTATUS
Definition: precomp.h:26
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizei const GLfloat * value
Definition: glext.h:6069
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_handle()

static void test_query_handle ( void  )
static

Definition at line 490 of file info.c.

491 {
493  ULONG ExpectedLength, ReturnLength;
494  ULONG SystemInformationLength = sizeof(SYSTEM_HANDLE_INFORMATION);
495  SYSTEM_HANDLE_INFORMATION* shi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
497  BOOL found;
498  INT i;
499 
501  ok( EventHandle != NULL, "CreateEventA failed %u\n", GetLastError() );
502 
503  /* Request the needed length : a SystemInformationLength greater than one struct sets ReturnLength */
504  ReturnLength = 0xdeadbeef;
505  status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
506  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
507  ok( ReturnLength != 0xdeadbeef, "Expected valid ReturnLength\n" );
508 
509  SystemInformationLength = ReturnLength;
510  shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength);
511  memset(shi, 0x55, SystemInformationLength);
512 
513  ReturnLength = 0xdeadbeef;
514  status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
515  while (status == STATUS_INFO_LENGTH_MISMATCH) /* Vista / 2008 */
516  {
517  SystemInformationLength *= 2;
518  shi = HeapReAlloc(GetProcessHeap(), 0, shi, SystemInformationLength);
519  memset(shi, 0x55, SystemInformationLength);
520  status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
521  }
522  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status );
523  ExpectedLength = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handle[shi->Count]);
524  ok( ReturnLength == ExpectedLength || broken(ReturnLength == ExpectedLength - sizeof(DWORD)), /* Vista / 2008 */
525  "Expected length %u, got %u\n", ExpectedLength, ReturnLength );
526  ok( shi->Count > 1, "Expected more than 1 handle, got %u\n", shi->Count );
527  ok( shi->Handle[1].HandleValue != 0x5555 || broken( shi->Handle[1].HandleValue == 0x5555 ), /* Vista / 2008 */
528  "Uninitialized second handle\n" );
529  if (shi->Handle[1].HandleValue == 0x5555)
530  {
531  win_skip("Skipping broken SYSTEM_HANDLE_INFORMATION\n");
533  goto done;
534  }
535 
536  for (i = 0, found = FALSE; i < shi->Count && !found; i++)
537  found = (shi->Handle[i].OwnerPid == GetCurrentProcessId()) &&
539  ok( found, "Expected to find event handle %p (pid %x) in handle list\n", EventHandle, GetCurrentProcessId() );
540 
541  if (!found)
542  for (i = 0; i < shi->Count; i++)
543  trace( "%d: handle %x pid %x\n", i, shi->Handle[i].HandleValue, shi->Handle[i].OwnerPid );
544 
546 
547  ReturnLength = 0xdeadbeef;
548  status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
549  while (status == STATUS_INFO_LENGTH_MISMATCH) /* Vista / 2008 */
550  {
551  SystemInformationLength *= 2;
552  shi = HeapReAlloc(GetProcessHeap(), 0, shi, SystemInformationLength);
553  status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
554  }
555  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status );
556  for (i = 0, found = FALSE; i < shi->Count && !found; i++)
557  found = (shi->Handle[i].OwnerPid == GetCurrentProcessId()) &&
559  ok( !found, "Unexpectedly found event handle in handle list\n" );
560 
561  status = pNtQuerySystemInformation(SystemHandleInformation, NULL, SystemInformationLength, &ReturnLength);
562  ok( status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status );
563 
564 done:
565  HeapFree( GetProcessHeap(), 0, shi);
566 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
ULONG OwnerPid
Definition: winternl.h:1516
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
static const void void SIZE_T *static SIZE_T *static const OBJECT_ATTRIBUTES const LARGE_INTEGER HANDLE
Definition: info.c:35
SYSTEM_HANDLE_ENTRY Handle[1]
Definition: winternl.h:1526
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCSTR lpName OPTIONAL)
Definition: synch.c:637
_In_ HANDLE Handle
Definition: extypes.h:390
#define GetProcessHeap()
Definition: compat.h:484
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
struct _SYSTEM_HANDLE_INFORMATION SYSTEM_HANDLE_INFORMATION
#define broken(x)
Definition: _sntprintf.h:21
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define HeapReAlloc
Definition: compat.h:482
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
USHORT HandleValue
Definition: winternl.h:1519
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
#define HeapFree(x, y, z)
Definition: compat.h:483
DWORD WINAPI GetCurrentProcessId(VOID)
Definition: proc.c:1158
_Out_ PHANDLE EventHandle
Definition: iofuncs.h:855
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_handle_ex()

static void test_query_handle_ex ( void  )
static

Definition at line 568 of file info.c.

569 {
571  ULONG ExpectedLength, ReturnLength;
572  ULONG SystemInformationLength = sizeof(SYSTEM_HANDLE_INFORMATION_EX);
573  SYSTEM_HANDLE_INFORMATION_EX* shi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
575  BOOL found;
576  INT i;
577 
579  ok( EventHandle != NULL, "CreateEventA failed %u\n", GetLastError() );
580 
581  ReturnLength = 0xdeadbeef;
582  status = pNtQuerySystemInformation(SystemExtendedHandleInformation, shi, SystemInformationLength, &ReturnLength);
583  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
584  ok( ReturnLength != 0xdeadbeef, "Expected valid ReturnLength\n" );
585 
586  SystemInformationLength = ReturnLength;
587  shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength);
588  memset(shi, 0x55, SystemInformationLength);
589 
590  ReturnLength = 0xdeadbeef;
591  status = pNtQuerySystemInformation(SystemExtendedHandleInformation, shi, SystemInformationLength, &ReturnLength);
592  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status );
593  ExpectedLength = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION_EX, Handle[shi->Count]);
594  ok( ReturnLength == ExpectedLength, "Expected length %u, got %u\n", ExpectedLength, ReturnLength );
595  ok( shi->Count > 1, "Expected more than 1 handle, got %u\n", (DWORD)shi->Count );
596 
597  for (i = 0, found = FALSE; i < shi->Count && !found; i++)
598  found = (shi->Handle[i].UniqueProcessId == GetCurrentProcessId()) &&
600  ok( found, "Expected to find event handle %p (pid %x) in handle list\n", EventHandle, GetCurrentProcessId() );
601 
602  if (!found)
603  {
604  for (i = 0; i < shi->Count; i++)
605  trace( "%d: handle %x pid %x\n", i, (DWORD)shi->Handle[i].HandleValue, (DWORD)shi->Handle[i].UniqueProcessId );
606  }
607 
609 
610  ReturnLength = 0xdeadbeef;
611  status = pNtQuerySystemInformation(SystemExtendedHandleInformation, shi, SystemInformationLength, &ReturnLength);
612  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status );
613  for (i = 0, found = FALSE; i < shi->Count && !found; i++)
614  found = (shi->Handle[i].UniqueProcessId == GetCurrentProcessId()) &&
616  ok( !found, "Unexpectedly found event handle in handle list\n" );
617 
618  status = pNtQuerySystemInformation(SystemExtendedHandleInformation, NULL, SystemInformationLength, &ReturnLength);
619  ok( status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status );
620 
621  HeapFree( GetProcessHeap(), 0, shi);
622 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
static const void void SIZE_T *static SIZE_T *static const OBJECT_ATTRIBUTES const LARGE_INTEGER HANDLE
Definition: info.c:35
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX Handle[1]
Definition: extypes.h:1420
smooth NULL
Definition: ftsmooth.c:416
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCSTR lpName OPTIONAL)
Definition: synch.c:637
_In_ HANDLE Handle
Definition: extypes.h:390
ULONG_PTR HandleValue
Definition: extypes.h:1408
#define GetProcessHeap()
Definition: compat.h:484
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
ULONG_PTR UniqueProcessId
Definition: extypes.h:1407
unsigned long DWORD
Definition: ntddk_ex.h:95
struct _SYSTEM_HANDLE_INFORMATION_EX SYSTEM_HANDLE_INFORMATION_EX
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define HeapReAlloc
Definition: compat.h:482
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:483
DWORD WINAPI GetCurrentProcessId(VOID)
Definition: proc.c:1158
_Out_ PHANDLE EventHandle
Definition: iofuncs.h:855
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_interrupt()

static void test_query_interrupt ( void  )
static

Definition at line 675 of file info.c.

676 {
679  ULONG NeededLength;
682 
683  /* Find out the number of processors */
684  status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
685  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
686  NeededLength = sbi.NumberOfProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION);
687 
688  sii = HeapAlloc(GetProcessHeap(), 0, NeededLength);
689 
690  status = pNtQuerySystemInformation(SystemInterruptInformation, sii, 0, &ReturnLength);
691  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
692 
693  /* Try it for all processors */
694  status = pNtQuerySystemInformation(SystemInterruptInformation, sii, NeededLength, &ReturnLength);
695  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
696 
697  /* Windows XP and W2K3 (and others?) always return 0 for the ReturnLength
698  * No test added for this as it's highly unlikely that an app depends on this
699  */
700 
701  HeapFree( GetProcessHeap(), 0, sii);
702 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct _SYSTEM_INTERRUPT_INFORMATION SYSTEM_INTERRUPT_INFORMATION
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:483
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_kerndebug()

static void test_query_kerndebug ( void  )
static

Definition at line 704 of file info.c.

705 {
709 
710  status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, 0, &ReturnLength);
711  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
712 
713  status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, sizeof(skdi), &ReturnLength);
714  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
715  ok( sizeof(skdi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
716 
717  status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, sizeof(skdi) + 2, &ReturnLength);
718  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
719  ok( sizeof(skdi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
720 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_logicalproc()

static void test_query_logicalproc ( void  )
static

Definition at line 740 of file info.c.

741 {
743  ULONG len, i, proc_no;
745  SYSTEM_INFO si;
746 
747  GetSystemInfo(&si);
748 
749  status = pNtQuerySystemInformation(SystemLogicalProcessorInformation, NULL, 0, &len);
751  {
752  win_skip("SystemLogicalProcessorInformation is not supported\n");
753  return;
754  }
756  {
757  todo_wine ok(0, "SystemLogicalProcessorInformation is not implemented\n");
758  return;
759  }
760  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
761  ok(len%sizeof(*slpi) == 0, "Incorrect length %d\n", len);
762 
763  slpi = HeapAlloc(GetProcessHeap(), 0, len);
764  status = pNtQuerySystemInformation(SystemLogicalProcessorInformation, slpi, len, &len);
765  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
766 
767  proc_no = 0;
768  for(i=0; i<len/sizeof(*slpi); i++) {
769  switch(slpi[i].Relationship) {
771  /* Get number of logical processors */
772  for(; slpi[i].ProcessorMask; slpi[i].ProcessorMask /= 2)
773  proc_no += slpi[i].ProcessorMask%2;
774  break;
775  default:
776  break;
777  }
778  }
779  ok(proc_no > 0, "No processors were found\n");
780  if(si.dwNumberOfProcessors <= 32)
781  ok(proc_no == si.dwNumberOfProcessors, "Incorrect number of logical processors: %d, expected %d\n",
782  proc_no, si.dwNumberOfProcessors);
783 
784  HeapFree(GetProcessHeap(), 0, slpi);
785 }
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
LONG NTSTATUS
Definition: precomp.h:26
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define todo_wine
Definition: test.h:162
GLenum GLsizei len
Definition: glext.h:6722
#define ok(value,...)
Definition: atltest.h:57
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:142
DWORD dwNumberOfProcessors
Definition: winbase.h:1143
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
#define HeapFree(x, y, z)
Definition: compat.h:483
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_logicalprocex()

static void test_query_logicalprocex ( void  )
static

Definition at line 787 of file info.c.

788 {
789  SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *infoex, *infoex2;
790  DWORD relationship, len2, len;
792  BOOL ret;
793 
794  if (!pNtQuerySystemInformationEx)
795  return;
796 
797  len = 0;
798  relationship = RelationProcessorCore;
799  status = pNtQuerySystemInformationEx(SystemLogicalProcessorInformationEx, &relationship, sizeof(relationship), NULL, 0, &len);
800  ok(status == STATUS_INFO_LENGTH_MISMATCH, "got 0x%08x\n", status);
801  ok(len > 0, "got %u\n", len);
802 
803  len = 0;
804  relationship = RelationAll;
805  status = pNtQuerySystemInformationEx(SystemLogicalProcessorInformationEx, &relationship, sizeof(relationship), NULL, 0, &len);
806  ok(status == STATUS_INFO_LENGTH_MISMATCH, "got 0x%08x\n", status);
807  ok(len > 0, "got %u\n", len);
808 
809  len2 = 0;
810  ret = pGetLogicalProcessorInformationEx(RelationAll, NULL, &len2);
811  ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %d, error %d\n", ret, GetLastError());
812  ok(len == len2, "got %u, expected %u\n", len2, len);
813 
814  if (len && len == len2) {
815  int j, i;
816 
819 
820  status = pNtQuerySystemInformationEx(SystemLogicalProcessorInformationEx, &relationship, sizeof(relationship), infoex, len, &len);
821  ok(status == STATUS_SUCCESS, "got 0x%08x\n", status);
822 
823  ret = pGetLogicalProcessorInformationEx(RelationAll, infoex2, &len2);
824  ok(ret, "got %d, error %d\n", ret, GetLastError());
825  ok(!memcmp(infoex, infoex2, len), "returned info data mismatch\n");
826 
827  for(i = 0; status == STATUS_SUCCESS && i < len; ){
828  SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *ex = (void*)(((char *)infoex) + i);
829 
830  ok(ex->Relationship >= RelationProcessorCore && ex->Relationship <= RelationGroup,
831  "Got invalid relationship value: 0x%x\n", ex->Relationship);
832  if (!ex->Size)
833  {
834  ok(0, "got infoex[%u].Size=0\n", i);
835  break;
836  }
837 
838  trace("infoex[%u].Size: %u\n", i, ex->Size);
839  switch(ex->Relationship){
842  trace("infoex[%u].Relationship: 0x%x (Core == 0x0 or Package == 0x3)\n", i, ex->Relationship);
843  trace("infoex[%u].Processor.Flags: 0x%x\n", i, ex->Processor.Flags);
844 #ifndef __REACTOS__
845  trace("infoex[%u].Processor.EfficiencyClass: 0x%x\n", i, ex->Processor.EfficiencyClass);
846 #endif
847  trace("infoex[%u].Processor.GroupCount: 0x%x\n", i, ex->Processor.GroupCount);
848  for(j = 0; j < ex->Processor.GroupCount; ++j){
849  trace("infoex[%u].Processor.GroupMask[%u].Mask: 0x%lx\n", i, j, ex->Processor.GroupMask[j].Mask);
850  trace("infoex[%u].Processor.GroupMask[%u].Group: 0x%x\n", i, j, ex->Processor.GroupMask[j].Group);
851  }
852  break;
853  case RelationNumaNode:
854  trace("infoex[%u].Relationship: 0x%x (NumaNode)\n", i, ex->Relationship);
855  trace("infoex[%u].NumaNode.NodeNumber: 0x%x\n", i, ex->NumaNode.NodeNumber);
856  trace("infoex[%u].NumaNode.GroupMask.Mask: 0x%lx\n", i, ex->NumaNode.GroupMask.Mask);
857  trace("infoex[%u].NumaNode.GroupMask.Group: 0x%x\n", i, ex->NumaNode.GroupMask.Group);
858  break;
859  case RelationCache:
860  trace("infoex[%u].Relationship: 0x%x (Cache)\n", i, ex->Relationship);
861  trace("infoex[%u].Cache.Level: 0x%x\n", i, ex->Cache.Level);
862  trace("infoex[%u].Cache.Associativity: 0x%x\n", i, ex->Cache.Associativity);
863  trace("infoex[%u].Cache.LineSize: 0x%x\n", i, ex->Cache.LineSize);
864  trace("infoex[%u].Cache.CacheSize: 0x%x\n", i, ex->Cache.CacheSize);
865  trace("infoex[%u].Cache.Type: 0x%x\n", i, ex->Cache.Type);
866  trace("infoex[%u].Cache.GroupMask.Mask: 0x%lx\n", i, ex->Cache.GroupMask.Mask);
867  trace("infoex[%u].Cache.GroupMask.Group: 0x%x\n", i, ex->Cache.GroupMask.Group);
868  break;
869  case RelationGroup:
870  trace("infoex[%u].Relationship: 0x%x (Group)\n", i, ex->Relationship);
871  trace("infoex[%u].Group.MaximumGroupCount: 0x%x\n", i, ex->Group.MaximumGroupCount);
872  trace("infoex[%u].Group.ActiveGroupCount: 0x%x\n", i, ex->Group.ActiveGroupCount);
873  for(j = 0; j < ex->Group.ActiveGroupCount; ++j){
874  trace("infoex[%u].Group.GroupInfo[%u].MaximumProcessorCount: 0x%x\n", i, j, ex->Group.GroupInfo[j].MaximumProcessorCount);
875  trace("infoex[%u].Group.GroupInfo[%u].ActiveProcessorCount: 0x%x\n", i, j, ex->Group.GroupInfo[j].ActiveProcessorCount);
876  trace("infoex[%u].Group.GroupInfo[%u].ActiveProcessorMask: 0x%lx\n", i, j, ex->Group.GroupInfo[j].ActiveProcessorMask);
877  }
878  break;
879  default:
880  break;
881  }
882 
883  i += ex->Size;
884  }
885 
886  HeapFree(GetProcessHeap(), 0, infoex);
887  HeapFree(GetProcessHeap(), 0, infoex2);
888  }
889 }
Definition: comerr.c:44
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define GetProcessHeap()
Definition: compat.h:484
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
GLenum GLsizei len
Definition: glext.h:6722
#define ok(value,...)
Definition: atltest.h:57
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:483
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_module()

static void test_query_module ( void  )
static

Definition at line 455 of file info.c.

456 {
459  ULONG ModuleCount, i;
460 
461  ULONG SystemInformationLength = sizeof(SYSTEM_MODULE_INFORMATION);
462  SYSTEM_MODULE_INFORMATION* smi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
463  SYSTEM_MODULE* sm;
464 
465  /* Request the needed length */
466  status = pNtQuerySystemInformation(SystemModuleInformation, smi, 0, &ReturnLength);
467  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
468  ok( ReturnLength > 0, "Expected a ReturnLength to show the needed length\n");
469 
470  SystemInformationLength = ReturnLength;
471  smi = HeapReAlloc(GetProcessHeap(), 0, smi , SystemInformationLength);
472  status = pNtQuerySystemInformation(SystemModuleInformation, smi, SystemInformationLength, &ReturnLength);
473  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
474 
475  ModuleCount = smi->ModulesCount;
476  sm = &smi->Modules[0];
477  /* our implementation is a stub for now */
478  ok( ModuleCount > 0, "Expected some modules to be loaded\n");
479 
480  /* Loop through all the modules/drivers, Wine doesn't get here (yet) */
481  for (i = 0; i < ModuleCount ; i++)
482  {
483  ok( i == sm->Id, "Id (%d) should have matched %u\n", sm->Id, i);
484  sm++;
485  }
486 
487  HeapFree( GetProcessHeap(), 0, smi);
488 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
SYSTEM_MODULE Modules[1]
Definition: winternl.h:2323
#define ok(value,...)
Definition: atltest.h:57
#define HeapReAlloc
Definition: compat.h:482
unsigned int ULONG
Definition: retypes.h:1
struct _SYSTEM_MODULE_INFORMATION SYSTEM_MODULE_INFORMATION
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:483
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_performance()

static void test_query_performance ( void  )
static

Definition at line 163 of file info.c.

164 {
169 
170  status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, 0, &ReturnLength);
171  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
172 
173  status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, size, &ReturnLength);
175  {
176  /* size is larger on wow64 under w2k8/win7 */
177  size += 16;
178  status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, size, &ReturnLength);
179  }
180  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
181  ok( ReturnLength == size, "Inconsistent length %d\n", ReturnLength);
182 
183  status = pNtQuerySystemInformation(SystemPerformanceInformation, buffer, size + 2, &ReturnLength);
184  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
185  ok( ReturnLength == size || ReturnLength == size + 2,
186  "Inconsistent length %d\n", ReturnLength);
187 
188  /* Not return values yet, as struct members are unknown */
189 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
GLuint buffer
Definition: glext.h:5915
#define SystemPerformanceInformation
Definition: memtest.h:87
GLsizeiptr size
Definition: glext.h:5919
uint64_t ULONGLONG
Definition: typedefs.h:67
unsigned long DWORD
Definition: ntddk_ex.h:95
static SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX DWORD *static BOOL is_wow64
Definition: info.c:41
struct _SYSTEM_PERFORMANCE_INFORMATION SYSTEM_PERFORMANCE_INFORMATION
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process()

static void test_query_process ( void  )
static

Definition at line 270 of file info.c.

271 {
273  DWORD last_pid;
275  int i = 0, k = 0;
276  BOOL is_nt = FALSE;
278 
279  /* Copy of our winternl.h structure turned into a private one */
280  typedef struct _SYSTEM_PROCESS_INFORMATION_PRIVATE {
281  ULONG NextEntryOffset;
282  DWORD dwThreadCount;
283  DWORD dwUnknown1[6];
284  FILETIME ftCreationTime;
285  FILETIME ftUserTime;
286  FILETIME ftKernelTime;
287  UNICODE_STRING ProcessName;
288  DWORD dwBasePriority;
289  HANDLE UniqueProcessId;
290  HANDLE ParentProcessId;
291  ULONG HandleCount;
292  DWORD dwUnknown3;
293  DWORD dwUnknown4;
294  VM_COUNTERS vmCounters;
295  IO_COUNTERS ioCounters;
297  } SYSTEM_PROCESS_INFORMATION_PRIVATE;
298 
299  ULONG SystemInformationLength = sizeof(SYSTEM_PROCESS_INFORMATION_PRIVATE);
300  SYSTEM_PROCESS_INFORMATION_PRIVATE *spi, *spi_buf = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
301 
302  /* test ReturnLength */
303  ReturnLength = 0;
304  status = pNtQuerySystemInformation(SystemProcessInformation, NULL, 0, &ReturnLength);
305  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH got %08x\n", status);
306  ok( ReturnLength > 0 || broken(ReturnLength == 0) /* NT4, Win2K */,
307  "Expected a ReturnLength to show the needed length\n");
308 
309  /* W2K3 and later returns the needed length, the rest returns 0, so we have to loop */
310  for (;;)
311  {
312  status = pNtQuerySystemInformation(SystemProcessInformation, spi_buf, SystemInformationLength, &ReturnLength);
313 
314  if (status != STATUS_INFO_LENGTH_MISMATCH) break;
315 
316  spi_buf = HeapReAlloc(GetProcessHeap(), 0, spi_buf , SystemInformationLength *= 2);
317  }
318  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
319  spi = spi_buf;
320 
321  /* Get the first NextEntryOffset, from this we can deduce the OS version we're running
322  *
323  * W2K/WinXP/W2K3:
324  * NextEntryOffset for a process is 184 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION)
325  * NT:
326  * NextEntryOffset for a process is 136 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION)
327  * Wine (with every windows version):
328  * NextEntryOffset for a process is 0 if just this test is running
329  * NextEntryOffset for a process is 184 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION) +
330  * ProcessName.MaximumLength
331  * if more wine processes are running
332  *
333  * Note : On windows the first process is in fact the Idle 'process' with a thread for every processor
334  */
335 
336  pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
337 
338  is_nt = ( spi->NextEntryOffset - (sbi.NumberOfProcessors * sizeof(SYSTEM_THREAD_INFORMATION)) == 136);
339 
340  if (is_nt) win_skip("Windows version is NT, we will skip thread tests\n");
341 
342  /* Check if we have some return values
343  *
344  * On windows there will be several processes running (Including the always present Idle and System)
345  * On wine we only have one (if this test is the only wine process running)
346  */
347 
348  /* Loop through the processes */
349 
350  for (;;)
351  {
352  i++;
353 
354  last_pid = (DWORD_PTR)spi->UniqueProcessId;
355 
357  ok( spi->dwThreadCount > 0, "Expected some threads for this process, got 0\n");
358 
359  /* Loop through the threads, skip NT4 for now */
360 
361  if (!is_nt)
362  {
363  DWORD j;
364  for ( j = 0; j < spi->dwThreadCount; j++)
365  {
366  k++;
368  ok ( spi->ti[j].ClientId.UniqueProcess == spi->UniqueProcessId,
369  "The owning pid of the thread (%p) doesn't equal the pid (%p) of the process\n",
370  spi->ti[j].ClientId.UniqueProcess, spi->UniqueProcessId);
371  }
372  }
373 
374  if (!spi->NextEntryOffset) break;
375 
376  one_before_last_pid = last_pid;
377 
378  spi = (SYSTEM_PROCESS_INFORMATION_PRIVATE*)((char*)spi + spi->NextEntryOffset);
379  }
380  trace("Total number of running processes : %d\n", i);
381  if (!is_nt) trace("Total number of running threads : %d\n", k);
382 
383  if (one_before_last_pid == 0) one_before_last_pid = last_pid;
384 
385  HeapFree( GetProcessHeap(), 0, spi_buf);
386 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
static DWORD one_before_last_pid
Definition: info.c:48
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define DWORD_PTR
Definition: treelist.c:76
LONG NTSTATUS
Definition: precomp.h:26
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define GetProcessHeap()
Definition: compat.h:484
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
#define disable_success_count
Definition: test.h:170
#define broken(x)
Definition: _sntprintf.h:21
#define ok(value,...)
Definition: atltest.h:57
#define HeapReAlloc
Definition: compat.h:482
unsigned int ULONG
Definition: retypes.h:1
struct _SYSTEM_THREAD_INFORMATION SYSTEM_THREAD_INFORMATION
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
int k
Definition: mpi.c:3369
#define HeapFree(x, y, z)
Definition: compat.h:483
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_basic()

static void test_query_process_basic ( void  )
static

Definition at line 1042 of file info.c.

1043 {
1044  NTSTATUS status;
1046 
1047  typedef struct _PROCESS_BASIC_INFORMATION_PRIVATE {
1049  PPEB PebBaseAddress;
1050  DWORD_PTR AffinityMask;
1051  DWORD_PTR BasePriority;
1052  ULONG_PTR UniqueProcessId;
1053  ULONG_PTR InheritedFromUniqueProcessId;
1055 
1057 
1058  /* This test also covers some basic parameter testing that should be the same for
1059  * every information class
1060  */
1061 
1062  /* Use a nonexistent info class */
1063  trace("Check nonexistent info class\n");
1064  status = pNtQueryInformationProcess(NULL, -1, NULL, 0, NULL);
1066  "Expected STATUS_INVALID_INFO_CLASS or STATUS_NOT_IMPLEMENTED, got %08x\n", status);
1067 
1068  /* Do not give a handle and buffer */
1069  trace("Check NULL handle and buffer and zero-length buffersize\n");
1070  status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, NULL, 0, NULL);
1071  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1072 
1073  /* Use a correct info class and buffer size, but still no handle and buffer */
1074  trace("Check NULL handle and buffer\n");
1075  status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, NULL, sizeof(pbi), NULL);
1077  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
1078 
1079  /* Use a correct info class and buffer size, but still no handle */
1080  trace("Check NULL handle\n");
1081  status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
1082  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1083 
1084  /* Use a greater buffer size */
1085  trace("Check NULL handle and too large buffersize\n");
1086  status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, &pbi, sizeof(pbi) * 2, NULL);
1087  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1088 
1089  /* Use no ReturnLength */
1090  trace("Check NULL ReturnLength\n");
1091  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
1092  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1093 
1094  /* Finally some correct calls */
1095  trace("Check with correct parameters\n");
1096  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), &ReturnLength);
1097  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1098  ok( sizeof(pbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1099 
1100  /* Everything is correct except a too large buffersize */
1101  trace("Too large buffersize\n");
1102  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi) * 2, &ReturnLength);
1103  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1104  ok( sizeof(pbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1105 
1106  /* Check if we have some return values */
1107  trace("ProcessID : %lx\n", pbi.UniqueProcessId);
1108  ok( pbi.UniqueProcessId > 0, "Expected a ProcessID > 0, got 0\n");
1109 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
uint32_t ULONG_PTR
Definition: typedefs.h:65
smooth NULL
Definition: ftsmooth.c:416
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917
#define trace
Definition: atltest.h:70
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define GetCurrentProcess()
Definition: compat.h:507
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
_In_ NTSTATUS ExitStatus
Definition: psfuncs.h:859
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_debug_flags()

static void test_query_process_debug_flags ( int  argc,
char **  argv 
)
static

Definition at line 1613 of file info.c.

1614 {
1615  static const DWORD test_flags[] = { DEBUG_PROCESS,
1618  CREATE_SUSPENDED };
1619  DWORD debug_flags = 0xdeadbeef;
1620  char cmdline[MAX_PATH];
1622  STARTUPINFOA si = { 0 };
1623  NTSTATUS status;
1624  DEBUG_EVENT ev;
1625  DWORD result;
1626  BOOL ret;
1627  int i, j;
1628 
1629  /* test invalid arguments */
1630  status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, NULL, 0, NULL);
1632  "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1633 
1634  status = pNtQueryInformationProcess(NULL, ProcessDebugFlags, NULL, sizeof(debug_flags), NULL);
1636  "Expected STATUS_INVALID_HANDLE, got %#x.\n", status);
1637 
1638  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1639  NULL, sizeof(debug_flags), NULL);
1640  ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status);
1641 
1642  status = pNtQueryInformationProcess(NULL, ProcessDebugFlags,
1643  &debug_flags, sizeof(debug_flags), NULL);
1645  "Expected STATUS_INVALID_HANDLE, got %#x.\n", status);
1646 
1647  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1648  &debug_flags, sizeof(debug_flags) - 1, NULL);
1649  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1650 
1651  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1652  &debug_flags, sizeof(debug_flags) + 1, NULL);
1653  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1654 
1655  /* test ProcessDebugFlags of current process */
1656  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugFlags,
1657  &debug_flags, sizeof(debug_flags), NULL);
1658  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1659  ok(debug_flags == TRUE, "Expected flag TRUE, got %x.\n", debug_flags);
1660 
1661  for (i = 0; i < sizeof(test_flags)/sizeof(test_flags[0]); i++)
1662  {
1663  DWORD expected_flags = !(test_flags[i] & DEBUG_ONLY_THIS_PROCESS);
1664  sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee");
1665 
1666  si.cb = sizeof(si);
1667  ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, test_flags[i], NULL, NULL, &si, &pi);
1668  ok(ret, "CreateProcess failed, last error %#x.\n", GetLastError());
1669 
1670  if (!(test_flags[i] & (DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS)))
1671  {
1672  /* test ProcessDebugFlags before attaching with debugger */
1673  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags,
1674  &debug_flags, sizeof(debug_flags), NULL);
1675  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1676  ok(debug_flags == TRUE, "Expected flag TRUE, got %x.\n", debug_flags);
1677 
1678  ret = DebugActiveProcess(pi.dwProcessId);
1679  ok(ret, "DebugActiveProcess failed, last error %#x.\n", GetLastError());
1680  expected_flags = FALSE;
1681  }
1682 
1683  /* test ProcessDebugFlags after attaching with debugger */
1684  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags,
1685  &debug_flags, sizeof(debug_flags), NULL);
1686  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1687  ok(debug_flags == expected_flags, "Expected flag %x, got %x.\n", expected_flags, debug_flags);
1688 
1689  if (!(test_flags[i] & CREATE_SUSPENDED))
1690  {
1691  /* Continue a couple of times to make sure the process is fully initialized,
1692  * otherwise Windows XP deadlocks in the following DebugActiveProcess(). */
1693  for (;;)
1694  {
1695  ret = WaitForDebugEvent(&ev, 1000);
1697  ok(ret, "WaitForDebugEvent failed, last error %#x.\n", GetLastError());
1698  if (!ret) break;
1699 
1700  if (ev.dwDebugEventCode == LOAD_DLL_DEBUG_EVENT) break;
1701 
1704  ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError());
1705  if (!ret) break;
1706  }
1707 
1708  result = SuspendThread(pi.hThread);
1709  ok(result == 0, "Expected 0, got %u.\n", result);
1710  }
1711 
1712  ret = DebugActiveProcessStop(pi.dwProcessId);
1713  ok(ret, "DebugActiveProcessStop failed, last error %#x.\n", GetLastError());
1714 
1715  /* test ProcessDebugFlags after detaching debugger */
1716  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags,
1717  &debug_flags, sizeof(debug_flags), NULL);
1718  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1719  ok(debug_flags == expected_flags, "Expected flag %x, got %x.\n", expected_flags, debug_flags);
1720 
1721  ret = DebugActiveProcess(pi.dwProcessId);
1722  ok(ret, "DebugActiveProcess failed, last error %#x.\n", GetLastError());
1723 
1724  /* test ProcessDebugFlags after re-attaching debugger */
1725  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags,
1726  &debug_flags, sizeof(debug_flags), NULL);
1727  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1728  ok(debug_flags == FALSE, "Expected flag FALSE, got %x.\n", debug_flags);
1729 
1730  result = ResumeThread(pi.hThread);
1731  todo_wine ok(result == 2, "Expected 2, got %u.\n", result);
1732 
1733  /* Wait until the process is terminated. On Windows XP the process randomly
1734  * gets stuck in a non-continuable exception, so stop after 100 iterations.
1735  * On Windows 2003, the debugged process disappears (or stops?) without
1736  * any EXIT_PROCESS_DEBUG_EVENT after a couple of events. */
1737  for (j = 0; j < 100; j++)
1738  {
1739  ret = WaitForDebugEvent(&ev, 1000);
1742  "WaitForDebugEvent failed, last error %#x.\n", GetLastError());
1743  if (!ret) break;
1744 
1745  if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break;
1746 
1749  ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError());
1750  if (!ret) break;
1751  }
1752  ok(j < 100 || broken(j >= 100) /* Win XP */, "Expected less than 100 debug events.\n");
1753 
1754  /* test ProcessDebugFlags after process has terminated */
1755  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugFlags,
1756  &debug_flags, sizeof(debug_flags), NULL);
1757  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1758  ok(debug_flags == FALSE, "Expected flag FALSE, got %x.\n", debug_flags);
1759 
1760  ret = CloseHandle(pi.hThread);
1761  ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1762  ret = CloseHandle(pi.hProcess);
1763  ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1764  }
1765 }
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
DWORD dwThreadId
Definition: winbase.h:768
#define TRUE
Definition: types.h:120
DWORD dwProcessId
Definition: winbase.h:767
LONG NTSTATUS
Definition: precomp.h:26
BOOL WINAPI ContinueDebugEvent(IN DWORD dwProcessId, IN DWORD dwThreadId, IN DWORD dwContinueStatus)
Definition: debugger.c:448
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
#define LOAD_DLL_DEBUG_EVENT
Definition: winbase.h:107
TCHAR * cmdline
Definition: stretchblt.cpp:32
#define argv
Definition: mplay32.c:18
#define DBG_CONTINUE
Definition: ntstatus.h:47
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define sprintf(buf, format,...)
Definition: sprintf.c:55
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define CREATE_SUSPENDED
Definition: winbase.h:178
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD dwDebugEventCode
Definition: winbase.h:766
smooth NULL
Definition: ftsmooth.c:416
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define EXIT_PROCESS_DEBUG_EVENT
Definition: winbase.h:106
DWORD cb
Definition: winbase.h:809
BOOL WINAPI DebugActiveProcessStop(IN DWORD dwProcessId)
Definition: debugger.c:521
static refpint_t pi[]
Definition: server.c:96
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4744
#define MAX_PATH
Definition: compat.h:34
unsigned long DWORD
Definition: ntddk_ex.h:95
#define disable_success_count
Definition: test.h:170
#define DEBUG_PROCESS
Definition: winbase.h:176
BOOL WINAPI WaitForDebugEvent(IN LPDEBUG_EVENT lpDebugEvent, IN DWORD dwMilliseconds)
Definition: debugger.c:625
int ret
DWORD WINAPI SuspendThread(IN HANDLE hThread)
Definition: thread.c:641
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define todo_wine
Definition: test.h:162
#define GetCurrentProcess()
Definition: compat.h:507
#define broken(x)
Definition: _sntprintf.h:21
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define ERROR_SEM_TIMEOUT
Definition: winerror.h:193
DWORD WINAPI ResumeThread(IN HANDLE hThread)
Definition: thread.c:566
BOOL WINAPI DebugActiveProcess(IN DWORD dwProcessId)
Definition: debugger.c:480
#define DEBUG_ONLY_THIS_PROCESS
Definition: winbase.h:177
GLuint64EXT * result
Definition: glext.h:11304
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_debug_object_handle()

static void test_query_process_debug_object_handle ( int  argc,
char **  argv 
)
static

Definition at line 1516 of file info.c.

1517 {
1518  char cmdline[MAX_PATH];
1519  STARTUPINFOA si = {0};
1521  BOOL ret;
1522  HANDLE debug_object;
1523  NTSTATUS status;
1524 
1525  sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee");
1526 
1527  si.cb = sizeof(si);
1529  NULL, &si, &pi);
1530  ok(ret, "CreateProcess failed with last error %u\n", GetLastError());
1531  if (!ret) return;
1532 
1533  status = pNtQueryInformationProcess(NULL, ProcessDebugObjectHandle, NULL,
1534  0, NULL);
1536  {
1537  win_skip("ProcessDebugObjectHandle is not supported\n");
1538  return;
1539  }
1541  "Expected NtQueryInformationProcess to return STATUS_INFO_LENGTH_MISMATCH, got 0x%08x\n",
1542  status);
1543 
1544  status = pNtQueryInformationProcess(NULL, ProcessDebugObjectHandle, NULL,
1545  sizeof(debug_object), NULL);
1547  status == STATUS_ACCESS_VIOLATION, /* XP */
1548  "Expected NtQueryInformationProcess to return STATUS_INVALID_HANDLE, got 0x%08x\n", status);
1549 
1550  status = pNtQueryInformationProcess(GetCurrentProcess(),
1551  ProcessDebugObjectHandle, NULL, sizeof(debug_object), NULL);
1553  "Expected NtQueryInformationProcess to return STATUS_ACCESS_VIOLATION, got 0x%08x\n", status);
1554 
1555  status = pNtQueryInformationProcess(NULL, ProcessDebugObjectHandle,
1556  &debug_object, sizeof(debug_object), NULL);
1558  "Expected NtQueryInformationProcess to return STATUS_ACCESS_VIOLATION, got 0x%08x\n", status);
1559 
1560  status = pNtQueryInformationProcess(GetCurrentProcess(),
1561  ProcessDebugObjectHandle, &debug_object,
1562  sizeof(debug_object) - 1, NULL);
1564  "Expected NtQueryInformationProcess to return STATUS_INFO_LENGTH_MISMATCH, got 0x%08x\n", status);
1565 
1566  status = pNtQueryInformationProcess(GetCurrentProcess(),
1567  ProcessDebugObjectHandle, &debug_object,
1568  sizeof(debug_object) + 1, NULL);
1570  "Expected NtQueryInformationProcess to return STATUS_INFO_LENGTH_MISMATCH, got 0x%08x\n", status);
1571 
1572  debug_object = (HANDLE)0xdeadbeef;
1573  status = pNtQueryInformationProcess(GetCurrentProcess(),
1574  ProcessDebugObjectHandle, &debug_object,
1575  sizeof(debug_object), NULL);
1577  "Expected NtQueryInformationProcess to return STATUS_PORT_NOT_SET, got 0x%08x\n", status);
1578  ok(debug_object == NULL ||
1579  broken(debug_object == (HANDLE)0xdeadbeef), /* Wow64 */
1580  "Expected debug object handle to be NULL, got %p\n", debug_object);
1581 
1582  debug_object = (HANDLE)0xdeadbeef;
1583  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugObjectHandle,
1584  &debug_object, sizeof(debug_object), NULL);
1585  todo_wine
1587  "Expected NtQueryInformationProcess to return STATUS_SUCCESS, got 0x%08x\n", status);
1588  todo_wine
1589  ok(debug_object != NULL,
1590  "Expected debug object handle to be non-NULL, got %p\n", debug_object);
1591 
1592  for (;;)
1593  {
1594  DEBUG_EVENT ev;
1595 
1596  ret = WaitForDebugEvent(&ev, INFINITE);
1597  ok(ret, "WaitForDebugEvent failed with last error %u\n", GetLastError());
1598  if (!ret) break;
1599 
1600  if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break;
1601 
1603  ok(ret, "ContinueDebugEvent failed with last error %u\n", GetLastError());
1604  if (!ret) break;
1605  }
1606 
1607  ret = CloseHandle(pi.hThread);
1608  ok(ret, "CloseHandle failed with last error %u\n", GetLastError());
1609  ret = CloseHandle(pi.hProcess);
1610  ok(ret, "CloseHandle failed with last error %u\n", GetLastError());
1611 }
#define CloseHandle
Definition: compat.h:487
#define STATUS_PORT_NOT_SET
Definition: ntstatus.h:894
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
DWORD dwThreadId
Definition: winbase.h:768
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
DWORD dwProcessId
Definition: winbase.h:767
LONG NTSTATUS
Definition: precomp.h:26
BOOL WINAPI ContinueDebugEvent(IN DWORD dwProcessId, IN DWORD dwThreadId, IN DWORD dwContinueStatus)
Definition: debugger.c:448
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
TCHAR * cmdline
Definition: stretchblt.cpp:32
static const void void SIZE_T *static SIZE_T *static const OBJECT_ATTRIBUTES const LARGE_INTEGER HANDLE
Definition: info.c:35
#define argv
Definition: mplay32.c:18
#define DBG_CONTINUE
Definition: ntstatus.h:47
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD dwDebugEventCode
Definition: winbase.h:766
smooth NULL
Definition: ftsmooth.c:416
#define EXIT_PROCESS_DEBUG_EVENT
Definition: winbase.h:106
DWORD cb
Definition: winbase.h:809
static refpint_t pi[]
Definition: server.c:96
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4744
#define MAX_PATH
Definition: compat.h:34
#define DEBUG_PROCESS
Definition: winbase.h:176
BOOL WINAPI WaitForDebugEvent(IN LPDEBUG_EVENT lpDebugEvent, IN DWORD dwMilliseconds)
Definition: debugger.c:625
int ret
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define todo_wine
Definition: test.h:162
#define GetCurrentProcess()
Definition: compat.h:507
#define broken(x)
Definition: _sntprintf.h:21
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_debug_port()

static void test_query_process_debug_port ( int  argc,
char **  argv 
)
static

Definition at line 1327 of file info.c.

1328 {
1329  DWORD_PTR debug_port = 0xdeadbeef;
1330  char cmdline[MAX_PATH];
1332  STARTUPINFOA si = { 0 };
1333  NTSTATUS status;
1334  BOOL ret;
1335 
1336  sprintf(cmdline, "%s %s %s", argv[0], argv[1], "debuggee");
1337 
1338  si.cb = sizeof(si);
1340  ok(ret, "CreateProcess failed, last error %#x.\n", GetLastError());
1341  if (!ret) return;
1342 
1343  status = pNtQueryInformationProcess(NULL, ProcessDebugPort,
1344  NULL, 0, NULL);
1345  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1346 
1347  status = pNtQueryInformationProcess(NULL, ProcessDebugPort,
1348  NULL, sizeof(debug_port), NULL);
1350  "Expected STATUS_INVALID_HANDLE, got %#x.\n", status);
1351 
1352  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1353  NULL, sizeof(debug_port), NULL);
1354  ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %#x.\n", status);
1355 
1356  status = pNtQueryInformationProcess(NULL, ProcessDebugPort,
1357  &debug_port, sizeof(debug_port), NULL);
1358  ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %#x.\n", status);
1359 
1360  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1361  &debug_port, sizeof(debug_port) - 1, NULL);
1362  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1363 
1364  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1365  &debug_port, sizeof(debug_port) + 1, NULL);
1366  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %#x.\n", status);
1367 
1368  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
1369  &debug_port, sizeof(debug_port), NULL);
1370  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1371  ok(debug_port == 0, "Expected port 0, got %#lx.\n", debug_port);
1372 
1373  status = pNtQueryInformationProcess(pi.hProcess, ProcessDebugPort,
1374  &debug_port, sizeof(debug_port), NULL);
1375  ok(!status, "NtQueryInformationProcess failed, status %#x.\n", status);
1376  ok(debug_port == ~(DWORD_PTR)0, "Expected port %#lx, got %#lx.\n", ~(DWORD_PTR)0, debug_port);
1377 
1378  for (;;)
1379  {
1380  DEBUG_EVENT ev;
1381 
1382  ret = WaitForDebugEvent(&ev, INFINITE);
1383  ok(ret, "WaitForDebugEvent failed, last error %#x.\n", GetLastError());
1384  if (!ret) break;
1385 
1386  if (ev.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break;
1387 
1389  ok(ret, "ContinueDebugEvent failed, last error %#x.\n", GetLastError());
1390  if (!ret) break;
1391  }
1392 
1393  ret = CloseHandle(pi.hThread);
1394  ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1395  ret = CloseHandle(pi.hProcess);
1396  ok(ret, "CloseHandle failed, last error %#x.\n", GetLastError());
1397 }
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
DWORD dwThreadId
Definition: winbase.h:768
DWORD dwProcessId
Definition: winbase.h:767
LONG NTSTATUS
Definition: precomp.h:26
BOOL WINAPI ContinueDebugEvent(IN DWORD dwProcessId, IN DWORD dwThreadId, IN DWORD dwContinueStatus)
Definition: debugger.c:448
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
TCHAR * cmdline
Definition: stretchblt.cpp:32
#define argv
Definition: mplay32.c:18
#define DBG_CONTINUE
Definition: ntstatus.h:47
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD dwDebugEventCode
Definition: winbase.h:766
smooth NULL
Definition: ftsmooth.c:416
#define EXIT_PROCESS_DEBUG_EVENT
Definition: winbase.h:106
DWORD cb
Definition: winbase.h:809
static refpint_t pi[]
Definition: server.c:96
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4744
#define MAX_PATH
Definition: compat.h:34
#define DEBUG_PROCESS
Definition: winbase.h:176
BOOL WINAPI WaitForDebugEvent(IN LPDEBUG_EVENT lpDebugEvent, IN DWORD dwMilliseconds)
Definition: debugger.c:625
int ret
#define GetCurrentProcess()
Definition: compat.h:507
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define INFINITE
Definition: serial.h:102
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_handlecount()

static void test_query_process_handlecount ( void  )
static

Definition at line 1433 of file info.c.

1434 {
1435  NTSTATUS status;
1437  DWORD handlecount;
1438  BYTE buffer[2 * sizeof(DWORD)];
1439  HANDLE process;
1440 
1441  status = pNtQueryInformationProcess(NULL, ProcessHandleCount, NULL, sizeof(handlecount), NULL);
1443  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
1444 
1445  status = pNtQueryInformationProcess(NULL, ProcessHandleCount, &handlecount, sizeof(handlecount), NULL);
1446  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1447 
1448  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessHandleCount, &handlecount, 2, &ReturnLength);
1449  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1450 
1452  if (!process)
1453  {
1454  trace("Could not open process with ID : %d, error : %u. Going to use current one.\n", one_before_last_pid, GetLastError());
1456  trace("ProcessHandleCount for current process\n");
1457  }
1458  else
1459  trace("ProcessHandleCount for process with ID : %d\n", one_before_last_pid);
1460 
1461  status = pNtQueryInformationProcess( process, ProcessHandleCount, &handlecount, sizeof(handlecount), &ReturnLength);
1462  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1463  ok( sizeof(handlecount) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1465 
1466  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessHandleCount, buffer, sizeof(buffer), &ReturnLength);
1468  "Expected STATUS_INFO_LENGTH_MISMATCH or STATUS_SUCCESS, got %08x\n", status);
1469  ok( sizeof(handlecount) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1470 
1471  /* Check if we have some return values */
1472  trace("HandleCount : %d\n", handlecount);
1473  todo_wine
1474  {
1475  ok( handlecount > 0, "Expected some handles, got 0\n");
1476  }
1477 }
static DWORD
Definition: info.c:70
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
static DWORD one_before_last_pid
Definition: info.c:48
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:158
LONG NTSTATUS
Definition: precomp.h:26
static HANDLE process
Definition: process.c:76
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
GLuint buffer
Definition: glext.h:5915
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define FALSE
Definition: types.h:117
smooth NULL
Definition: ftsmooth.c:416
#define trace
Definition: atltest.h:70
unsigned long DWORD
Definition: ntddk_ex.h:95
#define todo_wine
Definition: test.h:162
#define GetCurrentProcess()
Definition: compat.h:507
unsigned char BYTE
Definition: xxhash.c:193
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_image_file_name()

static void test_query_process_image_file_name ( void  )
static

Definition at line 1479 of file info.c.

1480 {
1481  NTSTATUS status;
1483  UNICODE_STRING image_file_name;
1484  void *buffer;
1485  char *file_nameA;
1486  INT len;
1487 
1488  status = pNtQueryInformationProcess(NULL, ProcessImageFileName, &image_file_name, sizeof(image_file_name), NULL);
1490  {
1491  win_skip("ProcessImageFileName is not supported\n");
1492  return;
1493  }
1494  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1495 
1496  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessImageFileName, &image_file_name, 2, &ReturnLength);
1497  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1498 
1499  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessImageFileName, &image_file_name, sizeof(image_file_name), &ReturnLength);
1500  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1501 
1503  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessImageFileName, buffer, ReturnLength, &ReturnLength);
1504  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1505  memcpy(&image_file_name, buffer, sizeof(image_file_name));
1506  len = WideCharToMultiByte(CP_ACP, 0, image_file_name.Buffer, image_file_name.Length/sizeof(WCHAR), NULL, 0, NULL, NULL);
1507  file_nameA = HeapAlloc(GetProcessHeap(), 0, len + 1);
1508  WideCharToMultiByte(CP_ACP, 0, image_file_name.Buffer, image_file_name.Length/sizeof(WCHAR), file_nameA, len, NULL, NULL);
1509  file_nameA[len] = '\0';
1511  trace("process image file name: %s\n", file_nameA);
1512  todo_wine ok(strncmp(file_nameA, "\\Device\\", 8) == 0, "Process image name should be an NT path beginning with \\Device\\ (is %s)\n", file_nameA);
1514 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
LONG NTSTATUS
Definition: precomp.h:26
GLuint buffer
Definition: glext.h:5915
int32_t INT
Definition: typedefs.h:58
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
const char * file_nameA(const char *str) DECLSPEC_HIDDEN
Definition: path.c:37
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:484
#define trace
Definition: atltest.h:70
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define todo_wine
Definition: test.h:162
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
#define GetCurrentProcess()
Definition: compat.h:507
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
#define HeapFree(x, y, z)
Definition: compat.h:483
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_io()

static void test_query_process_io ( void  )
static

Definition at line 1230 of file info.c.

1231 {
1232  NTSTATUS status;
1234  IO_COUNTERS pii;
1235 
1236  /* NT4 doesn't support this information class, so check for it */
1237  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii), &ReturnLength);
1239  {
1240  win_skip("ProcessIoCounters information class is not supported\n");
1241  return;
1242  }
1243 
1244  status = pNtQueryInformationProcess(NULL, ProcessIoCounters, NULL, sizeof(pii), NULL);
1246  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
1247 
1248  status = pNtQueryInformationProcess(NULL, ProcessIoCounters, &pii, sizeof(pii), NULL);
1249  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1250 
1251  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, 24, &ReturnLength);
1252  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1253 
1254  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii), &ReturnLength);
1255  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1256  ok( sizeof(pii) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1257 
1258  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii) * 2, &ReturnLength);
1259  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1260  ok( sizeof(pii) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1261 
1262  /* Check if we have some return values */
1263  trace("OtherOperationCount : 0x%s\n", wine_dbgstr_longlong(pii.OtherOperationCount));
1264  todo_wine
1265  {
1266  ok( pii.OtherOperationCount > 0, "Expected an OtherOperationCount > 0\n");
1267  }
1268 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
ULONGLONG OtherOperationCount
Definition: pstypes.h:85
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
smooth NULL
Definition: ftsmooth.c:416
#define trace
Definition: atltest.h:70
#define todo_wine
Definition: test.h:162
#define GetCurrentProcess()
Definition: compat.h:507
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
unsigned int ULONG
Definition: retypes.h:1
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define win_skip
Definition: test.h:149
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_priority()

static void test_query_process_priority ( void  )
static

Definition at line 1399 of file info.c.

1400 {
1403  DWORD orig_priority;
1404  NTSTATUS status;
1405  BOOL ret;
1406 
1407  status = pNtQueryInformationProcess(NULL, ProcessPriorityClass, NULL, sizeof(priority[0]), NULL);
1409  "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status);
1410 
1411  status = pNtQueryInformationProcess(NULL, ProcessPriorityClass, &priority, sizeof(priority[0]), NULL);
1412  ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1413 
1414  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessPriorityClass, &priority, 1, &ReturnLength);
1415  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1416 
1417  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessPriorityClass, &priority, sizeof(priority), &ReturnLength);
1418  ok(status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1419 
1420  orig_priority = GetPriorityClass(GetCurrentProcess());
1422  ok(ret, "Failed to set priority class: %u\n", GetLastError());
1423 
1424  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessPriorityClass, &priority, sizeof(priority[0]), &ReturnLength);
1425  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1426  ok(priority[0].PriorityClass == PROCESS_PRIOCLASS_BELOW_NORMAL,
1427  "Expected PROCESS_PRIOCLASS_BELOW_NORMAL, got %u\n", priority[0].PriorityClass);
1428 
1429  ret = SetPriorityClass(GetCurrentProcess(), orig_priority);
1430  ok(ret, "Failed to reset priority class: %u\n", GetLastError());
1431 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
BOOL WINAPI SetPriorityClass(IN HANDLE hProcess, IN DWORD dwPriorityClass)
Definition: proc.c:1694
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define PROCESS_PRIOCLASS_BELOW_NORMAL
Definition: winternl.h:1319
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define GetCurrentProcess()
Definition: compat.h:507
#define broken(x)
Definition: _sntprintf.h:21
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define BELOW_NORMAL_PRIORITY_CLASS
Definition: winbase.h:190
unsigned int ULONG
Definition: retypes.h:1
static int priority
Definition: timer.c:163
DWORD WINAPI GetPriorityClass(IN HANDLE hProcess)
Definition: proc.c:1659
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_times()

static void test_query_process_times ( void  )
static

Definition at line 1270 of file info.c.

1271 {
1272  NTSTATUS status;
1274  HANDLE process;
1275  SYSTEMTIME UTC, Local;
1276  KERNEL_USER_TIMES spti;
1277 
1278  status = pNtQueryInformationProcess(NULL, ProcessTimes, NULL, sizeof(spti), NULL);
1280  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
1281 
1282  status = pNtQueryInformationProcess(NULL, ProcessTimes, &spti, sizeof(spti), NULL);
1283  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1284 
1285  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, 24, &ReturnLength);
1286  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1287 
1289  if (!process)
1290  {
1291  trace("Could not open process with ID : %d, error : %u. Going to use current one.\n", one_before_last_pid, GetLastError());
1293  trace("ProcessTimes for current process\n");
1294  }
1295  else
1296  trace("ProcessTimes for process with ID : %d\n", one_before_last_pid);
1297 
1298  status = pNtQueryInformationProcess( process, ProcessTimes, &spti, sizeof(spti), &ReturnLength);
1299  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1300  ok( sizeof(spti) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1302 
1303  FileTimeToSystemTime((const FILETIME *)&spti.CreateTime, &UTC);
1304  SystemTimeToTzSpecificLocalTime(NULL, &UTC, &Local);
1305  trace("CreateTime : %02d/%02d/%04d %02d:%02d:%02d\n", Local.wMonth, Local.wDay, Local.wYear,
1306  Local.wHour, Local.wMinute, Local.wSecond);
1307 
1308  FileTimeToSystemTime((const FILETIME *)&spti.ExitTime, &UTC);
1309  SystemTimeToTzSpecificLocalTime(NULL, &UTC, &Local);
1310  trace("ExitTime : %02d/%02d/%04d %02d:%02d:%02d\n", Local.wMonth, Local.wDay, Local.wYear,
1311  Local.wHour, Local.wMinute, Local.wSecond);
1312 
1313  FileTimeToSystemTime((const FILETIME *)&spti.KernelTime, &Local);
1314  trace("KernelTime : %02d:%02d:%02d.%03d\n", Local.wHour, Local.wMinute, Local.wSecond, Local.wMilliseconds);
1315 
1316  FileTimeToSystemTime((const FILETIME *)&spti.UserTime, &Local);
1317  trace("UserTime : %02d:%02d:%02d.%03d\n", Local.wHour, Local.wMinute, Local.wSecond, Local.wMilliseconds);
1318 
1319  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, sizeof(spti) * 2, &ReturnLength);
1320  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1321  ok( sizeof(spti) == ReturnLength ||
1322  ReturnLength == 0 /* vista */ ||
1323  broken(is_wow64), /* returns garbage on wow64 */
1324  "Inconsistent length %d\n", ReturnLength);
1325 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
static DWORD one_before_last_pid
Definition: info.c:48
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:158
WORD wMonth
Definition: winbase.h:884
LONG NTSTATUS
Definition: precomp.h:26
LARGE_INTEGER UserTime
Definition: winternl.h:1063
static HANDLE process
Definition: process.c:76
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
LARGE_INTEGER ExitTime
Definition: winternl.h:1061
BOOL WINAPI SystemTimeToTzSpecificLocalTime(CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation, CONST SYSTEMTIME *lpUniversalTime, LPSYSTEMTIME lpLocalTime)
Definition: timezone.c:377
WORD wYear
Definition: winbase.h:883
#define FALSE
Definition: types.h:117
WORD wMinute
Definition: winbase.h:888
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
#define trace
Definition: atltest.h:70
LARGE_INTEGER CreateTime
Definition: winternl.h:1060
WORD wSecond
Definition: winbase.h:889
WORD wMilliseconds
Definition: winbase.h:890
#define GetCurrentProcess()
Definition: compat.h:507
static SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX DWORD *static BOOL is_wow64
Definition: info.c:41
#define broken(x)
Definition: _sntprintf.h:21
WORD wDay
Definition: winbase.h:886
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
WORD wHour
Definition: winbase.h:887
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
LARGE_INTEGER KernelTime
Definition: winternl.h:1062
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_vm()

static void test_query_process_vm ( void  )
static

Definition at line 1127 of file info.c.

1128 {
1129  NTSTATUS status;
1131  VM_COUNTERS pvi;
1132  ULONG old_size = FIELD_OFFSET(VM_COUNTERS,PrivatePageCount);
1133  HANDLE process;
1134  SIZE_T prev_size;
1135  const SIZE_T alloc_size = 16 * 1024 * 1024;
1136  void *ptr;
1137 
1138  status = pNtQueryInformationProcess(NULL, ProcessVmCounters, NULL, sizeof(pvi), NULL);
1140  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08x\n", status);
1141 
1142  status = pNtQueryInformationProcess(NULL, ProcessVmCounters, &pvi, old_size, NULL);
1143  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
1144 
1145  /* Windows XP and W2K3 will report success for a size of 44 AND 48 !
1146  Windows W2K will only report success for 44.
1147  For now we only care for 44, which is FIELD_OFFSET(VM_COUNTERS,PrivatePageCount))
1148  */
1149 
1150  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, 24, &ReturnLength);
1151  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1152 
1153  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, old_size, &ReturnLength);
1154  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1155  ok( old_size == ReturnLength, "Inconsistent length %d\n", ReturnLength);
1156 
1157  status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, 46, &ReturnLength);
1158  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1159  ok( ReturnLength == old_size || ReturnLength == sizeof(pvi), "Inconsistent length %d\n", ReturnLength);
1160 
1161  /* Check if we have some return values */
1162  dump_vm_counters("VM counters for GetCurrentProcess", &pvi);
1163  ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n");
1164  ok( pvi.PagefileUsage > 0, "Expected a PagefileUsage > 0\n");
1165 
1167  status = pNtQueryInformationProcess(process, ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1168  ok( status == STATUS_ACCESS_DENIED, "Expected STATUS_ACCESS_DENIED, got %08x\n", status);
1170 
1172  status = pNtQueryInformationProcess(process, ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1173  ok( status == STATUS_SUCCESS || broken(!process) /* XP */, "Expected STATUS_SUCCESS, got %08x\n", status);
1175 
1176  memset(&pvi, 0, sizeof(pvi));
1178  status = pNtQueryInformationProcess(process, ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1179  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1180 
1181  /* Check if we have some return values */
1182  dump_vm_counters("VM counters for GetCurrentProcessId", &pvi);
1183  ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n");
1184  ok( pvi.PagefileUsage > 0, "Expected a PagefileUsage > 0\n");
1185 
1187 
1188  /* Check if we have real counters */
1189  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1190  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1191  prev_size = pvi.VirtualSize;
1192  if (winetest_debug > 1)
1193  dump_vm_counters("VM counters before VirtualAlloc", &pvi);
1195  ok( ptr != NULL, "VirtualAlloc failed, err %u\n", GetLastError());
1196  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1197  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1198  if (winetest_debug > 1)
1199  dump_vm_counters("VM counters after VirtualAlloc", &pvi);
1200  todo_wine ok( pvi.VirtualSize >= prev_size + alloc_size,
1201  "Expected to be greater than %lu, got %lu\n", prev_size + alloc_size, pvi.VirtualSize);
1202  VirtualFree( ptr, 0, MEM_RELEASE);
1203 
1204  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1205  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1206  prev_size = pvi.VirtualSize;
1207  if (winetest_debug > 1)
1208  dump_vm_counters("VM counters before VirtualAlloc", &pvi);
1209  ptr = VirtualAlloc(NULL, alloc_size, MEM_RESERVE, PAGE_READWRITE);
1210  ok( ptr != NULL, "VirtualAlloc failed, err %u\n", GetLastError());
1211  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1212  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1213  if (winetest_debug > 1)
1214  dump_vm_counters("VM counters after VirtualAlloc(MEM_RESERVE)", &pvi);
1215  todo_wine ok( pvi.VirtualSize >= prev_size + alloc_size,
1216  "Expected to be greater than %lu, got %lu\n", prev_size + alloc_size, pvi.VirtualSize);
1217  prev_size = pvi.VirtualSize;
1218 
1219  ptr = VirtualAlloc(ptr, alloc_size, MEM_COMMIT, PAGE_READWRITE);
1220  ok( ptr != NULL, "VirtualAlloc failed, err %u\n", GetLastError());
1221  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), NULL);
1222  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1223  if (winetest_debug > 1)
1224  dump_vm_counters("VM counters after VirtualAlloc(MEM_COMMIT)", &pvi);
1225  ok( pvi.VirtualSize == prev_size,
1226  "Expected to equal to %lu, got %lu\n", prev_size, pvi.VirtualSize);
1227  VirtualFree( ptr, 0, MEM_RELEASE);
1228 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define CloseHandle
Definition: compat.h:487
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:158
LONG NTSTATUS
Definition: precomp.h:26
SIZE_T PagefileUsage
Definition: winternl.h:1614
static HANDLE process
Definition: process.c:76
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
SIZE_T VirtualSize
Definition: winternl.h:1606
#define MEM_COMMIT
Definition: nt_native.h:1313
int winetest_debug
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
LPVOID NTAPI VirtualAlloc(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flAllocationType, IN DWORD flProtect)
Definition: virtmem.c:74
#define FALSE
Definition: types.h:117
#define MEM_RESERVE
Definition: nt_native.h:1314
static PVOID ptr
Definition: dispmode.c:27
#define PROCESS_QUERY_LIMITED_INFORMATION
Definition: security.c:45
smooth NULL
Definition: ftsmooth.c:416
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define todo_wine
Definition: test.h:162
#define GetCurrentProcess()
Definition: compat.h:507
#define broken(x)
Definition: _sntprintf.h:21
ULONG_PTR SIZE_T
Definition: typedefs.h:80
SIZE_T WorkingSetSize
Definition: winternl.h:1609
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define PROCESS_VM_READ
Definition: pstypes.h:153
#define MEM_RELEASE
Definition: nt_native.h:1316
unsigned int ULONG
Definition: retypes.h:1
BOOL NTAPI VirtualFree(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD dwFreeType)
Definition: virtmem.c:128
static void dump_vm_counters(const char *header, const VM_COUNTERS *pvi)
Definition: info.c:1111
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
DWORD WINAPI GetCurrentProcessId(VOID)
Definition: proc.c:1158
#define PAGE_READWRITE
Definition: nt_native.h:1304
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_process_wow64()

static void test_query_process_wow64 ( void  )
static

Definition at line 964 of file info.c.

965 {
968  ULONG_PTR pbi[2], dummy;
969 
970  memset(&dummy, 0xcc, sizeof(dummy));
971 
972  /* Do not give a handle and buffer */
973  status = pNtQueryInformationProcess(NULL, ProcessWow64Information, NULL, 0, NULL);
974  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
975 
976  /* Use a correct info class and buffer size, but still no handle and buffer */
977  status = pNtQueryInformationProcess(NULL, ProcessWow64Information, NULL, sizeof(ULONG_PTR), NULL);
979  "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE, got %08x\n", status);
980 
981  /* Use a correct info class, buffer size and handle, but no buffer */
982  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, NULL, sizeof(ULONG_PTR), NULL);
983  ok( status == STATUS_ACCESS_VIOLATION , "Expected STATUS_ACCESS_VIOLATION, got %08x\n", status);
984 
985  /* Use a correct info class, buffer and buffer size, but no handle */
986  pbi[0] = pbi[1] = dummy;
987  status = pNtQueryInformationProcess(NULL, ProcessWow64Information, pbi, sizeof(ULONG_PTR), NULL);
988  ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08x\n", status);
989  ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
990  ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
991 
992  /* Use a greater buffer size */
993  pbi[0] = pbi[1] = dummy;
994  status = pNtQueryInformationProcess(NULL, ProcessWow64Information, pbi, sizeof(ULONG_PTR) + 1, NULL);
995  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
996  ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
997  ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
998 
999  /* Use no ReturnLength */
1000  pbi[0] = pbi[1] = dummy;
1001  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR), NULL);
1002  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1003  trace( "Platform is_wow64 %d, ProcessInformation of ProcessWow64Information %lx\n", is_wow64, pbi[0]);
1004  ok( is_wow64 == (pbi[0] != 0), "is_wow64 %x, pbi[0] %lx\n", is_wow64, pbi[0]);
1005  ok( pbi[0] != dummy, "pbi[0] %lx\n", pbi[0]);
1006  ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
1007  /* Test written size on 64 bit by checking high 32 bit buffer */
1008  if (sizeof(ULONG_PTR) > sizeof(DWORD))
1009  {
1010  DWORD *ptr = (DWORD *)pbi;
1011  ok( ptr[1] != (DWORD)dummy, "ptr[1] unchanged!\n");
1012  }
1013 
1014  /* Finally some correct calls */
1015  pbi[0] = pbi[1] = dummy;
1016  ReturnLength = 0xdeadbeef;
1017  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR), &ReturnLength);
1018  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
1019  ok( is_wow64 == (pbi[0] != 0), "is_wow64 %x, pbi[0] %lx\n", is_wow64, pbi[0]);
1020  ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
1021  ok( ReturnLength == sizeof(ULONG_PTR), "Inconsistent length %d\n", ReturnLength);
1022 
1023  /* Everything is correct except a too small buffer size */
1024  pbi[0] = pbi[1] = dummy;
1025  ReturnLength = 0xdeadbeef;
1026  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR) - 1, &ReturnLength);
1027  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1028  ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
1029  ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
1030  todo_wine ok( ReturnLength == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", ReturnLength);
1031 
1032  /* Everything is correct except a too large buffer size */
1033  pbi[0] = pbi[1] = dummy;
1034  ReturnLength = 0xdeadbeef;
1035  status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessWow64Information, pbi, sizeof(ULONG_PTR) + 1, &ReturnLength);
1036  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
1037  ok( pbi[0] == dummy, "pbi[0] changed to %lx\n", pbi[0]);
1038  ok( pbi[1] == dummy, "pbi[1] changed to %lx\n", pbi[1]);
1039  todo_wine ok( ReturnLength == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", ReturnLength);
1040 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
uint32_t ULONG_PTR
Definition: typedefs.h:65
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
_Inout_ PERBANDINFO * pbi
Definition: winddi.h:3917
#define trace
Definition: atltest.h:70
unsigned long DWORD
Definition: ntddk_ex.h:95
#define todo_wine
Definition: test.h:162
#define GetCurrentProcess()
Definition: compat.h:507
static SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX DWORD *static BOOL is_wow64
Definition: info.c:41
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
unsigned char dummy
Definition: maze.c:118
#define ok(value,...)
Definition: atltest.h:57
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_processor_power_info()

static void test_query_processor_power_info ( void  )
static

Definition at line 891 of file info.c.

892 {
895  ULONG size;
896  SYSTEM_INFO si;
897  int i;
898 
899  GetSystemInfo(&si);
901  ppi = HeapAlloc(GetProcessHeap(), 0, size);
902 
903  /* If size < (sizeof(PROCESSOR_POWER_INFORMATION) * NumberOfProcessors), Win7 returns
904  * STATUS_BUFFER_TOO_SMALL. WinXP returns STATUS_SUCCESS for any value of size. It copies as
905  * many whole PROCESSOR_POWER_INFORMATION structures that there is room for. Even if there is
906  * not enough room for one structure, WinXP still returns STATUS_SUCCESS having done nothing.
907  *
908  * If ppi == NULL, Win7 returns STATUS_INVALID_PARAMETER while WinXP returns STATUS_SUCCESS
909  * and does nothing.
910  *
911  * The same behavior is seen with CallNtPowerInformation (in powrprof.dll).
912  */
913 
914  if (si.dwNumberOfProcessors > 1)
915  {
916  for(i = 0; i < si.dwNumberOfProcessors; i++)
917  ppi[i].Number = 0xDEADBEEF;
918 
919  /* Call with a buffer size that is large enough to hold at least one but not large
920  * enough to hold them all. This will be STATUS_SUCCESS on WinXP but not on Win7 */
921  status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, size - sizeof(PROCESSOR_POWER_INFORMATION));
922  if (status == STATUS_SUCCESS)
923  {
924  /* lax version found on older Windows like WinXP */
925  ok( (ppi[si.dwNumberOfProcessors - 2].Number != 0xDEADBEEF) &&
926  (ppi[si.dwNumberOfProcessors - 1].Number == 0xDEADBEEF),
927  "Expected all but the last record to be overwritten.\n");
928 
929  status = pNtPowerInformation(ProcessorInformation, 0, 0, 0, size);
930  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
931 
932  for(i = 0; i < si.dwNumberOfProcessors; i++)
933  ppi[i].Number = 0xDEADBEEF;
934  status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, sizeof(PROCESSOR_POWER_INFORMATION) - 1);
935  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
936  for(i = 0; i < si.dwNumberOfProcessors; i++)
937  if (ppi[i].Number != 0xDEADBEEF) break;
938  ok( i == si.dwNumberOfProcessors, "Expected untouched buffer\n");
939  }
940  else
941  {
942  /* picky version found on newer Windows like Win7 */
943  ok( ppi[1].Number == 0xDEADBEEF, "Expected untouched buffer.\n");
944  ok( status == STATUS_BUFFER_TOO_SMALL, "Expected STATUS_BUFFER_TOO_SMALL, got %08x\n", status);
945 
946  status = pNtPowerInformation(ProcessorInformation, 0, 0, 0, size);
947  ok( status == STATUS_SUCCESS || status == STATUS_INVALID_PARAMETER, "Got %08x\n", status);
948 
949  status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, 0);
951  }
952  }
953  else
954  {
955  skip("Test needs more than one processor.\n");
956  }
957 
958  status = pNtPowerInformation(ProcessorInformation, 0, 0, ppi, size);
959  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
960 
961  HeapFree(GetProcessHeap(), 0, ppi);
962 }
struct _PROCESSOR_POWER_INFORMATION PROCESSOR_POWER_INFORMATION
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:204
#define ok(value,...)
Definition: atltest.h:57
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:142
#define skip(...)
Definition: atltest.h:64
DWORD dwNumberOfProcessors
Definition: winbase.h:1143
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:3014
static SERVICE_STATUS status
Definition: service.c:31
#define HeapFree(x, y, z)
Definition: compat.h:483
Definition: ps.c:97

Referenced by START_TEST().

◆ test_query_procperf()

static void test_query_procperf ( void  )
static

Definition at line 388 of file info.c.

389 {
392  ULONG NeededLength;
395 
396  /* Find out the number of processors */
397  status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
398  ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
400 
401  sppi = HeapAlloc(GetProcessHeap(), 0, NeededLength);
402 
403  status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, 0, &ReturnLength);
404  ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
405 
406  /* Try it for 1 processor */
407  sppi->KernelTime.QuadPart = 0xdeaddead;
408  sppi->UserTime.QuadPart = 0xdeaddead;
409  sppi->IdleTime.QuadPart = 0xdeaddead;
410  status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi,
412  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
414  "Inconsistent length %d\n", ReturnLength);
415  ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
416  ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
417  ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
418 
419  /* Try it for all processors */
420  sppi->KernelTime.QuadPart = 0xdeaddead;
421  sppi->UserTime.QuadPart = 0xdeaddead;
422  sppi->IdleTime.QuadPart = 0xdeaddead;
423  status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength, &ReturnLength);
424  ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
425  ok( NeededLength == ReturnLength, "Inconsistent length (%d) <-> (%d)\n", NeededLength, ReturnLength);
426  ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
427  ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
428  ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
429 
430  /* A too large given buffer size */
431  sppi = HeapReAlloc(GetProcessHeap(), 0, sppi , NeededLength + 2);
432  sppi->KernelTime.QuadPart = 0xdeaddead;
433  sppi->UserTime.QuadPart = 0xdeaddead;
434  sppi->IdleTime.QuadPart = 0xdeaddead;
435  status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength + 2, &ReturnLength);
437  "Expected STATUS_SUCCESS or STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
438  ok( NeededLength == ReturnLength, "Inconsistent length (%d) <-> (%d)\n", NeededLength, ReturnLength);
439  if (status == STATUS_SUCCESS)
440  {
441  ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
442  ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
443  ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
444  }
445  else /* vista and 2008 */
446  {
447  ok (sppi->KernelTime.QuadPart == 0xdeaddead, "KernelTime changed\n");
448  ok (sppi->UserTime.QuadPart == 0xdeaddead, "UserTime changed\n");
449  ok (sppi->IdleTime.QuadPart == 0xdeaddead, "IdleTime changed\n");
450  }
451 
452  HeapFree( GetProcessHeap(), 0, sppi);
453 }
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONG NTSTATUS
Definition: precomp.h:26
struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define ok(value,...)
Definition: atltest.h:57
#define HeapReAlloc
Definition: