Unix SMB/CIFS implementation.
test suite for spoolss rpc operations
- Copyright (C) Guenther Deschner 2009
+ Copyright (C) Guenther Deschner 2009-2010
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
****************************************************************************/
static BOOL test_EnumDrivers(struct torture_context *tctx,
- LPSTR servername)
+ LPSTR servername,
+ LPSTR architecture)
{
DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8 };
DWORD success[] = { 1, 1, 1, 1, 1, 1, 1 };
torture_comment(tctx, "Testing EnumPrinterDrivers level %d", levels[i]);
- EnumPrinterDrivers(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned);
+ EnumPrinterDrivers(servername, architecture, 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)) {
+ if (!EnumPrinterDrivers(servername, architecture, levels[i], buffer, needed, &needed, &returned)) {
err = GetLastError();
}
}
****************************************************************************/
static BOOL test_EnumPrintProcessors(struct torture_context *tctx,
- LPSTR servername)
+ LPSTR servername,
+ LPSTR architecture)
{
DWORD levels[] = { 1 };
DWORD success[] = { 1 };
torture_comment(tctx, "Testing EnumPrintProcessors level %d", levels[i]);
- EnumPrintProcessors(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned);
+ EnumPrintProcessors(servername, architecture, 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)) {
+ if (!EnumPrintProcessors(servername, architecture, levels[i], buffer, needed, &needed, &returned)) {
err = GetLastError();
}
}
****************************************************************************/
static BOOL test_EnumPrintProcessorDatatypes(struct torture_context *tctx,
- LPSTR servername)
+ LPSTR servername,
+ LPSTR architecture)
{
DWORD levels[] = { 1 };
DWORD success[] = { 1 };
torture_comment(tctx, "Testing EnumPrintProcessorDatatypes level %d", levels[i]);
- EnumPrintProcessorDatatypes(servername, "Windows NT x86", levels[i], NULL, 0, &needed, &returned);
+ EnumPrintProcessorDatatypes(servername, architecture, 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)) {
+ if (!EnumPrintProcessorDatatypes(servername, architecture, levels[i], buffer, needed, &needed, &returned)) {
err = GetLastError();
}
}
static BOOL test_GetPrinterDriver(struct torture_context *tctx,
LPSTR printername,
+ LPSTR architecture,
HANDLE handle)
{
DWORD levels[] = { 1, 2, 3, 4, 5, 6, 8, 101};
torture_comment(tctx, "Testing GetPrinterDriver level %d", levels[i]);
- GetPrinterDriver(handle, "Windows NT x86", levels[i], NULL, 0, &needed);
+ GetPrinterDriver(handle, architecture, 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)) {
+ if (!GetPrinterDriver(handle, architecture, levels[i], buffer, needed, &needed)) {
err = GetLastError();
}
}
****************************************************************************/
static BOOL test_OnePrinter(struct torture_context *tctx,
- LPSTR printername)
+ LPSTR printername,
+ LPSTR architecture)
{
HANDLE handle;
BOOL ret = TRUE;
ret &= test_OpenPrinter(tctx, printername, &handle);
ret &= test_GetPrinter(tctx, printername, handle);
- ret &= test_GetPrinterDriver(tctx, printername, handle);
+ ret &= test_GetPrinterDriver(tctx, printername, architecture, handle);
ret &= test_EnumForms(tctx, printername, handle);
ret &= test_EnumJobs(tctx, printername, handle);
ret &= test_ClosePrinter(tctx, handle);
****************************************************************************/
static BOOL test_EachPrinter(struct torture_context *tctx,
- LPSTR servername)
+ LPSTR servername,
+ LPSTR architecture)
{
DWORD needed = 0;
DWORD returned = 0;
}
for (i=0; i < returned; i++) {
- torture_assert(tctx, test_OnePrinter(tctx, buffer[i].pName),
+ torture_assert(tctx, test_OnePrinter(tctx, buffer[i].pName, architecture),
"failed to test one printer");
}
****************************************************************************/
static BOOL test_GetPrintProcessorDirectory(struct torture_context *tctx,
- LPSTR servername)
+ LPSTR servername,
+ LPSTR architecture)
{
DWORD levels[] = { 1 };
DWORD success[] = { 1 };
torture_comment(tctx, "Testing GetPrintProcessorDirectory level %d", levels[i]);
- GetPrintProcessorDirectory(servername, "Windows NT x86", levels[i], NULL, 0, &needed);
+ GetPrintProcessorDirectory(servername, architecture, 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)) {
+ if (!GetPrintProcessorDirectory(servername, architecture, levels[i], buffer, needed, &needed)) {
err = GetLastError();
}
}
****************************************************************************/
static BOOL test_GetPrinterDriverDirectory(struct torture_context *tctx,
- LPSTR servername)
+ LPSTR servername,
+ LPSTR architecture)
{
DWORD levels[] = { 1 };
DWORD success[] = { 1 };
torture_comment(tctx, "Testing GetPrinterDriverDirectory level %d", levels[i]);
- GetPrinterDriverDirectory(servername, "Windows NT x86", levels[i], NULL, 0, &needed);
+ GetPrinterDriverDirectory(servername, architecture, 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)) {
+ if (!GetPrinterDriverDirectory(servername, architecture, levels[i], buffer, needed, &needed)) {
err = GetLastError();
}
}
{
BOOL ret = FALSE;
LPSTR servername;
+ LPSTR architecture = "Windows NT x86";
HANDLE handle;
struct torture_context *tctx;
}
ret &= test_EnumPrinters(tctx, servername);
- ret &= test_EnumDrivers(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_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_EnumPrintProcessors(tctx, servername, architecture);
+ ret &= test_EnumPrintProcessorDatatypes(tctx, servername, architecture);
+ ret &= test_GetPrintProcessorDirectory(tctx, servername, architecture);
+ ret &= test_GetPrinterDriverDirectory(tctx, servername, architecture);
+ ret &= test_EachPrinter(tctx, servername, architecture);
ret &= test_EachDriver(tctx, servername);
if (!ret) {