static BOOL test_OpenPrinter(struct torture_context *tctx,
LPSTR printername,
- HANDLE handle)
+ LPPRINTER_DEFAULTS defaults,
+ LPHANDLE handle)
{
torture_comment(tctx, "Testing OpenPrinter(%s)", printername);
- if (!OpenPrinter(printername, handle, NULL)) {
+ if (!OpenPrinter(printername, handle, defaults)) {
char tmp[1024];
sprintf(tmp, "failed to open printer %s, error was: 0x%08x\n",
printername, GetLastError());
LPSTR servername,
LPSTR architecture)
{
- DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8 };
- DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 };
+ DWORD levels[] = { 1, 2, 3, 4, 5, 6 };
+ DWORD success[] = { 1, 1, 1, 1, 1, 1 };
DWORD i;
LPBYTE buffer = NULL;
}
}
+ if (tctx->print) {
+ print_driver_info_bylevel(levels[i], buffer, returned);
+ }
+
+ free(buffer);
+ buffer = NULL;
+ }
+
+ return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetForm(struct torture_context *tctx,
+ LPSTR servername,
+ HANDLE handle,
+ LPSTR formname)
+{
+ 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 err = 0;
+ char tmp[1024];
+
+ torture_comment(tctx, "Testing GetForm(%s) level %d", formname, levels[i]);
+
+ GetForm(handle, formname, levels[i], NULL, 0, &needed);
+ err = GetLastError();
+ if (err == ERROR_INSUFFICIENT_BUFFER) {
+ err = 0;
+ buffer = malloc(needed);
+ torture_assert(tctx, buffer, "malloc failed");
+ if (!GetForm(handle, formname, levels[i], buffer, needed, &needed)) {
+ err = GetLastError();
+ }
+ }
+ if (err) {
+ sprintf(tmp, "GetForm 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);
+ }
+ }
+
+ if (tctx->print) {
+ print_form_info_bylevel(levels[i], buffer, 1);
+ }
+
free(buffer);
buffer = NULL;
}
}
}
+ if (tctx->print) {
+ print_form_info_bylevel(levels[i], buffer, returned);
+ }
+
free(buffer);
buffer = NULL;
}
}
}
+ if (tctx->print) {
+ print_port_info_bylevel(levels[i], buffer, returned);
+ }
+
free(buffer);
buffer = NULL;
}
}
}
+ if (tctx->print) {
+ print_monitor_info_bylevel(levels[i], buffer, returned);
+ }
+
free(buffer);
buffer = NULL;
}
/****************************************************************************
****************************************************************************/
+static BOOL test_EnumPrinterKey(struct torture_context *tctx,
+ LPSTR servername,
+ HANDLE handle,
+ LPCSTR key)
+{
+ LPSTR buffer = NULL;
+ DWORD needed = 0;
+ DWORD err = 0;
+ char tmp[1024];
+
+ torture_comment(tctx, "Testing EnumPrinterKey(%s)", key);
+
+ err = EnumPrinterKey(handle, key, NULL, 0, &needed);
+ if (err == ERROR_MORE_DATA) {
+ buffer = (LPTSTR)malloc(needed);
+ torture_assert(tctx, buffer, "malloc failed");
+ err = EnumPrinterKey(handle, key, buffer, needed, &needed);
+ }
+ if (err) {
+ sprintf(tmp, "EnumPrinterKey(%s) failed on [%s] (buffer size = %d), error: %s\n",
+ key, servername, needed, errstr(err));
+ torture_fail(tctx, tmp);
+ }
+
+ if (tctx->print) {
+ print_printer_keys(buffer);
+ }
+
+ free(buffer);
+
+ return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
static BOOL test_GetPrinter(struct torture_context *tctx,
LPSTR printername,
HANDLE handle)
}
}
+ if (tctx->print) {
+ print_printer_info_bylevel(levels[i], buffer, 1);
+ }
+
free(buffer);
buffer = NULL;
}
LPSTR architecture,
HANDLE handle)
{
- DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8, 101};
- DWORD success[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
+ DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8 };
+ DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 };
DWORD i;
LPBYTE buffer = NULL;
}
}
+ if (tctx->print) {
+ print_driver_info_bylevel(levels[i], buffer, 1);
+ }
+
free(buffer);
buffer = NULL;
}
return TRUE;
}
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_EnumPrinterDataEx(struct torture_context *tctx,
+ LPSTR servername,
+ LPSTR keyname,
+ HANDLE handle,
+ LPBYTE *buffer_p,
+ DWORD *returned_p)
+{
+ LPBYTE buffer = NULL;
+ DWORD needed = 0;
+ DWORD returned = 0;
+ DWORD err = 0;
+ char tmp[1024];
+
+ torture_comment(tctx, "Testing EnumPrinterDataEx(%s)", keyname);
+
+ err = EnumPrinterDataEx(handle, keyname, NULL, 0, &needed, &returned);
+ if (err == ERROR_MORE_DATA) {
+ buffer = malloc(needed);
+ torture_assert(tctx, buffer, "malloc failed");
+ err = EnumPrinterDataEx(handle, keyname, buffer, needed, &needed, &returned);
+ }
+ if (err) {
+ sprintf(tmp, "EnumPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
+ keyname, servername, needed, errstr(err));
+ torture_fail(tctx, tmp);
+ }
+
+ if (tctx->print) {
+ DWORD i;
+ LPPRINTER_ENUM_VALUES v = (LPPRINTER_ENUM_VALUES)buffer;
+ for (i=0; i < returned; i++) {
+ print_printer_enum_values(&v[i]);
+ }
+ }
+
+ if (returned_p) {
+ *returned_p = returned;
+ }
+
+ if (buffer_p) {
+ *buffer_p = buffer;
+ } else {
+ free(buffer);
+ }
+
+ return TRUE;
+}
+
+
/****************************************************************************
****************************************************************************/
static BOOL test_OnePrinter(struct torture_context *tctx,
LPSTR printername,
- LPSTR architecture)
+ LPSTR architecture,
+ LPPRINTER_DEFAULTS defaults)
{
HANDLE handle;
BOOL ret = TRUE;
torture_comment(tctx, "Testing Printer %s", printername);
- ret &= test_OpenPrinter(tctx, printername, &handle);
+ ret &= test_OpenPrinter(tctx, printername, defaults, &handle);
ret &= test_GetPrinter(tctx, printername, handle);
ret &= test_GetPrinterDriver(tctx, printername, architecture, handle);
ret &= test_EnumForms(tctx, printername, handle);
ret &= test_EnumJobs(tctx, printername, handle);
+ ret &= test_EnumPrinterKey(tctx, printername, handle, "");
+ ret &= test_EnumPrinterKey(tctx, printername, handle, "PrinterDriverData");
+ ret &= test_EnumPrinterDataEx(tctx, printername, "PrinterDriverData", handle, NULL, NULL);
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,
- LPSTR architecture)
+ LPSTR architecture,
+ LPPRINTER_DEFAULTS defaults)
{
DWORD needed = 0;
DWORD returned = 0;
DWORD i;
DWORD flags = PRINTER_ENUM_NAME;
PPRINTER_INFO_1 buffer = NULL;
+ BOOL ret = TRUE;
torture_comment(tctx, "Testing EnumPrinters level %d", 1);
}
for (i=0; i < returned; i++) {
- torture_assert(tctx, test_OnePrinter(tctx, buffer[i].pName, architecture),
- "failed to test one printer");
+ ret &= test_OnePrinter(tctx, buffer[i].pName, architecture, defaults);
}
free(buffer);
- return TRUE;
+ return ret;
}
/****************************************************************************
return TRUE;
}
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetPrinterData(struct torture_context *tctx,
+ LPSTR servername,
+ LPSTR valuename,
+ HANDLE handle,
+ DWORD *type_p,
+ LPBYTE *buffer_p,
+ DWORD *size_p)
+{
+ LPBYTE buffer = NULL;
+ DWORD needed = 0;
+ DWORD type;
+ DWORD err = 0;
+ char tmp[1024];
+
+ torture_comment(tctx, "Testing GetPrinterData(%s)", valuename);
+
+ err = GetPrinterData(handle, valuename, &type, NULL, 0, &needed);
+ if (err == ERROR_MORE_DATA) {
+ buffer = (LPBYTE)malloc(needed);
+ torture_assert(tctx, buffer, "malloc failed");
+ err = GetPrinterData(handle, valuename, &type, buffer, needed, &needed);
+ }
+ if (err) {
+ sprintf(tmp, "GetPrinterData(%s) failed on [%s] (buffer size = %d), error: %s\n",
+ valuename, servername, needed, errstr(err));
+ torture_fail(tctx, tmp);
+ }
+
+ if (tctx->print) {
+ print_printer_data("PrinterDriverData", valuename, needed, buffer, type);
+ }
+
+ if (type_p) {
+ *type_p = type;
+ }
+
+ if (size_p) {
+ *size_p = needed;
+ }
+
+ if (buffer_p) {
+ *buffer_p = buffer;
+ } else {
+ free(buffer);
+ }
+
+ return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_GetPrinterDataEx(struct torture_context *tctx,
+ LPSTR servername,
+ LPSTR keyname,
+ LPSTR valuename,
+ HANDLE handle,
+ DWORD *type_p,
+ LPBYTE *buffer_p,
+ DWORD *size_p)
+{
+ LPBYTE buffer = NULL;
+ DWORD needed = 0;
+ DWORD type;
+ DWORD err = 0;
+ char tmp[1024];
+
+ torture_comment(tctx, "Testing GetPrinterDataEx(%s - %s)", keyname, valuename);
+
+ err = GetPrinterDataEx(handle, keyname, valuename, &type, NULL, 0, &needed);
+ if (err == ERROR_MORE_DATA) {
+ buffer = (LPBYTE)malloc(needed);
+ torture_assert(tctx, buffer, "malloc failed");
+ err = GetPrinterDataEx(handle, keyname, valuename, &type, buffer, needed, &needed);
+ }
+ if (err) {
+ sprintf(tmp, "GetPrinterDataEx(%s) failed on [%s] (buffer size = %d), error: %s\n",
+ valuename, servername, needed, errstr(err));
+ torture_fail(tctx, tmp);
+ }
+
+ if (tctx->print) {
+ print_printer_data(keyname, valuename, needed, buffer, type);
+ }
+
+ if (type_p) {
+ *type_p = type;
+ }
+
+ if (size_p) {
+ *size_p = needed;
+ }
+
+ if (buffer_p) {
+ *buffer_p = buffer;
+ } else {
+ free(buffer);
+ }
+
+ return TRUE;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL test_PrinterData(struct torture_context *tctx,
+ LPSTR servername,
+ HANDLE handle)
+{
+ BOOL ret = TRUE;
+ DWORD i;
+ DWORD type, type_ex;
+ LPBYTE buffer, buffer_ex;
+ DWORD size, size_ex;
+ LPSTR valuenames[] = {
+ SPLREG_DEFAULT_SPOOL_DIRECTORY,
+ SPLREG_MAJOR_VERSION,
+ SPLREG_MINOR_VERSION,
+ SPLREG_DS_PRESENT,
+ SPLREG_DNS_MACHINE_NAME,
+ SPLREG_ARCHITECTURE,
+ SPLREG_OS_VERSION
+ };
+
+ for (i=0; i < ARRAY_SIZE(valuenames); i++) {
+ ret &= test_GetPrinterData(tctx, servername, valuenames[i], handle, &type, &buffer, &size);
+ ret &= test_GetPrinterDataEx(tctx, servername, "random", valuenames[i], handle, &type_ex, &buffer_ex, &size_ex);
+ torture_assert_int_equal(tctx, type, type_ex, "type mismatch");
+ torture_assert_int_equal(tctx, size, size_ex, "size mismatch");
+ torture_assert_mem_equal(tctx, buffer, buffer_ex, size, "buffer mismatch");
+ free(buffer);
+ free(buffer_ex);
+ }
+
+ return ret;
+}
/****************************************************************************
****************************************************************************/
BOOL ret = FALSE;
LPSTR servername;
LPSTR architecture = "Windows NT x86";
- HANDLE handle;
+ HANDLE server_handle;
+ PRINTER_DEFAULTS defaults_admin, defaults_use;
struct torture_context *tctx;
if (argc < 2) {
}
}
+ defaults_admin.pDatatype = NULL;
+ defaults_admin.pDevMode = NULL;
+ defaults_admin.DesiredAccess = PRINTER_ACCESS_ADMINISTER;
+
+ defaults_use.pDatatype = NULL;
+ defaults_use.pDevMode = NULL;
+ defaults_use.DesiredAccess = PRINTER_ACCESS_USE;
+
ret &= test_EnumPrinters(tctx, servername);
ret &= test_EnumDrivers(tctx, servername, architecture);
- ret &= test_OpenPrinter(tctx, servername, &handle);
- ret &= test_EnumForms(tctx, servername, handle);
- ret &= test_ClosePrinter(tctx, handle);
+ ret &= test_OpenPrinter(tctx, servername, NULL, &server_handle);
+/* ret &= test_EnumPrinterKey(tctx, servername, server_handle, ""); */
+ ret &= test_PrinterData(tctx, servername, server_handle);
+ ret &= test_EnumForms(tctx, servername, server_handle);
+ ret &= test_ClosePrinter(tctx, server_handle);
ret &= test_EnumPorts(tctx, servername);
ret &= test_EnumMonitors(tctx, servername);
ret &= test_EnumPrintProcessors(tctx, servername, architecture);
ret &= test_EnumPrintProcessorDatatypes(tctx, servername);
ret &= test_GetPrintProcessorDirectory(tctx, servername, architecture);
ret &= test_GetPrinterDriverDirectory(tctx, servername, architecture);
- ret &= test_EachPrinter(tctx, servername, architecture);
- ret &= test_EachDriver(tctx, servername);
+ ret &= test_EachPrinter(tctx, servername, architecture, NULL);
if (!ret) {
if (tctx->last_reason) {
git.samba.org / ira / wip.git / blobdiff