winspool.drv/tests: No need to return anything as we are using a global variable...
[wine] / 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
23 #include "wine/test.h"
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "winreg.h"
30 #include "winspool.h"
31
32 #define MAGIC_DEAD  0xdeadbeef
33 #define DEFAULT_PRINTER_SIZE 1000
34
35 static CHAR does_not_exist_dll[]= "does_not_exists.dll";
36 static CHAR does_not_exist[]    = "does_not_exists";
37 static CHAR empty[]             = "";
38 static CHAR env_x86[]           = "Windows NT x86";
39 static CHAR env_win9x_case[]    = "windowS 4.0";
40 static CHAR illegal_name[]      = "illegal,name";
41 static CHAR invalid_env[]       = "invalid_env";
42 static CHAR invalid_server[]    = "\\invalid_server";
43 static CHAR portname_com1[]     = "COM1:";
44 static CHAR portname_file[]     = "FILE:";
45 static CHAR portname_lpt1[]     = "LPT1:";
46 static CHAR version_dll[]       = "version.dll";
47 static CHAR winetest_monitor[]  = "winetest";
48
49 static HANDLE  hwinspool;
50 static FARPROC pGetDefaultPrinterA;
51 static FARPROC pSetDefaultPrinterA;
52
53 struct monitor_entry {
54     LPSTR  env;
55     CHAR  dllname[32];
56 };
57
58 static LPSTR   default_printer = NULL;
59
60 /* report common behavior only once */
61 static DWORD report_deactivated_spooler = 1;
62 #define RETURN_ON_DEACTIVATED_SPOOLER(res) \
63     if((res == 0) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE)) \
64     { \
65         if(report_deactivated_spooler > 0) { \
66             report_deactivated_spooler--; \
67             trace("The Service 'Spooler' is required for many test\n"); \
68         } \
69         return; \
70     }
71
72
73 static void find_default_printer(VOID)
74 {
75     static  char    buffer[DEFAULT_PRINTER_SIZE];
76     DWORD   needed;
77     DWORD   res;
78     LPSTR   ptr;
79
80     if ((default_printer == NULL) && (pGetDefaultPrinterA))
81     {
82         /* w2k and above */
83         needed = sizeof(buffer);
84         res = pGetDefaultPrinterA(buffer, &needed);
85         if(res)  default_printer = buffer;
86         trace("default_printer: '%s'\n", default_printer);
87     }
88     if (default_printer == NULL)
89     {
90         HKEY hwindows;
91         DWORD   type;
92         /* NT 3.x and above */
93         if (RegOpenKeyEx(HKEY_CURRENT_USER, 
94                         "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows",
95                         0, KEY_QUERY_VALUE, &hwindows) == NO_ERROR) {
96
97             needed = sizeof(buffer);
98             if (RegQueryValueEx(hwindows, "device", NULL, 
99                                 &type, (LPBYTE)buffer, &needed) == NO_ERROR) {
100
101                 ptr = strchr(buffer, ',');
102                 if (ptr) {
103                     ptr[0] = '\0';
104                     default_printer = buffer;
105                 }
106             }
107             RegCloseKey(hwindows);
108         }
109         trace("default_printer: '%s'\n", default_printer);
110     }
111     if (default_printer == NULL)
112     {
113         /* win9x */
114         needed = sizeof(buffer);
115         res = GetProfileStringA("windows", "device", "*", buffer, needed);
116         if(res) {
117             ptr = strchr(buffer, ',');
118             if (ptr) {
119                 ptr[0] = '\0';
120                 default_printer = buffer;
121             }
122         }
123         trace("default_printer: '%s'\n", default_printer);
124     }
125 }
126
127
128 static struct monitor_entry * find_installed_monitor(void)
129 {
130     MONITOR_INFO_2A mi2a; 
131     static struct  monitor_entry * entry = NULL;
132     DWORD   num_tests;
133     DWORD   i = 0;
134
135     static struct monitor_entry  monitor_table[] = {
136         {env_win9x_case, "localspl.dll"},
137         {env_x86,        "localspl.dll"},
138         {env_win9x_case, "localmon.dll"},
139         {env_x86,        "localmon.dll"},
140         {env_win9x_case, "tcpmon.dll"},
141         {env_x86,        "tcpmon.dll"},
142         {env_win9x_case, "usbmon.dll"},
143         {env_x86,        "usbmon.dll"},
144         {env_win9x_case, "mspp32.dll"},
145         {env_x86,        "win32spl.dll"},
146         {env_x86,        "redmonnt.dll"},
147         {env_x86,        "redmon35.dll"},
148         {env_win9x_case, "redmon95.dll"},
149         {env_x86,        "pdfcmnnt.dll"},
150         {env_win9x_case, "pdfcmn95.dll"},
151     };
152
153     if (entry) return entry;
154
155     num_tests = (sizeof(monitor_table)/sizeof(struct monitor_entry));
156
157     /* cleanup */
158     DeleteMonitorA(NULL, env_x86, winetest_monitor);
159     DeleteMonitorA(NULL, env_win9x_case, winetest_monitor);
160
161     /* find a usable monitor from the table */    
162     mi2a.pName = winetest_monitor;
163     while ((entry == NULL) && (i < num_tests)) {
164         entry = &monitor_table[i];
165         i++;
166         mi2a.pEnvironment = entry->env;
167         mi2a.pDLLName = entry->dllname;
168
169         if (AddMonitorA(NULL, 2, (LPBYTE) &mi2a)) {
170             /* we got one */
171             trace("using '%s', '%s'\n", entry->env, entry->dllname);
172             DeleteMonitorA(NULL, entry->env, winetest_monitor);
173         }
174         else
175         {
176             entry = NULL;
177         }
178     }
179     return entry;
180 }
181
182 /* ########################### */
183
184
185 static void test_AddMonitor(void)
186 {
187     MONITOR_INFO_2A mi2a; 
188     struct  monitor_entry * entry = NULL;
189     DWORD   res;
190
191     entry = find_installed_monitor();
192
193     SetLastError(MAGIC_DEAD);
194     res = AddMonitorA(NULL, 1, NULL);
195     ok(!res && (GetLastError() == ERROR_INVALID_LEVEL), 
196         "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
197         res, GetLastError());
198
199     SetLastError(MAGIC_DEAD);
200     res = AddMonitorA(NULL, 3, NULL);
201     ok(!res && (GetLastError() == ERROR_INVALID_LEVEL), 
202         "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
203         res, GetLastError());
204
205 #if 0
206     /* This test crash with win9x on vmware (works with win9x on qemu 0.8.1) */
207     SetLastError(MAGIC_DEAD);
208     res = AddMonitorA(NULL, 2, NULL);
209     /* NT: unchanged,  9x: ERROR_PRIVILEGE_NOT_HELD */
210     ok(!res &&
211         ((GetLastError() == MAGIC_DEAD) ||
212          (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)), 
213         "returned %d with %d (expected '0' with: MAGIC_DEAD or " \
214         "ERROR_PRIVILEGE_NOT_HELD)\n", res, GetLastError());
215 #endif
216
217     ZeroMemory(&mi2a, sizeof(MONITOR_INFO_2A));
218     SetLastError(MAGIC_DEAD);
219     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
220     RETURN_ON_DEACTIVATED_SPOOLER(res)
221
222     if (!res && (GetLastError() == ERROR_ACCESS_DENIED)) {
223         trace("skip tests (ACCESS_DENIED)\n");
224         return;
225     }
226
227     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_INVALID_ENVIRONMENT */
228     ok(!res && ((GetLastError() == ERROR_INVALID_PARAMETER) ||
229                 (GetLastError() == ERROR_INVALID_ENVIRONMENT)), 
230         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or " \
231         "ERROR_INVALID_ENVIRONMENT)\n", res, GetLastError());
232
233     if (!entry) {
234         trace("No usable Monitor found: Skip tests\n");
235         return;
236     }
237
238 #if 0
239     /* The Test is deactivated, because when mi2a.pName is NULL, the subkey
240        HKLM\System\CurrentControlSet\Control\Print\Monitors\C:\WINDOWS\SYSTEM
241        or HKLM\System\CurrentControlSet\Control\Print\Monitors\ì
242        is created on win9x and we do not want to hit this bug here. */
243
244     mi2a.pEnvironment = entry->env;
245     SetLastError(MAGIC_DEAD);
246     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
247     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_PRIVILEGE_NOT_HELD */
248 #endif
249
250     mi2a.pEnvironment = entry->env;
251     mi2a.pName = empty;
252     SetLastError(MAGIC_DEAD);
253     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
254     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_PRIVILEGE_NOT_HELD */
255     ok( !res &&
256         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
257          (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)), 
258         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or " \
259         "ERROR_PRIVILEGE_NOT_HELD)\n",
260         res, GetLastError());
261
262     mi2a.pName = winetest_monitor;
263     SetLastError(MAGIC_DEAD);
264     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
265     /* NT: ERROR_INVALID_PARAMETER,  9x: ERROR_PRIVILEGE_NOT_HELD */
266     ok( !res &&
267         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
268          (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)), 
269         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or " \
270         "ERROR_PRIVILEGE_NOT_HELD)\n",
271         res, GetLastError());
272
273     mi2a.pDLLName = empty;
274     SetLastError(MAGIC_DEAD);
275     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
276     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER),
277         "returned %d with %d (expected '0' with ERROR_INVALID_PARAMETER)\n",
278         res, GetLastError());
279
280     mi2a.pDLLName = does_not_exist_dll;
281     SetLastError(MAGIC_DEAD);
282     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
283     /* NT: ERROR_MOD_NOT_FOUND,  9x: ERROR_INVALID_PARAMETER */
284     ok( !res &&
285         ((GetLastError() == ERROR_MOD_NOT_FOUND) ||
286         (GetLastError() == ERROR_INVALID_PARAMETER)),
287         "returned %d with %d (expected '0' with: ERROR_MOD_NOT_FOUND or " \
288         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
289
290     mi2a.pDLLName = version_dll;
291     SetLastError(MAGIC_DEAD);
292     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
293     /* NT: ERROR_PROC_NOT_FOUND,  9x: ERROR_INVALID_PARAMETER */
294     ok( !res &&
295         ((GetLastError() == ERROR_PROC_NOT_FOUND) ||
296         (GetLastError() == ERROR_INVALID_PARAMETER)),
297         "returned %d with %d (expected '0' with: ERROR_PROC_NOT_FOUND or " \
298         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
299     if (res) DeleteMonitorA(NULL, entry->env, winetest_monitor); 
300
301    /* Test AddMonitor with real options */
302     mi2a.pDLLName = entry->dllname;
303     SetLastError(MAGIC_DEAD);
304     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
305     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
306
307     /* add a monitor twice */
308     SetLastError(MAGIC_DEAD);
309     res = AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
310     /* NT: ERROR_PRINT_MONITOR_ALREADY_INSTALLED (3006), 9x: ERROR_ALREADY_EXISTS (183) */
311     ok( !res &&
312         ((GetLastError() == ERROR_PRINT_MONITOR_ALREADY_INSTALLED) ||
313         (GetLastError() == ERROR_ALREADY_EXISTS)), 
314         "returned %d with %d (expected '0' with: " \
315         "ERROR_PRINT_MONITOR_ALREADY_INSTALLED or ERROR_ALREADY_EXISTS)\n",
316         res, GetLastError());
317
318     DeleteMonitorA(NULL, entry->env, winetest_monitor); 
319     SetLastError(MAGIC_DEAD);
320     res = AddMonitorA(empty, 2, (LPBYTE) &mi2a);
321     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
322
323     /* cleanup */
324     DeleteMonitorA(NULL, entry->env, winetest_monitor);
325
326 }
327
328 /* ########################### */
329
330 static void test_AddPort(void)
331 {
332     DWORD   res;
333
334     SetLastError(0xdeadbeef);
335     res = AddPortA(NULL, 0, NULL);
336     RETURN_ON_DEACTIVATED_SPOOLER(res)
337     /* NT: RPC_X_NULL_REF_POINTER, 9x: ERROR_INVALID_PARAMETER */
338     ok( !res && ((GetLastError() == RPC_X_NULL_REF_POINTER) || 
339                  (GetLastError() == ERROR_INVALID_PARAMETER)),
340         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
341         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
342
343
344     SetLastError(0xdeadbeef);
345     res = AddPortA(NULL, 0, empty);
346     /* Allowed only for (Printer-)Administrators */
347     if (!res && (GetLastError() == ERROR_ACCESS_DENIED)) {
348         trace("skip tests (ACCESS_DENIED)\n");
349         return;
350     }
351     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
352     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) || 
353                  (GetLastError() == ERROR_INVALID_PARAMETER)),
354         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
355         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
356
357
358     SetLastError(0xdeadbeef);
359     res = AddPortA(NULL, 0, does_not_exist);
360     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
361     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) || 
362                  (GetLastError() == ERROR_INVALID_PARAMETER)),
363         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
364         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
365
366 }
367
368 /* ########################### */
369
370 static void test_ConfigurePort(void)
371 {
372     DWORD   res;
373
374
375     SetLastError(0xdeadbeef);
376     res = ConfigurePortA(NULL, 0, NULL);
377     RETURN_ON_DEACTIVATED_SPOOLER(res)
378     /* NT: RPC_X_NULL_REF_POINTER, 9x: ERROR_INVALID_PARAMETER */
379     ok( !res && ((GetLastError() == RPC_X_NULL_REF_POINTER) || 
380                  (GetLastError() == ERROR_INVALID_PARAMETER)),
381         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
382         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
383
384     SetLastError(0xdeadbeef);
385     res = ConfigurePortA(NULL, 0, empty);
386     /* Allowed only for (Printer-)Administrators */
387     if (!res && (GetLastError() == ERROR_ACCESS_DENIED)) {
388         trace(" skip tests (ACCESS_DENIED)\n");
389         return;
390     }
391     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
392     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) || 
393                  (GetLastError() == ERROR_INVALID_PARAMETER)),
394         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
395         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
396
397
398     SetLastError(0xdeadbeef);
399     res = ConfigurePortA(NULL, 0, does_not_exist);
400     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
401     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) || 
402                  (GetLastError() == ERROR_INVALID_PARAMETER)),
403         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
404         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
405
406
407     /*  Testing-Results:
408         - Case of Portnames is ignored 
409         - Portname without ":" => NT: ERROR_NOT_SUPPORTED, 9x: Dialog comes up
410         - Empty Servername (LPT1:) => NT: ERROR_NOT_SUPPORTED, 9x: Dialog comes up
411
412         - Port not present =>  9x: ERROR_INVALID_PARAMETER, NT:ERROR_NOT_SUPPORTED
413         - "FILE:" => 9x:Success, NT:ERROR_CANCELED
414         - Cancel ("Local Port") => ERROR_CANCELED
415         - Cancel ("Redirected Port") => Success
416     */
417     if (winetest_interactive > 0) {
418         SetLastError(0xdeadbeef);
419         res = ConfigurePortA(NULL, 0, portname_com1);
420         trace("'%s' returned %d with %d\n", portname_com1, res, GetLastError());
421
422         SetLastError(0xdeadbeef);
423         res = ConfigurePortA(NULL, 0, portname_lpt1);
424         trace("'%s' returned %d with %d\n", portname_lpt1, res, GetLastError());
425
426         SetLastError(0xdeadbeef);
427         res = ConfigurePortA(NULL, 0, portname_file);
428         trace("'%s' returned %d with %d\n", portname_file, res, GetLastError());
429     }
430 }
431
432 /* ########################### */
433
434 static void test_DeleteMonitor(void)
435 {
436     MONITOR_INFO_2A         mi2a;
437     struct monitor_entry  * entry = NULL;
438     DWORD                   res;
439
440
441     entry = find_installed_monitor();
442
443     if (!entry) {
444         trace("No usable Monitor found: Skip tests\n");
445         return;
446     }
447
448     mi2a.pName = winetest_monitor;
449     mi2a.pEnvironment = entry->env;
450     mi2a.pDLLName = entry->dllname;
451
452     /* Testing DeleteMonitor with real options */
453     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
454
455     SetLastError(MAGIC_DEAD);
456     res = DeleteMonitorA(NULL, entry->env, winetest_monitor);
457     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
458
459     /* Delete the Monitor twice */
460     SetLastError(MAGIC_DEAD);
461     res = DeleteMonitorA(NULL, entry->env, winetest_monitor);
462     /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
463     ok( !res &&
464         ((GetLastError() == ERROR_UNKNOWN_PRINT_MONITOR) ||
465         (GetLastError() == ERROR_INVALID_PARAMETER)), 
466         "returned %d with %d (expected '0' with: ERROR_UNKNOWN_PRINT_MONITOR" \
467         " or ERROR_INVALID_PARAMETER)\n", res, GetLastError());
468
469     /* the environment */
470     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
471     SetLastError(MAGIC_DEAD);
472     res = DeleteMonitorA(NULL, NULL, winetest_monitor);
473     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
474
475     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
476     SetLastError(MAGIC_DEAD);
477     res = DeleteMonitorA(NULL, empty, winetest_monitor);
478     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
479
480     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
481     SetLastError(MAGIC_DEAD);
482     res = DeleteMonitorA(NULL, invalid_env, winetest_monitor);
483     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
484
485     /* the monitor-name */
486     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
487     SetLastError(MAGIC_DEAD);
488     res = DeleteMonitorA(NULL, entry->env, NULL);
489     /* NT: ERROR_INVALID_PARAMETER (87),  9x: ERROR_INVALID_NAME (123)*/
490     ok( !res &&
491         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
492         (GetLastError() == ERROR_INVALID_NAME)),
493         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or " \
494         "ERROR_INVALID_NAME)\n", res, GetLastError());
495
496     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
497     SetLastError(MAGIC_DEAD);
498     res = DeleteMonitorA(NULL, entry->env, empty);
499     /* NT: ERROR_INVALID_PARAMETER (87),  9x: ERROR_INVALID_NAME (123)*/
500     ok( !res && 
501         ((GetLastError() == ERROR_INVALID_PARAMETER) ||
502         (GetLastError() == ERROR_INVALID_NAME)),
503         "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or " \
504         "ERROR_INVALID_NAME)\n", res, GetLastError());
505
506     AddMonitorA(NULL, 2, (LPBYTE) &mi2a);
507     SetLastError(MAGIC_DEAD);
508     res = DeleteMonitorA(empty, entry->env, winetest_monitor);
509     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
510
511     /* cleanup */
512     DeleteMonitorA(NULL, entry->env, winetest_monitor);
513 }
514
515 /* ########################### */
516
517 static void test_DeletePort(void)
518 {
519     DWORD   res;
520
521     SetLastError(0xdeadbeef);
522     res = DeletePortA(NULL, 0, NULL);
523     RETURN_ON_DEACTIVATED_SPOOLER(res)
524
525     SetLastError(0xdeadbeef);
526     res = DeletePortA(NULL, 0, empty);
527     /* Allowed only for (Printer-)Administrators */
528     if (!res && (GetLastError() == ERROR_ACCESS_DENIED)) {
529         trace("skip tests (ACCESS_DENIED)\n");
530         return;
531     }
532     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
533     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) || 
534                  (GetLastError() == ERROR_INVALID_PARAMETER)),
535         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
536         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
537
538
539     SetLastError(0xdeadbeef);
540     res = DeletePortA(NULL, 0, does_not_exist);
541     /* XP: ERROR_NOT_SUPPORTED, NT351 and 9x: ERROR_INVALID_PARAMETER */
542     ok( !res && ((GetLastError() == ERROR_NOT_SUPPORTED) || 
543                  (GetLastError() == ERROR_INVALID_PARAMETER)),
544         "returned %d with %d (expected '0' with ERROR_NOT_SUPPORTED or " \
545         "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
546
547 }
548
549 /* ########################### */
550
551 static void test_EnumForms(LPSTR pName)
552 {
553     DWORD   res;
554     HANDLE  hprinter = 0;
555     LPBYTE  buffer;
556     DWORD   cbBuf;
557     DWORD   pcbNeeded;
558     DWORD   pcReturned;
559     DWORD   level;
560   
561
562     res = OpenPrinter(pName, &hprinter, NULL);
563     RETURN_ON_DEACTIVATED_SPOOLER(res)
564     if (!res || !hprinter)
565     {
566         /* Open the local Prinserver is not supported on win9x */
567         if (pName) trace("Failed to open '%s', skiping the test\n", pName);
568         return;
569     }
570
571     /* valid levels are 1 and 2 */
572     for(level = 0; level < 4; level++) {
573         cbBuf = 0xdeadbeef;
574         pcReturned = 0xdeadbeef;
575         SetLastError(0xdeadbeef);
576         res = EnumFormsA(hprinter, level, NULL, 0, &cbBuf, &pcReturned);
577        
578         /* EnumForms is not implemented in win9x */
579         if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) continue;
580
581         /* EnumForms for the Server not implemented on all NT-Versions */
582         if (!res && (GetLastError() == ERROR_INVALID_HANDLE) && !pName) continue;
583
584         /* Level 2 for EnumForms is not supported on all systems */
585         if (!res && (GetLastError() == ERROR_INVALID_LEVEL) && (level == 2)) continue;
586
587         /* use only a short test, when we test with an invalid level */
588         if(!level || (level > 2)) {
589             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
590                 (res && (pcReturned == 0)),
591                 "(%d) returned %d with %d and 0x%08x (expected '0' with " \
592                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
593                 level, res, GetLastError(), pcReturned);
594             continue;
595         }        
596
597         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
598             "(%d) returned %d with %d (expected '0' with " \
599             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
600
601         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
602         if (buffer == NULL) continue;
603
604         SetLastError(0xdeadbeef);
605         res = EnumFormsA(hprinter, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
606         ok(res, "(%d) returned %d with %d (expected '!=0')\n",
607                 level, res, GetLastError());
608         /* We can dump the returned Data here */
609
610
611         SetLastError(0xdeadbeef);
612         res = EnumFormsA(hprinter, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
613         ok( res, "(%d) returned %d with %d (expected '!=0')\n",
614             level, res, GetLastError());
615
616         SetLastError(0xdeadbeef);
617         res = EnumFormsA(hprinter, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
618         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
619             "(%d) returned %d with %d (expected '0' with " \
620             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
621
622
623         SetLastError(0xdeadbeef);
624         res = EnumFormsA(hprinter, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
625         ok( !res && (GetLastError() == ERROR_INVALID_USER_BUFFER) ,
626             "(%d) returned %d with %d (expected '0' with "\
627             "ERROR_INVALID_USER_BUFFER)\n", level, res, GetLastError());
628
629
630         SetLastError(0xdeadbeef);
631         res = EnumFormsA(hprinter, level, buffer, cbBuf, NULL, &pcReturned);
632         ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER) ,
633             "(%d) returned %d with %d (expected '0' with "\
634             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
635
636         SetLastError(0xdeadbeef);
637         res = EnumFormsA(hprinter, level, buffer, cbBuf, &pcbNeeded, NULL);
638         ok( !res && (GetLastError() == RPC_X_NULL_REF_POINTER) ,
639             "(%d) returned %d with %d (expected '0' with "\
640             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
641
642         SetLastError(0xdeadbeef);
643         res = EnumFormsA(0, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
644         ok( !res && (GetLastError() == ERROR_INVALID_HANDLE) ,
645             "(%d) returned %d with %d (expected '0' with "\
646             "ERROR_INVALID_HANDLE)\n", level, res, GetLastError());
647
648         HeapFree(GetProcessHeap(), 0, buffer);
649     } /* for(level ... */
650
651     ClosePrinter(hprinter);
652 }
653
654 /* ########################### */
655
656 static void test_EnumMonitors(void)
657 {
658     DWORD   res;
659     LPBYTE  buffer;
660     DWORD   cbBuf;
661     DWORD   pcbNeeded;
662     DWORD   pcReturned;
663     DWORD   level;
664
665     /* valid levels are 1 and 2 */
666     for(level = 0; level < 4; level++) {
667         cbBuf = MAGIC_DEAD;
668         pcReturned = MAGIC_DEAD;
669         SetLastError(MAGIC_DEAD);
670         res = EnumMonitorsA(NULL, level, NULL, 0, &cbBuf, &pcReturned);
671
672         RETURN_ON_DEACTIVATED_SPOOLER(res)
673
674         /* not implemented yet in wine */
675         if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) continue;
676
677
678         /* use only a short test, when we test with an invalid level */
679         if(!level || (level > 2)) {
680             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
681                 (res && (pcReturned == 0)),
682                 "(%d) returned %d with %d and 0x%08x (expected '0' with " \
683                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
684                 level, res, GetLastError(), pcReturned);
685             continue;
686         }        
687
688         /* Level 2 is not supported on win9x */
689         if (!res && (GetLastError() == ERROR_INVALID_LEVEL)) {
690             trace("Level %d not supported, skipping tests\n", level);
691             continue;
692         }
693
694         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
695             "(%d) returned %d with %d (expected '0' with " \
696             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
697
698         if (!cbBuf) {
699             trace("no valid buffer size returned, skipping tests\n");
700             continue;
701         }
702
703         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
704         if (buffer == NULL) continue;
705
706         SetLastError(MAGIC_DEAD);
707         pcbNeeded = MAGIC_DEAD;
708         res = EnumMonitorsA(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
709         ok(res, "(%d) returned %d with %d (expected '!=0')\n",
710                 level, res, GetLastError());
711         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n",
712                 level, pcbNeeded, cbBuf);
713         /* We can validate the returned Data with the Registry here */
714
715
716         SetLastError(MAGIC_DEAD);
717         pcReturned = MAGIC_DEAD;
718         pcbNeeded = MAGIC_DEAD;
719         res = EnumMonitorsA(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
720         ok(res, "(%d) returned %d with %d (expected '!=0')\n", level,
721                 res, GetLastError());
722         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level,
723                 pcbNeeded, cbBuf);
724
725         SetLastError(MAGIC_DEAD);
726         pcbNeeded = MAGIC_DEAD;
727         res = EnumMonitorsA(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
728         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
729             "(%d) returned %d with %d (expected '0' with " \
730             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
731
732         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level,
733                 pcbNeeded, cbBuf);
734
735 /*
736       Do not add the next test:
737       w2k+:  RPC_X_NULL_REF_POINTER 
738       NT3.5: ERROR_INVALID_USER_BUFFER
739       win9x: crash in winspool.drv
740
741       res = EnumMonitorsA(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
742 */
743
744         SetLastError(MAGIC_DEAD);
745         pcbNeeded = MAGIC_DEAD;
746         pcReturned = MAGIC_DEAD;
747         res = EnumMonitorsA(NULL, level, buffer, cbBuf, NULL, &pcReturned);
748         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
749             "(%d) returned %d with %d (expected '!=0' or '0' with "\
750             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
751
752         pcbNeeded = MAGIC_DEAD;
753         pcReturned = MAGIC_DEAD;
754         SetLastError(MAGIC_DEAD);
755         res = EnumMonitorsA(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
756         ok( res || (!res && (GetLastError() == RPC_X_NULL_REF_POINTER)) ,
757             "(%d) returned %d with %d (expected '!=0' or '0' with "\
758             "RPC_X_NULL_REF_POINTER)\n", level, res, GetLastError());
759
760         HeapFree(GetProcessHeap(), 0, buffer);
761     } /* for(level ... */
762 }
763
764 /* ########################### */
765
766 static void test_EnumPorts(void)
767 {
768     DWORD   res;
769     DWORD   level;
770     LPBYTE  buffer;
771     DWORD   cbBuf;
772     DWORD   pcbNeeded;
773     DWORD   pcReturned;
774
775     /* valid levels are 1 and 2 */
776     for(level = 0; level < 4; level++) {
777
778         cbBuf = 0xdeadbeef;
779         pcReturned = 0xdeadbeef;
780         SetLastError(0xdeadbeef);
781         res = EnumPortsA(NULL, level, NULL, 0, &cbBuf, &pcReturned);
782         RETURN_ON_DEACTIVATED_SPOOLER(res)
783
784         /* use only a short test, when we test with an invalid level */
785         if(!level || (level > 2)) {
786             /* NT: ERROR_INVALID_LEVEL, 9x: success */
787             ok( (!res && (GetLastError() == ERROR_INVALID_LEVEL)) ||
788                 (res && (pcReturned == 0)),
789                 "(%d) returned %d with %d and 0x%08x (expected '0' with " \
790                 "ERROR_INVALID_LEVEL or '!=0' and 0x0)\n",
791                 level, res, GetLastError(), pcReturned);
792             continue;
793         }        
794
795         
796         /* Level 2 is not supported on NT 3.x */
797         if (!res && (GetLastError() == ERROR_INVALID_LEVEL)) {
798             trace("Level %d not supported, skipping tests\n", level);
799             continue;
800         }
801
802         ok((!res) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
803             "(%d) returned %d with %d (expected '0' with " \
804             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
805
806         buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf *2);
807         if (buffer == NULL) continue;
808
809         pcbNeeded = 0xdeadbeef;
810         SetLastError(0xdeadbeef);
811         res = EnumPortsA(NULL, level, buffer, cbBuf, &pcbNeeded, &pcReturned);
812         ok(res, "(%d) returned %d with %d (expected '!=0')\n", level, res, GetLastError());
813         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
814         /* ToDo: Compare the returned Data with the Registry / "win.ini",[Ports] here */
815
816         pcbNeeded = 0xdeadbeef;
817         pcReturned = 0xdeadbeef;
818         SetLastError(0xdeadbeef);
819         res = EnumPortsA(NULL, level, buffer, cbBuf+1, &pcbNeeded, &pcReturned);
820         ok(res, "(%d) returned %d with %d (expected '!=0')\n", level, res, GetLastError());
821         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
822
823         pcbNeeded = 0xdeadbeef;
824         SetLastError(0xdeadbeef);
825         res = EnumPortsA(NULL, level, buffer, cbBuf-1, &pcbNeeded, &pcReturned);
826         ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
827             "(%d) returned %d with %d (expected '0' with " \
828             "ERROR_INSUFFICIENT_BUFFER)\n", level, res, GetLastError());
829         ok(pcbNeeded == cbBuf, "(%d) returned %d (expected %d)\n", level, pcbNeeded, cbBuf);
830
831         /*
832           Do not add this test:
833           res = EnumPortsA(NULL, level, NULL, cbBuf, &pcbNeeded, &pcReturned);
834           w2k+:  RPC_X_NULL_REF_POINTER 
835           NT3.5: ERROR_INVALID_USER_BUFFER
836           win9x: crash in winspool.drv
837          */
838
839         SetLastError(0xdeadbeef);
840         res = EnumPorts(NULL, level, buffer, cbBuf, NULL, &pcReturned);
841         /* NT: RPC_X_NULL_REF_POINTER (1780),  9x: success */
842         ok( (!res && (GetLastError() == RPC_X_NULL_REF_POINTER) ) ||
843             ( res && (GetLastError() == ERROR_SUCCESS) ),
844             "(%d) returned %d with %d (expected '0' with " \
845             "RPC_X_NULL_REF_POINTER or '!=0' with NO_ERROR)\n",
846             level, res, GetLastError());
847
848
849         SetLastError(0xdeadbeef);
850         res = EnumPorts(NULL, level, buffer, cbBuf, &pcbNeeded, NULL);
851         /* NT: RPC_X_NULL_REF_POINTER (1780),  9x: success */
852         ok( (!res && (GetLastError() == RPC_X_NULL_REF_POINTER) ) ||
853             ( res && (GetLastError() == ERROR_SUCCESS) ),
854             "(%d) returned %d with %d (expected '0' with " \
855             "RPC_X_NULL_REF_POINTER or '!=0' with NO_ERROR)\n",
856             level, res, GetLastError());
857
858         HeapFree(GetProcessHeap(), 0, buffer);
859     }
860 }
861
862 /* ########################### */
863
864 static void test_GetDefaultPrinter(void)
865 {
866     BOOL    retval;
867     DWORD   exact = DEFAULT_PRINTER_SIZE;
868     DWORD   size;
869     char    buffer[DEFAULT_PRINTER_SIZE];
870
871     if (!pGetDefaultPrinterA)  return;
872         /* only supported on NT like OSes starting with win2k */
873
874     SetLastError(ERROR_SUCCESS);
875     retval = pGetDefaultPrinterA(buffer, &exact);
876     if (!retval || !exact || !strlen(buffer) ||
877         (ERROR_SUCCESS != GetLastError())) {
878         if ((ERROR_FILE_NOT_FOUND == GetLastError()) ||
879             (ERROR_INVALID_NAME == GetLastError()))
880             trace("this test requires a default printer to be set\n");
881         else {
882                 ok( 0, "function call GetDefaultPrinterA failed unexpected!\n"
883                 "function returned %s\n"
884                 "last error 0x%08x\n"
885                 "returned buffer size 0x%08x\n"
886                 "returned buffer content %s\n",
887                 retval ? "true" : "false", GetLastError(), exact, buffer);
888         }
889         return;
890     }
891     SetLastError(ERROR_SUCCESS);
892     retval = pGetDefaultPrinterA(NULL, NULL); 
893     ok( !retval, "function result wrong! False expected\n");
894     ok( ERROR_INVALID_PARAMETER == GetLastError(),
895         "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08x\n",
896         GetLastError());
897
898     SetLastError(ERROR_SUCCESS);
899     retval = pGetDefaultPrinterA(buffer, NULL); 
900     ok( !retval, "function result wrong! False expected\n");
901     ok( ERROR_INVALID_PARAMETER == GetLastError(),
902         "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08x\n",
903         GetLastError());
904
905     SetLastError(ERROR_SUCCESS);
906     size = 0;
907     retval = pGetDefaultPrinterA(NULL, &size); 
908     ok( !retval, "function result wrong! False expected\n");
909     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
910         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08x\n",
911         GetLastError());
912     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
913         exact, size);
914
915     SetLastError(ERROR_SUCCESS);
916     size = DEFAULT_PRINTER_SIZE;
917     retval = pGetDefaultPrinterA(NULL, &size); 
918     ok( !retval, "function result wrong! False expected\n");
919     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
920         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08x\n",
921         GetLastError());
922     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
923         exact, size);
924
925     size = 0;
926     retval = pGetDefaultPrinterA(buffer, &size); 
927     ok( !retval, "function result wrong! False expected\n");
928     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
929         "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08x\n",
930         GetLastError());
931     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
932         exact, size);
933
934     size = exact;
935     retval = pGetDefaultPrinterA(buffer, &size); 
936     ok( retval, "function result wrong! True expected\n");
937     ok( size == exact, "Parameter size wrong! %d expected got %d\n",
938         exact, size);
939 }
940
941 static void test_GetPrinterDriverDirectory(void)
942 {
943     LPBYTE      buffer = NULL;
944     DWORD       cbBuf = 0, pcbNeeded = 0;
945     BOOL        res;
946
947
948     SetLastError(MAGIC_DEAD);
949     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, 0, &cbBuf);
950     trace("first call returned 0x%04x, with %d: buffer size 0x%08x\n",
951     res, GetLastError(), cbBuf);
952
953     RETURN_ON_DEACTIVATED_SPOOLER(res)
954     ok((res == 0) && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
955         "returned %d with lasterror=%d (expected '0' with " \
956         "ERROR_INSUFFICIENT_BUFFER)\n", res, GetLastError());
957
958     if (!cbBuf) {
959         trace("no valid buffer size returned, skipping tests\n");
960         return;
961     }
962
963     buffer = HeapAlloc( GetProcessHeap(), 0, cbBuf*2);
964     if (buffer == NULL)  return ;
965
966     res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded);
967     ok( res, "expected result != 0, got %d\n", res);
968     ok( cbBuf == pcbNeeded, "pcbNeeded set to %d instead of %d\n",
969                             pcbNeeded, cbBuf);
970
971     res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
972     ok( res, "expected result != 0, got %d\n", res);
973     ok( cbBuf == pcbNeeded, "pcbNeeded set to %d instead of %d\n",
974                             pcbNeeded, cbBuf);
975  
976     SetLastError(MAGIC_DEAD);
977     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded);
978     ok( !res , "expected result == 0, got %d\n", res);
979     ok( cbBuf == pcbNeeded, "pcbNeeded set to %d instead of %d\n",
980                             pcbNeeded, cbBuf);
981     
982     ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
983         "last error set to %d instead of ERROR_INSUFFICIENT_BUFFER\n",
984         GetLastError());
985
986 /*
987     Do not add the next test:
988     XPsp2: crash in this app, when the spooler is not running 
989     NT3.5: ERROR_INVALID_USER_BUFFER
990     win9x: ERROR_INVALID_PARAMETER
991
992     pcbNeeded = MAGIC_DEAD;
993     SetLastError(MAGIC_DEAD);
994     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, &pcbNeeded);
995 */
996
997     SetLastError(MAGIC_DEAD);
998     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf, NULL);
999     ok( (!res && RPC_X_NULL_REF_POINTER == GetLastError()) || res,
1000          "expected either result == 0 and "
1001          "last error == RPC_X_NULL_REF_POINTER or result != 0 "
1002          "got result %d and last error == %d\n", res, GetLastError());
1003
1004     SetLastError(MAGIC_DEAD);
1005     res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, NULL);
1006     ok(res || (GetLastError() == RPC_X_NULL_REF_POINTER),
1007         "returned %d with %d (expected '!=0' or '0' with " \
1008         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError());
1009  
1010  
1011     /* with a valid buffer, but level is too large */
1012     buffer[0] = '\0';
1013     SetLastError(MAGIC_DEAD);
1014     res = GetPrinterDriverDirectoryA(NULL, NULL, 2, buffer, cbBuf, &pcbNeeded);
1015
1016     /* Level not checked in win9x and wine:*/
1017     if((res != FALSE) && buffer[0])
1018     {
1019         trace("Level '2' not checked '%s'\n", buffer);
1020     }
1021     else
1022     {
1023         ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
1024         "returned %d with lasterror=%d (expected '0' with " \
1025         "ERROR_INVALID_LEVEL)\n", res, GetLastError());
1026     }
1027
1028     /* printing environments are case insensitive */
1029     /* "Windows 4.0" is valid for win9x and NT */
1030     buffer[0] = '\0';
1031     SetLastError(MAGIC_DEAD);
1032     res = GetPrinterDriverDirectoryA(NULL, env_win9x_case, 1, 
1033                                         buffer, cbBuf*2, &pcbNeeded);
1034
1035     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
1036         cbBuf = pcbNeeded;
1037         buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, cbBuf*2);
1038         if (buffer == NULL)  return ;
1039
1040         SetLastError(MAGIC_DEAD);
1041         res = GetPrinterDriverDirectoryA(NULL, env_win9x_case, 1, 
1042                                         buffer, cbBuf*2, &pcbNeeded);
1043     }
1044
1045     ok(res && buffer[0], "returned %d with " \
1046         "lasterror=%d and len=%d (expected '1' with 'len > 0')\n", 
1047         res, GetLastError(), lstrlenA((char *)buffer));
1048
1049     buffer[0] = '\0';
1050     SetLastError(MAGIC_DEAD);
1051     res = GetPrinterDriverDirectoryA(NULL, env_x86, 1, 
1052                                         buffer, cbBuf*2, &pcbNeeded);
1053
1054     if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
1055         cbBuf = pcbNeeded;
1056         buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, cbBuf*2);
1057         if (buffer == NULL)  return ;
1058
1059         buffer[0] = '\0';
1060         SetLastError(MAGIC_DEAD);
1061         res = GetPrinterDriverDirectoryA(NULL, env_x86, 1, 
1062                                         buffer, cbBuf*2, &pcbNeeded);
1063     }
1064
1065     /* "Windows NT x86" is invalid for win9x */
1066     ok( (res && buffer[0]) ||
1067         (!res && (GetLastError() == ERROR_INVALID_ENVIRONMENT)), 
1068         "returned %d with lasterror=%d and len=%d (expected '!= 0' with " \
1069         "'len > 0' or '0' with ERROR_INVALID_ENVIRONMENT)\n",
1070         res, GetLastError(), lstrlenA((char *)buffer));
1071
1072     /* A Setup-Programm (PDFCreator_0.8.0) use empty strings */
1073     SetLastError(MAGIC_DEAD);
1074     res = GetPrinterDriverDirectoryA(empty, empty, 1, buffer, cbBuf*2, &pcbNeeded);
1075     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError() );
1076
1077     SetLastError(MAGIC_DEAD);
1078     res = GetPrinterDriverDirectoryA(NULL, empty, 1, buffer, cbBuf*2, &pcbNeeded);
1079     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError() );
1080
1081     SetLastError(MAGIC_DEAD);
1082     res = GetPrinterDriverDirectoryA(empty, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1083     ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError() );
1084
1085     HeapFree( GetProcessHeap(), 0, buffer);
1086 }
1087
1088 /* ##### */
1089
1090 static void test_GetPrintProcessorDirectory(void)
1091 {
1092     LPBYTE      buffer = NULL;
1093     DWORD       cbBuf = 0;
1094     DWORD       pcbNeeded = 0;
1095     BOOL        res;
1096
1097
1098     SetLastError(0xdeadbeef);
1099     res = GetPrintProcessorDirectoryA(NULL, NULL, 1, NULL, 0, &cbBuf);
1100     /* The deactivated Spooler is catched here on NT3.51 */
1101     RETURN_ON_DEACTIVATED_SPOOLER(res)
1102     ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1103         "returned %d with %d (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1104         res, GetLastError());
1105
1106     buffer = HeapAlloc(GetProcessHeap(), 0, cbBuf*2);
1107     if(buffer == NULL)  return;
1108
1109     buffer[0] = '\0';
1110     SetLastError(0xdeadbeef);
1111     res = GetPrintProcessorDirectoryA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded);
1112     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1113
1114     SetLastError(0xdeadbeef);
1115     buffer[0] = '\0';
1116     res = GetPrintProcessorDirectoryA(NULL, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1117     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1118  
1119     /* Buffer to small */
1120     buffer[0] = '\0';
1121     SetLastError(0xdeadbeef);
1122     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded);
1123     ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1124         "returned %d with %d (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n",
1125         res, GetLastError());
1126
1127 #if 0
1128     /* XPsp2: the programm will crash here, when the spooler is not running  */
1129     /*        GetPrinterDriverDirectory has the same bug */
1130     pcbNeeded = 0;
1131     SetLastError(0xdeadbeef);
1132     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, NULL, cbBuf, &pcbNeeded);
1133 #endif
1134
1135     buffer[0] = '\0';
1136     SetLastError(0xdeadbeef);
1137     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, buffer, cbBuf, NULL);
1138     /* NT: RPC_X_NULL_REF_POINTER, 9x: res != 0  */
1139     ok( res || (GetLastError() == RPC_X_NULL_REF_POINTER),
1140         "returned %d with %d (expected '!= 0' or '0' with " \
1141         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError());
1142
1143
1144     buffer[0] = '\0';
1145     SetLastError(0xdeadbeef);
1146     res = GetPrintProcessorDirectoryA( NULL, NULL, 1, NULL, cbBuf, NULL);
1147     /* NT: RPC_X_NULL_REF_POINTER, 9x: res != 0  */
1148     ok( res || (GetLastError() == RPC_X_NULL_REF_POINTER),
1149         "returned %d with %d (expected '!= 0' or '0' with " \
1150         "RPC_X_NULL_REF_POINTER)\n", res, GetLastError());
1151
1152  
1153     /* with a valid buffer, but level is invalid */
1154     buffer[0] = '\0';
1155     SetLastError(0xdeadbeef);
1156     res = GetPrintProcessorDirectoryA(NULL, NULL, 2, buffer, cbBuf, &pcbNeeded);
1157     if (res && buffer[0])
1158     {
1159         /* Level is ignored in win9x*/
1160         trace("invalid level (2) was ignored\n");
1161     }
1162     else
1163     {
1164         ok( !res && (GetLastError() == ERROR_INVALID_LEVEL),
1165             "returned %d with %d (expected '0' with ERROR_INVALID_LEVEL)\n",
1166             res, GetLastError());
1167     }
1168
1169     /* Empty environment is the same as the default environment */
1170     buffer[0] = '\0';
1171     SetLastError(0xdeadbeef);
1172     res = GetPrintProcessorDirectoryA(NULL, empty, 1, buffer, cbBuf*2, &pcbNeeded);
1173     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1174
1175     /* "Windows 4.0" is valid for win9x and NT */
1176     buffer[0] = '\0';
1177     SetLastError(0xdeadbeef);
1178     res = GetPrintProcessorDirectoryA(NULL, env_win9x_case, 1, buffer, cbBuf*2, &pcbNeeded);
1179     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1180
1181
1182     /* "Windows NT x86" is invalid for win9x */
1183     buffer[0] = '\0';
1184     SetLastError(0xdeadbeef);
1185     res = GetPrintProcessorDirectoryA(NULL, env_x86, 1, buffer, cbBuf*2, &pcbNeeded);
1186     ok( res || (GetLastError() == ERROR_INVALID_ENVIRONMENT), 
1187         "returned %d with %d (expected '!= 0' or '0' with " \
1188         "ERROR_INVALID_ENVIRONMENT)\n", res, GetLastError());
1189
1190     /* invalid on all Systems */
1191     buffer[0] = '\0';
1192     SetLastError(0xdeadbeef);
1193     res = GetPrintProcessorDirectoryA(NULL, invalid_env, 1, buffer, cbBuf*2, &pcbNeeded);
1194     ok( !res && (GetLastError() == ERROR_INVALID_ENVIRONMENT), 
1195         "returned %d with %d (expected '0' with ERROR_INVALID_ENVIRONMENT)\n",
1196         res, GetLastError());
1197
1198     /* Empty servername is the same as the local computer */
1199     buffer[0] = '\0';
1200     SetLastError(0xdeadbeef);
1201     res = GetPrintProcessorDirectoryA(empty, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1202     ok(res, "returned %d with %d (expected '!= 0')\n", res, GetLastError());
1203
1204     /* invalid on all Systems */
1205     buffer[0] = '\0';
1206     SetLastError(0xdeadbeef);
1207     res = GetPrintProcessorDirectoryA(invalid_server, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
1208     ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER), 
1209         "returned %d with %d (expected '0' with ERROR_INVALID_PARAMETER)\n",
1210         res, GetLastError());
1211
1212     HeapFree(GetProcessHeap(), 0, buffer);
1213 }
1214
1215 /* ##### */
1216
1217 static void test_OpenPrinter(void)
1218 {
1219     PRINTER_DEFAULTSA   defaults;
1220     HANDLE              hprinter;
1221     DWORD               res;
1222     DWORD               size;
1223     CHAR                buffer[DEFAULT_PRINTER_SIZE];
1224     LPSTR               ptr;
1225
1226
1227     SetLastError(MAGIC_DEAD);
1228     res = OpenPrinter(NULL, NULL, NULL);    
1229     /* The deactivated Spooler is catched here on NT3.51 */
1230     RETURN_ON_DEACTIVATED_SPOOLER(res)
1231     ok(!res && (GetLastError() == ERROR_INVALID_PARAMETER),
1232         "returned %d with %d (expected '0' with ERROR_INVALID_PARAMETER)\n",
1233         res, GetLastError());
1234
1235
1236     /* Get Handle for the local Printserver (NT only)*/
1237     hprinter = (HANDLE) MAGIC_DEAD;
1238     SetLastError(MAGIC_DEAD);
1239     res = OpenPrinter(NULL, &hprinter, NULL);
1240     /* The deactivated Spooler is catched here on XPsp2 */
1241     RETURN_ON_DEACTIVATED_SPOOLER(res)
1242     ok(res || (!res && GetLastError() == ERROR_INVALID_PARAMETER),
1243         "returned %d with %d (expected '!=0' or '0' with ERROR_INVALID_PARAMETER)\n",
1244         res, GetLastError());
1245     if(res) {
1246         ClosePrinter(hprinter);
1247
1248         defaults.pDatatype=NULL;
1249         defaults.pDevMode=NULL;
1250
1251         defaults.DesiredAccess=0;
1252         hprinter = (HANDLE) MAGIC_DEAD;
1253         SetLastError(MAGIC_DEAD);
1254         res = OpenPrinter(NULL, &hprinter, &defaults);
1255         ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
1256         if (res) ClosePrinter(hprinter);
1257
1258         defaults.DesiredAccess=-1;
1259         hprinter = (HANDLE) MAGIC_DEAD;
1260         SetLastError(MAGIC_DEAD);
1261         res = OpenPrinter(NULL, &hprinter, &defaults);
1262         todo_wine {
1263         ok(!res && GetLastError() == ERROR_ACCESS_DENIED,
1264             "returned %d with %d (expected '0' with ERROR_ACCESS_DENIED)\n", 
1265             res, GetLastError());
1266         }
1267         if (res) ClosePrinter(hprinter);
1268
1269     }
1270
1271     size = sizeof(buffer) - 3 ;
1272     ptr = buffer;
1273     ptr[0] = '\\';
1274     ptr++;
1275     ptr[0] = '\\';
1276     ptr++;
1277     if (GetComputerNameA(ptr, &size)) {
1278
1279         hprinter = (HANDLE) MAGIC_DEAD;
1280         SetLastError(MAGIC_DEAD);
1281         res = OpenPrinter(buffer, &hprinter, NULL);
1282         todo_wine {
1283         ok(res || (!res && GetLastError() == ERROR_INVALID_PARAMETER),
1284             "returned %d with %d (expected '!=0' or '0' with ERROR_INVALID_PARAMETER)\n",
1285             res, GetLastError());
1286         }
1287         if(res) ClosePrinter(hprinter);
1288     }
1289
1290     /* Invalid Printername */
1291     hprinter = (HANDLE) MAGIC_DEAD;
1292     SetLastError(MAGIC_DEAD);
1293     res = OpenPrinter(illegal_name, &hprinter, NULL);
1294     ok(!res && ((GetLastError() == ERROR_INVALID_PRINTER_NAME) || 
1295                 (GetLastError() == ERROR_INVALID_PARAMETER) ),
1296        "returned %d with %d (expected '0' with: ERROR_INVALID_PARAMETER or" \
1297        "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1298     if(res) ClosePrinter(hprinter);
1299
1300     hprinter = (HANDLE) MAGIC_DEAD;
1301     SetLastError(MAGIC_DEAD);
1302     res = OpenPrinter(empty, &hprinter, NULL);
1303     /* NT: ERROR_INVALID_PRINTER_NAME,  9x: ERROR_INVALID_PARAMETER */
1304     ok( !res &&
1305         ((GetLastError() == ERROR_INVALID_PRINTER_NAME) || 
1306         (GetLastError() == ERROR_INVALID_PARAMETER) ),
1307         "returned %d with %d (expected '0' with: ERROR_INVALID_PRINTER_NAME" \
1308         " or ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1309     if(res) ClosePrinter(hprinter);
1310
1311
1312     /* Get Handle for the default Printer */
1313     if (default_printer)
1314     {
1315         hprinter = (HANDLE) MAGIC_DEAD;
1316         SetLastError(MAGIC_DEAD);
1317         res = OpenPrinter(default_printer, &hprinter, NULL);
1318         if((!res) && (GetLastError() == RPC_S_SERVER_UNAVAILABLE))
1319         {
1320             trace("The Service 'Spooler' is required for '%s'\n", default_printer);
1321             return;
1322         }
1323         ok(res, "returned %d with %d (expected '!=0')\n", res, GetLastError());
1324         if(res) ClosePrinter(hprinter);
1325
1326         SetLastError(MAGIC_DEAD);
1327         res = OpenPrinter(default_printer, NULL, NULL);
1328         /* NT: FALSE with ERROR_INVALID_PARAMETER, 9x: TRUE */
1329         ok(res || (GetLastError() == ERROR_INVALID_PARAMETER),
1330             "returned %d with %d (expected '!=0' or '0' with " \
1331             "ERROR_INVALID_PARAMETER)\n", res, GetLastError());
1332
1333         defaults.pDatatype=NULL;
1334         defaults.pDevMode=NULL;
1335         defaults.DesiredAccess=0;
1336
1337         hprinter = (HANDLE) MAGIC_DEAD;
1338         SetLastError(MAGIC_DEAD);
1339         res = OpenPrinter(default_printer, &hprinter, &defaults);
1340         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
1341             "returned %d with %d (expected '!=0' or '0' with " \
1342             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
1343         if(res) ClosePrinter(hprinter);
1344
1345         defaults.pDatatype = empty;
1346
1347         hprinter = (HANDLE) MAGIC_DEAD;
1348         SetLastError(MAGIC_DEAD);
1349         res = OpenPrinter(default_printer, &hprinter, &defaults);
1350         /* stop here, when a remote Printserver has no RPC-Service running */
1351         RETURN_ON_DEACTIVATED_SPOOLER(res)
1352         ok(res || ((GetLastError() == ERROR_INVALID_DATATYPE) ||
1353                    (GetLastError() == ERROR_ACCESS_DENIED)),
1354             "returned %d with %d (expected '!=0' or '0' with: " \
1355             "ERROR_INVALID_DATATYPE or ERROR_ACCESS_DENIED)\n",
1356             res, GetLastError());
1357         if(res) ClosePrinter(hprinter);
1358
1359
1360         defaults.pDatatype=NULL;
1361         defaults.DesiredAccess=PRINTER_ACCESS_USE;
1362
1363         hprinter = (HANDLE) MAGIC_DEAD;
1364         SetLastError(MAGIC_DEAD);
1365         res = OpenPrinter(default_printer, &hprinter, &defaults);
1366         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
1367             "returned %d with %d (expected '!=0' or '0' with " \
1368             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
1369         if(res) ClosePrinter(hprinter);
1370
1371
1372         defaults.DesiredAccess=PRINTER_ALL_ACCESS;
1373         hprinter = (HANDLE) MAGIC_DEAD;
1374         SetLastError(MAGIC_DEAD);
1375         res = OpenPrinter(default_printer, &hprinter, &defaults);
1376         ok(res || GetLastError() == ERROR_ACCESS_DENIED,
1377             "returned %d with %d (expected '!=0' or '0' with " \
1378             "ERROR_ACCESS_DENIED)\n", res, GetLastError());
1379         if(res) ClosePrinter(hprinter);
1380     }
1381
1382 }
1383
1384
1385 static void test_SetDefaultPrinter(void)
1386 {
1387     DWORD   res;
1388     DWORD   size = DEFAULT_PRINTER_SIZE;
1389     CHAR    buffer[DEFAULT_PRINTER_SIZE];
1390     CHAR    org_value[DEFAULT_PRINTER_SIZE];
1391
1392
1393     if (!pSetDefaultPrinterA)  return;
1394         /* only supported on win2k and above */
1395
1396     /* backup the original value */
1397     org_value[0] = '\0';
1398     SetLastError(MAGIC_DEAD);
1399     res = GetProfileStringA("windows", "device", NULL, org_value, size);
1400
1401     /* first part: with the default Printer */
1402     SetLastError(MAGIC_DEAD);
1403     res = pSetDefaultPrinterA("no_printer_with_this_name");
1404
1405     RETURN_ON_DEACTIVATED_SPOOLER(res)
1406     /* spooler is running or we have no spooler here*/
1407
1408     /* Not implemented in wine */
1409     if (!res && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) {
1410         trace("SetDefaultPrinterA() not implemented yet.\n");
1411         return;
1412     }
1413
1414     ok(!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME),
1415         "returned %d with %d (expected '0' with " \
1416         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1417
1418     WriteProfileStringA("windows", "device", org_value);
1419     SetLastError(MAGIC_DEAD);
1420     res = pSetDefaultPrinterA("");
1421     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1422         "returned %d with %d (expected '!=0' or '0' with " \
1423         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1424
1425     WriteProfileStringA("windows", "device", org_value);
1426     SetLastError(MAGIC_DEAD);
1427     res = pSetDefaultPrinterA(NULL);
1428     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1429         "returned %d with %d (expected '!=0' or '0' with " \
1430         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1431
1432     WriteProfileStringA("windows", "device", org_value);
1433     SetLastError(MAGIC_DEAD);
1434     res = pSetDefaultPrinterA(default_printer);
1435     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1436         "returned %d with %d (expected '!=0' or '0' with " \
1437         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1438
1439
1440     /* second part: always without a default Printer */
1441     WriteProfileStringA("windows", "device", NULL);    
1442     SetLastError(MAGIC_DEAD);
1443     res = pSetDefaultPrinterA("no_printer_with_this_name");
1444
1445     ok(!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME),
1446         "returned %d with %d (expected '0' with " \
1447         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1448
1449     WriteProfileStringA("windows", "device", NULL);    
1450     SetLastError(MAGIC_DEAD);
1451     res = pSetDefaultPrinterA("");
1452     /* we get ERROR_INVALID_PRINTER_NAME when no printer is installed */
1453     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1454          "returned %d with %d (expected '!=0' or '0' with " \
1455          "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1456
1457     WriteProfileStringA("windows", "device", NULL);    
1458     SetLastError(MAGIC_DEAD);
1459     res = pSetDefaultPrinterA(NULL);
1460     /* we get ERROR_INVALID_PRINTER_NAME when no printer is installed */
1461     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1462         "returned %d with %d (expected '!=0' or '0' with " \
1463         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1464
1465     WriteProfileStringA("windows", "device", NULL);    
1466     SetLastError(MAGIC_DEAD);
1467     res = pSetDefaultPrinterA(default_printer);
1468     ok(res || (!res && (GetLastError() == ERROR_INVALID_PRINTER_NAME)),
1469         "returned %d with %d (expected '!=0' or '0' with " \
1470         "ERROR_INVALID_PRINTER_NAME)\n", res, GetLastError());
1471
1472     /* restore the original value */
1473     res = pSetDefaultPrinterA(default_printer);          /* the nice way */
1474     WriteProfileStringA("windows", "device", org_value); /* the old way */
1475
1476     buffer[0] = '\0';
1477     SetLastError(MAGIC_DEAD);
1478     res = GetProfileStringA("windows", "device", NULL, buffer, size);
1479     ok(!lstrcmpA(org_value, buffer), "'%s' (expected '%s')\n", buffer, org_value);
1480
1481 }
1482
1483 static void test_GetPrinterDriver(void)
1484 {
1485     HANDLE hprn;
1486     BOOL ret;
1487     BYTE *buf;
1488     INT level;
1489     DWORD needed, filled;
1490
1491     if (!default_printer)
1492     {
1493         trace("There is no default printer installed, skiping the test\n");
1494         return;
1495     }
1496
1497     hprn = 0;
1498     ret = OpenPrinter(default_printer, &hprn, NULL);
1499     if (!ret)
1500     {
1501         trace("There is no printers installed, skiping the test\n");
1502         return;
1503     }
1504     ok(hprn != 0, "wrong hprn %p\n", hprn);
1505
1506     for (level = -1; level <= 7; level++)
1507     {
1508         SetLastError(0xdeadbeef);
1509         needed = (DWORD)-1;
1510         ret = GetPrinterDriver(hprn, NULL, level, NULL, 0, &needed);
1511         ok(!ret, "level %d: GetPrinterDriver should fail\n", level);
1512         if (level >= 1 && level <= 6)
1513         {
1514             /* Not all levels are supported on all Windows-Versions */
1515             if(GetLastError() == ERROR_INVALID_LEVEL) continue;
1516             ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "wrong error %d\n", GetLastError());
1517             ok(needed > 0,"not expected needed buffer size %d\n", needed);
1518         }
1519         else
1520         {
1521             /* ERROR_OUTOFMEMORY found on win9x */
1522             ok( ((GetLastError() == ERROR_INVALID_LEVEL) ||
1523                  (GetLastError() == ERROR_OUTOFMEMORY)),
1524                 "%d: returned %d with %d (expected '0' with: " \
1525                 "ERROR_INVALID_LEVEL or ERROR_OUTOFMEMORY)\n",
1526                 level, ret, GetLastError());
1527             /* needed is modified in win9x. The modified Value depends on the
1528                default Printer. testing for "needed == (DWORD)-1" will fail */
1529             continue;
1530         }
1531
1532         buf = HeapAlloc(GetProcessHeap(), 0, needed);
1533
1534         SetLastError(0xdeadbeef);
1535         filled = -1;
1536         ret = GetPrinterDriver(hprn, NULL, level, buf, needed, &filled);
1537         ok(ret, "level %d: GetPrinterDriver error %d\n", level, GetLastError());
1538         ok(needed == filled, "needed %d != filled %d\n", needed, filled);
1539
1540         if (level == 2)
1541         {
1542             DRIVER_INFO_2 *di_2 = (DRIVER_INFO_2 *)buf;
1543             DWORD calculated = sizeof(*di_2);
1544
1545             /* MSDN is wrong: The Drivers on the win9x-CD's have cVersion=0x0400
1546                NT351: 1, NT4.0+w2k(Kernelmode): 2, w2k and above(Usermode): 3  */
1547             ok((di_2->cVersion >= 0 && di_2->cVersion <= 3) ||
1548                 (di_2->cVersion == 0x0400), "di_2->cVersion = %d\n", di_2->cVersion);
1549             ok(di_2->pName != NULL, "not expected NULL ptr\n");
1550             ok(di_2->pEnvironment != NULL, "not expected NULL ptr\n");
1551             ok(di_2->pDriverPath != NULL, "not expected NULL ptr\n");
1552             ok(di_2->pDataFile != NULL, "not expected NULL ptr\n");
1553             ok(di_2->pConfigFile != NULL, "not expected NULL ptr\n");
1554
1555             trace("cVersion %d\n", di_2->cVersion);
1556             trace("pName %s\n", di_2->pName);
1557             calculated += strlen(di_2->pName) + 1;
1558             trace("pEnvironment %s\n", di_2->pEnvironment);
1559             calculated += strlen(di_2->pEnvironment) + 1;
1560             trace("pDriverPath %s\n", di_2->pDriverPath);
1561             calculated += strlen(di_2->pDriverPath) + 1;
1562             trace("pDataFile %s\n", di_2->pDataFile);
1563             calculated += strlen(di_2->pDataFile) + 1;
1564             trace("pConfigFile %s\n", di_2->pConfigFile);
1565             calculated += strlen(di_2->pConfigFile) + 1;
1566
1567             /* XP allocates memory for both ANSI and unicode names */
1568             ok(filled >= calculated,"calculated %d != filled %d\n", calculated, filled);
1569         }
1570
1571         HeapFree(GetProcessHeap(), 0, buf);
1572     }
1573
1574     SetLastError(0xdeadbeef);
1575     ret = ClosePrinter(hprn);
1576     ok(ret, "ClosePrinter error %d\n", GetLastError());
1577 }
1578
1579 static void test_DEVMODE(const DEVMODE *dm, LONG dmSize, LPCSTR exp_prn_name)
1580 {
1581     /* On NT3.51, some fields in DEVMODE are empty/zero
1582       (dmDeviceName, dmSpecVersion, dmDriverVersion and dmDriverExtra)
1583        We skip the Tests on this Platform */
1584     if (dm->dmSpecVersion || dm->dmDriverVersion || dm->dmDriverExtra) {
1585     /* The 0-terminated Printername can be larger (MAX_PATH) than CCHDEVICENAME */
1586         ok(!strncmp(exp_prn_name, (LPCSTR)dm->dmDeviceName, CCHDEVICENAME -1),
1587             "expected '%s', got '%s'\n", exp_prn_name, dm->dmDeviceName);
1588         ok(dm->dmSize + dm->dmDriverExtra == dmSize,
1589             "%u != %d\n", dm->dmSize + dm->dmDriverExtra, dmSize);
1590     }
1591     trace("dmFields %08x\n", dm->dmFields);
1592 }
1593
1594 static void test_DocumentProperties(void)
1595 {
1596     HANDLE hprn;
1597     LONG dm_size, ret;
1598     DEVMODE *dm;
1599
1600     if (!default_printer)
1601     {
1602         trace("There is no default printer installed, skiping the test\n");
1603         return;
1604     }
1605
1606     hprn = 0;
1607     ret = OpenPrinter(default_printer, &hprn, NULL);
1608     if (!ret)
1609     {
1610         trace("There is no printers installed, skiping the test\n");
1611         return;
1612     }
1613     ok(hprn != 0, "wrong hprn %p\n", hprn);
1614
1615     dm_size = DocumentProperties(0, hprn, NULL, NULL, NULL, 0);
1616     trace("DEVMODE required size %d\n", dm_size);
1617     ok(dm_size >= sizeof(DEVMODE), "unexpected DocumentProperties ret value %d\n", dm_size);
1618
1619     dm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dm_size);
1620
1621     ret = DocumentProperties(0, hprn, NULL, dm, dm, DM_OUT_BUFFER);
1622     ok(ret == IDOK, "DocumentProperties ret value %d != expected IDOK\n", ret);
1623
1624     test_DEVMODE(dm, dm_size, default_printer);
1625
1626     HeapFree(GetProcessHeap(), 0, dm);
1627
1628     SetLastError(0xdeadbeef);
1629     ret = ClosePrinter(hprn);
1630     ok(ret, "ClosePrinter error %d\n", GetLastError());
1631 }
1632
1633 static void test_EnumPrinters(void)
1634 {
1635     DWORD neededA, neededW, num;
1636     DWORD ret;
1637
1638     SetLastError(0xdeadbeef);
1639     neededA = -1;
1640     ret = EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &neededA, &num);
1641     if (!ret)
1642     {
1643         /* We have 1 or more printers */
1644         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "gle %d\n", GetLastError());
1645         ok(neededA > 0, "Expected neededA to show the number of needed bytes\n");
1646     }
1647     else
1648     {
1649         /* We don't have any printers defined */
1650         ok(GetLastError() == S_OK, "gle %d\n", GetLastError());
1651         ok(neededA == 0, "Expected neededA to be zero\n");
1652     }
1653     ok(num == 0, "num %d\n", num);
1654
1655     SetLastError(0xdeadbeef);
1656     neededW = -1;
1657     ret = EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &neededW, &num);
1658     if (!ret)
1659     {
1660         /* We have 1 or more printers */
1661         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "gle %d\n", GetLastError());
1662         ok(neededW > 0, "Expected neededW to show the number of needed bytes\n");
1663     }
1664     else
1665     {
1666         /* We don't have any printers defined */
1667         ok(GetLastError() == S_OK, "gle %d\n", GetLastError());
1668         ok(neededW == 0, "Expected neededW to be zero\n");
1669     }
1670     ok(num == 0, "num %d\n", num);
1671
1672     /* Outlook2003 relies on the buffer size returned by EnumPrintersA being big enough
1673        to hold the buffer returned by EnumPrintersW */
1674     ok(neededA == neededW, "neededA %d neededW %d\n", neededA, neededW);
1675 }
1676
1677 START_TEST(info)
1678 {
1679     hwinspool = GetModuleHandleA("winspool.drv");
1680     pGetDefaultPrinterA = (void *) GetProcAddress(hwinspool, "GetDefaultPrinterA");
1681     pSetDefaultPrinterA = (void *) GetProcAddress(hwinspool, "SetDefaultPrinterA");
1682
1683     find_default_printer();
1684
1685     test_AddMonitor();
1686     test_AddPort();
1687     test_ConfigurePort();
1688     test_DeleteMonitor();
1689     test_DeletePort();
1690     test_DocumentProperties();
1691     test_EnumForms(NULL);
1692     if (default_printer) test_EnumForms(default_printer);
1693     test_EnumMonitors(); 
1694     test_EnumPorts();
1695     test_GetDefaultPrinter();
1696     test_GetPrinterDriverDirectory();
1697     test_GetPrintProcessorDirectory();
1698     test_OpenPrinter();
1699     test_GetPrinterDriver();
1700     test_SetDefaultPrinter();
1701
1702     test_EnumPrinters();
1703 }