git.oblomov.eu Git - wine/blob - dlls/winspool.drv/tests/info.c

   1 /*
   2  * Copyright (C) 2003, 2004 Stefan Leichter
   3  * Copyright (C) 2005, 2006 Detlef Riekenberg
   4  * Copyright (C) 2006 Dmitry Timoshkov
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <assert.h>
  23
  24 #define NONAMELESSSTRUCT
  25 #define NONAMELESSUNION
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "wingdi.h"
  31 #include "winnls.h"
  32 #include "winuser.h"
  33 #include "winreg.h"
  34 #include "winspool.h"
  35 #include "commdlg.h"
  36 #include "wine/test.h"
  37
  38 #define MAGIC_DEAD  0xdeadbeef
  39 #define DEFAULT_PRINTER_SIZE 1000
  40
  41 static CHAR defaultspooldirectory[] = "DefaultSpoolDirectory";
  42 static CHAR does_not_exist_dll[]= "does_not_exist.dll";
  43 static CHAR does_not_exist[]    = "does_not_exist";
  44 static CHAR empty[]             = "";
  45 static CHAR env_x64[]           = "Windows x64";
  46 static CHAR env_x86[]           = "Windows NT x86";
  47 static CHAR env_win9x_case[]    = "windowS 4.0";
  48 static CHAR illegal_name[]      = "illegal,name";
  49 static CHAR invalid_env[]       = "invalid_env";
  50 static CHAR LocalPortA[]        = "Local Port";
  51 static CHAR portname_com1[]     = "COM1:";
  52 static CHAR portname_file[]     = "FILE:";
  53 static CHAR portname_lpt1[]     = "LPT1:";
  54 static CHAR server_does_not_exist[] = "\\\\does_not_exist";
  55 static CHAR version_dll[]       = "version.dll";
  56 static CHAR winetest[]          = "winetest";
  57 static CHAR xcv_localport[]     = ",XcvMonitor Local Port";
  58
  59 static WCHAR cmd_MonitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
  60 static WCHAR cmd_PortIsValidW[] = {'P','o','r','t','I','s','V','a','l','i','d',0};
  61 static WCHAR emptyW[] = {0};
  62
  63 static WCHAR portname_com1W[] = {'C','O','M','1',':',0};
  64 static WCHAR portname_com2W[] = {'C','O','M','2',':',0};
  65 static WCHAR portname_fileW[] = {'F','I','L','E',':',0};
  66 static WCHAR portname_lpt1W[] = {'L','P','T','1',':',0};
  67 static WCHAR portname_lpt2W[] = {'L','P','T','2',':',0};
  68
  69 static HANDLE  hwinspool;
  70 static BOOL  (WINAPI * pAddPortExA)(LPSTR, DWORD, LPBYTE, LPSTR);
  71 static BOOL  (WINAPI * pEnumPrinterDriversW)(LPWSTR, LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD, LPDWORD);
  72 static BOOL  (WINAPI * pGetDefaultPrinterA)(LPSTR, LPDWORD);
  73 static DWORD (WINAPI * pGetPrinterDataExA)(HANDLE, LPCSTR, LPCSTR, LPDWORD, LPBYTE, DWORD, LPDWORD);
  74 static BOOL  (WINAPI * pGetPrinterDriverW)(HANDLE, LPWSTR, DWORD, LPBYTE, DWORD, LPDWORD);
  75 static BOOL  (WINAPI * pGetPrinterW)(HANDLE, DWORD, LPBYTE, DWORD, LPDWORD);
  76 static BOOL  (WINAPI * pSetDefaultPrinterA)(LPCSTR);
  77 static DWORD (WINAPI * pXcvDataW)(HANDLE, LPCWSTR, PBYTE, DWORD, PBYTE, DWORD, PDWORD, PDWORD);
  78 static BOOL  (WINAPI * pIsValidDevmodeW)(PDEVMODEW, SIZE_T);
  79
  80
  81 /* ################################ */
  82
  83 struct monitor_entry {
  84     LPSTR  env;
  85     CHAR  dllname[32];
  86 };
  87
  88 static LPSTR default_printer = NULL;
  89 static LPSTR local_server = NULL;
  90 static LPSTR tempdirA = NULL;
  91 static LPSTR tempfileA = NULL;
  92 static LPWSTR tempdirW = NULL;
  93 static LPWSTR tempfileW = NULL;
  94
  95 /* ################################ */
  96 /* report common behavior only once */
  97 static DWORD deactivated_spooler_reported = 0;
  98 #define RETURN_ON_DEACTIVATED_SPOOLER(res) \
  99     if ((res == 0) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE)) \
 100     { \
 101         if (!deactivated_spooler_reported) { \
 102             deactivated_spooler_reported++; \
 103             skip("The service 'Spooler' is required for many tests\n"); \
 104         } \
 105         return; \
 106     }
 107
 108 static DWORD access_denied_reported = 0;
 109 #define RETURN_ON_ACCESS_DENIED(res) \
 110     if ((res == 0) && (GetLastError() == ERROR_ACCESS_DENIED)) \
 111     { \
 112         if (!access_denied_reported) { \
 113             access_denied_reported++; \
 114             skip("More access rights are required for many tests\n"); \
 115         } \
 116         return; \
 117     }
 118
 119 /* ################################ */
 120
 121 static BOOL on_win9x = FALSE;
 122
 123 static BOOL check_win9x(void)
 124 {
 125     if (pGetPrinterW)
 126     {
 127         SetLastError(0xdeadbeef);
 128         pGetPrinterW(NULL, 0, NULL, 0, NULL);
 129         return (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED);
 130     }
 131     else
 132     {
 133         return TRUE;
 134     }
 135 }
 136
 137 static void find_default_printer(VOID)
 138 {
 139     static  char    buffer[DEFAULT_PRINTER_SIZE];
 140     DWORD   needed;
 141     DWORD   res;
 142     LPSTR   ptr;
 143
 144     if ((default_printer == NULL) && (pGetDefaultPrinterA))
 145     {
 146         /* w2k and above */
 147         needed = sizeof(buffer);
 148         res = pGetDefaultPrinterA(buffer, &needed);
 149         if(res)  default_printer = buffer;
 150         trace("default_printer: '%s'\n", default_printer ? default_printer : "(null)");
 151     }
 152     if (default_printer == NULL)
 153     {
 154         HKEY hwindows;
 155         DWORD   type;
 156         /* NT 3.x and above */
 157         if (RegOpenKeyEx(HKEY_CURRENT_USER,
 158                         "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows",
 159                         0, KEY_QUERY_VALUE, &hwindows) == NO_ERROR) {
 160
 161             needed = sizeof(buffer);
 162             if (RegQueryValueEx(hwindows, "device", NULL,
 163                                 &type, (LPBYTE)buffer, &needed) == NO_ERROR) {
 164
 165                 ptr = strchr(buffer, ',');
 166                 if (ptr) {
 167                     ptr[0] = '\0';
 168                     default_printer = buffer;
 169                 }
 170             }
 171             RegCloseKey(hwindows);
 172         }
 173         trace("default_printer: '%s'\n", default_printer ? default_printer : "(null)");
 174     }
 175     if (default_printer == NULL)
 176     {
 177         /* win9x */
 178         needed = sizeof(buffer);
 179         res = GetProfileStringA("windows", "device", "*", buffer, needed);
 180         if(res) {
 181             ptr = strchr(buffer, ',');
 182             if (ptr) {
 183                 ptr[0] = '\0';
 184                 default_printer = buffer;
 185             }
 186         }
 187         trace("default_printer: '%s'\n", default_printer ? default_printer : "(null)");
 188     }
 189 }
 190
 191
 192 static struct monitor_entry * find_installed_monitor(void)
 193 {
 194     MONITOR_INFO_2A mi2a;
 195     static struct  monitor_entry * entry = NULL;
 196     DWORD   num_tests;
 197     DWORD   i = 0;
 198
 199     static struct monitor_entry  monitor_table[] = {
 200         {env_win9x_case, "localspl.dll"},
 201         {env_x86,        "localspl.dll"},
 202         {env_x64,        "localspl.dll"},
 203         {env_win9x_case, "localmon.dll"},
 204         {env_x86,        "localmon.dll"},
 205         {env_win9x_case, "tcpmon.dll"},
 206         {env_x86,        "tcpmon.dll"},
 207         {env_win9x_case, "usbmon.dll"},
 208         {env_x86,        "usbmon.dll"},
 209         {env_win9x_case, "mspp32.dll"},
 210         {env_x86,        "win32spl.dll"},
 211         {env_x86,        "redmonnt.dll"},
 212         {env_x86,        "redmon35.dll"},
 213         {env_win9x_case, "redmon95.dll"},
 214         {env_x86,        "pdfcmnnt.dll"},
 215         {env_win9x_case, "pdfcmn95.dll"},
 216     };
 217
 218     if (entry) return entry;
 219
 220     num_tests = (sizeof(monitor_table)/sizeof(struct monitor_entry));
 221
 222     /* cleanup */
 223     DeleteMonitorA(NULL, env_x64, winetest);
 224     DeleteMonitorA(NULL, env_x86, winetest);
 225     DeleteMonitorA(NULL, env_win9x_case, winetest);
 226
 227     /* find a usable monitor from the table */
 228     mi2a.pName = winetest;
 229     while ((entry == NULL) && (i < num_tests)) {
 230         entry = &monitor_table[i];
 231         i++;
 232         mi2a.pEnvironment = entry->env;
 233         mi2a.pDLLName = entry->dllname;
 234
 235         if (AddMonitorA(NULL, 2, (LPBYTE) &mi2a)) {
 236             /* we got one */
 237             trace("using '%s', '%s'\n", entry->env, entry->dllname);
 238             DeleteMonitorA(NULL, entry->env, winetest);
 239         }
 240         else
 241         {
 242             entry = NULL;
 243         }
 244     }
 245     return entry;
 246 }
 247
 248
 249 /* ########################### */
 250
 251 static void find_local_server(VOID)
 252 {
 253     static  char    buffer[MAX_PATH];
 254     DWORD   res;
 255     DWORD   size;
 256
 257     size = sizeof(buffer) - 3 ;
 258     buffer[0] = '\\';
 259     buffer[1] = '\\';
 260     buffer[2] = '\0';
 261
 262     SetLastError(0xdeadbeef);
 263     res = GetComputerNameA(&buffer[2], &size);
 264     trace("returned %d with %d and %d: '%s'\n", res, GetLastError(), size, buffer);
 265
 266     ok( res != 0, "returned %d with %d and %d: '%s' (expected '!= 0')\n",
 267         res, GetLastError(), size, buffer);
 268
 269     if (res) local_server = buffer;
 270 }
 271
 272 /* ########################### */
 273
 274 static void find_tempfile(VOID)
 275 {
 276     static CHAR buffer_dirA[MAX_PATH];
 277     static CHAR buffer_fileA[MAX_PATH];
 278     static WCHAR buffer_dirW[MAX_PATH];
 279     static WCHAR buffer_fileW[MAX_PATH];
 280     DWORD   res;
 281     int     resint;
 282
 283     memset(buffer_dirA, 0, MAX_PATH - 1);
 284     buffer_dirA[MAX_PATH - 1] = '\0';
 285     SetLastError(0xdeadbeef);
 286     res = GetTempPathA(MAX_PATH, buffer_dirA);
 287     ok(res, "returned %u with %u and '%s' (expected '!= 0')\n", res, GetLastError(), buffer_dirA);
 288     if (res == 0) return;
 289
 290     memset(buffer_fileA, 0, MAX_PATH - 1);
 291     buffer_fileA[MAX_PATH - 1] = '\0';
 292     SetLastError(0xdeadbeef);
 293     res = GetTempFileNameA(buffer_dirA, winetest, 0, buffer_fileA);
 294     ok(res, "returned %u with %u and '%s' (expected '!= 0')\n", res, GetLastError(), buffer_fileA);
 295     if (res == 0) return;
 296
 297     SetLastError(0xdeadbeef);
 298     resint = MultiByteToWideChar(CP_ACP, 0, buffer_dirA, -1, buffer_dirW, MAX_PATH);
 299     ok(res, "returned %u with %u (expected '!= 0')\n", resint, GetLastError());
 300     if (resint == 0) return;
 301
 302     SetLastError(0xdeadbeef);
 303     resint = MultiByteToWideChar(CP_ACP, 0, buffer_fileA, -1, buffer_fileW, MAX_PATH);
 304     ok(res, "returned %u with %u (expected '!= 0')\n", resint, GetLastError());
 305     if (resint == 0) return;
 306
 307     tempdirA  = buffer_dirA;
 308     tempfileA = buffer_fileA;
 309     tempdirW  = buffer_dirW;
 310     tempfileW = buffer_fileW;
 311     trace("tempfile: '%s'\n", tempfileA);
 312 }
 313
 314 /* ########################### */
 315
 316 static void test_AddMonitor(void)
 317 {
 318     MONITOR_INFO_2A mi2a;
 319     struct  monitor_entry * entry = NULL;
 320     DWORD   res;
 321
 322     entry = find_installed_monitor();
 323
 324     SetLastError(MAGIC_DEAD);
 325     res = AddMonitorA(NULL, 1, NULL);
 326     ok(!res && (GetLastError() == ERROR_INVALID_LEVEL),
 327         "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
 328         res, GetLastError());
 329
 330     SetLastError(MAGIC_DEAD);
 331     res = AddMonitorA(NULL, 3, NULL);
 332     ok(!res && (GetLastError() == ERROR_INVALID_LEVEL),
 333         "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
 334         res, GetLastError());
 335
 336     if (0)
 337     {
 338     /* This test crashes win9x on vmware (works with win9x on qemu 0.8.1) */
 339     SetLastError(MAGIC_DEAD);
 340     res = AddMonitorA(NULL, 2, NULL);
 341     /* NT: unchanged,  9x: ERROR_PRIVILEGE_NOT_HELD */
 342     ok(!res &&
 343         ((GetLastError() == MAGIC_DEAD) ||
 344          (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)),
 345         "returned %d with %d (expected '0' with: MAGIC_DEAD or "
 346         "ERROR_PRIVILEGE_NOT_HELD)\n", res, GetLastError());
 347     }
 348
 349     ZeroMemory(&mi2a, sizeof(MONITOR_INFO_2A));
 350     SetLastError(MAGIC_DEAD);
 351     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 352     RETURN_ON_DEACTIVATED_SPOOLER(res)
 353     RETURN_ON_ACCESS_DENIED(res)
 354
 355     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_INVALID_ENVIRONMENT */
 356     ok(!res && ((GetLastError() == ERROR_INVALID_PARAMETER) ||
 357                 (GetLastError() == ERROR_INVALID_ENVIRONMENT)),
 358         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or "
 359         "ERROR_INVALID_ENVIRONMENT)\n", res, GetLastError());
 360
 361     if (!entry) {
 362         skip("No usable Monitor found\n");
 363         return;
 364     }
 365
 366     if (0)
 367     {
 368     /* The test is deactivated, because when mi2a.pName is NULL, the subkey
 369        HKLM\System\CurrentControlSet\Control\Print\Monitors\C:\WINDOWS\SYSTEM
 370        or HKLM\System\CurrentControlSet\Control\Print\Monitors\ì
 371        is created on win9x and we do not want to hit this bug here. */
 372
 373     mi2a.pEnvironment = entry->env;
 374     SetLastError(MAGIC_DEAD);
 375     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 376     ok(res, "AddMonitor error %d\n", GetLastError());
 377     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_PRIVILEGE_NOT_HELD */
 378     }
 379
 380     mi2a.pEnvironment = entry->env;
 381     mi2a.pName = empty;
 382     SetLastError(MAGIC_DEAD);
 383     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 384     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_PRIVILEGE_NOT_HELD */
 385     ok( !res &&
 386         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
 387          (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)),
 388         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or "
 389         "ERROR_PRIVILEGE_NOT_HELD)\n",
 390         res, GetLastError());
 391
 392     mi2a.pName = winetest;
 393     SetLastError(MAGIC_DEAD);
 394     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 395     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_PRIVILEGE_NOT_HELD */
 396     ok( !res &&
 397         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
 398          (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)),
 399         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or "
 400         "ERROR_PRIVILEGE_NOT_HELD)\n",
 401         res, GetLastError());
 402
 403     mi2a.pDLLName = empty;
 404     SetLastError(MAGIC_DEAD);
 405     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 406     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 407         "returned %d with %d (expected '0' with ERROR_INVALID_PARAMETER)\n",
 408         res, GetLastError());
 409
 410     mi2a.pDLLName = does_not_exist_dll;
 411     SetLastError(MAGIC_DEAD);
 412     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 413     /* NT: ERROR_MOD_NOT_FOUND,  9x: ERROR_INVALID_PARAMETER */
 414     ok( !res &&
 415         ((GetLastError() == ERROR_MOD_NOT_FOUND) ||
 416         (GetLastError() == ERROR_INVALID_PARAMETER)),
 417         "returned %d with %d (expected '0' with: ERROR_MOD_NOT_FOUND or "
 418         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 419
 420     mi2a.pDLLName = version_dll;
 421     SetLastError(MAGIC_DEAD);
 422     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 423     /* NT: ERROR_PROC_NOT_FOUND,  9x: ERROR_INVALID_PARAMETER */
 424     ok( !res &&
 425         ((GetLastError() == ERROR_PROC_NOT_FOUND) ||
 426         (GetLastError() == ERROR_INVALID_PARAMETER)),
 427         "returned %d with %d (expected '0' with: ERROR_PROC_NOT_FOUND or "
 428         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 429     if (res) DeleteMonitorA(NULL, entry->env, winetest);
 430
 431    /* Test AddMonitor with real options */
 432     mi2a.pDLLName = entry->dllname;
 433     SetLastError(MAGIC_DEAD);
 434     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 435     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
 436
 437     /* add a monitor twice */
 438     SetLastError(MAGIC_DEAD);
 439     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 440     /* NT: ERROR_PRINT_MONITOR_ALREADY_INSTALLED (3006), 9x: ERROR_ALREADY_EXISTS (183) */
 441     ok( !res &&
 442         ((GetLastError() == ERROR_PRINT_MONITOR_ALREADY_INSTALLED) ||
 443         (GetLastError() == ERROR_ALREADY_EXISTS)),
 444         "returned %d with %d (expected '0' with: "
 445         "ERROR_PRINT_MONITOR_ALREADY_INSTALLED or ERROR_ALREADY_EXISTS)\n",
 446         res, GetLastError());
 447
 448     DeleteMonitorA(NULL, entry->env, winetest);
 449     SetLastError(MAGIC_DEAD);
 450     res = AddMonitorA(empty, 2, (LPBYTE) &mi2a);
 451     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
 452
 453     /* cleanup */
 454     DeleteMonitorA(NULL, entry->env, winetest);
 455
 456 }
 457
 458 /* ########################### */
 459
 460 static void test_AddPort(void)
 461 {
 462     DWORD   res;
 463
 464     SetLastError(0xdeadbeef);
 465     res = AddPortA(NULL, 0, NULL);
 466     RETURN_ON_DEACTIVATED_SPOOLER(res)
 467     /* NT: RPC_X_NULL_REF_POINTER, 9x: ERROR_INVALID_PARAMETER */
 468     ok( !res && ((GetLastError() == RPC_X_NULL_REF_POINTER) ||
 469                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 470         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 471         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 472
 473
 474     SetLastError(0xdeadbeef);
 475     res = AddPortA(NULL, 0, empty);
 476     /* Allowed only for (Printer-)Administrators */
 477     RETURN_ON_ACCESS_DENIED(res)
 478
 479     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
 480     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) ||
 481                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 482         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 483         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 484
 485
 486     SetLastError(0xdeadbeef);
 487     res = AddPortA(NULL, 0, does_not_exist);
 488     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
 489     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) ||
 490                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 491         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 492         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 493
 494 }
 495
 496 /* ########################### */
 497
 498 static void test_AddPortEx(void)
 499 {
 500     PORT_INFO_2A pi;
 501     DWORD   res;
 502
 503
 504     if (!pAddPortExA) {
 505         win_skip("AddPortEx not supported\n");
 506         return;
 507     }
 508
 509     /* start test with a clean system */
 510     DeletePortA(NULL, 0, tempfileA);
 511
 512     pi.pPortName = tempfileA;
 513     SetLastError(0xdeadbeef);
 514     res = pAddPortExA(NULL, 1, (LPBYTE) &pi, LocalPortA);
 515     RETURN_ON_DEACTIVATED_SPOOLER(res)
 516
 517     /* Allowed only for (Printer-)Administrators.
 518        W2K+XP: ERROR_INVALID_PARAMETER  */
 519     if (!res && (GetLastError() == ERROR_INVALID_PARAMETER)) {
 520         skip("ACCESS_DENIED (ERROR_INVALID_PARAMETER)\n");
 521         return;
 522     }
 523     ok( res, "got %u with %u (expected '!= 0')\n", res, GetLastError());
 524
 525     /* add a port that already exists */
 526     SetLastError(0xdeadbeef);
 527     res = pAddPortExA(NULL, 1, (LPBYTE) &pi, LocalPortA);
 528     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 529         "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
 530         res, GetLastError());
 531     DeletePortA(NULL, 0, tempfileA);
 532
 533
 534     /* the Monitorname must match */
 535     SetLastError(0xdeadbeef);
 536     res = pAddPortExA(NULL, 1, (LPBYTE) &pi, NULL);
 537     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 538         "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
 539         res, GetLastError());
 540     if (res) DeletePortA(NULL, 0, tempfileA);
 541
 542     SetLastError(0xdeadbeef);
 543     res = pAddPortExA(NULL, 1, (LPBYTE) &pi, empty);
 544     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 545         "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
 546         res, GetLastError());
 547     if (res) DeletePortA(NULL, 0, tempfileA);
 548
 549     SetLastError(0xdeadbeef);
 550     res = pAddPortExA(NULL, 1, (LPBYTE) &pi, does_not_exist);
 551     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 552         "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
 553         res, GetLastError());
 554     if (res) DeletePortA(NULL, 0, tempfileA);
 555
 556
 557     /* We need a Portname */
 558     SetLastError(0xdeadbeef);
 559     res = pAddPortExA(NULL, 1, NULL, LocalPortA);
 560     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 561         "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
 562         res, GetLastError());
 563
 564     pi.pPortName = NULL;
 565     SetLastError(0xdeadbeef);
 566     res = pAddPortExA(NULL, 1, (LPBYTE) &pi, LocalPortA);
 567     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
 568         "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n",
 569         res, GetLastError());
 570     if (res) DeletePortA(NULL, 0, tempfileA);
 571
 572
 573     /*  level 2 is documented as supported for Printmonitors,
 574         but that is not supported for "Local Port" (localspl.dll) and
 575         AddPortEx fails with ERROR_INVALID_LEVEL */
 576
 577     pi.pPortName = tempfileA;
 578     pi.pMonitorName = LocalPortA;
 579     pi.pDescription = winetest;
 580     pi.fPortType = PORT_TYPE_WRITE;
 581
 582     SetLastError(0xdeadbeef);
 583     res = pAddPortExA(NULL, 2, (LPBYTE) &pi, LocalPortA);
 584     ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
 585         "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
 586         res, GetLastError());
 587     if (res) DeletePortA(NULL, 0, tempfileA);
 588
 589
 590     /* invalid levels */
 591     SetLastError(0xdeadbeef);
 592     res = pAddPortExA(NULL, 0, (LPBYTE) &pi, LocalPortA);
 593     ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
 594         "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
 595         res, GetLastError());
 596
 597     SetLastError(0xdeadbeef);
 598     res = pAddPortExA(NULL, 3, (LPBYTE) &pi, LocalPortA);
 599     ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
 600         "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
 601         res, GetLastError());
 602
 603
 604     /* cleanup */
 605     DeletePortA(NULL, 0, tempfileA);
 606
 607 }
 608
 609 /* ########################### */
 610
 611 static void test_ConfigurePort(void)
 612 {
 613     DWORD   res;
 614
 615
 616     SetLastError(0xdeadbeef);
 617     res = ConfigurePortA(NULL, 0, NULL);
 618     RETURN_ON_DEACTIVATED_SPOOLER(res)
 619     /* NT: RPC_X_NULL_REF_POINTER, 9x: ERROR_INVALID_PARAMETER */
 620     ok( !res && ((GetLastError() == RPC_X_NULL_REF_POINTER) ||
 621                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 622         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 623         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 624
 625     SetLastError(0xdeadbeef);
 626     res = ConfigurePortA(NULL, 0, empty);
 627     /* Allowed only for (Printer-)Administrators */
 628     RETURN_ON_ACCESS_DENIED(res)
 629
 630     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
 631     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) ||
 632                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 633         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 634         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 635
 636
 637     SetLastError(0xdeadbeef);
 638     res = ConfigurePortA(NULL, 0, does_not_exist);
 639     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
 640     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) ||
 641                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 642         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 643         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 644
 645
 646     /*  Testing-Results:
 647         - Case of Portnames is ignored
 648         - Portname without ":" => NT: ERROR_NOT_SUPPORTED, 9x: Dialog comes up
 649         - Empty Servername (LPT1:) => NT: ERROR_NOT_SUPPORTED, 9x: Dialog comes up
 650
 651         - Port not present =>  9x: ERROR_INVALID_PARAMETER, NT:ERROR_NOT_SUPPORTED
 652         - "FILE:" => 9x:Success, NT:ERROR_CANCELED
 653         - Cancel ("Local Port") => ERROR_CANCELED
 654         - Cancel ("Redirected Port") => Success
 655     */
 656     if (winetest_interactive > 0) {
 657         SetLastError(0xdeadbeef);
 658         res = ConfigurePortA(NULL, 0, portname_com1);
 659         trace("'%s' returned %d with %d\n", portname_com1, res, GetLastError());
 660
 661         SetLastError(0xdeadbeef);
 662         res = ConfigurePortA(NULL, 0, portname_lpt1);
 663         trace("'%s' returned %d with %d\n", portname_lpt1, res, GetLastError());
 664
 665         SetLastError(0xdeadbeef);
 666         res = ConfigurePortA(NULL, 0, portname_file);
 667         trace("'%s' returned %d with %d\n", portname_file, res, GetLastError());
 668     }
 669 }
 670
 671 /* ########################### */
 672
 673 static void test_DeleteMonitor(void)
 674 {
 675     MONITOR_INFO_2A         mi2a;
 676     struct monitor_entry  * entry = NULL;
 677     DWORD                   res;
 678
 679
 680     entry = find_installed_monitor();
 681
 682     if (!entry) {
 683         skip("No usable Monitor found\n");
 684         return;
 685     }
 686
 687     mi2a.pName = winetest;
 688     mi2a.pEnvironment = entry->env;
 689     mi2a.pDLLName = entry->dllname;
 690
 691     /* Testing DeleteMonitor with real options */
 692     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 693
 694     SetLastError(MAGIC_DEAD);
 695     res = DeleteMonitorA(NULL, entry->env, winetest);
 696     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
 697
 698     /* Delete the Monitor twice */
 699     SetLastError(MAGIC_DEAD);
 700     res = DeleteMonitorA(NULL, entry->env, winetest);
 701     /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
 702     ok( !res &&
 703         ((GetLastError() == ERROR_UNKNOWN_PRINT_MONITOR) ||
 704         (GetLastError() == ERROR_INVALID_PARAMETER)),
 705         "returned %d with %d (expected '0' with: ERROR_UNKNOWN_PRINT_MONITOR"
 706         " or ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 707
 708     /* the environment */
 709     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 710     SetLastError(MAGIC_DEAD);
 711     res = DeleteMonitorA(NULL, NULL, winetest);
 712     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
 713
 714     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 715     SetLastError(MAGIC_DEAD);
 716     res = DeleteMonitorA(NULL, empty, winetest);
 717     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
 718
 719     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 720     SetLastError(MAGIC_DEAD);
 721     res = DeleteMonitorA(NULL, invalid_env, winetest);
 722     ok( res ||
 723         (!res && GetLastError() == ERROR_INVALID_ENVIRONMENT) /* Vista/W2K8 */,
 724         "returned %d with %d\n", res, GetLastError());
 725
 726     /* the monitor-name */
 727     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 728     SetLastError(MAGIC_DEAD);
 729     res = DeleteMonitorA(NULL, entry->env, NULL);
 730     /* NT: ERROR_INVALID_PARAMETER (87),  9x: ERROR_INVALID_NAME (123)*/
 731     ok( !res &&
 732         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
 733         (GetLastError() == ERROR_INVALID_NAME)),
 734         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or "
 735         "ERROR_INVALID_NAME)\n", res, GetLastError());
 736
 737     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 738     SetLastError(MAGIC_DEAD);
 739     res = DeleteMonitorA(NULL, entry->env, empty);
 740     /* NT: ERROR_INVALID_PARAMETER (87),  9x: ERROR_INVALID_NAME (123)*/
 741     ok( !res &&
 742         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
 743         (GetLastError() == ERROR_INVALID_NAME)),
 744         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or "
 745         "ERROR_INVALID_NAME)\n", res, GetLastError());
 746
 747     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
 748     SetLastError(MAGIC_DEAD);
 749     res = DeleteMonitorA(empty, entry->env, winetest);
 750     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
 751
 752     /* cleanup */
 753     DeleteMonitorA(NULL, entry->env, winetest);
 754 }
 755
 756 /* ########################### */
 757
 758 static void test_DeletePort(void)
 759 {
 760     DWORD   res;
 761
 762     SetLastError(0xdeadbeef);
 763     res = DeletePortA(NULL, 0, NULL);
 764     RETURN_ON_DEACTIVATED_SPOOLER(res)
 765
 766     SetLastError(0xdeadbeef);
 767     res = DeletePortA(NULL, 0, empty);
 768     /* Allowed only for (Printer-)Administrators */
 769     RETURN_ON_ACCESS_DENIED(res)
 770
 771     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
 772     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) ||
 773                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 774         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 775         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 776
 777
 778     SetLastError(0xdeadbeef);
 779     res = DeletePortA(NULL, 0, does_not_exist);
 780     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
 781     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) ||
 782                  (GetLastError() == ERROR_INVALID_PARAMETER)),
 783         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or "
 784         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
 785
 786 }
 787
 788 /* ########################### */
 789
 790 static void test_EnumForms(LPSTR pName)
 791 {
 792     DWORD   res;
 793     HANDLE  hprinter = 0;
 794     LPBYTE  buffer;
 795     DWORD   cbBuf;
 796     DWORD   pcbNeeded;
 797     DWORD   pcReturned;
 798     DWORD   level;
 799     UINT    i;
 800     const char *formtype;
 801     static const char * const formtypes[] = { "FORM_USER", "FORM_BUILTIN", "FORM_PRINTER", "FORM_flag_unknown" };
 802 #define FORMTYPE_MAX 2
 803     PFORM_INFO_1A pFI_1a;
 804     PFORM_INFO_2A pFI_2a;
 805
 806     res = OpenPrinter(pName, &hprinter, NULL);
 807     RETURN_ON_DEACTIVATED_SPOOLER(res)
 808     if (!res || !hprinter)
 809     {
 810         /* opening the local Printserver is not supported on win9x */
 811         if (pName) skip("Failed to open '%s' (not supported on win9x)\n", pName);
 812         return;
 813     }
 814
 815     /* valid levels are 1 and 2 */
 816     for(level = 0; level < 4; level++) {
 817         cbBuf = 0xdeadbeef;
 818         pcReturned = 0xdeadbeef;
 819         SetLastError(0xdeadbeef);
 820         res = EnumFormsA(hprinter, level, NULL, 0, &cbBuf, &pcReturned);
 821
 822         /* EnumForms is not implemented on win9x */
 823         if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) continue;
 824
 825         /* EnumForms for the server is not implemented on all NT-versions */
 826         if (!res && (GetLastError() == ERROR_INVALID_HANDLE) && !pName) continue;
 827
 828         /* Level 2 for EnumForms is not supported on all systems */
 829         if (!res && (GetLastError() == ERROR_INVALID_LEVEL) && (level == 2)) continue;
 830
 831         /* use only a short test when testing an invalid level */
 832         if(!level || (level > 2)) {
 833             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
 834                 (res && (pcReturned == 0)),
 835                 "(%d) returned %d with %d and 0x%08x (expected '0' with "
 836                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
 837                 level, res, GetLastError(), pcReturned);
 838             continue;
 839         }
 840
 841         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 842             "(%d) returned %d with %d (expected '0' with "
 843             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
 844
 845         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
 846         if (buffer == NULL) continue;
 847
 848         SetLastError(0xdeadbeef);
 849         res = EnumFormsA(hprinter, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
 850         ok(res, "(%d) returned %d with %d (expected '!=0')\n",
 851                 level, res, GetLastError());
 852
 853         if (winetest_debug > 1) {
 854             trace("dumping %d forms level %d\n", pcReturned, level);
 855             pFI_1a = (PFORM_INFO_1A)buffer;
 856             pFI_2a = (PFORM_INFO_2A)buffer;
 857             for (i = 0; i < pcReturned; i++)
 858             {
 859                 /* first part is same in FORM_INFO_1 and FORM_INFO_2 */
 860                 formtype = (pFI_1a->Flags <= FORMTYPE_MAX) ? formtypes[pFI_1a->Flags] : formtypes[3];
 861                 trace("%u (%s): %.03fmm x %.03fmm, %s\n", i, pFI_1a->pName,
 862                       (float)pFI_1a->Size.cx/1000, (float)pFI_1a->Size.cy/1000, formtype);
 863
 864                 if (level == 1) pFI_1a ++;
 865                 else {
 866                     /* output additional FORM_INFO_2 fields */
 867                     trace("\tkeyword=%s strtype=%u muidll=%s resid=%u dispname=%s langid=%u\n",
 868                           pFI_2a->pKeyword, pFI_2a->StringType, pFI_2a->pMuiDll,
 869                           pFI_2a->dwResourceId, pFI_2a->pDisplayName, pFI_2a->wLangId);
 870
 871                     /* offset pointer pFI_1a by 1*sizeof(FORM_INFO_2A) Bytes */
 872                     pFI_2a ++;
 873                     pFI_1a = (PFORM_INFO_1A)pFI_2a;
 874                 }
 875             }
 876         }
 877
 878         SetLastError(0xdeadbeef);
 879         res = EnumFormsA(hprinter, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
 880         ok( res, "(%d) returned %d with %d (expected '!=0')\n",
 881             level, res, GetLastError());
 882
 883         SetLastError(0xdeadbeef);
 884         res = EnumFormsA(hprinter, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
 885         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 886             "(%d) returned %d with %d (expected '0' with "
 887             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
 888
 889
 890         SetLastError(0xdeadbeef);
 891         res = EnumFormsA(hprinter, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
 892         ok( !res && (GetLastError() == ERROR_INVALID_USER_BUFFER) ,
 893             "(%d) returned %d with %d (expected '0' with "
 894             "ERROR_INVALID_USER_BUFFER)\n", level, res, GetLastError());
 895
 896
 897         SetLastError(0xdeadbeef);
 898         res = EnumFormsA(hprinter, level, buffer, cbBuf, NULL, &pcReturned);
 899         ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER) ,
 900             "(%d) returned %d with %d (expected '0' with "
 901             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
 902
 903         SetLastError(0xdeadbeef);
 904         res = EnumFormsA(hprinter, level, buffer, cbBuf, &pcbNeeded, NULL);
 905         ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER) ,
 906             "(%d) returned %d with %d (expected '0' with "
 907             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
 908
 909         SetLastError(0xdeadbeef);
 910         res = EnumFormsA(0, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
 911         ok( !res && (GetLastError() == ERROR_INVALID_HANDLE) ,
 912             "(%d) returned %d with %d (expected '0' with "
 913             "ERROR_INVALID_HANDLE)\n", level, res, GetLastError());
 914
 915         HeapFree(GetProcessHeap(), 0, buffer);
 916     } /* for(level ... */
 917
 918     ClosePrinter(hprinter);
 919 }
 920
 921 /* ########################### */
 922
 923 static void test_EnumMonitors(void)
 924 {
 925     DWORD   res;
 926     LPBYTE  buffer;
 927     DWORD   cbBuf;
 928     DWORD   pcbNeeded;
 929     DWORD   pcReturned;
 930     DWORD   level;
 931
 932     /* valid levels are 1 and 2 */
 933     for(level = 0; level < 4; level++) {
 934         cbBuf = MAGIC_DEAD;
 935         pcReturned = MAGIC_DEAD;
 936         SetLastError(MAGIC_DEAD);
 937         res = EnumMonitorsA(NULL, level, NULL, 0, &cbBuf, &pcReturned);
 938
 939         RETURN_ON_DEACTIVATED_SPOOLER(res)
 940
 941         /* not implemented yet in wine */
 942         if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) continue;
 943
 944
 945         /* use only a short test when testing an invalid level */
 946         if(!level || (level > 2)) {
 947             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
 948                 (res && (pcReturned == 0)),
 949                 "(%d) returned %d with %d and 0x%08x (expected '0' with "
 950                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
 951                 level, res, GetLastError(), pcReturned);
 952             continue;
 953         }
 954
 955         /* Level 2 is not supported on win9x */
 956         if (!res && (GetLastError() == ERROR_INVALID_LEVEL)) {
 957             skip("Level %d not supported\n", level);
 958             continue;
 959         }
 960
 961         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 962             "(%d) returned %d with %d (expected '0' with "
 963             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
 964
 965         if (!cbBuf) {
 966             skip("no valid buffer size returned\n");
 967             continue;
 968         }
 969
 970         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
 971         if (buffer == NULL) continue;
 972
 973         SetLastError(MAGIC_DEAD);
 974         pcbNeeded = MAGIC_DEAD;
 975         res = EnumMonitorsA(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
 976         ok(res, "(%d) returned %d with %d (expected '!=0')\n",
 977                 level, res, GetLastError());
 978         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n",
 979                 level, pcbNeeded, cbBuf);
 980         /* We can validate the returned Data with the Registry here */
 981
 982
 983         SetLastError(MAGIC_DEAD);
 984         pcReturned = MAGIC_DEAD;
 985         pcbNeeded = MAGIC_DEAD;
 986         res = EnumMonitorsA(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
 987         ok(res, "(%d) returned %d with %d (expected '!=0')\n", level,
 988                 res, GetLastError());
 989         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level,
 990                 pcbNeeded, cbBuf);
 991
 992         SetLastError(MAGIC_DEAD);
 993         pcbNeeded = MAGIC_DEAD;
 994         res = EnumMonitorsA(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
 995         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 996             "(%d) returned %d with %d (expected '0' with "
 997             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
 998
 999         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level,
1000                 pcbNeeded, cbBuf);
1001
1002 /*
1003       Do not add the next test:
1004       w2k+:  RPC_X_NULL_REF_POINTER
1005       NT3.5: ERROR_INVALID_USER_BUFFER
1006       win9x: crash in winspool.drv
1007
1008       res = EnumMonitorsA(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
1009 */
1010
1011         SetLastError(MAGIC_DEAD);
1012         pcbNeeded = MAGIC_DEAD;
1013         pcReturned = MAGIC_DEAD;
1014         res = EnumMonitorsA(NULL, level, buffer, cbBuf, NULL, &pcReturned);
1015         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
1016             "(%d) returned %d with %d (expected '!=0' or '0' with "
1017             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
1018
1019         pcbNeeded = MAGIC_DEAD;
1020         pcReturned = MAGIC_DEAD;
1021         SetLastError(MAGIC_DEAD);
1022         res = EnumMonitorsA(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
1023         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
1024             "(%d) returned %d with %d (expected '!=0' or '0' with "
1025             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
1026
1027         HeapFree(GetProcessHeap(), 0, buffer);
1028     } /* for(level ... */
1029 }
1030
1031 /* ########################### */
1032
1033 static void test_EnumPorts(void)
1034 {
1035     DWORD   res;
1036     DWORD   level;
1037     LPBYTE  buffer;
1038     DWORD   cbBuf;
1039     DWORD   pcbNeeded;
1040     DWORD   pcReturned;
1041
1042     /* valid levels are 1 and 2 */
1043     for(level = 0; level < 4; level++) {
1044
1045         cbBuf = 0xdeadbeef;
1046         pcReturned = 0xdeadbeef;
1047         SetLastError(0xdeadbeef);
1048         res = EnumPortsA(NULL, level, NULL, 0, &cbBuf, &pcReturned);
1049         RETURN_ON_DEACTIVATED_SPOOLER(res)
1050
1051         /* use only a short test when testing an invalid level */
1052         if(!level || (level > 2)) {
1053             /* NT: ERROR_INVALID_LEVEL, 9x: success */
1054             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
1055                 (res && (pcReturned == 0)),
1056                 "(%d) returned %d with %d and 0x%08x (expected '0' with "
1057                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
1058                 level, res, GetLastError(), pcReturned);
1059             continue;
1060         }
1061
1062
1063         /* Level 2 is not supported on NT 3.x */
1064         if (!res && (GetLastError() == ERROR_INVALID_LEVEL)) {
1065             skip("Level %d not supported\n", level);
1066             continue;
1067         }
1068
1069         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1070             "(%d) returned %d with %d (expected '0' with "
1071             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
1072
1073         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
1074         if (buffer == NULL) continue;
1075
1076         pcbNeeded = 0xdeadbeef;
1077         SetLastError(0xdeadbeef);
1078         res = EnumPortsA(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
1079         ok(res, "(%d) returned %d with %d (expected '!=0')\n", level, res, GetLastError());
1080         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
1081         /* ToDo: Compare the returned Data with the Registry / "win.ini",[Ports] here */
1082
1083         pcbNeeded = 0xdeadbeef;
1084         pcReturned = 0xdeadbeef;
1085         SetLastError(0xdeadbeef);
1086         res = EnumPortsA(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
1087         ok(res, "(%d) returned %d with %d (expected '!=0')\n", level, res, GetLastError());
1088         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
1089
1090         pcbNeeded = 0xdeadbeef;
1091         SetLastError(0xdeadbeef);
1092         res = EnumPortsA(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
1093         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1094             "(%d) returned %d with %d (expected '0' with "
1095             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
1096         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
1097
1098         /*
1099           Do not add this test:
1100           res = EnumPortsA(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
1101           w2k+:  RPC_X_NULL_REF_POINTER
1102           NT3.5: ERROR_INVALID_USER_BUFFER
1103           win9x: crash in winspool.drv
1104          */
1105
1106         SetLastError(0xdeadbeef);
1107         res = EnumPorts(NULL, level, buffer, cbBuf, NULL, &pcReturned);
1108         /* NT: RPC_X_NULL_REF_POINTER (1780),  9x: success */
1109         ok( (!res && (GetLastError() == RPC_X_NULL_REF_POINTER) ) ||
1110             ( res && (GetLastError() == ERROR_SUCCESS) ),
1111             "(%d) returned %d with %d (expected '0' with "
1112             "RPC_X_NULL_REF_POINTER or '!=0' with NO_ERROR)\n",
1113             level, res, GetLastError());
1114
1115
1116         SetLastError(0xdeadbeef);
1117         res = EnumPorts(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
1118         /* NT: RPC_X_NULL_REF_POINTER (1780),  9x: success */
1119         ok( (!res && (GetLastError() == RPC_X_NULL_REF_POINTER) ) ||
1120             ( res && (GetLastError() == ERROR_SUCCESS) ),
1121             "(%d) returned %d with %d (expected '0' with "
1122             "RPC_X_NULL_REF_POINTER or '!=0' with NO_ERROR)\n",
1123             level, res, GetLastError());
1124
1125         HeapFree(GetProcessHeap(), 0, buffer);
1126     }
1127 }
1128
1129 /* ########################### */
1130
1131 static void test_EnumPrinterDrivers(void)
1132 {
1133     static char env_all[] = "all";
1134
1135     DWORD   res;
1136     LPBYTE  buffer;
1137     DWORD   cbBuf;
1138     DWORD   pcbNeeded;
1139     DWORD   pcReturned;
1140     DWORD   level;
1141
1142     /* 1-3 for w95/w98/NT4; 1-3+6 for me; 1-6 for w2k/xp/2003; 1-6+8 for vista */
1143     for(level = 0; level < 10; level++) {
1144         cbBuf = 0xdeadbeef;
1145         pcReturned = 0xdeadbeef;
1146         SetLastError(0xdeadbeef);
1147         res = EnumPrinterDriversA(NULL, NULL, level, NULL, 0, &cbBuf, &pcReturned);
1148         RETURN_ON_DEACTIVATED_SPOOLER(res)
1149
1150         /* use only a short test when testing an invalid level */
1151         if(!level || (level == 7) || (level > 8)) {
1152
1153             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
1154                 (res && (pcReturned == 0)),
1155                 "(%d) got %u with %u and 0x%x "
1156                 "(expected '0' with ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
1157                 level, res, GetLastError(), pcReturned);
1158             continue;
1159         }
1160
1161         /* some levels are not supported on all windows versions */
1162         if (!res && (GetLastError() == ERROR_INVALID_LEVEL)) {
1163             skip("Level %d not supported\n", level);
1164             continue;
1165         }
1166
1167         ok( ((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) ||
1168             (res && (default_printer == NULL)),
1169             "(%u) got %u with %u for %s (expected '0' with "
1170             "ERROR_INSUFFICIENT_BUFFER or '!= 0' without a printer)\n",
1171             level, res, GetLastError(), default_printer);
1172
1173         if (!cbBuf) {
1174             skip("no valid buffer size returned\n");
1175             continue;
1176         }
1177
1178         /* EnumPrinterDriversA returns the same number of bytes as EnumPrinterDriversW */
1179         if (!on_win9x && pEnumPrinterDriversW)
1180         {
1181             DWORD double_needed;
1182             DWORD double_returned;
1183             pEnumPrinterDriversW(NULL, NULL, level, NULL, 0, &double_needed, &double_returned);
1184             ok(double_needed == cbBuf, "level %d: EnumPrinterDriversA returned different size %d than EnumPrinterDriversW (%d)\n", level, cbBuf, double_needed);
1185         }
1186
1187         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf + 4);
1188         if (buffer == NULL) continue;
1189
1190         SetLastError(0xdeadbeef);
1191         pcbNeeded = 0xdeadbeef;
1192         res = EnumPrinterDriversA(NULL, NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
1193         ok(res, "(%u) got %u with %u (expected '!=0')\n", level, res, GetLastError());
1194         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
1195
1196         /* validate the returned data here */
1197         if (level > 1) {
1198             LPDRIVER_INFO_2A di = (LPDRIVER_INFO_2A) buffer;
1199
1200             ok( strrchr(di->pDriverPath, '\\') != NULL,
1201                 "(%u) got %s for %s (expected a full path)\n",
1202                 level, di->pDriverPath, di->pName);
1203
1204         }
1205
1206         SetLastError(0xdeadbeef);
1207         pcReturned = 0xdeadbeef;
1208         pcbNeeded = 0xdeadbeef;
1209         res = EnumPrinterDriversA(NULL, NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
1210         ok(res, "(%u) got %u with %u (expected '!=0')\n", level, res, GetLastError());
1211         ok(pcbNeeded == cbBuf, "(%u) returned %u (expected %u)\n", level, pcbNeeded, cbBuf);
1212
1213         SetLastError(0xdeadbeef);
1214         pcbNeeded = 0xdeadbeef;
1215         res = EnumPrinterDriversA(NULL, NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
1216         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1217             "(%u) got %u with %u (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1218             level, res, GetLastError());
1219         ok(pcbNeeded == cbBuf, "(%u) returned %u (expected %u)\n", level, pcbNeeded, cbBuf);
1220
1221 /*
1222       Do not add the next test:
1223       NT: ERROR_INVALID_USER_BUFFER
1224       win9x: crash or 100% CPU
1225
1226       res = EnumPrinterDriversA(NULL, NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
1227 */
1228
1229         SetLastError(0xdeadbeef);
1230         pcbNeeded = 0xdeadbeef;
1231         pcReturned = 0xdeadbeef;
1232         res = EnumPrinterDriversA(NULL, NULL, level, buffer, cbBuf, NULL, &pcReturned);
1233         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
1234             "(%u) got %u with %u (expected '!=0' or '0' with "
1235             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
1236
1237         pcbNeeded = 0xdeadbeef;
1238         pcReturned = 0xdeadbeef;
1239         SetLastError(0xdeadbeef);
1240         res = EnumPrinterDriversA(NULL, NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
1241         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
1242             "(%u) got %u with %u (expected '!=0' or '0' with "
1243             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
1244
1245         HeapFree(GetProcessHeap(), 0, buffer);
1246     } /* for(level ... */
1247
1248     pcbNeeded = 0;
1249     pcReturned = 0;
1250     SetLastError(0xdeadbeef);
1251     res = EnumPrinterDriversA(NULL, env_all, 1, NULL, 0, &pcbNeeded, &pcReturned);
1252     if (res)
1253     {
1254         skip("no printer drivers found\n");
1255         return;
1256     }
1257     if (GetLastError() == ERROR_INVALID_ENVIRONMENT)
1258     {
1259         win_skip("NT4 and below don't support the 'all' environment value\n");
1260         return;
1261     }
1262     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "unexpected error %u\n", GetLastError());
1263
1264     buffer = HeapAlloc(GetProcessHeap(), 0, pcbNeeded);
1265     res = EnumPrinterDriversA(NULL, env_all, 1, buffer, pcbNeeded, &pcbNeeded, &pcReturned);
1266     ok(res, "EnumPrinterDriversA failed %u\n", GetLastError());
1267     if (res && pcReturned > 0)
1268     {
1269         DRIVER_INFO_1 *di_1 = (DRIVER_INFO_1 *)buffer;
1270         ok((LPBYTE) di_1->pName == NULL || (LPBYTE) di_1->pName < buffer ||
1271             (LPBYTE) di_1->pName >= (LPBYTE)(di_1 + pcReturned),
1272             "Driver Information not in sequence; pName %p, top of data %p\n",
1273             di_1->pName, di_1 + pcReturned);
1274     }
1275
1276     HeapFree(GetProcessHeap(), 0, buffer);
1277 }
1278
1279 /* ########################### */
1280
1281 static void test_EnumPrintProcessors(void)
1282 {
1283     DWORD   res;
1284     LPBYTE  buffer;
1285     DWORD   cbBuf;
1286     DWORD   pcbNeeded;
1287     DWORD   pcReturned;
1288
1289
1290     cbBuf = 0xdeadbeef;
1291     pcReturned = 0xdeadbeef;
1292     SetLastError(0xdeadbeef);
1293     res = EnumPrintProcessorsA(NULL, NULL, 1, NULL, 0, &cbBuf, &pcReturned);
1294     RETURN_ON_DEACTIVATED_SPOOLER(res)
1295
1296     if (res && !cbBuf) {
1297         skip("No Printprocessor installed\n");
1298         return;
1299     }
1300
1301     ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1302         "got %u with %u (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1303         res, GetLastError());
1304
1305     buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf + 4);
1306     if (buffer == NULL)
1307         return;
1308
1309     SetLastError(0xdeadbeef);
1310     pcbNeeded = 0xdeadbeef;
1311     res = EnumPrintProcessorsA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded, &pcReturned);
1312     ok(res, "got %u with %u (expected '!=0')\n", res, GetLastError());
1313     /* validate the returned data here. */
1314
1315
1316     SetLastError(0xdeadbeef);
1317     pcReturned = 0xdeadbeef;
1318     pcbNeeded = 0xdeadbeef;
1319     res = EnumPrintProcessorsA(NULL, NULL, 1, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
1320     ok(res, "got %u with %u (expected '!=0')\n", res, GetLastError());
1321
1322     SetLastError(0xdeadbeef);
1323     pcbNeeded = 0xdeadbeef;
1324     res = EnumPrintProcessorsA(NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
1325     ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1326         "got %u with %u (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1327         res, GetLastError());
1328
1329     /* only level 1 is valid */
1330     if (0) {
1331         /* both tests crash on win98se */
1332         SetLastError(0xdeadbeef);
1333         pcbNeeded = 0xdeadbeef;
1334         pcReturned = 0xdeadbeef;
1335         res = EnumPrintProcessorsA(NULL, NULL, 0, buffer, cbBuf, &pcbNeeded, &pcReturned);
1336         ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
1337             "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
1338             res, GetLastError());
1339
1340         SetLastError(0xdeadbeef);
1341         pcbNeeded = 0xdeadbeef;
1342         res = EnumPrintProcessorsA(NULL, NULL, 2, buffer, cbBuf, &pcbNeeded, &pcReturned);
1343         ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
1344             "got %u with %u (expected '0' with ERROR_INVALID_LEVEL)\n",
1345             res, GetLastError());
1346     }
1347
1348     /* an empty environment is ignored */
1349     SetLastError(0xdeadbeef);
1350     pcbNeeded = 0xdeadbeef;
1351     res = EnumPrintProcessorsA(NULL, empty, 1, buffer, cbBuf, &pcbNeeded, &pcReturned);
1352     ok(res, "got %u with %u (expected '!=0')\n", res, GetLastError());
1353
1354     /* the environment is checked */
1355     SetLastError(0xdeadbeef);
1356     pcbNeeded = 0xdeadbeef;
1357     res = EnumPrintProcessorsA(NULL, invalid_env, 1, buffer, cbBuf, &pcbNeeded, &pcReturned);
1358     /* NT5: ERROR_INVALID_ENVIRONMENT, NT4: res != 0, 9x: ERROR_INVALID_PARAMETER */
1359     ok( broken(res) || /* NT4 */
1360         (GetLastError() == ERROR_INVALID_ENVIRONMENT) ||
1361         (GetLastError() == ERROR_INVALID_PARAMETER),
1362         "got %u with %u (expected '0' with ERROR_INVALID_ENVIRONMENT or "
1363         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1364
1365
1366     /* failure-Codes for NULL */
1367     if (0) {
1368         /* this test crashes on win98se */
1369         SetLastError(0xdeadbeef);
1370         pcbNeeded = 0xdeadbeef;
1371         pcReturned = 0xdeadbeef;
1372         res = EnumPrintProcessorsA(NULL, NULL, 1, NULL, cbBuf, &pcbNeeded, &pcReturned);
1373         ok( !res && (GetLastError() == ERROR_INVALID_USER_BUFFER) ,
1374             "got %u with %u (expected '0' with ERROR_INVALID_USER_BUFFER)\n",
1375             res, GetLastError());
1376     }
1377
1378     SetLastError(0xdeadbeef);
1379     pcbNeeded = 0xdeadbeef;
1380     pcReturned = 0xdeadbeef;
1381     res = EnumPrintProcessorsA(NULL, NULL, 1, buffer, cbBuf, NULL, &pcReturned);
1382     /* the NULL is ignored on win9x */
1383     ok( broken(res) || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)),
1384         "got %u with %u (expected '0' with RPC_X_NULL_REF_POINTER)\n",
1385         res, GetLastError());
1386
1387     pcbNeeded = 0xdeadbeef;
1388     pcReturned = 0xdeadbeef;
1389     SetLastError(0xdeadbeef);
1390     res = EnumPrintProcessorsA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded, NULL);
1391     /* the NULL is ignored on win9x */
1392     ok( broken(res) || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)),
1393         "got %u with %u (expected '0' with RPC_X_NULL_REF_POINTER)\n",
1394         res, GetLastError());
1395
1396     HeapFree(GetProcessHeap(), 0, buffer);
1397
1398 }
1399
1400 /* ########################### */
1401
1402 static void test_GetDefaultPrinter(void)
1403 {
1404     BOOL    retval;
1405     DWORD   exact = DEFAULT_PRINTER_SIZE;
1406     DWORD   size;
1407     char    buffer[DEFAULT_PRINTER_SIZE];
1408
1409     if (!pGetDefaultPrinterA)  return;
1410         /* only supported on NT like OSes starting with win2k */
1411
1412     SetLastError(ERROR_SUCCESS);
1413     retval = pGetDefaultPrinterA(buffer, &exact);
1414     if (!retval || !exact || !strlen(buffer) ||
1415         (ERROR_SUCCESS != GetLastError())) {
1416         if ((ERROR_FILE_NOT_FOUND == GetLastError()) ||
1417             (ERROR_INVALID_NAME == GetLastError()))
1418             trace("this test requires a default printer to be set\n");
1419         else {
1420                 ok( 0, "function call GetDefaultPrinterA failed unexpected!\n"
1421                 "function returned %s\n"
1422                 "last error 0x%08x\n"
1423                 "returned buffer size 0x%08x\n"
1424                 "returned buffer content %s\n",
1425                 retval ? "true" : "false", GetLastError(), exact, buffer);
1426         }
1427         return;
1428     }
1429     SetLastError(ERROR_SUCCESS);
1430     retval = pGetDefaultPrinterA(NULL, NULL);
1431     ok( !retval, "function result wrong! False expected\n");
1432     ok( ERROR_INVALID_PARAMETER == GetLastError(),
1433         "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08x\n",
1434         GetLastError());
1435
1436     SetLastError(ERROR_SUCCESS);
1437     retval = pGetDefaultPrinterA(buffer, NULL);
1438     ok( !retval, "function result wrong! False expected\n");
1439     ok( ERROR_INVALID_PARAMETER == GetLastError(),
1440         "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08x\n",
1441         GetLastError());
1442
1443     SetLastError(ERROR_SUCCESS);
1444     size = 0;
1445     retval = pGetDefaultPrinterA(NULL, &size);
1446     ok( !retval, "function result wrong! False expected\n");
1447     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
1448         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08x\n",
1449         GetLastError());
1450     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
1451         exact, size);
1452
1453     SetLastError(ERROR_SUCCESS);
1454     size = DEFAULT_PRINTER_SIZE;
1455     retval = pGetDefaultPrinterA(NULL, &size);
1456     ok( !retval, "function result wrong! False expected\n");
1457     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
1458         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08x\n",
1459         GetLastError());
1460     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
1461         exact, size);
1462
1463     size = 0;
1464     retval = pGetDefaultPrinterA(buffer, &size);
1465     ok( !retval, "function result wrong! False expected\n");
1466     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
1467         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08x\n",
1468         GetLastError());
1469     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
1470         exact, size);
1471
1472     size = exact;
1473     retval = pGetDefaultPrinterA(buffer, &size);
1474     ok( retval, "function result wrong! True expected\n");
1475     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
1476         exact, size);
1477 }
1478
1479 static void test_GetPrinterDriverDirectory(void)
1480 {
1481     LPBYTE      buffer = NULL;
1482     DWORD       cbBuf = 0, pcbNeeded = 0;
1483     BOOL        res;
1484
1485
1486     SetLastError(MAGIC_DEAD);
1487     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, 0, &cbBuf);
1488     trace("first call returned 0x%04x, with %d: buffer size 0x%08x\n",
1489     res, GetLastError(), cbBuf);
1490
1491     RETURN_ON_DEACTIVATED_SPOOLER(res)
1492     ok((res == 0) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1493         "returned %d with lasterror=%d (expected '0' with "
1494         "ERROR_INSUFFICIENT_BUFFER)\n", res, GetLastError());
1495
1496     if (!cbBuf) {
1497         skip("no valid buffer size returned\n");
1498         return;
1499     }
1500
1501     buffer = HeapAlloc( GetProcessHeap(), 0, cbBuf*2);
1502     if (buffer == NULL)  return ;
1503
1504     res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded);
1505     ok( res, "expected result != 0, got %d\n", res);
1506     ok( cbBuf == pcbNeeded, "pcbNeeded set to %d instead of %d\n",
1507                             pcbNeeded, cbBuf);
1508
1509     res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1510     ok( res, "expected result != 0, got %d\n", res);
1511     ok( cbBuf == pcbNeeded, "pcbNeeded set to %d instead of %d\n",
1512                             pcbNeeded, cbBuf);
1513
1514     SetLastError(MAGIC_DEAD);
1515     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded);
1516     ok( !res , "expected result == 0, got %d\n", res);
1517     ok( cbBuf == pcbNeeded, "pcbNeeded set to %d instead of %d\n",
1518                             pcbNeeded, cbBuf);
1519
1520     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
1521         "last error set to %d instead of ERROR_INSUFFICIENT_BUFFER\n",
1522         GetLastError());
1523
1524 /*
1525     Do not add the next test:
1526     XPsp2: crash in this app, when the spooler is not running
1527     NT3.5: ERROR_INVALID_USER_BUFFER
1528     win9x: ERROR_INVALID_PARAMETER
1529
1530     pcbNeeded = MAGIC_DEAD;
1531     SetLastError(MAGIC_DEAD);
1532     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, &pcbNeeded);
1533 */
1534
1535     SetLastError(MAGIC_DEAD);
1536     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf, NULL);
1537     /* w7 with deactivated spooler: ERROR_INVALID_PARAMETER,
1538        NT: RPC_X_NULL_REF_POINTER  */
1539     ok( res || (GetLastError() == RPC_X_NULL_REF_POINTER) ||
1540                (GetLastError() == ERROR_INVALID_PARAMETER),
1541         "returned %d with %d (expected '!=0' or '0' with RPC_X_NULL_REF_POINTER "
1542         "or '0' with ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1543
1544     SetLastError(MAGIC_DEAD);
1545     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, NULL);
1546     /* w7 with deactivated spooler: ERROR_INVALID_PARAMETER,
1547        NT: RPC_X_NULL_REF_POINTER  */
1548     ok( res || (GetLastError() == RPC_X_NULL_REF_POINTER) ||
1549                (GetLastError() == ERROR_INVALID_PARAMETER),
1550         "returned %d with %d (expected '!=0' or '0' with RPC_X_NULL_REF_POINTER "
1551         "or '0' with ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1552
1553     /* with a valid buffer, but level is too large */
1554     buffer[0] = '\0';
1555     SetLastError(MAGIC_DEAD);
1556     res = GetPrinterDriverDirectoryA(NULL, NULL, 2, buffer, cbBuf, &pcbNeeded);
1557
1558     /* Level not checked in win9x and wine:*/
1559     if((res != FALSE) && buffer[0])
1560     {
1561         trace("Level '2' not checked '%s'\n", buffer);
1562     }
1563     else
1564     {
1565         ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
1566         "returned %d with lasterror=%d (expected '0' with "
1567         "ERROR_INVALID_LEVEL)\n", res, GetLastError());
1568     }
1569
1570     /* printing environments are case insensitive */
1571     /* "Windows 4.0" is valid for win9x and NT */
1572     buffer[0] = '\0';
1573     SetLastError(MAGIC_DEAD);
1574     res = GetPrinterDriverDirectoryA(NULL, env_win9x_case, 1,
1575                                         buffer, cbBuf*2, &pcbNeeded);
1576
1577     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
1578         cbBuf = pcbNeeded;
1579         buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, cbBuf*2);
1580         if (buffer == NULL)  return ;
1581
1582         SetLastError(MAGIC_DEAD);
1583         res = GetPrinterDriverDirectoryA(NULL, env_win9x_case, 1,
1584                                         buffer, cbBuf*2, &pcbNeeded);
1585     }
1586
1587     ok(res && buffer[0], "returned %d with "
1588         "lasterror=%d and len=%d (expected '1' with 'len > 0')\n",
1589         res, GetLastError(), lstrlenA((char *)buffer));
1590
1591     buffer[0] = '\0';
1592     SetLastError(MAGIC_DEAD);
1593     res = GetPrinterDriverDirectoryA(NULL, env_x86, 1,
1594                                         buffer, cbBuf*2, &pcbNeeded);
1595
1596     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
1597         cbBuf = pcbNeeded;
1598         buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, cbBuf*2);
1599         if (buffer == NULL)  return ;
1600
1601         buffer[0] = '\0';
1602         SetLastError(MAGIC_DEAD);
1603         res = GetPrinterDriverDirectoryA(NULL, env_x86, 1,
1604                                         buffer, cbBuf*2, &pcbNeeded);
1605     }
1606
1607     /* "Windows NT x86" is invalid for win9x */
1608     ok( (res && buffer[0]) ||
1609         (!res && (GetLastError() == ERROR_INVALID_ENVIRONMENT)),
1610         "returned %d with lasterror=%d and len=%d (expected '!= 0' with "
1611         "'len > 0' or '0' with ERROR_INVALID_ENVIRONMENT)\n",
1612         res, GetLastError(), lstrlenA((char *)buffer));
1613
1614     /* A setup program (PDFCreator_0.8.0) use empty strings */
1615     SetLastError(MAGIC_DEAD);
1616     res = GetPrinterDriverDirectoryA(empty, empty, 1, buffer, cbBuf*2, &pcbNeeded);
1617     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError() );
1618
1619     SetLastError(MAGIC_DEAD);
1620     res = GetPrinterDriverDirectoryA(NULL, empty, 1, buffer, cbBuf*2, &pcbNeeded);
1621     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError() );
1622
1623     SetLastError(MAGIC_DEAD);
1624     res = GetPrinterDriverDirectoryA(empty, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1625     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError() );
1626
1627     HeapFree( GetProcessHeap(), 0, buffer);
1628 }
1629
1630 /* ##### */
1631
1632 static void test_GetPrintProcessorDirectory(void)
1633 {
1634     LPBYTE      buffer = NULL;
1635     DWORD       cbBuf = 0;
1636     DWORD       pcbNeeded = 0;
1637     BOOL        res;
1638
1639
1640     SetLastError(0xdeadbeef);
1641     res = GetPrintProcessorDirectoryA(NULL, NULL, 1, NULL, 0, &cbBuf);
1642     /* The deactivated spooler is caught here on NT3.51 */
1643     RETURN_ON_DEACTIVATED_SPOOLER(res)
1644     ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1645         "returned %d with %d (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1646         res, GetLastError());
1647
1648     buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf*2);
1649     if(buffer == NULL)  return;
1650
1651     buffer[0] = '\0';
1652     SetLastError(0xdeadbeef);
1653     res = GetPrintProcessorDirectoryA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded);
1654     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1655
1656     SetLastError(0xdeadbeef);
1657     buffer[0] = '\0';
1658     res = GetPrintProcessorDirectoryA(NULL, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1659     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1660
1661     /* Buffer to small */
1662     buffer[0] = '\0';
1663     SetLastError(0xdeadbeef);
1664     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded);
1665     ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1666         "returned %d with %d (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1667         res, GetLastError());
1668
1669     if (0)
1670     {
1671     /* XPsp2: the program will crash here, when the spooler is not running  */
1672     /*        GetPrinterDriverDirectory has the same bug */
1673     pcbNeeded = 0;
1674     SetLastError(0xdeadbeef);
1675     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, NULL, cbBuf, &pcbNeeded);
1676     /* NT: ERROR_INVALID_USER_BUFFER, 9x: res != 0  */
1677     ok( (!res && (GetLastError() == ERROR_INVALID_USER_BUFFER)) ||
1678         broken(res),
1679         "returned %d with %d (expected '0' with ERROR_INVALID_USER_BUFFER)\n",
1680         res, GetLastError());
1681     }
1682
1683     buffer[0] = '\0';
1684     SetLastError(0xdeadbeef);
1685     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, buffer, cbBuf, NULL);
1686     /* w7 with deactivated spooler: ERROR_INVALID_PARAMETER,
1687        NT: RPC_X_NULL_REF_POINTER, 9x: res != 0  */
1688     ok( !res && ((GetLastError() == RPC_X_NULL_REF_POINTER) ||
1689                  (GetLastError() == ERROR_INVALID_PARAMETER)),
1690         "returned %d with %d (expected '0' with RPC_X_NULL_REF_POINTER "
1691         "or with ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1692
1693     buffer[0] = '\0';
1694     SetLastError(0xdeadbeef);
1695     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, NULL, cbBuf, NULL);
1696     /* w7 with deactivated spooler: ERROR_INVALID_PARAMETER,
1697        NT: RPC_X_NULL_REF_POINTER, 9x: res != 0  */
1698     ok( !res && ((GetLastError() == RPC_X_NULL_REF_POINTER) ||
1699                  (GetLastError() == ERROR_INVALID_PARAMETER)),
1700         "returned %d with %d (expected '0' with RPC_X_NULL_REF_POINTER "
1701         "or with ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1702
1703     /* with a valid buffer, but level is invalid */
1704     buffer[0] = '\0';
1705     SetLastError(0xdeadbeef);
1706     res = GetPrintProcessorDirectoryA(NULL, NULL, 0, buffer, cbBuf, &pcbNeeded);
1707     /* Level is ignored in win9x*/
1708     ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
1709         broken(res && buffer[0]),
1710         "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
1711         res, GetLastError());
1712
1713     buffer[0] = '\0';
1714     SetLastError(0xdeadbeef);
1715     res = GetPrintProcessorDirectoryA(NULL, NULL, 2, buffer, cbBuf, &pcbNeeded);
1716     /* Level is ignored on win9x*/
1717     ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
1718         broken(res && buffer[0]),
1719         "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
1720         res, GetLastError());
1721
1722     /* Empty environment is the same as the default environment */
1723     buffer[0] = '\0';
1724     SetLastError(0xdeadbeef);
1725     res = GetPrintProcessorDirectoryA(NULL, empty, 1, buffer, cbBuf*2, &pcbNeeded);
1726     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1727
1728     /* "Windows 4.0" is valid for win9x and NT */
1729     buffer[0] = '\0';
1730     SetLastError(0xdeadbeef);
1731     res = GetPrintProcessorDirectoryA(NULL, env_win9x_case, 1, buffer, cbBuf*2, &pcbNeeded);
1732     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1733
1734
1735     /* "Windows NT x86" is invalid for win9x */
1736     buffer[0] = '\0';
1737     SetLastError(0xdeadbeef);
1738     res = GetPrintProcessorDirectoryA(NULL, env_x86, 1, buffer, cbBuf*2, &pcbNeeded);
1739     ok( res || (GetLastError() == ERROR_INVALID_ENVIRONMENT),
1740         "returned %d with %d (expected '!= 0' or '0' with "
1741         "ERROR_INVALID_ENVIRONMENT)\n", res, GetLastError());
1742
1743     /* invalid on all systems */
1744     buffer[0] = '\0';
1745     SetLastError(0xdeadbeef);
1746     res = GetPrintProcessorDirectoryA(NULL, invalid_env, 1, buffer, cbBuf*2, &pcbNeeded);
1747     ok( !res && (GetLastError() == ERROR_INVALID_ENVIRONMENT),
1748         "returned %d with %d (expected '0' with ERROR_INVALID_ENVIRONMENT)\n",
1749         res, GetLastError());
1750
1751     /* Empty servername is the same as the local computer */
1752     buffer[0] = '\0';
1753     SetLastError(0xdeadbeef);
1754     res = GetPrintProcessorDirectoryA(empty, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1755     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1756
1757     /* invalid on all systems */
1758     buffer[0] = '\0';
1759     SetLastError(0xdeadbeef);
1760     res = GetPrintProcessorDirectoryA(server_does_not_exist, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1761     ok( !res, "expected failure\n");
1762     ok( GetLastError() == RPC_S_SERVER_UNAVAILABLE || /* NT */
1763         GetLastError() == ERROR_INVALID_PARAMETER ||  /* 9x */
1764         GetLastError() == RPC_S_INVALID_NET_ADDR,     /* Some Vista */
1765         "unexpected last error %d\n", GetLastError());
1766
1767     HeapFree(GetProcessHeap(), 0, buffer);
1768 }
1769
1770 /* ##### */
1771
1772 static void test_OpenPrinter(void)
1773 {
1774     PRINTER_DEFAULTSA   defaults;
1775     HANDLE              hprinter;
1776     DWORD               res;
1777
1778     SetLastError(MAGIC_DEAD);
1779     res = OpenPrinter(NULL, NULL, NULL);
1780     /* The deactivated spooler is caught here on NT3.51 */
1781     RETURN_ON_DEACTIVATED_SPOOLER(res)
1782     ok(!res && (GetLastError() == ERROR_INVALID_PARAMETER),
1783         "returned %d with %d (expected '0' with ERROR_INVALID_PARAMETER)\n",
1784         res, GetLastError());
1785
1786
1787     /* Get Handle for the local Printserver (NT only)*/
1788     hprinter = (HANDLE) MAGIC_DEAD;
1789     SetLastError(MAGIC_DEAD);
1790     res = OpenPrinter(NULL, &hprinter, NULL);
1791     /* The deactivated spooler is caught here on XPsp2 */
1792     RETURN_ON_DEACTIVATED_SPOOLER(res)
1793     ok(res || (!res && GetLastError() == ERROR_INVALID_PARAMETER),
1794         "returned %d with %d (expected '!=0' or '0' with ERROR_INVALID_PARAMETER)\n",
1795         res, GetLastError());
1796     if(res) {
1797         ClosePrinter(hprinter);
1798
1799         defaults.pDatatype=NULL;
1800         defaults.pDevMode=NULL;
1801
1802         defaults.DesiredAccess=0;
1803         hprinter = (HANDLE) MAGIC_DEAD;
1804         SetLastError(MAGIC_DEAD);
1805         res = OpenPrinter(NULL, &hprinter, &defaults);
1806         ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
1807         if (res) ClosePrinter(hprinter);
1808
1809         defaults.DesiredAccess=-1;
1810         hprinter = (HANDLE) MAGIC_DEAD;
1811         SetLastError(MAGIC_DEAD);
1812         res = OpenPrinter(NULL, &hprinter, &defaults);
1813         todo_wine {
1814         ok(!res && GetLastError() == ERROR_ACCESS_DENIED,
1815             "returned %d with %d (expected '0' with ERROR_ACCESS_DENIED)\n",
1816             res, GetLastError());
1817         }
1818         if (res) ClosePrinter(hprinter);
1819
1820     }
1821
1822
1823     if (local_server != NULL) {
1824         hprinter = (HANDLE) 0xdeadbeef;
1825         SetLastError(0xdeadbeef);
1826         res = OpenPrinter(local_server, &hprinter, NULL);
1827         ok(res || (!res && GetLastError() == ERROR_INVALID_PARAMETER),
1828             "returned %d with %d (expected '!=0' or '0' with ERROR_INVALID_PARAMETER)\n",
1829             res, GetLastError());
1830         if(res) ClosePrinter(hprinter);
1831     }
1832
1833     /* Invalid Printername */
1834     hprinter = (HANDLE) MAGIC_DEAD;
1835     SetLastError(MAGIC_DEAD);
1836     res = OpenPrinter(illegal_name, &hprinter, NULL);
1837     ok(!res && ((GetLastError() == ERROR_INVALID_PRINTER_NAME) ||
1838                 (GetLastError() == ERROR_INVALID_PARAMETER) ),
1839        "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or"
1840        "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1841     if(res) ClosePrinter(hprinter);
1842
1843     hprinter = (HANDLE) MAGIC_DEAD;
1844     SetLastError(MAGIC_DEAD);
1845     res = OpenPrinter(empty, &hprinter, NULL);
1846     /* NT: ERROR_INVALID_PRINTER_NAME,  9x: ERROR_INVALID_PARAMETER */
1847     ok( !res &&
1848         ((GetLastError() == ERROR_INVALID_PRINTER_NAME) ||
1849         (GetLastError() == ERROR_INVALID_PARAMETER) ),
1850         "returned %d with %d (expected '0' with: ERROR_INVALID_PRINTER_NAME"
1851         " or ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1852     if(res) ClosePrinter(hprinter);
1853
1854
1855     /* get handle for the default printer */
1856     if (default_printer)
1857     {
1858         hprinter = (HANDLE) MAGIC_DEAD;
1859         SetLastError(MAGIC_DEAD);
1860         res = OpenPrinter(default_printer, &hprinter, NULL);
1861         if((!res) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE))
1862         {
1863             trace("The service 'Spooler' is required for '%s'\n", default_printer);
1864             return;
1865         }
1866         ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
1867         if(res) ClosePrinter(hprinter);
1868
1869         SetLastError(MAGIC_DEAD);
1870         res = OpenPrinter(default_printer, NULL, NULL);
1871         /* NT: FALSE with ERROR_INVALID_PARAMETER, 9x: TRUE */
1872         ok(res || (GetLastError() == ERROR_INVALID_PARAMETER),
1873             "returned %d with %d (expected '!=0' or '0' with "
1874             "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1875
1876         defaults.pDatatype=NULL;
1877         defaults.pDevMode=NULL;
1878         defaults.DesiredAccess=0;
1879
1880         hprinter = (HANDLE) MAGIC_DEAD;
1881         SetLastError(MAGIC_DEAD);
1882         res = OpenPrinter(default_printer, &hprinter, &defaults);
1883         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
1884             "returned %d with %d (expected '!=0' or '0' with "
1885             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
1886         if(res) ClosePrinter(hprinter);
1887
1888         defaults.pDatatype = empty;
1889
1890         hprinter = (HANDLE) MAGIC_DEAD;
1891         SetLastError(MAGIC_DEAD);
1892         res = OpenPrinter(default_printer, &hprinter, &defaults);
1893         /* stop here, when a remote Printserver has no RPC-Service running */
1894         RETURN_ON_DEACTIVATED_SPOOLER(res)
1895         ok(res || ((GetLastError() == ERROR_INVALID_DATATYPE) ||
1896                    (GetLastError() == ERROR_ACCESS_DENIED)),
1897             "returned %d with %d (expected '!=0' or '0' with: "
1898             "ERROR_INVALID_DATATYPE or ERROR_ACCESS_DENIED)\n",
1899             res, GetLastError());
1900         if(res) ClosePrinter(hprinter);
1901
1902
1903         defaults.pDatatype=NULL;
1904         defaults.DesiredAccess=PRINTER_ACCESS_USE;
1905
1906         hprinter = (HANDLE) MAGIC_DEAD;
1907         SetLastError(MAGIC_DEAD);
1908         res = OpenPrinter(default_printer, &hprinter, &defaults);
1909         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
1910             "returned %d with %d (expected '!=0' or '0' with "
1911             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
1912         if(res) ClosePrinter(hprinter);
1913
1914
1915         defaults.DesiredAccess=PRINTER_ALL_ACCESS;
1916         hprinter = (HANDLE) MAGIC_DEAD;
1917         SetLastError(MAGIC_DEAD);
1918         res = OpenPrinter(default_printer, &hprinter, &defaults);
1919         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
1920             "returned %d with %d (expected '!=0' or '0' with "
1921             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
1922         if(res) ClosePrinter(hprinter);
1923     }
1924
1925 }
1926
1927
1928 static void test_SetDefaultPrinter(void)
1929 {
1930     DWORD   res;
1931     DWORD   size = DEFAULT_PRINTER_SIZE;
1932     CHAR    buffer[DEFAULT_PRINTER_SIZE];
1933     CHAR    org_value[DEFAULT_PRINTER_SIZE];
1934
1935     if (!default_printer)
1936     {
1937         skip("There is no default printer installed\n");
1938         return;
1939     }
1940
1941     if (!pSetDefaultPrinterA)  return;
1942         /* only supported on win2k and above */
1943
1944     /* backup the original value */
1945     org_value[0] = '\0';
1946     SetLastError(MAGIC_DEAD);
1947     res = GetProfileStringA("windows", "device", NULL, org_value, size);
1948     ok(res, "GetProfileString error %d\n", GetLastError());
1949
1950     /* first part: with the default Printer */
1951     SetLastError(MAGIC_DEAD);
1952     res = pSetDefaultPrinterA("no_printer_with_this_name");
1953
1954     RETURN_ON_DEACTIVATED_SPOOLER(res)
1955     /* spooler is running or we have no spooler here*/
1956
1957     /* Not implemented in wine */
1958     if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) {
1959         trace("SetDefaultPrinterA() not implemented yet.\n");
1960         return;
1961     }
1962
1963     ok(!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME),
1964         "returned %d with %d (expected '0' with "
1965         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1966
1967     WriteProfileStringA("windows", "device", org_value);
1968     SetLastError(MAGIC_DEAD);
1969     res = pSetDefaultPrinterA("");
1970     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1971         "returned %d with %d (expected '!=0' or '0' with "
1972         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1973
1974     WriteProfileStringA("windows", "device", org_value);
1975     SetLastError(MAGIC_DEAD);
1976     res = pSetDefaultPrinterA(NULL);
1977     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1978         "returned %d with %d (expected '!=0' or '0' with "
1979         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1980
1981     WriteProfileStringA("windows", "device", org_value);
1982     SetLastError(MAGIC_DEAD);
1983     res = pSetDefaultPrinterA(default_printer);
1984     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1985         "returned %d with %d (expected '!=0' or '0' with "
1986         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1987
1988
1989     /* second part: always without a default Printer */
1990     WriteProfileStringA("windows", "device", NULL);
1991     SetLastError(MAGIC_DEAD);
1992     res = pSetDefaultPrinterA("no_printer_with_this_name");
1993
1994     ok(!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME),
1995         "returned %d with %d (expected '0' with "
1996         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1997
1998     WriteProfileStringA("windows", "device", NULL);
1999     SetLastError(MAGIC_DEAD);
2000     res = pSetDefaultPrinterA("");
2001     if ((res == 0) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE))     {
2002         if (!deactivated_spooler_reported) {
2003             deactivated_spooler_reported++;
2004             skip("The service 'Spooler' is required for many tests\n");
2005         }
2006         goto restore_old_printer;
2007     }
2008
2009     /* we get ERROR_INVALID_PRINTER_NAME when no printer is installed */
2010     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
2011          "returned %d with %d (expected '!=0' or '0' with "
2012          "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
2013
2014     WriteProfileStringA("windows", "device", NULL);
2015     SetLastError(MAGIC_DEAD);
2016     res = pSetDefaultPrinterA(NULL);
2017     /* we get ERROR_INVALID_PRINTER_NAME when no printer is installed */
2018     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
2019         "returned %d with %d (expected '!=0' or '0' with "
2020         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
2021
2022     WriteProfileStringA("windows", "device", NULL);
2023     SetLastError(MAGIC_DEAD);
2024     res = pSetDefaultPrinterA(default_printer);
2025     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
2026         "returned %d with %d (expected '!=0' or '0' with "
2027         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
2028
2029     /* restore the original value */
2030 restore_old_printer:
2031     res = pSetDefaultPrinterA(default_printer);          /* the nice way */
2032     ok(res, "SetDefaultPrinter error %d\n", GetLastError());
2033     WriteProfileStringA("windows", "device", org_value); /* the old way */
2034
2035     buffer[0] = '\0';
2036     SetLastError(MAGIC_DEAD);
2037     res = GetProfileStringA("windows", "device", NULL, buffer, size);
2038     ok(res, "GetProfileString error %d\n", GetLastError());
2039     ok(!lstrcmpA(org_value, buffer), "'%s' (expected '%s')\n", buffer, org_value);
2040
2041 }
2042
2043 /* ########################### */
2044
2045 static void test_XcvDataW_MonitorUI(void)
2046 {
2047     DWORD   res;
2048     HANDLE  hXcv;
2049     BYTE    buffer[MAX_PATH + 4];
2050     DWORD   needed;
2051     DWORD   status;
2052     DWORD   len;
2053     PRINTER_DEFAULTSA pd;
2054
2055     /* api is not present before w2k */
2056     if (pXcvDataW == NULL) return;
2057
2058     pd.pDatatype = NULL;
2059     pd.pDevMode  = NULL;
2060     pd.DesiredAccess = SERVER_ACCESS_ADMINISTER;
2061
2062     hXcv = NULL;
2063     SetLastError(0xdeadbeef);
2064     res = OpenPrinter(xcv_localport, &hXcv, &pd);
2065     RETURN_ON_DEACTIVATED_SPOOLER(res)
2066     RETURN_ON_ACCESS_DENIED(res)
2067
2068     ok(res, "returned %d with %u and handle %p (expected '!= 0')\n", res, GetLastError(), hXcv);
2069     if (!res) return;
2070
2071     /* ask for needed size */
2072     needed = (DWORD) 0xdeadbeef;
2073     status = (DWORD) 0xdeadbeef;
2074     SetLastError(0xdeadbeef);
2075     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, NULL, 0, &needed, &status);
2076     ok( res && (status == ERROR_INSUFFICIENT_BUFFER) && (needed <= MAX_PATH),
2077         "returned %d with %u and %u for status %u (expected '!= 0' and "
2078         "'<= MAX_PATH' for status ERROR_INSUFFICIENT_BUFFER)\n",
2079         res, GetLastError(), needed, status);
2080
2081     if (needed > MAX_PATH) {
2082         ClosePrinter(hXcv);
2083         skip("buffer overflow (%u)\n", needed);
2084         return;
2085     }
2086     len = needed;       /* Size is in bytes */
2087
2088     /* the command is required */
2089     needed = (DWORD) 0xdeadbeef;
2090     status = (DWORD) 0xdeadbeef;
2091     SetLastError(0xdeadbeef);
2092     res = pXcvDataW(hXcv, emptyW, NULL, 0, NULL, 0, &needed, &status);
2093     ok( res && (status == ERROR_INVALID_PARAMETER),
2094         "returned %d with %u and %u for status %u (expected '!= 0' with "
2095         "ERROR_INVALID_PARAMETER)\n", res, GetLastError(), needed, status);
2096
2097     needed = (DWORD) 0xdeadbeef;
2098     status = (DWORD) 0xdeadbeef;
2099     SetLastError(0xdeadbeef);
2100     res = pXcvDataW(hXcv, NULL, NULL, 0, buffer, MAX_PATH, &needed, &status);
2101     ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER),
2102         "returned %d with %u and %u for status %u (expected '0' with "
2103         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError(), needed, status);
2104
2105     /* "PDWORD needed" is checked before RPC-Errors */
2106     needed = (DWORD) 0xdeadbeef;
2107     status = (DWORD) 0xdeadbeef;
2108     SetLastError(0xdeadbeef);
2109     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, NULL, &status);
2110     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
2111         "returned %d with %u and %u for status %u (expected '0' with "
2112         "ERROR_INVALID_PARAMETER)\n", res, GetLastError(), needed, status);
2113
2114     needed = (DWORD) 0xdeadbeef;
2115     status = (DWORD) 0xdeadbeef;
2116     SetLastError(0xdeadbeef);
2117     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, NULL, len, &needed, &status);
2118     ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER),
2119         "returned %d with %u and %u for status %u (expected '0' with "
2120         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError(), needed, status);
2121
2122     needed = (DWORD) 0xdeadbeef;
2123     status = (DWORD) 0xdeadbeef;
2124     SetLastError(0xdeadbeef);
2125     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, &needed, NULL);
2126     ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER),
2127         "returned %d with %u and %u for status %u (expected '0' with "
2128         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError(), needed, status);
2129
2130     /* off by one: larger  */
2131     needed = (DWORD) 0xdeadbeef;
2132     status = (DWORD) 0xdeadbeef;
2133     SetLastError(0xdeadbeef);
2134     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len+1, &needed, &status);
2135     ok( res && (status == ERROR_SUCCESS),
2136         "returned %d with %u and %u for status %u (expected '!= 0' for status "
2137         "ERROR_SUCCESS)\n", res, GetLastError(), needed, status);
2138
2139     /* off by one: smaller */
2140     /* the buffer is not modified for NT4, w2k, XP */
2141     needed = (DWORD) 0xdeadbeef;
2142     status = (DWORD) 0xdeadbeef;
2143     SetLastError(0xdeadbeef);
2144     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len-1, &needed, &status);
2145     ok( res && (status == ERROR_INSUFFICIENT_BUFFER),
2146         "returned %d with %u and %u for status %u (expected '!= 0' for status "
2147         "ERROR_INSUFFICIENT_BUFFER)\n", res, GetLastError(), needed, status);
2148
2149
2150     /* Normal use. The DLL-Name without a Path is returned */
2151     memset(buffer, 0, len);
2152     needed = (DWORD) 0xdeadbeef;
2153     status = (DWORD) 0xdeadbeef;
2154     SetLastError(0xdeadbeef);
2155     res = pXcvDataW(hXcv, cmd_MonitorUIW, NULL, 0, buffer, len, &needed, &status);
2156     ok( res && (status == ERROR_SUCCESS),
2157         "returned %d with %u and %u for status %u (expected '!= 0' for status "
2158         "ERROR_SUCCESS)\n", res, GetLastError(), needed, status);
2159
2160     ClosePrinter(hXcv);
2161 }
2162
2163 /* ########################### */
2164
2165 static void test_XcvDataW_PortIsValid(void)
2166 {
2167     DWORD   res;
2168     HANDLE  hXcv;
2169     DWORD   needed;
2170     DWORD   status;
2171     PRINTER_DEFAULTSA   pd;
2172
2173     /* api is not present before w2k */
2174     if (pXcvDataW == NULL) return;
2175
2176     pd.pDatatype = NULL;
2177     pd.pDevMode  = NULL;
2178     pd.DesiredAccess = SERVER_ACCESS_ADMINISTER;
2179
2180     hXcv = NULL;
2181     SetLastError(0xdeadbeef);
2182     res = OpenPrinter(xcv_localport, &hXcv, &pd);
2183
2184     RETURN_ON_DEACTIVATED_SPOOLER(res)
2185     RETURN_ON_ACCESS_DENIED(res)
2186
2187     ok(res, "returned %d with %u and handle %p (expected '!= 0')\n", res, GetLastError(), hXcv);
2188     if (!res) return;
2189
2190
2191     /* "PDWORD needed" is always required */
2192     needed = (DWORD) 0xdeadbeef;
2193     status = (DWORD) 0xdeadbeef;
2194     SetLastError(0xdeadbeef);
2195     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, NULL, &status);
2196     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
2197         "returned %d with %u and %u for status %u (expected '!= 0' with ERROR_INVALID_PARAMETER)\n",
2198          res, GetLastError(), needed, status);
2199
2200     /* an empty name is not allowed */
2201     needed = (DWORD) 0xdeadbeef;
2202     status = (DWORD) 0xdeadbeef;
2203     SetLastError(0xdeadbeef);
2204     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) emptyW, sizeof(emptyW), NULL, 0, &needed, &status);
2205     ok( res && ((status == ERROR_FILE_NOT_FOUND) || (status == ERROR_PATH_NOT_FOUND)),
2206         "returned %d with %u and %u for status %u (expected '!= 0' for status: "
2207         "ERROR_FILE_NOT_FOUND or ERROR_PATH_NOT_FOUND)\n",
2208         res, GetLastError(), needed, status);
2209
2210     /* a directory is not allowed */
2211     needed = (DWORD) 0xdeadbeef;
2212     status = (DWORD) 0xdeadbeef;
2213     SetLastError(0xdeadbeef);
2214     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) tempdirW, (lstrlenW(tempdirW) + 1) * sizeof(WCHAR), NULL, 0, &needed, &status);
2215     /* XP: ERROR_PATH_NOT_FOUND, w2k ERROR_ACCESS_DENIED */
2216     ok( res && ((status == ERROR_PATH_NOT_FOUND) || (status == ERROR_ACCESS_DENIED)),
2217         "returned %d with %u and %u for status %u (expected '!= 0' for status: "
2218         "ERROR_PATH_NOT_FOUND or ERROR_ACCESS_DENIED)\n",
2219         res, GetLastError(), needed, status);
2220
2221     /* more valid well known ports */
2222     needed = (DWORD) 0xdeadbeef;
2223     status = (DWORD) 0xdeadbeef;
2224     SetLastError(0xdeadbeef);
2225     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt1W, sizeof(portname_lpt1W), NULL, 0, &needed, &status);
2226     ok( res && (status == ERROR_SUCCESS),
2227         "returned %d with %u and %u for status %u (expected '!= 0' for ERROR_SUCCESS)\n",
2228         res, GetLastError(), needed, status);
2229
2230     needed = (DWORD) 0xdeadbeef;
2231     status = (DWORD) 0xdeadbeef;
2232     SetLastError(0xdeadbeef);
2233     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) portname_lpt2W, sizeof(portname_lpt2W), NULL, 0, &needed, &status);
2234     ok( res && (status == ERROR_SUCCESS),
2235         "returned %d with %u and %u for status %u (expected '!= 0' for ERROR_SUCCESS)\n",
2236         res, GetLastError(), needed, status);
2237
2238     needed = (DWORD) 0xdeadbeef;
2239     status = (DWORD) 0xdeadbeef;
2240     SetLastError(0xdeadbeef);
2241     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) portname_com1W, sizeof(portname_com1W), NULL, 0, &needed, &status);
2242     ok( res && (status == ERROR_SUCCESS),
2243         "returned %d with %u and %u for status %u (expected '!= 0' for ERROR_SUCCESS)\n",
2244         res, GetLastError(), needed, status);
2245
2246     needed = (DWORD) 0xdeadbeef;
2247     status = (DWORD) 0xdeadbeef;
2248     SetLastError(0xdeadbeef);
2249     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) portname_com2W, sizeof(portname_com2W), NULL, 0, &needed, &status);
2250     ok( res && (status == ERROR_SUCCESS),
2251         "returned %d with %u and %u for status %u (expected '!= 0' for ERROR_SUCCESS)\n",
2252         res, GetLastError(), needed, status);
2253
2254     needed = (DWORD) 0xdeadbeef;
2255     status = (DWORD) 0xdeadbeef;
2256     SetLastError(0xdeadbeef);
2257     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) portname_fileW, sizeof(portname_fileW), NULL, 0, &needed, &status);
2258     ok( res && (status == ERROR_SUCCESS),
2259         "returned %d with %u and %u for status %u (expected '!= 0' with  ERROR_SUCCESS)\n",
2260         res, GetLastError(), needed, status);
2261
2262
2263     /* a normal, writable file is allowed */
2264     needed = (DWORD) 0xdeadbeef;
2265     status = (DWORD) 0xdeadbeef;
2266     SetLastError(0xdeadbeef);
2267     res = pXcvDataW(hXcv, cmd_PortIsValidW, (PBYTE) tempfileW, (lstrlenW(tempfileW) + 1) * sizeof(WCHAR), NULL, 0, &needed, &status);
2268     ok( res && (status == ERROR_SUCCESS),
2269         "returned %d with %u and %u for status %u (expected '!= 0' with ERROR_SUCCESS)\n",
2270         res, GetLastError(), needed, status);
2271
2272     ClosePrinter(hXcv);
2273 }
2274
2275 /* ########################### */
2276
2277 static void test_GetPrinter(void)
2278 {
2279     HANDLE hprn;
2280     BOOL ret;
2281     BYTE *buf;
2282     INT level;
2283     DWORD needed, filled;
2284
2285     if (!default_printer)
2286     {
2287         skip("There is no default printer installed\n");
2288         return;
2289     }
2290
2291     hprn = 0;
2292     ret = OpenPrinter(default_printer, &hprn, NULL);
2293     if (!ret)
2294     {
2295         skip("Unable to open the default printer (%s)\n", default_printer);
2296         return;
2297     }
2298     ok(hprn != 0, "wrong hprn %p\n", hprn);
2299
2300     for (level = 1; level <= 9; level++)
2301     {
2302         SetLastError(0xdeadbeef);
2303         needed = (DWORD)-1;
2304         ret = GetPrinter(hprn, level, NULL, 0, &needed);
2305         if (ret)
2306         {
2307             win_skip("Level %d is not supported on Win9x/WinMe\n", level);
2308             ok(GetLastError() == ERROR_SUCCESS, "wrong error %d\n", GetLastError());
2309             ok(needed == 0,"Expected 0, got %d\n", needed);
2310             continue;
2311         }
2312         ok(!ret, "level %d: GetPrinter should fail\n", level);
2313         /* Not all levels are supported on all Windows-Versions */
2314         if (GetLastError() == ERROR_INVALID_LEVEL ||
2315             GetLastError() == ERROR_NOT_SUPPORTED /* Win9x/WinMe */)
2316         {
2317             skip("Level %d not supported\n", level);
2318             continue;
2319         }
2320         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "wrong error %d\n", GetLastError());
2321         ok(needed > 0,"not expected needed buffer size %d\n", needed);
2322
2323         /* GetPrinterA returns the same number of bytes as GetPrinterW */
2324         if (!on_win9x && !ret && pGetPrinterW && level != 6 && level != 7)
2325         {
2326             DWORD double_needed;
2327             ret = pGetPrinterW(hprn, level, NULL, 0, &double_needed);
2328             ok(!ret, "level %d: GetPrinter error %d\n", level, GetLastError());
2329             ok(double_needed == needed, "level %d: GetPrinterA returned different size %d than GetPrinterW (%d)\n", level, needed, double_needed);
2330         }
2331
2332         buf = HeapAlloc(GetProcessHeap(), 0, needed);
2333
2334         SetLastError(0xdeadbeef);
2335         filled = -1;
2336         ret = GetPrinter(hprn, level, buf, needed, &filled);
2337         ok(ret, "level %d: GetPrinter error %d\n", level, GetLastError());
2338         ok(needed == filled, "needed %d != filled %d\n", needed, filled);
2339
2340         if (level == 2)
2341         {
2342             PRINTER_INFO_2 *pi_2 = (PRINTER_INFO_2 *)buf;
2343
2344             ok(pi_2->pPrinterName!= NULL, "not expected NULL ptr\n");
2345             ok(pi_2->pDriverName!= NULL, "not expected NULL ptr\n");
2346
2347             trace("pPrinterName %s\n", pi_2->pPrinterName);
2348             trace("pDriverName %s\n", pi_2->pDriverName);
2349         }
2350
2351         HeapFree(GetProcessHeap(), 0, buf);
2352     }
2353
2354     SetLastError(0xdeadbeef);
2355     ret = ClosePrinter(hprn);
2356     ok(ret, "ClosePrinter error %d\n", GetLastError());
2357 }
2358
2359 /* ########################### */
2360
2361 static void test_GetPrinterData(void)
2362 {
2363     HANDLE hprn = 0;
2364     DWORD res;
2365     DWORD type;
2366     CHAR  buffer[MAX_PATH + 1];
2367     DWORD needed;
2368     DWORD len;
2369
2370     /* ToDo: test parameter validation, test with the default printer */
2371
2372     SetLastError(0xdeadbeef);
2373     res = OpenPrinter(NULL, &hprn, NULL);
2374     if (!res)
2375     {
2376         /* printserver not available on win9x */
2377         if (!on_win9x)
2378             win_skip("Unable to open the printserver: %d\n", GetLastError());
2379         return;
2380     }
2381
2382     memset(buffer, '#', sizeof(buffer));
2383     buffer[MAX_PATH] = 0;
2384     type = 0xdeadbeef;
2385     needed = 0xdeadbeef;
2386     SetLastError(0xdeadbeef);
2387     res = GetPrinterDataA(hprn, defaultspooldirectory, &type, (LPBYTE) buffer, sizeof(buffer), &needed);
2388
2389     len = lstrlenA(buffer) + sizeof(CHAR);
2390     /* NT4 and w2k require a buffer to save the UNICODE result also for the ANSI function */
2391     ok( !res && (type == REG_SZ) && ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2392         "got %d, type %d, needed: %d and '%s' (expected ERROR_SUCCESS, REG_SZ and %d)\n",
2393         res, type, needed, buffer, len);
2394
2395     needed = 0xdeadbeef;
2396     SetLastError(0xdeadbeef);
2397     res = GetPrinterDataA(hprn, defaultspooldirectory, NULL, NULL, 0, &needed);
2398     ok( (res == ERROR_MORE_DATA) && ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2399         "got %d, needed: %d (expected ERROR_MORE_DATA and %d)\n", res, needed, len);
2400
2401     /* ToDo: test SPLREG_*  */
2402
2403     SetLastError(0xdeadbeef);
2404     res = ClosePrinter(hprn);
2405     ok(res, "ClosePrinter error %d\n", GetLastError());
2406 }
2407
2408 /* ########################### */
2409
2410 static void test_GetPrinterDataEx(void)
2411 {
2412     HANDLE hprn = 0;
2413     DWORD res;
2414     DWORD type;
2415     CHAR  buffer[MAX_PATH + 1];
2416     DWORD needed;
2417     DWORD len;
2418
2419     /* not present before w2k */
2420     if (!pGetPrinterDataExA) {
2421         win_skip("GetPrinterDataEx not found\n");
2422         return;
2423     }
2424
2425     /* ToDo: test parameter validation, test with the default printer */
2426
2427     SetLastError(0xdeadbeef);
2428     res = OpenPrinter(NULL, &hprn, NULL);
2429     if (!res)
2430     {
2431         win_skip("Unable to open the printserver: %d\n", GetLastError());
2432         return;
2433     }
2434
2435     /* keyname is ignored, when hprn is a HANDLE for a printserver */
2436     memset(buffer, '#', sizeof(buffer));
2437     buffer[MAX_PATH] = 0;
2438     type = 0xdeadbeef;
2439     needed = 0xdeadbeef;
2440     SetLastError(0xdeadbeef);
2441     res = pGetPrinterDataExA(hprn, NULL, defaultspooldirectory, &type,
2442                              (LPBYTE) buffer, sizeof(buffer), &needed);
2443
2444     len = lstrlenA(buffer) + sizeof(CHAR);
2445     /* NT4 and w2k require a buffer to save the UNICODE result also for the ANSI function */
2446     ok( !res && (type == REG_SZ) && ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2447         "got %d, type %d, needed: %d and '%s' (expected ERROR_SUCCESS, REG_SZ and %d)\n",
2448         res, type, needed, buffer, len);
2449
2450     memset(buffer, '#', sizeof(buffer));
2451     buffer[MAX_PATH] = 0;
2452     type = 0xdeadbeef;
2453     needed = 0xdeadbeef;
2454     SetLastError(0xdeadbeef);
2455     res = pGetPrinterDataExA(hprn, "", defaultspooldirectory, &type,
2456                              (LPBYTE) buffer, sizeof(buffer), &needed);
2457     len = lstrlenA(buffer) + sizeof(CHAR);
2458     ok( !res && (type == REG_SZ) && ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2459         "got %d, type %d, needed: %d and '%s' (expected ERROR_SUCCESS, REG_SZ and %d)\n",
2460         res, type, needed, buffer, len);
2461
2462     memset(buffer, '#', sizeof(buffer));
2463     buffer[MAX_PATH] = 0;
2464     type = 0xdeadbeef;
2465     needed = 0xdeadbeef;
2466     SetLastError(0xdeadbeef);
2467     /* Wine uses GetPrinterDataEx with "PrinterDriverData" to implement GetPrinterData */
2468     res = pGetPrinterDataExA(hprn, "PrinterDriverData", defaultspooldirectory,
2469                              &type, (LPBYTE) buffer, sizeof(buffer), &needed);
2470     len = lstrlenA(buffer) + sizeof(CHAR);
2471     ok( !res && (type == REG_SZ) && ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2472         "got %d, type %d, needed: %d and '%s' (expected ERROR_SUCCESS, REG_SZ and %d)\n",
2473         res, type, needed, buffer, len);
2474
2475
2476     memset(buffer, '#', sizeof(buffer));
2477     buffer[MAX_PATH] = 0;
2478     type = 0xdeadbeef;
2479     needed = 0xdeadbeef;
2480     SetLastError(0xdeadbeef);
2481     res = pGetPrinterDataExA(hprn, does_not_exist, defaultspooldirectory, &type,
2482                              (LPBYTE) buffer, sizeof(buffer), &needed);
2483     len = lstrlenA(buffer) + sizeof(CHAR);
2484     ok( !res && (type == REG_SZ) && ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2485         "got %d, type %d, needed: %d and '%s' (expected ERROR_SUCCESS, REG_SZ and %d)\n",
2486         res, type, needed, buffer, len);
2487
2488     needed = 0xdeadbeef;
2489     SetLastError(0xdeadbeef);
2490     /* vista and w2k8 have a bug in GetPrinterDataEx:
2491        the current LastError value is returned as result */
2492     res = pGetPrinterDataExA(hprn, NULL, defaultspooldirectory, NULL, NULL, 0, &needed);
2493     ok( ((res == ERROR_MORE_DATA) || broken(res == 0xdeadbeef)) &&
2494         ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2495         "got %d, needed: %d (expected ERROR_MORE_DATA and %d)\n", res, needed, len);
2496
2497     needed = 0xdeadbeef;
2498     SetLastError(0xdeaddead);
2499     res = pGetPrinterDataExA(hprn, NULL, defaultspooldirectory, NULL, NULL, 0, &needed);
2500     ok( ((res == ERROR_MORE_DATA) || broken(res == 0xdeaddead)) &&
2501         ((needed == len) || (needed == (len * sizeof(WCHAR)))),
2502         "got %d, needed: %d (expected ERROR_MORE_DATA and %d)\n", res, needed, len);
2503
2504     SetLastError(0xdeadbeef);
2505     res = ClosePrinter(hprn);
2506     ok(res, "ClosePrinter error %d\n", GetLastError());
2507 }
2508
2509 /* ########################### */
2510
2511 static void test_GetPrinterDriver(void)
2512 {
2513     HANDLE hprn;
2514     BOOL ret;
2515     BYTE *buf;
2516     INT level;
2517     DWORD needed, filled;
2518
2519     if (!default_printer)
2520     {
2521         skip("There is no default printer installed\n");
2522         return;
2523     }
2524
2525     hprn = 0;
2526     ret = OpenPrinter(default_printer, &hprn, NULL);
2527     if (!ret)
2528     {
2529         skip("Unable to open the default printer (%s)\n", default_printer);
2530         return;
2531     }
2532     ok(hprn != 0, "wrong hprn %p\n", hprn);
2533
2534     for (level = -1; level <= 7; level++)
2535     {
2536         SetLastError(0xdeadbeef);
2537         needed = (DWORD)-1;
2538         ret = GetPrinterDriver(hprn, NULL, level, NULL, 0, &needed);
2539         ok(!ret, "level %d: GetPrinterDriver should fail\n", level);
2540         if (level >= 1 && level <= 6)
2541         {
2542             /* Not all levels are supported on all Windows-Versions */
2543             if(GetLastError() == ERROR_INVALID_LEVEL) continue;
2544             ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "wrong error %d\n", GetLastError());
2545             ok(needed > 0,"not expected needed buffer size %d\n", needed);
2546         }
2547         else
2548         {
2549             /* ERROR_OUTOFMEMORY found on win9x */
2550             ok( ((GetLastError() == ERROR_INVALID_LEVEL) ||
2551                  (GetLastError() == ERROR_OUTOFMEMORY)),
2552                 "%d: returned %d with %d (expected '0' with: "
2553                 "ERROR_INVALID_LEVEL or ERROR_OUTOFMEMORY)\n",
2554                 level, ret, GetLastError());
2555             /* needed is modified in win9x. The modified Value depends on the
2556                default Printer. testing for "needed == (DWORD)-1" will fail */
2557             continue;
2558         }
2559
2560         /* GetPrinterDriverA returns the same number of bytes as GetPrinterDriverW */
2561         if (!on_win9x && !ret && pGetPrinterDriverW)
2562         {
2563             DWORD double_needed;
2564             ret = pGetPrinterDriverW(hprn, NULL, level, NULL, 0, &double_needed);
2565             ok(!ret, "level %d: GetPrinterDriver error %d\n", level, GetLastError());
2566             ok(double_needed == needed, "GetPrinterDriverA returned different size %d than GetPrinterDriverW (%d)\n", needed, double_needed);
2567         }
2568
2569         buf = HeapAlloc(GetProcessHeap(), 0, needed);
2570
2571         SetLastError(0xdeadbeef);
2572         filled = -1;
2573         ret = GetPrinterDriver(hprn, NULL, level, buf, needed, &filled);
2574         ok(ret, "level %d: GetPrinterDriver error %d\n", level, GetLastError());
2575         ok(needed == filled, "needed %d != filled %d\n", needed, filled);
2576
2577         if (level == 2)
2578         {
2579             DRIVER_INFO_2 *di_2 = (DRIVER_INFO_2 *)buf;
2580             DWORD calculated = sizeof(*di_2);
2581             HANDLE hf;
2582
2583             /* MSDN is wrong: The Drivers on the win9x-CD's have cVersion=0x0400
2584                NT351: 1, NT4.0+w2k(Kernelmode): 2, w2k-win7(Usermode): 3, win8 and above(Usermode): 4 */
2585             ok( (di_2->cVersion <= 4) ||
2586                 (di_2->cVersion == 0x0400), "di_2->cVersion = %d\n", di_2->cVersion);
2587             ok(di_2->pName != NULL, "not expected NULL ptr\n");
2588             ok(di_2->pEnvironment != NULL, "not expected NULL ptr\n");
2589             ok(di_2->pDriverPath != NULL, "not expected NULL ptr\n");
2590             ok(di_2->pDataFile != NULL, "not expected NULL ptr\n");
2591             ok(di_2->pConfigFile != NULL, "not expected NULL ptr\n");
2592
2593             trace("cVersion %d\n", di_2->cVersion);
2594             trace("pName %s\n", di_2->pName);
2595             calculated += strlen(di_2->pName) + 1;
2596             trace("pEnvironment %s\n", di_2->pEnvironment);
2597             calculated += strlen(di_2->pEnvironment) + 1;
2598             trace("pDriverPath %s\n", di_2->pDriverPath);
2599             calculated += strlen(di_2->pDriverPath) + 1;
2600             trace("pDataFile %s\n", di_2->pDataFile);
2601             calculated += strlen(di_2->pDataFile) + 1;
2602             trace("pConfigFile %s\n", di_2->pConfigFile);
2603             calculated += strlen(di_2->pConfigFile) + 1;
2604
2605             hf = CreateFileA(di_2->pDriverPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2606             if(hf != INVALID_HANDLE_VALUE)
2607                 CloseHandle(hf);
2608             todo_wine
2609             ok(hf != INVALID_HANDLE_VALUE, "Could not open %s\n", di_2->pDriverPath);
2610
2611             hf = CreateFileA(di_2->pDataFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2612             if(hf != INVALID_HANDLE_VALUE)
2613                 CloseHandle(hf);
2614             ok(hf != INVALID_HANDLE_VALUE, "Could not open %s\n", di_2->pDataFile);
2615
2616             hf = CreateFileA(di_2->pConfigFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2617             if(hf != INVALID_HANDLE_VALUE)
2618                 CloseHandle(hf);
2619             todo_wine
2620             ok(hf != INVALID_HANDLE_VALUE, "Could not open %s\n", di_2->pConfigFile);
2621
2622             /* XP allocates memory for both ANSI and unicode names */
2623             ok(filled >= calculated,"calculated %d != filled %d\n", calculated, filled);
2624
2625             /* Obscure test - demonstrate that Windows zero fills the buffer, even on failure */
2626             ret = GetPrinterDriver(hprn, NULL, level, buf, needed - 2, &filled);
2627             ok(!ret, "level %d: GetPrinterDriver succeeded with less buffer than it should\n", level);
2628             ok(di_2->pDataFile == NULL ||
2629                broken(di_2->pDataFile != NULL), /* Win9x/WinMe */
2630                "Even on failure, GetPrinterDriver clears the buffer to zeros\n");
2631         }
2632
2633         HeapFree(GetProcessHeap(), 0, buf);
2634     }
2635
2636     SetLastError(0xdeadbeef);
2637     ret = ClosePrinter(hprn);
2638     ok(ret, "ClosePrinter error %d\n", GetLastError());
2639 }
2640
2641 static void test_DEVMODE(const DEVMODE *dm, LONG dmSize, LPCSTR exp_prn_name)
2642 {
2643     /* On NT3.51, some fields in DEVMODE are empty/zero
2644       (dmDeviceName, dmSpecVersion, dmDriverVersion and dmDriverExtra)
2645        We skip the Tests on this Platform */
2646     if (dm->dmSpecVersion || dm->dmDriverVersion || dm->dmDriverExtra) {
2647     /* The 0-terminated Printername can be larger (MAX_PATH) than CCHDEVICENAME */
2648         ok(!strncmp(exp_prn_name, (LPCSTR)dm->dmDeviceName, CCHDEVICENAME -1) ||
2649            !strncmp(exp_prn_name, (LPCSTR)dm->dmDeviceName, CCHDEVICENAME -2), /* XP+ */
2650             "expected '%s', got '%s'\n", exp_prn_name, dm->dmDeviceName);
2651         ok(dm->dmSize + dm->dmDriverExtra == dmSize,
2652             "%u != %d\n", dm->dmSize + dm->dmDriverExtra, dmSize);
2653     }
2654     trace("dmFields %08x\n", dm->dmFields);
2655 }
2656
2657 static void test_DocumentProperties(void)
2658 {
2659     HANDLE hprn;
2660     LONG dm_size, ret;
2661     DEVMODE *dm;
2662
2663     if (!default_printer)
2664     {
2665         skip("There is no default printer installed\n");
2666         return;
2667     }
2668
2669     hprn = 0;
2670     ret = OpenPrinter(default_printer, &hprn, NULL);
2671     if (!ret)
2672     {
2673         skip("Unable to open the default printer (%s)\n", default_printer);
2674         return;
2675     }
2676     ok(hprn != 0, "wrong hprn %p\n", hprn);
2677
2678     dm_size = DocumentProperties(0, hprn, NULL, NULL, NULL, 0);
2679     trace("DEVMODE required size %d\n", dm_size);
2680     ok(dm_size >= sizeof(DEVMODE), "unexpected DocumentProperties ret value %d\n", dm_size);
2681
2682     dm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dm_size);
2683
2684     ret = DocumentProperties(0, hprn, NULL, dm, dm, DM_OUT_BUFFER);
2685     ok(ret == IDOK, "DocumentProperties ret value %d != expected IDOK\n", ret);
2686
2687     test_DEVMODE(dm, dm_size, default_printer);
2688
2689     HeapFree(GetProcessHeap(), 0, dm);
2690
2691     SetLastError(0xdeadbeef);
2692     ret = ClosePrinter(hprn);
2693     ok(ret, "ClosePrinter error %d\n", GetLastError());
2694 }
2695
2696 static void test_EnumPrinters(void)
2697 {
2698     DWORD neededA, neededW, num;
2699     DWORD ret;
2700
2701     SetLastError(0xdeadbeef);
2702     neededA = -1;
2703     ret = EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &neededA, &num);
2704     RETURN_ON_DEACTIVATED_SPOOLER(ret)
2705     if (!ret)
2706     {
2707         /* We have 1 or more printers */
2708         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "gle %d\n", GetLastError());
2709         ok(neededA > 0, "Expected neededA to show the number of needed bytes\n");
2710     }
2711     else
2712     {
2713         /* We don't have any printers defined */
2714         ok(GetLastError() == S_OK, "gle %d\n", GetLastError());
2715         ok(neededA == 0, "Expected neededA to be zero\n");
2716     }
2717     ok(num == 0, "num %d\n", num);
2718
2719     SetLastError(0xdeadbeef);
2720     neededW = -1;
2721     ret = EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &neededW, &num);
2722     /* EnumPrintersW is not supported on all platforms */
2723     if (!ret && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
2724     {
2725         win_skip("EnumPrintersW is not implemented\n");
2726         return;
2727     }
2728
2729     if (!ret)
2730     {
2731         /* We have 1 or more printers */
2732         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "gle %d\n", GetLastError());
2733         ok(neededW > 0, "Expected neededW to show the number of needed bytes\n");
2734     }
2735     else
2736     {
2737         /* We don't have any printers defined */
2738         ok(GetLastError() == S_OK, "gle %d\n", GetLastError());
2739         ok(neededW == 0, "Expected neededW to be zero\n");
2740     }
2741     ok(num == 0, "num %d\n", num);
2742
2743     /* Outlook2003 relies on the buffer size returned by EnumPrintersA being big enough
2744        to hold the buffer returned by EnumPrintersW */
2745     ok(neededA == neededW, "neededA %d neededW %d\n", neededA, neededW);
2746 }
2747
2748 static void test_DeviceCapabilities(void)
2749 {
2750     HANDLE hComdlg32;
2751     BOOL (WINAPI *pPrintDlgA)(PRINTDLGA *);
2752     PRINTDLGA prn_dlg;
2753     DEVMODE *dm;
2754     DEVNAMES *dn;
2755     const char *driver, *device, *port;
2756     WORD *papers;
2757     POINT *paper_size;
2758     POINTS ext;
2759     struct
2760     {
2761         char name[64];
2762     } *paper_name;
2763     INT n_papers, n_paper_size, n_paper_names, n_copies, ret;
2764     DWORD fields;
2765
2766     hComdlg32 = LoadLibrary("comdlg32.dll");
2767     assert(hComdlg32);
2768     pPrintDlgA = (void *)GetProcAddress(hComdlg32, "PrintDlgA");
2769     assert(pPrintDlgA);
2770
2771     memset(&prn_dlg, 0, sizeof(prn_dlg));
2772     prn_dlg.lStructSize = sizeof(prn_dlg);
2773     prn_dlg.Flags = PD_RETURNDEFAULT;
2774     ret = pPrintDlgA(&prn_dlg);
2775     FreeLibrary(hComdlg32);
2776     if (!ret)
2777     {
2778         skip("PrintDlg returned no default printer\n");
2779         return;
2780     }
2781     ok(prn_dlg.hDevMode != 0, "PrintDlg returned hDevMode == NULL\n");
2782     ok(prn_dlg.hDevNames != 0, "PrintDlg returned hDevNames == NULL\n");
2783
2784     dm = GlobalLock(prn_dlg.hDevMode);
2785     ok(dm != NULL, "GlobalLock(prn_dlg.hDevMode) failed\n");
2786     trace("dmDeviceName \"%s\"\n", dm->dmDeviceName);
2787
2788     dn = GlobalLock(prn_dlg.hDevNames);
2789     ok(dn != NULL, "GlobalLock(prn_dlg.hDevNames) failed\n");
2790     ok(dn->wDriverOffset, "expected not 0 wDriverOffset\n");
2791     ok(dn->wDeviceOffset, "expected not 0 wDeviceOffset\n");
2792     ok(dn->wOutputOffset, "expected not 0 wOutputOffset\n");
2793     ok(dn->wDefault == DN_DEFAULTPRN, "expected DN_DEFAULTPRN got %x\n", dn->wDefault);
2794     driver = (const char *)dn + dn->wDriverOffset;
2795     device = (const char *)dn + dn->wDeviceOffset;
2796     port = (const char *)dn + dn->wOutputOffset;
2797     trace("driver \"%s\" device \"%s\" port \"%s\"\n", driver, device, port);
2798
2799     test_DEVMODE(dm, dm->dmSize + dm->dmDriverExtra, device);
2800
2801     n_papers = DeviceCapabilities(device, port, DC_PAPERS, NULL, NULL);
2802     ok(n_papers > 0, "DeviceCapabilities DC_PAPERS failed\n");
2803     papers = HeapAlloc(GetProcessHeap(), 0, sizeof(*papers) * n_papers);
2804     ret = DeviceCapabilities(device, port, DC_PAPERS, (LPSTR)papers, NULL);
2805     ok(ret == n_papers, "expected %d, got %d\n", n_papers, ret);
2806 #ifdef VERBOSE
2807     for (ret = 0; ret < n_papers; ret++)
2808         trace("papers[%d] = %d\n", ret, papers[ret]);
2809 #endif
2810     HeapFree(GetProcessHeap(), 0, papers);
2811
2812     n_paper_size = DeviceCapabilities(device, port, DC_PAPERSIZE, NULL, NULL);
2813     ok(n_paper_size > 0, "DeviceCapabilities DC_PAPERSIZE failed\n");
2814     ok(n_paper_size == n_papers, "n_paper_size %d != n_papers %d\n", n_paper_size, n_papers);
2815     paper_size = HeapAlloc(GetProcessHeap(), 0, sizeof(*paper_size) * n_paper_size);
2816     ret = DeviceCapabilities(device, port, DC_PAPERSIZE, (LPSTR)paper_size, NULL);
2817     ok(ret == n_paper_size, "expected %d, got %d\n", n_paper_size, ret);
2818 #ifdef VERBOSE
2819     for (ret = 0; ret < n_paper_size; ret++)
2820         trace("paper_size[%d] = %d x %d\n", ret, paper_size[ret].x, paper_size[ret].y);
2821 #endif
2822     HeapFree(GetProcessHeap(), 0, paper_size);
2823
2824     n_paper_names = DeviceCapabilities(device, port, DC_PAPERNAMES, NULL, NULL);
2825     ok(n_paper_names > 0, "DeviceCapabilities DC_PAPERNAMES failed\n");
2826     ok(n_paper_names == n_papers, "n_paper_names %d != n_papers %d\n", n_paper_names, n_papers);
2827     paper_name = HeapAlloc(GetProcessHeap(), 0, sizeof(*paper_name) * n_paper_names);
2828     ret = DeviceCapabilities(device, port, DC_PAPERNAMES, (LPSTR)paper_name, NULL);
2829     ok(ret == n_paper_names, "expected %d, got %d\n", n_paper_names, ret);
2830 #ifdef VERBOSE
2831     for (ret = 0; ret < n_paper_names; ret++)
2832         trace("paper_name[%u] = %s\n", ret, paper_name[ret].name);
2833 #endif
2834     HeapFree(GetProcessHeap(), 0, paper_name);
2835
2836     n_copies = DeviceCapabilities(device, port, DC_COPIES, NULL, dm);
2837     ok(n_copies > 0, "DeviceCapabilities DC_COPIES failed\n");
2838     trace("n_copies = %d\n", n_copies);
2839
2840     /* these capabilities are not available on all printer drivers */
2841     if (0)
2842     {
2843         ret = DeviceCapabilities(device, port, DC_MAXEXTENT, NULL, NULL);
2844         ok(ret != -1, "DeviceCapabilities DC_MAXEXTENT failed\n");
2845         ext = MAKEPOINTS(ret);
2846         trace("max ext = %d x %d\n", ext.x, ext.y);
2847
2848         ret = DeviceCapabilities(device, port, DC_MINEXTENT, NULL, NULL);
2849         ok(ret != -1, "DeviceCapabilities DC_MINEXTENT failed\n");
2850         ext = MAKEPOINTS(ret);
2851         trace("min ext = %d x %d\n", ext.x, ext.y);
2852     }
2853
2854     fields = DeviceCapabilities(device, port, DC_FIELDS, NULL, NULL);
2855     ok(fields != (DWORD)-1, "DeviceCapabilities DC_FIELDS failed\n");
2856     todo_wine
2857     ok(fields == (dm->dmFields | DM_FORMNAME) ||
2858        fields == ((dm->dmFields | DM_FORMNAME | DM_PAPERSIZE) & ~(DM_PAPERLENGTH|DM_PAPERWIDTH)) ||
2859         broken(fields == dm->dmFields), /* Win9x/WinMe */
2860         "fields %x, dm->dmFields %x\n", fields, dm->dmFields);
2861
2862     GlobalUnlock(prn_dlg.hDevMode);
2863     GlobalFree(prn_dlg.hDevMode);
2864     GlobalUnlock(prn_dlg.hDevNames);
2865     GlobalFree(prn_dlg.hDevNames);
2866 }
2867
2868 static void test_IsValidDevmodeW(void)
2869 {
2870     BOOL br;
2871
2872     if (!pIsValidDevmodeW)
2873     {
2874         win_skip("IsValidDevmodeW not implemented.\n");
2875         return;
2876     }
2877
2878     br = pIsValidDevmodeW(NULL, 0);
2879     ok(br == FALSE, "Got %d\n", br);
2880
2881     br = pIsValidDevmodeW(NULL, 1);
2882     ok(br == FALSE, "Got %d\n", br);
2883
2884     br = pIsValidDevmodeW(NULL, sizeof(DEVMODEW));
2885     ok(br == FALSE, "Got %d\n", br);
2886 }
2887
2888 static void test_OpenPrinter_defaults(void)
2889 {
2890     HANDLE printer;
2891     BOOL ret;
2892     DWORD needed;
2893     short default_size;
2894     ADDJOB_INFO_1 *add_job;
2895     JOB_INFO_2 *job_info;
2896     DEVMODE my_dm;
2897     PRINTER_DEFAULTS prn_def;
2898     PRINTER_INFO_2 *pi;
2899
2900     if (!default_printer)
2901     {
2902         skip("There is no default printer installed\n");
2903         return;
2904     }
2905
2906     /* Printer opened with NULL defaults.  Retrieve default paper size
2907        and confirm that jobs have this size. */
2908
2909     ret = OpenPrinter( default_printer, &printer, NULL );
2910     if (!ret)
2911     {
2912         skip("Unable to open the default printer (%s)\n", default_printer);
2913         return;
2914     }
2915
2916     ret = GetPrinter( printer, 2, NULL, 0, &needed );
2917     ok( !ret, "got %d\n", ret );
2918     pi = HeapAlloc( GetProcessHeap(), 0, needed );
2919     ret = GetPrinter( printer, 2, (BYTE *)pi, needed, &needed );
2920     ok( ret, "got %d\n", ret );
2921     default_size = pi->pDevMode->u1.s1.dmPaperSize;
2922     HeapFree( GetProcessHeap(), 0, pi );
2923
2924     ret = AddJob( printer, 1, NULL, 0, &needed );
2925     ok( !ret, "got %d\n", ret );
2926     add_job = HeapAlloc( GetProcessHeap(), 0, needed );
2927     ret = AddJob( printer, 1, (BYTE *)add_job, needed, &needed );
2928     ok( ret, "got %d\n", ret );
2929
2930     ret = GetJob( printer, add_job->JobId, 2, NULL, 0, &needed );
2931     ok( !ret, "got %d\n", ret );
2932     job_info = HeapAlloc( GetProcessHeap(), 0, needed );
2933     ret = GetJob( printer, add_job->JobId, 2, (BYTE *)job_info, needed, &needed );
2934     ok( ret, "got %d\n", ret );
2935
2936 todo_wine
2937     ok( job_info->pDevMode != NULL, "got NULL devmode\n");
2938     if (job_info->pDevMode)
2939         ok( job_info->pDevMode->u1.s1.dmPaperSize == default_size, "got %d default %d\n",
2940             job_info->pDevMode->u1.s1.dmPaperSize, default_size );
2941
2942     HeapFree( GetProcessHeap(), 0, job_info );
2943     ScheduleJob( printer, add_job->JobId ); /* remove the empty job */
2944     HeapFree( GetProcessHeap(), 0, add_job );
2945     ClosePrinter( printer );
2946
2947     /* Printer opened with something other than the default paper size. */
2948
2949     memset( &my_dm, 0, sizeof(my_dm) );
2950     my_dm.dmSize = sizeof(my_dm);
2951     my_dm.dmFields = DM_PAPERSIZE;
2952     my_dm.u1.s1.dmPaperSize = (default_size == DMPAPER_A4) ? DMPAPER_LETTER : DMPAPER_A4;
2953
2954     prn_def.pDatatype = NULL;
2955     prn_def.pDevMode = &my_dm;
2956     prn_def.DesiredAccess = PRINTER_ACCESS_USE;
2957
2958     ret = OpenPrinter( default_printer, &printer, &prn_def );
2959     ok( ret, "got %d\n", ret );
2960
2961     /* GetPrinter stills returns default size */
2962     ret = GetPrinter( printer, 2, NULL, 0, &needed );
2963     ok( !ret, "got %d\n", ret );
2964     pi = HeapAlloc( GetProcessHeap(), 0, needed );
2965     ret = GetPrinter( printer, 2, (BYTE *)pi, needed, &needed );
2966     ok( ret, "got %d\n", ret );
2967     ok( pi->pDevMode->u1.s1.dmPaperSize == default_size, "got %d default %d\n",
2968         pi->pDevMode->u1.s1.dmPaperSize, default_size );
2969
2970     HeapFree( GetProcessHeap(), 0, pi );
2971
2972     /* However the GetJob has the new size */
2973     ret = AddJob( printer, 1, NULL, 0, &needed );
2974     ok( !ret, "got %d\n", ret );
2975     add_job = HeapAlloc( GetProcessHeap(), 0, needed );
2976     ret = AddJob( printer, 1, (BYTE *)add_job, needed, &needed );
2977     ok( ret, "got %d\n", ret );
2978
2979     ret = GetJob( printer, add_job->JobId, 2, NULL, 0, &needed );
2980     ok( !ret, "got %d\n", ret );
2981     job_info = HeapAlloc( GetProcessHeap(), 0, needed );
2982     ret = GetJob( printer, add_job->JobId, 2, (BYTE *)job_info, needed, &needed );
2983     ok( ret, "got %d\n", ret );
2984
2985     ok( job_info->pDevMode->dmFields == DM_PAPERSIZE, "got %08x\n",
2986         job_info->pDevMode->dmFields );
2987     ok( job_info->pDevMode->u1.s1.dmPaperSize == my_dm.u1.s1.dmPaperSize,
2988         "got %d new size %d\n",
2989         job_info->pDevMode->u1.s1.dmPaperSize, my_dm.u1.s1.dmPaperSize );
2990
2991     HeapFree( GetProcessHeap(), 0, job_info );
2992     ScheduleJob( printer, add_job->JobId ); /* remove the empty job */
2993     HeapFree( GetProcessHeap(), 0, add_job );
2994     ClosePrinter( printer );
2995 }
2996
2997 START_TEST(info)
2998 {
2999     hwinspool = GetModuleHandleA("winspool.drv");
3000     pAddPortExA = (void *) GetProcAddress(hwinspool, "AddPortExA");
3001     pEnumPrinterDriversW = (void *) GetProcAddress(hwinspool, "EnumPrinterDriversW");
3002     pGetDefaultPrinterA = (void *) GetProcAddress(hwinspool, "GetDefaultPrinterA");
3003     pGetPrinterDataExA = (void *) GetProcAddress(hwinspool, "GetPrinterDataExA");
3004     pGetPrinterDriverW = (void *) GetProcAddress(hwinspool, "GetPrinterDriverW");
3005     pGetPrinterW = (void *) GetProcAddress(hwinspool, "GetPrinterW");
3006     pSetDefaultPrinterA = (void *) GetProcAddress(hwinspool, "SetDefaultPrinterA");
3007     pXcvDataW = (void *) GetProcAddress(hwinspool, "XcvDataW");
3008     pIsValidDevmodeW = (void *) GetProcAddress(hwinspool, "IsValidDevmodeW");
3009
3010     on_win9x = check_win9x();
3011     if (on_win9x)
3012         win_skip("Several W-functions are not available on Win9x/WinMe\n");
3013
3014     find_default_printer();
3015     find_local_server();
3016     find_tempfile();
3017
3018     test_AddMonitor();
3019     test_AddPort();
3020     test_AddPortEx();
3021     test_ConfigurePort();
3022     test_DeleteMonitor();
3023     test_DeletePort();
3024     test_DeviceCapabilities();
3025     test_DocumentProperties();
3026     test_EnumForms(NULL);
3027     if (default_printer) test_EnumForms(default_printer);
3028     test_EnumMonitors();
3029     test_EnumPorts();
3030     test_EnumPrinterDrivers();
3031     test_EnumPrinters();
3032     test_EnumPrintProcessors();
3033     test_GetDefaultPrinter();
3034     test_GetPrinterDriverDirectory();
3035     test_GetPrintProcessorDirectory();
3036     test_OpenPrinter();
3037     test_GetPrinter();
3038     test_GetPrinterData();
3039     test_GetPrinterDataEx();
3040     test_GetPrinterDriver();
3041     test_SetDefaultPrinter();
3042     test_XcvDataW_MonitorUI();
3043     test_XcvDataW_PortIsValid();
3044     test_IsValidDevmodeW();
3045     test_OpenPrinter_defaults();
3046
3047     /* Cleanup our temporary file */
3048     DeleteFileA(tempfileA);
3049 }