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     DWORD *tmp, counter = 0;
 153     MODULEINFO info;
 154     DWORD ret;
 155
 156     SetLastError(0xdeadbeef);
 157     pGetModuleInformation(NULL, hMod, &info, sizeof(info));
 158     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 159
 160     SetLastError(0xdeadbeef);
 161     pGetModuleInformation(hpQI, hMod, &info, sizeof(info));
 162     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 163
 164     SetLastError(0xdeadbeef);
 165     pGetModuleInformation(hpQV, hBad, &info, sizeof(info));
 166     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 167
 168     SetLastError(0xdeadbeef);
 169     pGetModuleInformation(hpQV, hMod, &info, sizeof(info)-1);
 170     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 171
 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     hMod = LoadLibraryA("shell32.dll");
 177     ok(hMod != NULL, "Failed to load shell32.dll, error: %u\n", GetLastError());
 178
 179     ret = pGetModuleInformation(hpQV, hMod, &info, sizeof(info));
 180     ok(ret == 1, "failed with %d\n", GetLastError());
 181     info.SizeOfImage /= sizeof(DWORD);
 182     for (tmp = (DWORD *)hMod; info.SizeOfImage; info.SizeOfImage--)
 183         counter ^= *tmp++;
 184     trace("xor of shell32: %08x\n", counter);
 185
 186     FreeLibrary(hMod);
 187 }
 188
 189 static BOOL check_with_margin(SIZE_T perf, SIZE_T sysperf, int margin)
 190 {
 191     return (perf >= max(sysperf, margin) - margin && perf <= sysperf + margin);
 192 }
 193
 194 static void test_GetPerformanceInfo(void)
 195 {
 196     PERFORMANCE_INFORMATION info;
 197     NTSTATUS status;
 198     DWORD size;
 199     BOOL ret;
 200
 201     SetLastError(0xdeadbeef);
 202     ret = pGetPerformanceInfo(&info, sizeof(info)-1);
 203     ok(!ret, "GetPerformanceInfo unexpectedly succeeded\n");
 204     ok(GetLastError() == ERROR_BAD_LENGTH, "expected error=ERROR_BAD_LENGTH but got %d\n", GetLastError());
 205
 206     SetLastError(0xdeadbeef);
 207     ret = pGetPerformanceInfo(&info, sizeof(info));
 208     ok(ret, "GetPerformanceInfo failed with %d\n", GetLastError());
 209     ok(info.cb == sizeof(PERFORMANCE_INFORMATION), "got %d\n", info.cb);
 210
 211     if (!pNtQuerySystemInformation)
 212         win_skip("NtQuerySystemInformation not found, skipping tests\n");
 213     else
 214     {
 215         char performance_buffer[sizeof(SYSTEM_PERFORMANCE_INFORMATION) + 16]; /* larger on w2k8/win7 */
 216         SYSTEM_PERFORMANCE_INFORMATION *sys_performance_info = (SYSTEM_PERFORMANCE_INFORMATION *)performance_buffer;
 217         SYSTEM_PROCESS_INFORMATION *sys_process_info = NULL, *spi;
 218         SYSTEM_BASIC_INFORMATION sys_basic_info;
 219         DWORD process_count, handle_count, thread_count;
 220
 221         /* compare with values from SYSTEM_PERFORMANCE_INFORMATION */
 222         size = 0;
 223         status = pNtQuerySystemInformation(SystemPerformanceInformation, sys_performance_info, sizeof(performance_buffer), &size);
 224         ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
 225         ok(size >= sizeof(SYSTEM_PERFORMANCE_INFORMATION), "incorrect length %d\n", size);
 226
 227
 228         ok(check_with_margin(info.CommitTotal,          sys_performance_info->TotalCommittedPages,  288),
 229            "expected approximately %ld but got %d\n", info.CommitTotal, sys_performance_info->TotalCommittedPages);
 230
 231         ok(check_with_margin(info.CommitLimit,          sys_performance_info->TotalCommitLimit,     32),
 232            "expected approximately %ld but got %d\n", info.CommitLimit, sys_performance_info->TotalCommitLimit);
 233
 234         ok(check_with_margin(info.CommitPeak,           sys_performance_info->PeakCommitment,       32),
 235            "expected approximately %ld but got %d\n", info.CommitPeak, sys_performance_info->PeakCommitment);
 236
 237         ok(check_with_margin(info.PhysicalAvailable,    sys_performance_info->AvailablePages,       128),
 238            "expected approximately %ld but got %d\n", info.PhysicalAvailable, sys_performance_info->AvailablePages);
 239
 240         /* TODO: info.SystemCache not checked yet - to which field(s) does this value correspond to? */
 241
 242         ok(check_with_margin(info.KernelTotal, sys_performance_info->PagedPoolUsage + sys_performance_info->NonPagedPoolUsage, 64),
 243            "expected approximately %ld but got %d\n", info.KernelTotal,
 244            sys_performance_info->PagedPoolUsage + sys_performance_info->NonPagedPoolUsage);
 245
 246         ok(check_with_margin(info.KernelPaged,          sys_performance_info->PagedPoolUsage,       64),
 247            "expected approximately %ld but got %d\n", info.KernelPaged, sys_performance_info->PagedPoolUsage);
 248
 249         ok(check_with_margin(info.KernelNonpaged,       sys_performance_info->NonPagedPoolUsage,    8),
 250            "expected approximately %ld but got %d\n", info.KernelNonpaged, sys_performance_info->NonPagedPoolUsage);
 251
 252         /* compare with values from SYSTEM_BASIC_INFORMATION */
 253         size = 0;
 254         status = pNtQuerySystemInformation(SystemBasicInformation, &sys_basic_info, sizeof(sys_basic_info), &size);
 255         ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
 256         ok(size >= sizeof(SYSTEM_BASIC_INFORMATION), "incorrect length %d\n", size);
 257
 258         ok(info.PhysicalTotal == sys_basic_info.MmNumberOfPhysicalPages,
 259            "expected info.PhysicalTotal=%u but got %u\n",
 260            sys_basic_info.MmNumberOfPhysicalPages, (ULONG)info.PhysicalTotal);
 261
 262         ok(info.PageSize == sys_basic_info.PageSize,
 263            "expected info.PageSize=%u but got %u\n",
 264            sys_basic_info.PageSize, (ULONG)info.PageSize);
 265
 266         /* compare with values from SYSTEM_PROCESS_INFORMATION */
 267         size = 0;
 268         status = pNtQuerySystemInformation(SystemProcessInformation, NULL, 0, &size);
 269         ok(status == STATUS_INFO_LENGTH_MISMATCH, "expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
 270         ok(size > 0, "incorrect length %d\n", size);
 271         while (status == STATUS_INFO_LENGTH_MISMATCH)
 272         {
 273             sys_process_info = HeapAlloc(GetProcessHeap(), 0, size);
 274             ok(sys_process_info != NULL, "failed to allocate memory\n");
 275             status = pNtQuerySystemInformation(SystemProcessInformation, sys_process_info, size, &size);
 276             if (status == STATUS_SUCCESS) break;
 277             HeapFree(GetProcessHeap(), 0, sys_process_info);
 278         }
 279         ok(status == STATUS_SUCCESS, "expected STATUS_SUCCESS, got %08x\n", status);
 280
 281         process_count = handle_count = thread_count = 0;
 282         for (spi = sys_process_info;; spi = (SYSTEM_PROCESS_INFORMATION *)(((char *)spi) + spi->NextEntryOffset))
 283         {
 284             process_count++;
 285             handle_count += spi->HandleCount;
 286             thread_count += spi->dwThreadCount;
 287             if (spi->NextEntryOffset == 0) break;
 288         }
 289         HeapFree(GetProcessHeap(), 0, sys_process_info);
 290
 291         ok(check_with_margin(info.HandleCount,  handle_count,  24),
 292            "expected approximately %d but got %d\n", info.HandleCount, handle_count);
 293
 294         ok(check_with_margin(info.ProcessCount, process_count, 4),
 295            "expected approximately %d but got %d\n", info.ProcessCount, process_count);
 296
 297         ok(check_with_margin(info.ThreadCount,  thread_count,  4),
 298            "expected approximately %d but got %d\n", info.ThreadCount, thread_count);
 299     }
 300 }
 301
 302
 303 static void test_GetProcessMemoryInfo(void)
 304 {
 305     PROCESS_MEMORY_COUNTERS pmc;
 306     DWORD ret;
 307
 308     SetLastError(0xdeadbeef);
 309     ret = pGetProcessMemoryInfo(NULL, &pmc, sizeof(pmc));
 310     ok(!ret, "GetProcessMemoryInfo should fail\n");
 311     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 312
 313     SetLastError(0xdeadbeef);
 314     ret = pGetProcessMemoryInfo(hpSR, &pmc, sizeof(pmc));
 315     ok(!ret, "GetProcessMemoryInfo should fail\n");
 316     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 317
 318     SetLastError(0xdeadbeef);
 319     ret = pGetProcessMemoryInfo(hpQI, &pmc, sizeof(pmc)-1);
 320     ok(!ret, "GetProcessMemoryInfo should fail\n");
 321     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 322
 323     SetLastError(0xdeadbeef);
 324     ret = pGetProcessMemoryInfo(hpQI, &pmc, sizeof(pmc));
 325     ok(ret == 1, "failed with %d\n", GetLastError());
 326 }
 327
 328 static BOOL nt_get_mapped_file_name(HANDLE process, LPVOID addr, LPWSTR name, DWORD len)
 329 {
 330     MEMORY_SECTION_NAME *section_name;
 331     WCHAR *buf;
 332     SIZE_T buf_len, ret_len;
 333     NTSTATUS status;
 334
 335     if (!pNtQueryVirtualMemory) return FALSE;
 336
 337     buf_len = len * sizeof(WCHAR) + sizeof(MEMORY_SECTION_NAME);
 338     buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buf_len);
 339
 340     ret_len = 0xdeadbeef;
 341     status = pNtQueryVirtualMemory(process, addr, MemorySectionName, buf, buf_len, &ret_len);
 342     ok(!status, "NtQueryVirtualMemory error %x\n", status);
 343
 344     section_name = (MEMORY_SECTION_NAME *)buf;
 345     ok(ret_len == section_name->SectionFileName.MaximumLength + sizeof(*section_name), "got %lu, %u\n",
 346        ret_len, section_name->SectionFileName.MaximumLength);
 347     ok((char *)section_name->SectionFileName.Buffer == (char *)section_name + sizeof(*section_name), "got %p, %p\n",
 348        section_name, section_name->SectionFileName.Buffer);
 349     ok(section_name->SectionFileName.MaximumLength == section_name->SectionFileName.Length + sizeof(WCHAR), "got %u, %u\n",
 350        section_name->SectionFileName.MaximumLength, section_name->SectionFileName.Length);
 351     ok(section_name->SectionFileName.Length == lstrlenW(section_name->SectionFileName.Buffer) * sizeof(WCHAR), "got %u, %u\n",
 352        section_name->SectionFileName.Length, lstrlenW(section_name->SectionFileName.Buffer));
 353
 354     memcpy(name, section_name->SectionFileName.Buffer, section_name->SectionFileName.MaximumLength);
 355     HeapFree(GetProcessHeap(), 0, buf);
 356     return TRUE;
 357 }
 358
 359 static void test_GetMappedFileName(void)
 360 {
 361     HMODULE hMod = GetModuleHandleA(NULL);
 362     char szMapPath[MAX_PATH], szModPath[MAX_PATH], *szMapBaseName;
 363     DWORD ret;
 364     char *base;
 365     char temp_path[MAX_PATH], file_name[MAX_PATH], map_name[MAX_PATH], device_name[MAX_PATH], drive[3];
 366     WCHAR map_nameW[MAX_PATH], nt_map_name[MAX_PATH];
 367     HANDLE hfile, hmap;
 368     HANDLE current_process;
 369
 370     DuplicateHandle( GetCurrentProcess(), GetCurrentProcess(),
 371                      GetCurrentProcess(), &current_process, 0, 0, DUPLICATE_SAME_ACCESS );
 372
 373     SetLastError(0xdeadbeef);
 374     ret = pGetMappedFileNameA(NULL, hMod, szMapPath, sizeof(szMapPath));
 375     ok(!ret, "GetMappedFileName should fail\n");
 376     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 377
 378     SetLastError(0xdeadbeef);
 379     ret = pGetMappedFileNameA(hpSR, hMod, szMapPath, sizeof(szMapPath));
 380     ok(!ret, "GetMappedFileName should fail\n");
 381     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 382
 383     SetLastError( 0xdeadbeef );
 384     ret = pGetMappedFileNameA(hpQI, hMod, szMapPath, sizeof(szMapPath));
 385     ok( ret || broken(GetLastError() == ERROR_UNEXP_NET_ERR), /* win2k */
 386         "GetMappedFileNameA failed with error %u\n", GetLastError() );
 387     if (ret)
 388     {
 389         ok(ret == strlen(szMapPath), "szMapPath=\"%s\" ret=%d\n", szMapPath, ret);
 390         ok(szMapPath[0] == '\\', "szMapPath=\"%s\"\n", szMapPath);
 391         szMapBaseName = strrchr(szMapPath, '\\'); /* That's close enough for us */
 392         ok(szMapBaseName && *szMapBaseName, "szMapPath=\"%s\"\n", szMapPath);
 393         if (szMapBaseName)
 394         {
 395             GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 396             ok(!strcmp(strrchr(szModPath, '\\'), szMapBaseName),
 397                "szModPath=\"%s\" szMapBaseName=\"%s\"\n", szModPath, szMapBaseName);
 398         }
 399     }
 400
 401     GetTempPathA(MAX_PATH, temp_path);
 402     GetTempFileNameA(temp_path, "map", 0, file_name);
 403
 404     drive[0] = file_name[0];
 405     drive[1] = ':';
 406     drive[2] = 0;
 407     SetLastError(0xdeadbeef);
 408     ret = QueryDosDeviceA(drive, device_name, sizeof(device_name));
 409     ok(ret, "QueryDosDeviceA error %d\n", GetLastError());
 410     trace("%s -> %s\n", drive, device_name);
 411
 412     SetLastError(0xdeadbeef);
 413     hfile = CreateFileA(file_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 414     ok(hfile != INVALID_HANDLE_VALUE, "CreateFileA(%s) error %d\n", file_name, GetLastError());
 415     SetFilePointer(hfile, 0x4000, NULL, FILE_BEGIN);
 416     SetEndOfFile(hfile);
 417
 418     SetLastError(0xdeadbeef);
 419     hmap = CreateFileMappingA(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
 420     ok(hmap != 0, "CreateFileMappingA error %d\n", GetLastError());
 421
 422     SetLastError(0xdeadbeef);
 423     base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
 424     ok(base != NULL, "MapViewOfFile error %d\n", GetLastError());
 425
 426     SetLastError(0xdeadbeef);
 427     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, 0);
 428     ok(!ret, "GetMappedFileName should fail\n");
 429     ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 430        "wrong error %d\n", GetLastError());
 431
 432     SetLastError(0xdeadbeef);
 433     ret = pGetMappedFileNameA(GetCurrentProcess(), base, 0, sizeof(map_name));
 434     ok(!ret, "GetMappedFileName should fail\n");
 435     ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 436
 437     SetLastError(0xdeadbeef);
 438     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, 1);
 439     ok(ret == 1, "GetMappedFileName error %d\n", GetLastError());
 440     ok(!map_name[0] || broken(map_name[0] == device_name[0]) /* before win2k */, "expected 0, got %c\n", map_name[0]);
 441
 442     SetLastError(0xdeadbeef);
 443     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name));
 444     ok(ret, "GetMappedFileName error %d\n", GetLastError());
 445     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 446     ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 447
 448     SetLastError(0xdeadbeef);
 449     ret = pGetMappedFileNameW(GetCurrentProcess(), 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(GetCurrentProcess(), 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 = pGetMappedFileNameW(current_process, base, map_nameW, sizeof(map_nameW)/sizeof(map_nameW[0]));
 462     ok(ret, "GetMappedFileNameW error %d\n", GetLastError());
 463     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 464
 465     if (nt_get_mapped_file_name(current_process, base, nt_map_name, sizeof(nt_map_name)/sizeof(nt_map_name[0])))
 466     {
 467         ok(memcmp(map_nameW, nt_map_name, lstrlenW(map_nameW)) == 0, "map name does not start with a device name: %s\n", map_name);
 468         WideCharToMultiByte(CP_ACP, 0, map_nameW, -1, map_name, MAX_PATH, NULL, NULL);
 469         ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 470     }
 471
 472     SetLastError(0xdeadbeef);
 473     ret = pGetMappedFileNameA(GetCurrentProcess(), base + 0x2000, map_name, sizeof(map_name));
 474     ok(ret, "GetMappedFileName error %d\n", GetLastError());
 475     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 476     ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 477
 478     SetLastError(0xdeadbeef);
 479     ret = pGetMappedFileNameA(GetCurrentProcess(), base + 0x4000, map_name, sizeof(map_name));
 480     ok(!ret, "GetMappedFileName should fail\n");
 481     ok(GetLastError() == ERROR_UNEXP_NET_ERR, "expected ERROR_UNEXP_NET_ERR, got %d\n", GetLastError());
 482
 483     SetLastError(0xdeadbeef);
 484     ret = pGetMappedFileNameA(GetCurrentProcess(), NULL, map_name, sizeof(map_name));
 485     ok(!ret, "GetMappedFileName should fail\n");
 486 todo_wine
 487     ok(GetLastError() == ERROR_UNEXP_NET_ERR, "expected ERROR_UNEXP_NET_ERR, got %d\n", GetLastError());
 488
 489     SetLastError(0xdeadbeef);
 490     ret = pGetMappedFileNameA(0, base, map_name, sizeof(map_name));
 491     ok(!ret, "GetMappedFileName should fail\n");
 492     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 493
 494     UnmapViewOfFile(base);
 495     CloseHandle(hmap);
 496     CloseHandle(hfile);
 497     DeleteFileA(file_name);
 498
 499     SetLastError(0xdeadbeef);
 500     hmap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READONLY | SEC_COMMIT, 0, 4096, NULL);
 501     ok(hmap != 0, "CreateFileMappingA error %d\n", GetLastError());
 502
 503     SetLastError(0xdeadbeef);
 504     base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
 505     ok(base != NULL, "MapViewOfFile error %d\n", GetLastError());
 506
 507     SetLastError(0xdeadbeef);
 508     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name));
 509     ok(!ret, "GetMappedFileName should fail\n");
 510     ok(GetLastError() == ERROR_FILE_INVALID, "expected ERROR_FILE_INVALID, got %d\n", GetLastError());
 511
 512     CloseHandle(current_process);
 513     UnmapViewOfFile(base);
 514     CloseHandle(hmap);
 515 }
 516
 517 static void test_GetProcessImageFileName(void)
 518 {
 519     HMODULE hMod = GetModuleHandleA(NULL);
 520     char szImgPath[MAX_PATH], szMapPath[MAX_PATH];
 521     WCHAR szImgPathW[MAX_PATH];
 522     DWORD ret, ret1;
 523
 524     if(pGetProcessImageFileNameA == NULL)
 525         return;
 526
 527     /* This function is available on WinXP+ only */
 528     SetLastError(0xdeadbeef);
 529     if(!pGetProcessImageFileNameA(hpQI, szImgPath, sizeof(szImgPath)))
 530     {
 531         if(GetLastError() == ERROR_INVALID_FUNCTION) {
 532             win_skip("GetProcessImageFileName not implemented\n");
 533             return;
 534         }
 535
 536         if(GetLastError() == 0xdeadbeef)
 537             todo_wine ok(0, "failed without error code\n");
 538         else
 539             todo_wine ok(0, "failed with %d\n", GetLastError());
 540     }
 541
 542     SetLastError(0xdeadbeef);
 543     pGetProcessImageFileNameA(NULL, szImgPath, sizeof(szImgPath));
 544     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 545
 546     SetLastError(0xdeadbeef);
 547     pGetProcessImageFileNameA(hpSR, szImgPath, sizeof(szImgPath));
 548     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 549
 550     SetLastError(0xdeadbeef);
 551     pGetProcessImageFileNameA(hpQI, szImgPath, 0);
 552     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 553
 554     ret = pGetProcessImageFileNameA(hpQI, szImgPath, sizeof(szImgPath));
 555     ret1 = pGetMappedFileNameA(hpQV, hMod, szMapPath, sizeof(szMapPath));
 556     if(ret && ret1)
 557     {
 558         /* Windows returns 2*strlen-1 */
 559         ok(ret >= strlen(szImgPath), "szImgPath=\"%s\" ret=%d\n", szImgPath, ret);
 560         ok(!strcmp(szImgPath, szMapPath), "szImgPath=\"%s\" szMapPath=\"%s\"\n", szImgPath, szMapPath);
 561     }
 562
 563     SetLastError(0xdeadbeef);
 564     pGetProcessImageFileNameW(NULL, szImgPathW, sizeof(szImgPathW));
 565     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 566
 567     /* no information about correct buffer size returned: */
 568     SetLastError(0xdeadbeef);
 569     pGetProcessImageFileNameW(hpQI, szImgPathW, 0);
 570     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 571
 572     SetLastError(0xdeadbeef);
 573     pGetProcessImageFileNameW(hpQI, NULL, 0);
 574     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 575
 576     /* correct call */
 577     memset(szImgPathW, 0xff, sizeof(szImgPathW));
 578     ret = pGetProcessImageFileNameW(hpQI, szImgPathW, sizeof(szImgPathW)/sizeof(WCHAR));
 579     ok(ret > 0, "GetProcessImageFileNameW should have succeeded.\n");
 580     ok(szImgPathW[0] == '\\', "GetProcessImageFileNameW should have returned an NT path.\n");
 581     ok(lstrlenW(szImgPathW) == ret, "Expected length to be %d, got %d\n", ret, lstrlenW(szImgPathW));
 582
 583     /* boundary values of 'size' */
 584     SetLastError(0xdeadbeef);
 585     pGetProcessImageFileNameW(hpQI, szImgPathW, ret);
 586     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 587
 588     memset(szImgPathW, 0xff, sizeof(szImgPathW));
 589     ret = pGetProcessImageFileNameW(hpQI, szImgPathW, ret + 1);
 590     ok(ret > 0, "GetProcessImageFileNameW should have succeeded.\n");
 591     ok(szImgPathW[0] == '\\', "GetProcessImageFileNameW should have returned an NT path.\n");
 592     ok(lstrlenW(szImgPathW) == ret, "Expected length to be %d, got %d\n", ret, lstrlenW(szImgPathW));
 593 }
 594
 595 static void test_GetModuleFileNameEx(void)
 596 {
 597     HMODULE hMod = GetModuleHandleA(NULL);
 598     char szModExPath[MAX_PATH+1], szModPath[MAX_PATH+1];
 599     WCHAR buffer[MAX_PATH];
 600     DWORD ret;
 601
 602     SetLastError(0xdeadbeef);
 603     ret = pGetModuleFileNameExA(NULL, hMod, szModExPath, sizeof(szModExPath));
 604     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 605     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 606
 607     SetLastError(0xdeadbeef);
 608     ret = pGetModuleFileNameExA(hpQI, hMod, szModExPath, sizeof(szModExPath));
 609     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 610     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 611
 612     SetLastError(0xdeadbeef);
 613     ret = pGetModuleFileNameExA(hpQV, hBad, szModExPath, sizeof(szModExPath));
 614     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 615     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 616
 617     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, sizeof(szModExPath));
 618     if(!ret)
 619             return;
 620     ok(ret == strlen(szModExPath), "szModExPath=\"%s\" ret=%d\n", szModExPath, ret);
 621     GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 622     ok(!strncmp(szModExPath, szModPath, MAX_PATH),
 623        "szModExPath=\"%s\" szModPath=\"%s\"\n", szModExPath, szModPath);
 624
 625     SetLastError(0xdeadbeef);
 626     memset( szModExPath, 0xcc, sizeof(szModExPath) );
 627     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, 4 );
 628     ok( ret == 4 || ret == strlen(szModExPath), "wrong length %u\n", ret );
 629     ok( broken(szModExPath[3]) /*w2kpro*/ || strlen(szModExPath) == 3,
 630         "szModExPath=\"%s\" ret=%d\n", szModExPath, ret );
 631     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 632
 633     if (0) /* crashes on Windows 10 */
 634     {
 635         SetLastError(0xdeadbeef);
 636         ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, 0 );
 637         ok( ret == 0, "wrong length %u\n", ret );
 638         ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %d\n", GetLastError());
 639     }
 640
 641     SetLastError(0xdeadbeef);
 642     memset( buffer, 0xcc, sizeof(buffer) );
 643     ret = pGetModuleFileNameExW(hpQV, NULL, buffer, 4 );
 644     ok( ret == 4 || ret == lstrlenW(buffer), "wrong length %u\n", ret );
 645     ok( broken(buffer[3]) /*w2kpro*/ || lstrlenW(buffer) == 3,
 646         "buffer=%s ret=%d\n", wine_dbgstr_w(buffer), ret );
 647     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 648
 649     if (0) /* crashes on Windows 10 */
 650     {
 651         SetLastError(0xdeadbeef);
 652         buffer[0] = 0xcc;
 653         ret = pGetModuleFileNameExW(hpQV, NULL, buffer, 0 );
 654         ok( ret == 0, "wrong length %u\n", ret );
 655         ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 656         ok( buffer[0] == 0xcc, "buffer modified %s\n", wine_dbgstr_w(buffer) );
 657     }
 658 }
 659
 660 static void test_GetModuleBaseName(void)
 661 {
 662     HMODULE hMod = GetModuleHandleA(NULL);
 663     char szModPath[MAX_PATH], szModBaseName[MAX_PATH];
 664     DWORD ret;
 665
 666     SetLastError(0xdeadbeef);
 667     pGetModuleBaseNameA(NULL, hMod, szModBaseName, sizeof(szModBaseName));
 668     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 669
 670     SetLastError(0xdeadbeef);
 671     pGetModuleBaseNameA(hpQI, hMod, szModBaseName, sizeof(szModBaseName));
 672     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 673
 674     SetLastError(0xdeadbeef);
 675     pGetModuleBaseNameA(hpQV, hBad, szModBaseName, sizeof(szModBaseName));
 676     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 677
 678     ret = pGetModuleBaseNameA(hpQV, NULL, szModBaseName, sizeof(szModBaseName));
 679     if(!ret)
 680         return;
 681     ok(ret == strlen(szModBaseName), "szModBaseName=\"%s\" ret=%d\n", szModBaseName, ret);
 682     GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 683     ok(!strcmp(strrchr(szModPath, '\\') + 1, szModBaseName),
 684        "szModPath=\"%s\" szModBaseName=\"%s\"\n", szModPath, szModBaseName);
 685 }
 686
 687 static void test_ws_functions(void)
 688 {
 689     PSAPI_WS_WATCH_INFORMATION wswi[4096];
 690     ULONG_PTR pages[4096];
 691     char *addr;
 692     unsigned int i;
 693     BOOL ret;
 694
 695     SetLastError(0xdeadbeef);
 696     pEmptyWorkingSet(NULL);
 697     todo_wine ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 698
 699     SetLastError(0xdeadbeef);
 700     pEmptyWorkingSet(hpSR);
 701     todo_wine ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 702
 703     SetLastError(0xdeadbeef);
 704     ret = pEmptyWorkingSet(hpAA);
 705     ok(ret == 1, "failed with %d\n", GetLastError());
 706
 707     SetLastError( 0xdeadbeef );
 708     ret = pInitializeProcessForWsWatch( NULL );
 709     todo_wine ok( !ret, "InitializeProcessForWsWatch succeeded\n" );
 710     if (!ret)
 711     {
 712         if (GetLastError() == ERROR_INVALID_FUNCTION)  /* not supported on xp in wow64 mode */
 713         {
 714             trace( "InitializeProcessForWsWatch not supported\n" );
 715             return;
 716         }
 717         ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
 718     }
 719     SetLastError(0xdeadbeef);
 720     ret = pInitializeProcessForWsWatch(hpAA);
 721     ok(ret == 1, "failed with %d\n", GetLastError());
 722
 723     addr = VirtualAlloc(NULL, 1, MEM_COMMIT, PAGE_READWRITE);
 724     if(!addr)
 725         return;
 726
 727     *addr = 0; /* make sure it's paged in (needed on wow64) */
 728     if(!VirtualLock(addr, 1))
 729     {
 730         trace("locking failed (error=%d) - skipping test\n", GetLastError());
 731         goto free_page;
 732     }
 733
 734     SetLastError(0xdeadbeef);
 735     ret = pQueryWorkingSet(hpQI, pages, 4096 * sizeof(ULONG_PTR));
 736     todo_wine ok(ret == 1, "failed with %d\n", GetLastError());
 737     if(ret == 1)
 738     {
 739        for(i = 0; i < pages[0]; i++)
 740            if((pages[i+1] & ~0xfffL) == (ULONG_PTR)addr)
 741            {
 742                todo_wine ok(ret == 1, "QueryWorkingSet found our page\n");
 743                goto test_gwsc;
 744            }
 745
 746        todo_wine ok(0, "QueryWorkingSet didn't find our page\n");
 747     }
 748
 749 test_gwsc:
 750     SetLastError(0xdeadbeef);
 751     ret = pGetWsChanges(hpQI, wswi, sizeof(wswi));
 752     todo_wine ok(ret == 1, "failed with %d\n", GetLastError());
 753     if(ret == 1)
 754     {
 755         for(i = 0; wswi[i].FaultingVa; i++)
 756             if(((ULONG_PTR)wswi[i].FaultingVa & ~0xfffL) == (ULONG_PTR)addr)
 757             {
 758                 todo_wine ok(ret == 1, "GetWsChanges found our page\n");
 759                 goto free_page;
 760             }
 761
 762         todo_wine ok(0, "GetWsChanges didn't find our page\n");
 763     }
 764
 765 free_page:
 766     VirtualFree(addr, 0, MEM_RELEASE);
 767 }
 768
 769 START_TEST(psapi_main)
 770 {
 771     HMODULE hpsapi = LoadLibraryA("psapi.dll");
 772
 773     if(!hpsapi)
 774     {
 775         win_skip("Could not load psapi.dll\n");
 776         return;
 777     }
 778
 779     if(InitFunctionPtrs(hpsapi))
 780     {
 781         DWORD pid = GetCurrentProcessId();
 782
 783     hpSR = OpenProcess(STANDARD_RIGHTS_REQUIRED, FALSE, pid);
 784     hpQI = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
 785     hpVR = OpenProcess(PROCESS_VM_READ, FALSE, pid);
 786     hpQV = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
 787     hpAA = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
 788
 789     if(hpSR && hpQI && hpVR && hpQV && hpAA)
 790         {
 791             test_EnumProcesses();
 792             test_EnumProcessModules();
 793             test_GetModuleInformation();
 794             test_GetPerformanceInfo();
 795             test_GetProcessMemoryInfo();
 796             test_GetMappedFileName();
 797             test_GetProcessImageFileName();
 798             test_GetModuleFileNameEx();
 799             test_GetModuleBaseName();
 800             test_ws_functions();
 801         }
 802         CloseHandle(hpSR);
 803         CloseHandle(hpQI);
 804         CloseHandle(hpVR);
 805         CloseHandle(hpQV);
 806         CloseHandle(hpAA);
 807     }
 808
 809     FreeLibrary(hpsapi);
 810 }