dlls/winspool/tests/info.c

   1 /*
   2  * Copyright (C) 2003, 2004 Stefan Leichter
   3  * Copyright (C) 2005 Detlef Riekenberg
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #include "wine/test.h"
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winerror.h"
  26 #include "wingdi.h"
  27 #include "winreg.h"
  28 #include "winspool.h"
  29
  30 #define MAGIC_DEAD  0x00dead00
  31 #define DEFAULT_PRINTER_SIZE 1000
  32
  33 static char env_x86[] = "Windows NT x86";
  34 static char env_win9x_case[] = "windowS 4.0";
  35
  36 static HANDLE  hwinspool;
  37 static FARPROC pGetDefaultPrinterA;
  38 static FARPROC pSetDefaultPrinterA;
  39
  40 /* report common behavior only once */
  41 static DWORD report_deactivated_spooler = 1;
  42 #define RETURN_ON_DEACTIVATED_SPOOLER(res) \
  43     if((res == 0) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE)) \
  44     { \
  45         if(report_deactivated_spooler > 0) { \
  46             report_deactivated_spooler--; \
  47             trace("The Service 'Spooler' is required for many test\n"); \
  48         } \
  49         return; \
  50     }
  51
  52
  53 static LPSTR find_default_printer(VOID)
  54 {
  55     static  LPSTR   default_printer = NULL;
  56     static  char    buffer[DEFAULT_PRINTER_SIZE];
  57     DWORD   needed;
  58     DWORD   res;
  59     LPSTR   ptr;
  60
  61     if ((default_printer == NULL) && (pGetDefaultPrinterA))
  62     {
  63         /* w2k and above */
  64         needed = sizeof(buffer);
  65         res = pGetDefaultPrinterA(buffer, &needed);
  66         if(res)  default_printer = buffer;
  67         trace("default_printer: '%s'\n", default_printer);
  68     }
  69     if (default_printer == NULL)
  70     {
  71         HKEY hwindows;
  72         DWORD   type;
  73         /* NT 3.x and above */
  74         if (RegOpenKeyEx(HKEY_CURRENT_USER,
  75                         "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows",
  76                         0, KEY_QUERY_VALUE, &hwindows) == NO_ERROR) {
  77
  78             needed = sizeof(buffer);
  79             if (RegQueryValueEx(hwindows, "device", NULL,
  80                                 &type, (LPBYTE)buffer, &needed) == NO_ERROR) {
  81
  82                 ptr = strchr(buffer, ',');
  83                 if (ptr) {
  84                     ptr[0] = '\0';
  85                     default_printer = buffer;
  86                 }
  87             }
  88             RegCloseKey(hwindows);
  89         }
  90         trace("default_printer: '%s'\n", default_printer);
  91     }
  92     if (default_printer == NULL)
  93     {
  94         /* win9x */
  95         needed = sizeof(buffer);
  96         res = GetProfileStringA("windows", "device", "*", buffer, needed);
  97         if(res) {
  98             ptr = strchr(buffer, ',');
  99             if (ptr) {
 100                 ptr[0] = '\0';
 101                 default_printer = buffer;
 102             }
 103         }
 104         trace("default_printer: '%s'\n", default_printer);
 105     }
 106     return default_printer;
 107 }
 108
 109 /* ########################### */
 110
 111 static void test_EnumMonitors(void)
 112 {
 113     DWORD   res;
 114     LPBYTE  buffer;
 115     DWORD   cbBuf;
 116     DWORD   pcbNeeded;
 117     DWORD   pcReturned;
 118     DWORD   level;
 119
 120     /* valid levels are 1 and 2 */
 121     for(level = 0; level < 4; level++) {
 122         cbBuf = MAGIC_DEAD;
 123         pcReturned = MAGIC_DEAD;
 124         SetLastError(MAGIC_DEAD);
 125         res = EnumMonitorsA(NULL, level, NULL, 0, &cbBuf, &pcReturned);
 126
 127         RETURN_ON_DEACTIVATED_SPOOLER(res)
 128
 129         /* not implemented yet in wine */
 130         if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) continue;
 131
 132
 133         /* use only a short test, when we test with an invalid level */
 134         if(!level || (level > 2)) {
 135             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
 136                 (res && (pcReturned == 0)),
 137                 "(%ld) returned %ld with %ld and 0x%08lx (expected '0' with " \
 138                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
 139                 level, res, GetLastError(), pcReturned);
 140             continue;
 141         }
 142
 143         /* Level 2 is not supported on win9x */
 144         if (!res && (GetLastError() == ERROR_INVALID_LEVEL)) {
 145             trace("Level %ld not supported, skipping tests\n", level);
 146             continue;
 147         }
 148
 149         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 150             "(%ld) returned %ld with %ld (expected '0' with " \
 151             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
 152
 153         if (!cbBuf) {
 154             trace("no valid buffer size returned, skipping tests\n");
 155             continue;
 156         }
 157
 158         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
 159         if (buffer == NULL) continue;
 160
 161         SetLastError(MAGIC_DEAD);
 162         pcbNeeded = MAGIC_DEAD;
 163         res = EnumMonitorsA(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
 164         ok(res, "(%ld) returned %ld with %ld (expected '!=0')\n",
 165                 level, res, GetLastError());
 166         ok(pcbNeeded == cbBuf, "(%ld) returned %ld (expected %ld)\n",
 167                 level, pcbNeeded, cbBuf);
 168         /* We can validate the returned Data with the Registry here */
 169
 170
 171         SetLastError(MAGIC_DEAD);
 172         pcReturned = MAGIC_DEAD;
 173         pcbNeeded = MAGIC_DEAD;
 174         res = EnumMonitorsA(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
 175         ok(res, "(%ld) returned %ld with %ld (expected '!=0')\n", level,
 176                 res, GetLastError());
 177         ok(pcbNeeded == cbBuf, "(%ld) returned %ld (expected %ld)\n", level,
 178                 pcbNeeded, cbBuf);
 179
 180         SetLastError(MAGIC_DEAD);
 181         pcbNeeded = MAGIC_DEAD;
 182         res = EnumMonitorsA(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
 183         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 184             "(%ld) returned %ld with %ld (expected '0' with " \
 185             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
 186
 187         ok(pcbNeeded == cbBuf, "(%ld) returned %ld (expected %ld)\n", level,
 188                 pcbNeeded, cbBuf);
 189
 190 /*
 191       Do not add the next test:
 192       w2k+:  RPC_X_NULL_REF_POINTER
 193       NT3.5: ERROR_INVALID_USER_BUFFER
 194       win9x: crash in winspool.drv
 195
 196       res = EnumMonitorsA(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
 197 */
 198
 199         SetLastError(MAGIC_DEAD);
 200         pcbNeeded = MAGIC_DEAD;
 201         pcReturned = MAGIC_DEAD;
 202         res = EnumMonitorsA(NULL, level, buffer, cbBuf, NULL, &pcReturned);
 203         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
 204             "(%ld) returned %ld with %ld (expected '!=0' or '0' with "\
 205             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
 206
 207         pcbNeeded = MAGIC_DEAD;
 208         pcReturned = MAGIC_DEAD;
 209         SetLastError(MAGIC_DEAD);
 210         res = EnumMonitorsA(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
 211         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
 212             "(%ld) returned %ld with %ld (expected '!=0' or '0' with "\
 213             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
 214
 215         HeapFree(GetProcessHeap(), 0, buffer);
 216     } /* for(level ... */
 217 }
 218
 219
 220 static void test_GetDefaultPrinter(void)
 221 {
 222     BOOL    retval;
 223     DWORD   exact = DEFAULT_PRINTER_SIZE;
 224     DWORD   size;
 225     char    buffer[DEFAULT_PRINTER_SIZE];
 226
 227     if (!pGetDefaultPrinterA)  return;
 228         /* only supported on NT like OSes starting with win2k */
 229
 230     SetLastError(ERROR_SUCCESS);
 231     retval = pGetDefaultPrinterA(buffer, &exact);
 232     if (!retval || !exact || !strlen(buffer) ||
 233         (ERROR_SUCCESS != GetLastError())) {
 234         if ((ERROR_FILE_NOT_FOUND == GetLastError()) ||
 235             (ERROR_INVALID_NAME == GetLastError()))
 236             trace("this test requires a default printer to be set\n");
 237         else {
 238                 ok( 0, "function call GetDefaultPrinterA failed unexpected!\n"
 239                 "function returned %s\n"
 240                 "last error 0x%08lx\n"
 241                 "returned buffer size 0x%08lx\n"
 242                 "returned buffer content %s\n",
 243                 retval ? "true" : "false", GetLastError(), exact, buffer);
 244         }
 245         return;
 246     }
 247     SetLastError(ERROR_SUCCESS);
 248     retval = pGetDefaultPrinterA(NULL, NULL);
 249     ok( !retval, "function result wrong! False expected\n");
 250     ok( ERROR_INVALID_PARAMETER == GetLastError(),
 251         "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08lx\n",
 252         GetLastError());
 253
 254     SetLastError(ERROR_SUCCESS);
 255     retval = pGetDefaultPrinterA(buffer, NULL);
 256     ok( !retval, "function result wrong! False expected\n");
 257     ok( ERROR_INVALID_PARAMETER == GetLastError(),
 258         "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08lx\n",
 259         GetLastError());
 260
 261     SetLastError(ERROR_SUCCESS);
 262     size = 0;
 263     retval = pGetDefaultPrinterA(NULL, &size);
 264     ok( !retval, "function result wrong! False expected\n");
 265     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
 266         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08lx\n",
 267         GetLastError());
 268     ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
 269         exact, size);
 270
 271     SetLastError(ERROR_SUCCESS);
 272     size = DEFAULT_PRINTER_SIZE;
 273     retval = pGetDefaultPrinterA(NULL, &size);
 274     ok( !retval, "function result wrong! False expected\n");
 275     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
 276         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08lx\n",
 277         GetLastError());
 278     ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
 279         exact, size);
 280
 281     size = 0;
 282     retval = pGetDefaultPrinterA(buffer, &size);
 283     ok( !retval, "function result wrong! False expected\n");
 284     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
 285         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08lx\n",
 286         GetLastError());
 287     ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
 288         exact, size);
 289
 290     size = exact;
 291     retval = pGetDefaultPrinterA(buffer, &size);
 292     ok( retval, "function result wrong! True expected\n");
 293     ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
 294         exact, size);
 295 }
 296
 297 static void test_GetPrinterDriverDirectory(void)
 298 {
 299     LPBYTE buffer = NULL;
 300     DWORD  cbBuf = 0, pcbNeeded = 0;
 301     BOOL   res;
 302
 303     SetLastError(MAGIC_DEAD);
 304     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, 0, &cbBuf);
 305     trace("first call returned 0x%04x, with %ld: buffer size 0x%08lx\n",
 306     res, GetLastError(), cbBuf);
 307
 308     RETURN_ON_DEACTIVATED_SPOOLER(res)
 309     ok((res == 0) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
 310         "returned %d with lasterror=%ld (expected '0' with " \
 311         "ERROR_INSUFFICIENT_BUFFER)\n", res, GetLastError());
 312
 313     if (!cbBuf) {
 314         trace("no valid buffer size returned, skipping tests\n");
 315         return;
 316     }
 317
 318     buffer = HeapAlloc( GetProcessHeap(), 0, cbBuf*2);
 319     if (buffer == NULL)  return ;
 320
 321     res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded);
 322     ok( res, "expected result != 0, got %d\n", res);
 323     ok( cbBuf == pcbNeeded, "pcbNeeded set to %ld instead of %ld\n",
 324                             pcbNeeded, cbBuf);
 325
 326     res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
 327     ok( res, "expected result != 0, got %d\n", res);
 328     ok( cbBuf == pcbNeeded, "pcbNeeded set to %ld instead of %ld\n",
 329                             pcbNeeded, cbBuf);
 330
 331     SetLastError(MAGIC_DEAD);
 332     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded);
 333     ok( !res , "expected result == 0, got %d\n", res);
 334     ok( cbBuf == pcbNeeded, "pcbNeeded set to %ld instead of %ld\n",
 335                             pcbNeeded, cbBuf);
 336
 337     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
 338         "last error set to %ld instead of ERROR_INSUFFICIENT_BUFFER\n",
 339         GetLastError());
 340
 341 /*
 342     Do not add the next test:
 343     XPsp2: crash in this app, when the spooler is not running
 344     NT3.5: ERROR_INVALID_USER_BUFFER
 345     win9x: ERROR_INVALID_PARAMETER
 346
 347     pcbNeeded = MAGIC_DEAD;
 348     SetLastError(MAGIC_DEAD);
 349     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, &pcbNeeded);
 350 */
 351
 352     SetLastError(MAGIC_DEAD);
 353     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf, NULL);
 354     ok( (!res && RPC_X_NULL_REF_POINTER == GetLastError()) || res,
 355          "expected either result == 0 and "
 356          "last error == RPC_X_NULL_REF_POINTER or result != 0 "
 357          "got result %d and last error == %ld\n", res, GetLastError());
 358
 359     SetLastError(MAGIC_DEAD);
 360     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, NULL);
 361     ok(res || (GetLastError() == RPC_X_NULL_REF_POINTER),
 362         "returned %d with %ld (expected '!=0' or '0' with " \
 363         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError());
 364
 365
 366     /* with a valid buffer, but level is too large */
 367     buffer[0] = '\0';
 368     SetLastError(MAGIC_DEAD);
 369     res = GetPrinterDriverDirectoryA(NULL, NULL, 2, buffer, cbBuf, &pcbNeeded);
 370
 371     /* Level not checked in win9x and wine:*/
 372     if((res != FALSE) && buffer[0])
 373     {
 374         trace("Level '2' not checked '%s'\n", buffer);
 375     }
 376     else
 377     {
 378         ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
 379         "returned %d with lasterror=%ld (expected '0' with " \
 380         "ERROR_INVALID_LEVEL)\n", res, GetLastError());
 381     }
 382
 383     /* printing environments are case insensitive */
 384     /* "Windows 4.0" is valid for win9x and NT */
 385     buffer[0] = '\0';
 386     SetLastError(MAGIC_DEAD);
 387     res = GetPrinterDriverDirectoryA(NULL, env_win9x_case, 1,
 388                                         buffer, cbBuf*2, &pcbNeeded);
 389
 390     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
 391         cbBuf = pcbNeeded;
 392         buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, cbBuf*2);
 393         if (buffer == NULL)  return ;
 394
 395         SetLastError(MAGIC_DEAD);
 396         res = GetPrinterDriverDirectoryA(NULL, env_win9x_case, 1,
 397                                         buffer, cbBuf*2, &pcbNeeded);
 398     }
 399
 400     ok(res && buffer[0], "returned %d with " \
 401         "lasterror=%ld and len=%d (expected '1' with 'len > 0')\n",
 402         res, GetLastError(), lstrlenA((char *)buffer));
 403
 404     buffer[0] = '\0';
 405     SetLastError(MAGIC_DEAD);
 406     res = GetPrinterDriverDirectoryA(NULL, env_x86, 1,
 407                                         buffer, cbBuf*2, &pcbNeeded);
 408
 409     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
 410         cbBuf = pcbNeeded;
 411         buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, cbBuf*2);
 412         if (buffer == NULL)  return ;
 413
 414         buffer[0] = '\0';
 415         SetLastError(MAGIC_DEAD);
 416         res = GetPrinterDriverDirectoryA(NULL, env_x86, 1,
 417                                         buffer, cbBuf*2, &pcbNeeded);
 418     }
 419
 420     /* "Windows NT x86" is invalid for win9x */
 421     ok( (res && buffer[0]) ||
 422         (!res && (GetLastError() == ERROR_INVALID_ENVIRONMENT)),
 423         "returned %d with lasterror=%ld and len=%d (expected '!= 0' with " \
 424         "'len > 0' or '0' with ERROR_INVALID_ENVIRONMENT)\n",
 425         res, GetLastError(), lstrlenA((char *)buffer));
 426
 427     /* A Setup-Programm (PDFCreator_0.8.0) use empty strings */
 428     SetLastError(MAGIC_DEAD);
 429     res = GetPrinterDriverDirectoryA("", "", 1, buffer, cbBuf*2, &pcbNeeded);
 430     ok(res, "returned %d with %ld (expected '!=0')\n", res, GetLastError() );
 431
 432     SetLastError(MAGIC_DEAD);
 433     res = GetPrinterDriverDirectoryA(NULL, "", 1, buffer, cbBuf*2, &pcbNeeded);
 434     ok(res, "returned %d with %ld (expected '!=0')\n", res, GetLastError() );
 435
 436     SetLastError(MAGIC_DEAD);
 437     res = GetPrinterDriverDirectoryA("", NULL, 1, buffer, cbBuf*2, &pcbNeeded);
 438     ok(res, "returned %d with %ld (expected '!=0')\n", res, GetLastError() );
 439
 440     HeapFree( GetProcessHeap(), 0, buffer);
 441 }
 442
 443 static void test_OpenPrinter(void)
 444 {
 445     PRINTER_DEFAULTSA defaults;
 446     HANDLE  hprinter;
 447     LPSTR   default_printer;
 448     DWORD   res;
 449     DWORD   size;
 450     CHAR    buffer[DEFAULT_PRINTER_SIZE];
 451     LPSTR   ptr;
 452
 453     SetLastError(MAGIC_DEAD);
 454     res = OpenPrinter(NULL, NULL, NULL);
 455     /* The deactivated Spooler is catched here on NT3.51 */
 456     RETURN_ON_DEACTIVATED_SPOOLER(res)
 457     ok(!res && (GetLastError() == ERROR_INVALID_PARAMETER),
 458         "returned %ld with %ld (expected '0' with ERROR_INVALID_PARAMETER)\n",
 459         res, GetLastError());
 460
 461
 462     /* Get Handle for the local Printserver (NT only)*/
 463     hprinter = (HANDLE) MAGIC_DEAD;
 464     SetLastError(MAGIC_DEAD);
 465     res = OpenPrinter(NULL, &hprinter, NULL);
 466     /* The deactivated Spooler is catched here on XPsp2 */
 467     RETURN_ON_DEACTIVATED_SPOOLER(res)
 468     ok(res || (!res && GetLastError() == ERROR_INVALID_PARAMETER),
 469         "returned %ld with %ld (expected '!=0' or '0' with ERROR_INVALID_PARAMETER)\n",
 470         res, GetLastError());
 471     if(res) {
 472         ClosePrinter(hprinter);
 473
 474         defaults.pDatatype=NULL;
 475         defaults.pDevMode=NULL;
 476
 477         defaults.DesiredAccess=0;
 478         hprinter = (HANDLE) MAGIC_DEAD;
 479         SetLastError(MAGIC_DEAD);
 480         res = OpenPrinter(NULL, &hprinter, &defaults);
 481         ok(res, "returned %ld with %ld (expected '!=0')\n", res, GetLastError());
 482         if (res) ClosePrinter(hprinter);
 483
 484         defaults.DesiredAccess=-1;
 485         hprinter = (HANDLE) MAGIC_DEAD;
 486         SetLastError(MAGIC_DEAD);
 487         res = OpenPrinter(NULL, &hprinter, &defaults);
 488         ok(!res && GetLastError() == ERROR_ACCESS_DENIED,
 489             "returned %ld with %ld (expected '0' with ERROR_ACCESS_DENIED)\n",
 490             res, GetLastError());
 491         if (res) ClosePrinter(hprinter);
 492
 493     }
 494
 495     size = sizeof(buffer) - 3 ;
 496     ptr = buffer;
 497     ptr[0] = '\\';
 498     ptr++;
 499     ptr[0] = '\\';
 500     ptr++;
 501     if (GetComputerNameA(ptr, &size)) {
 502
 503         hprinter = (HANDLE) MAGIC_DEAD;
 504         SetLastError(MAGIC_DEAD);
 505         res = OpenPrinter(buffer, &hprinter, NULL);
 506         todo_wine {
 507         ok(res || (!res && GetLastError() == ERROR_INVALID_PARAMETER),
 508             "returned %ld with %ld (expected '!=0' or '0' with ERROR_INVALID_PARAMETER)\n",
 509             res, GetLastError());
 510         }
 511         if(res) ClosePrinter(hprinter);
 512     }
 513
 514     /* Invalid Printername */
 515     hprinter = (HANDLE) MAGIC_DEAD;
 516     SetLastError(MAGIC_DEAD);
 517     res = OpenPrinter("illegal,name", &hprinter, NULL);
 518     ok(!res && ((GetLastError() == ERROR_INVALID_PRINTER_NAME) ||
 519                 (GetLastError() == ERROR_INVALID_PARAMETER) ),
 520        "returned %ld with %ld (expected '0' with: ERROR_INVALID_PARAMETER or" \
 521        "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 522     if(res) ClosePrinter(hprinter);
 523
 524
 525     /* Get Handle for the default Printer */
 526     if ((default_printer = find_default_printer()))
 527     {
 528         hprinter = (HANDLE) MAGIC_DEAD;
 529         SetLastError(MAGIC_DEAD);
 530         res = OpenPrinter(default_printer, &hprinter, NULL);
 531         if((!res) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE))
 532         {
 533                 trace("The Service 'Spooler' is required for '%s'\n", default_printer);
 534             return;
 535         }
 536         ok(res, "returned %ld with %ld (expected '!=0')\n", res, GetLastError());
 537         if(res) ClosePrinter(hprinter);
 538
 539         defaults.pDatatype=NULL;
 540         defaults.pDevMode=NULL;
 541         defaults.DesiredAccess=0;
 542
 543         hprinter = (HANDLE) MAGIC_DEAD;
 544         SetLastError(MAGIC_DEAD);
 545         res = OpenPrinter(default_printer, &hprinter, &defaults);
 546         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
 547             "returned %ld with %ld (expected '!=0' or '0' with " \
 548             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
 549         if(res) ClosePrinter(hprinter);
 550
 551         defaults.pDatatype="";
 552
 553         hprinter = (HANDLE) MAGIC_DEAD;
 554         SetLastError(MAGIC_DEAD);
 555         res = OpenPrinter(default_printer, &hprinter, &defaults);
 556         /* stop here, when a remote Printserver has no RPC-Service running */
 557         RETURN_ON_DEACTIVATED_SPOOLER(res)
 558         ok(res || ((GetLastError() == ERROR_INVALID_DATATYPE) ||
 559                    (GetLastError() == ERROR_ACCESS_DENIED)),
 560             "returned %ld with %ld (expected '!=0' or '0' with: " \
 561             "ERROR_INVALID_DATATYPE or ERROR_ACCESS_DENIED)\n",
 562             res, GetLastError());
 563         if(res) ClosePrinter(hprinter);
 564
 565
 566         defaults.pDatatype=NULL;
 567         defaults.DesiredAccess=PRINTER_ACCESS_USE;
 568
 569         hprinter = (HANDLE) MAGIC_DEAD;
 570         SetLastError(MAGIC_DEAD);
 571         res = OpenPrinter(default_printer, &hprinter, &defaults);
 572         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
 573             "returned %ld with %ld (expected '!=0' or '0' with " \
 574             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
 575         if(res) ClosePrinter(hprinter);
 576
 577
 578         defaults.DesiredAccess=PRINTER_ALL_ACCESS;
 579         hprinter = (HANDLE) MAGIC_DEAD;
 580         SetLastError(MAGIC_DEAD);
 581         res = OpenPrinter(default_printer, &hprinter, &defaults);
 582         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
 583             "returned %ld with %ld (expected '!=0' or '0' with " \
 584             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
 585         if(res) ClosePrinter(hprinter);
 586     }
 587
 588 }
 589
 590
 591 static void test_SetDefaultPrinter(void)
 592 {
 593     DWORD   res;
 594     LPSTR   default_printer;
 595     DWORD   size = DEFAULT_PRINTER_SIZE;
 596     CHAR    buffer[DEFAULT_PRINTER_SIZE];
 597     CHAR    org_value[DEFAULT_PRINTER_SIZE];
 598
 599
 600     if (!pSetDefaultPrinterA)  return;
 601         /* only supported on win2k and above */
 602
 603     default_printer = find_default_printer();
 604
 605     /* backup the original value */
 606     org_value[0] = '\0';
 607     SetLastError(MAGIC_DEAD);
 608     res = GetProfileStringA("windows", "device", NULL, org_value, size);
 609
 610     /* first part: with the default Printer */
 611     SetLastError(MAGIC_DEAD);
 612     res = pSetDefaultPrinterA("no_printer_with_this_name");
 613
 614     RETURN_ON_DEACTIVATED_SPOOLER(res)
 615     /* spooler is running or we have no spooler here*/
 616
 617     /* Not implemented in wine */
 618     if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) {
 619         trace("SetDefaultPrinterA() not implemented yet.\n");
 620         return;
 621     }
 622
 623     ok(!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME),
 624         "returned %ld with %ld (expected '0' with " \
 625         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 626
 627     WriteProfileStringA("windows", "device", org_value);
 628     SetLastError(MAGIC_DEAD);
 629     res = pSetDefaultPrinterA("");
 630     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
 631         "returned %ld with %ld (expected '!=0' or '0' with " \
 632         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 633
 634     WriteProfileStringA("windows", "device", org_value);
 635     SetLastError(MAGIC_DEAD);
 636     res = pSetDefaultPrinterA(NULL);
 637     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
 638         "returned %ld with %ld (expected '!=0' or '0' with " \
 639         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 640
 641     WriteProfileStringA("windows", "device", org_value);
 642     SetLastError(MAGIC_DEAD);
 643     res = pSetDefaultPrinterA(default_printer);
 644     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
 645         "returned %ld with %ld (expected '!=0' or '0' with " \
 646         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 647
 648
 649     /* second part: always without a default Printer */
 650     WriteProfileStringA("windows", "device", NULL);
 651     SetLastError(MAGIC_DEAD);
 652     res = pSetDefaultPrinterA("no_printer_with_this_name");
 653
 654     ok(!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME),
 655         "returned %ld with %ld (expected '0' with " \
 656         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 657
 658     WriteProfileStringA("windows", "device", NULL);
 659     SetLastError(MAGIC_DEAD);
 660     res = pSetDefaultPrinterA("");
 661     /* we get ERROR_INVALID_PRINTER_NAME when no printer is installed */
 662     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
 663          "returned %ld with %ld (expected '!=0' or '0' with " \
 664          "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 665
 666     WriteProfileStringA("windows", "device", NULL);
 667     SetLastError(MAGIC_DEAD);
 668     res = pSetDefaultPrinterA(NULL);
 669     /* we get ERROR_INVALID_PRINTER_NAME when no printer is installed */
 670     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
 671         "returned %ld with %ld (expected '!=0' or '0' with " \
 672         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 673
 674     WriteProfileStringA("windows", "device", NULL);
 675     SetLastError(MAGIC_DEAD);
 676     res = pSetDefaultPrinterA(default_printer);
 677     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
 678         "returned %ld with %ld (expected '!=0' or '0' with " \
 679         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
 680
 681     /* restore the original value */
 682     res = pSetDefaultPrinterA(default_printer);          /* the nice way */
 683     WriteProfileStringA("windows", "device", org_value); /* the old way */
 684
 685     buffer[0] = '\0';
 686     SetLastError(MAGIC_DEAD);
 687     res = GetProfileStringA("windows", "device", NULL, buffer, size);
 688     ok(!lstrcmpA(org_value, buffer), "'%s' (expected '%s')\n", buffer, org_value);
 689
 690 }
 691
 692
 693 START_TEST(info)
 694 {
 695     hwinspool = GetModuleHandleA("winspool.drv");
 696     pGetDefaultPrinterA = (void *) GetProcAddress(hwinspool, "GetDefaultPrinterA");
 697     pSetDefaultPrinterA = (void *) GetProcAddress(hwinspool, "SetDefaultPrinterA");
 698
 699     find_default_printer();
 700
 701     test_EnumMonitors();
 702     test_GetDefaultPrinter();
 703     test_GetPrinterDriverDirectory();
 704     test_OpenPrinter();
 705     test_SetDefaultPrinter();
 706 }