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