git.oblomov.eu Git - wine/blob - dlls/psapi/tests/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 /* 0x0600 makes PROCESS_ALL_ACCESS not compatible with pre-Vista versions */
  25 #define _WIN32_WINNT 0x0500
  26
  27 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winreg.h"
  33 #include "winnt.h"
  34 #include "winternl.h"
  35 #include "winnls.h"
  36 #include "psapi.h"
  37 #include "wine/test.h"
  38
  39 #define PSAPI_GET_PROC(func) \
  40     p ## func = (void*)GetProcAddress(hpsapi, #func); \
  41     if(!p ## func) { \
  42         ok(0, "GetProcAddress(%s) failed\n", #func); \
  43         FreeLibrary(hpsapi); \
  44         return FALSE; \
  45     }
  46
  47 static BOOL  (WINAPI *pEmptyWorkingSet)(HANDLE);
  48 static BOOL  (WINAPI *pEnumProcesses)(DWORD*, DWORD, DWORD*);
  49 static BOOL  (WINAPI *pEnumProcessModules)(HANDLE, HMODULE*, DWORD, LPDWORD);
  50 static DWORD (WINAPI *pGetModuleBaseNameA)(HANDLE, HMODULE, LPSTR, DWORD);
  51 static DWORD (WINAPI *pGetModuleFileNameExA)(HANDLE, HMODULE, LPSTR, DWORD);
  52 static DWORD (WINAPI *pGetModuleFileNameExW)(HANDLE, HMODULE, LPWSTR, DWORD);
  53 static BOOL  (WINAPI *pGetModuleInformation)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
  54 static DWORD (WINAPI *pGetMappedFileNameA)(HANDLE, LPVOID, LPSTR, DWORD);
  55 static DWORD (WINAPI *pGetMappedFileNameW)(HANDLE, LPVOID, LPWSTR, DWORD);
  56 static DWORD (WINAPI *pGetProcessImageFileNameA)(HANDLE, LPSTR, DWORD);
  57 static DWORD (WINAPI *pGetProcessImageFileNameW)(HANDLE, LPWSTR, DWORD);
  58 static BOOL  (WINAPI *pGetProcessMemoryInfo)(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD);
  59 static BOOL  (WINAPI *pGetWsChanges)(HANDLE, PPSAPI_WS_WATCH_INFORMATION, DWORD);
  60 static BOOL  (WINAPI *pInitializeProcessForWsWatch)(HANDLE);
  61 static BOOL  (WINAPI *pQueryWorkingSet)(HANDLE, PVOID, DWORD);
  62 static NTSTATUS (WINAPI *pNtQueryVirtualMemory)(HANDLE, LPCVOID, ULONG, PVOID, SIZE_T, SIZE_T *);
  63
  64 static BOOL InitFunctionPtrs(HMODULE hpsapi)
  65 {
  66     PSAPI_GET_PROC(EmptyWorkingSet);
  67     PSAPI_GET_PROC(EnumProcessModules);
  68     PSAPI_GET_PROC(EnumProcesses);
  69     PSAPI_GET_PROC(GetModuleBaseNameA);
  70     PSAPI_GET_PROC(GetModuleFileNameExA);
  71     PSAPI_GET_PROC(GetModuleFileNameExW);
  72     PSAPI_GET_PROC(GetModuleInformation);
  73     PSAPI_GET_PROC(GetMappedFileNameA);
  74     PSAPI_GET_PROC(GetMappedFileNameW);
  75     PSAPI_GET_PROC(GetProcessMemoryInfo);
  76     PSAPI_GET_PROC(GetWsChanges);
  77     PSAPI_GET_PROC(InitializeProcessForWsWatch);
  78     PSAPI_GET_PROC(QueryWorkingSet);
  79     /* GetProcessImageFileName is not exported on NT4 */
  80     pGetProcessImageFileNameA =
  81       (void *)GetProcAddress(hpsapi, "GetProcessImageFileNameA");
  82     pGetProcessImageFileNameW =
  83       (void *)GetProcAddress(hpsapi, "GetProcessImageFileNameW");
  84     pNtQueryVirtualMemory = (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtQueryVirtualMemory");
  85     return TRUE;
  86 }
  87
  88 static HANDLE hpSR, hpQI, hpVR, hpQV, hpAA;
  89 static const HANDLE hBad = (HANDLE)0xdeadbeef;
  90
  91 static void test_EnumProcesses(void)
  92 {
  93     DWORD pid, ret, cbUsed = 0xdeadbeef;
  94
  95     SetLastError(0xdeadbeef);
  96     ret = pEnumProcesses(NULL, 0, &cbUsed);
  97     ok(ret == 1, "failed with %d\n", GetLastError());
  98     ok(cbUsed == 0, "cbUsed=%d\n", cbUsed);
  99
 100     SetLastError(0xdeadbeef);
 101     ret = pEnumProcesses(&pid, 4, &cbUsed);
 102     ok(ret == 1, "failed with %d\n", GetLastError());
 103     ok(cbUsed == 4, "cbUsed=%d\n", cbUsed);
 104 }
 105
 106 static void test_EnumProcessModules(void)
 107 {
 108     HMODULE hMod = GetModuleHandle(NULL);
 109     DWORD ret, cbNeeded = 0xdeadbeef;
 110
 111     SetLastError(0xdeadbeef);
 112     pEnumProcessModules(NULL, NULL, 0, &cbNeeded);
 113     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 114
 115     SetLastError(0xdeadbeef);
 116     pEnumProcessModules(hpQI, NULL, 0, &cbNeeded);
 117     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 118
 119     SetLastError(0xdeadbeef);
 120     ret = pEnumProcessModules(hpQV, NULL, 0, &cbNeeded);
 121     ok(ret == 1, "failed with %d\n", GetLastError());
 122
 123     SetLastError(0xdeadbeef);
 124     ret = pEnumProcessModules(hpQV, &hMod, sizeof(HMODULE), &cbNeeded);
 125     if(ret != 1)
 126         return;
 127     ok(hMod == GetModuleHandle(NULL),
 128        "hMod=%p GetModuleHandle(NULL)=%p\n", hMod, GetModuleHandle(NULL));
 129     ok(cbNeeded % sizeof(hMod) == 0, "not a multiple of sizeof(HMODULE) cbNeeded=%d\n", cbNeeded);
 130     /* Windows sometimes has a bunch of extra dlls, presumably brought in by
 131      * aclayers.dll.
 132      */
 133     if (cbNeeded < 4 * sizeof(HMODULE) || cbNeeded > 30 * sizeof(HMODULE))
 134     {
 135         HMODULE hmods[100];
 136         int i;
 137         ok(0, "cbNeeded=%d\n", cbNeeded);
 138
 139         pEnumProcessModules(hpQV, hmods, sizeof(hmods), &cbNeeded);
 140         for (i = 0 ; i < cbNeeded/sizeof(*hmods); i++)
 141         {
 142             char path[1024];
 143             GetModuleFileNameA(hmods[i], path, sizeof(path));
 144             trace("i=%d hmod=%p path=[%s]\n", i, hmods[i], path);
 145         }
 146     }
 147 }
 148
 149 static void test_GetModuleInformation(void)
 150 {
 151     HMODULE hMod = GetModuleHandle(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 void test_GetProcessMemoryInfo(void)
 178 {
 179     PROCESS_MEMORY_COUNTERS pmc;
 180     DWORD ret;
 181
 182     SetLastError(0xdeadbeef);
 183     ret = pGetProcessMemoryInfo(NULL, &pmc, sizeof(pmc));
 184     ok(!ret, "GetProcessMemoryInfo should fail\n");
 185     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 186
 187     SetLastError(0xdeadbeef);
 188     ret = pGetProcessMemoryInfo(hpSR, &pmc, sizeof(pmc));
 189 todo_wine
 190     ok(!ret, "GetProcessMemoryInfo should fail\n");
 191 todo_wine
 192     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 193
 194     SetLastError(0xdeadbeef);
 195     ret = pGetProcessMemoryInfo(hpQI, &pmc, sizeof(pmc)-1);
 196     ok(!ret, "GetProcessMemoryInfo should fail\n");
 197     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 198
 199     SetLastError(0xdeadbeef);
 200     ret = pGetProcessMemoryInfo(hpQI, &pmc, sizeof(pmc));
 201     ok(ret == 1, "failed with %d\n", GetLastError());
 202 }
 203
 204 static BOOL nt_get_mapped_file_name(HANDLE process, LPVOID addr, LPWSTR name, DWORD len)
 205 {
 206     MEMORY_SECTION_NAME *section_name;
 207     WCHAR *buf;
 208     SIZE_T buf_len, ret_len;
 209     NTSTATUS status;
 210
 211     if (!pNtQueryVirtualMemory) return FALSE;
 212
 213     buf_len = len * sizeof(WCHAR) + sizeof(MEMORY_SECTION_NAME);
 214     buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buf_len);
 215
 216     ret_len = 0xdeadbeef;
 217     status = pNtQueryVirtualMemory(process, addr, MemorySectionName, buf, buf_len, &ret_len);
 218 todo_wine
 219     ok(!status, "NtQueryVirtualMemory error %x\n", status);
 220     /* FIXME: remove once Wine is fixed */
 221     if (status) return FALSE;
 222
 223     section_name = (MEMORY_SECTION_NAME *)buf;
 224     ok(ret_len == section_name->SectionFileName.MaximumLength + sizeof(*section_name), "got %lu, %u\n",
 225        ret_len, section_name->SectionFileName.MaximumLength);
 226     ok((char *)section_name->SectionFileName.Buffer == (char *)section_name + sizeof(*section_name), "got %p, %p\n",
 227        section_name, section_name->SectionFileName.Buffer);
 228     ok(section_name->SectionFileName.MaximumLength == section_name->SectionFileName.Length + sizeof(WCHAR), "got %u, %u\n",
 229        section_name->SectionFileName.MaximumLength, section_name->SectionFileName.Length);
 230     ok(section_name->SectionFileName.Length == lstrlenW(section_name->SectionFileName.Buffer) * sizeof(WCHAR), "got %u, %u\n",
 231        section_name->SectionFileName.Length, lstrlenW(section_name->SectionFileName.Buffer));
 232
 233     memcpy(name, section_name->SectionFileName.Buffer, section_name->SectionFileName.MaximumLength);
 234     HeapFree(GetProcessHeap(), 0, buf);
 235     return TRUE;
 236 }
 237
 238 static void test_GetMappedFileName(void)
 239 {
 240     HMODULE hMod = GetModuleHandle(NULL);
 241     char szMapPath[MAX_PATH], szModPath[MAX_PATH], *szMapBaseName;
 242     DWORD ret;
 243     char *base;
 244     char temp_path[MAX_PATH], file_name[MAX_PATH], map_name[MAX_PATH], device_name[MAX_PATH], drive[3];
 245     WCHAR map_nameW[MAX_PATH], nt_map_name[MAX_PATH];
 246     HANDLE hfile, hmap;
 247
 248     SetLastError(0xdeadbeef);
 249     ret = pGetMappedFileNameA(NULL, hMod, szMapPath, sizeof(szMapPath));
 250     ok(!ret, "GetMappedFileName should fail\n");
 251 todo_wine
 252     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 253
 254     SetLastError(0xdeadbeef);
 255     ret = pGetMappedFileNameA(hpSR, hMod, szMapPath, sizeof(szMapPath));
 256     ok(!ret, "GetMappedFileName should fail\n");
 257 todo_wine
 258     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 259
 260     SetLastError( 0xdeadbeef );
 261     ret = pGetMappedFileNameA(hpQI, hMod, szMapPath, sizeof(szMapPath));
 262 todo_wine
 263     ok( ret || broken(GetLastError() == ERROR_UNEXP_NET_ERR), /* win2k */
 264         "GetMappedFileNameA failed with error %u\n", GetLastError() );
 265     if (ret)
 266     {
 267         ok(ret == strlen(szMapPath), "szMapPath=\"%s\" ret=%d\n", szMapPath, ret);
 268         todo_wine
 269         ok(szMapPath[0] == '\\', "szMapPath=\"%s\"\n", szMapPath);
 270         szMapBaseName = strrchr(szMapPath, '\\'); /* That's close enough for us */
 271         todo_wine
 272         ok(szMapBaseName && *szMapBaseName, "szMapPath=\"%s\"\n", szMapPath);
 273         if (szMapBaseName)
 274         {
 275             GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 276             ok(!strcmp(strrchr(szModPath, '\\'), szMapBaseName),
 277                "szModPath=\"%s\" szMapBaseName=\"%s\"\n", szModPath, szMapBaseName);
 278         }
 279     }
 280
 281     GetTempPath(MAX_PATH, temp_path);
 282     GetTempFileName(temp_path, "map", 0, file_name);
 283
 284     drive[0] = file_name[0];
 285     drive[1] = ':';
 286     drive[2] = 0;
 287     SetLastError(0xdeadbeef);
 288     ret = QueryDosDevice(drive, device_name, sizeof(device_name));
 289     ok(ret, "QueryDosDevice error %d\n", GetLastError());
 290     trace("%s -> %s\n", drive, device_name);
 291
 292     SetLastError(0xdeadbeef);
 293     hfile = CreateFile(file_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
 294     ok(hfile != INVALID_HANDLE_VALUE, "CreateFile(%s) error %d\n", file_name, GetLastError());
 295     SetFilePointer(hfile, 0x4000, NULL, FILE_BEGIN);
 296     SetEndOfFile(hfile);
 297
 298     SetLastError(0xdeadbeef);
 299     hmap = CreateFileMapping(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
 300     ok(hmap != 0, "CreateFileMapping error %d\n", GetLastError());
 301
 302     SetLastError(0xdeadbeef);
 303     base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
 304     ok(base != NULL, "MapViewOfFile error %d\n", GetLastError());
 305
 306     SetLastError(0xdeadbeef);
 307     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, 0);
 308     ok(!ret, "GetMappedFileName should fail\n");
 309 todo_wine
 310     ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 311
 312     SetLastError(0xdeadbeef);
 313     ret = pGetMappedFileNameA(GetCurrentProcess(), base, 0, sizeof(map_name));
 314     ok(!ret, "GetMappedFileName should fail\n");
 315 todo_wine
 316     ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 317
 318     SetLastError(0xdeadbeef);
 319     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, 1);
 320 todo_wine
 321     ok(ret == 1, "GetMappedFileName error %d\n", GetLastError());
 322     ok(!map_name[0] || broken(map_name[0] == device_name[0]) /* before win2k */, "expected 0, got %c\n", map_name[0]);
 323
 324     SetLastError(0xdeadbeef);
 325     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name));
 326 todo_wine {
 327     ok(ret, "GetMappedFileName error %d\n", GetLastError());
 328     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 329     ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 330 }
 331
 332     SetLastError(0xdeadbeef);
 333     ret = pGetMappedFileNameW(GetCurrentProcess(), base, map_nameW, sizeof(map_nameW)/sizeof(map_nameW[0]));
 334 todo_wine {
 335     ok(ret, "GetMappedFileNameW error %d\n", GetLastError());
 336     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 337 }
 338     if (nt_get_mapped_file_name(GetCurrentProcess(), base, nt_map_name, sizeof(nt_map_name)/sizeof(nt_map_name[0])))
 339     {
 340         ok(memcmp(map_nameW, nt_map_name, lstrlenW(map_nameW)) == 0, "map name does not start with a device name: %s\n", map_name);
 341         WideCharToMultiByte(CP_ACP, 0, map_nameW, -1, map_name, MAX_PATH, NULL, NULL);
 342         ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 343     }
 344
 345     SetLastError(0xdeadbeef);
 346     ret = pGetMappedFileNameA(GetCurrentProcess(), base + 0x2000, map_name, sizeof(map_name));
 347 todo_wine {
 348     ok(ret, "GetMappedFileName error %d\n", GetLastError());
 349     ok(ret > strlen(device_name), "map_name should be longer than device_name\n");
 350     ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name);
 351 }
 352
 353     SetLastError(0xdeadbeef);
 354     ret = pGetMappedFileNameA(GetCurrentProcess(), base + 0x4000, map_name, sizeof(map_name));
 355     ok(!ret, "GetMappedFileName should fail\n");
 356 todo_wine
 357     ok(GetLastError() == ERROR_UNEXP_NET_ERR, "expected ERROR_UNEXP_NET_ERR, got %d\n", GetLastError());
 358
 359     SetLastError(0xdeadbeef);
 360     ret = pGetMappedFileNameA(GetCurrentProcess(), NULL, map_name, sizeof(map_name));
 361     ok(!ret, "GetMappedFileName should fail\n");
 362 todo_wine
 363     ok(GetLastError() == ERROR_UNEXP_NET_ERR, "expected ERROR_UNEXP_NET_ERR, got %d\n", GetLastError());
 364
 365     SetLastError(0xdeadbeef);
 366     ret = pGetMappedFileNameA(0, base, map_name, sizeof(map_name));
 367     ok(!ret, "GetMappedFileName should fail\n");
 368 todo_wine
 369     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 370
 371     UnmapViewOfFile(base);
 372     CloseHandle(hmap);
 373     CloseHandle(hfile);
 374     DeleteFile(file_name);
 375
 376     SetLastError(0xdeadbeef);
 377     hmap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READONLY | SEC_COMMIT, 0, 4096, NULL);
 378     ok(hmap != 0, "CreateFileMapping error %d\n", GetLastError());
 379
 380     SetLastError(0xdeadbeef);
 381     base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
 382     ok(base != NULL, "MapViewOfFile error %d\n", GetLastError());
 383
 384     SetLastError(0xdeadbeef);
 385     ret = pGetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name));
 386     ok(!ret, "GetMappedFileName should fail\n");
 387 todo_wine
 388     ok(GetLastError() == ERROR_FILE_INVALID, "expected ERROR_FILE_INVALID, got %d\n", GetLastError());
 389
 390     UnmapViewOfFile(base);
 391     CloseHandle(hmap);
 392 }
 393
 394 static void test_GetProcessImageFileName(void)
 395 {
 396     HMODULE hMod = GetModuleHandle(NULL);
 397     char szImgPath[MAX_PATH], szMapPath[MAX_PATH];
 398     WCHAR szImgPathW[MAX_PATH];
 399     DWORD ret, ret1;
 400
 401     if(pGetProcessImageFileNameA == NULL)
 402         return;
 403
 404     /* This function is available on WinXP+ only */
 405     SetLastError(0xdeadbeef);
 406     if(!pGetProcessImageFileNameA(hpQI, szImgPath, sizeof(szImgPath)))
 407     {
 408         if(GetLastError() == ERROR_INVALID_FUNCTION) {
 409             win_skip("GetProcessImageFileName not implemented\n");
 410             return;
 411         }
 412
 413         if(GetLastError() == 0xdeadbeef)
 414             todo_wine ok(0, "failed without error code\n");
 415         else
 416             todo_wine ok(0, "failed with %d\n", GetLastError());
 417     }
 418
 419     SetLastError(0xdeadbeef);
 420     pGetProcessImageFileNameA(NULL, szImgPath, sizeof(szImgPath));
 421     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 422
 423     SetLastError(0xdeadbeef);
 424     pGetProcessImageFileNameA(hpSR, szImgPath, sizeof(szImgPath));
 425     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 426
 427     SetLastError(0xdeadbeef);
 428     pGetProcessImageFileNameA(hpQI, szImgPath, 0);
 429     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 430
 431     ret = pGetProcessImageFileNameA(hpQI, szImgPath, sizeof(szImgPath));
 432     ret1 = pGetMappedFileNameA(hpQV, hMod, szMapPath, sizeof(szMapPath));
 433     if(ret && ret1)
 434     {
 435         /* Windows returns 2*strlen-1 */
 436         todo_wine ok(ret >= strlen(szImgPath), "szImgPath=\"%s\" ret=%d\n", szImgPath, ret);
 437         todo_wine ok(!strcmp(szImgPath, szMapPath), "szImgPath=\"%s\" szMapPath=\"%s\"\n", szImgPath, szMapPath);
 438     }
 439
 440     SetLastError(0xdeadbeef);
 441     pGetProcessImageFileNameW(NULL, szImgPathW, sizeof(szImgPathW));
 442     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 443
 444     /* no information about correct buffer size returned: */
 445     SetLastError(0xdeadbeef);
 446     pGetProcessImageFileNameW(hpQI, szImgPathW, 0);
 447     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 448
 449     SetLastError(0xdeadbeef);
 450     pGetProcessImageFileNameW(hpQI, NULL, 0);
 451     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 452
 453     /* correct call */
 454     memset(szImgPathW, 0xff, sizeof(szImgPathW));
 455     ret = pGetProcessImageFileNameW(hpQI, szImgPathW, sizeof(szImgPathW)/sizeof(WCHAR));
 456     ok(ret > 0, "GetProcessImageFileNameW should have succeeded.\n");
 457     ok(szImgPathW[0] == '\\', "GetProcessImageFileNameW should have returned an NT path.\n");
 458     ok(lstrlenW(szImgPathW) == ret, "Expected length to be %d, got %d\n", ret, lstrlenW(szImgPathW));
 459
 460     /* boundary values of 'size' */
 461     SetLastError(0xdeadbeef);
 462     pGetProcessImageFileNameW(hpQI, szImgPathW, ret);
 463     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected error=ERROR_INSUFFICIENT_BUFFER but got %d\n", GetLastError());
 464
 465     memset(szImgPathW, 0xff, sizeof(szImgPathW));
 466     ret = pGetProcessImageFileNameW(hpQI, szImgPathW, ret + 1);
 467     ok(ret > 0, "GetProcessImageFileNameW should have succeeded.\n");
 468     ok(szImgPathW[0] == '\\', "GetProcessImageFileNameW should have returned an NT path.\n");
 469     ok(lstrlenW(szImgPathW) == ret, "Expected length to be %d, got %d\n", ret, lstrlenW(szImgPathW));
 470 }
 471
 472 static void test_GetModuleFileNameEx(void)
 473 {
 474     HMODULE hMod = GetModuleHandle(NULL);
 475     char szModExPath[MAX_PATH+1], szModPath[MAX_PATH+1];
 476     WCHAR buffer[MAX_PATH];
 477     DWORD ret;
 478
 479     SetLastError(0xdeadbeef);
 480     ret = pGetModuleFileNameExA(NULL, hMod, szModExPath, sizeof(szModExPath));
 481     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 482     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 483
 484     SetLastError(0xdeadbeef);
 485     ret = pGetModuleFileNameExA(hpQI, hMod, szModExPath, sizeof(szModExPath));
 486     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 487     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 488
 489     SetLastError(0xdeadbeef);
 490     ret = pGetModuleFileNameExA(hpQV, hBad, szModExPath, sizeof(szModExPath));
 491     ok( !ret, "GetModuleFileNameExA succeeded\n" );
 492     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 493
 494     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, sizeof(szModExPath));
 495     if(!ret)
 496             return;
 497     ok(ret == strlen(szModExPath), "szModExPath=\"%s\" ret=%d\n", szModExPath, ret);
 498     GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 499     ok(!strncmp(szModExPath, szModPath, MAX_PATH),
 500        "szModExPath=\"%s\" szModPath=\"%s\"\n", szModExPath, szModPath);
 501
 502     SetLastError(0xdeadbeef);
 503     memset( szModExPath, 0xcc, sizeof(szModExPath) );
 504     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, 4 );
 505     ok( ret == 4, "wrong length %u\n", ret );
 506     ok( broken(szModExPath[3]) /*w2kpro*/ || strlen(szModExPath) == 3,
 507         "szModExPath=\"%s\" ret=%d\n", szModExPath, ret );
 508     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 509
 510     SetLastError(0xdeadbeef);
 511     ret = pGetModuleFileNameExA(hpQV, NULL, szModExPath, 0 );
 512     ok( ret == 0, "wrong length %u\n", ret );
 513     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %d\n", GetLastError());
 514
 515     SetLastError(0xdeadbeef);
 516     memset( buffer, 0xcc, sizeof(buffer) );
 517     ret = pGetModuleFileNameExW(hpQV, NULL, buffer, 4 );
 518     ok( ret == 4, "wrong length %u\n", ret );
 519     ok( broken(buffer[3]) /*w2kpro*/ || lstrlenW(buffer) == 3,
 520         "buffer=%s ret=%d\n", wine_dbgstr_w(buffer), ret );
 521     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 522
 523     SetLastError(0xdeadbeef);
 524     buffer[0] = 0xcc;
 525     ret = pGetModuleFileNameExW(hpQV, NULL, buffer, 0 );
 526     ok( ret == 0, "wrong length %u\n", ret );
 527     ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
 528     ok( buffer[0] == 0xcc, "buffer modified %s\n", wine_dbgstr_w(buffer) );
 529 }
 530
 531 static void test_GetModuleBaseName(void)
 532 {
 533     HMODULE hMod = GetModuleHandle(NULL);
 534     char szModPath[MAX_PATH], szModBaseName[MAX_PATH];
 535     DWORD ret;
 536
 537     SetLastError(0xdeadbeef);
 538     pGetModuleBaseNameA(NULL, hMod, szModBaseName, sizeof(szModBaseName));
 539     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 540
 541     SetLastError(0xdeadbeef);
 542     pGetModuleBaseNameA(hpQI, hMod, szModBaseName, sizeof(szModBaseName));
 543     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 544
 545     SetLastError(0xdeadbeef);
 546     pGetModuleBaseNameA(hpQV, hBad, szModBaseName, sizeof(szModBaseName));
 547     ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 548
 549     ret = pGetModuleBaseNameA(hpQV, NULL, szModBaseName, sizeof(szModBaseName));
 550     if(!ret)
 551         return;
 552     ok(ret == strlen(szModBaseName), "szModBaseName=\"%s\" ret=%d\n", szModBaseName, ret);
 553     GetModuleFileNameA(NULL, szModPath, sizeof(szModPath));
 554     ok(!strcmp(strrchr(szModPath, '\\') + 1, szModBaseName),
 555        "szModPath=\"%s\" szModBaseName=\"%s\"\n", szModPath, szModBaseName);
 556 }
 557
 558 static void test_ws_functions(void)
 559 {
 560     PSAPI_WS_WATCH_INFORMATION wswi[4096];
 561     ULONG_PTR pages[4096];
 562     char *addr;
 563     unsigned int i;
 564     BOOL ret;
 565
 566     SetLastError(0xdeadbeef);
 567     pEmptyWorkingSet(NULL);
 568     todo_wine ok(GetLastError() == ERROR_INVALID_HANDLE, "expected error=ERROR_INVALID_HANDLE but got %d\n", GetLastError());
 569
 570     SetLastError(0xdeadbeef);
 571     pEmptyWorkingSet(hpSR);
 572     todo_wine ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error=ERROR_ACCESS_DENIED but got %d\n", GetLastError());
 573
 574     SetLastError(0xdeadbeef);
 575     ret = pEmptyWorkingSet(hpAA);
 576     ok(ret == 1, "failed with %d\n", GetLastError());
 577
 578     SetLastError( 0xdeadbeef );
 579     ret = pInitializeProcessForWsWatch( NULL );
 580     todo_wine ok( !ret, "InitializeProcessForWsWatch succeeded\n" );
 581     if (!ret)
 582     {
 583         if (GetLastError() == ERROR_INVALID_FUNCTION)  /* not supported on xp in wow64 mode */
 584         {
 585             trace( "InitializeProcessForWsWatch not supported\n" );
 586             return;
 587         }
 588         ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
 589     }
 590     SetLastError(0xdeadbeef);
 591     ret = pInitializeProcessForWsWatch(hpAA);
 592     ok(ret == 1, "failed with %d\n", GetLastError());
 593
 594     addr = VirtualAlloc(NULL, 1, MEM_COMMIT, PAGE_READWRITE);
 595     if(!addr)
 596         return;
 597
 598     *addr = 0; /* make sure it's paged in (needed on wow64) */
 599     if(!VirtualLock(addr, 1))
 600     {
 601         trace("locking failed (error=%d) - skipping test\n", GetLastError());
 602         goto free_page;
 603     }
 604
 605     SetLastError(0xdeadbeef);
 606     ret = pQueryWorkingSet(hpQI, pages, 4096 * sizeof(ULONG_PTR));
 607     todo_wine ok(ret == 1, "failed with %d\n", GetLastError());
 608     if(ret == 1)
 609     {
 610        for(i = 0; i < pages[0]; i++)
 611            if((pages[i+1] & ~0xfffL) == (ULONG_PTR)addr)
 612            {
 613                todo_wine ok(ret == 1, "QueryWorkingSet found our page\n");
 614                goto test_gwsc;
 615            }
 616
 617        todo_wine ok(0, "QueryWorkingSet didn't find our page\n");
 618     }
 619
 620 test_gwsc:
 621     SetLastError(0xdeadbeef);
 622     ret = pGetWsChanges(hpQI, wswi, sizeof(wswi));
 623     todo_wine ok(ret == 1, "failed with %d\n", GetLastError());
 624     if(ret == 1)
 625     {
 626         for(i = 0; wswi[i].FaultingVa; i++)
 627             if(((ULONG_PTR)wswi[i].FaultingVa & ~0xfffL) == (ULONG_PTR)addr)
 628             {
 629                 todo_wine ok(ret == 1, "GetWsChanges found our page\n");
 630                 goto free_page;
 631             }
 632
 633         todo_wine ok(0, "GetWsChanges didn't find our page\n");
 634     }
 635
 636 free_page:
 637     VirtualFree(addr, 0, MEM_RELEASE);
 638 }
 639
 640 START_TEST(psapi_main)
 641 {
 642     HMODULE hpsapi = LoadLibraryA("psapi.dll");
 643
 644     if(!hpsapi)
 645     {
 646         win_skip("Could not load psapi.dll\n");
 647         return;
 648     }
 649
 650     if(InitFunctionPtrs(hpsapi))
 651     {
 652         DWORD pid = GetCurrentProcessId();
 653
 654     hpSR = OpenProcess(STANDARD_RIGHTS_REQUIRED, FALSE, pid);
 655     hpQI = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
 656     hpVR = OpenProcess(PROCESS_VM_READ, FALSE, pid);
 657     hpQV = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
 658     hpAA = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
 659
 660     if(hpSR && hpQI && hpVR && hpQV && hpAA)
 661         {
 662             test_EnumProcesses();
 663             test_EnumProcessModules();
 664             test_GetModuleInformation();
 665             test_GetProcessMemoryInfo();
 666             test_GetMappedFileName();
 667             test_GetProcessImageFileName();
 668             test_GetModuleFileNameEx();
 669             test_GetModuleBaseName();
 670             test_ws_functions();
 671         }
 672         CloseHandle(hpSR);
 673         CloseHandle(hpQI);
 674         CloseHandle(hpVR);
 675         CloseHandle(hpQV);
 676         CloseHandle(hpAA);
 677     }
 678
 679     FreeLibrary(hpsapi);
 680 }