← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/cache-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/cache-test.c
264
264
}
265
265
 
266
266
static void
267
 
do_basics_test (SoupURI *base_uri)
 
267
do_basics_test (gconstpointer data)
268
268
{
 
269
        SoupURI *base_uri = (SoupURI *)data;
269
270
        SoupSession *session;
270
271
        SoupCache *cache;
271
272
        char *cache_dir;
272
273
        char *body1, *body2, *body3, *body4, *body5, *cmp;
273
274
 
274
 
        debug_printf (1, "Cache basics\n");
275
 
 
276
275
        cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
277
276
        debug_printf (2, "  Caching to %s\n", cache_dir);
278
277
        cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
307
306
        debug_printf (1, "  Fresh cached resource\n");
308
307
        cmp = do_request (session, base_uri, "GET", "/1", NULL,
309
308
                          NULL);
310
 
        if (last_request_hit_network) {
311
 
                debug_printf (1, "    Request for /1 not filled from cache!\n");
312
 
                errors++;
313
 
        }
314
 
        if (strcmp (body1, cmp) != 0) {
315
 
                debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
316
 
                              cmp, body1);
317
 
                errors++;
318
 
        }
 
309
        soup_test_assert (!last_request_hit_network,
 
310
                          "Request for /1 not filled from cache");
 
311
        g_assert_cmpstr (body1, ==, cmp);
319
312
        g_free (cmp);
320
313
 
321
314
 
323
316
        debug_printf (1, "  Heuristically-fresh cached resource\n");
324
317
        cmp = do_request (session, base_uri, "GET", "/2", NULL,
325
318
                          NULL);
326
 
        if (last_request_hit_network) {
327
 
                debug_printf (1, "    Request for /2 not filled from cache!\n");
328
 
                errors++;
329
 
        }
330
 
        if (strcmp (body2, cmp) != 0) {
331
 
                debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
332
 
                              cmp, body2);
333
 
                errors++;
334
 
        }
 
319
        soup_test_assert (!last_request_hit_network,
 
320
                          "Request for /2 not filled from cache");
 
321
        g_assert_cmpstr (body2, ==, cmp);
335
322
        g_free (cmp);
336
323
 
337
324
 
339
326
        debug_printf (1, "  Fresh cached resource with a query\n");
340
327
        cmp = do_request (session, base_uri, "GET", "/1?attr=value", NULL,
341
328
                          NULL);
342
 
        if (!last_request_hit_network) {
343
 
                debug_printf (1, "    Request for /1?attr=value filled from cache!\n");
344
 
                errors++;
345
 
        }
 
329
        soup_test_assert (last_request_hit_network,
 
330
                          "Request for /1?attr=value filled from cache");
346
331
        g_free (cmp);
347
332
        debug_printf (2, "  Second request\n");
348
333
        cmp = do_request (session, base_uri, "GET", "/1", NULL,
349
334
                          NULL);
350
 
        if (last_request_hit_network) {
351
 
                debug_printf (1, "    Second request for /1 not filled from cache!\n");
352
 
                errors++;
353
 
        }
354
 
        if (strcmp (body1, cmp) != 0) {
355
 
                debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
356
 
                              cmp, body1);
357
 
                errors++;
358
 
        }
 
335
        soup_test_assert (!last_request_hit_network,
 
336
                          "Second request for /1 not filled from cache");
 
337
        g_assert_cmpstr (body1, ==, cmp);
359
338
        g_free (cmp);
360
339
 
361
340
 
365
344
                          "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
366
345
                          "Test-Set-Cache-Control", "must-revalidate",
367
346
                          NULL);
368
 
        if (!last_request_validated) {
369
 
                debug_printf (1, "    Request for /3 not validated!\n");
370
 
                errors++;
371
 
        }
372
 
        if (last_request_hit_network) {
373
 
                debug_printf (1, "    Request for /3 not filled from cache!\n");
374
 
                errors++;
375
 
        }
376
 
        if (strcmp (body3, cmp) != 0) {
377
 
                debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
378
 
                              cmp, body3);
379
 
                errors++;
380
 
        }
 
347
        soup_test_assert (last_request_validated,
 
348
                          "Request for /3 not validated");
 
349
        soup_test_assert (!last_request_hit_network,
 
350
                          "Request for /3 not filled from cache");
 
351
        g_assert_cmpstr (body3, ==, cmp);
381
352
        g_free (cmp);
382
353
 
383
354
 
387
358
                          "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
388
359
                          "Test-Set-Cache-Control", "must-revalidate",
389
360
                          NULL);
390
 
        if (!last_request_validated) {
391
 
                debug_printf (1, "    Request for /3 not validated!\n");
392
 
                errors++;
393
 
        }
394
 
        if (!last_request_hit_network) {
395
 
                debug_printf (1, "    Request for /3 filled from cache!\n");
396
 
                errors++;
397
 
        }
398
 
        if (strcmp (body3, cmp) == 0) {
399
 
                debug_printf (1, "    Request for /3 returned cached response\n");
400
 
                errors++;
401
 
        }
 
361
        soup_test_assert (last_request_validated,
 
362
                          "Request for /3 not validated");
 
363
        soup_test_assert (last_request_hit_network,
 
364
                          "Request for /3 filled from cache");
 
365
        g_assert_cmpstr (body3, !=, cmp);
402
366
        g_free (cmp);
403
367
 
404
368
        debug_printf (2, "  Second request\n");
406
370
                          "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
407
371
                          "Test-Set-Cache-Control", "must-revalidate",
408
372
                          NULL);
409
 
        if (!last_request_validated) {
410
 
                debug_printf (1, "    Second request for /3 not validated!\n");
411
 
                errors++;
412
 
        }
413
 
        if (last_request_hit_network) {
414
 
                debug_printf (1, "    Second request for /3 not filled from cache!\n");
415
 
                errors++;
416
 
        }
417
 
        if (strcmp (body3, cmp) == 0) {
418
 
                debug_printf (1, "    Replacement body for /3 not cached!\n");
419
 
                errors++;
420
 
        }
 
373
        soup_test_assert (last_request_validated,
 
374
                          "Second request for /3 not validated");
 
375
        soup_test_assert (!last_request_hit_network,
 
376
                          "Second request for /3 not filled from cache");
 
377
        g_assert_cmpstr (body3, !=, cmp);
421
378
        g_free (cmp);
422
379
 
423
380
        /* ETag + must-revalidate causes a conditional request */
425
382
        cmp = do_request (session, base_uri, "GET", "/4", NULL,
426
383
                          "Test-Set-ETag", "\"abcdefg\"",
427
384
                          NULL);
428
 
        if (!last_request_validated) {
429
 
                debug_printf (1, "    Request for /4 not validated!\n");
430
 
                errors++;
431
 
        }
432
 
        if (last_request_hit_network) {
433
 
                debug_printf (1, "    Request for /4 not filled from cache!\n");
434
 
                errors++;
435
 
        }
436
 
        if (strcmp (body4, cmp) != 0) {
437
 
                debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
438
 
                              cmp, body4);
439
 
                errors++;
440
 
        }
 
385
        soup_test_assert (last_request_validated,
 
386
                          "Request for /4 not validated");
 
387
        soup_test_assert (!last_request_hit_network,
 
388
                          "Request for /4 not filled from cache");
 
389
        g_assert_cmpstr (body4, ==, cmp);
441
390
        g_free (cmp);
442
391
 
443
392
 
446
395
        cmp = do_request (session, base_uri, "GET", "/5", NULL,
447
396
                          "Test-Set-Cache-Control", "no-cache",
448
397
                          NULL);
449
 
        if (!last_request_hit_network) {
450
 
                debug_printf (1, "    Request for /5 filled from cache!\n");
451
 
                errors++;
452
 
        }
453
 
        if (strcmp (body5, cmp) != 0) {
454
 
                debug_printf (1, "    Re-retrieved response (%s) did not match original (%s)\n",
455
 
                              cmp, body5);
456
 
                errors++;
457
 
        }
 
398
        soup_test_assert (last_request_hit_network,
 
399
                          "Request for /5 filled from cache");
 
400
        g_assert_cmpstr (body5, ==, cmp);
458
401
        g_free (cmp);
459
402
 
460
403
 
462
405
        debug_printf (1, "  Invalidating and re-requesting a cached resource\n");
463
406
        cmp = do_request (session, base_uri, "PUT", "/1", NULL,
464
407
                          NULL);
465
 
        if (!last_request_hit_network) {
466
 
                debug_printf (1, "    PUT filled from cache!\n");
467
 
                errors++;
468
 
        }
 
408
        soup_test_assert (last_request_hit_network,
 
409
                          "PUT filled from cache");
469
410
        g_free (cmp);
470
411
        cmp = do_request (session, base_uri, "GET", "/1", NULL,
471
412
                          NULL);
472
 
        if (!last_request_hit_network) {
473
 
                debug_printf (1, "    PUT failed to invalidate cache entry!\n");
474
 
                errors++;
475
 
        }
 
413
        soup_test_assert (last_request_hit_network,
 
414
                          "PUT failed to invalidate cache entry");
 
415
        g_assert_true (last_request_hit_network);
476
416
        g_free (cmp);
477
417
 
478
418
 
488
428
}
489
429
 
490
430
static void
491
 
do_cancel_test (SoupURI *base_uri)
 
431
do_cancel_test (gconstpointer data)
492
432
{
 
433
        SoupURI *base_uri = (SoupURI *)data;
493
434
        SoupSession *session;
494
435
        SoupCache *cache;
495
436
        char *cache_dir;
496
437
        char *body1, *body2;
497
438
        guint flags;
498
439
 
499
 
        debug_printf (1, "Cache cancel tests\n");
 
440
        g_test_bug ("692310");
500
441
 
501
442
        cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
502
443
        debug_printf (2, "  Caching to %s\n", cache_dir);
521
462
        debug_printf (1, "  Cancel fresh resource with soup_session_message_cancel()\n");
522
463
        flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
523
464
        do_request_with_cancel (session, base_uri, "GET", "/1", flags);
524
 
        if (cancelled_requests != 1) {
525
 
                debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
526
 
                              cancelled_requests);
527
 
                errors++;
528
 
        }
 
465
        g_assert_cmpint (cancelled_requests, ==, 1);
529
466
 
530
467
        debug_printf (1, "  Cancel fresh resource with g_cancellable_cancel()\n");
531
468
        flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
532
469
        do_request_with_cancel (session, base_uri, "GET", "/1", flags);
533
 
        if (cancelled_requests != 1) {
534
 
                debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
535
 
                              cancelled_requests);
536
 
                errors++;
537
 
        }
 
470
        g_assert_cmpint (cancelled_requests, ==, 1);
538
471
 
539
472
        soup_test_session_abort_unref (session);
540
473
 
549
482
        debug_printf (1, "  Cancel a revalidating resource with soup_session_message_cancel()\n");
550
483
        flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
551
484
        do_request_with_cancel (session, base_uri, "GET", "/2", flags);
552
 
        if (cancelled_requests != 2) {
553
 
                debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
554
 
                              cancelled_requests);
555
 
                errors++;
556
 
        }
 
485
        g_assert_cmpint (cancelled_requests, ==, 2);
557
486
 
558
487
        debug_printf (1, "  Cancel a revalidating resource with g_cancellable_cancel()\n");
559
488
        flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
560
489
        do_request_with_cancel (session, base_uri, "GET", "/2", flags);
561
 
        if (cancelled_requests != 2) {
562
 
                debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
563
 
                              cancelled_requests);
564
 
                errors++;
565
 
        }
 
490
        g_assert_cmpint (cancelled_requests, ==, 2);
566
491
 
567
492
        soup_test_session_abort_unref (session);
568
493
 
586
511
}
587
512
 
588
513
static void
589
 
do_refcounting_test (SoupURI *base_uri)
 
514
do_refcounting_test (gconstpointer data)
590
515
{
 
516
        SoupURI *base_uri = (SoupURI *)data;
591
517
        SoupSession *session;
592
518
        SoupCache *cache;
593
519
        char *cache_dir;
598
524
        guint flags;
599
525
        GMainLoop *loop;
600
526
 
601
 
        debug_printf (1, "Cache refcounting tests\n");
 
527
        g_test_bug ("682527");
602
528
 
603
529
        cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
604
530
        debug_printf (2, "  Caching to %s\n", cache_dir);
644
570
}
645
571
 
646
572
static void
647
 
do_headers_test (SoupURI *base_uri)
 
573
do_headers_test (gconstpointer data)
648
574
{
 
575
        SoupURI *base_uri = (SoupURI *)data;
649
576
        SoupSession *session;
650
577
        SoupMessageHeaders *headers;
651
578
        SoupCache *cache;
653
580
        char *body1, *cmp;
654
581
        const char *header_value;
655
582
 
656
 
        debug_printf (1, "Cache basics\n");
657
 
 
658
583
        cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
659
584
        debug_printf (2, "  Caching to %s\n", cache_dir);
660
585
        cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
678
603
                          "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
679
604
                          "Test-Set-My-Header", "My header NEW value",
680
605
                          NULL);
681
 
        if (!last_request_validated) {
682
 
                debug_printf (1, "    Request for /1 not validated!\n");
683
 
                errors++;
684
 
        }
685
 
        if (last_request_hit_network) {
686
 
                debug_printf (1, "    Request for /1 not filled from cache!\n");
687
 
                errors++;
688
 
        }
 
606
        soup_test_assert (last_request_validated,
 
607
                          "Request for /1 not validated");
 
608
        soup_test_assert (!last_request_hit_network,
 
609
                          "Request for /1 not filled from cache");
689
610
        g_free (cmp);
690
611
 
691
612
        /* Check that cache returns the updated header */
694
615
        cmp = do_request (session, base_uri, "GET", "/1", headers,
695
616
                          "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
696
617
                          NULL);
697
 
        if (last_request_hit_network) {
698
 
                debug_printf (1, "    Request for /1 not filled from cache!\n");
699
 
                errors++;
700
 
        }
 
618
        soup_test_assert (!last_request_hit_network,
 
619
                          "Request for /1 not filled from cache");
701
620
        g_free (cmp);
702
621
 
703
622
        header_value = soup_message_headers_get_list (headers, "My-Header");
704
 
        if (!header_value) {
705
 
                debug_printf (1, "    Header \"My-Header\" not present!\n");
706
 
                errors++;
707
 
        } else if (strcmp (header_value, "My header NEW value") != 0) {
708
 
                debug_printf (1, "    \"My-Header = %s\" and should be \"%s\"\n",
709
 
                              header_value,
710
 
                              "My header NEW value");
711
 
                errors++;
712
 
        }
 
623
        g_assert_cmpstr (header_value, ==, "My header NEW value");
713
624
        soup_message_headers_free (headers);
714
625
 
715
626
        soup_test_session_abort_unref (session);
724
635
{
725
636
        SoupServer *server;
726
637
        SoupURI *base_uri;
 
638
        int ret;
727
639
 
728
640
        test_init (argc, argv, NULL);
729
641
 
732
644
        base_uri = soup_uri_new ("http://127.0.0.1/");
733
645
        soup_uri_set_port (base_uri, soup_server_get_port (server));
734
646
 
735
 
        do_basics_test (base_uri);
736
 
        do_cancel_test (base_uri);
737
 
        do_refcounting_test (base_uri);
738
 
        do_headers_test (base_uri);
 
647
        g_test_add_data_func ("/cache/basics", base_uri, do_basics_test);
 
648
        g_test_add_data_func ("/cache/cancellation", base_uri, do_cancel_test);
 
649
        g_test_add_data_func ("/cache/refcounting", base_uri, do_refcounting_test);
 
650
        g_test_add_data_func ("/cache/headers", base_uri, do_headers_test);
 
651
 
 
652
        ret = g_test_run ();
739
653
 
740
654
        soup_uri_free (base_uri);
741
655
        soup_test_server_quit_unref (server);
742
656
 
743
657
        test_cleanup ();
744
 
        return errors != 0;
 
658
        return ret;
745
659
}