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, 0 };
233 LPBYTE buffer = NULL;
235 for (i=0; i < ARRAY_SIZE(levels); i++) {
242 torture_comment(tctx, "Testing EnumForms level %d", levels[i]);
244 EnumForms(handle, levels[i], NULL, 0, &needed, &returned);
245 err = GetLastError();
246 if (err == ERROR_INSUFFICIENT_BUFFER) {
248 buffer = malloc(needed);
249 torture_assert(tctx, buffer, "malloc failed");
250 if (!EnumForms(handle, levels[i], buffer, needed, &needed, &returned)) {
251 err = GetLastError();
255 sprintf(tmp, "EnumForms failed level %d on [%s] (buffer size = %d), error: %s\n",
256 levels[i], servername, needed, errstr(err));
258 torture_fail(tctx, tmp);
260 torture_warning(tctx, tmp);
265 print_form_info_bylevel(levels[i], buffer, returned);
275 /****************************************************************************
276 ****************************************************************************/
278 static BOOL test_EnumPorts(struct torture_context *tctx,
281 DWORD levels[] = { 1, 2 };
282 DWORD success[] = { 1, 1 };
284 LPBYTE buffer = NULL;
286 for (i=0; i < ARRAY_SIZE(levels); i++) {
293 torture_comment(tctx, "Testing EnumPorts level %d", levels[i]);
295 EnumPorts(servername, levels[i], NULL, 0, &needed, &returned);
296 err = GetLastError();
297 if (err == ERROR_INSUFFICIENT_BUFFER) {
299 buffer = malloc(needed);
300 torture_assert(tctx, buffer, "malloc failed");
301 if (!EnumPorts(servername, levels[i], buffer, needed, &needed, &returned)) {
302 err = GetLastError();
306 sprintf(tmp, "EnumPorts failed level %d on [%s] (buffer size = %d), error: %s\n",
307 levels[i], servername, needed, errstr(err));
309 torture_fail(tctx, tmp);
311 torture_warning(tctx, tmp);
316 print_port_info_bylevel(levels[i], buffer, returned);
326 /****************************************************************************
327 ****************************************************************************/
329 static BOOL test_EnumMonitors(struct torture_context *tctx,
332 DWORD levels[] = { 1, 2 };
333 DWORD success[] = { 1, 1 };
335 LPBYTE buffer = NULL;
337 for (i=0; i < ARRAY_SIZE(levels); i++) {
344 torture_comment(tctx, "Testing EnumMonitors level %d", levels[i]);
346 EnumMonitors(servername, levels[i], NULL, 0, &needed, &returned);
347 err = GetLastError();
348 if (err == ERROR_INSUFFICIENT_BUFFER) {
350 buffer = malloc(needed);
351 torture_assert(tctx, buffer, "malloc failed");
352 if (!EnumMonitors(servername, levels[i], buffer, needed, &needed, &returned)) {
353 err = GetLastError();
357 sprintf(tmp, "EnumMonitors failed level %d on [%s] (buffer size = %d), error: %s\n",
358 levels[i], servername, needed, errstr(err));
360 torture_fail(tctx, tmp);
362 torture_warning(tctx, tmp);
367 print_monitor_info_bylevel(levels[i], buffer, returned);
377 /****************************************************************************
378 ****************************************************************************/
380 static BOOL test_EnumPrintProcessors(struct torture_context *tctx,
384 DWORD levels[] = { 1 };
385 DWORD success[] = { 1 };
387 LPBYTE buffer = NULL;
389 for (i=0; i < ARRAY_SIZE(levels); i++) {
396 torture_comment(tctx, "Testing EnumPrintProcessors level %d", levels[i]);
398 EnumPrintProcessors(servername, architecture, levels[i], NULL, 0, &needed, &returned);
399 err = GetLastError();
400 if (err == ERROR_INSUFFICIENT_BUFFER) {
402 buffer = malloc(needed);
403 torture_assert(tctx, buffer, "malloc failed");
404 if (!EnumPrintProcessors(servername, architecture, levels[i], buffer, needed, &needed, &returned)) {
405 err = GetLastError();
409 sprintf(tmp, "EnumPrintProcessors failed level %d on [%s] (buffer size = %d), error: %s\n",
410 levels[i], servername, needed, errstr(err));
412 torture_fail(tctx, tmp);
414 torture_warning(tctx, tmp);
419 print_printprocessor_info_bylevel(levels[i], buffer, returned);
429 /****************************************************************************
430 ****************************************************************************/
432 static BOOL test_EnumPrintProcessorDatatypes(struct torture_context *tctx,
435 DWORD levels[] = { 1 };
436 DWORD success[] = { 1 };
438 LPBYTE buffer = NULL;
440 for (i=0; i < ARRAY_SIZE(levels); i++) {
447 torture_comment(tctx, "Testing EnumPrintProcessorDatatypes level %d", levels[i]);
449 EnumPrintProcessorDatatypes(servername, "winprint", levels[i], NULL, 0, &needed, &returned);
450 err = GetLastError();
451 if (err == ERROR_INSUFFICIENT_BUFFER) {
453 buffer = malloc(needed);
454 torture_assert(tctx, buffer, "malloc failed");
455 if (!EnumPrintProcessorDatatypes(servername, "winprint", levels[i], buffer, needed, &needed, &returned)) {
456 err = GetLastError();
460 sprintf(tmp, "EnumPrintProcessorDatatypes failed level %d on [%s] (buffer size = %d), error: %s\n",
461 levels[i], servername, needed, errstr(err));
463 torture_fail(tctx, tmp);
465 torture_warning(tctx, tmp);
476 /****************************************************************************
477 ****************************************************************************/
479 static BOOL test_EnumPrinterKey(struct torture_context *tctx,
489 torture_comment(tctx, "Testing EnumPrinterKey(%s)", key);
491 err = EnumPrinterKey(handle, key, NULL, 0, &needed);
492 if (err == ERROR_MORE_DATA) {
493 buffer = (LPTSTR)malloc(needed);
494 torture_assert(tctx, buffer, "malloc failed");
495 err = EnumPrinterKey(handle, key, buffer, needed, &needed);
498 sprintf(tmp, "EnumPrinterKey(%s) failed on [%s] (buffer size = %d), error: %s\n",
499 key, servername, needed, errstr(err));
500 torture_fail(tctx, tmp);
504 print_printer_keys(buffer);
512 /****************************************************************************
513 ****************************************************************************/
515 static BOOL test_GetPrinter(struct torture_context *tctx,
519 DWORD levels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
520 DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
522 LPBYTE buffer = NULL;
524 for (i=0; i < ARRAY_SIZE(levels); i++) {
530 torture_comment(tctx, "Testing GetPrinter level %d", levels[i]);
532 GetPrinter(handle, levels[i], NULL, 0, &needed);
533 err = GetLastError();
534 if (err == ERROR_INSUFFICIENT_BUFFER) {
536 buffer = malloc(needed);
537 torture_assert(tctx, buffer, "malloc failed");
538 if (!GetPrinter(handle, levels[i], buffer, needed, &needed)) {
539 err = GetLastError();
543 sprintf(tmp, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n",
544 levels[i], printername, needed, errstr(err));
546 torture_fail(tctx, tmp);
548 torture_warning(tctx, tmp);
553 print_printer_info_bylevel(levels[i], buffer, 1);
563 /****************************************************************************
564 ****************************************************************************/
566 static BOOL test_GetPrinterDriver(struct torture_context *tctx,
571 DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8 };
572 DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 };
574 LPBYTE buffer = NULL;
576 for (i=0; i < ARRAY_SIZE(levels); i++) {
582 torture_comment(tctx, "Testing GetPrinterDriver level %d", levels[i]);
584 GetPrinterDriver(handle, architecture, levels[i], NULL, 0, &needed);
585 err = GetLastError();
586 if (err == ERROR_INSUFFICIENT_BUFFER) {
588 buffer = malloc(needed);
589 torture_assert(tctx, buffer, "malloc failed");
590 if (!GetPrinterDriver(handle, architecture, levels[i], buffer, needed, &needed)) {
591 err = GetLastError();
595 sprintf(tmp, "GetPrinterDriver failed level %d on [%s] (buffer size = %d), error: %s\n",
596 levels[i], printername, needed, errstr(err));
598 torture_fail(tctx, tmp);
600 torture_warning(tctx, tmp);
605 print_driver_info_bylevel(levels[i], buffer, 1);
616 /****************************************************************************
617 ****************************************************************************/
619 static BOOL test_EnumJobs(struct torture_context *tctx,
623 DWORD levels[] = { 1, 2, 3, 4 };
624 DWORD success[] = { 1, 1, 1, 1 };
626 LPBYTE buffer = NULL;
628 for (i=0; i < ARRAY_SIZE(levels); i++) {
635 torture_comment(tctx, "Testing EnumJobs level %d", levels[i]);
637 EnumJobs(handle, 0, 100, levels[i], NULL, 0, &needed, &returned);
638 err = GetLastError();
639 if (err == ERROR_INSUFFICIENT_BUFFER) {
641 buffer = malloc(needed);
642 torture_assert(tctx, buffer, "malloc failed");
643 if (!EnumJobs(handle, 0, 100, levels[i], buffer, needed, &needed, &returned)) {
644 err = GetLastError();
648 sprintf(tmp, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n",
649 levels[i], printername, needed, errstr(err));
651 torture_fail(tctx, tmp);
653 torture_warning(tctx, tmp);
664 /****************************************************************************
665 ****************************************************************************/
667 static BOOL test_EnumPrinterDataEx(struct torture_context *tctx,
674 LPBYTE buffer = NULL;
680 torture_comment(tctx, "Testing EnumPrinterDataEx(%s)", keyname);
682 err = EnumPrinterDataEx(handle, keyname, NULL, 0, &needed, &returned);
683 if (err == ERROR_MORE_DATA) {
684 buffer = malloc(needed);
685 torture_assert(tctx, buffer, "malloc failed");
686 err = EnumPrinterDataEx(handle, keyname, buffer, needed, &needed, &returned);
689 sprintf(tmp, "EnumPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
690 keyname, servername, needed, errstr(err));
691 torture_fail(tctx, tmp);
696 LPPRINTER_ENUM_VALUES v = (LPPRINTER_ENUM_VALUES)buffer;
697 for (i=0; i < returned; i++) {
698 print_printer_enum_values(&v[i]);
703 *returned_p = returned;
716 /****************************************************************************
717 ****************************************************************************/
719 static BOOL test_OnePrinter(struct torture_context *tctx,
722 LPPRINTER_DEFAULTS defaults)
727 torture_comment(tctx, "Testing Printer %s", printername);
729 ret &= test_OpenPrinter(tctx, printername, defaults, &handle);
730 ret &= test_GetPrinter(tctx, printername, handle);
731 ret &= test_GetPrinterDriver(tctx, printername, architecture, handle);
732 ret &= test_EnumForms(tctx, printername, handle);
733 ret &= test_EnumJobs(tctx, printername, handle);
734 ret &= test_EnumPrinterKey(tctx, printername, handle, "");
735 ret &= test_EnumPrinterKey(tctx, printername, handle, "PrinterDriverData");
736 ret &= test_EnumPrinterDataEx(tctx, printername, "PrinterDriverData", handle, NULL, NULL);
737 ret &= test_ClosePrinter(tctx, handle);
742 /****************************************************************************
743 ****************************************************************************/
745 static BOOL test_EachPrinter(struct torture_context *tctx,
748 LPPRINTER_DEFAULTS defaults)
755 DWORD flags = PRINTER_ENUM_NAME;
756 PPRINTER_INFO_1 buffer = NULL;
759 torture_comment(tctx, "Testing EnumPrinters level %d", 1);
761 EnumPrinters(flags, servername, 1, NULL, 0, &needed, &returned);
762 err = GetLastError();
763 if (err == ERROR_INSUFFICIENT_BUFFER) {
765 buffer = (PPRINTER_INFO_1)malloc(needed);
766 torture_assert(tctx, buffer, "malloc failed");
767 if (!EnumPrinters(flags, servername, 1, (LPBYTE)buffer, needed, &needed, &returned)) {
768 err = GetLastError();
772 sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n",
773 1, servername, needed, errstr(err));
774 torture_fail(tctx, tmp);
777 for (i=0; i < returned; i++) {
778 ret &= test_OnePrinter(tctx, buffer[i].pName, architecture, defaults);
786 /****************************************************************************
787 ****************************************************************************/
789 static BOOL test_GetPrintProcessorDirectory(struct torture_context *tctx,
793 DWORD levels[] = { 1 };
794 DWORD success[] = { 1 };
796 LPBYTE buffer = NULL;
798 for (i=0; i < ARRAY_SIZE(levels); i++) {
804 torture_comment(tctx, "Testing GetPrintProcessorDirectory level %d", levels[i]);
806 GetPrintProcessorDirectory(servername, architecture, levels[i], NULL, 0, &needed);
807 err = GetLastError();
808 if (err == ERROR_INSUFFICIENT_BUFFER) {
810 buffer = malloc(needed);
811 torture_assert(tctx, buffer, "malloc failed");
812 if (!GetPrintProcessorDirectory(servername, architecture, levels[i], buffer, needed, &needed)) {
813 err = GetLastError();
817 sprintf(tmp, "GetPrintProcessorDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
818 levels[i], servername, needed, errstr(err));
820 torture_fail(tctx, tmp);
822 torture_warning(tctx, tmp);
833 /****************************************************************************
834 ****************************************************************************/
836 static BOOL test_GetPrinterDriverDirectory(struct torture_context *tctx,
840 DWORD levels[] = { 1 };
841 DWORD success[] = { 1 };
843 LPBYTE buffer = NULL;
845 for (i=0; i < ARRAY_SIZE(levels); i++) {
851 torture_comment(tctx, "Testing GetPrinterDriverDirectory level %d", levels[i]);
853 GetPrinterDriverDirectory(servername, architecture, levels[i], NULL, 0, &needed);
854 err = GetLastError();
855 if (err == ERROR_INSUFFICIENT_BUFFER) {
857 buffer = malloc(needed);
858 torture_assert(tctx, buffer, "malloc failed");
859 if (!GetPrinterDriverDirectory(servername, architecture, levels[i], buffer, needed, &needed)) {
860 err = GetLastError();
864 sprintf(tmp, "GetPrinterDriverDirectory failed level %d on [%s] (buffer size = %d), error: %s\n",
865 levels[i], servername, needed, errstr(err));
867 torture_fail(tctx, tmp);
869 torture_warning(tctx, tmp);
880 /****************************************************************************
881 ****************************************************************************/
883 static BOOL test_GetPrinterData(struct torture_context *tctx,
891 LPBYTE buffer = NULL;
897 torture_comment(tctx, "Testing GetPrinterData(%s)", valuename);
899 err = GetPrinterData(handle, valuename, &type, NULL, 0, &needed);
900 if (err == ERROR_MORE_DATA) {
901 buffer = (LPBYTE)malloc(needed);
902 torture_assert(tctx, buffer, "malloc failed");
903 err = GetPrinterData(handle, valuename, &type, buffer, needed, &needed);
906 sprintf(tmp, "GetPrinterData(%s) failed on [%s] (buffer size = %d), error: %s\n",
907 valuename, servername, needed, errstr(err));
908 torture_fail(tctx, tmp);
912 print_printer_data("PrinterDriverData", valuename, needed, buffer, type);
932 /****************************************************************************
933 ****************************************************************************/
935 static BOOL test_GetPrinterDataEx(struct torture_context *tctx,
944 LPBYTE buffer = NULL;
950 torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)", keyname, valuename);
952 err = GetPrinterDataEx(handle, keyname, valuename, &type, NULL, 0, &needed);
953 if (err == ERROR_MORE_DATA) {
954 buffer = (LPBYTE)malloc(needed);
955 torture_assert(tctx, buffer, "malloc failed");
956 err = GetPrinterDataEx(handle, keyname, valuename, &type, buffer, needed, &needed);
959 sprintf(tmp, "GetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
960 valuename, servername, needed, errstr(err));
961 torture_fail(tctx, tmp);
965 print_printer_data(keyname, valuename, needed, buffer, type);
985 /****************************************************************************
986 ****************************************************************************/
988 static BOOL test_PrinterData(struct torture_context *tctx,
995 LPBYTE buffer, buffer_ex;
997 LPSTR valuenames[] = {
998 SPLREG_DEFAULT_SPOOL_DIRECTORY,
999 SPLREG_MAJOR_VERSION,
1000 SPLREG_MINOR_VERSION,
1002 SPLREG_DNS_MACHINE_NAME,
1003 SPLREG_ARCHITECTURE,
1007 for (i=0; i < ARRAY_SIZE(valuenames); i++) {
1008 ret &= test_GetPrinterData(tctx, servername, valuenames[i], handle, &type, &buffer, &size);
1009 ret &= test_GetPrinterDataEx(tctx, servername, "random", valuenames[i], handle, &type_ex, &buffer_ex, &size_ex);
1010 torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
1011 torture_assert_int_equal(tctx, size, size_ex, "size mismatch");
1012 torture_assert_mem_equal(tctx, buffer, buffer_ex, size, "buffer mismatch");
1020 /****************************************************************************
1021 ****************************************************************************/
1023 int main(int argc, char *argv[])
1027 LPSTR architecture = "Windows NT x86";
1028 HANDLE server_handle;
1029 PRINTER_DEFAULTS defaults_admin, defaults_use;
1030 struct torture_context *tctx;
1033 fprintf(stderr, "usage: %s <servername> [print]\n", argv[0]);
1037 tctx = malloc(sizeof(struct torture_context));
1039 fprintf(stderr, "out of memory\n");
1042 memset(tctx, '\0', sizeof(*tctx));
1044 servername = argv[1];
1047 if (strcmp(argv[2], "print") == 0) {
1052 defaults_admin.pDatatype = NULL;
1053 defaults_admin.pDevMode = NULL;
1054 defaults_admin.DesiredAccess = PRINTER_ACCESS_ADMINISTER;
1056 defaults_use.pDatatype = NULL;
1057 defaults_use.pDevMode = NULL;
1058 defaults_use.DesiredAccess = PRINTER_ACCESS_USE;
1060 ret &= test_EnumPrinters(tctx, servername);
1061 ret &= test_EnumDrivers(tctx, servername, architecture);
1062 ret &= test_OpenPrinter(tctx, servername, NULL, &server_handle);
1063 /* ret &= test_EnumPrinterKey(tctx, servername, server_handle, ""); */
1064 ret &= test_PrinterData(tctx, servername, server_handle);
1065 ret &= test_EnumForms(tctx, servername, server_handle);
1066 ret &= test_ClosePrinter(tctx, server_handle);
1067 ret &= test_EnumPorts(tctx, servername);
1068 ret &= test_EnumMonitors(tctx, servername);
1069 ret &= test_EnumPrintProcessors(tctx, servername, architecture);
1070 ret &= test_EnumPrintProcessorDatatypes(tctx, servername);
1071 ret &= test_GetPrintProcessorDirectory(tctx, servername, architecture);
1072 ret &= test_GetPrinterDriverDirectory(tctx, servername, architecture);
1073 ret &= test_EachPrinter(tctx, servername, architecture, NULL);
1076 if (tctx->last_reason) {
1077 fprintf(stderr, "failed: %s\n", tctx->last_reason);
1083 printf("%s run successfully\n", argv[0]);