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