+2007-10-28 Dan Winship <danw@gnome.org>
+
+ * tests/auth-test.c:
+ * tests/date.c:
+ * tests/header-parsing.c:
+ * tests/ntlm-test.c:
+ * tests/proxy-test.c:
+ * tests/uri-parsing.c:
+ * tests/xmlrpc-test.c: Make these less verbose by default (to make
+ it easier to see what failed when a "make check" fails).
+
2007-10-15 Dan Winship <danw@gnome.org>
* configure.in: 2.2.102
#include "config.h"
#endif
+#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
#include "libsoup/soup.h"
#include "libsoup/soup-auth.h"
#include "libsoup/soup-session.h"
-#ifdef HAVE_APACHE
#include "apache-wrapper.h"
-#endif
GMainLoop *loop;
int errors = 0;
+gboolean debug = FALSE;
+
+static void
+dprintf (const char *format, ...)
+{
+ va_list args;
+
+ if (!debug)
+ return;
+
+ va_start (args, format);
+ vprintf (format, args);
+ va_end (args);
+}
typedef struct {
/* Explanation of what you should see */
auth = identify_auth (msg);
- printf (" %d %s (using %s)\n", msg->status_code, msg->reason_phrase,
- auths[auth]);
+ dprintf (" %d %s (using %s)\n", msg->status_code, msg->reason_phrase,
+ auths[auth]);
if (*expected) {
exp = *expected - '0';
if (auth != exp) {
- printf (" expected %s!\n", auths[exp]);
+ dprintf (" expected %s!\n", auths[exp]);
errors++;
}
memmove (expected, expected + 1, strlen (expected));
} else {
- printf (" expected to be finished\n");
+ dprintf (" expected to be finished\n");
errors++;
}
}
int auth = identify_auth (msg);
if (!*authenticated && auth) {
- printf (" using auth on message %d before authenticating!!??\n", n);
+ dprintf (" using auth on message %d before authenticating!!??\n", n);
errors++;
} else if (*authenticated && !auth) {
- printf (" sent unauthenticated message %d after authenticating!\n", n);
+ dprintf (" sent unauthenticated message %d after authenticating!\n", n);
errors++;
}
}
return;
if (!*authenticated) {
- printf (" authenticating message %d\n", n);
+ dprintf (" authenticating message %d\n", n);
*username = g_strdup ("user1");
*password = g_strdup ("realm1");
*authenticated = TRUE;
} else {
- printf (" asked to authenticate message %d after authenticating!\n", n);
+ dprintf (" asked to authenticate message %d after authenticating!\n", n);
errors++;
}
}
int n = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (msg), "#"));
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
- printf (" got status '%d %s' on message %d!\n",
+ dprintf (" got status '%d %s' on message %d!\n",
msg->status_code, msg->reason_phrase, n);
errors++;
}
SoupMessage *msg;
char *base_uri, *uri, *expected;
gboolean authenticated;
-#ifdef HAVE_APACHE
- gboolean using_apache = FALSE;
-#endif
- int i;
+ int i, opt;
g_type_init ();
g_thread_init (NULL);
- if (argc != 1) {
- char *p;
-
- base_uri = argv[0];
- p = strrchr (base_uri, '/');
- if (!p || p[1])
- base_uri = g_strdup_printf ("%s/", base_uri);
- } else {
-#ifdef HAVE_APACHE
- if (!apache_init ()) {
- fprintf (stderr, "Could not start apache\n");
+ while ((opt = getopt (argc, argv, "d")) != -1) {
+ switch (opt) {
+ case 'd':
+ debug = TRUE;
+ break;
+ default:
+ fprintf (stderr, "Usage: %s [-d]\n", argv[0]);
return 1;
}
- base_uri = "http://localhost:47524/";
- using_apache = TRUE;
-#else
- fprintf (stderr, "Must specify base_uri for tests if configured --without-apache\n");
+ }
+
+ if (!apache_init ()) {
+ fprintf (stderr, "Could not start apache\n");
return 1;
-#endif
}
+ base_uri = "http://localhost:47524/";
session = soup_session_async_new ();
g_signal_connect (session, "authenticate",
G_CALLBACK (reauthenticate), &i);
for (i = 0; i < ntests; i++) {
- printf ("Test %d: %s\n", i + 1, tests[i].explanation);
+ dprintf ("Test %d: %s\n", i + 1, tests[i].explanation);
uri = g_strconcat (base_uri, tests[i].url, NULL);
- printf (" GET %s\n", uri);
+ dprintf (" GET %s\n", uri);
msg = soup_message_new (SOUP_METHOD_GET, uri);
g_free (uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_UNAUTHORIZED &&
msg->status_code != SOUP_STATUS_OK) {
- printf (" %d %s !\n", msg->status_code,
+ dprintf (" %d %s !\n", msg->status_code,
msg->reason_phrase);
errors++;
}
if (*expected) {
- printf (" expected %d more round(s)\n",
+ dprintf (" expected %d more round(s)\n",
(int)strlen (expected));
errors++;
}
g_free (expected);
if (msg->status_code != tests[i].final_status)
- printf (" expected %d\n", tests[i].final_status);
+ dprintf (" expected %d\n", tests[i].final_status);
- printf ("\n");
+ dprintf ("\n");
g_object_unref (msg);
}
/* And now for a regression test */
- printf ("Regression test for bug 271540:\n");
+ dprintf ("Regression test for bug 271540:\n");
session = soup_session_async_new ();
authenticated = FALSE;
g_object_unref (session);
-#ifdef HAVE_APACHE
- if (using_apache)
- apache_cleanup ();
-#endif
+ apache_cleanup ();
- printf ("\nauth-test: %d errors\n", errors);
+ dprintf ("\n");
+ if (errors) {
+ printf ("auth-test: %d error(s). Run with '-d' for details\n",
+ errors);
+ } else
+ printf ("auth-test: OK\n");
return errors;
}
}
if (errors == 0)
- printf ("OK\n");
+ printf ("date: OK\n");
else
- fprintf (stderr, "%d errors\n", errors);
+ fprintf (stderr, "date: %d errors\n", errors);
return errors;
}
#include <stdio.h>
#include <string.h>
+#include <unistd.h>
#include "libsoup/soup-message.h"
#include "libsoup/soup-headers.h"
+gboolean debug = FALSE;
+
+static void
+dprintf (const char *format, ...)
+{
+ va_list args;
+
+ if (!debug)
+ return;
+
+ va_start (args, format);
+ vprintf (format, args);
+ va_end (args);
+}
+
struct RequestTest {
char *description;
char *request;
print_header (gpointer key, gpointer value, gpointer data)
{
GSList *values = value;
- printf (" '%s': '%s'\n",
- (char *)key, (char*)values->data);
+ dprintf (" '%s': '%s'\n",
+ (char *)key, (char*)values->data);
}
static void
SoupHttpVersion version;
GHashTable *headers;
- printf ("Request tests\n");
+ dprintf ("Request tests\n");
for (i = 0; i < num_reqtests; i++) {
gboolean ok = TRUE;
- printf ("%2d. %s (%s): ", i + 1, reqtests[i].description,
- reqtests[i].method ? "should parse" : "should NOT parse");
+ dprintf ("%2d. %s (%s): ", i + 1, reqtests[i].description,
+ reqtests[i].method ? "should parse" : "should NOT parse");
headers = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, free_headers);
}
if (ok)
- printf ("OK!\n");
+ dprintf ("OK!\n");
else {
- printf ("BAD!\n");
+ dprintf ("BAD!\n");
errors++;
if (reqtests[i].method) {
- printf (" expected: '%s' '%s' 'HTTP/1.%d'\n",
- reqtests[i].method, reqtests[i].path,
- reqtests[i].version);
+ dprintf (" expected: '%s' '%s' 'HTTP/1.%d'\n",
+ reqtests[i].method, reqtests[i].path,
+ reqtests[i].version);
for (h = 0; reqtests[i].headers[h].name; h++) {
- printf (" '%s': '%s'\n",
- reqtests[i].headers[h].name,
- reqtests[i].headers[h].value);
+ dprintf (" '%s': '%s'\n",
+ reqtests[i].headers[h].name,
+ reqtests[i].headers[h].value);
}
} else
- printf (" expected: parse error\n");
+ dprintf (" expected: parse error\n");
if (method) {
- printf (" got: '%s' '%s' 'HTTP/1.%d'\n",
+ dprintf (" got: '%s' '%s' 'HTTP/1.%d'\n",
method, path, version);
g_hash_table_foreach (headers, print_header, NULL);
} else
- printf (" got: parse error\n");
+ dprintf (" got: parse error\n");
}
g_free (method);
g_free (path);
g_hash_table_destroy (headers);
}
- printf ("\n");
+ dprintf ("\n");
return errors;
}
SoupHttpVersion version;
GHashTable *headers;
- printf ("Response tests\n");
+ dprintf ("Response tests\n");
for (i = 0; i < num_resptests; i++) {
gboolean ok = TRUE;
- printf ("%2d. %s (%s): ", i + 1, resptests[i].description,
- resptests[i].reason_phrase ? "should parse" : "should NOT parse");
+ dprintf ("%2d. %s (%s): ", i + 1, resptests[i].description,
+ resptests[i].reason_phrase ? "should parse" : "should NOT parse");
headers = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, free_headers);
}
if (ok)
- printf ("OK!\n");
+ dprintf ("OK!\n");
else {
- printf ("BAD!\n");
+ dprintf ("BAD!\n");
errors++;
if (resptests[i].reason_phrase) {
- printf (" expected: 'HTTP/1.%d' '%03d' '%s'\n",
- resptests[i].version,
- resptests[i].status_code,
- resptests[i].reason_phrase);
+ dprintf (" expected: 'HTTP/1.%d' '%03d' '%s'\n",
+ resptests[i].version,
+ resptests[i].status_code,
+ resptests[i].reason_phrase);
for (h = 0; resptests[i].headers[h].name; h++) {
- printf (" '%s': '%s'\n",
- resptests[i].headers[h].name,
- resptests[i].headers[h].value);
+ dprintf (" '%s': '%s'\n",
+ resptests[i].headers[h].name,
+ resptests[i].headers[h].value);
}
} else
- printf (" expected: parse error\n");
+ dprintf (" expected: parse error\n");
if (reason_phrase) {
- printf (" got: 'HTTP/1.%d' '%03d' '%s'\n",
- version, status_code, reason_phrase);
+ dprintf (" got: 'HTTP/1.%d' '%03d' '%s'\n",
+ version, status_code, reason_phrase);
g_hash_table_foreach (headers, print_header, NULL);
} else
- printf (" got: parse error\n");
+ dprintf (" got: parse error\n");
}
g_free (reason_phrase);
g_hash_table_destroy (headers);
}
- printf ("\n");
+ dprintf ("\n");
return errors;
}
int
main (int argc, char **argv)
{
- int errors;
+ int opt, errors;
+
+ while ((opt = getopt (argc, argv, "d")) != -1) {
+ switch (opt) {
+ case 'd':
+ debug = TRUE;
+ break;
+ default:
+ fprintf (stderr, "Usage: %s [-d]\n", argv[0]);
+ return 1;
+ }
+ }
errors = do_request_tests ();
errors += do_response_tests ();
- printf ("%d errors\n", errors);
+ dprintf ("\n");
+ if (errors) {
+ printf ("header-parsing: %d error(s). Run with '-d' for details\n",
+ errors);
+ } else
+ printf ("header-parsing: OK\n");
return errors;
}
#include <libsoup/soup-server-message.h>
#include <libsoup/soup-session-async.h>
+gboolean debug = FALSE;
+
+static void
+dprintf (const char *format, ...)
+{
+ va_list args;
+
+ if (!debug)
+ return;
+
+ va_start (args, format);
+ vprintf (format, args);
+ va_end (args);
+}
+
typedef enum {
NTLM_UNAUTHENTICATED,
NTLM_RECEIVED_REQUEST,
G_CALLBACK (ntlm_response_check), &state);
soup_session_send_message (session, msg);
- printf (" %-10s -> ", path);
+ dprintf (" %-10s -> ", path);
if (state.got_prompt) {
- printf (" PROMPT");
+ dprintf (" PROMPT");
if (!get_prompt) {
- printf ("???");
+ dprintf ("???");
errors++;
}
} else if (get_prompt) {
- printf (" no-prompt???");
+ dprintf (" no-prompt???");
errors++;
}
if (state.sent_request) {
- printf (" REQUEST");
+ dprintf (" REQUEST");
if (!do_ntlm) {
- printf ("???");
+ dprintf ("???");
errors++;
}
} else if (do_ntlm) {
- printf (" no-request???");
+ dprintf (" no-request???");
errors++;
}
if (state.got_challenge) {
- printf (" CHALLENGE");
+ dprintf (" CHALLENGE");
if (!do_ntlm) {
- printf ("???");
+ dprintf ("???");
errors++;
}
} else if (do_ntlm) {
- printf (" no-challenge???");
+ dprintf (" no-challenge???");
errors++;
}
if (state.sent_response) {
- printf (" RESPONSE");
+ dprintf (" RESPONSE");
if (!do_ntlm) {
- printf ("???");
+ dprintf ("???");
errors++;
}
} else if (do_ntlm) {
- printf (" no-response???");
+ dprintf (" no-response???");
errors++;
}
- printf (" -> %s", msg->reason_phrase);
+ dprintf (" -> %s", msg->reason_phrase);
if (msg->status_code != status_code) {
- printf ("???");
+ dprintf ("???");
errors++;
}
- printf ("\n");
+ dprintf ("\n");
return errors;
}
{
int errors = 0;
- printf ("Round 1: Non-NTLM Connection\n");
+ dprintf ("Round 1: Non-NTLM Connection\n");
errors += do_ntlm_round (base_uri, NULL);
- printf ("Round 2: NTLM Connection, user=alice\n");
+ dprintf ("Round 2: NTLM Connection, user=alice\n");
errors += do_ntlm_round (base_uri, "alice");
- printf ("Round 3: NTLM Connection, user=bob\n");
+ dprintf ("Round 3: NTLM Connection, user=bob\n");
errors += do_ntlm_round (base_uri, "bob");
return errors;
GMainLoop *loop;
SoupServer *server;
int opt;
- int port = SOUP_ADDRESS_ANY_PORT;
GHashTable *connections;
SoupUri *uri;
int errors;
g_thread_init (NULL);
signal (SIGINT, quit);
- while ((opt = getopt (argc, argv, "p:")) != -1) {
+ while ((opt = getopt (argc, argv, "d")) != -1) {
switch (opt) {
- case 'p':
- port = atoi (optarg);
+ case 'd':
+ debug = TRUE;
break;
default:
- fprintf (stderr, "Usage: %s [-p port]\n",
+ fprintf (stderr, "Usage: %s [-d]\n",
argv[0]);
exit (1);
}
connections = g_hash_table_new (NULL, NULL);
- server = soup_server_new (SOUP_SERVER_PORT, port,
+ server = soup_server_new (SOUP_SERVER_PORT, 0,
NULL);
if (!server) {
- fprintf (stderr, "Unable to bind to server port %d\n", port);
+ fprintf (stderr, "Unable to bind server\n");
exit (1);
}
soup_server_add_handler (server, NULL, NULL,
uri->port = soup_server_get_port (server);
errors = do_ntlm_tests (uri);
- printf ("\n%d errors\n", errors);
+ dprintf ("\n");
+ if (errors) {
+ printf ("ntlm-test: %d error(s). Run with '-d' for details\n",
+ errors);
+ } else
+ printf ("ntlm-test: OK\n");
return errors != 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
#include "libsoup/soup.h"
#include "apache-wrapper.h"
int errors = 0;
+gboolean debug = FALSE;
+
+static void
+dprintf (const char *format, ...)
+{
+ va_list args;
+
+ if (!debug)
+ return;
+
+ va_start (args, format);
+ vprintf (format, args);
+ va_end (args);
+}
typedef struct {
const char *explanation;
SoupUri *proxy_uri;
SoupMessage *msg;
- printf (" GET %s via %s\n", url, proxy_names[proxy]);
+ dprintf (" GET %s via %s\n", url, proxy_names[proxy]);
if (proxy == UNAUTH_PROXY && expected != SOUP_STATUS_FORBIDDEN)
expected = SOUP_STATUS_PROXY_UNAUTHORIZED;
soup_session_send_message (session, msg);
- printf (" %d %s\n", msg->status_code, msg->reason_phrase);
+ dprintf (" %d %s\n", msg->status_code, msg->reason_phrase);
if (msg->status_code != expected) {
- printf (" EXPECTED %d!\n", expected);
+ dprintf (" EXPECTED %d!\n", expected);
errors++;
}
{
char *http_url, *https_url;
- printf ("Test %d: %s (%s)\n", i + 1, tests[i].explanation,
- sync ? "sync" : "async");
+ dprintf ("Test %d: %s (%s)\n", i + 1, tests[i].explanation,
+ sync ? "sync" : "async");
if (!strncmp (tests[i].url, "http", 4)) {
http_url = g_strdup (tests[i].url);
g_free (http_url);
g_free (https_url);
- printf ("\n");
+ dprintf ("\n");
}
int
main (int argc, char **argv)
{
- int i;
+ int i, opt;
g_type_init ();
g_thread_init (NULL);
+ while ((opt = getopt (argc, argv, "d")) != -1) {
+ switch (opt) {
+ case 'd':
+ debug = TRUE;
+ break;
+ default:
+ fprintf (stderr, "Usage: %s [-d]\n", argv[0]);
+ return 1;
+ }
+ }
+
if (!apache_init ()) {
fprintf (stderr, "Could not start apache\n");
return 1;
apache_cleanup ();
- printf ("proxy-test: %d errors\n", errors);
+ dprintf ("\n");
+ if (errors) {
+ printf ("proxy-test: %d error(s). Run with '-d' for details\n",
+ errors);
+ } else
+ printf ("proxy-test: OK\n");
return errors;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
#include "libsoup/soup-uri.h"
+gboolean debug = FALSE;
+
+static void
+dprintf (const char *format, ...)
+{
+ va_list args;
+
+ if (!debug)
+ return;
+
+ va_start (args, format);
+ vprintf (format, args);
+ va_end (args);
+}
+
struct {
const char *uri_string, *result;
} abs_tests[] = {
char *uri_string;
if (base_uri) {
- printf ("<%s> + <%s> = <%s>? ", base_str, in_uri,
- out_uri ? out_uri : "ERR");
+ dprintf ("<%s> + <%s> = <%s>? ", base_str, in_uri,
+ out_uri ? out_uri : "ERR");
uri = soup_uri_new_with_base (base_uri, in_uri);
} else {
- printf ("<%s> => <%s>? ", in_uri,
- out_uri ? out_uri : "ERR");
+ dprintf ("<%s> => <%s>? ", in_uri,
+ out_uri ? out_uri : "ERR");
uri = soup_uri_new (in_uri);
}
if (!uri) {
if (out_uri) {
- printf ("ERR\n Could not parse %s\n", in_uri);
+ dprintf ("ERR\n Could not parse %s\n", in_uri);
return FALSE;
} else {
- printf ("OK\n");
+ dprintf ("OK\n");
return TRUE;
}
}
soup_uri_free (uri);
if (!out_uri) {
- printf ("ERR\n Got %s\n", uri_string);
+ dprintf ("ERR\n Got %s\n", uri_string);
return FALSE;
}
if (strcmp (uri_string, out_uri) != 0) {
- printf ("NO\n Unparses to <%s>\n", uri_string);
+ dprintf ("NO\n Unparses to <%s>\n", uri_string);
g_free (uri_string);
return FALSE;
}
g_free (uri_string);
- printf ("OK\n");
+ dprintf ("OK\n");
return TRUE;
}
{
SoupUri *base_uri;
char *uri_string;
- int i, errs = 0;
+ int i, errs = 0, opt;
+
+ while ((opt = getopt (argc, argv, "d")) != -1) {
+ switch (opt) {
+ case 'd':
+ debug = TRUE;
+ break;
+ default:
+ fprintf (stderr, "Usage: %s [-d]\n", argv[0]);
+ return 1;
+ }
+ }
- printf ("Absolute URI parsing\n");
+ dprintf ("Absolute URI parsing\n");
for (i = 0; i < num_abs_tests; i++) {
if (!do_uri (NULL, NULL, abs_tests[i].uri_string,
abs_tests[i].result))
errs++;
}
- printf ("\nRelative URI parsing\n");
+ dprintf ("\nRelative URI parsing\n");
base_uri = soup_uri_new (base);
if (!base_uri) {
fprintf (stderr, "Could not parse %s!\n", base);
errs++;
}
- printf ("\n%d errors\n", errs);
+ dprintf ("\n");
+ if (errs) {
+ printf ("uri-parsing: %d error(s). Run with '-d' for details\n",
+ errs);
+ } else
+ printf ("uri-parsing: OK\n");
return errs;
}
static const char *uri = "http://localhost:47524/xmlrpc-server.php";
int debug;
+static void
+dprintf (int level, const char *format, ...)
+{
+ va_list args;
+
+ if (debug < level)
+ return;
+
+ va_start (args, format);
+ vprintf (format, args);
+ va_end (args);
+}
+
static const char *const value_type[] = {
"BAD",
"int",
soup_xmlrpc_message_persist (xmsg);
status = soup_session_send_message (session, msg);
- if (debug > 1) {
- printf ("\n%.*s\n%d %s\n%.*s\n",
- msg->request.length, msg->request.body,
- msg->status_code, msg->reason_phrase,
- msg->response.length, msg->response.body);
- }
+ dprintf (3, "\n%.*s\n%d %s\n%.*s\n",
+ msg->request.length, msg->request.body,
+ msg->status_code, msg->reason_phrase,
+ msg->response.length, msg->response.body);
if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
- printf ("ERROR: %d %s\n", status, msg->reason_phrase);
+ dprintf (1, "ERROR: %d %s\n", status, msg->reason_phrase);
return FALSE;
}
response = soup_xmlrpc_message_parse_response (xmsg);
if (!response || soup_xmlrpc_response_is_fault (response)) {
if (!response)
- printf ("ERROR: no response\n");
+ dprintf (1, "ERROR: no response\n");
else
- printf ("ERROR: fault\n");
+ dprintf (1, "ERROR: fault\n");
return FALSE;
}
value = soup_xmlrpc_response_get_value (response);
if (!value) {
- printf ("ERROR: no value?\n");
+ dprintf (1, "ERROR: no value?\n");
return NULL;
} else if (soup_xmlrpc_value_get_type (value) != type) {
- printf ("ERROR: wrong value type; expected %s, got %s\n",
- value_type[type], value_type[soup_xmlrpc_value_get_type (value)]);
+ dprintf (1, "ERROR: wrong value type; expected %s, got %s\n",
+ value_type[type], value_type[soup_xmlrpc_value_get_type (value)]);
return NULL;
}
int i, val, sum;
long result;
- printf ("sum (array of int -> int): ");
+ dprintf (1, "sum (array of int -> int): ");
msg = soup_xmlrpc_message_new (uri);
soup_xmlrpc_message_start_call (msg, "sum");
soup_xmlrpc_message_start_array (msg);
for (i = sum = 0; i < 10; i++) {
val = rand () % 100;
- if (debug)
- printf ("%s%d", i == 0 ? "[" : ", ", val);
+ dprintf (2, "%s%d", i == 0 ? "[" : ", ", val);
soup_xmlrpc_message_write_int (msg, val);
sum += val;
}
- if (debug)
- printf ("] -> ");
+ dprintf (2, "] -> ");
soup_xmlrpc_message_end_array (msg);
soup_xmlrpc_message_end_param (msg);
soup_xmlrpc_message_end_call (msg);
return FALSE;
if (!soup_xmlrpc_value_get_int (value, &result)) {
- printf ("wrong type?\n");
+ dprintf (1, "wrong type?\n");
return FALSE;
}
- if (debug)
- printf ("%ld: ", result);
- printf ("%s\n", result == sum ? "OK!" : "WRONG!");
+ dprintf (2, "%ld: ", result);
+ dprintf (1, "%s\n", result == sum ? "OK!" : "WRONG!");
return result == sum;
}
gboolean val, ok;
GHashTable *result;
- printf ("countBools (array of boolean -> struct of ints): ");
+ dprintf (1, "countBools (array of boolean -> struct of ints): ");
msg = soup_xmlrpc_message_new (uri);
soup_xmlrpc_message_start_call (msg, "countBools");
soup_xmlrpc_message_start_array (msg);
for (i = trues = falses = 0; i < 10; i++) {
val = rand () > (RAND_MAX / 2);
- if (debug)
- printf ("%s%c", i == 0 ? "[" : ", ", val ? 'T' : 'F');
+ dprintf (2, "%s%c", i == 0 ? "[" : ", ", val ? 'T' : 'F');
soup_xmlrpc_message_write_boolean (msg, val);
if (val)
trues++;
else
falses++;
}
- if (debug)
- printf ("] -> ");
+ dprintf (2, "] -> ");
soup_xmlrpc_message_end_array (msg);
soup_xmlrpc_message_end_param (msg);
soup_xmlrpc_message_end_call (msg);
return FALSE;
if (!soup_xmlrpc_value_get_struct (value, &result)) {
- printf ("wrong type?\n");
+ dprintf (1, "wrong type?\n");
return FALSE;
}
if (!soup_xmlrpc_value_get_int (g_hash_table_lookup (result, "true"), &ret_trues)) {
- printf ("NO 'true' value in response\n");
+ dprintf (1, "NO 'true' value in response\n");
return FALSE;
}
if (!soup_xmlrpc_value_get_int (g_hash_table_lookup (result, "false"), &ret_falses)) {
- printf ("NO 'false' value in response\n");
+ dprintf (1, "NO 'false' value in response\n");
return FALSE;
}
- if (debug)
- printf ("{ true: %ld, false: %ld } ", ret_trues, ret_falses);
+ dprintf (2, "{ true: %ld, false: %ld } ", ret_trues, ret_falses);
ok = (trues == ret_trues) && (falses == ret_falses);
- printf ("%s\n", ok ? "OK!" : "WRONG!");
+ dprintf (1, "%s\n", ok ? "OK!" : "WRONG!");
return ok;
}
guchar digest[16];
gboolean ok;
- printf ("md5sum (base64 -> base64): ");
+ dprintf (1, "md5sum (base64 -> base64): ");
msg = soup_xmlrpc_message_new (uri);
soup_xmlrpc_message_start_call (msg, "md5sum");
return FALSE;
if (!soup_xmlrpc_value_get_base64 (value, &result)) {
- printf ("wrong type?\n");
+ dprintf (1, "wrong type?\n");
return FALSE;
}
if (result->len != 16) {
- printf ("result has WRONG length (%d)\n", result->len);
+ dprintf (1, "result has WRONG length (%d)\n", result->len);
g_byte_array_free (result, TRUE);
return FALSE;
}
soup_md5_final (&md5, digest);
ok = (memcmp (digest, result->data, 16) == 0);
- printf ("%s\n", ok ? "OK!" : "WRONG!");
+ dprintf (1, "%s\n", ok ? "OK!" : "WRONG!");
g_byte_array_free (result, TRUE);
return ok;
}
time_t when, result;
char timestamp[128];
- printf ("dateChange (struct of time and ints -> time): ");
+ dprintf (1, "dateChange (struct of time and ints -> time): ");
msg = soup_xmlrpc_message_new (uri);
soup_xmlrpc_message_start_call (msg, "dateChange");
soup_xmlrpc_message_write_datetime (msg, when);
soup_xmlrpc_message_end_member (msg);
- if (debug) {
- strftime (timestamp, sizeof (timestamp),
- "%Y-%m-%dT%H:%M:%S", &tm);
- printf ("{ date: %s", timestamp);
- }
+ strftime (timestamp, sizeof (timestamp),
+ "%Y-%m-%dT%H:%M:%S", &tm);
+ dprintf (2, "{ date: %s", timestamp);
if (rand () % 3) {
tm.tm_year = 70 + (rand () % 50);
- if (debug)
- printf (", tm_year: %d", tm.tm_year);
+ dprintf (2, ", tm_year: %d", tm.tm_year);
soup_xmlrpc_message_start_member (msg, "tm_year");
soup_xmlrpc_message_write_int (msg, tm.tm_year);
soup_xmlrpc_message_end_member (msg);
}
if (rand () % 3) {
tm.tm_mon = rand () % 12;
- if (debug)
- printf (", tm_mon: %d", tm.tm_mon);
+ dprintf (2, ", tm_mon: %d", tm.tm_mon);
soup_xmlrpc_message_start_member (msg, "tm_mon");
soup_xmlrpc_message_write_int (msg, tm.tm_mon);
soup_xmlrpc_message_end_member (msg);
}
if (rand () % 3) {
tm.tm_mday = 1 + (rand () % 28);
- if (debug)
- printf (", tm_mday: %d", tm.tm_mday);
+ dprintf (2, ", tm_mday: %d", tm.tm_mday);
soup_xmlrpc_message_start_member (msg, "tm_mday");
soup_xmlrpc_message_write_int (msg, tm.tm_mday);
soup_xmlrpc_message_end_member (msg);
}
if (rand () % 3) {
tm.tm_hour = rand () % 24;
- if (debug)
- printf (", tm_hour: %d", tm.tm_hour);
+ dprintf (2, ", tm_hour: %d", tm.tm_hour);
soup_xmlrpc_message_start_member (msg, "tm_hour");
soup_xmlrpc_message_write_int (msg, tm.tm_hour);
soup_xmlrpc_message_end_member (msg);
}
if (rand () % 3) {
tm.tm_min = rand () % 60;
- if (debug)
- printf (", tm_min: %d", tm.tm_min);
+ dprintf (2, ", tm_min: %d", tm.tm_min);
soup_xmlrpc_message_start_member (msg, "tm_min");
soup_xmlrpc_message_write_int (msg, tm.tm_min);
soup_xmlrpc_message_end_member (msg);
}
if (rand () % 3) {
tm.tm_sec = rand () % 60;
- if (debug)
- printf (", tm_sec: %d", tm.tm_sec);
+ dprintf (2, ", tm_sec: %d", tm.tm_sec);
soup_xmlrpc_message_start_member (msg, "tm_sec");
soup_xmlrpc_message_write_int (msg, tm.tm_sec);
soup_xmlrpc_message_end_member (msg);
}
when = soup_mktime_utc (&tm);
- if (debug)
- printf (" } -> ");
+ dprintf (2, " } -> ");
soup_xmlrpc_message_end_struct (msg);
soup_xmlrpc_message_end_param (msg);
return FALSE;
if (!soup_xmlrpc_value_get_datetime (value, &result)) {
- printf ("wrong type?\n");
+ dprintf (1, "wrong type?\n");
return FALSE;
}
- if (debug) {
- memset (&tm, 0, sizeof (tm));
- soup_gmtime (&result, &tm);
- strftime (timestamp, sizeof (timestamp),
- "%Y-%m-%dT%H:%M:%S", &tm);
- printf ("%s: ", timestamp);
- }
+ memset (&tm, 0, sizeof (tm));
+ soup_gmtime (&result, &tm);
+ strftime (timestamp, sizeof (timestamp), "%Y-%m-%dT%H:%M:%S", &tm);
+ dprintf (2, "%s: ", timestamp);
- printf ("%s\n", (when == result) ? "OK!" : "WRONG!");
+ dprintf (1, "%s\n", (when == result) ? "OK!" : "WRONG!");
return (when == result);
}
char *echo;
int i;
- printf ("echo (array of string -> array of string): ");
+ dprintf (1, "echo (array of string -> array of string): ");
msg = soup_xmlrpc_message_new (uri);
soup_xmlrpc_message_start_call (msg, "echo");
soup_xmlrpc_message_start_param (msg);
soup_xmlrpc_message_start_array (msg);
for (i = 0; i < N_ECHO_STRINGS; i++) {
- if (debug)
- printf ("%s\"%s\"", i == 0 ? "[" : ", ", echo_strings[i]);
+ dprintf (2, "%s\"%s\"", i == 0 ? "[" : ", ", echo_strings[i]);
soup_xmlrpc_message_write_string (msg, echo_strings[i]);
}
- if (debug)
- printf ("] -> ");
+ dprintf (2, "] -> ");
soup_xmlrpc_message_end_array (msg);
soup_xmlrpc_message_end_param (msg);
soup_xmlrpc_message_end_call (msg);
return FALSE;
if (!soup_xmlrpc_value_array_get_iterator (value, &iter)) {
- printf ("wrong type?\n");
+ dprintf (1, "wrong type?\n");
return FALSE;
}
i = 0;
while (iter) {
if (!soup_xmlrpc_value_array_iterator_get_value (iter, &elt)) {
- printf (" WRONG! Can't get result element %d\n", i + 1);
+ dprintf (1, " WRONG! Can't get result element %d\n", i + 1);
return FALSE;
}
if (!soup_xmlrpc_value_get_string (elt, &echo)) {
- printf (" WRONG! Result element %d is not a string", i + 1);
+ dprintf (1, " WRONG! Result element %d is not a string", i + 1);
return FALSE;
}
- if (debug)
- printf ("%s\"%s\"", i == 0 ? "[" : ", ", echo);
+ dprintf (2, "%s\"%s\"", i == 0 ? "[" : ", ", echo);
if (strcmp (echo_strings[i], echo) != 0) {
- printf (" WRONG! Mismatch at %d\n", i + 1);
+ dprintf (1, " WRONG! Mismatch at %d\n", i + 1);
return FALSE;
}
iter = soup_xmlrpc_value_array_iterator_next (iter);
i++;
}
- if (debug)
- printf ("] ");
+ dprintf (2, "] ");
- printf ("%s\n", i == N_ECHO_STRINGS ? "OK!" : "WRONG! Too few results");
+ dprintf (1, "%s\n", i == N_ECHO_STRINGS ? "OK!" : "WRONG! Too few results");
return i == N_ECHO_STRINGS;
}
apache_cleanup ();
- printf ("\n%d errors\n", errors);
- return errors > 0;
+ dprintf (1, "\n");
+ if (errors) {
+ printf ("xmlrpc-test: %d error(s). Run with '-d' for details\n",
+ errors);
+ } else
+ printf ("xmlrpc-test: OK\n");
+ return errors;
}
projects / platform / upstream / libsoup.git / commitdiff