New Testsuite for GetDefaultPrinter and GetPrinterDriverDirectory
Added:
+ Test Printing Environments for GetPrinterDriverDirectory
+ More intensive Testing.
+ Verbose Output with "WINETEST_DEBUG" > 1
* More tests will follow.
If the Patch is to Large (i already removed the Unicode-Tests)
i can split the Testsuite, but this will reduce the amount of testing,
compared to the current CVS.
Changelog:
- New Testsuite for winspool.drv:
GetDefaultPrinterA and
GetPrinterDriverDirectoryA (with different environments)
- Verbose Output with "WINETEST_DEBUG" > 1
--
By By ...
... Detlef
--- /dev/null 2005-09-25 11:44:34.245335448 +0200
+++ dlls/winspool/tests/drivers.c 2005-09-26 01:17:34.315283344 +0200
@@ -0,0 +1,617 @@
+/*
+ * Copyright 2005 Detlef Riekenberg
+ *
+ * some parts based on
+ * Copyright (C) 2003, 2004 Stefan Leichter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdarg.h>
+#include <wine/test.h>
+#include <winuser.h>
+
+#include "winspool_test.h"
+
+
+/* ############################
+ *
+ * PARAMETERS
+ * LPWSTR servername [I]
+ * LPWSTR environment [I]
+ * DWORD level [I]
+ * LPWSTR buffer [O]
+ * DWORD buffersize [I]
+ * LPDWORD needed_size [I] (bytes)
+ *
+ */
+
+static DWORD (WINAPI *pGetPrinterDriverDirectoryA) \
+ (LPSTR, LPSTR, DWORD, LPSTR, DWORD, LPDWORD);
+
+
+/* #####################################################
+ *
+ */
+
+VOID test_GetPrinterDriverDirectoryA(DWORD envindex)
+{
+ LPSTR buffer;
+ LPSTR bufferoverflow;
+ LPSTR env;
+ DWORD exactbytes;
+ DWORD exactsize;
+ DWORD result;
+ DWORD size;
+
+
+ pGetPrinterDriverDirectoryA = (void *) GetProcAddress(hwinspool,
+ "GetPrinterDriverDirectoryA");
+ if(opt_verbose)
+ {
+ trace("%p: %s,pGetPrinterDriverDirectoryA\n",
+ pGetPrinterDriverDirectoryA, debugstr_a(winspool_nameA));
+ }
+
+
+ if(pGetPrinterDriverDirectoryA == NULL)
+ {
+ pGetPrinterDriverDirectoryA = (void *) GetProcAddress(hwinspool,
+ "GetPrinterDriverDirectory");
+ if(opt_verbose)
+ {
+ trace("%p: %s,pGetPrinterDriverDirectory\n",
+ pGetPrinterDriverDirectoryA, debugstr_a(winspool_nameA));
+ }
+ }
+
+ ok((pGetPrinterDriverDirectoryA != NULL),
+ "GetPrinterDriverDirectoryA not exported\n");
+
+ if(pGetPrinterDriverDirectoryA == NULL)
+ {
+ return ;
+ }
+
+
+ env = (LPSTR) environment_tableA[envindex];
+ trace("%08lx: Environment is %s\n", envindex, debugstr_a(env));
+
+
+ /* Default Usage */
+ size=0;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, NULL, 0, &size);
+ lasterror = GetLastError();
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, NULL, 0, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, (DWORD) 0, size);
+ }
+ is_result_ok(FALSE);
+
+ if((result == FALSE) && (lasterror == ERROR_INVALID_ENVIRONMENT))
+ {
+ if((envindex > ENVIRONMENT_WIN40) && (sys_isNT == FALSE))
+ {
+
+ /* In Win9x, only NULL and "Windows 4.0" are supported */
+ if(opt_verbose)
+ {
+ trace("%08lx: Environment %s not supported\n",
+ envindex, debugstr_a(env));
+ }
+ }else
+ {
+
+ /* "Windows NT IA64" was added in WinXPsp2 and Win2003 */
+ if(envindex == ENVIRONMENT_IA64)
+ {
+ if(opt_verbose)
+ {
+ trace("%08lx: Environment %s not supported\n",
+ envindex, debugstr_a(env));
+ }
+ }else
+ {
+ todo_wine ok(0, "%08lx: Environment %s not supported\n",
+ envindex, debugstr_a(env));
+ }
+ }
+ return;
+ }
+
+ if((result == FALSE) && (lasterror == RPC_S_SERVER_UNAVAILABLE))
+ {
+ trace("The Service 'Print Spooler' is required for this Test\n");
+ return;
+ }
+
+ is_lasterror_ok(ERROR_INSUFFICIENT_BUFFER);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* remember the required buffersize */
+ exactsize = size;
+ exactbytes = size;
+
+
+ /* alloc the buffer */
+ size = exactbytes + overflow_reserved;
+ do_dead();
+ buffer = HeapAlloc(GetProcessHeap(), 0, size);
+ lasterror=GetLastError();
+ if(opt_verbose)
+ {
+ trace("%p: HeapAlloc(%p, 0, 0x%lx/%ld) => (0x%lx/%ld)\n", buffer,
+ GetProcessHeap(), size, size, lasterror, lasterror);
+
+ put_lasterror();
+ }
+ ok(buffer != NULL, "allocating 0x%ld/%ld Bytes for Buffer => (0x%lx/%ld)\n",
+ size, size, lasterror, lasterror);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+ if(buffer == NULL)
+ {
+ return;
+ }
+
+ bufferoverflow = (LPSTR)buffer + exactbytes;
+
+
+ /* Test for BUG in wine and correct the buggy Value */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, exactsize-1, &size);
+ lasterror = GetLastError();
+ if((result == FALSE) &&
+ (check_buffer_touched(buffer, exactbytes) == (LPBYTE)buffer) &&
+ (size == (lstrlenA(buffer)+2)) )
+ {
+ todo_wine
+ {
+ ok(0,
+ "BUG in wine: returned 'need_size' (0x%lx/%ld) was 1 Byte to Large\n",
+ exactsize, exactsize);
+
+ exactsize--;
+ exactbytes--;
+ bufferoverflow--;
+ }
+ }
+
+
+ /* everything NULL/zero */
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 0, NULL, 0, NULL);
+ lasterror = GetLastError();
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 0, NULL, 0, NULL)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ lasterror, lasterror);
+ put_lasterror();
+ }
+ is_result_ok(FALSE);
+ is_lasterror_ok2(ERROR_INSUFFICIENT_BUFFER, ERROR_INVALID_LEVEL);
+
+
+ /* size ok, but no buffer */
+ size = exactsize +1;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, NULL, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, NULL, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ exactsize + 1, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize +1, size);
+ }
+
+ if( (result != FALSE) &&
+ (lasterror == ERROR_INVALID_PARAMETER) &&
+ (sys_isNT == FALSE) )
+ {
+ trace("BUG in win9x: Returning 'SUCCESS' with ERROR_INVALID_PARAMETER\n");
+
+ }else
+ {
+ todo_wine is_result_ok(FALSE);
+ todo_wine is_lasterror_ok(ERROR_INVALID_USER_BUFFER);
+
+ /* This fails before NT4.0 */
+ if((size != 0) && (opt_verbose))
+ {
+ trace("returned size 0x%lx/%ld (must be 0x%x/%d)\n",
+ size, size, 0, 0);
+ }
+ }
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+
+
+ /* level, buffer and size ok, but "LPDWORD needed_size" is NULL */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+ size = exactsize;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, size, NULL);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, %p, %ld, NULL)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, size, lasterror, lasterror);
+ put_lasterror();
+ }
+
+ if( (result != FALSE) &&
+ (lasterror == NO_ERROR) &&
+ (sys_isNT == FALSE) )
+ {
+ trace("BUG in win9x: Returning 'SUCCESS' with NO_ERROR," \
+ " but LPDWORD is NULL\n");
+
+ }else
+ {
+ is_result_ok(FALSE);
+ todo_wine is_lasterror_ok(RPC_X_NULL_REF_POINTER);
+ warn_buffer_touched((LPBYTE) buffer, exactbytes);
+ is_overflowarea_ok(bufferoverflow);
+ }
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+
+ /* with a buffer, but size of buffer = 0 */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = 0;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, %p, 0, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, (DWORD) 0, size);
+ }
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INSUFFICIENT_BUFFER);
+ todo_wine
+ {
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+ }
+ warn_buffer_touched((LPBYTE)buffer, exactbytes);
+ is_overflowarea_ok(bufferoverflow);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* with a buffer, but size of buffer 1 Byte to small */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = exactsize-1;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, %p, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, exactsize-1, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize-1, size);
+ }
+
+
+
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INSUFFICIENT_BUFFER);
+ todo_wine
+ {
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+ }
+ warn_buffer_touched((LPBYTE)buffer, exactbytes);
+ is_overflowarea_ok(bufferoverflow);
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+
+ /* with a buffer, but size of buffer 1 Byte to large */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = exactsize+1;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, %p, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, exactsize+1, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize+1, size);
+ }
+ is_result_ok(TRUE);
+ todo_wine
+ {
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+ }
+
+ /* This fails on win9x */
+ if( (memcmp(bufferoverflow, overflow_ok, overflow_reserved) != 0) &&
+ (sys_isNT == FALSE))
+ {
+ if(opt_verbose)
+ {
+ trace ("INFO for win9x: the supplied buffer is touched more than needed\n");
+ }
+ }else
+ {
+ is_overflowarea_ok(bufferoverflow);
+ }
+
+ result = (lstrlenA(buffer)+1);
+ ok((result == exactsize) || ((result+result) == exactsize) ,
+ "returned required size was 0x%lx/%ld (data need 0x%lx /%ld Byte)\n",
+ exactsize, exactsize, result, result);
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+
+ /* with a buffer, but level is invalid (to small) */
+ if(opt_verbose)
+ {
+ trace("test with invalid Levels\n");
+ }
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = exactsize+1;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 0, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 0, %p, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, exactsize+1, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize+1, size);
+ }
+
+
+ /* Test for BUG in win9x and wine: Level not checked */
+ if((result != FALSE) && (lstrlenA(buffer) == (exactsize-1)) )
+ {
+ /* we found the BUG, but display only a message for win9x */
+ if(sys_isNT == FALSE)
+ {
+ trace("BUG in win9x and wine: Invalid Level '0' is not checked " \
+ "(valid Level is '1')\n");
+ }else
+ {
+ todo_wine
+ {
+ ok(0, "BUG in win9x and wine: Invalid Level '0' is not checked " \
+ "(valid Level is '1')\n");
+ }
+ }
+ }else
+ {
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INVALID_LEVEL);
+ warn_size_touched((exactsize+1));
+ warn_buffer_touched((LPBYTE) buffer, exactbytes);
+ is_overflowarea_ok(bufferoverflow);
+
+ }
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+
+ /* with a buffer, but level is invalid (to large) */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = exactsize+1;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 2, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 2, %p, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, exactsize+1, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize+1, size);
+ }
+
+
+ /* Test for BUG in win9x and wine: Level not checked */
+ if((result != FALSE) && (lstrlenA(buffer) == (exactsize-1)))
+ {
+ /* we found the BUG, but display only a message for win9x */
+ if(sys_isNT == FALSE)
+ {
+ trace("BUG in win9x and wine: Invalid Level '2' is not checked " \
+ "(valid Level is '1')\n");
+ }else
+ {
+ todo_wine
+ {
+ ok(0, "BUG in win9x and wine: Invalid Level '2' is not checked " \
+ "(valid Level is '1')\n");
+ }
+ }
+ }else
+ {
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INVALID_LEVEL);
+ warn_size_touched((exactsize+1));
+ warn_buffer_touched((LPBYTE) buffer, exactbytes);
+ is_overflowarea_ok(bufferoverflow);
+ }
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+
+ /* The Environment is case insensitive. */
+ env = clone_cstrA(environment_tableA[envindex]);
+ if(env != NULL)
+ {
+ CharLowerA(env);
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = exactsize;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, %p, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, exactsize, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize, size);
+ trace("%p: buffer: %s\n", buffer, debugstr_a(buffer));
+ }
+ is_result_ok(TRUE);
+
+
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+
+ is_overflowarea_ok(bufferoverflow);
+
+ free_strA(env);
+ }
+ env = (LPSTR) environment_tableA[envindex];
+
+
+
+ /* test normal use */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+
+ size = exactsize;
+ do_dead();
+ result = pGetPrinterDriverDirectoryA(NULL, env, 1, buffer, size, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetPrinterDriverDirectoryA(NULL, %s, 1, %p, %ld, %p)" \
+ " => (0x%lx/%ld)\n", result, debugstr_a(env),
+ buffer, exactsize, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize, size);
+ trace("%p: buffer: %s\n", buffer, debugstr_a(buffer));
+ }
+ todo_wine
+ {
+ is_result_ok(TRUE);
+
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+ }
+ is_overflowarea_ok(bufferoverflow);
+
+ result = (lstrlenA(buffer)+1) ;
+ ok((result == exactsize) || ((result+result) == exactsize) ,
+ "returned required size was 0x%lx/%ld (data need 0x%lx /%ld Byte)\n",
+ exactsize, exactsize, result, result);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+ HeapFree(GetProcessHeap(), 0, buffer);
+
+}
+
+/* ############################
+ *
+ */
+
+START_TEST(drivers)
+{
+ DWORD envindex;
+ if(create_test_environment() == NO_ERROR)
+ {
+ for(envindex = 0; envindex <= ENVIRONMENT_MAX; envindex++)
+ {
+ test_GetPrinterDriverDirectoryA(envindex);
+ }
+ }
+ shutdown_test_environment();
+}
+
--- /dev/null 2005-09-25 11:44:34.245335448 +0200
+++ dlls/winspool/tests/printers.c 2005-09-26 01:10:33.990182472 +0200
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2005 Detlef Riekenberg
+ *
+ * some parts based on
+ * Copyright (C) 2003, 2004 Stefan Leichter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdarg.h>
+#include <wine/test.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+#include "winspool_test.h"
+
+
+/* ############################
+ *
+ * PARAMETERS
+ * LPWSTR buffer [O]
+ * LPDWORD buffersize [I/O] (number of CHAR / WCHAR incl. zero)
+ *
+ */
+
+
+static DWORD (WINAPI *pGetDefaultPrinterA)(LPSTR, LPDWORD);
+
+
+/* ############################
+ *
+ */
+
+VOID test_GetDefaultPrinterA(VOID)
+{
+ LPSTR buffer;
+ LPSTR bufferoverflow;
+ DWORD exactbytes;
+ DWORD exactsize;
+ DWORD result;
+ DWORD size;
+
+
+ pGetDefaultPrinterA = (void *)GetProcAddress(hwinspool, "GetDefaultPrinterA");
+ if(opt_verbose)
+ {
+ trace("%p: %s,pGetDefaultPrinterA\n", pGetDefaultPrinterA, debugstr_a(winspool_nameA));
+ }
+ if (pGetDefaultPrinterA == NULL)
+ {
+ pGetDefaultPrinterA = (void *)GetProcAddress(hwinspool, "GetDefaultPrinter");
+ if(opt_verbose)
+ {
+ trace("%p: %s,pGetDefaultPrinter\n", pGetDefaultPrinterA, debugstr_a(winspool_nameA));
+ }
+ }
+
+ /* This Fuction is not present before win98 and before w2k */
+ if(pGetDefaultPrinterA == NULL)
+ {
+ return ;
+ }
+
+
+ /* everything NULL/zero */
+ do_dead();
+ result = pGetDefaultPrinterA(NULL, NULL);
+ lasterror = GetLastError();
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(NULL, NULL) => (0x%lx/%ld)\n",
+ result, lasterror, lasterror);
+ put_lasterror();
+
+ }
+
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INVALID_PARAMETER);
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* Default Usage */
+ size = 0;
+ do_dead();
+ result = pGetDefaultPrinterA(NULL, &size);
+ lasterror = GetLastError();
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(NULL, %p) => (0x%lx/%ld)\n",
+ result, &size, lasterror, lasterror);
+
+ put_lasterror();
+ trace("%p: old=%ld, new = %ld\n", &size, (DWORD) 0, size);
+ }
+ is_result_ok(FALSE);
+
+ ok(((lasterror == ERROR_FILE_NOT_FOUND) ||
+ (lasterror == ERROR_INVALID_NAME) ||
+ (lasterror == ERROR_INSUFFICIENT_BUFFER)),
+ "GetLastError() returned 0x%lx/%ld "\
+ "(must be 0x%x/%d, 0x%x/%d or 0x%x/%d)\n", lasterror, lasterror,
+ ERROR_FILE_NOT_FOUND, ERROR_FILE_NOT_FOUND, ERROR_INVALID_NAME,
+ ERROR_INVALID_NAME, ERROR_INSUFFICIENT_BUFFER, ERROR_INSUFFICIENT_BUFFER);
+
+
+ if((lasterror == ERROR_FILE_NOT_FOUND) || (lasterror == ERROR_INVALID_NAME))
+ {
+ trace("FIXME: Verify (with EnumPrinters), that we have no Printers\n");
+ trace("For this tests, a default printer must be set\n");
+ return ;
+ }
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+ /* remember the required buffersize */
+ exactbytes = size;
+ exactsize = size;
+
+ /* alloc the buffer */
+ size += overflow_reserved;
+ do_dead();
+ buffer = HeapAlloc(GetProcessHeap(), 0, size);
+ lasterror=GetLastError();
+ if(opt_verbose)
+ {
+ trace("%p: HeapAlloc(%p, 0, 0x%lx/%ld) => (0x%lx/%ld)\n", buffer,
+ GetProcessHeap(), size, size, lasterror, lasterror);
+
+ put_lasterror();
+ }
+ ok(buffer != NULL, "allocating 0x%ld/%ld Bytes for Buffer => (0x%lx/%ld)\n",
+ size, size, lasterror, lasterror);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+ if(buffer == NULL)
+ {
+ return;
+ }
+
+ bufferoverflow = (LPBYTE)buffer + exactbytes;
+
+
+ /* size ok, but no buffer */
+ size=exactsize+1;
+ do_dead();
+ result = pGetDefaultPrinterA(NULL, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(NULL, %p) => (0x%lx/%ld)\n", result,
+ &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, (DWORD) exactsize+1, size);
+ }
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INSUFFICIENT_BUFFER);
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* with a buffer, but size of buffer = 0 */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+ size = 0;
+ do_dead();
+ result = pGetDefaultPrinterA(buffer, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(%p, %p) => (0x%lx/%ld)\n", result,
+ buffer, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, (DWORD) 0, size);
+ }
+
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INSUFFICIENT_BUFFER);
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+
+ warn_buffer_touched((LPBYTE)buffer, exactbytes);
+ is_overflowarea_ok(bufferoverflow);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* with a buffer, but size of buffer 1 Byte to small */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+ size = exactsize-1;
+ do_dead();
+ result = pGetDefaultPrinterA(buffer, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(%p, %p) => (0x%lx/%ld)\n", result,
+ buffer, &size, lasterror, lasterror);
+ put_lasterror();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize-1, size);
+ }
+
+ is_result_ok(FALSE);
+ is_lasterror_ok(ERROR_INSUFFICIENT_BUFFER);
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+
+ is_overflowarea_ok(bufferoverflow);
+ warn_buffer_touched((LPBYTE)buffer, exactbytes);
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* with a buffer, but size of buffer 1 Byte to large */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+ size = exactsize+1;
+ do_dead();
+ result = pGetDefaultPrinterA(buffer, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(%p, %p) => (0x%lx/%ld)\n", result,
+ buffer, &size, lasterror, lasterror);
+ put_error();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize+1, size);
+ trace("%p: buffer: %s\n", buffer, debugstr_a(buffer));
+ }
+
+ is_result_ok(TRUE);
+ warn_lasterror_touched(MAGIC_DEAD);
+
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+ is_overflowarea_ok(bufferoverflow);
+
+ result = strlen(buffer)+1;
+ ok(result == exactsize,
+ "returned required size was 0x%lx/%ld (data need 0x%lx /%ld Byte)\n",
+ exactsize, exactsize, result, result);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ /* test normal use */
+ FillMemory(buffer, exactbytes, MAGIC_FILL);
+ CopyMemory(bufferoverflow, overflow_ok, overflow_reserved);
+ size = exactsize;
+ do_dead();
+ result = pGetDefaultPrinterA(buffer, &size);
+ lasterror = GetLastError();
+
+ if(opt_verbose)
+ {
+ trace("%08lx: GetDefaultPrinterA(%p, %p) => (0x%lx/%ld)\n", result,
+ buffer, &size, lasterror, lasterror);
+ put_error();
+ trace("%p: oldsize=%ld, newsize=%ld\n", &size, exactsize, size);
+ trace("%p: buffer: %s\n", buffer, debugstr_a(buffer));
+ }
+
+ is_result_ok(TRUE);
+ warn_lasterror_touched(MAGIC_DEAD);
+
+ ok(size == exactsize, "returned size 0x%lx/%ld (must be 0x%lx /%ld)\n",
+ size, size, exactsize, exactsize);
+
+ is_overflowarea_ok(bufferoverflow);
+
+ if(opt_verbose)
+ {
+ trace("-----\n");
+ }
+
+
+ trace("FIXME: Verify (with EnumPrinters), that the Printer %s is valid\n",
+ debugstr_a(buffer));
+
+
+ HeapFree(GetProcessHeap(), 0, buffer);
+}
+
+
+/* ############################
+ *
+ */
+
+
+START_TEST(printers)
+{
+ if(create_test_environment() == NO_ERROR)
+ {
+ test_GetDefaultPrinterA();
+
+ }
+ shutdown_test_environment();
+}
+
--- /dev/null 2005-09-25 11:44:34.245335448 +0200
+++ dlls/winspool/tests/winspool_test.h 2005-09-26 01:10:28.407031240 +0200
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2005 Detlef Riekenberg
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdarg.h>
+
+#include <wine/test.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "wingdi.h"
+#include "winnls.h"
+#include "winreg.h"
+
+#include "winspool.h"
+
+
+/* ################################################### */
+/* Setting up the Environment for testing winspool.drv */
+/* ################################################### */
+
+/* was SetLastError() used by the tested function? */
+#define MAGIC_DEAD 0x00dead00
+
+/* was the contents of the output-buffer modified? */
+#define MAGIC_FILL '#'
+
+
+#define DEBUGSTR_MAXLEN 1024
+#define LASTERROR_MAXLEN 1024
+
+extern CHAR lasterror_buffer[];
+extern CHAR pathname_buffer[];
+extern LPSTR winspool_nameA;
+
+
+/* valid printing environments */
+extern LPCSTR environment_tableA[];
+
+
+#define ENVIRONMENT_NULL 0
+#define ENVIRONMENT_WIN40 1
+#define ENVIRONMENT_W32X86 2
+#define ENVIRONMENT_IA64 3
+#define ENVIRONMENT_W32ALPHA 4
+#define ENVIRONMENT_W32PPC 5
+#define ENVIRONMENT_W32MIPS 6
+#define ENVIRONMENT_MAX ENVIRONMENT_W32MIPS
+
+
+/* definitions for Buffer-overflow check */
+extern LPSTR overflow_ok;
+extern LPSTR overflow_bad;
+extern DWORD overflow_reserved;
+
+
+/* was the contents of the output-buffer modified ? */
+extern LPBYTE firsttouchedptr;
+extern DWORD firsttouchedoffset;
+extern LPBYTE firstuntouchedptr;
+extern DWORD firstuntouchedoffset;
+
+
+/* ############################
+ *
+ */
+
+extern DWORD lasterror;
+extern DWORD opt_verbose;
+
+
+extern BOOL sys_isNT;
+
+/* ############################
+ *
+ */
+
+extern HMODULE hwinspool;
+
+
+/* ############################
+ *
+ */
+
+LPBYTE check_buffer_touched(LPBYTE buffer, SIZE_T len);
+
+
+LPSTR clone_strA(LPSTR what);
+#define clone_cstrA(what) clone_strA((LPSTR) what)
+
+
+
+LPSTR debugstr_a(LPSTR what);
+#define debugstr_ca(what) debugstr_a((LPSTR) what)
+
+
+
+static inline VOID do_dead()
+ {
+ SetLastError(MAGIC_DEAD);
+ }
+
+
+static inline VOID free_strW(LPWSTR what)
+{
+ if(what)
+ {
+ HeapFree(GetProcessHeap(), 0, what);
+ }
+}
+
+static inline VOID free_strA(LPSTR what)
+{
+ if(what)
+ {
+ HeapFree(GetProcessHeap(), 0, what);
+ }
+}
+
+
+
+BOOL is_error(DWORD ignorethis);
+
+
+#define is_lasterror_ok(value) \
+ ok(lasterror == value , \
+ "GetLastError() returned 0x%lx/%ld (must return 0x%x/%d %s)\n", \
+ lasterror, lasterror, value , value, debugstr_a( #value ))
+
+#define is_lasterror_ok2(value1, value2) \
+ ok((lasterror == value1) || (lasterror == value2) , \
+ "GetLastError() returned 0x%lx/%ld (must return " \
+ "0x%x/%d %s or 0x%x/%d %s)\n", lasterror, lasterror, \
+ value1 , value1, debugstr_a( #value1 ), \
+ value2 , value2, debugstr_a( #value2 ) )
+
+
+
+#define is_overflowarea_ok(overflowarea) \
+ ok(memcmp(overflowarea, overflow_ok, overflow_reserved) == 0 , \
+ "buffer overflow error at %p: %s\n", \
+ overflowarea, debugstr_a(overflowarea ))
+
+
+#define is_result_ok(value) \
+ ok(result == value , \
+ "function returned 0x%lx/%ld (must return 0x%x: %s), " \
+ "GetLastError() is 0x%lx,%ld\n", result, result, \
+ value, debugstr_a( #value ), lasterror, lasterror)
+
+
+/* ############################
+ *
+ */
+
+HMODULE loaddll(LPSTR dllname);
+
+
+VOID put_error_(const char * file, int line);
+#define put_error() put_error_(__FILE__, __LINE__)
+
+
+#define put_exclude(ignorethis) \
+ if(is_error(ignorethis)) \
+ { \
+ put_error_(__FILE__, __LINE__); \
+ }
+
+
+#define put_lasterror() put_exclude(NO_ERROR)
+
+
+
+VOID unloaddll(HMODULE * target);
+
+/* ############################
+ *
+ * Downgraded some tests ("ok" => "trace") of undocumented behaviours
+ * to show the Implementation-specific difference.
+ *
+ *
+ */
+
+#define warn_buffer_touched(buffer, bufferlen) \
+ { \
+ check_buffer_touched((LPBYTE)buffer, bufferlen); \
+ if((firsttouchedptr != NULL) && (opt_verbose))\
+ { \
+ trace("Undocumented: buffer touched at %p" \
+ " (%p + 0x%lx/%ld): %s\n", firsttouchedptr, \
+ buffer, firsttouchedoffset, firsttouchedoffset, \
+ debugstr_ca(firsttouchedptr) ); \
+ } \
+ }
+
+
+#define warn_lasterror_touched(value) \
+ if((lasterror != value) && (opt_verbose)) \
+ { \
+ trace("Undocumented: GetLastError() returned 0x%lx/%ld (touched 0x%08x %s)\n", \
+ lasterror, lasterror, value , debugstr_a( #value )); \
+ }
+
+
+#define warn_size_touched(value) \
+ if((size != value) && (opt_verbose)) \
+ { \
+ trace("Undocumented: returned size: 0x%lx/%ld (touched 0x%lx/%ld)\n", \
+ size, size, value , value); \
+ }
+
+
+/* ############################
+ *
+ */
+
+DWORD create_test_environment(VOID);
+VOID shutdown_test_environment(VOID);
+
+
+/* ############################
+ *
+ */
+
? dlls/winspool/tests/drivers.c
? dlls/winspool/tests/printers.c
? dlls/winspool/tests/winspool_test.h
Index: dlls/winspool/tests/.cvsignore
===================================================================
RCS file: /home/wine/wine/dlls/winspool/tests/.cvsignore,v
retrieving revision 1.2
diff -u -r1.2 .cvsignore
--- dlls/winspool/tests/.cvsignore 2 Mar 2004 21:16:38 -0000 1.2
+++ dlls/winspool/tests/.cvsignore 25 Sep 2005 23:28:39 -0000
@@ -1,3 +1,5 @@
Makefile
+drivers.ok
info.ok
+printers.ok
testlist.c
Index: dlls/winspool/tests/Makefile.in
===================================================================
RCS file: /home/wine/wine/dlls/winspool/tests/Makefile.in,v
retrieving revision 1.1
diff -u -r1.1 Makefile.in
--- dlls/winspool/tests/Makefile.in 15 Jan 2003 00:50:48 -0000 1.1
+++ dlls/winspool/tests/Makefile.in 25 Sep 2005 23:28:39 -0000
@@ -3,10 +3,17 @@
SRCDIR = @srcdir@
VPATH = @srcdir@
TESTDLL = winspool.drv
-IMPORTS = winspool kernel32
+IMPORTS = kernel32 user32
+EXTRALIBS =
CTESTS = \
- info.c
+ drivers.c \
+ info.c \
+ printers.c
+
+
+EXTRA_SRCS = winspool_test.h
+
@MAKE_TEST_RULES@
Index: dlls/winspool/tests/info.c
===================================================================
RCS file: /home/wine/wine/dlls/winspool/tests/info.c,v
retrieving revision 1.9
diff -u -r1.9 info.c
--- dlls/winspool/tests/info.c 16 Jun 2004 20:07:02 -0000 1.9
+++ dlls/winspool/tests/info.c 25 Sep 2005 23:28:39 -0000
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2003, 2004 Stefan Leichter
+ * Copyright 2005 Detlef Riekenberg
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -17,158 +17,364 @@
*/
#include <stdarg.h>
+#include <wine/test.h>
+#include <winbase.h>
+#include <winuser.h>
-#include "wine/test.h"
-#include "windef.h"
-#include "winbase.h"
-#include "winerror.h"
-#include "wingdi.h"
-#include "winspool.h"
-
-static void test_default_printer(void)
-{
-#define DEFAULT_PRINTER_SIZE 1000
- BOOL retval;
- DWORD exact = DEFAULT_PRINTER_SIZE;
- DWORD size;
- FARPROC func = NULL;
- HMODULE lib = NULL;
- char buffer[DEFAULT_PRINTER_SIZE];
-
- lib = GetModuleHandleA("winspool.drv");
- if (!lib) {
- ok( 0, "GetModuleHandleA(\"winspool.drv\") failed\n");
- return;
- }
-
- func = GetProcAddress( lib, "GetDefaultPrinterA");
- if (!func)
- /* only supported on NT like OSes starting with win2k */
- return;
-
- SetLastError(ERROR_SUCCESS);
- retval = func( buffer, &exact);
- if (!retval || !exact || !strlen(buffer) ||
- (ERROR_SUCCESS != GetLastError())) {
- if ((ERROR_FILE_NOT_FOUND == GetLastError()) ||
- (ERROR_INVALID_NAME == GetLastError()))
- trace("this test requires a default printer to be set\n");
- else {
- ok( 0, "function call GetDefaultPrinterA failed unexpected!\n"
- "function returned %s\n"
- "last error 0x%08lx\n"
- "returned buffer size 0x%08lx\n"
- "returned buffer content %s\n",
- retval ? "true" : "false", GetLastError(), exact, buffer);
- }
- return;
- }
- SetLastError(ERROR_SUCCESS);
- retval = func( NULL, NULL);
- ok( !retval, "function result wrong! False expected\n");
- ok( ERROR_INVALID_PARAMETER == GetLastError(),
- "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08lx\n",
- GetLastError());
-
- SetLastError(ERROR_SUCCESS);
- retval = func( buffer, NULL);
- ok( !retval, "function result wrong! False expected\n");
- ok( ERROR_INVALID_PARAMETER == GetLastError(),
- "Last error wrong! ERROR_INVALID_PARAMETER expected, got 0x%08lx\n",
- GetLastError());
-
- SetLastError(ERROR_SUCCESS);
- size = 0;
- retval = func( NULL, &size);
- ok( !retval, "function result wrong! False expected\n");
- ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
- "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08lx\n",
- GetLastError());
- ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
- exact, size);
-
- SetLastError(ERROR_SUCCESS);
- size = DEFAULT_PRINTER_SIZE;
- retval = func( NULL, &size);
- ok( !retval, "function result wrong! False expected\n");
- ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
- "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08lx\n",
- GetLastError());
- ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
- exact, size);
-
- size = 0;
- retval = func( buffer, &size);
- ok( !retval, "function result wrong! False expected\n");
- ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
- "Last error wrong! ERROR_INSUFFICIENT_BUFFER expected, got 0x%08lx\n",
- GetLastError());
- ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
- exact, size);
-
- size = exact;
- retval = func( buffer, &size);
- ok( retval, "function result wrong! True expected\n");
- ok( size == exact, "Parameter size wrong! %ld expected got %ld\n",
- exact, size);
-}
-
-static void test_printer_directory(void)
-{ LPBYTE buffer = NULL;
- DWORD cbBuf = 0, pcbNeeded = 0;
- BOOL res;
-
- res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, 0, &cbBuf);
- trace("GetPrinterDriverDirectoryA: first call returned 0x%04x, "
- "buffer size 0x%08lx\n", res, cbBuf);
-
- buffer = HeapAlloc( GetProcessHeap(), 0, cbBuf*2);
-
- res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf, &pcbNeeded);
- ok( res, "expected result != 0, got %d\n", res);
- ok( cbBuf == pcbNeeded, "pcbNeeded set to %ld instead of %ld\n",
- pcbNeeded, cbBuf);
-
- res = GetPrinterDriverDirectoryA(NULL, NULL, 1, buffer, cbBuf*2, &pcbNeeded);
- ok( res, "expected result != 0, got %d\n", res);
- ok( cbBuf == pcbNeeded, "pcbNeeded set to %ld instead of %ld\n",
- pcbNeeded, cbBuf);
-
- res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf-1, &pcbNeeded);
- ok( !res , "expected result == 0, got %d\n", res);
- ok( cbBuf == pcbNeeded, "pcbNeeded set to %ld instead of %ld\n",
- pcbNeeded, cbBuf);
- ok( ERROR_INSUFFICIENT_BUFFER == GetLastError(),
- "last error set to %ld instead of ERROR_INSUFFICIENT_BUFFER\n",
- GetLastError());
-
- res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, &pcbNeeded);
- ok( (!res && ERROR_INVALID_USER_BUFFER == GetLastError()) ||
- ( res && ERROR_INVALID_PARAMETER == GetLastError()) ,
- "expected either result == 0 and "
- "last error == ERROR_INVALID_USER_BUFFER "
- "or result != 0 and last error == ERROR_INVALID_PARAMETER "
- "got result %d and last error == %ld\n", res, GetLastError());
-
- res = GetPrinterDriverDirectoryA( NULL, NULL, 1, buffer, cbBuf, NULL);
- ok( (!res && RPC_X_NULL_REF_POINTER == GetLastError()) || res,
- "expected either result == 0 and "
- "last error == RPC_X_NULL_REF_POINTER or result != 0 "
- "got result %d and last error == %ld\n", res, GetLastError());
-
- res = GetPrinterDriverDirectoryA( NULL, NULL, 1, NULL, cbBuf, NULL);
- ok( (!res && RPC_X_NULL_REF_POINTER == GetLastError()) ||
- ( res && ERROR_INVALID_PARAMETER == GetLastError()) ,
- "expected either result == 0 and "
- "last error == RPC_X_NULL_REF_POINTER "
- "or result != 0 and last error == ERROR_INVALID_PARAMETER "
- "got result %d and last error == %ld\n", res, GetLastError());
+#include "winspool_test.h"
- HeapFree( GetProcessHeap(), 0, buffer);
+
+/* ################################################### */
+/* Setting up the Environment for testing winspool.drv */
+
+CHAR lasterror_buffer[LASTERROR_MAXLEN];
+CHAR pathname_buffer[MAX_PATH+MAX_PATH];
+
+LPSTR winspool_nameA = "winspool.drv";
+
+
+/* valid printing environments */
+
+LPCSTR environment_tableA[] = {NULL,
+ "Windows 4.0",
+ "Windows NT x86",
+ "Windows NT IA64",
+ "Windows NT Alpha_AXP",
+ "Windows NT PowerPC",
+ "Windows NT R4000", NULL};
+
+
+
+/* definitions for Buffer-overflow check */
+LPSTR overflow_ok = "ok\0\0\0\0";
+DWORD overflow_reserved = 6;
+
+/* was the contents of the output-buffer modified ? */
+LPBYTE firsttouchedptr=NULL;
+DWORD firsttouchedoffset=0;
+LPBYTE firstuntouchedptr=NULL;
+DWORD firstuntouchedoffset=0;
+
+/* ############################
+ *
+ */
+
+BOOL sys_isNT;
+
+DWORD lasterror = 0;
+DWORD opt_verbose = 0;
+
+
+/* ############################
+ *
+ */
+
+
+HMODULE hwinspool = NULL;
+
+/* ############################
+ *
+ */
+
+static CHAR debug_buffer[DEBUGSTR_MAXLEN + DEBUGSTR_MAXLEN];
+static CHAR * debug_data[] = {debug_buffer, &(debug_buffer[DEBUGSTR_MAXLEN]) };
+
+
+/* ############################
+ *
+ */
+
+LPBYTE check_buffer_touched(LPBYTE buffer, DWORD len)
+{
+
+ firsttouchedptr = NULL;
+ firsttouchedoffset = len;
+ firstuntouchedptr = buffer;
+ firstuntouchedoffset = 0;
+ CHAR * ptr = (CHAR *) buffer;
+
+ if(ptr != NULL)
+ {
+ while((len > 0) && (*ptr == MAGIC_FILL))
+ {
+ ptr++;
+ len--;
+ }
+
+ if(len > 0)
+ {
+ /* buffer is touched */
+ firsttouchedptr = ptr;
+ firsttouchedoffset -= len;
+
+ while((len > 0) && (*(ptr + len-1) == MAGIC_FILL))
+ {
+ len--;
+ }
+ firstuntouchedptr = & ptr[len];
+ firstuntouchedoffset = firsttouchedoffset + len;
+ }
+ }
+ return firsttouchedptr;
+}
+
+/* ############################
+ *
+ */
+
+LPSTR clone_strA(LPSTR what)
+{
+ LPSTR rc;
+ DWORD len;
+
+ if(what == NULL)
+ {
+ return NULL;
+ }
+
+ len = lstrlenA(what);
+ rc = HeapAlloc(GetProcessHeap(), 0, (len + 1));
+ if(rc)
+ {
+ CopyMemory(rc, what, len);
+ rc[len] = (CHAR) '\0' ;
+ }
+ return rc;
+}
+
+/* ############################
+ *
+ */
+
+LPSTR debugstr_a(LPSTR what)
+{
+ char * ptr;
+ INT len=0;
+ BOOL do_space = TRUE;
+
+ ptr=debug_data[0];
+
+ if (what != NULL)
+ {
+ if(HIWORD(what) != 0)
+ {
+ *ptr='"';
+ ptr++;
+ len = DEBUGSTR_MAXLEN - 9;
+ while((len > 0) && (*what))
+ {
+ if ((*what) == '\012' || (*what) == '\015')
+ {
+ if(do_space)
+ {
+ *ptr = ' ';
+ len--;
+ do_space = FALSE;
+ }
+ }else
+ {
+ if(((*what) < 127) && ((*what) > 31))
+ {
+ *ptr++ = (CHAR) *what;
+ len--;
+ do_space = TRUE;
+
+ }else
+ {
+ wsprintfA(ptr,"\\0x%02x", *what);
+ ptr +=5;
+ len -=5;
+ do_space = TRUE;
+ }
+ }
+ what++;
+ }
+ *ptr='"';
+ ptr++;
+ *ptr='\0';
+ }else
+ {
+ wsprintfA(ptr,"#%ld", (DWORD) what);
+
+ }
+ ptr=debug_data[0];
+ debug_data[0] = debug_data[1];
+ debug_data[1] = ptr;
+ return ptr;
+ }else
+ {
+ return "--NULL--";
+ }
+}
+
+
+/* ############################
+ *
+ */
+
+BOOL is_error(DWORD ignorethis)
+{
+ if((lasterror == MAGIC_DEAD) || (lasterror == ignorethis))
+ {
+ return FALSE;
+ }
+ return (lasterror != NO_ERROR);
+}
+
+
+/* ############################
+ *
+ */
+
+HMODULE loaddll(LPSTR dllname)
+{
+ HMODULE rc = NULL;
+
+
+ do_dead();
+ rc = LoadLibraryA(dllname);
+ lasterror = GetLastError();
+
+ if ((opt_verbose) || (rc == NULL))
+ {
+ trace("%p: LoadLibraryA(%s) => (0x%lx/%ld)\n", rc,
+ debugstr_a(dllname), lasterror, lasterror);
+ put_lasterror();
+ }
+ if(rc != NULL)
+ {
+ lasterror = NO_ERROR;
+ }
+ return rc;
+
+}
+
+
+/* ############################
+ *
+ * Use "trace_" to print the Result from GetLastError()
+ *
+ */
+
+VOID put_error_(const char * file, int line)
+{
+ INT status;
+
+ status = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
+ lasterror, 0, lasterror_buffer, LASTERROR_MAXLEN, NULL);
+ if(status)
+ {
+ trace_(file, line)("%08lx: (%ld) GetLastError() %s\n", lasterror, lasterror,
+ debugstr_a(lasterror_buffer));
+ }else
+ {
+ trace_(file, line)("0x%08lx: (%ld) GetLastError()\n", lasterror, lasterror);
+ }
+}
+
+
+
+
+/* ############################
+ *
+ */
+
+VOID unloaddll(HMODULE * target)
+{
+ HMODULE hdll;
+
+ hdll = *target;
+
+ if(hdll)
+ {
+ FreeLibrary(hdll);
+
+ }
+ *target = NULL;
+}
+
+
+
+/* ############################
+ *
+ */
+
+DWORD create_test_environment(VOID)
+{
+ DWORD result = NO_ERROR;
+
+ if (hwinspool == NULL)
+ {
+ HMODULE hntdll;
+ if(winetest_debug > 1)
+ {
+ opt_verbose = winetest_debug - 1;
+ }
+
+ hwinspool = loaddll(winspool_nameA);
+
+ ok(hwinspool != NULL, "LoadLibrary(%s) => 0x%lx/%ld\n",
+ debugstr_a(winspool_nameA), lasterror, lasterror);
+
+
+ /* some functions/options are not implemented in win9x */
+ sys_isNT = (GetVersion() < 0x80000000);
+
+ hntdll = LoadLibraryA("ntdll.dll");
+ if (hntdll != NULL)
+ {
+ static DWORD (WINAPI *pwine_server_call)(LPBYTE);
+
+ pwine_server_call = (VOID *) GetProcAddress(hntdll,
+ "wine_server_call");
+ if(pwine_server_call != NULL)
+ {
+ trace("#### Welcome to WINE ####\n");
+ sys_isNT = TRUE;
+ }
+ FreeLibrary(hntdll);
+ }
+
+
+ }
+
+ return result;
}
+
+/* ############################
+ *
+ */
+
+VOID shutdown_test_environment(VOID)
+{
+
+ unloaddll(&hwinspool);
+
+}
+
+
+
+/* ############################
+ *
+ */
+
+static void show_winetest_info(void)
+{
+
+ trace("%p: WINTEST_PLATFORM = %s\n", winetest_platform, debugstr_ca(winetest_platform));
+ trace("%08x: WINTEST_DEBUG = %d\n", winetest_debug, winetest_debug);
+ trace("%08x: WINTEST_INTERACTIVE = %d\n", winetest_interactive, winetest_interactive);
+ trace("%p: %s loaded\n", hwinspool, debugstr_a(winspool_nameA));
+}
+
+
START_TEST(info)
{
- test_default_printer();
- test_printer_directory();
+ if(create_test_environment() == NO_ERROR)
+ {
+ show_winetest_info();
+ }
+ shutdown_test_environment();
+
}
