← Back to branch summary

~cyphermox/ubuntu/utopic/libsoup2.4/autopkgtest

« back to all changes in this revision

Viewing changes to tests/xmlrpc-test.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2014-05-12 12:28:40 UTC
  • mfrom: (10.3.28 utopic-proposed)
  • Revision ID: package-import@ubuntu.com-20140512122840-48y5krquj9i3ru79
Tags: 2.46.0-2ubuntu1
* Resynchronize on Debian, remaining change
  - Use dh-autoreconf to update libtool.m4 for new ports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/xmlrpc-test.c
5
5
 
6
6
#include "test-utils.h"
7
7
 
8
 
#ifdef HAVE_PHP_XMLRPC
9
 
 
10
8
#ifdef G_GNUC_BEGIN_IGNORE_DEPRECATIONS
11
9
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
12
10
#endif
16
14
static const char *uri = NULL;
17
15
static gboolean server_test = FALSE;
18
16
 
 
17
#ifdef HAVE_PHP_XMLRPC
 
18
#define SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER
 
19
#else
 
20
#define SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER                              \
 
21
        G_STMT_START {                                                  \
 
22
                if (!server_test) {                                     \
 
23
                        g_test_skip ("php-xmlrpc is not available");    \
 
24
                        return;                                         \
 
25
                }                                                       \
 
26
        } G_STMT_END
 
27
#endif
 
28
 
19
29
static const char *const value_type[] = {
20
30
        "BAD",
21
31
        "int",
39
49
                                  body, strlen (body));
40
50
        soup_session_send_message (session, msg);
41
51
 
42
 
        if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
43
 
                debug_printf (1, "ERROR: %d %s\n", msg->status_code,
44
 
                              msg->reason_phrase);
45
 
                g_object_unref (msg);
46
 
                return FALSE;
47
 
        }
 
52
        soup_test_assert_message_status (msg, SOUP_STATUS_OK);
48
53
 
49
54
        if (!soup_xmlrpc_parse_method_response (msg->response_body->data,
50
55
                                                msg->response_body->length,
51
56
                                                retval, &err)) {
52
57
                if (err) {
53
 
                        debug_printf (1, "FAULT: %d %s\n", err->code, err->message);
 
58
                        soup_test_assert (FALSE, "FAULT: %d %s\n", err->code, err->message);
54
59
                        g_error_free (err);
55
60
                } else
56
 
                        debug_printf (1, "ERROR: could not parse response\n");
 
61
                        soup_test_assert (FALSE, "ERROR: could not parse response\n");
57
62
                g_object_unref (msg);
58
63
                return FALSE;
59
64
        }
92
97
        va_list args;
93
98
 
94
99
        if (!G_VALUE_HOLDS (value, type)) {
95
 
                debug_printf (1, "ERROR: could not parse response\n");
96
 
                g_value_unset (value);
 
100
                g_assert_true (G_VALUE_HOLDS (value, type));
97
101
                return FALSE;
98
102
        }
99
103
 
103
107
        return TRUE;
104
108
}
105
109
 
106
 
static gboolean
 
110
static void
107
111
test_sum (void)
108
112
{
109
113
        GValueArray *ints;
111
115
        GValue retval;
112
116
        gboolean ok;
113
117
 
114
 
        debug_printf (1, "sum (array of int -> int): ");
 
118
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
 
119
 
 
120
        debug_printf (2, "sum (array of int -> int): ");
115
121
 
116
122
        ints = g_value_array_new (10);
117
123
        for (i = sum = 0; i < 10; i++) {
129
135
        g_value_array_free (ints);
130
136
 
131
137
        if (!ok)
132
 
                return FALSE;
 
138
                return;
133
139
 
134
 
        debug_printf (2, "%d: ", result);
135
 
        debug_printf (1, "%s\n", result == sum ? "OK!" : "WRONG!");
136
 
        return result == sum;
 
140
        debug_printf (2, "%d\n", result);
 
141
        g_assert_cmpint (result, ==, sum);
137
142
}
138
143
 
139
 
static gboolean
 
144
static void
140
145
test_countBools (void)
141
146
{
142
147
        GValueArray *bools;
146
151
        gboolean val, ok;
147
152
        GHashTable *result;
148
153
 
149
 
        debug_printf (1, "countBools (array of boolean -> struct of ints): ");
 
154
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
 
155
 
 
156
        debug_printf (2, "countBools (array of boolean -> struct of ints): ");
150
157
 
151
158
        bools = g_value_array_new (10);
152
159
        for (i = trues = falses = 0; i < 10; i++) {
166
173
              check_xmlrpc (&retval, G_TYPE_HASH_TABLE, &result));
167
174
        g_value_array_free (bools);
168
175
        if (!ok)
169
 
                return FALSE;
170
 
 
171
 
        if (!soup_value_hash_lookup (result, "true", G_TYPE_INT, &ret_trues)) {
172
 
                debug_printf (1, "NO 'true' value in response\n");
173
 
                return FALSE;
174
 
        }
175
 
        if (!soup_value_hash_lookup (result, "false", G_TYPE_INT, &ret_falses)) {
176
 
                debug_printf (1, "NO 'false' value in response\n");
177
 
                return FALSE;
178
 
        }
 
176
                return;
 
177
 
 
178
        g_assert_true (soup_value_hash_lookup (result, "true", G_TYPE_INT, &ret_trues));
 
179
        g_assert_true (soup_value_hash_lookup (result, "false", G_TYPE_INT, &ret_falses));
 
180
 
179
181
        g_hash_table_destroy (result);
180
182
 
181
 
        debug_printf (2, "{ true: %d, false: %d } ", ret_trues, ret_falses);
182
 
        ok = (trues == ret_trues) && (falses == ret_falses);
183
 
        debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
184
 
        return ok;
 
183
        debug_printf (2, "{ true: %d, false: %d }\n", ret_trues, ret_falses);
 
184
        g_assert_cmpint (trues, ==, ret_trues);
 
185
        g_assert_cmpint (falses, ==, ret_falses);
185
186
}
186
187
 
187
 
static gboolean
 
188
static void
188
189
test_md5sum (void)
189
190
{
190
191
        GByteArray *data, *result;
195
196
        GValue retval;
196
197
        gboolean ok;
197
198
 
198
 
        debug_printf (1, "md5sum (base64 -> base64): ");
 
199
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
 
200
 
 
201
        debug_printf (2, "md5sum (base64 -> base64)\n");
199
202
 
200
203
        data = g_byte_array_new ();
201
204
        g_byte_array_set_size (data, 256);
213
216
              check_xmlrpc (&retval, SOUP_TYPE_BYTE_ARRAY, &result));
214
217
        g_byte_array_free (data, TRUE);
215
218
        if (!ok)
216
 
                return FALSE;
217
 
 
218
 
        if (result->len != digest_len) {
219
 
                debug_printf (1, "result has WRONG length (%d)\n", result->len);
220
 
                g_byte_array_free (result, TRUE);
221
 
                return FALSE;
222
 
        }
223
 
 
224
 
        ok = (memcmp (digest, result->data, digest_len) == 0);
225
 
        debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
 
219
                return;
 
220
 
 
221
        soup_assert_cmpmem (result->data, result->len,
 
222
                            digest, digest_len);
226
223
        g_byte_array_free (result, TRUE);
227
 
        return ok;
228
224
}
229
225
 
230
 
static gboolean
 
226
static void
231
227
test_dateChange (void)
232
228
{
233
229
        GHashTable *structval;
236
232
        GValue retval;
237
233
        gboolean ok;
238
234
 
239
 
        debug_printf (1, "dateChange (date, struct of ints -> time): ");
 
235
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
 
236
 
 
237
        debug_printf (2, "dateChange (date, struct of ints -> time)\n");
240
238
 
241
239
        date = soup_date_new (1970 + (g_random_int_range (0, 50)),
242
240
                              1 + g_random_int_range (0, 12),
301
299
        g_hash_table_destroy (structval);
302
300
        if (!ok) {
303
301
                soup_date_free (date);
304
 
                return FALSE;
 
302
                return;
305
303
        }
306
304
 
307
305
        if (debug_level >= 2) {
308
306
                timestamp = soup_date_to_string (result, SOUP_DATE_ISO8601_XMLRPC);
309
 
                debug_printf (2, "%s: ", timestamp);
 
307
                debug_printf (2, "%s\n", timestamp);
310
308
                g_free (timestamp);
311
309
        }
312
310
 
313
 
        ok = ((date->year   == result->year) &&
314
 
              (date->month  == result->month) &&
315
 
              (date->day    == result->day) &&
316
 
              (date->hour   == result->hour) &&
317
 
              (date->minute == result->minute) &&
318
 
              (date->second == result->second));
 
311
        g_assert_cmpint (date->year,   ==, result->year);
 
312
        g_assert_cmpint (date->month,  ==, result->month);
 
313
        g_assert_cmpint (date->day,    ==, result->day);
 
314
        g_assert_cmpint (date->hour,   ==, result->hour);
 
315
        g_assert_cmpint (date->minute, ==, result->minute);
 
316
        g_assert_cmpint (date->second, ==, result->second);
 
317
 
319
318
        soup_date_free (date);
320
319
        soup_date_free (result);
321
 
 
322
 
        debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
323
 
        return ok;
324
320
}
325
321
 
326
322
static const char *const echo_strings[] = {
338
334
        "amp; so is lt;thisgt;"
339
335
};
340
336
 
341
 
static gboolean
 
337
static void
342
338
test_echo (void)
343
339
{
344
340
        GValueArray *originals, *echoes;
345
341
        GValue retval;
346
342
        int i;
347
 
        gboolean php_bug = FALSE;
348
 
 
349
 
        debug_printf (1, "echo (array of string -> array of string): ");
 
343
 
 
344
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
 
345
 
 
346
        debug_printf (2, "echo (array of string -> array of string):\n");
350
347
 
351
348
        originals = g_value_array_new (N_ECHO_STRINGS);
352
349
        for (i = 0; i < N_ECHO_STRINGS; i++) {
360
357
                         G_TYPE_INVALID) &&
361
358
              check_xmlrpc (&retval, G_TYPE_VALUE_ARRAY, &echoes))) {
362
359
                g_value_array_free (originals);
363
 
                return FALSE;
 
360
                return;
364
361
        }
365
362
        g_value_array_free (originals);
366
363
 
369
366
                        debug_printf (2, "%s\"%s\"", i == 0 ? "[" : ", ",
370
367
                                      g_value_get_string (&echoes->values[i]));
371
368
                }
372
 
                debug_printf (2, "] -> ");
 
369
                debug_printf (2, "]\n");
373
370
        }
374
371
 
375
 
        if (echoes->n_values != N_ECHO_STRINGS) {
376
 
                debug_printf (1, " WRONG! Wrong number of return strings");
377
 
                g_value_array_free (echoes);
378
 
                return FALSE;
379
 
        }
 
372
        g_assert_cmpint (echoes->n_values, ==, N_ECHO_STRINGS);
380
373
 
381
374
        for (i = 0; i < echoes->n_values; i++) {
382
 
                if (strcmp (echo_strings[i], g_value_get_string (&echoes->values[i])) != 0) {
383
 
                        if (!server_test && strcmp (echo_strings_broken[i], g_value_get_string (&echoes->values[i])) == 0)
384
 
                                php_bug = TRUE;
385
 
                        else {
386
 
                                debug_printf (1, " WRONG! Mismatch at %d\n", i + 1);
387
 
                                g_value_array_free (echoes);
388
 
                                return FALSE;
389
 
                        }
 
375
                if (!server_test && strcmp (echo_strings_broken[i], g_value_get_string (&echoes->values[i])) == 0) {
 
376
                        g_test_skip ("PHP bug");
 
377
                        g_value_array_free (echoes);
 
378
                        return;
390
379
                }
 
380
 
 
381
                g_assert_cmpstr (echo_strings[i], ==, g_value_get_string (&echoes->values[i]));
391
382
        }
392
383
 
393
 
        if (php_bug)
394
 
                debug_printf (1, "WRONG, but it's php's fault\n");
395
 
        else
396
 
                debug_printf (1, "OK!\n");
397
384
        g_value_array_free (echoes);
398
 
        return TRUE;
399
385
}
400
386
 
401
 
static gboolean
402
 
test_ping (gboolean include_params)
 
387
static void
 
388
test_ping (gconstpointer include_params)
403
389
{
404
390
        GValueArray *params;
405
391
        GValue retval;
407
393
        char *out;
408
394
        gboolean ret;
409
395
 
410
 
        debug_printf (1, "ping (void (%s) -> string): ",
 
396
        g_test_bug ("671661");
 
397
 
 
398
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
 
399
 
 
400
        debug_printf (2, "ping (void (%s) -> string)\n",
411
401
                      include_params ? "empty <params>" : "no <params>");
412
402
 
413
403
        params = soup_value_array_new ();
415
405
                                                 params->n_values);
416
406
        g_value_array_free (params);
417
407
        if (!request)
418
 
                return FALSE;
 
408
                return;
419
409
 
420
410
        if (!include_params) {
421
411
                char *params, *end;
422
412
 
423
413
                params = strstr (request, "<params/>");
424
414
                if (!params) {
425
 
                        debug_printf (1, "ERROR: XML did not contain <params/>!");
426
 
                        return FALSE;
 
415
                        soup_test_assert (FALSE, "ERROR: XML did not contain <params/>!");
 
416
                        return;
427
417
                }
428
418
                end = params + strlen ("<params/>");
429
419
                memmove (params, end, strlen (end) + 1);
433
423
        g_free (request);
434
424
 
435
425
        if (!ret || !check_xmlrpc (&retval, G_TYPE_STRING, &out))
436
 
                return FALSE;
 
426
                return;
437
427
 
438
 
        if (!strcmp (out, "pong")) {
439
 
                debug_printf (1, "OK!\n");
440
 
                ret = TRUE;
441
 
        } else {
442
 
                debug_printf (1, "WRONG! Bad response '%s'", out);
443
 
                ret = FALSE;
444
 
        }
 
428
        g_assert_cmpstr (out, ==, "pong");
445
429
 
446
430
        g_free (out);
447
 
        return ret;
448
431
}
449
432
 
450
 
static gboolean
 
433
static void
451
434
do_bad_xmlrpc (const char *body)
452
435
{
453
436
        SoupMessage *msg;
459
442
                                  body, strlen (body));
460
443
        soup_session_send_message (session, msg);
461
444
 
462
 
        if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
463
 
                debug_printf (1, "ERROR: %d %s\n", msg->status_code,
464
 
                              msg->reason_phrase);
465
 
                g_object_unref (msg);
466
 
                return FALSE;
467
 
        }
 
445
        soup_test_assert_message_status (msg, SOUP_STATUS_OK);
468
446
 
469
447
        if (!soup_xmlrpc_parse_method_response (msg->response_body->data,
470
448
                                                msg->response_body->length,
474
452
                                      err->code, err->message);
475
453
                        g_error_free (err);
476
454
                        g_object_unref (msg);
477
 
                        return TRUE;
 
455
                        return;
478
456
                } else
479
 
                        debug_printf (1, "ERROR: could not parse response\n");
 
457
                        soup_test_assert (FALSE, "ERROR: could not parse response\n");
480
458
        } else
481
 
                debug_printf (1, "Unexpectedly got successful response!\n");
 
459
                soup_test_assert (FALSE, "Unexpectedly got successful response!\n");
482
460
 
483
461
        g_object_unref (msg);
484
 
        return FALSE;
485
462
}
486
463
 
487
 
static gboolean
 
464
static void
488
465
test_fault_malformed (void)
489
466
{
490
 
        debug_printf (1, "malformed request: ");
 
467
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
491
468
 
492
 
        return do_bad_xmlrpc ("<methodCall/>");
 
469
        do_bad_xmlrpc ("<methodCall/>");
493
470
}
494
471
 
495
 
static gboolean
 
472
static void
496
473
test_fault_method (void)
497
474
{
498
 
        debug_printf (1, "request to non-existent method: ");
 
475
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
499
476
 
500
 
        return do_bad_xmlrpc ("<methodCall><methodName>no_such_method</methodName><params><param><value><int>1</int></value></param></params></methodCall>");
 
477
        do_bad_xmlrpc ("<methodCall><methodName>no_such_method</methodName><params><param><value><int>1</int></value></param></params></methodCall>");
501
478
}
502
479
 
503
 
static gboolean
 
480
static void
504
481
test_fault_args (void)
505
482
{
506
 
        debug_printf (1, "request with invalid args: ");
 
483
        SOUP_TEST_SKIP_IF_NO_XMLRPC_SERVER;
507
484
 
508
 
        return do_bad_xmlrpc ("<methodCall><methodName>sum</methodName><params><param><value><int>1</int></value></param></params></methodCall>");
 
485
        do_bad_xmlrpc ("<methodCall><methodName>sum</methodName><params><param><value><int>1</int></value></param></params></methodCall>");
509
486
}
510
487
 
511
488
static GOptionEntry xmlrpc_entries[] = {
512
 
        { "uri", 'u', 0, G_OPTION_ARG_STRING, &uri,
 
489
        { "uri", 'U', 0, G_OPTION_ARG_STRING, &uri,
513
490
          "Alternate URI for server", NULL },
514
 
        { "server-test", 's', 0, G_OPTION_ARG_NONE, &server_test,
 
491
        { "server-test", 'S', 0, G_OPTION_ARG_NONE, &server_test,
515
492
          "If this is being run from xmlrpc-server-test", NULL },
516
493
        { NULL }
517
494
};
519
496
int
520
497
main (int argc, char **argv)
521
498
{
 
499
        int ret;
 
500
 
522
501
        test_init (argc, argv, xmlrpc_entries);
523
502
 
524
 
        if (!uri) {
 
503
        if (!uri && !server_test) {
525
504
                apache_init ();
526
505
                uri = default_uri;
527
506
        }
528
507
 
529
508
        session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
530
509
 
531
 
        if (!test_sum ())
532
 
                errors++;
533
 
        if (!test_countBools ())
534
 
                errors++;
535
 
        if (!test_md5sum ())
536
 
                errors++;
537
 
        if (!test_dateChange ())
538
 
                errors++;
539
 
        if (!test_echo ())
540
 
                errors++;
541
 
        if (!test_ping (TRUE))
542
 
                errors++;
543
 
        if (!test_ping (FALSE))
544
 
                errors++;
545
 
        if (!test_fault_malformed ())
546
 
                errors++;
547
 
        if (!test_fault_method ())
548
 
                errors++;
549
 
        if (!test_fault_args ())
550
 
                errors++;
 
510
        g_test_add_func ("/xmlrpc/sum", test_sum);
 
511
        g_test_add_func ("/xmlrpc/countBools", test_countBools);
 
512
        g_test_add_func ("/xmlrpc/md5sum", test_md5sum);
 
513
        g_test_add_func ("/xmlrpc/dateChange", test_dateChange);
 
514
        g_test_add_func ("/xmlrpc/echo", test_echo);
 
515
        g_test_add_data_func ("/xmlrpc/ping/empty-params", GINT_TO_POINTER (TRUE), test_ping);
 
516
        g_test_add_data_func ("/xmlrpc/ping/no-params", GINT_TO_POINTER (FALSE), test_ping);
 
517
        g_test_add_func ("/xmlrpc/fault/malformed", test_fault_malformed);
 
518
        g_test_add_func ("/xmlrpc/fault/method", test_fault_method);
 
519
        g_test_add_func ("/xmlrpc/fault/args", test_fault_args);
 
520
 
 
521
        ret = g_test_run ();
551
522
 
552
523
        soup_test_session_abort_unref (session);
553
524
 
554
525
        test_cleanup ();
555
 
        return errors != 0;
556
 
}
557
 
 
558
 
#else /* HAVE_PHP_XMLRPC */
559
 
 
560
 
int
561
 
main (int argc, char **argv)
562
 
{
563
 
        return 77; /* SKIP */
564
 
}
565
 
 
566
 
#endif
 
526
        return ret;
 
527
}