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