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