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