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