modules/rostests/winetests/psapi/psapi_main.c

   1 /*
   2  * Unit test suite for PSAPI
   3  *
   4  * Copyright (C) 2005 Felix Nawothnig
   5  * Copyright (C) 2012 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winreg.h"
  30 #include "winnt.h"
  31 #include "wine/winternl.h"
  32 #include "winnls.h"
  33 #include "psapi.h"
  34 #include "wine/test.h"
  35
  36 #define PSAPI_GET_PROC(func) \
  37     p ## func = (void*)GetProcAddress(hpsapi, #func); \
  38     if(!p ## func) { \
  39         ok(0, "GetProcAddress(%s) failed\n", #func); \
  40         FreeLibrary(hpsapi); \
  41         return FALSE; \
  42     }
  43
  44 static BOOL  (WINAPI *pEmptyWorkingSet)(HANDLE);
  45 static BOOL  (WINAPI *pEnumProcesses)(DWORD*, DWORD, DWORD*);
  46 static BOOL  (WINAPI *pEnumProcessModules)(HANDLE, HMODULE*, DWORD, LPDWORD);
  47 static DWORD (WINAPI *pGetModuleBaseNameA)(HANDLE, HMODULE, LPSTR, DWORD);
  48 static DWORD (WINAPI *pGetModuleFileNameExA)(HANDLE, HMODULE, LPSTR, DWORD);
  49 static DWORD (WINAPI *pGetModuleFileNameExW)(HANDLE, HMODULE, LPWSTR, DWORD);
  50 static BOOL  (WINAPI *pGetModuleInformation)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
  51 static DWORD (WINAPI *pGetMappedFileNameA)(HANDLE, LPVOID, LPSTR, DWORD);
  52 static DWORD (WINAPI *pGetMappedFileNameW)(HANDLE, LPVOID, LPWSTR, DWORD);
  53 static BOOL  (WINAPI *pGetPerformanceInfo)(PPERFORMANCE_INFORMATION, DWORD);
  54 static DWORD (WINAPI *pGetProcessImageFileNameA)(HANDLE, LPSTR, DWORD);
  55 static DWORD (WINAPI *pGetProcessImageFileNameW)(HANDLE, LPWSTR, DWORD);
  56 static BOOL  (WINAPI *pGetProcessMemoryInfo)(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD);
  57 static BOOL  (WINAPI *pGetWsChanges)(HANDLE, PPSAPI_WS_WATCH_INFORMATION, DWORD);
  58 static BOOL  (WINAPI *pInitializeProcessForWsWatch)(HANDLE);
  59 static BOOL  (WINAPI *pQueryWorkingSet)(HANDLE, PVOID, DWORD);
  60 static NTSTATUS (WINAPI *pNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG);
  61 static NTSTATUS (WINAPI *pNtQueryVirtualMemory)(HANDLE, LPCVOID, ULONG, PVOID, SIZE_T, SIZE_T *);
  62
  63 static BOOL InitFunctionPtrs(HMODULE hpsapi)
  64 {
  65     PSAPI_GET_PROC(EmptyWorkingSet);
  66     PSAPI_GET_PROC(EnumProcessModules);
  67     PSAPI_GET_PROC(EnumProcesses);
  68     PSAPI_GET_PROC(GetModuleBaseNameA);
  69     PSAPI_GET_PROC(GetModuleFileNameExA);
  70     PSAPI_GET_PROC(GetModuleFileNameExW);
  71     PSAPI_GET_PROC(GetModuleInformation);
  72     PSAPI_GET_PROC(GetMappedFileNameA);
  73     PSAPI_GET_PROC(GetMappedFileNameW);
  74     PSAPI_GET_PROC(GetProcessMemoryInfo);
  75     PSAPI_GET_PROC(GetWsChanges);
  76     PSAPI_GET_PROC(InitializeProcessForWsWatch);
  77     PSAPI_GET_PROC(QueryWorkingSet);
  78     /* GetProcessImageFileName is not exported on NT4 */
  79     pGetPerformanceInfo =
  80       (void *)GetProcAddress(hpsapi, "GetPerformanceInfo");
  81     pGetProcessImageFileNameA =
  82       (void *)GetProcAddress(hpsapi, "GetProcessImageFileNameA");
  83     pGetProcessImageFileNameW =
  84       (void *)GetProcAddress(hpsapi, "GetProcessImageFileNameW");
  85     pNtQuerySystemInformation = (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtQuerySystemInformation");
  86     pNtQueryVirtualMemory = (void *)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtQueryVirtualMemory");
  87     return TRUE;
  88 }
  89
  90 static HANDLE hpSR, hpQI, hpVR, hpQV, hpAA;
  91 static const HANDLE hBad = (HANDLE)0xdeadbeef;
  92
  93 static void test_EnumProcesses(void)
  94 {
  95     DWORD pid, ret, cbUsed = 0xdeadbeef;
  96
  97     SetLastError(0xdeadbeef);
  98     ret = pEnumProcesses(NULL, 0, &cbUsed);
  99     ok(ret == 1, "failed with %d\n", GetLastError());
 100     ok(cbUsed == 0, "cbUsed=%d\n", cbUsed);
 101
 102     SetLastError(0xdeadbeef);
 103     ret = pEnumProcesses(&pid, 4, &cbUsed);
 104     ok(ret == 1, "failed with %d\n", GetLastError());
 105     ok(cbUsed == 4, "cbUsed=%d\n", cbUsed);
 106 }
 107
 108 static void test_EnumProcessModules(void)
 109 {
 110     HMODULE hMod = GetModuleHandleA(NULL);
 111     DWORD ret, cbNeeded = 0xdeadbeef;
 112
 113     SetLastError(0xdeadbeef);
 114     pEnumProcessModules(NULL, NULL, 0, &cbNeeded);
 115     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 116
 117     SetLastError(0xdeadbeef);
 118     pEnumProcessModules(hpQI, NULL, 0, &cbNeeded);
 119     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 120
 121     SetLastError(0xdeadbeef);
 122     ret = pEnumProcessModules(hpQI, &hMod, sizeof(HMODULE), NULL);
 123     ok(!ret, "succeeded\n");
 124     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 125
 126     SetLastError(0xdeadbeef);
 127     ret = pEnumProcessModules(hpQV, &hMod, sizeof(HMODULE), NULL);
 128     ok(!ret, "succeeded\n");
 129     ok(GetLastError() == ERROR_NOACCESS, "expected error=ERROR_NOACCESS but got %d\n", GetLastError());
 130
 131     SetLastError(0xdeadbeef);
 132     ret = pEnumProcessModules(hpQV, NULL, 0, &cbNeeded);
 133     ok(ret == 1, "failed with %d\n", GetLastError());
 134
 135     SetLastError(0xdeadbeef);
 136     ret = pEnumProcessModules(hpQV, NULL, sizeof(HMODULE), &cbNeeded);
 137     ok(!ret, "succeeded\n");
 138     ok(GetLastError() == ERROR_NOACCESS, "expected error=ERROR_NOACCESS but got %d\n", GetLastError());
 139
 140     SetLastError(0xdeadbeef);
 141     ret = pEnumProcessModules(hpQV, &hMod, sizeof(HMODULE), &cbNeeded);
 142     if(ret != 1)
 143         return;
 144     ok(hMod == GetModuleHandleA(NULL),
 145        "hMod=%p GetModuleHandleA(NULL)=%p\n", hMod, GetModuleHandleA(NULL));
 146     ok(cbNeeded % sizeof(hMod) == 0, "not a multiple of sizeof(HMODULE) cbNeeded=%d\n", cbNeeded);
 147 }
 148
 149 static void test_GetModuleInformation(void)
 150 {
 151     HMODULE hMod = GetModuleHandleA(NULL);
 152     MODULEINFO info;
 153     DWORD ret;
 154
 155     SetLastError(0xdeadbeef);
 156     pGetModuleInformation(NULL, hMod, &info, sizeof(info));
 157     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 158
 159     SetLastError(0xdeadbeef);
 160     pGetModuleInformation(hpQI, hMod, &info, sizeof(info));
 161     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 162
 163     SetLastError(0xdeadbeef);
 164     pGetModuleInformation(hpQV, hBad, &info, sizeof(info));
 165     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 166
 167     SetLastError(0xdeadbeef);
 168     pGetModuleInformation(hpQV, hMod, &info, sizeof(info)-1);
 169     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 170
 171     SetLastError(0xdeadbeef);
 172     ret = pGetModuleInformation(hpQV, hMod, &info, sizeof(info));
 173     ok(ret == 1, "failed with %d\n", GetLastError());
 174     ok(info.lpBaseOfDll == hMod, "lpBaseOfDll=%p hMod=%p\n", info.lpBaseOfDll, hMod);
 175 }
 176
 177 static BOOL check_with_margin(SIZE_T perf, SIZE_T sysperf, int margin)
 178 {
 179     return (perf >= max(sysperf, margin) - margin && perf <= sysperf + margin);
 180 }
 181
 182 static void test_GetPerformanceInfo(void)
 183 {
 184     PERFORMANCE_INFORMATION info;
 185     NTSTATUS status;
 186     DWORD size;
 187     BOOL ret;
 188
 189     SetLastError(0xdeadbeef);
 190     ret = pGetPerformanceInfo(&info, sizeof(info)-1);
 191     ok(!ret, "GetPerformanceInfo unexpectedly succeeded\n");
 192     ok(GetLastError() == ERROR_BAD_LENGTH, "expected error=ERROR_BAD_LENGTH but got %d\n", GetLastError());
 193
 194     SetLastError(0xdeadbeef);
 195     ret = pGetPerformanceInfo(&info, sizeof(info));
 196     ok(ret, "GetPerformanceInfo failed with %d\n", GetLastError());
 197     ok(info.cb == sizeof(PERFORMANCE_INFORMATION), "got %d\n", info.cb);
 198
 199     if (!pNtQuerySystemInformation)
 200         win_skip("NtQuerySystemInformation not found, skipping tests\n");
 201     else
 202     {
 203         char performance_buffer[sizeof(SYSTEM_PERFORMANCE_INFORMATION) + 16]; /* larger on w2k8/win7 */
 204         SYSTEM_PERFORMANCE_INFORMATION *sys_performance_info = (SYSTEM_PERFORMANCE_INFORMATION *)performance_buffer;
 205         SYSTEM_PROCESS_INFORMATION *sys_process_info = NULL, *spi;
 206         SYSTEM_BASIC_INFORMATION sys_basic_info;
 207         DWORD process_count, handle_count, thread_count;
 208
 209         /* compare with values from SYSTEM_PERFORMANCE_INFORMATION */
 210         size = 0;
 211         status = pNtQuerySystemInformation(SystemPerformanceInformation, sys_performance_info, sizeof(performance_buffer), &size);
 212         ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
 213         ok(size >= sizeof(SYSTEM_PERFORMANCE_INFORMATION), "incorrect length %d\n", size);
 214
 215
 216         ok(check_with_margin(info.CommitTotal,          sys_performance_info->TotalCommittedPages,  288),
 217            "expected approximately %ld but got %d\n", info.CommitTotal, sys_performance_info->TotalCommittedPages);
 218
 219         ok(check_with_margin(info.CommitLimit,          sys_performance_info->TotalCommitLimit,     32),
 220            "expected approximately %ld but got %d\n", info.CommitLimit, sys_performance_info->TotalCommitLimit);
 221
 222         ok(check_with_margin(info.CommitPeak,           sys_performance_info->PeakCommitment,       32),
 223            "expected approximately %ld but got %d\n", info.CommitPeak, sys_performance_info->PeakCommitment);
 224
 225         ok(check_with_margin(info.PhysicalAvailable,    sys_performance_info->AvailablePages,       128),
 226            "expected approximately %ld but got %d\n", info.PhysicalAvailable, sys_performance_info->AvailablePages);
 227
 228         /* TODO: info.SystemCache not checked yet - to which field(s) does this value correspond to? */
 229
 230         ok(check_with_margin(info.KernelTotal, sys_performance_info->PagedPoolUsage + sys_performance_info->NonPagedPoolUsage, 64),
 231            "expected approximately %ld but got %d\n", info.KernelTotal,
 232            sys_performance_info->PagedPoolUsage + sys_performance_info->NonPagedPoolUsage);
 233
 234         ok(check_with_margin(info.KernelPaged,          sys_performance_info->PagedPoolUsage,       64),
 235            "expected approximately %ld but got %d\n", info.KernelPaged, sys_performance_info->PagedPoolUsage);
 236
 237         ok(check_with_margin(info.KernelNonpaged,       sys_performance_info->NonPagedPoolUsage,    8),
 238            "expected approximately %ld but got %d\n", info.KernelNonpaged, sys_performance_info->NonPagedPoolUsage);
 239
 240         /* compare with values from SYSTEM_BASIC_INFORMATION */
 241         size = 0;
 242         status = pNtQuerySystemInformation(SystemBasicInformation, &sys_basic_info, sizeof(sys_basic_info), &size);
 243         ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
 244         ok(size >= sizeof(SYSTEM_BASIC_INFORMATION), "incorrect length %d\n", size);
 245
 246         ok(info.PhysicalTotal == sys_basic_info.MmNumberOfPhysicalPages,
 247            "expected info.PhysicalTotal=%u but got %u\n",
 248            sys_basic_info.MmNumberOfPhysicalPages, (ULONG)info.PhysicalTotal);
 249
 250         ok(info.PageSize == sys_basic_info.PageSize,
 251            "expected info.PageSize=%u but got %u\n",
 252            sys_basic_info.PageSize, (ULONG)info.PageSize);
 253
 254         /* compare with values from SYSTEM_PROCESS_INFORMATION */
 255         size = 0;
 256         status = pNtQuerySystemInformation(SystemProcessInformation, NULL, 0, &size);
 257         ok(status == STATUS_INFO_LENGTH_MISMATCH, "expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
 258         ok(size > 0, "incorrect length %d\n", size);
 259         while (status == STATUS_INFO_LENGTH_MISMATCH)
 260         {
 261             sys_process_info = HeapAlloc(GetProcessHeap(), 0, size);
 262             ok(sys_process_info != NULL, "failed to allocate memory\n");
 263             status = pNtQuerySystemInformation(SystemProcessInformation, sys_process_info, size, &size);
 264             if (status == STATUS_SUCCESS) break;
 265             HeapFree(GetProcessHeap(), 0, sys_process_info);
 266         }
 267         ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
 268
 269         process_count = handle_count = thread_count = 0;
 270         for (spi = sys_process_info;; spi = (SYSTEM_PROCESS_INFORMATION *)(((char *)spi) + spi->NextEntryOffset))
 271         {
 272             process_count++;
 273             handle_count += spi->HandleCount;
 274             thread_count += spi->dwThreadCount;
 275             if (spi->NextEntryOffset == 0) break;
 276         }
 277         HeapFree(GetProcessHeap(), 0, sys_process_info);
 278
 279         ok(check_with_margin(info.HandleCount,  handle_count,  24),
 280            "expected approximately %d but got %d\n", info.HandleCount, handle_count);
 281
 282         ok(check_with_margin(info.ProcessCount, process_count, 4),
 283            "expected approximately %d but got %d\n", info.ProcessCount, process_count);
 284
 285         ok(check_with_margin(info.ThreadCount,  thread_count,  4),
 286            "expected approximately %d but got %d\n", info.ThreadCount, thread_count);
 287     }
 288 }
 289
 290
 291 static void test_GetProcessMemoryInfo(void)
 292 {
 293     PROCESS_MEMORY_COUNTERS pmc;
 294     DWORD ret;
 295
 296     SetLastError(0xdeadbeef);
 297     ret = pGetProcessMemoryInfo(NULL, &pmc, sizeof(pmc));
 298     ok(!ret, "GetProcessMemoryInfo should fail\n");
 299     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 300
 301     SetLastError(0xdeadbeef);
 302     ret = pGetProcessMemoryInfo(hpSR, &pmc, sizeof(pmc));
 303     ok(!ret, "GetProcessMemoryInfo should fail\n");
 304     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 305
 306     SetLastError(0xdeadbeef);
 307     ret = pGetProcessMemoryInfo(hpQI, &pmc, sizeof(pmc)-1);
 308     ok(!ret, "GetProcessMemoryInfo should fail\n");
 309     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 310
 311     SetLastError(0xdeadbeef);
 312     ret = pGetProcessMemoryInfo(hpQI, &pmc, sizeof(pmc));
 313     ok(ret == 1, "failed with %d\n", GetLastError());
 314 }
 315
 316 static BOOL nt_get_mapped_file_name(HANDLE process, LPVOID addr, LPWSTR name, DWORD len)
 317 {
 318     MEMORY_SECTION_NAME *section_name;
 319     WCHAR *buf;
 320     SIZE_T buf_len, ret_len;
 321     NTSTATUS status;
 322
 323     if (!pNtQueryVirtualMemory) return FALSE;
 324
 325     buf_len = len * sizeof(WCHAR) + sizeof(MEMORY_SECTION_NAME);
 326     buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buf_len);
 327
 328     ret_len = 0xdeadbeef;
 329     status = pNtQueryVirtualMemory(process, addr, MemorySectionName, buf, buf_len, &ret_len);
 330     ok(!status, "NtQueryVirtualMemory error %x\n", status);
 331
 332     section_name = (MEMORY_SECTION_NAME *)buf;
 333     ok(ret_len == section_name->SectionFileName.MaximumLength + sizeof(*section_name), "got %lu, %u\n",
 334        ret_len, section_name->SectionFileName.MaximumLength);
 335     ok((char *)section_name->SectionFileName.Buffer == (char *)section_name + sizeof(*section_name), "got %p, %p\n",
 336        section_name, section_name->SectionFileName.Buffer);
 337     ok(section_name->SectionFileName.MaximumLength == section_name->SectionFileName.Length + sizeof(WCHAR), "got %u, %u\n",
 338        section_name->SectionFileName.MaximumLength, section_name->SectionFileName.Length);
 339     ok(section_name->SectionFileName.Length == lstrlenW(section_name->SectionFileName.Buffer) * sizeof(WCHAR), "got %u, %u\n",
 340        section_name->SectionFileName.Length, lstrlenW(section_name->SectionFileName.Buffer));
 341
 342     memcpy(name, section_name->SectionFileName.Buffer, section_name->SectionFileName.MaximumLength);
 343     HeapFree(GetProcessHeap(), 0, buf);
 344     return TRUE;
 345 }
 346
 347 static void test_GetMappedFileName(void)
 348 {
 349     HMODULE hMod = GetModuleHandleA(NULL);
 350     char szMapPath[MAX_PATH], szModPath[MAX_PATH], *szMapBaseName;
 351     DWORD ret;
 352     char *base;
 353     char temp_path[MAX_PATH], file_name[MAX_PATH], map_name[MAX_PATH], device_name[MAX_PATH], drive[3];
 354     WCHAR map_nameW[MAX_PATH], nt_map_name[MAX_PATH];
 355     HANDLE hfile, hmap;
 356     HANDLE current_process;
 357
 358     DuplicateHandle( GetCurrentProcess(), GetCurrentProcess(),
 359                      GetCurrentProcess(), &current_process, 0, 0, DUPLICATE_SAME_ACCESS );
 360
 361     SetLastError(0xdeadbeef);
 362     ret = pGetMappedFileNameA(NULL, hMod, szMapPath, sizeof(szMapPath));
 363     ok(!ret, "GetMappedFileName should fail\n");
 364     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 365
 366     SetLastError(0xdeadbeef);
 367     ret = pGetMappedFileNameA(hpSR, hMod, szMapPath, sizeof(szMapPath));
 368     ok(!ret, "GetMappedFileName should fail\n");
 369     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 370
 371     SetLastError( 0xdeadbeef );
 372     ret = pGetMappedFileNameA(hpQI, hMod, szMapPath, sizeof(szMapPath));
 373     ok( ret || broken(GetLastError() == ERROR_UNEXP_NET_ERR), /* win2k */
 374         "GetMappedFileNameA failed with error %u\n", GetLastError() );
 375     if (ret)
 376     {
 377         ok(ret == strlen(szMapPath), "szMapPath=\"%s\" ret=%d\n", szMapPath, ret);
 378         ok(szMapPath[0] == '\\', "szMapPath=\"%s\"\n", szMapPath);
 379         szMapBaseName = strrchr(szMapPath, '\\'); /* That's close enough for us */
 380         ok(szMapBaseName && *szMapBaseName, "szMapPath=\"%s\"\n", szMapPath);
 381         if (szMapBaseName)
 382         {
 383             GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 384             ok(!strcmp(strrchr(szModPath, '\\'), szMapBaseName),
 385                "szModPath=\"%s\" szMapBaseName=\"%s\"\n", szModPath, szMapBaseName);
 386         }
 387     }
 388
 389     GetTempPathA(MAX_PATH, temp_path);
 390     GetTempFileNameA(temp_path, "map", 0, file_name);
 391
 392     drive[0] = file_name[0];
 393     drive[1] = ':';
 394     drive[2] = 0;
 395     SetLastError(0xdeadbeef);
 396     ret = QueryDosDeviceA(drive, device_name, sizeof(device_name));
 397     ok(ret, "QueryDosDeviceA error %d\n", GetLastError());
 398     trace("%s -> %s\n", drive, device_name);
 399
 400     SetLastError(0xdeadbeef);
 401     hfile = CreateFileA(file_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 402     ok(hfile != INVALID_HANDLE_VALUE, "CreateFileA(%s) error %d\n", file_name, GetLastError());
 403     SetFilePointer(hfile, 0x4000, NULL, FILE_BEGIN);
 404     SetEndOfFile(hfile);
 405
 406     SetLastError(0xdeadbeef);
 407     hmap = CreateFileMappingA(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
 408     ok(hmap != 0, "CreateFileMappingA error %d\n", GetLastError());
 409
 410     SetLastError(0xdeadbeef);
 411     base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
 412     ok(base != NULL, "MapViewOfFile error %d\n", GetLastError());
 413
 414     SetLastError(0xdeadbeef);
 415     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, 0);
 416     ok(!ret, "GetMappedFileName should fail\n");
 417     ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 418        "wrong error %d\n", GetLastError());
 419
 420     SetLastError(0xdeadbeef);
 421     ret = pGetMappedFileNameA(GetCurrentProcess(), base, 0, sizeof(map_name));
 422     ok(!ret, "GetMappedFileName should fail\n");
 423     ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 424
 425     SetLastError(0xdeadbeef);
 426     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, 1);
 427     ok(ret == 1, "GetMappedFileName error %d\n", GetLastError());
 428     ok(!map_name[0] || broken(map_name[0] == device_name[0]) /* before win2k */, "expected 0, got %c\n", map_name[0]);
 429
 430     SetLastError(0xdeadbeef);
 431     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name));
 432     ok(ret, "GetMappedFileName error %d\n", GetLastError());
 433     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 434     ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 435
 436     SetLastError(0xdeadbeef);
 437     ret = pGetMappedFileNameW(GetCurrentProcess(), base, map_nameW, sizeof(map_nameW)/sizeof(map_nameW[0]));
 438     ok(ret, "GetMappedFileNameW error %d\n", GetLastError());
 439     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 440
 441     if (nt_get_mapped_file_name(GetCurrentProcess(), base, nt_map_name, sizeof(nt_map_name)/sizeof(nt_map_name[0])))
 442     {
 443         ok(memcmp(map_nameW, nt_map_name, lstrlenW(map_nameW)) == 0, "map name does not start with a device name: %s\n", map_name);
 444         WideCharToMultiByte(CP_ACP, 0, map_nameW, -1, map_name, MAX_PATH, NULL, NULL);
 445         ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 446     }
 447
 448     SetLastError(0xdeadbeef);
 449     ret = pGetMappedFileNameW(current_process, base, map_nameW, sizeof(map_nameW)/sizeof(map_nameW[0]));
 450     ok(ret, "GetMappedFileNameW error %d\n", GetLastError());
 451     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 452
 453     if (nt_get_mapped_file_name(current_process, base, nt_map_name, sizeof(nt_map_name)/sizeof(nt_map_name[0])))
 454     {
 455         ok(memcmp(map_nameW, nt_map_name, lstrlenW(map_nameW)) == 0, "map name does not start with a device name: %s\n", map_name);
 456         WideCharToMultiByte(CP_ACP, 0, map_nameW, -1, map_name, MAX_PATH, NULL, NULL);
 457         ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 458     }
 459
 460     SetLastError(0xdeadbeef);
 461     ret = pGetMappedFileNameA(GetCurrentProcess(), base + 0x2000, map_name, sizeof(map_name));
 462     ok(ret, "GetMappedFileName error %d\n", GetLastError());
 463     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 464     ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 465
 466     SetLastError(0xdeadbeef);
 467     ret = pGetMappedFileNameA(GetCurrentProcess(), base + 0x4000, map_name, sizeof(map_name));
 468     ok(!ret, "GetMappedFileName should fail\n");
 469     ok(GetLastError() == ERROR_UNEXP_NET_ERR, "expected ERROR_UNEXP_NET_ERR, got %d\n", GetLastError());
 470
 471     SetLastError(0xdeadbeef);
 472     ret = pGetMappedFileNameA(GetCurrentProcess(), NULL, map_name, sizeof(map_name));
 473     ok(!ret, "GetMappedFileName should fail\n");
 474 todo_wine
 475     ok(GetLastError() == ERROR_UNEXP_NET_ERR, "expected ERROR_UNEXP_NET_ERR, got %d\n", GetLastError());
 476
 477     SetLastError(0xdeadbeef);
 478     ret = pGetMappedFileNameA(0, base, map_name, sizeof(map_name));
 479     ok(!ret, "GetMappedFileName should fail\n");
 480     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 481
 482     UnmapViewOfFile(base);
 483     CloseHandle(hmap);
 484     CloseHandle(hfile);
 485     DeleteFileA(file_name);
 486
 487     SetLastError(0xdeadbeef);
 488     hmap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READONLY | SEC_COMMIT, 0, 4096, NULL);
 489     ok(hmap != 0, "CreateFileMappingA error %d\n", GetLastError());
 490
 491     SetLastError(0xdeadbeef);
 492     base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
 493     ok(base != NULL, "MapViewOfFile error %d\n", GetLastError());
 494
 495     SetLastError(0xdeadbeef);
 496     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name));
 497     ok(!ret, "GetMappedFileName should fail\n");
 498     ok(GetLastError() == ERROR_FILE_INVALID, "expected ERROR_FILE_INVALID, got %d\n", GetLastError());
 499
 500     CloseHandle(current_process);
 501     UnmapViewOfFile(base);
 502     CloseHandle(hmap);
 503 }
 504
 505 static void test_GetProcessImageFileName(void)
 506 {
 507     HMODULE hMod = GetModuleHandleA(NULL);
 508     char szImgPath[MAX_PATH], szMapPath[MAX_PATH];
 509     WCHAR szImgPathW[MAX_PATH];
 510     DWORD ret, ret1;
 511
 512     if(pGetProcessImageFileNameA == NULL)
 513         return;
 514
 515     /* This function is available on WinXP+ only */
 516     SetLastError(0xdeadbeef);
 517     if(!pGetProcessImageFileNameA(hpQI, szImgPath, sizeof(szImgPath)))
 518     {
 519         if(GetLastError() == ERROR_INVALID_FUNCTION) {
 520             win_skip("GetProcessImageFileName not implemented\n");
 521             return;
 522         }
 523
 524         if(GetLastError() == 0xdeadbeef)
 525             todo_wine ok(0, "failed without error code\n");
 526         else
 527             todo_wine ok(0, "failed with %d\n", GetLastError());
 528     }
 529
 530     SetLastError(0xdeadbeef);
 531     pGetProcessImageFileNameA(NULL, szImgPath, sizeof(szImgPath));
 532     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 533
 534     SetLastError(0xdeadbeef);
 535     pGetProcessImageFileNameA(hpSR, szImgPath, sizeof(szImgPath));
 536     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 537
 538     SetLastError(0xdeadbeef);
 539     pGetProcessImageFileNameA(hpQI, szImgPath, 0);
 540     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 541
 542     ret = pGetProcessImageFileNameA(hpQI, szImgPath, sizeof(szImgPath));
 543     ret1 = pGetMappedFileNameA(hpQV, hMod, szMapPath, sizeof(szMapPath));
 544     if(ret && ret1)
 545     {
 546         /* Windows returns 2*strlen-1 */
 547         ok(ret >= strlen(szImgPath), "szImgPath=\"%s\" ret=%d\n", szImgPath, ret);
 548         ok(!strcmp(szImgPath, szMapPath), "szImgPath=\"%s\" szMapPath=\"%s\"\n", szImgPath, szMapPath);
 549     }
 550
 551     SetLastError(0xdeadbeef);
 552     pGetProcessImageFileNameW(NULL, szImgPathW, sizeof(szImgPathW));
 553     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 554
 555     /* no information about correct buffer size returned: */
 556     SetLastError(0xdeadbeef);
 557     pGetProcessImageFileNameW(hpQI, szImgPathW, 0);
 558     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 559
 560     SetLastError(0xdeadbeef);
 561     pGetProcessImageFileNameW(hpQI, NULL, 0);
 562     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 563
 564     /* correct call */
 565     memset(szImgPathW, 0xff, sizeof(szImgPathW));
 566     ret = pGetProcessImageFileNameW(hpQI, szImgPathW, sizeof(szImgPathW)/sizeof(WCHAR));
 567     ok(ret > 0, "GetProcessImageFileNameW should have succeeded.\n");
 568     ok(szImgPathW[0] == '\\', "GetProcessImageFileNameW should have returned an NT path.\n");
 569     ok(lstrlenW(szImgPathW) == ret, "Expected length to be %d, got %d\n", ret, lstrlenW(szImgPathW));
 570
 571     /* boundary values of 'size' */
 572     SetLastError(0xdeadbeef);
 573     pGetProcessImageFileNameW(hpQI, szImgPathW, ret);
 574     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 575
 576     memset(szImgPathW, 0xff, sizeof(szImgPathW));
 577     ret = pGetProcessImageFileNameW(hpQI, szImgPathW, ret + 1);
 578     ok(ret > 0, "GetProcessImageFileNameW should have succeeded.\n");
 579     ok(szImgPathW[0] == '\\', "GetProcessImageFileNameW should have returned an NT path.\n");
 580     ok(lstrlenW(szImgPathW) == ret, "Expected length to be %d, got %d\n", ret, lstrlenW(szImgPathW));
 581 }
 582
 583 static void test_GetModuleFileNameEx(void)
 584 {
 585     HMODULE hMod = GetModuleHandleA(NULL);
 586     char szModExPath[MAX_PATH+1], szModPath[MAX_PATH+1];
 587     WCHAR buffer[MAX_PATH];
 588     DWORD ret;
 589
 590     SetLastError(0xdeadbeef);
 591     ret = pGetModuleFileNameExA(NULL, hMod, szModExPath, sizeof(szModExPath));
 592     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 593     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 594
 595     SetLastError(0xdeadbeef);
 596     ret = pGetModuleFileNameExA(hpQI, hMod, szModExPath, sizeof(szModExPath));
 597     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 598     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 599
 600     SetLastError(0xdeadbeef);
 601     ret = pGetModuleFileNameExA(hpQV, hBad, szModExPath, sizeof(szModExPath));
 602     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 603     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 604
 605     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, sizeof(szModExPath));
 606     if(!ret)
 607             return;
 608     ok(ret == strlen(szModExPath), "szModExPath=\"%s\" ret=%d\n", szModExPath, ret);
 609     GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 610     ok(!strncmp(szModExPath, szModPath, MAX_PATH),
 611        "szModExPath=\"%s\" szModPath=\"%s\"\n", szModExPath, szModPath);
 612
 613     SetLastError(0xdeadbeef);
 614     memset( szModExPath, 0xcc, sizeof(szModExPath) );
 615     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, 4 );
 616     ok( ret == 4 || ret == strlen(szModExPath), "wrong length %u\n", ret );
 617     ok( broken(szModExPath[3]) /*w2kpro*/ || strlen(szModExPath) == 3,
 618         "szModExPath=\"%s\" ret=%d\n", szModExPath, ret );
 619     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 620
 621     if (0) /* crashes on Windows 10 */
 622     {
 623         SetLastError(0xdeadbeef);
 624         ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, 0 );
 625         ok( ret == 0, "wrong length %u\n", ret );
 626         ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %d\n", GetLastError());
 627     }
 628
 629     SetLastError(0xdeadbeef);
 630     memset( buffer, 0xcc, sizeof(buffer) );
 631     ret = pGetModuleFileNameExW(hpQV, NULL, buffer, 4 );
 632     ok( ret == 4 || ret == lstrlenW(buffer), "wrong length %u\n", ret );
 633     ok( broken(buffer[3]) /*w2kpro*/ || lstrlenW(buffer) == 3,
 634         "buffer=%s ret=%d\n", wine_dbgstr_w(buffer), ret );
 635     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 636
 637     if (0) /* crashes on Windows 10 */
 638     {
 639         SetLastError(0xdeadbeef);
 640         buffer[0] = 0xcc;
 641         ret = pGetModuleFileNameExW(hpQV, NULL, buffer, 0 );
 642         ok( ret == 0, "wrong length %u\n", ret );
 643         ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 644         ok( buffer[0] == 0xcc, "buffer modified %s\n", wine_dbgstr_w(buffer) );
 645     }
 646 }
 647
 648 static void test_GetModuleBaseName(void)
 649 {
 650     HMODULE hMod = GetModuleHandleA(NULL);
 651     char szModPath[MAX_PATH], szModBaseName[MAX_PATH];
 652     DWORD ret;
 653
 654     SetLastError(0xdeadbeef);
 655     pGetModuleBaseNameA(NULL, hMod, szModBaseName, sizeof(szModBaseName));
 656     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 657
 658     SetLastError(0xdeadbeef);
 659     pGetModuleBaseNameA(hpQI, hMod, szModBaseName, sizeof(szModBaseName));
 660     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 661
 662     SetLastError(0xdeadbeef);
 663     pGetModuleBaseNameA(hpQV, hBad, szModBaseName, sizeof(szModBaseName));
 664     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 665
 666     ret = pGetModuleBaseNameA(hpQV, NULL, szModBaseName, sizeof(szModBaseName));
 667     if(!ret)
 668         return;
 669     ok(ret == strlen(szModBaseName), "szModBaseName=\"%s\" ret=%d\n", szModBaseName, ret);
 670     GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 671     ok(!strcmp(strrchr(szModPath, '\\') + 1, szModBaseName),
 672        "szModPath=\"%s\" szModBaseName=\"%s\"\n", szModPath, szModBaseName);
 673 }
 674
 675 static void test_ws_functions(void)
 676 {
 677     PSAPI_WS_WATCH_INFORMATION wswi[4096];
 678     ULONG_PTR pages[4096];
 679     char *addr;
 680     unsigned int i;
 681     BOOL ret;
 682
 683     SetLastError(0xdeadbeef);
 684     pEmptyWorkingSet(NULL);
 685     todo_wine ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 686
 687     SetLastError(0xdeadbeef);
 688     pEmptyWorkingSet(hpSR);
 689     todo_wine ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 690
 691     SetLastError(0xdeadbeef);
 692     ret = pEmptyWorkingSet(hpAA);
 693     ok(ret == 1, "failed with %d\n", GetLastError());
 694
 695     SetLastError( 0xdeadbeef );
 696     ret = pInitializeProcessForWsWatch( NULL );
 697     todo_wine ok( !ret, "InitializeProcessForWsWatch succeeded\n" );
 698     if (!ret)
 699     {
 700         if (GetLastError() == ERROR_INVALID_FUNCTION)  /* not supported on xp in wow64 mode */
 701         {
 702             trace( "InitializeProcessForWsWatch not supported\n" );
 703             return;
 704         }
 705         ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
 706     }
 707     SetLastError(0xdeadbeef);
 708     ret = pInitializeProcessForWsWatch(hpAA);
 709     ok(ret == 1, "failed with %d\n", GetLastError());
 710
 711     addr = VirtualAlloc(NULL, 1, MEM_COMMIT, PAGE_READWRITE);
 712     if(!addr)
 713         return;
 714
 715     *addr = 0; /* make sure it's paged in (needed on wow64) */
 716     if(!VirtualLock(addr, 1))
 717     {
 718         trace("locking failed (error=%d) - skipping test\n", GetLastError());
 719         goto free_page;
 720     }
 721
 722     SetLastError(0xdeadbeef);
 723     ret = pQueryWorkingSet(hpQI, pages, 4096 * sizeof(ULONG_PTR));
 724     todo_wine ok(ret == 1, "failed with %d\n", GetLastError());
 725     if(ret == 1)
 726     {
 727        for(i = 0; i < pages[0]; i++)
 728            if((pages[i+1] & ~0xfffL) == (ULONG_PTR)addr)
 729            {
 730                todo_wine ok(ret == 1, "QueryWorkingSet found our page\n");
 731                goto test_gwsc;
 732            }
 733
 734        todo_wine ok(0, "QueryWorkingSet didn't find our page\n");
 735     }
 736
 737 test_gwsc:
 738     SetLastError(0xdeadbeef);
 739     ret = pGetWsChanges(hpQI, wswi, sizeof(wswi));
 740     todo_wine ok(ret == 1, "failed with %d\n", GetLastError());
 741     if(ret == 1)
 742     {
 743         for(i = 0; wswi[i].FaultingVa; i++)
 744             if(((ULONG_PTR)wswi[i].FaultingVa & ~0xfffL) == (ULONG_PTR)addr)
 745             {
 746                 todo_wine ok(ret == 1, "GetWsChanges found our page\n");
 747                 goto free_page;
 748             }
 749
 750         todo_wine ok(0, "GetWsChanges didn't find our page\n");
 751     }
 752
 753 free_page:
 754     VirtualFree(addr, 0, MEM_RELEASE);
 755 }
 756
 757 START_TEST(psapi_main)
 758 {
 759     HMODULE hpsapi = LoadLibraryA("psapi.dll");
 760
 761     if(!hpsapi)
 762     {
 763         win_skip("Could not load psapi.dll\n");
 764         return;
 765     }
 766
 767     if(InitFunctionPtrs(hpsapi))
 768     {
 769         DWORD pid = GetCurrentProcessId();
 770
 771     hpSR = OpenProcess(STANDARD_RIGHTS_REQUIRED, FALSE, pid);
 772     hpQI = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
 773     hpVR = OpenProcess(PROCESS_VM_READ, FALSE, pid);
 774     hpQV = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
 775     hpAA = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
 776
 777     if(hpSR && hpQI && hpVR && hpQV && hpAA)
 778         {
 779             test_EnumProcesses();
 780             test_EnumProcessModules();
 781             test_GetModuleInformation();
 782             test_GetPerformanceInfo();
 783             test_GetProcessMemoryInfo();
 784             test_GetMappedFileName();
 785             test_GetProcessImageFileName();
 786             test_GetModuleFileNameEx();
 787             test_GetModuleBaseName();
 788             test_ws_functions();
 789         }
 790         CloseHandle(hpSR);
 791         CloseHandle(hpQI);
 792         CloseHandle(hpVR);
 793         CloseHandle(hpQV);
 794         CloseHandle(hpAA);
 795     }
 796
 797     FreeLibrary(hpsapi);
 798 }