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_EnumPrinterDataEx(struct torture_context
*tctx
,
692 LPBYTE buffer
= NULL
;
698 torture_comment(tctx
, "Testing EnumPrinterDataEx(%s)", keyname
);
700 err
= EnumPrinterDataEx(handle
, keyname
, NULL
, 0, &needed
, &returned
);
701 if (err
== ERROR_MORE_DATA
) {
702 buffer
= malloc(needed
);
703 torture_assert(tctx
, buffer
, "malloc failed");
704 err
= EnumPrinterDataEx(handle
, keyname
, buffer
, needed
, &needed
, &returned
);
707 sprintf(tmp
, "EnumPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
708 keyname
, servername
, needed
, errstr(err
));
709 torture_fail(tctx
, tmp
);
714 LPPRINTER_ENUM_VALUES v
= (LPPRINTER_ENUM_VALUES
)buffer
;
715 for (i
=0; i
< returned
; i
++) {
716 print_printer_enum_values(&v
[i
]);
721 *returned_p
= returned
;
733 /****************************************************************************
734 ****************************************************************************/
736 static BOOL
test_devicemode_equal(struct torture_context
*tctx
,
745 torture_comment(tctx
, "%s\n", __location__
);
749 torture_assert_str_equal(tctx
, (const char *)d1
->dmDeviceName
, (const char *)d2
->dmDeviceName
, "dmDeviceName mismatch");
750 torture_assert_int_equal(tctx
, d1
->dmSpecVersion
, d2
->dmSpecVersion
, "dmSpecVersion mismatch");
751 torture_assert_int_equal(tctx
, d1
->dmDriverVersion
, d2
->dmDriverVersion
, "dmDriverVersion mismatch");
752 torture_assert_int_equal(tctx
, d1
->dmSize
, d2
->dmSize
, "size mismatch");
753 torture_assert_int_equal(tctx
, d1
->dmDriverExtra
, d2
->dmDriverExtra
, "dmDriverExtra mismatch");
754 torture_assert_int_equal(tctx
, d1
->dmFields
, d2
->dmFields
, "dmFields mismatch");
756 torture_assert_int_equal(tctx
, d1
->dmOrientation
, d2
->dmOrientation
, "dmOrientation mismatch");
757 torture_assert_int_equal(tctx
, d1
->dmPaperSize
, d2
->dmPaperSize
, "dmPaperSize mismatch");
758 torture_assert_int_equal(tctx
, d1
->dmPaperLength
, d2
->dmPaperLength
, "dmPaperLength mismatch");
759 torture_assert_int_equal(tctx
, d1
->dmPaperWidth
, d2
->dmPaperWidth
, "dmPaperWidth mismatch");
760 torture_assert_int_equal(tctx
, d1
->dmScale
, d2
->dmScale
, "dmScale mismatch");
761 torture_assert_int_equal(tctx
, d1
->dmCopies
, d2
->dmCopies
, "dmCopies mismatch");
762 torture_assert_int_equal(tctx
, d1
->dmDefaultSource
, d2
->dmDefaultSource
, "dmDefaultSource mismatch");
763 torture_assert_int_equal(tctx
, d1
->dmPrintQuality
, d2
->dmPrintQuality
, "dmPrintQuality mismatch");
765 torture_assert_int_equal(tctx
, d1
->dmColor
, d2
->dmColor
, "dmColor mismatch");
766 torture_assert_int_equal(tctx
, d1
->dmDuplex
, d2
->dmDuplex
, "dmDuplex mismatch");
767 torture_assert_int_equal(tctx
, d1
->dmYResolution
, d2
->dmYResolution
, "dmYResolution mismatch");
768 torture_assert_int_equal(tctx
, d1
->dmTTOption
, d2
->dmTTOption
, "dmTTOption mismatch");
769 torture_assert_int_equal(tctx
, d1
->dmCollate
, d2
->dmCollate
, "dmCollate mismatch");
770 torture_assert_str_equal(tctx
, (const char *)d1
->dmFormName
, (const char *)d2
->dmFormName
, "dmFormName mismatch");
771 torture_assert_int_equal(tctx
, d1
->dmLogPixels
, d2
->dmLogPixels
, "dmLogPixels mismatch");
772 torture_assert_int_equal(tctx
, d1
->dmBitsPerPel
, d2
->dmBitsPerPel
, "dmBitsPerPel mismatch");
773 torture_assert_int_equal(tctx
, d1
->dmPelsWidth
, d2
->dmPelsWidth
, "dmPelsWidth mismatch");
774 torture_assert_int_equal(tctx
, d1
->dmPelsHeight
, d2
->dmPelsHeight
, "dmPelsHeight mismatch");
776 torture_assert_int_equal(tctx
, d1
->dmDisplayFlags
, d2
->dmDisplayFlags
, "dmDisplayFlags mismatch");
778 torture_assert_int_equal(tctx
, d1
->dmDisplayFrequency
, d2
->dmDisplayFrequency
, "dmDisplayFrequency mismatch");
780 torture_assert_int_equal(tctx
, d1
->dmICMMethod
, d2
->dmICMMethod
, "dmICMMethod mismatch");
781 torture_assert_int_equal(tctx
, d1
->dmICMIntent
, d2
->dmICMIntent
, "dmICMIntent mismatch");
782 torture_assert_int_equal(tctx
, d1
->dmMediaType
, d2
->dmMediaType
, "dmMediaType mismatch");
783 torture_assert_int_equal(tctx
, d1
->dmDitherType
, d2
->dmDitherType
, "dmDitherType mismatch");
784 torture_assert_int_equal(tctx
, d1
->dmReserved1
, d2
->dmReserved1
, "dmReserved1 mismatch");
785 torture_assert_int_equal(tctx
, d1
->dmReserved2
, d2
->dmReserved2
, "reserved2 mismatch");
787 torture_assert_int_equal(tctx
, d1
->dmPanningWidth
, d2
->dmPanningWidth
, "dmPanningWidth mismatch");
788 torture_assert_int_equal(tctx
, d1
->dmPanningHeight
, d2
->dmPanningHeight
, "dmPanningHeight mismatch");
790 /* torture_assert_mem_equal(tctx, d1 + d1->dmSize, d2 + d2->dmSize, d1->dmDriverExtra, "private extra data mismatch"); */
795 /****************************************************************************
796 ****************************************************************************/
798 static BOOL
test_DeviceModes(struct torture_context
*tctx
,
802 PPRINTER_INFO_2 info2
= NULL
;
803 PPRINTER_INFO_8 info8
= NULL
;
808 torture_comment(tctx
, "Testing DeviceModes");
810 torture_comment(tctx
, "Testing GetPrinter level %d", 2);
812 GetPrinter(handle
, 2, NULL
, 0, &needed
);
813 err
= GetLastError();
814 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
816 info2
= (PPRINTER_INFO_2
)malloc(needed
);
817 torture_assert(tctx
, (LPBYTE
)info2
, "malloc failed");
818 if (!GetPrinter(handle
, 2, (LPBYTE
)info2
, needed
, &needed
)) {
819 err
= GetLastError();
823 sprintf(tmp
, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
824 2, printername
, needed
, errstr(err
));
825 torture_fail(tctx
, tmp
);
829 print_printer_info_2(info2
);
832 torture_comment(tctx
, "Testing GetPrinter level %d", 8);
834 GetPrinter(handle
, 8, NULL
, 0, &needed
);
835 err
= GetLastError();
836 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
838 info8
= (PPRINTER_INFO_8
)malloc(needed
);
839 torture_assert(tctx
, (LPBYTE
)info8
, "malloc failed");
840 if (!GetPrinter(handle
, 8, (LPBYTE
)info8
, needed
, &needed
)) {
841 err
= GetLastError();
845 sprintf(tmp
, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
846 8, printername
, needed
, errstr(err
));
847 torture_fail(tctx
, tmp
);
851 print_printer_info_8(info8
);
854 torture_assert(tctx
, test_devicemode_equal(tctx
, info2
->pDevMode
, info8
->pDevMode
), "");
862 /****************************************************************************
863 ****************************************************************************/
865 static BOOL
test_GetJob(struct torture_context
*tctx
,
870 DWORD levels
[] = { 1, 2, 3, 4 };
871 DWORD success
[] = { 1, 1, 1, 1 };
873 LPBYTE buffer
= NULL
;
875 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
881 torture_comment(tctx
, "Testing GetJob(%d) level %d", job_id
, levels
[i
]);
883 if (tctx
->samba3
&& (levels
[i
] == 4) || (levels
[i
] == 3)) {
884 torture_comment(tctx
, "skipping level %d getjob against samba\n", levels
[i
]);
888 GetJob(handle
, job_id
, levels
[i
], NULL
, 0, &needed
);
889 err
= GetLastError();
890 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
892 buffer
= malloc(needed
);
893 torture_assert(tctx
, buffer
, "malloc failed");
894 if (!GetJob(handle
, job_id
, levels
[i
], buffer
, needed
, &needed
)) {
895 err
= GetLastError();
899 sprintf(tmp
, "GetJob failed level %d on [%s] (buffer size = %d), error: %s\n",
900 levels
[i
], printername
, needed
, errstr(err
));
902 torture_fail(tctx
, tmp
);
904 torture_warning(tctx
, tmp
);
909 print_job_info_bylevel(levels
[i
], buffer
, 1);
919 /****************************************************************************
920 ****************************************************************************/
922 static BOOL
test_EachJob(struct torture_context
*tctx
,
927 PJOB_INFO_1 buffer
= NULL
;
935 torture_comment(tctx
, "Testing Each PrintJob %d");
937 EnumJobs(handle
, 0, 100, level
, NULL
, 0, &needed
, &returned
);
938 err
= GetLastError();
939 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
941 buffer
= (PJOB_INFO_1
)malloc(needed
);
942 torture_assert(tctx
, buffer
, "malloc failed");
943 if (!EnumJobs(handle
, 0, 100, level
, (LPBYTE
)buffer
, needed
, &needed
, &returned
)) {
944 err
= GetLastError();
948 sprintf(tmp
, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
949 level
, printername
, needed
, errstr(err
));
950 torture_fail(tctx
, tmp
);
954 print_job_info_bylevel(level
, (LPBYTE
)buffer
, returned
);
957 for (i
=0; i
< returned
; i
++) {
958 ret
= test_GetJob(tctx
, printername
, handle
, buffer
[i
].JobId
);
967 /****************************************************************************
968 ****************************************************************************/
970 static BOOL
test_OnePrinter(struct torture_context
*tctx
,
973 LPPRINTER_DEFAULTS defaults
)
978 torture_comment(tctx
, "Testing Printer %s", printername
);
980 ret
&= test_OpenPrinter(tctx
, printername
, defaults
, &handle
);
981 ret
&= test_GetPrinter(tctx
, printername
, handle
);
982 ret
&= test_GetPrinterDriver(tctx
, printername
, architecture
, handle
);
983 ret
&= test_EnumForms(tctx
, printername
, handle
);
984 ret
&= test_EnumJobs(tctx
, printername
, handle
);
985 ret
&= test_EachJob(tctx
, printername
, handle
);
986 ret
&= test_EnumPrinterKey(tctx
, printername
, handle
, "");
987 ret
&= test_EnumPrinterKey(tctx
, printername
, handle
, "PrinterDriverData");
988 ret
&= test_EnumPrinterDataEx(tctx
, printername
, "PrinterDriverData", handle
, NULL
, NULL
);
989 ret
&= test_DeviceModes(tctx
, printername
, handle
);
990 ret
&= test_PrinterData(tctx
, printername
, handle
);
991 ret
&= test_ClosePrinter(tctx
, handle
);
996 /****************************************************************************
997 ****************************************************************************/
999 static BOOL
test_EachPrinter(struct torture_context
*tctx
,
1002 LPPRINTER_DEFAULTS defaults
)
1009 DWORD flags
= PRINTER_ENUM_NAME
;
1010 PPRINTER_INFO_1 buffer
= NULL
;
1013 torture_comment(tctx
, "Testing EnumPrinters level %d", 1);
1015 EnumPrinters(flags
, servername
, 1, NULL
, 0, &needed
, &returned
);
1016 err
= GetLastError();
1017 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1019 buffer
= (PPRINTER_INFO_1
)malloc(needed
);
1020 torture_assert(tctx
, buffer
, "malloc failed");
1021 if (!EnumPrinters(flags
, servername
, 1, (LPBYTE
)buffer
, needed
, &needed
, &returned
)) {
1022 err
= GetLastError();
1026 sprintf(tmp
, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
1027 1, servername
, needed
, errstr(err
));
1028 torture_fail(tctx
, tmp
);
1031 for (i
=0; i
< returned
; i
++) {
1032 ret
&= test_OnePrinter(tctx
, buffer
[i
].pName
, architecture
, defaults
);
1040 /****************************************************************************
1041 ****************************************************************************/
1043 static BOOL
test_GetPrintProcessorDirectory(struct torture_context
*tctx
,
1047 DWORD levels
[] = { 1 };
1048 DWORD success
[] = { 1 };
1050 LPBYTE buffer
= NULL
;
1052 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
1058 torture_comment(tctx
, "Testing GetPrintProcessorDirectory level %d", levels
[i
]);
1060 GetPrintProcessorDirectory(servername
, architecture
, levels
[i
], NULL
, 0, &needed
);
1061 err
= GetLastError();
1062 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1064 buffer
= malloc(needed
);
1065 torture_assert(tctx
, buffer
, "malloc failed");
1066 if (!GetPrintProcessorDirectory(servername
, architecture
, levels
[i
], buffer
, needed
, &needed
)) {
1067 err
= GetLastError();
1071 sprintf(tmp
, "GetPrintProcessorDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
1072 levels
[i
], servername
, needed
, errstr(err
));
1074 torture_fail(tctx
, tmp
);
1076 torture_warning(tctx
, tmp
);
1081 printf("\tPrint Processor Directory\t= %s\n\n", (LPSTR
)buffer
);
1091 /****************************************************************************
1092 ****************************************************************************/
1094 static BOOL
test_GetPrinterDriverDirectory(struct torture_context
*tctx
,
1098 DWORD levels
[] = { 1 };
1099 DWORD success
[] = { 1 };
1101 LPBYTE buffer
= NULL
;
1103 for (i
=0; i
< ARRAY_SIZE(levels
); i
++) {
1109 torture_comment(tctx
, "Testing GetPrinterDriverDirectory level %d", levels
[i
]);
1111 GetPrinterDriverDirectory(servername
, architecture
, levels
[i
], NULL
, 0, &needed
);
1112 err
= GetLastError();
1113 if (err
== ERROR_INSUFFICIENT_BUFFER
) {
1115 buffer
= malloc(needed
);
1116 torture_assert(tctx
, buffer
, "malloc failed");
1117 if (!GetPrinterDriverDirectory(servername
, architecture
, levels
[i
], buffer
, needed
, &needed
)) {
1118 err
= GetLastError();
1122 sprintf(tmp
, "GetPrinterDriverDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
1123 levels
[i
], servername
, needed
, errstr(err
));
1125 torture_fail(tctx
, tmp
);
1127 torture_warning(tctx
, tmp
);
1132 printf("\tPrinter Driver Directory\t= %s\n\n", (LPSTR
)buffer
);
1142 /****************************************************************************
1143 ****************************************************************************/
1145 static BOOL
test_GetPrinterData(struct torture_context
*tctx
,
1153 LPBYTE buffer
= NULL
;
1159 torture_comment(tctx
, "Testing GetPrinterData(%s)", valuename
);
1161 err
= GetPrinterData(handle
, valuename
, &type
, NULL
, 0, &needed
);
1162 if (err
== ERROR_MORE_DATA
) {
1163 buffer
= (LPBYTE
)malloc(needed
);
1164 torture_assert(tctx
, buffer
, "malloc failed");
1165 err
= GetPrinterData(handle
, valuename
, &type
, buffer
, needed
, &needed
);
1168 sprintf(tmp
, "GetPrinterData(%s) failed on [%s] (buffer size = %d), error: %s\n",
1169 valuename
, servername
, needed
, errstr(err
));
1170 torture_fail(tctx
, tmp
);
1174 print_printer_data("PrinterDriverData", valuename
, needed
, buffer
, type
);
1194 /****************************************************************************
1195 ****************************************************************************/
1197 static BOOL
test_GetPrinterDataEx(struct torture_context
*tctx
,
1206 LPBYTE buffer
= NULL
;
1212 torture_comment(tctx
, "Testing GetPrinterDataEx(%s - %s)", keyname
, valuename
);
1214 err
= GetPrinterDataEx(handle
, keyname
, valuename
, &type
, NULL
, 0, &needed
);
1215 if (err
== ERROR_MORE_DATA
) {
1216 buffer
= (LPBYTE
)malloc(needed
);
1217 torture_assert(tctx
, buffer
, "malloc failed");
1218 err
= GetPrinterDataEx(handle
, keyname
, valuename
, &type
, buffer
, needed
, &needed
);
1221 sprintf(tmp
, "GetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
1222 valuename
, servername
, needed
, errstr(err
));
1223 torture_fail(tctx
, tmp
);
1227 print_printer_data(keyname
, valuename
, needed
, buffer
, type
);
1247 /****************************************************************************
1248 ****************************************************************************/
1250 static BOOL
test_DeletePrinterDataEx(struct torture_context
*tctx
,
1259 torture_comment(tctx
, "Testing DeletePrinterDataEx(%s - %s)", keyname
, valuename
);
1261 err
= DeletePrinterDataEx(handle
, keyname
, valuename
);
1263 sprintf(tmp
, "DeletePrinterDataEx(%s - %s) failed on [%s], error: %s\n",
1264 keyname
, valuename
, servername
, errstr(err
));
1265 torture_fail(tctx
, tmp
);
1271 /****************************************************************************
1272 ****************************************************************************/
1274 static BOOL
test_DeletePrinterKey(struct torture_context
*tctx
,
1282 torture_comment(tctx
, "Testing DeletePrinterKey(%s)", keyname
);
1284 err
= DeletePrinterKey(handle
, keyname
);
1286 sprintf(tmp
, "DeletePrinterKey(%s) failed on [%s], error: %s\n",
1287 keyname
, servername
, errstr(err
));
1288 torture_fail(tctx
, tmp
);
1294 /****************************************************************************
1295 ****************************************************************************/
1297 static BOOL
test_SetPrinterDataEx(struct torture_context
*tctx
,
1309 torture_comment(tctx
, "Testing SetPrinterDataEx(%s - %s)", keyname
, valuename
);
1311 err
= SetPrinterDataEx(handle
, keyname
, valuename
, type
, buffer
, offered
);
1313 sprintf(tmp
, "SetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
1314 valuename
, servername
, offered
, errstr(err
));
1315 torture_fail(tctx
, tmp
);
1321 /****************************************************************************
1322 ****************************************************************************/
1324 static BOOL
test_PrinterData_Server(struct torture_context
*tctx
,
1330 DWORD type
, type_ex
;
1331 LPBYTE buffer
, buffer_ex
;
1332 DWORD size
, size_ex
;
1333 LPSTR valuenames
[] = {
1334 SPLREG_DEFAULT_SPOOL_DIRECTORY
,
1335 SPLREG_MAJOR_VERSION
,
1336 SPLREG_MINOR_VERSION
,
1338 SPLREG_DNS_MACHINE_NAME
,
1339 SPLREG_ARCHITECTURE
,
1343 for (i
=0; i
< ARRAY_SIZE(valuenames
); i
++) {
1344 ret
&= test_GetPrinterData(tctx
, servername
, valuenames
[i
], handle
, &type
, &buffer
, &size
);
1345 ret
&= test_GetPrinterDataEx(tctx
, servername
, "random", valuenames
[i
], handle
, &type_ex
, &buffer_ex
, &size_ex
);
1346 torture_assert_int_equal(tctx
, type
, type_ex
, "type mismatch");
1347 torture_assert_int_equal(tctx
, size
, size_ex
, "size mismatch");
1348 torture_assert_mem_equal(tctx
, buffer
, buffer_ex
, size
, "buffer mismatch");
1356 /****************************************************************************
1357 ****************************************************************************/
1359 static BOOL
PrinterDataEqual(struct torture_context
*tctx
,
1360 DWORD type1
, DWORD type2
,
1361 DWORD size1
, DWORD size2
,
1362 LPBYTE buffer1
, LPBYTE buffer2
)
1364 torture_assert_int_equal(tctx
, type1
, type2
, "type mismatch");
1365 torture_assert_int_equal(tctx
, size1
, size2
, "size mismatch");
1366 torture_assert_mem_equal(tctx
, buffer1
, buffer2
, size1
, "buffer mismatch");
1371 /****************************************************************************
1372 ****************************************************************************/
1374 static BOOL
test_PrinterData(struct torture_context
*tctx
,
1378 LPSTR keyname
= "torture_key";
1379 LPSTR valuename
= "torture_value";
1381 DWORD type
, type_ex
;
1382 LPBYTE buffer
, buffer_ex
;
1383 DWORD size
, size_ex
;
1385 torture_comment(tctx
, "Testing PrinterData");
1389 buffer
= malloc(size
);
1398 ret
&= test_SetPrinterDataEx(tctx
, printername
, keyname
, valuename
, handle
, type
, buffer
, size
);
1399 ret
&= test_GetPrinterDataEx(tctx
, printername
, keyname
, valuename
, handle
, &type_ex
, &buffer_ex
, &size_ex
);
1401 ret
&= PrinterDataEqual(tctx
, type_ex
, type
, size_ex
, size
, buffer_ex
, buffer
);
1403 ret
&= test_DeletePrinterDataEx(tctx
, printername
, keyname
, valuename
, handle
);
1404 ret
&= test_DeletePrinterKey(tctx
, printername
, keyname
, handle
);
1411 /****************************************************************************
1412 ****************************************************************************/
1414 const char *get_string_param(const char *str
)
1418 p
= strchr(str
, '=');
1426 /****************************************************************************
1427 ****************************************************************************/
1429 int main(int argc
, char *argv
[])
1433 LPSTR architecture
= "Windows NT x86";
1434 HANDLE server_handle
;
1435 PRINTER_DEFAULTS defaults_admin
, defaults_use
;
1436 struct torture_context
*tctx
;
1440 fprintf(stderr
, "usage: %s <name> [print] [samba3] [architecture=ARCHITECTURE]\n\n", argv
[0]);
1441 fprintf(stderr
, "\t<name> can be a server or printer name URI\n");
1442 fprintf(stderr
, "\t[print] will print all data that has been retrieved\n");
1443 fprintf(stderr
, "\t from the printserver\n");
1444 fprintf(stderr
, "\t[samba3] will skip some tests samba servers are known\n");
1445 fprintf(stderr
, "\t not to have implemented\n");
1446 fprintf(stderr
, "\t[architecture=X] allows to define a specific\n");
1447 fprintf(stderr
, "\t architecture to test with. choose between:\n");
1448 fprintf(stderr
, "\t \"Windows NT x86\" or \"Windows x64\"\n");
1452 tctx
= malloc(sizeof(struct torture_context
));
1454 fprintf(stderr
, "out of memory\n");
1457 memset(tctx
, '\0', sizeof(*tctx
));
1459 servername
= argv
[1];
1461 for (i
=1; i
< argc
; i
++) {
1462 if (strcmp(argv
[i
], "print") == 0) {
1465 if (strcmp(argv
[i
], "samba3") == 0) {
1466 tctx
->samba3
= TRUE
;
1468 if (strncmp(argv
[i
], "architecture", strlen("architecture")) == 0) {
1469 architecture
= get_string_param(argv
[i
]);
1473 printf("Running testsuite with architecture: %s\n", architecture
);
1475 defaults_admin
.pDatatype
= NULL
;
1476 defaults_admin
.pDevMode
= NULL
;
1477 defaults_admin
.DesiredAccess
= PRINTER_ACCESS_ADMINISTER
;
1479 defaults_use
.pDatatype
= NULL
;
1480 defaults_use
.pDevMode
= NULL
;
1481 defaults_use
.DesiredAccess
= PRINTER_ACCESS_USE
;
1483 if ((servername
[0] == '\\') && (servername
[1] == '\\')) {
1484 LPSTR p
= servername
+2;
1486 if ((p2
= strchr(p
, '\\')) != NULL
) {
1487 ret
= test_OnePrinter(tctx
, servername
, architecture
, &defaults_admin
);
1492 ret
&= test_EnumPrinters(tctx
, servername
);
1493 ret
&= test_EnumDrivers(tctx
, servername
, architecture
);
1494 ret
&= test_OpenPrinter(tctx
, servername
, NULL
, &server_handle
);
1495 /* ret &= test_EnumPrinterKey(tctx, servername, server_handle, ""); */
1496 ret
&= test_PrinterData_Server(tctx
, servername
, server_handle
);
1497 ret
&= test_EnumForms(tctx
, servername
, server_handle
);
1498 ret
&= test_ClosePrinter(tctx
, server_handle
);
1499 ret
&= test_EnumPorts(tctx
, servername
);
1500 ret
&= test_EnumMonitors(tctx
, servername
);
1501 ret
&= test_EnumPrintProcessors(tctx
, servername
, architecture
);
1502 ret
&= test_EnumPrintProcessorDatatypes(tctx
, servername
);
1503 ret
&= test_GetPrintProcessorDirectory(tctx
, servername
, architecture
);
1504 ret
&= test_GetPrinterDriverDirectory(tctx
, servername
, architecture
);
1505 ret
&= test_EachPrinter(tctx
, servername
, architecture
, &defaults_admin
);
1509 if (tctx
->last_reason
) {
1510 fprintf(stderr
, "failed: %s\n", tctx
->last_reason
);
1516 printf("%s run successfully\n", argv
[0]);