/* * Copyright 2015 Vincent Sanders * Copyright 2011 John Mark Bell * * This file is part of NetSurf, http://www.netsurf-browser.org/ * * NetSurf is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; version 2 of the License. * * NetSurf is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ /** * \file * Test nsurl operations. */ #include #include #include #include #include #include #include #include "utils/corestrings.h" #include "utils/log.h" #include "utils/corestrings.h" #include "utils/nsurl.h" #include "utils/nsoption.h" #include "netsurf/url_db.h" #include "netsurf/cookie_db.h" #include "netsurf/bitmap.h" #include "content/urldb.h" #include "desktop/gui_internal.h" #include "desktop/cookie_manager.h" /** * url database used as input to test sets */ const char *test_urldb_path = "test/data/urldb"; /** * url database used as output reference */ const char *test_urldb_out_path = "test/data/urldb-out"; /** * cookie database used as input */ const char *test_cookies_path = "test/data/cookies"; /** * cookie database used as output reference */ const char *test_cookies_out_path = "test/data/cookies-out"; const char *wikipedia_url = "http://www.wikipedia.org/"; struct netsurf_table *guit = NULL; struct test_urls { const char* url; const char* title; const content_type type; const bool persistent; }; #define NELEMS(x) (sizeof(x) / sizeof((x)[0])) /* Stubs */ nserror nslog_set_filter_by_options() { return NSERROR_OK; } /** * generate test output filenames */ static char *testnam(char *out) { static int count = 0; static char name[64]; snprintf(name, 64, "/tmp/urldbtest%d-%d", getpid(), count); count++; return name; } /** * compare two files contents */ static int cmp(const char *f1, const char *f2) { int res = 0; FILE *fp1; FILE *fp2; int ch1; int ch2; fp1 = fopen(f1, "r"); if (fp1 == NULL) { return -1; } fp2 = fopen(f2, "r"); if (fp2 == NULL) { fclose(fp1); return -1; } while (res == 0) { ch1 = fgetc(fp1); ch2 = fgetc(fp2); if (ch1 != ch2) { res = 1; } if (ch1 == EOF) { break; } } fclose(fp1); fclose(fp2); return res; } /*************** original test helpers ************/ bool cookie_manager_add(const struct cookie_data *data) { return true; } void cookie_manager_remove(const struct cookie_data *data) { } static nsurl *make_url(const char *url) { nsurl *nsurl; if (nsurl_create(url, &nsurl) != NSERROR_OK) { NSLOG(netsurf, INFO, "failed creating nsurl"); exit(1); } return nsurl; } static bool test_urldb_set_cookie(const char *header, const char *url, const char *referer) { nsurl *r = NULL; nsurl *nsurl = make_url(url); bool ret; if (referer != NULL) r = make_url(referer); ret = urldb_set_cookie(header, nsurl, r); if (referer != NULL) nsurl_unref(r); nsurl_unref(nsurl); return ret; } static char *test_urldb_get_cookie(const char *url) { nsurl *nsurl = make_url(url); char *ret; ret = urldb_get_cookie(nsurl, true); nsurl_unref(nsurl); return ret; } /*************************************************/ /* mock table callbacks */ static void destroy_bitmap(void *b) { } struct gui_bitmap_table tst_bitmap_table = { .destroy = destroy_bitmap, }; struct netsurf_table tst_table = { .bitmap = &tst_bitmap_table, }; /** urldb create fixture */ static void urldb_create(void) { nserror res; /* mock bitmap interface */ guit = &tst_table; res = corestrings_init(); ck_assert_int_eq(res, NSERROR_OK); } /** urldb create pre-loaded db fixture */ static void urldb_create_loaded(void) { nserror res; /* mock bitmap interface */ guit = &tst_table; res = corestrings_init(); ck_assert_int_eq(res, NSERROR_OK); res = urldb_load(test_urldb_path); ck_assert_int_eq(res, NSERROR_OK); urldb_load_cookies(test_cookies_path); } static void urldb_lwc_iterator(lwc_string *str, void *pw) { int *scount = pw; NSLOG(netsurf, INFO, "[%3u] %.*s", str->refcnt, (int)lwc_string_length(str), lwc_string_data(str)); (*scount)++; } /** urldb teardown fixture with destroy */ static void urldb_teardown(void) { int scount = 0; urldb_destroy(); corestrings_fini(); NSLOG(netsurf, INFO, "Remaining lwc strings:"); lwc_iterate_strings(urldb_lwc_iterator, &scount); ck_assert_int_eq(scount, 0); } START_TEST(urldb_original_test) { nsurl *url; nsurl *urlr; /* fragments */ url = make_url("http://netsurf.strcprstskrzkrk.co.uk/path/to/resource.htm?a=b"); ck_assert(urldb_add_url(url) == true); nsurl_unref(url); url = make_url("http://netsurf.strcprstskrzkrk.co.uk/path/to/resource.htm#zz?a=b"); ck_assert(urldb_add_url(url) == true); nsurl_unref(url); url = make_url("http://netsurf.strcprstskrzkrk.co.uk/path/to/resource.htm#aa?a=b"); ck_assert(urldb_add_url(url) == true); nsurl_unref(url); url = make_url("http://netsurf.strcprstskrzkrk.co.uk/path/to/resource.htm#yy?a=b"); ck_assert(urldb_add_url(url) == true); nsurl_unref(url); /* set cookies on urls */ url = make_url("http://www.minimarcos.org.uk/cgi-bin/forum/Blah.pl?,v=login,p=2"); urldb_set_cookie("mmblah=foo; path=/; expires=Thur, 31-Dec-2099 00:00:00 GMT\r\n", url, NULL); nsurl_unref(url); url = make_url("http://www.minimarcos.org.uk/cgi-bin/forum/Blah.pl?,v=login,p=2"); urldb_set_cookie("BlahPW=bar; path=/; expires=Thur, 31-Dec-2099 00:00:00 GMT\r\n", url, NULL); nsurl_unref(url); url = make_url("http://ccdb.cropcircleresearch.com/"); urldb_set_cookie("details=foo|bar|Sun, 03-Jun-2007;expires=Mon, 24-Jul-2006 09:53:45 GMT\r\n", url, NULL); nsurl_unref(url); url = make_url("http://www.google.com/"); urldb_set_cookie("PREF=ID=a:TM=b:LM=c:S=d; path=/; domain=.google.com\r\n", url, NULL); nsurl_unref(url); url = make_url("http://www.bbc.co.uk/"); urldb_set_cookie("test=foo, bar, baz; path=/, quux=blah; path=/", url, NULL); nsurl_unref(url); // urldb_set_cookie("a=b; path=/; domain=.a.com", "http://a.com/", NULL); url = make_url("https://www.foo.com/blah/moose"); urlr = make_url("https://www.foo.com/blah/moose"); urldb_set_cookie("foo=bar;Path=/blah;Secure\r\n", url, urlr); nsurl_unref(url); nsurl_unref(urlr); url = make_url("https://www.foo.com/blah/wxyzabc"); urldb_get_cookie(url, true); nsurl_unref(url); /* Valid path */ ck_assert(test_urldb_set_cookie("name=value;Path=/\r\n", "http://www.google.com/", NULL)); /* Valid path (non-root directory) */ ck_assert(test_urldb_set_cookie("name=value;Path=/foo/bar/\r\n", "http://www.example.org/foo/bar/", NULL)); /* Defaulted path */ ck_assert(test_urldb_set_cookie("name=value\r\n", "http://www.example.org/foo/bar/baz/bat.html", NULL)); ck_assert(test_urldb_get_cookie("http://www.example.org/foo/bar/baz/quux.htm") != NULL); /* Defaulted path with no non-leaf path segments */ ck_assert(test_urldb_set_cookie("name=value\r\n", "http://no-non-leaf.example.org/index.html", NULL)); ck_assert(test_urldb_get_cookie("http://no-non-leaf.example.org/page2.html") != NULL); ck_assert(test_urldb_get_cookie("http://no-non-leaf.example.org/") != NULL); /* Valid path (includes leafname) */ ck_assert(test_urldb_set_cookie("name=value;Version=1;Path=/index.cgi\r\n", "http://example.org/index.cgi", NULL)); ck_assert(test_urldb_get_cookie("http://example.org/index.cgi") != NULL); /* Valid path (includes leafname in non-root directory) */ ck_assert(test_urldb_set_cookie("name=value;Path=/foo/index.html\r\n", "http://www.example.org/foo/index.html", NULL)); /* Should _not_ match the above, as the leafnames differ */ ck_assert(test_urldb_get_cookie("http://www.example.org/foo/bar.html") == NULL); /* Invalid path (contains different leafname) */ ck_assert(test_urldb_set_cookie("name=value;Path=/index.html\r\n", "http://example.org/index.htm", NULL) == false); /* Invalid path (contains leafname in different directory) */ ck_assert(test_urldb_set_cookie("name=value;Path=/foo/index.html\r\n", "http://www.example.org/bar/index.html", NULL) == false); /* Test partial domain match with IP address failing */ ck_assert(test_urldb_set_cookie("name=value;Domain=.foo.org\r\n", "http://192.168.0.1/", NULL) == false); /* Test handling of non-domain cookie sent by server (domain part should * be ignored) */ ck_assert(test_urldb_set_cookie("foo=value;Domain=blah.com\r\n", "http://www.example.com/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://www.example.com/"), "foo=value") == 0); /* Test handling of domain cookie from wrong host (strictly invalid but * required to support the real world) */ ck_assert(test_urldb_set_cookie("name=value;Domain=.example.com\r\n", "http://foo.bar.example.com/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://www.example.com/"), "foo=value; name=value") == 0); /* Test presence of separators in cookie value */ ck_assert(test_urldb_set_cookie("name=\"value=foo\\\\bar\\\\\\\";\\\\baz=quux\";Version=1\r\n", "http://www.example.org/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://www.example.org/"), "$Version=1; name=\"value=foo\\\\bar\\\\\\\";\\\\baz=quux\"") == 0); /* Test cookie with blank value */ ck_assert(test_urldb_set_cookie("a=\r\n", "http://www.example.net/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://www.example.net/"), "a=") == 0); /* Test specification of multiple cookies in one header */ ck_assert(test_urldb_set_cookie("a=b, foo=bar; Path=/\r\n", "http://www.example.net/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://www.example.net/"), "a=b; foo=bar") == 0); /* Test use of separators in unquoted cookie value */ ck_assert(test_urldb_set_cookie("foo=moo@foo:blah?moar\\ text\r\n", "http://example.com/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://example.com/"), "foo=moo@foo:blah?moar\\ text; name=value") == 0); /* Test use of unnecessary quotes */ ck_assert(test_urldb_set_cookie("foo=\"hello\";Version=1,bar=bat\r\n", "http://example.com/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://example.com/"), "foo=\"hello\"; bar=bat; name=value") == 0); /* Test domain matching in unverifiable transactions */ ck_assert(test_urldb_set_cookie("foo=bar; domain=.example.tld\r\n", "http://www.foo.example.tld/", "http://bar.example.tld/")); ck_assert(strcmp(test_urldb_get_cookie("http://www.foo.example.tld/"), "foo=bar") == 0); /* Test expiry */ ck_assert(test_urldb_set_cookie("foo=bar", "http://expires.com/", NULL)); ck_assert(strcmp(test_urldb_get_cookie("http://expires.com/"), "foo=bar") == 0); ck_assert(test_urldb_set_cookie("foo=bar; expires=Thu, 01-Jan-1970 00:00:01 GMT\r\n", "http://expires.com/", NULL)); ck_assert(test_urldb_get_cookie("http://expires.com/") == NULL); urldb_dump(); } END_TEST /** * test case comprised of tests historicaly found in netsurf * * These tests are carried forward from original open coded tests * found in the url database code. */ static TCase *urldb_original_case_create(void) { TCase *tc; tc = tcase_create("Original_tests"); /* ensure corestrings are initialised and finalised for every test */ tcase_add_checked_fixture(tc, urldb_create, urldb_teardown); tcase_add_test(tc, urldb_original_test); return tc; } /** * add set and get tests */ static const struct test_urls add_set_get_tests[] = { { "http://intranet/", "foo", CONTENT_HTML, false }, /* from legacy tests */ { "http:moodle.org", "buggy", CONTENT_HTML, false }, /* Mantis bug #993 */ { "http://a_a/", "buggsy", CONTENT_HTML, false }, /* Mantis bug #993 */ { "http://www2.2checkout.com/", "foobar", CONTENT_HTML, false }, /* Mantis bug #913 */ { "http://2.bp.blogspot.com/_448y6kVhntg/TSekubcLJ7I/AAAAAAAAHJE/yZTsV5xT5t4/s1600/covers.jpg", "a more complex title", CONTENT_IMAGE, true }, /* Numeric subdomains */ { "http://tree.example.com/this_url_has_a_ridiculously_long_path/made_up_from_a_number_of_inoranately_long_elments_some_of_well_over_forty/characters_in_length/the_whole_path_comes_out_well_in_excess_of_two_hundred_characters_in_length/this_is_intended_to_try_and_drive/the_serialisation_code_mad/foo.png", NULL, CONTENT_IMAGE, false }, { "https://tree.example.com:8080/example.png", "fishy port ", CONTENT_HTML, false }, { "http://tree.example.com/bar.png", "\t ", CONTENT_IMAGE, false }, /* silly title */ { "http://[2001:db8:1f70::999:de8:7648:6e8]:100/", "ipv6 with port", CONTENT_TEXTPLAIN, false }, { "file:///home/", NULL, CONTENT_HTML, false }, /* no title */ { "http://foo@moose.com/", NULL, CONTENT_HTML, false }, /* Mantis bug #996 */ { "http://a.xn--11b4c3d/a", "a title", CONTENT_HTML, false }, { "https://smog.大众汽车/test", "unicode title 大众汽车", CONTENT_HTML, false }, }; /** * add set and get test */ START_TEST(urldb_add_set_get_test) { nserror err; nsurl *url; nsurl *res_url; const struct url_data *data; const struct test_urls *tst = &add_set_get_tests[_i]; /* not testing create, this should always succeed */ err = nsurl_create(tst->url, &url); ck_assert(err == NSERROR_OK); /* add the url to the database */ ck_assert(urldb_add_url(url) == true); /* set title */ err = urldb_set_url_title(url, tst->title); ck_assert(err == NSERROR_OK); err = urldb_set_url_content_type(url, tst->type); ck_assert(err == NSERROR_OK); /* retrieve the url from the database and check it matches */ res_url = urldb_get_url(url); ck_assert(res_url != NULL); ck_assert(nsurl_compare(url, res_url, NSURL_COMPLETE) == true); /* retrieve url data and check title matches */ data = urldb_get_url_data(url); ck_assert(data != NULL); /* ensure title matches */ if (tst->title != NULL) { ck_assert_str_eq(data->title, tst->title); } else { ck_assert(data->title == NULL); } /* ensure type matches */ ck_assert(data->type == tst->type); /* release test url */ nsurl_unref(url); } END_TEST /** * test cases that simply add and then get a url * * these tests exercise the adding and retrival of urls verifying the * data added. */ static TCase *urldb_add_get_case_create(void) { TCase *tc; tc = tcase_create("Add Get tests"); /* ensure corestrings are initialised and finalised for every test */ tcase_add_checked_fixture(tc, urldb_create, urldb_teardown); tcase_add_loop_test(tc, urldb_add_set_get_test, 0, NELEMS(add_set_get_tests)); return tc; } /** * Session basic test case * * The databases are loaded and saved with no manipulation * * \warning This test will fail when 32bit time_t wraps in 2038 as the * cookie database expiry field is limited to that size. */ START_TEST(urldb_session_test) { nserror res; char *outnam; /* writing output requires options initialising */ res = nsoption_init(NULL, NULL, NULL); ck_assert_int_eq(res, NSERROR_OK); res = urldb_load(test_urldb_path); ck_assert_int_eq(res, NSERROR_OK); urldb_load_cookies(test_cookies_path); /* write database out */ outnam = testnam(NULL); res = urldb_save(outnam); ck_assert_int_eq(res, NSERROR_OK); /* check the url database file written and the test file match */ ck_assert_int_eq(cmp(outnam, test_urldb_out_path), 0); /* remove test output */ unlink(outnam); /* write cookies out */ outnam = testnam(NULL); urldb_save_cookies(outnam); /* check the cookies file written and the test file match */ ck_assert_int_eq(cmp(outnam, test_cookies_out_path), 0); /* remove test output */ unlink(outnam); /* finalise options */ res = nsoption_finalise(NULL, NULL); ck_assert_int_eq(res, NSERROR_OK); } END_TEST /** * Session more extensive test case * * The databases are loaded and saved with a host and paths added */ START_TEST(urldb_session_add_test) { nserror res; char *outnam; nsurl *url; unsigned int t; /* writing output requires options initialising */ res = nsoption_init(NULL, NULL, NULL); ck_assert_int_eq(res, NSERROR_OK); res = urldb_load(test_urldb_path); ck_assert_int_eq(res, NSERROR_OK); urldb_load_cookies(test_cookies_path); /* add to db */ for (t = 0; t < NELEMS(add_set_get_tests); t++) { const struct test_urls *tst = &add_set_get_tests[t]; /* not testing url creation, this should always succeed */ res = nsurl_create(tst->url, &url); ck_assert_int_eq(res, NSERROR_OK); /* add the url to the database */ ck_assert(urldb_add_url(url) == true); /* set title */ res = urldb_set_url_title(url, tst->title); ck_assert(res == NSERROR_OK); /* update the visit time so it gets serialised */ if (tst->persistent) { res = urldb_set_url_persistence(url, true); } else { res = urldb_update_url_visit_data(url); } ck_assert_int_eq(res, NSERROR_OK); nsurl_unref(url); } /* write database out */ outnam = testnam(NULL); res = urldb_save(outnam); ck_assert_int_eq(res, NSERROR_OK); /* remove urldb test output */ unlink(outnam); /* write cookies out */ outnam = testnam(NULL); urldb_save_cookies(outnam); /* remove cookies test output */ unlink(outnam); /* finalise options */ res = nsoption_finalise(NULL, NULL); ck_assert_int_eq(res, NSERROR_OK); } END_TEST /** * Test case to check entire session * * These tests define a session as loading a url database and cookie * database and then saving them back to disc. */ static TCase *urldb_session_case_create(void) { TCase *tc; tc = tcase_create("Full_session"); /* ensure corestrings are initialised and finalised for every test */ tcase_add_checked_fixture(tc, urldb_create, urldb_teardown); tcase_add_test(tc, urldb_session_test); tcase_add_test(tc, urldb_session_add_test); return tc; } static int cb_count; static bool urldb_iterate_entries_cb(nsurl *url, const struct url_data *data) { NSLOG(netsurf, INFO, "url: %s", nsurl_access(url)); /* fprintf(stderr, "url:%s\ntitle:%s\n\n",nsurl_access(url), data->title); */ cb_count++; return true; } START_TEST(urldb_iterate_entries_test) { urldb_iterate_entries(urldb_iterate_entries_cb); } END_TEST /** * iterate through partial matches */ START_TEST(urldb_iterate_partial_www_test) { cb_count = 0; urldb_iterate_partial("www", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 7); } END_TEST /** * iterate through partial matches */ START_TEST(urldb_iterate_partial_nomatch_test) { cb_count = 0; urldb_iterate_partial("/", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 0); } END_TEST /** * iterate through partial matches */ START_TEST(urldb_iterate_partial_add_test) { nsurl *url; cb_count = 0; urldb_iterate_partial("wikipedia", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 0); url = make_url(wikipedia_url); urldb_add_url(url); nsurl_unref(url); cb_count = 0; urldb_iterate_partial("wikipedia", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 1); } END_TEST /** * iterate through partial matches */ START_TEST(urldb_iterate_partial_path_test) { cb_count = 0; urldb_iterate_partial("en.wikipedia.org/wiki", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 2); } END_TEST /** * iterate through partial matches of numeric v4 address */ START_TEST(urldb_iterate_partial_numeric_v4_test) { nsurl *url; cb_count = 0; urldb_iterate_partial("192.168.7.1/", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 0); url = make_url("http://192.168.7.1/index.html"); urldb_add_url(url); nsurl_unref(url); cb_count = 0; urldb_iterate_partial("192.168.7.1/", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 1); } END_TEST /** * iterate through partial matches of numeric v6 address */ START_TEST(urldb_iterate_partial_numeric_v6_test) { nsurl *url; cb_count = 0; urldb_iterate_partial("[2001:db8:1f70::999:de8:7648:6e8]", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 0); url = make_url("http://[2001:db8:1f70::999:de8:7648:6e8]/index.html"); urldb_add_url(url); nsurl_unref(url); cb_count = 0; urldb_iterate_partial("[2001:db8:1f70::999:de8:7648:6e8]/index.wrong", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 0); cb_count = 0; urldb_iterate_partial("[2001:db8:1f70::999:de8:7648:6e8]", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 1); cb_count = 0; urldb_iterate_partial("[2001:db8:1f70::999:de8:7648:6e8]/in", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 1); /* double path separators are ignored */ cb_count = 0; urldb_iterate_partial("[2001:db8:1f70::999:de8:7648:6e8]//index.html", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 1); /* bad ipv6 address inet_pton should fail with this */ cb_count = 0; urldb_iterate_partial("[2001::1f70::999::7648:8]", urldb_iterate_entries_cb); ck_assert_int_eq(cb_count, 0); } END_TEST START_TEST(urldb_auth_details_test) { nsurl *url; const char *res; const char *auth = "mooooo"; url = make_url(wikipedia_url); urldb_set_auth_details(url, "tree", auth); res = urldb_get_auth_details(url, "tree"); ck_assert_str_eq(res, auth); nsurl_unref(url); } END_TEST START_TEST(urldb_cert_permissions_test) { nsurl *url; bool permit; url = make_url(wikipedia_url); urldb_set_cert_permissions(url, true); /* permit invalid certs for url */ permit = urldb_get_cert_permissions(url); ck_assert(permit == true); urldb_set_cert_permissions(url, false); /* do not permit invalid certs for url */ permit = urldb_get_cert_permissions(url); ck_assert(permit == false); nsurl_unref(url); } END_TEST START_TEST(urldb_update_visit_test) { nsurl *url; url = make_url(wikipedia_url); urldb_update_url_visit_data(url); urldb_add_url(url); urldb_update_url_visit_data(url); /** \todo test needs to check results */ nsurl_unref(url); } END_TEST START_TEST(urldb_reset_visit_test) { nsurl *url; url = make_url(wikipedia_url); urldb_reset_url_visit_data(url); urldb_add_url(url); urldb_reset_url_visit_data(url); /** \todo test needs to check results */ nsurl_unref(url); } END_TEST START_TEST(urldb_persistence_test) { nsurl *url; url = make_url(wikipedia_url); urldb_set_url_persistence(url, true); urldb_add_url(url); urldb_set_url_persistence(url, true); urldb_set_url_persistence(url, false); /** \todo test needs to check results */ nsurl_unref(url); } END_TEST static TCase *urldb_case_create(void) { TCase *tc; tc = tcase_create("General"); /* ensure corestrings are initialised and finalised for every test */ tcase_add_checked_fixture(tc, urldb_create_loaded, urldb_teardown); tcase_add_test(tc, urldb_iterate_entries_test); tcase_add_test(tc, urldb_iterate_partial_www_test); tcase_add_test(tc, urldb_iterate_partial_nomatch_test); tcase_add_test(tc, urldb_iterate_partial_add_test); tcase_add_test(tc, urldb_iterate_partial_path_test); tcase_add_test(tc, urldb_iterate_partial_numeric_v4_test); tcase_add_test(tc, urldb_iterate_partial_numeric_v6_test); tcase_add_test(tc, urldb_auth_details_test); tcase_add_test(tc, urldb_cert_permissions_test); tcase_add_test(tc, urldb_update_visit_test); tcase_add_test(tc, urldb_reset_visit_test); tcase_add_test(tc, urldb_persistence_test); return tc; } static bool urldb_iterate_cookies_cb(const struct cookie_data *data) { NSLOG(netsurf, INFO, "%p", data); /* fprintf(stderr, "domain:%s\npath:%s\nname:%s\n\n",data->domain, data->path, data->name);*/ return true; } START_TEST(urldb_iterate_cookies_test) { urldb_iterate_cookies(urldb_iterate_cookies_cb); } END_TEST START_TEST(urldb_cookie_create_test) { /* Valid path (includes leafname) */ const char *cookie_hdr = "name=value;Version=1;Path=/index.cgi\r\n"; const char *cookie = "$Version=1; name=value; $Path=\"/index.cgi\""; char *cdata; /* cookie data */ ck_assert(test_urldb_set_cookie(cookie_hdr, "http://example.org/index.cgi", NULL)); cdata = test_urldb_get_cookie("http://example.org/index.cgi"); ck_assert_str_eq(cdata, cookie); } END_TEST START_TEST(urldb_cookie_delete_test) { /* Valid path (includes leafname) */ const char *cookie_hdr = "name=value;Version=1;Path=/index.cgi\r\n"; const char *cookie = "$Version=1; name=value; $Path=\"/index.cgi\""; char *cdata; /* cookie data */ ck_assert(test_urldb_set_cookie(cookie_hdr, "http://example.org/index.cgi", NULL)); cdata = test_urldb_get_cookie("http://example.org/index.cgi"); ck_assert_str_eq(cdata, cookie); urldb_delete_cookie("example.org", "/index.cgi", "name"); cdata = test_urldb_get_cookie("http://example.org/index.cgi"); ck_assert(cdata == NULL); } END_TEST /** * Test case for urldb cookie management */ static TCase *urldb_cookie_case_create(void) { TCase *tc; tc = tcase_create("Cookies"); /* ensure corestrings are initialised and finalised for every test */ tcase_add_checked_fixture(tc, urldb_create_loaded, urldb_teardown); tcase_add_test(tc, urldb_cookie_create_test); tcase_add_test(tc, urldb_iterate_cookies_test); tcase_add_test(tc, urldb_cookie_delete_test); return tc; } /** * Test urldb_add_url asserting on NULL. */ START_TEST(urldb_api_add_url_assert_test) { bool res; res = urldb_add_url(NULL); ck_assert(res == true); } END_TEST /** * Test urldb find failing for differing bad url. */ START_TEST(urldb_api_url_find_test) { nsurl *url; nserror res; urldb_create(); /* search for a url with mailto scheme */ res = nsurl_create("mailto:", &url); ck_assert_int_eq(res, NSERROR_OK); res = urldb_set_url_persistence(url, true); ck_assert_int_eq(res, NSERROR_NOT_FOUND); nsurl_unref(url); /* search for a url with odd scheme and no host */ res = nsurl_create("fish:///", &url); ck_assert_int_eq(res, NSERROR_OK); ck_assert(nsurl_has_component(url, NSURL_HOST) == false); res = urldb_set_url_title(url, NULL); ck_assert_int_eq(res, NSERROR_NOT_FOUND); nsurl_unref(url); /* search for a url with not found url */ res = nsurl_create("http://no.example.com/", &url); ck_assert_int_eq(res, NSERROR_OK); ck_assert(nsurl_has_component(url, NSURL_HOST) == true); res = urldb_set_url_persistence(url, true); ck_assert_int_eq(res, NSERROR_NOT_FOUND); nsurl_unref(url); } END_TEST /** * test url database finalisation without initialisation. */ START_TEST(urldb_api_destroy_no_init_test) { urldb_destroy(); } END_TEST /** * test case for urldb API including error returns and asserts */ static TCase *urldb_api_case_create(void) { TCase *tc; tc = tcase_create("API_checks"); tcase_add_test_raise_signal(tc, urldb_api_add_url_assert_test, 6); tcase_add_test(tc, urldb_api_url_find_test); tcase_add_test(tc, urldb_api_destroy_no_init_test); return tc; } /** * Test suite for url database */ static Suite *urldb_suite_create(void) { Suite *s; s = suite_create("URLDB"); suite_add_tcase(s, urldb_api_case_create()); suite_add_tcase(s, urldb_add_get_case_create()); suite_add_tcase(s, urldb_session_case_create()); suite_add_tcase(s, urldb_case_create()); suite_add_tcase(s, urldb_cookie_case_create()); suite_add_tcase(s, urldb_original_case_create()); return s; } int main(int argc, char **argv) { int number_failed; SRunner *sr; sr = srunner_create(urldb_suite_create()); srunner_run_all(sr, CK_ENV); number_failed = srunner_ntests_failed(sr); srunner_free(sr); return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; }