From 487a03a1586e478baaadada184836be98c609aa0 Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Mon, 14 Dec 2009 23:54:42 +0100 Subject: testprogs: add win32 spoolss testsuite. Guenther --- testprogs/win32/spoolss/Makefile | 38 ++ testprogs/win32/spoolss/Makefile.mingw | 22 + testprogs/win32/spoolss/README | 1 + testprogs/win32/spoolss/error.c | 115 +++++ testprogs/win32/spoolss/error.h | 36 ++ testprogs/win32/spoolss/spoolss.c | 771 ++++++++++++++++++++++++++++++++ testprogs/win32/spoolss/spoolss.h | 50 +++ testprogs/win32/spoolss/string.h | 15 + testprogs/win32/spoolss/torture.c | 106 +++++ testprogs/win32/spoolss/torture.h | 91 ++++ testprogs/win32/spoolss/torture_proto.h | 32 ++ 11 files changed, 1277 insertions(+) create mode 100644 testprogs/win32/spoolss/Makefile create mode 100644 testprogs/win32/spoolss/Makefile.mingw create mode 100644 testprogs/win32/spoolss/README create mode 100644 testprogs/win32/spoolss/error.c create mode 100644 testprogs/win32/spoolss/error.h create mode 100644 testprogs/win32/spoolss/spoolss.c create mode 100644 testprogs/win32/spoolss/spoolss.h create mode 100644 testprogs/win32/spoolss/string.h create mode 100644 testprogs/win32/spoolss/torture.c create mode 100644 testprogs/win32/spoolss/torture.h create mode 100644 testprogs/win32/spoolss/torture_proto.h (limited to 'testprogs/win32/spoolss') diff --git a/testprogs/win32/spoolss/Makefile b/testprogs/win32/spoolss/Makefile new file mode 100644 index 0000000000..96efceacf4 --- /dev/null +++ b/testprogs/win32/spoolss/Makefile @@ -0,0 +1,38 @@ +CFLAGS = /nologo /Zi /MT /Gm- /W4 /FR /D_CRT_SECURE_NO_WARNINGS +LIBS = kernel32.lib gdi32.lib user32.lib shell32.lib \ + advapi32.lib ole32.lib ws2_32.lib rpcrt4.lib +WINSPOOL_LIBS = winspool.lib + +all: spoolss.exe + +.cpp.obj: + cl /c $(CFLAGS) $*.cpp + +.c.obj: + cl /c $(CFLAGS) $*.c + +clean: cleantmp + -del *.dll 2>nul + +cleantmp: + -del *~ *.o *.obj *.sbr *.bsc *.pdb *.lib *.ilk *.exp 2>nul + -del test_s.c test_c.c test.h 2>nul + +############################### +# helpers +############################### + +error.obj: error.c + +torture.obj: torture.c + +############################### +# binaries +############################### + +spoolss.obj: spoolss.c + +spoolss.exe: spoolss.obj error.obj torture.obj + cl $(CFLAGS) /Fe$@ spoolss.obj error.obj torture.obj \ + /link /incremental:no /subsystem:console $(LIBS) $(WINSPOOL_LIBS) + diff --git a/testprogs/win32/spoolss/Makefile.mingw b/testprogs/win32/spoolss/Makefile.mingw new file mode 100644 index 0000000000..82fc7ed488 --- /dev/null +++ b/testprogs/win32/spoolss/Makefile.mingw @@ -0,0 +1,22 @@ +MAKE=mingw32-make +CFLAGS=-I../../../ -I/usr/i686-pc-mingw32/sys-root/mingw/include +LDFLAGS=-L/usr/i686-pc-mingw32/sys-root/mingw/lib +CC=/usr/bin/i686-pc-mingw32-gcc +LIBS=-lwinspool + +all: spoolss.exe + +clean: + rm -vf *.exe tags + +ctags: + ctags `find . -name "*.[ch]" | grep -v include/proto.h` + ctags --c-kinds=-p -a `find /usr/i686-pc-mingw32/sys-root/mingw/include -name "*.[ch]" | grep -v /CVS/` + +proto: + mkproto.pl torture.c --private=torture_proto.h --public=torture_proto_pub.h --srcdir=. --builddir=. + +spoolss.exe: spoolss.c torture.c error.c + @echo Compiling spoolss.exe + @$(CC) $(CFLAGS) $(LDFLAGS) spoolss.c torture.c error.c $(LIBS) -o spoolss.exe + diff --git a/testprogs/win32/spoolss/README b/testprogs/win32/spoolss/README new file mode 100644 index 0000000000..9d6cf4b7fb --- /dev/null +++ b/testprogs/win32/spoolss/README @@ -0,0 +1 @@ +FIXME diff --git a/testprogs/win32/spoolss/error.c b/testprogs/win32/spoolss/error.c new file mode 100644 index 0000000000..e523c15864 --- /dev/null +++ b/testprogs/win32/spoolss/error.c @@ -0,0 +1,115 @@ +/* + Unix SMB/CIFS implementation. + test suite for spoolss rpc operations + + Copyright (C) Guenther Deschner 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "spoolss.h" + +const char *errstr(DWORD error) +{ + static char tmp[20]; + + switch (error) { + case ERROR_ACCESS_DENIED: + return "ERROR_ACCESS_DENIED"; + case ERROR_INVALID_PARAMETER: + return "ERROR_INVALID_PARAMETER"; + case ERROR_CALL_NOT_IMPLEMENTED: + return "ERROR_CALL_NOT_IMPLEMENTED"; + case ERROR_INSUFFICIENT_BUFFER: + return "ERROR_INSUFFICIENT_BUFFER"; + case ERROR_INVALID_NAME: + return "ERROR_INVALID_NAME"; + case ERROR_INVALID_LEVEL: + return "ERROR_INVALID_LEVEL"; + case ERROR_MORE_DATA: + return "ERROR_MORE_DATA"; +#ifdef ERROR_INVALID_DATATYPE + case ERROR_INVALID_DATATYPE: + return "ERROR_INVALID_DATATYPE"; +#endif + case ERROR_INVALID_ENVIRONMENT: + return "ERROR_INVALID_ENVIRONMENT"; + case ERROR_INVALID_PRINTER_COMMAND: + return "ERROR_INVALID_PRINTER_COMMAND"; + case ERROR_PRINTER_ALREADY_EXISTS: + return "ERROR_PRINTER_ALREADY_EXISTS"; + case ERROR_INVALID_PRINTER_NAME: + return "ERROR_INVALID_PRINTER_NAME"; + case ERROR_INVALID_PRIORITY: + return "ERROR_INVALID_PRIORITY"; + case ERROR_INVALID_SEPARATOR_FILE: + return "ERROR_INVALID_SEPARATOR_FILE"; + case ERROR_UNKNOWN_PRINTPROCESSOR: + return "ERROR_UNKNOWN_PRINTPROCESSOR"; + case ERROR_UNKNOWN_PRINTER_DRIVER: + return "ERROR_UNKNOWN_PRINTER_DRIVER"; + case ERROR_UNKNOWN_PORT: + return "ERROR_UNKNOWN_PORT"; + case ERROR_PRINTER_DRIVER_ALREADY_INSTALLED: + return "ERROR_PRINTER_DRIVER_ALREADY_INSTALLED"; + case ERROR_UNKNOWN_PRINT_MONITOR: + return "ERROR_UNKNOWN_PRINT_MONITOR"; + case ERROR_PRINTER_DRIVER_IN_USE: + return "ERROR_PRINTER_DRIVER_IN_USE"; + case ERROR_SPOOL_FILE_NOT_FOUND: + return "ERROR_SPOOL_FILE_NOT_FOUND"; + case ERROR_SPL_NO_STARTDOC: + return "ERROR_SPL_NO_STARTDOC"; + case ERROR_SPL_NO_ADDJOB: + return "ERROR_SPL_NO_ADDJOB"; + case ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED: + return "ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED"; + case ERROR_PRINT_MONITOR_ALREADY_INSTALLED: + return "ERROR_PRINT_MONITOR_ALREADY_INSTALLED"; + case ERROR_INVALID_PRINT_MONITOR: + return "ERROR_INVALID_PRINT_MONITOR"; + case ERROR_PRINT_MONITOR_IN_USE: + return "ERROR_PRINT_MONITOR_IN_USE"; + case ERROR_PRINTER_HAS_JOBS_QUEUED: + return "ERROR_PRINTER_HAS_JOBS_QUEUED"; + case ERROR_PRINTER_NOT_FOUND: + return "ERROR_PRINTER_NOT_FOUND"; + case ERROR_PRINTER_DRIVER_WARNED: + return "ERROR_PRINTER_DRIVER_WARNED"; + case ERROR_PRINTER_DRIVER_BLOCKED: + return "ERROR_PRINTER_DRIVER_BLOCKED"; +#ifdef ERROR_PRINTER_DRIVER_PACKAGE_IN_USE + case ERROR_PRINTER_DRIVER_PACKAGE_IN_USE: + return "ERROR_PRINTER_DRIVER_PACKAGE_IN_USE"; +#endif +#ifdef ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND + case ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND: + return "ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND"; +#endif +#ifdef ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED + case ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED: + return "ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED"; +#endif +#ifdef ERROR_PRINT_JOB_RESTART_REQUIRED + case ERROR_PRINT_JOB_RESTART_REQUIRED: + return "ERROR_PRINT_JOB_RESTART_REQUIRED"; +#endif + default: + break; + } + + sprintf(tmp, "0x%08x", error); + + return tmp; +} diff --git a/testprogs/win32/spoolss/error.h b/testprogs/win32/spoolss/error.h new file mode 100644 index 0000000000..581c1097c1 --- /dev/null +++ b/testprogs/win32/spoolss/error.h @@ -0,0 +1,36 @@ +/* + Unix SMB/CIFS implementation. + test suite for spoolss rpc operations + + Copyright (C) Guenther Deschner 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef ERROR_INVALID_PARAMETER +#define ERROR_INVALID_PARAMETER 87 +#endif + +#ifndef ERROR_INSUFFICIENT_BUFFER +#define ERROR_INSUFFICIENT_BUFFER 0x007a +#endif + +#if 0 +#ifdef STATUS_PENDING +#undef STATUS_PENDING +#define STATUS_PENDING 0x0103 +#endif +#endif + +const char *errstr(DWORD error); diff --git a/testprogs/win32/spoolss/spoolss.c b/testprogs/win32/spoolss/spoolss.c new file mode 100644 index 0000000000..200f89602b --- /dev/null +++ b/testprogs/win32/spoolss/spoolss.c @@ -0,0 +1,771 @@ +/* + Unix SMB/CIFS implementation. + test suite for spoolss rpc operations + + Copyright (C) Guenther Deschner 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/**************************************************************************** +****************************************************************************/ + +#include "spoolss.h" +#include "string.h" +#include "torture.h" + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_OpenPrinter(struct torture_context *tctx, + LPSTR printername, + HANDLE handle) +{ + torture_comment(tctx, "Testing OpenPrinter(%s)", printername); + + if (!OpenPrinter(printername, handle, NULL)) { + char tmp[1024]; + sprintf(tmp, "failed to open printer %s, error was: 0x%08x\n", + printername, GetLastError()); + torture_fail(tctx, tmp); + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_ClosePrinter(struct torture_context *tctx, + HANDLE handle) +{ + torture_comment(tctx, "Testing ClosePrinter"); + + if (!ClosePrinter(handle)) { + char tmp[1024]; + sprintf(tmp, "failed to close printer, error was: %s\n", + errstr(GetLastError())); + torture_fail(tctx, tmp); + } + + return TRUE; +} + + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumPrinters(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1, 2, 5 }; + DWORD success[] = { 1, 1, 1 }; + DWORD i; + DWORD flags = PRINTER_ENUM_NAME; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumPrinters level %d", levels[i]); + + EnumPrinters(flags, servername, levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumPrinters(flags, servername, levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumDrivers(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8 }; + DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumPrinterDrivers level %d", levels[i]); + + EnumPrinterDrivers(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumPrinterDrivers(servername, "Windows NT x86", levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumPrinterDrivers failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumForms(struct torture_context *tctx, + LPSTR servername, + HANDLE handle) +{ + DWORD levels[] = { 1, 2 }; + DWORD success[] = { 1, 0 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumForms level %d", levels[i]); + + EnumForms(handle, levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumForms(handle, levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumForms failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumPorts(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1, 2 }; + DWORD success[] = { 1, 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumPorts level %d", levels[i]); + + EnumPorts(servername, levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumPorts(servername, levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumPorts failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumMonitors(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1, 2 }; + DWORD success[] = { 1, 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumMonitors level %d", levels[i]); + + EnumMonitors(servername, levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumMonitors(servername, levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumMonitors failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumPrintProcessors(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1 }; + DWORD success[] = { 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumPrintProcessors level %d", levels[i]); + + EnumPrintProcessors(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumPrintProcessors(servername, "Windows NT x86", levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumPrintProcessors failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumPrintProcessorDatatypes(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1 }; + DWORD success[] = { 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumPrintProcessorDatatypes level %d", levels[i]); + + EnumPrintProcessorDatatypes(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumPrintProcessorDatatypes(servername, "Windows NT x86", levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumPrintProcessorDatatypes failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_GetPrinter(struct torture_context *tctx, + LPSTR printername, + HANDLE handle) +{ + DWORD levels[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing GetPrinter level %d", levels[i]); + + GetPrinter(handle, levels[i], NULL, 0, &needed); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!GetPrinter(handle, levels[i], buffer, needed, &needed)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "GetPrinter failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], printername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_GetPrinterDriver(struct torture_context *tctx, + LPSTR printername, + HANDLE handle) +{ + DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8, 101}; + DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing GetPrinterDriver level %d", levels[i]); + + GetPrinterDriver(handle, "Windows NT x86", levels[i], NULL, 0, &needed); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!GetPrinterDriver(handle, "Windows NT x86", levels[i], buffer, needed, &needed)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "GetPrinterDriver failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], printername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EnumJobs(struct torture_context *tctx, + LPSTR printername, + HANDLE handle) +{ + DWORD levels[] = { 1, 2, 3, 4 }; + DWORD success[] = { 1, 1, 1, 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing EnumJobs level %d", levels[i]); + + EnumJobs(handle, 0, 100, levels[i], NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumJobs(handle, 0, 100, levels[i], buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumJobs failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], printername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_OnePrinter(struct torture_context *tctx, + LPSTR printername) +{ + HANDLE handle; + BOOL ret = TRUE; + + torture_comment(tctx, "Testing Printer %s", printername); + + ret &= test_OpenPrinter(tctx, printername, &handle); + ret &= test_GetPrinter(tctx, printername, handle); + ret &= test_GetPrinterDriver(tctx, printername, handle); + ret &= test_EnumForms(tctx, printername, handle); + ret &= test_EnumJobs(tctx, printername, handle); + ret &= test_ClosePrinter(tctx, handle); + + return ret; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_OneDriver(struct torture_context *tctx, + LPSTR printername, + LPSTR drivername) +{ + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EachDriver(struct torture_context *tctx, + LPSTR servername) +{ + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_EachPrinter(struct torture_context *tctx, + LPSTR servername) +{ + DWORD needed = 0; + DWORD returned = 0; + DWORD err = 0; + char tmp[1024]; + DWORD i; + DWORD flags = PRINTER_ENUM_NAME; + PPRINTER_INFO_1 buffer = NULL; + + torture_comment(tctx, "Testing EnumPrinters level %d", 1); + + EnumPrinters(flags, servername, 1, NULL, 0, &needed, &returned); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = (PPRINTER_INFO_1)malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!EnumPrinters(flags, servername, 1, (LPBYTE)buffer, needed, &needed, &returned)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "EnumPrinters failed level %d on [%s] (buffer size = %d), error: %s\n", + 1, servername, needed, errstr(err)); + torture_fail(tctx, tmp); + } + + for (i=0; i < returned; i++) { + torture_assert(tctx, test_OnePrinter(tctx, buffer[i].pName), + "failed to test one printer"); + } + + free(buffer); + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_GetPrintProcessorDirectory(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1 }; + DWORD success[] = { 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing GetPrintProcessorDirectory level %d", levels[i]); + + GetPrintProcessorDirectory(servername, "Windows NT x86", levels[i], NULL, 0, &needed); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!GetPrintProcessorDirectory(servername, "Windows NT x86", levels[i], buffer, needed, &needed)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "GetPrintProcessorDirectory failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + +/**************************************************************************** +****************************************************************************/ + +static BOOL test_GetPrinterDriverDirectory(struct torture_context *tctx, + LPSTR servername) +{ + DWORD levels[] = { 1 }; + DWORD success[] = { 1 }; + DWORD i; + LPBYTE buffer = NULL; + + for (i=0; i < ARRAY_SIZE(levels); i++) { + + DWORD needed = 0; + DWORD err = 0; + char tmp[1024]; + + torture_comment(tctx, "Testing GetPrinterDriverDirectory level %d", levels[i]); + + GetPrinterDriverDirectory(servername, "Windows NT x86", levels[i], NULL, 0, &needed); + err = GetLastError(); + if (err == ERROR_INSUFFICIENT_BUFFER) { + err = 0; + buffer = malloc(needed); + torture_assert(tctx, buffer, "malloc failed"); + if (!GetPrinterDriverDirectory(servername, "Windows NT x86", levels[i], buffer, needed, &needed)) { + err = GetLastError(); + } + } + if (err) { + sprintf(tmp, "GetPrinterDriverDirectory failed level %d on [%s] (buffer size = %d), error: %s\n", + levels[i], servername, needed, errstr(err)); + if (success[i]) { + torture_fail(tctx, tmp); + } else { + torture_warning(tctx, tmp); + } + } + + free(buffer); + buffer = NULL; + } + + return TRUE; +} + + +/**************************************************************************** +****************************************************************************/ + +int main(int argc, char *argv[]) +{ + BOOL ret = FALSE; + LPSTR servername; + HANDLE handle; + struct torture_context *tctx; + + if (argc < 2) { + fprintf(stderr, "usage: %s [print]\n", argv[0]); + exit(-1); + } + + tctx = malloc(sizeof(struct torture_context)); + if (!tctx) { + fprintf(stderr, "out of memory\n"); + exit(-1); + } + memset(tctx, '\0', sizeof(*tctx)); + + servername = argv[1]; + + if (argc >= 3) { + if (strcmp(argv[2], "print") == 0) { + tctx->print = TRUE; + } + } + + ret &= test_EnumPrinters(tctx, servername); + ret &= test_EnumDrivers(tctx, servername); + ret &= test_OpenPrinter(tctx, servername, &handle); + ret &= test_EnumForms(tctx, servername, handle); + ret &= test_ClosePrinter(tctx, handle); + ret &= test_EnumPorts(tctx, servername); + ret &= test_EnumMonitors(tctx, servername); + ret &= test_EnumPrintProcessors(tctx, servername); + ret &= test_EnumPrintProcessorDatatypes(tctx, servername); + ret &= test_GetPrintProcessorDirectory(tctx, servername); + ret &= test_GetPrinterDriverDirectory(tctx, servername); + ret &= test_EachPrinter(tctx, servername); + ret &= test_EachDriver(tctx, servername); + + if (!ret) { + if (tctx->last_reason) { + fprintf(stderr, "failed: %s\n", tctx->last_reason); + } + free(tctx); + return -1; + } + + printf("%s run successfully\n", argv[0]); + + free(tctx); + return 0; +} diff --git a/testprogs/win32/spoolss/spoolss.h b/testprogs/win32/spoolss/spoolss.h new file mode 100644 index 0000000000..adf178670f --- /dev/null +++ b/testprogs/win32/spoolss/spoolss.h @@ -0,0 +1,50 @@ +/* + Unix SMB/CIFS implementation. + test suite for spoolss rpc operations + + Copyright (C) Guenther Deschner 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#if 0 +#include "lib/replace/replace.h" +#endif + +#include +#include + +#include "error.h" + +#if 0 +#include "lib/talloc/talloc.h" +#include "libcli/util/ntstatus.h" +#include "lib/torture/torture.h" +#endif + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0])) +#endif + +#ifndef true +#define true TRUE +#endif + +#ifndef false +#define false FALSE +#endif + +#ifndef PRINTER_ENUM_NAME +#define PRINTER_ENUM_NAME 8 +#endif diff --git a/testprogs/win32/spoolss/string.h b/testprogs/win32/spoolss/string.h new file mode 100644 index 0000000000..17561eb7ad --- /dev/null +++ b/testprogs/win32/spoolss/string.h @@ -0,0 +1,15 @@ +/* __location__ macro replacement taken from talloc.h */ + +/* + this uses a little trick to allow __LINE__ to be stringified +*/ +#ifndef __location__ +#define __STRING_LINE1__(s) #s +#define __STRING_LINE2__(s) __STRING_LINE1__(s) +#define __STRING_LINE3__ __STRING_LINE2__(__LINE__) +#define __location__ __FILE__ ":" __STRING_LINE3__ +#endif + +#ifndef __STRING +#define __STRING(s) #s +#endif diff --git a/testprogs/win32/spoolss/torture.c b/testprogs/win32/spoolss/torture.c new file mode 100644 index 0000000000..27872a6ccc --- /dev/null +++ b/testprogs/win32/spoolss/torture.c @@ -0,0 +1,106 @@ +/* + Unix SMB/CIFS implementation. + SMB torture UI functions + + Copyright (C) Jelmer Vernooij 2006 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "spoolss.h" +#include "torture.h" + +/**************************************************************************** +****************************************************************************/ + +void torture_warning(struct torture_context *context, const char *comment, ...) +{ + va_list ap; + char tmp[1024]; + +#if 0 + if (!context->results->ui_ops->warning) + return; +#endif + + va_start(ap, comment); + if (vsprintf(tmp, comment, ap) == -1) { + return; + } + va_end(ap); + + fprintf(stderr, "WARNING: %s\n", tmp); +#if 0 + context->results->ui_ops->warning(context, tmp); + + free(tmp); +#endif +} + +/**************************************************************************** +****************************************************************************/ + +void torture_result(struct torture_context *context, + enum torture_result result, const char *fmt, ...) +{ + va_list ap; + char tmp[1024]; + + va_start(ap, fmt); + + if (context->last_reason) { + torture_warning(context, "%s", context->last_reason); + free(context->last_reason); + context->last_reason = NULL; + } + + context->last_result = result; + if (vsprintf(tmp, fmt, ap) == -1) { + return; + } + context->last_reason = malloc(sizeof(tmp)); + if (!context->last_reason) { + return; + } + memcpy(context->last_reason, tmp, sizeof(tmp)); + + va_end(ap); +} + +/**************************************************************************** +****************************************************************************/ + +void torture_comment(struct torture_context *context, const char *comment, ...) +{ + va_list ap; + char tmp[1024]; +#if 0 + if (!context->results->ui_ops->comment) + return; +#endif + va_start(ap, comment); + if (vsprintf(tmp, comment, ap) == -1) { + return; + } + va_end(ap); + +#if 0 + context->results->ui_ops->comment(context, tmp); +#endif + fprintf(stdout, "%s\n", tmp); + +#if 0 + free(tmp); +#endif +} diff --git a/testprogs/win32/spoolss/torture.h b/testprogs/win32/spoolss/torture.h new file mode 100644 index 0000000000..23746cc2b7 --- /dev/null +++ b/testprogs/win32/spoolss/torture.h @@ -0,0 +1,91 @@ +/* + Unix SMB/CIFS implementation. + SMB torture UI functions + + Copyright (C) Jelmer Vernooij 2006 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef __TORTURE_UI_H__ +#define __TORTURE_UI_H__ + +/**************************************************************************** +****************************************************************************/ + +enum torture_result { + TORTURE_OK=0, + TORTURE_FAIL=1, + TORTURE_ERROR=2, + TORTURE_SKIP=3 +}; + +struct torture_context { + enum torture_result last_result; + char *last_reason; + BOOL print; +}; + +/**************************************************************************** +****************************************************************************/ + +#define torture_assert(torture_ctx,expr,cmt) do {\ + if (!(expr)) {\ + torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \ + return false;\ + }\ +} while(0) + +#define torture_assert_str_equal(torture_ctx,got,expected,cmt)\ + do { const char *__got = (got), *__expected = (expected); \ + if (strcmp_safe(__got, __expected) != 0) { \ + torture_result(torture_ctx, TORTURE_FAIL, \ + __location__": "#got" was %s, expected %s: %s", \ + __got, __expected, cmt); \ + return false; \ + } \ + } while(0) + +#define torture_assert_int_equal(torture_ctx,got,expected,cmt)\ + do { int __got = (got), __expected = (expected); \ + if (__got != __expected) { \ + torture_result(torture_ctx, TORTURE_FAIL, \ + __location__": "#got" was %d, expected %d: %s", \ + __got, __expected, cmt); \ + return false; \ + } \ + } while(0) + +#define torture_assert_mem_equal(torture_ctx,got,expected,len,cmt)\ + do { const void *__got = (got), *__expected = (expected); \ + if (memcmp(__got, __expected, len) != 0) { \ + torture_result(torture_ctx, TORTURE_FAIL, \ + __location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \ + return false; \ + } \ + } while(0) + +#define torture_skip(torture_ctx,cmt) do {\ + torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\ + return true; \ + } while(0) + +#define torture_fail(torture_ctx,cmt) do {\ + torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\ + return false; \ + } while (0) + +#include "torture_proto.h" + +#endif diff --git a/testprogs/win32/spoolss/torture_proto.h b/testprogs/win32/spoolss/torture_proto.h new file mode 100644 index 0000000000..5d1dd8804b --- /dev/null +++ b/testprogs/win32/spoolss/torture_proto.h @@ -0,0 +1,32 @@ +#ifndef __TORTURE_PROTO_H__ +#define __TORTURE_PROTO_H__ + +#undef _PRINTF_ATTRIBUTE +#define _PRINTF_ATTRIBUTE(a1, a2) PRINTF_ATTRIBUTE(a1, a2) +/* This file was automatically generated by mkproto.pl. DO NOT EDIT */ + +/* this file contains prototypes for functions that are private + * to this subsystem or library. These functions should not be + * used outside this particular subsystem! */ + + +/* The following definitions come from torture.c */ + + +/**************************************************************************** +****************************************************************************/ +void torture_warning(struct torture_context *context, const char *comment, ...); + +/**************************************************************************** +****************************************************************************/ +void torture_result(struct torture_context *context, + enum torture_result result, const char *fmt, ...); + +/**************************************************************************** +****************************************************************************/ +void torture_comment(struct torture_context *context, const char *comment, ...); +#undef _PRINTF_ATTRIBUTE +#define _PRINTF_ATTRIBUTE(a1, a2) + +#endif /* __TORTURE_PROTO_H__ */ + -- cgit