2 Unix SMB/CIFS implementation.
3 test suite for spoolss rpc operations
5 Copyright (C) Guenther Deschner 2009-2010
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 /****************************************************************************
22 ****************************************************************************/
28 /****************************************************************************
29 ****************************************************************************/
31 static BOOL
test_OpenPrinter(struct torture_context
*tctx
,
33 LPPRINTER_DEFAULTS defaults
,
36 torture_comment(tctx
, "Testing OpenPrinter(%s)", printername
);
38 if (!OpenPrinter(printername
, handle
, defaults
)) {
40 sprintf(tmp
, "failed to open printer %s, error was: 0x%08x\n",
41 printername
, GetLastError());
42 torture_fail(tctx
, tmp
);
48 /****************************************************************************
49 ****************************************************************************/
51 static BOOL
test_ClosePrinter(struct torture_context
*tctx
,
54 torture_comment(tctx
, "Testing ClosePrinter");
56 if (!ClosePrinter(handle
)) {
58 sprintf(tmp
, "failed to close printer, error was: %s\n",
59 errstr(GetLastError()));
60 torture_fail(tctx
, tmp
);
67 /****************************************************************************
68 ****************************************************************************/
70 static BOOL
test_EnumPrinters(struct torture_context
*tctx
,
73 DWORD levels
[] = { 1, 2, 5 };
74 DWORD success
[] = { 1, 1, 1 };
76 DWORD flags
= PRINTER_ENUM_NAME
;
79 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
86 torture_comment(tctx
, "Testing EnumPrinters level %d", levels
[i
]);
88 EnumPrinters(flags
, servername
, levels
[i
], NULL
, 0, &needed
, &returned
);
90 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
92 buffer
= malloc(needed
);
93 torture_assert(tctx
, buffer
, "malloc failed");
94 if (!EnumPrinters(flags
, servername
, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
99 sprintf(tmp
, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
100 levels
[i
], servername
, needed
, errstr(err
));
102 torture_fail(tctx
, tmp
);
104 torture_warning(tctx
, tmp
);
109 print_printer_info_bylevel(levels
[i
], buffer
, returned
);
119 /****************************************************************************
120 ****************************************************************************/
122 static BOOL
test_EnumDrivers(struct torture_context
*tctx
,
126 DWORD levels
[] = { 1, 2, 3, 4, 5, 6 };
127 DWORD success
[] = { 1, 1, 1, 1, 1, 1 };
129 LPBYTE buffer
= NULL
;
131 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
138 torture_comment(tctx
, "Testing EnumPrinterDrivers level %d", levels
[i
]);
140 EnumPrinterDrivers(servername
, architecture
, levels
[i
], NULL
, 0, &needed
, &returned
);
141 err
= GetLastError();
142 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
144 buffer
= malloc(needed
);
145 torture_assert(tctx
, buffer
, "malloc failed");
146 if (!EnumPrinterDrivers(servername
, architecture
, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
147 err
= GetLastError();
151 sprintf(tmp
, "EnumPrinterDrivers failed level %d on [%s] (buffer size = %d), error: %s\n",
152 levels
[i
], servername
, needed
, errstr(err
));
154 torture_fail(tctx
, tmp
);
156 torture_warning(tctx
, tmp
);
161 print_driver_info_bylevel(levels
[i
], buffer
, returned
);
171 /****************************************************************************
172 ****************************************************************************/
174 static BOOL
test_GetForm(struct torture_context
*tctx
,
179 DWORD levels
[] = { 1, 2 };
180 DWORD success
[] = { 1, 0 };
182 LPBYTE buffer
= NULL
;
184 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
190 torture_comment(tctx
, "Testing GetForm(%s) level %d", formname
, levels
[i
]);
192 GetForm(handle
, formname
, levels
[i
], NULL
, 0, &needed
);
193 err
= GetLastError();
194 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
196 buffer
= malloc(needed
);
197 torture_assert(tctx
, buffer
, "malloc failed");
198 if (!GetForm(handle
, formname
, levels
[i
], buffer
, needed
, &needed
)) {
199 err
= GetLastError();
203 sprintf(tmp
, "GetForm failed level %d on [%s] (buffer size = %d), error: %s\n",
204 levels
[i
], servername
, needed
, errstr(err
));
206 torture_fail(tctx
, tmp
);
208 torture_warning(tctx
, tmp
);
213 print_form_info_bylevel(levels
[i
], buffer
, 1);
223 /****************************************************************************
224 ****************************************************************************/
226 static BOOL
test_EnumForms(struct torture_context
*tctx
,
230 DWORD levels
[] = { 1, 2 };
231 DWORD success
[] = { 1, 1 };
233 LPBYTE buffer
= NULL
;
235 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
242 torture_comment(tctx
, "Testing EnumForms level %d", levels
[i
]);
244 if (tctx
->samba3
&& levels
[i
] == 2) {
245 torture_comment(tctx
, "skipping level %d enum against samba\n", levels
[i
]);
249 EnumForms(handle
, levels
[i
], NULL
, 0, &needed
, &returned
);
250 err
= GetLastError();
251 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
253 buffer
= malloc(needed
);
254 torture_assert(tctx
, buffer
, "malloc failed");
255 if (!EnumForms(handle
, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
256 err
= GetLastError();
260 sprintf(tmp
, "EnumForms failed level %d on [%s] (buffer size = %d), error: %s\n",
261 levels
[i
], servername
, needed
, errstr(err
));
263 torture_fail(tctx
, tmp
);
265 torture_warning(tctx
, tmp
);
270 print_form_info_bylevel(levels
[i
], buffer
, returned
);
280 /****************************************************************************
281 ****************************************************************************/
283 static BOOL
test_EnumPorts(struct torture_context
*tctx
,
286 DWORD levels
[] = { 1, 2 };
287 DWORD success
[] = { 1, 1 };
289 LPBYTE buffer
= NULL
;
291 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
298 torture_comment(tctx
, "Testing EnumPorts level %d", levels
[i
]);
300 EnumPorts(servername
, levels
[i
], NULL
, 0, &needed
, &returned
);
301 err
= GetLastError();
302 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
304 buffer
= malloc(needed
);
305 torture_assert(tctx
, buffer
, "malloc failed");
306 if (!EnumPorts(servername
, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
307 err
= GetLastError();
311 sprintf(tmp
, "EnumPorts failed level %d on [%s] (buffer size = %d), error: %s\n",
312 levels
[i
], servername
, needed
, errstr(err
));
314 torture_fail(tctx
, tmp
);
316 torture_warning(tctx
, tmp
);
321 print_port_info_bylevel(levels
[i
], buffer
, returned
);
331 /****************************************************************************
332 ****************************************************************************/
334 static BOOL
test_EnumMonitors(struct torture_context
*tctx
,
337 DWORD levels
[] = { 1, 2 };
338 DWORD success
[] = { 1, 1 };
340 LPBYTE buffer
= NULL
;
342 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
349 torture_comment(tctx
, "Testing EnumMonitors level %d", levels
[i
]);
351 EnumMonitors(servername
, levels
[i
], NULL
, 0, &needed
, &returned
);
352 err
= GetLastError();
353 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
355 buffer
= malloc(needed
);
356 torture_assert(tctx
, buffer
, "malloc failed");
357 if (!EnumMonitors(servername
, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
358 err
= GetLastError();
362 sprintf(tmp
, "EnumMonitors failed level %d on [%s] (buffer size = %d), error: %s\n",
363 levels
[i
], servername
, needed
, errstr(err
));
365 torture_fail(tctx
, tmp
);
367 torture_warning(tctx
, tmp
);
372 print_monitor_info_bylevel(levels
[i
], buffer
, returned
);
382 /****************************************************************************
383 ****************************************************************************/
385 static BOOL
test_EnumPrintProcessors(struct torture_context
*tctx
,
389 DWORD levels
[] = { 1 };
390 DWORD success
[] = { 1 };
392 LPBYTE buffer
= NULL
;
394 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
401 torture_comment(tctx
, "Testing EnumPrintProcessors level %d", levels
[i
]);
403 EnumPrintProcessors(servername
, architecture
, levels
[i
], NULL
, 0, &needed
, &returned
);
404 err
= GetLastError();
405 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
407 buffer
= malloc(needed
);
408 torture_assert(tctx
, buffer
, "malloc failed");
409 if (!EnumPrintProcessors(servername
, architecture
, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
410 err
= GetLastError();
414 sprintf(tmp
, "EnumPrintProcessors failed level %d on [%s] (buffer size = %d), error: %s\n",
415 levels
[i
], servername
, needed
, errstr(err
));
417 torture_fail(tctx
, tmp
);
419 torture_warning(tctx
, tmp
);
424 print_printprocessor_info_bylevel(levels
[i
], buffer
, returned
);
434 /****************************************************************************
435 ****************************************************************************/
437 static BOOL
test_EnumPrintProcessorDatatypes(struct torture_context
*tctx
,
440 DWORD levels
[] = { 1 };
441 DWORD success
[] = { 1 };
443 LPBYTE buffer
= NULL
;
445 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
452 torture_comment(tctx
, "Testing EnumPrintProcessorDatatypes level %d", levels
[i
]);
454 EnumPrintProcessorDatatypes(servername
, "winprint", levels
[i
], NULL
, 0, &needed
, &returned
);
455 err
= GetLastError();
456 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
458 buffer
= malloc(needed
);
459 torture_assert(tctx
, buffer
, "malloc failed");
460 if (!EnumPrintProcessorDatatypes(servername
, "winprint", levels
[i
], buffer
, needed
, &needed
, &returned
)) {
461 err
= GetLastError();
465 sprintf(tmp
, "EnumPrintProcessorDatatypes failed level %d on [%s] (buffer size = %d), error: %s\n",
466 levels
[i
], servername
, needed
, errstr(err
));
468 torture_fail(tctx
, tmp
);
470 torture_warning(tctx
, tmp
);
475 print_datatypes_info_bylevel(levels
[i
], buffer
, returned
);
485 /****************************************************************************
486 ****************************************************************************/
488 static BOOL
test_EnumPrinterKey(struct torture_context
*tctx
,
498 torture_comment(tctx
, "Testing EnumPrinterKey(%s)", key
);
500 err
= EnumPrinterKey(handle
, key
, NULL
, 0, &needed
);
501 if (err
== ERROR_MORE_DATA
) {
502 buffer
= (LPTSTR
)malloc(needed
);
503 torture_assert(tctx
, buffer
, "malloc failed");
504 err
= EnumPrinterKey(handle
, key
, buffer
, needed
, &needed
);
507 sprintf(tmp
, "EnumPrinterKey(%s) failed on [%s] (buffer size = %d), error: %s\n",
508 key
, servername
, needed
, errstr(err
));
509 torture_fail(tctx
, tmp
);
513 print_printer_keys(buffer
);
521 /****************************************************************************
522 ****************************************************************************/
524 static BOOL
test_GetPrinter(struct torture_context
*tctx
,
528 DWORD levels
[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
529 DWORD success
[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
531 LPBYTE buffer
= NULL
;
533 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
539 torture_comment(tctx
, "Testing GetPrinter level %d", levels
[i
]);
541 GetPrinter(handle
, levels
[i
], NULL
, 0, &needed
);
542 err
= GetLastError();
543 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
545 buffer
= malloc(needed
);
546 torture_assert(tctx
, buffer
, "malloc failed");
547 if (!GetPrinter(handle
, levels
[i
], buffer
, needed
, &needed
)) {
548 err
= GetLastError();
552 sprintf(tmp
, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
553 levels
[i
], printername
, needed
, errstr(err
));
555 torture_fail(tctx
, tmp
);
557 torture_warning(tctx
, tmp
);
562 print_printer_info_bylevel(levels
[i
], buffer
, 1);
572 /****************************************************************************
573 ****************************************************************************/
575 static BOOL
test_GetPrinterDriver(struct torture_context
*tctx
,
580 DWORD levels
[] = { 1, 2, 3, 4, 5, 6, 8 };
581 DWORD success
[] = { 1, 1, 1, 1, 1, 1, 1 };
583 LPBYTE buffer
= NULL
;
585 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
591 torture_comment(tctx
, "Testing GetPrinterDriver level %d", levels
[i
]);
593 GetPrinterDriver(handle
, architecture
, levels
[i
], NULL
, 0, &needed
);
594 err
= GetLastError();
595 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
597 buffer
= malloc(needed
);
598 torture_assert(tctx
, buffer
, "malloc failed");
599 if (!GetPrinterDriver(handle
, architecture
, levels
[i
], buffer
, needed
, &needed
)) {
600 err
= GetLastError();
604 sprintf(tmp
, "GetPrinterDriver failed level %d on [%s] (buffer size = %d), error: %s\n",
605 levels
[i
], printername
, needed
, errstr(err
));
607 torture_fail(tctx
, tmp
);
609 torture_warning(tctx
, tmp
);
614 print_driver_info_bylevel(levels
[i
], buffer
, 1);
625 /****************************************************************************
626 ****************************************************************************/
628 static BOOL
test_EnumJobs(struct torture_context
*tctx
,
632 DWORD levels
[] = { 1, 2, 3, 4 };
633 DWORD success
[] = { 1, 1, 1, 1 };
635 LPBYTE buffer
= NULL
;
637 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
644 torture_comment(tctx
, "Testing EnumJobs level %d", levels
[i
]);
646 if (tctx
->samba3
&& levels
[i
] == 4) {
647 torture_comment(tctx
, "skipping level %d enum against samba\n", levels
[i
]);
651 EnumJobs(handle
, 0, 100, levels
[i
], NULL
, 0, &needed
, &returned
);
652 err
= GetLastError();
653 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
655 buffer
= malloc(needed
);
656 torture_assert(tctx
, buffer
, "malloc failed");
657 if (!EnumJobs(handle
, 0, 100, levels
[i
], buffer
, needed
, &needed
, &returned
)) {
658 err
= GetLastError();
662 sprintf(tmp
, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
663 levels
[i
], printername
, needed
, errstr(err
));
665 torture_fail(tctx
, tmp
);
667 torture_warning(tctx
, tmp
);
672 print_job_info_bylevel(levels
[i
], buffer
, returned
);
682 /****************************************************************************
683 ****************************************************************************/
685 static BOOL
test_EnumPrinterData(struct torture_context
*tctx
,
694 DWORD value_offered
= 0, value_needed
;
695 DWORD data_offered
= 0, data_needed
;
698 torture_comment(tctx
, "Testing EnumPrinterData(%d) (value offered: %d, data_offered: %d)\n",
699 index
, value_offered
, data_offered
);
701 err
= EnumPrinterData(handle
, 0, NULL
, 0, &value_needed
, NULL
, NULL
, 0, &data_needed
);
703 sprintf(tmp
, "EnumPrinterData(%d) failed on [%s] (value size = %d, data size = %d), error: %s\n",
704 index
, servername
, value_offered
, data_offered
, errstr(err
));
705 torture_fail(tctx
, tmp
);
708 value_name
= malloc(value_needed
);
709 torture_assert(tctx
, value_name
, "malloc failed");
710 data
= malloc(data_needed
);
711 torture_assert(tctx
, data
, "malloc failed");
713 value_offered
= value_needed
;
714 data_offered
= data_needed
;
721 torture_comment(tctx
, "Testing EnumPrinterData(%d) (value offered: %d, data_offered: %d)\n",
722 index
, value_offered
, data_offered
);
724 err
= EnumPrinterData(handle
, index
++, value_name
, value_offered
, &value_needed
, &type
, data
, data_offered
, &data_needed
);
725 if (err
== ERROR_NO_MORE_ITEMS
) {
729 sprintf(tmp
, "EnumPrinterData(%d) failed on [%s] (value size = %d, data size = %d), error: %s\n",
730 index
, servername
, value_offered
, data_offered
, errstr(err
));
731 torture_fail(tctx
, tmp
);
735 print_printer_data(NULL
, value_name
, data_needed
, data
, type
);
738 } while (err
!= ERROR_NO_MORE_ITEMS
);
746 /****************************************************************************
747 ****************************************************************************/
749 static BOOL
test_EnumPrinterDataEx(struct torture_context
*tctx
,
756 LPBYTE buffer
= NULL
;
762 torture_comment(tctx
, "Testing EnumPrinterDataEx(%s)", keyname
);
764 err
= EnumPrinterDataEx(handle
, keyname
, NULL
, 0, &needed
, &returned
);
765 if (err
== ERROR_MORE_DATA
) {
766 buffer
= malloc(needed
);
767 torture_assert(tctx
, buffer
, "malloc failed");
768 err
= EnumPrinterDataEx(handle
, keyname
, buffer
, needed
, &needed
, &returned
);
771 sprintf(tmp
, "EnumPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
772 keyname
, servername
, needed
, errstr(err
));
773 torture_fail(tctx
, tmp
);
778 LPPRINTER_ENUM_VALUES v
= (LPPRINTER_ENUM_VALUES
)buffer
;
779 for (i
=0; i
< returned
; i
++) {
780 print_printer_enum_values(&v
[i
]);
785 *returned_p
= returned
;
797 /****************************************************************************
798 ****************************************************************************/
800 static BOOL
test_devicemode_equal(struct torture_context
*tctx
,
809 torture_comment(tctx
, "%s\n", __location__
);
813 torture_assert_str_equal(tctx
, (const char *)d1
->dmDeviceName
, (const char *)d2
->dmDeviceName
, "dmDeviceName mismatch");
814 torture_assert_int_equal(tctx
, d1
->dmSpecVersion
, d2
->dmSpecVersion
, "dmSpecVersion mismatch");
815 torture_assert_int_equal(tctx
, d1
->dmDriverVersion
, d2
->dmDriverVersion
, "dmDriverVersion mismatch");
816 torture_assert_int_equal(tctx
, d1
->dmSize
, d2
->dmSize
, "size mismatch");
817 torture_assert_int_equal(tctx
, d1
->dmDriverExtra
, d2
->dmDriverExtra
, "dmDriverExtra mismatch");
818 torture_assert_int_equal(tctx
, d1
->dmFields
, d2
->dmFields
, "dmFields mismatch");
820 torture_assert_int_equal(tctx
, d1
->dmOrientation
, d2
->dmOrientation
, "dmOrientation mismatch");
821 torture_assert_int_equal(tctx
, d1
->dmPaperSize
, d2
->dmPaperSize
, "dmPaperSize mismatch");
822 torture_assert_int_equal(tctx
, d1
->dmPaperLength
, d2
->dmPaperLength
, "dmPaperLength mismatch");
823 torture_assert_int_equal(tctx
, d1
->dmPaperWidth
, d2
->dmPaperWidth
, "dmPaperWidth mismatch");
824 torture_assert_int_equal(tctx
, d1
->dmScale
, d2
->dmScale
, "dmScale mismatch");
825 torture_assert_int_equal(tctx
, d1
->dmCopies
, d2
->dmCopies
, "dmCopies mismatch");
826 torture_assert_int_equal(tctx
, d1
->dmDefaultSource
, d2
->dmDefaultSource
, "dmDefaultSource mismatch");
827 torture_assert_int_equal(tctx
, d1
->dmPrintQuality
, d2
->dmPrintQuality
, "dmPrintQuality mismatch");
829 torture_assert_int_equal(tctx
, d1
->dmColor
, d2
->dmColor
, "dmColor mismatch");
830 torture_assert_int_equal(tctx
, d1
->dmDuplex
, d2
->dmDuplex
, "dmDuplex mismatch");
831 torture_assert_int_equal(tctx
, d1
->dmYResolution
, d2
->dmYResolution
, "dmYResolution mismatch");
832 torture_assert_int_equal(tctx
, d1
->dmTTOption
, d2
->dmTTOption
, "dmTTOption mismatch");
833 torture_assert_int_equal(tctx
, d1
->dmCollate
, d2
->dmCollate
, "dmCollate mismatch");
834 torture_assert_str_equal(tctx
, (const char *)d1
->dmFormName
, (const char *)d2
->dmFormName
, "dmFormName mismatch");
835 torture_assert_int_equal(tctx
, d1
->dmLogPixels
, d2
->dmLogPixels
, "dmLogPixels mismatch");
836 torture_assert_int_equal(tctx
, d1
->dmBitsPerPel
, d2
->dmBitsPerPel
, "dmBitsPerPel mismatch");
837 torture_assert_int_equal(tctx
, d1
->dmPelsWidth
, d2
->dmPelsWidth
, "dmPelsWidth mismatch");
838 torture_assert_int_equal(tctx
, d1
->dmPelsHeight
, d2
->dmPelsHeight
, "dmPelsHeight mismatch");
840 torture_assert_int_equal(tctx
, d1
->dmDisplayFlags
, d2
->dmDisplayFlags
, "dmDisplayFlags mismatch");
842 torture_assert_int_equal(tctx
, d1
->dmDisplayFrequency
, d2
->dmDisplayFrequency
, "dmDisplayFrequency mismatch");
844 torture_assert_int_equal(tctx
, d1
->dmICMMethod
, d2
->dmICMMethod
, "dmICMMethod mismatch");
845 torture_assert_int_equal(tctx
, d1
->dmICMIntent
, d2
->dmICMIntent
, "dmICMIntent mismatch");
846 torture_assert_int_equal(tctx
, d1
->dmMediaType
, d2
->dmMediaType
, "dmMediaType mismatch");
847 torture_assert_int_equal(tctx
, d1
->dmDitherType
, d2
->dmDitherType
, "dmDitherType mismatch");
848 torture_assert_int_equal(tctx
, d1
->dmReserved1
, d2
->dmReserved1
, "dmReserved1 mismatch");
849 torture_assert_int_equal(tctx
, d1
->dmReserved2
, d2
->dmReserved2
, "reserved2 mismatch");
851 torture_assert_int_equal(tctx
, d1
->dmPanningWidth
, d2
->dmPanningWidth
, "dmPanningWidth mismatch");
852 torture_assert_int_equal(tctx
, d1
->dmPanningHeight
, d2
->dmPanningHeight
, "dmPanningHeight mismatch");
854 /* torture_assert_mem_equal(tctx, d1 + d1->dmSize, d2 + d2->dmSize, d1->dmDriverExtra, "private extra data mismatch"); */
859 /****************************************************************************
860 ****************************************************************************/
862 static BOOL
test_DeviceModes(struct torture_context
*tctx
,
866 PPRINTER_INFO_2 info2
= NULL
;
867 PPRINTER_INFO_8 info8
= NULL
;
872 torture_comment(tctx
, "Testing DeviceModes");
874 torture_comment(tctx
, "Testing GetPrinter level %d", 2);
876 GetPrinter(handle
, 2, NULL
, 0, &needed
);
877 err
= GetLastError();
878 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
880 info2
= (PPRINTER_INFO_2
)malloc(needed
);
881 torture_assert(tctx
, (LPBYTE
)info2
, "malloc failed");
882 if (!GetPrinter(handle
, 2, (LPBYTE
)info2
, needed
, &needed
)) {
883 err
= GetLastError();
887 sprintf(tmp
, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
888 2, printername
, needed
, errstr(err
));
889 torture_fail(tctx
, tmp
);
893 print_printer_info_2(info2
);
896 torture_comment(tctx
, "Testing GetPrinter level %d", 8);
898 GetPrinter(handle
, 8, NULL
, 0, &needed
);
899 err
= GetLastError();
900 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
902 info8
= (PPRINTER_INFO_8
)malloc(needed
);
903 torture_assert(tctx
, (LPBYTE
)info8
, "malloc failed");
904 if (!GetPrinter(handle
, 8, (LPBYTE
)info8
, needed
, &needed
)) {
905 err
= GetLastError();
909 sprintf(tmp
, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
910 8, printername
, needed
, errstr(err
));
911 torture_fail(tctx
, tmp
);
915 print_printer_info_8(info8
);
918 torture_assert(tctx
, test_devicemode_equal(tctx
, info2
->pDevMode
, info8
->pDevMode
), "");
926 /****************************************************************************
927 ****************************************************************************/
929 static BOOL
test_GetJob(struct torture_context
*tctx
,
934 DWORD levels
[] = { 1, 2, 3, 4 };
935 DWORD success
[] = { 1, 1, 1, 1 };
937 LPBYTE buffer
= NULL
;
939 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
945 torture_comment(tctx
, "Testing GetJob(%d) level %d", job_id
, levels
[i
]);
947 if (tctx
->samba3
&& (levels
[i
] == 4) || (levels
[i
] == 3)) {
948 torture_comment(tctx
, "skipping level %d getjob against samba\n", levels
[i
]);
952 GetJob(handle
, job_id
, levels
[i
], NULL
, 0, &needed
);
953 err
= GetLastError();
954 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
956 buffer
= malloc(needed
);
957 torture_assert(tctx
, buffer
, "malloc failed");
958 if (!GetJob(handle
, job_id
, levels
[i
], buffer
, needed
, &needed
)) {
959 err
= GetLastError();
963 sprintf(tmp
, "GetJob failed level %d on [%s] (buffer size = %d), error: %s\n",
964 levels
[i
], printername
, needed
, errstr(err
));
966 torture_fail(tctx
, tmp
);
968 torture_warning(tctx
, tmp
);
973 print_job_info_bylevel(levels
[i
], buffer
, 1);
983 /****************************************************************************
984 ****************************************************************************/
986 static BOOL
test_EachJob(struct torture_context
*tctx
,
991 PJOB_INFO_1 buffer
= NULL
;
999 torture_comment(tctx
, "Testing Each PrintJob %d");
1001 EnumJobs(handle
, 0, 100, level
, NULL
, 0, &needed
, &returned
);
1002 err
= GetLastError();
1003 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1005 buffer
= (PJOB_INFO_1
)malloc(needed
);
1006 torture_assert(tctx
, buffer
, "malloc failed");
1007 if (!EnumJobs(handle
, 0, 100, level
, (LPBYTE
)buffer
, needed
, &needed
, &returned
)) {
1008 err
= GetLastError();
1012 sprintf(tmp
, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
1013 level
, printername
, needed
, errstr(err
));
1014 torture_fail(tctx
, tmp
);
1018 print_job_info_bylevel(level
, (LPBYTE
)buffer
, returned
);
1021 for (i
=0; i
< returned
; i
++) {
1022 ret
= test_GetJob(tctx
, printername
, handle
, buffer
[i
].JobId
);
1031 /****************************************************************************
1032 ****************************************************************************/
1034 static BOOL
test_OnePrinter(struct torture_context
*tctx
,
1037 LPPRINTER_DEFAULTS defaults
)
1042 torture_comment(tctx
, "Testing Printer %s", printername
);
1044 ret
&= test_OpenPrinter(tctx
, printername
, defaults
, &handle
);
1045 ret
&= test_GetPrinter(tctx
, printername
, handle
);
1046 ret
&= test_GetPrinterDriver(tctx
, printername
, architecture
, handle
);
1047 ret
&= test_EnumForms(tctx
, printername
, handle
);
1048 ret
&= test_EnumJobs(tctx
, printername
, handle
);
1049 ret
&= test_EachJob(tctx
, printername
, handle
);
1050 ret
&= test_EnumPrinterKey(tctx
, printername
, handle
, "");
1051 ret
&= test_EnumPrinterKey(tctx
, printername
, handle
, "PrinterDriverData");
1052 ret
&= test_EnumPrinterData(tctx
, printername
, handle
);
1053 ret
&= test_EnumPrinterDataEx(tctx
, printername
, "PrinterDriverData", handle
, NULL
, NULL
);
1054 ret
&= test_DeviceModes(tctx
, printername
, handle
);
1055 ret
&= test_PrinterData(tctx
, printername
, handle
);
1056 ret
&= test_PrinterDataW(tctx
, printername
, handle
);
1057 ret
&= test_ClosePrinter(tctx
, handle
);
1062 /****************************************************************************
1063 ****************************************************************************/
1065 static BOOL
test_EachPrinter(struct torture_context
*tctx
,
1068 LPPRINTER_DEFAULTS defaults
)
1075 DWORD flags
= PRINTER_ENUM_NAME
;
1076 PPRINTER_INFO_1 buffer
= NULL
;
1079 torture_comment(tctx
, "Testing EnumPrinters level %d", 1);
1081 EnumPrinters(flags
, servername
, 1, NULL
, 0, &needed
, &returned
);
1082 err
= GetLastError();
1083 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1085 buffer
= (PPRINTER_INFO_1
)malloc(needed
);
1086 torture_assert(tctx
, buffer
, "malloc failed");
1087 if (!EnumPrinters(flags
, servername
, 1, (LPBYTE
)buffer
, needed
, &needed
, &returned
)) {
1088 err
= GetLastError();
1092 sprintf(tmp
, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
1093 1, servername
, needed
, errstr(err
));
1094 torture_fail(tctx
, tmp
);
1097 for (i
=0; i
< returned
; i
++) {
1098 ret
&= test_OnePrinter(tctx
, buffer
[i
].pName
, architecture
, defaults
);
1106 /****************************************************************************
1107 ****************************************************************************/
1109 static BOOL
test_GetPrintProcessorDirectory(struct torture_context
*tctx
,
1113 DWORD levels
[] = { 1 };
1114 DWORD success
[] = { 1 };
1116 LPBYTE buffer
= NULL
;
1118 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
1124 torture_comment(tctx
, "Testing GetPrintProcessorDirectory level %d", levels
[i
]);
1126 GetPrintProcessorDirectory(servername
, architecture
, levels
[i
], NULL
, 0, &needed
);
1127 err
= GetLastError();
1128 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1130 buffer
= malloc(needed
);
1131 torture_assert(tctx
, buffer
, "malloc failed");
1132 if (!GetPrintProcessorDirectory(servername
, architecture
, levels
[i
], buffer
, needed
, &needed
)) {
1133 err
= GetLastError();
1137 sprintf(tmp
, "GetPrintProcessorDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
1138 levels
[i
], servername
, needed
, errstr(err
));
1140 torture_fail(tctx
, tmp
);
1142 torture_warning(tctx
, tmp
);
1147 printf("\tPrint Processor Directory\t= %s\n\n", (LPSTR
)buffer
);
1157 /****************************************************************************
1158 ****************************************************************************/
1160 static BOOL
test_GetPrinterDriverDirectory(struct torture_context
*tctx
,
1164 DWORD levels
[] = { 1 };
1165 DWORD success
[] = { 1 };
1167 LPBYTE buffer
= NULL
;
1169 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
1175 torture_comment(tctx
, "Testing GetPrinterDriverDirectory level %d", levels
[i
]);
1177 GetPrinterDriverDirectory(servername
, architecture
, levels
[i
], NULL
, 0, &needed
);
1178 err
= GetLastError();
1179 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1181 buffer
= malloc(needed
);
1182 torture_assert(tctx
, buffer
, "malloc failed");
1183 if (!GetPrinterDriverDirectory(servername
, architecture
, levels
[i
], buffer
, needed
, &needed
)) {
1184 err
= GetLastError();
1188 sprintf(tmp
, "GetPrinterDriverDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
1189 levels
[i
], servername
, needed
, errstr(err
));
1191 torture_fail(tctx
, tmp
);
1193 torture_warning(tctx
, tmp
);
1198 printf("\tPrinter Driver Directory\t= %s\n\n", (LPSTR
)buffer
);
1208 /****************************************************************************
1209 ****************************************************************************/
1211 static BOOL
test_GetPrinterData(struct torture_context
*tctx
,
1219 LPBYTE buffer
= NULL
;
1225 torture_comment(tctx
, "Testing GetPrinterData(%s)", valuename
);
1227 err
= GetPrinterData(handle
, valuename
, &type
, NULL
, 0, &needed
);
1228 if (err
== ERROR_MORE_DATA
) {
1229 buffer
= (LPBYTE
)malloc(needed
);
1230 torture_assert(tctx
, buffer
, "malloc failed");
1231 err
= GetPrinterData(handle
, valuename
, &type
, buffer
, needed
, &needed
);
1234 sprintf(tmp
, "GetPrinterData(%s) failed on [%s] (buffer size = %d), error: %s\n",
1235 valuename
, servername
, needed
, errstr(err
));
1236 torture_fail(tctx
, tmp
);
1240 print_printer_data("PrinterDriverData", valuename
, needed
, buffer
, type
);
1260 /****************************************************************************
1261 ****************************************************************************/
1263 static BOOL
test_GetPrinterDataEx(struct torture_context
*tctx
,
1272 LPBYTE buffer
= NULL
;
1278 torture_comment(tctx
, "Testing GetPrinterDataEx(%s - %s)", keyname
, valuename
);
1280 err
= GetPrinterDataEx(handle
, keyname
, valuename
, &type
, NULL
, 0, &needed
);
1281 if (err
== ERROR_MORE_DATA
) {
1282 buffer
= (LPBYTE
)malloc(needed
);
1283 torture_assert(tctx
, buffer
, "malloc failed");
1284 err
= GetPrinterDataEx(handle
, keyname
, valuename
, &type
, buffer
, needed
, &needed
);
1287 sprintf(tmp
, "GetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
1288 valuename
, servername
, needed
, errstr(err
));
1289 torture_fail(tctx
, tmp
);
1293 print_printer_data(keyname
, valuename
, needed
, buffer
, type
);
1313 /****************************************************************************
1314 ****************************************************************************/
1316 static BOOL
test_GetPrinterDataExW(struct torture_context
*tctx
,
1325 LPBYTE buffer
= NULL
;
1331 torture_comment(tctx
, "Testing GetPrinterDataExW(%ls - %ls)", keyname
, valuename
);
1333 err
= GetPrinterDataExW(handle
, keyname
, valuename
, &type
, NULL
, 0, &needed
);
1334 if (err
== ERROR_MORE_DATA
) {
1335 buffer
= (LPBYTE
)malloc(needed
);
1336 torture_assert(tctx
, buffer
, "malloc failed");
1337 err
= GetPrinterDataExW(handle
, keyname
, valuename
, &type
, buffer
, needed
, &needed
);
1340 sprintf(tmp
, "GetPrinterDataExW(%ls) failed on [%s] (buffer size = %d), error: %s\n",
1341 valuename
, servername
, needed
, errstr(err
));
1342 torture_fail(tctx
, tmp
);
1346 print_printer_dataw(keyname
, valuename
, needed
, buffer
, type
);
1367 /****************************************************************************
1368 ****************************************************************************/
1370 static BOOL
test_DeletePrinterDataEx(struct torture_context
*tctx
,
1379 torture_comment(tctx
, "Testing DeletePrinterDataEx(%s - %s)", keyname
, valuename
);
1381 err
= DeletePrinterDataEx(handle
, keyname
, valuename
);
1383 sprintf(tmp
, "DeletePrinterDataEx(%s - %s) failed on [%s], error: %s\n",
1384 keyname
, valuename
, servername
, errstr(err
));
1385 torture_fail(tctx
, tmp
);
1391 /****************************************************************************
1392 ****************************************************************************/
1394 static BOOL
test_DeletePrinterDataExW(struct torture_context
*tctx
,
1403 torture_comment(tctx
, "Testing DeletePrinterDataExW(%ls - %ls)", keyname
, valuename
);
1405 err
= DeletePrinterDataExW(handle
, keyname
, valuename
);
1407 sprintf(tmp
, "DeletePrinterDataExW(%ls - %ls) failed on [%s], error: %s\n",
1408 keyname
, valuename
, servername
, errstr(err
));
1409 torture_fail(tctx
, tmp
);
1416 /****************************************************************************
1417 ****************************************************************************/
1419 static BOOL
test_DeletePrinterKey(struct torture_context
*tctx
,
1427 torture_comment(tctx
, "Testing DeletePrinterKey(%s)", keyname
);
1429 err
= DeletePrinterKey(handle
, keyname
);
1431 sprintf(tmp
, "DeletePrinterKey(%s) failed on [%s], error: %s\n",
1432 keyname
, servername
, errstr(err
));
1433 torture_fail(tctx
, tmp
);
1439 /****************************************************************************
1440 ****************************************************************************/
1442 static BOOL
test_DeletePrinterKeyW(struct torture_context
*tctx
,
1450 torture_comment(tctx
, "Testing DeletePrinterKeyW(%ls)", keyname
);
1452 err
= DeletePrinterKeyW(handle
, keyname
);
1454 sprintf(tmp
, "DeletePrinterKeyW(%ls) failed on [%s], error: %s\n",
1455 keyname
, servername
, errstr(err
));
1456 torture_fail(tctx
, tmp
);
1462 /****************************************************************************
1463 ****************************************************************************/
1465 static BOOL
test_SetPrinterDataEx(struct torture_context
*tctx
,
1477 torture_comment(tctx
, "Testing SetPrinterDataEx(%s - %s)", keyname
, valuename
);
1479 err
= SetPrinterDataEx(handle
, keyname
, valuename
, type
, buffer
, offered
);
1481 sprintf(tmp
, "SetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
1482 valuename
, servername
, offered
, errstr(err
));
1483 torture_fail(tctx
, tmp
);
1489 /****************************************************************************
1490 ****************************************************************************/
1492 static BOOL
test_SetPrinterDataExW(struct torture_context
*tctx
,
1504 torture_comment(tctx
, "Testing SetPrinterDataExW(%ls - %ls)", keyname
, valuename
);
1506 err
= SetPrinterDataExW(handle
, keyname
, valuename
, type
, buffer
, offered
);
1508 sprintf(tmp
, "SetPrinterDataExW(%ls) failed on [%s] (buffer size = %d), error: %s\n",
1509 valuename
, servername
, offered
, errstr(err
));
1510 torture_fail(tctx
, tmp
);
1517 /****************************************************************************
1518 ****************************************************************************/
1520 static BOOL
test_PrinterData_Server(struct torture_context
*tctx
,
1526 DWORD type
, type_ex
;
1527 LPBYTE buffer
, buffer_ex
;
1528 DWORD size
, size_ex
;
1529 LPSTR valuenames
[] = {
1530 SPLREG_DEFAULT_SPOOL_DIRECTORY
,
1531 SPLREG_MAJOR_VERSION
,
1532 SPLREG_MINOR_VERSION
,
1534 SPLREG_DNS_MACHINE_NAME
,
1535 SPLREG_ARCHITECTURE
,
1539 for (i
=0; i
< ARRAY_SIZE(valuenames
); i
++) {
1540 ret
&= test_GetPrinterData(tctx
, servername
, valuenames
[i
], handle
, &type
, &buffer
, &size
);
1541 ret
&= test_GetPrinterDataEx(tctx
, servername
, "random", valuenames
[i
], handle
, &type_ex
, &buffer_ex
, &size_ex
);
1542 torture_assert_int_equal(tctx
, type
, type_ex
, "type mismatch");
1543 torture_assert_int_equal(tctx
, size
, size_ex
, "size mismatch");
1544 torture_assert_mem_equal(tctx
, buffer
, buffer_ex
, size
, "buffer mismatch");
1552 /****************************************************************************
1553 ****************************************************************************/
1555 static BOOL
PrinterDataEqual(struct torture_context
*tctx
,
1556 DWORD type1
, DWORD type2
,
1557 DWORD size1
, DWORD size2
,
1558 LPBYTE buffer1
, LPBYTE buffer2
)
1560 torture_assert_int_equal(tctx
, type1
, type2
, "type mismatch");
1561 torture_assert_int_equal(tctx
, size1
, size2
, "size mismatch");
1562 torture_assert_mem_equal(tctx
, buffer1
, buffer2
, size1
, "buffer mismatch");
1567 /****************************************************************************
1568 ****************************************************************************/
1570 static BOOL
test_PrinterData(struct torture_context
*tctx
,
1575 LPSTR keyname
= "torture_key";
1576 LPSTR valuename
= "torture_value";
1583 DWORD value
= 12345678;
1584 LPSTR str
= "abcdefghijklmnopqrstuvwxzy";
1587 for (t
=0; t
< ARRAY_SIZE(types
); t
++) {
1588 for (s
=0; s
< strlen(str
); s
++) {
1590 DWORD type
, type_ex
;
1591 LPBYTE buffer
, buffer_ex
;
1592 DWORD size
, size_ex
;
1594 if (types
[t
] == REG_DWORD
) {
1601 memcpy(buffer
, str
, s
);
1606 memcpy(buffer
, &value
, 4);
1611 memcpy(buffer
, str
, s
);
1615 sprintf(tmp
, "type %d untested\n", types
[t
]);
1616 torture_fail(tctx
, tmp
);
1622 torture_comment(tctx
, "Testing PrinterData (type: %s, size: 0x%08x)", reg_type_str(type
), size
);
1624 torture_assert(tctx
,
1625 test_SetPrinterDataEx(tctx
, printername
, keyname
, valuename
, handle
, type
, buffer
, size
),
1626 "failed to call SetPrinterDataEx");
1627 torture_assert(tctx
,
1628 test_GetPrinterDataEx(tctx
, printername
, keyname
, valuename
, handle
, &type_ex
, &buffer_ex
, &size_ex
),
1629 "failed to call GetPrinterDataEx");
1631 if (!PrinterDataEqual(tctx
, type_ex
, type
, size_ex
, size
, buffer_ex
, buffer
)) {
1632 torture_warning(tctx
, "GetPrinterDataEx does not return the same info as we set with SetPrinterDataEx");
1635 ret
&= test_DeletePrinterDataEx(tctx
, printername
, keyname
, valuename
, handle
);
1636 ret
&= test_DeletePrinterKey(tctx
, printername
, keyname
, handle
);
1646 /****************************************************************************
1647 ****************************************************************************/
1649 static BOOL
test_PrinterDataW(struct torture_context
*tctx
,
1654 LPCWSTR keyname
= L
"torture_key";
1655 LPCWSTR valuename
= L
"torture_value";
1662 DWORD value
= 12345678;
1663 LPSTR str
= "abcdefghijklmnopqrstuvwxzy";
1666 for (t
=0; t
< ARRAY_SIZE(types
); t
++) {
1667 for (s
=0; s
< strlen(str
); s
++) {
1669 DWORD type
, type_ex
;
1670 LPBYTE buffer
, buffer_ex
;
1671 DWORD size
, size_ex
;
1673 if (types
[t
] == REG_DWORD
) {
1680 memcpy(buffer
, str
, s
);
1685 memcpy(buffer
, &value
, 4);
1690 memcpy(buffer
, str
, s
);
1694 sprintf(tmp
, "type %d untested\n", types
[t
]);
1695 torture_fail(tctx
, tmp
);
1701 torture_comment(tctx
, "Testing PrinterDataW (type: %s, size: 0x%08x)", reg_type_str(type
), size
);
1703 torture_assert(tctx
,
1704 test_SetPrinterDataExW(tctx
, printername
, keyname
, valuename
, handle
, type
, buffer
, size
),
1705 "failed to call SetPrinterDataExW");
1706 torture_assert(tctx
,
1707 test_GetPrinterDataExW(tctx
, printername
, keyname
, valuename
, handle
, &type_ex
, &buffer_ex
, &size_ex
),
1708 "failed to call GetPrinterDataExW");
1710 if (!PrinterDataEqual(tctx
, type_ex
, type
, size_ex
, size
, buffer_ex
, buffer
)) {
1711 torture_warning(tctx
, "GetPrinterDataExW does not return the same info as we set with SetPrinterDataExW");
1714 ret
&= test_DeletePrinterDataExW(tctx
, printername
, keyname
, valuename
, handle
);
1715 ret
&= test_DeletePrinterKeyW(tctx
, printername
, keyname
, handle
);
1725 /****************************************************************************
1726 ****************************************************************************/
1728 const char *get_string_param(const char *str
)
1732 p
= strchr(str
, '=');
1740 /****************************************************************************
1741 ****************************************************************************/
1743 int main(int argc
, char *argv
[])
1747 LPSTR architecture
= "Windows NT x86";
1748 HANDLE server_handle
;
1749 PRINTER_DEFAULTS defaults_admin
, defaults_use
;
1750 struct torture_context
*tctx
;
1754 fprintf(stderr
, "usage: %s <name> [print] [samba3] [architecture=ARCHITECTURE]\n\n", argv
[0]);
1755 fprintf(stderr
, "\t<name> can be a server or printer name URI\n");
1756 fprintf(stderr
, "\t[print] will print all data that has been retrieved\n");
1757 fprintf(stderr
, "\t from the printserver\n");
1758 fprintf(stderr
, "\t[samba3] will skip some tests samba servers are known\n");
1759 fprintf(stderr
, "\t not to have implemented\n");
1760 fprintf(stderr
, "\t[architecture=X] allows to define a specific\n");
1761 fprintf(stderr
, "\t architecture to test with. choose between:\n");
1762 fprintf(stderr
, "\t \"Windows NT x86\" or \"Windows x64\"\n");
1766 tctx
= malloc(sizeof(struct torture_context
));
1768 fprintf(stderr
, "out of memory\n");
1771 memset(tctx
, '\0', sizeof(*tctx
));
1773 servername
= argv
[1];
1775 for (i
=1; i
< argc
; i
++) {
1776 if (strcmp(argv
[i
], "print") == 0) {
1779 if (strcmp(argv
[i
], "samba3") == 0) {
1780 tctx
->samba3
= TRUE
;
1782 if (strncmp(argv
[i
], "architecture", strlen("architecture")) == 0) {
1783 architecture
= get_string_param(argv
[i
]);
1787 printf("Running testsuite with architecture: %s\n", architecture
);
1789 defaults_admin
.pDatatype
= NULL
;
1790 defaults_admin
.pDevMode
= NULL
;
1791 defaults_admin
.DesiredAccess
= PRINTER_ACCESS_ADMINISTER
;
1793 defaults_use
.pDatatype
= NULL
;
1794 defaults_use
.pDevMode
= NULL
;
1795 defaults_use
.DesiredAccess
= PRINTER_ACCESS_USE
;
1797 if ((servername
[0] == '\\') && (servername
[1] == '\\')) {
1798 LPSTR p
= servername
+2;
1800 if ((p2
= strchr(p
, '\\')) != NULL
) {
1801 ret
= test_OnePrinter(tctx
, servername
, architecture
, &defaults_admin
);
1806 ret
&= test_EnumPrinters(tctx
, servername
);
1807 ret
&= test_EnumDrivers(tctx
, servername
, architecture
);
1808 ret
&= test_OpenPrinter(tctx
, servername
, NULL
, &server_handle
);
1809 /* ret &= test_EnumPrinterKey(tctx, servername, server_handle, ""); */
1810 ret
&= test_PrinterData_Server(tctx
, servername
, server_handle
);
1811 ret
&= test_EnumForms(tctx
, servername
, server_handle
);
1812 ret
&= test_ClosePrinter(tctx
, server_handle
);
1813 ret
&= test_EnumPorts(tctx
, servername
);
1814 ret
&= test_EnumMonitors(tctx
, servername
);
1815 ret
&= test_EnumPrintProcessors(tctx
, servername
, architecture
);
1816 ret
&= test_EnumPrintProcessorDatatypes(tctx
, servername
);
1817 ret
&= test_GetPrintProcessorDirectory(tctx
, servername
, architecture
);
1818 ret
&= test_GetPrinterDriverDirectory(tctx
, servername
, architecture
);
1819 ret
&= test_EachPrinter(tctx
, servername
, architecture
, &defaults_admin
);
1823 if (tctx
->last_reason
) {
1824 fprintf(stderr
, "failed: %s\n", tctx
->last_reason
);
1830 printf("%s run successfully\n", argv
[0]);