From 7b2d15a036bf4ef67eb88cfee23272d564c4a766 Mon Sep 17 00:00:00 2001 From: Vincent Sanders Date: Thu, 9 Jul 2015 23:29:44 +0100 Subject: Add tests for all asserts in nsurl API and for access and access_leaf --- test/nsurl.c | 656 ++++++++++++++++++++++++++++++++++++++++++---------------- utils/nsurl.c | 4 + 2 files changed, 481 insertions(+), 179 deletions(-) diff --git a/test/nsurl.c b/test/nsurl.c index 66a3c8f7d..87058f240 100644 --- a/test/nsurl.c +++ b/test/nsurl.c @@ -1,4 +1,5 @@ /* + * Copyright 2015 Vincent Sanders * Copyright 2011 John Mark Bell * * This file is part of NetSurf, http://www.netsurf-browser.org/ @@ -109,6 +110,108 @@ static const struct test_pairs create_tests[] = { }; +/** + * url creation test + */ +START_TEST(nsurl_create_test) +{ + nserror err; + nsurl *res; + const struct test_pairs *tst = &create_tests[_i]; + + err = nsurl_create(tst->test, &res); + if (tst->res == NULL) { + /* result must be invalid */ + ck_assert(err != NSERROR_OK); + + } else { + /* result must be valid */ + ck_assert(err == NSERROR_OK); + + ck_assert_str_eq(nsurl_access(res), tst->res); + + nsurl_unref(res); + } +} +END_TEST + +static const struct test_triplets access_tests[] = { + { "http://www.netsurf-browser.org/a/big/tree", + "http://www.netsurf-browser.org/a/big/tree", + "tree" }, + + { "HTTP://ci.netsurf-browser.org/jenkins/view/Unit Tests/job/coverage-netsurf/11/cobertura/utils/nsurl_c/", + "http://ci.netsurf-browser.org/jenkins/view/Unit%20Tests/job/coverage-netsurf/11/cobertura/utils/nsurl_c/", + "" }, + + { "FILE:///", + "file:///", + "/" }, +}; + +/** + * url access test + */ +START_TEST(nsurl_access_test) +{ + nserror err; + nsurl *res_url; + const struct test_triplets *tst = &access_tests[_i]; + + /* not testing create, this should always succeed */ + err = nsurl_create(tst->test1, &res_url); + ck_assert(err == NSERROR_OK); + + /* The url accessed string must match the input */ + ck_assert_str_eq(nsurl_access(res_url), tst->test2); + + nsurl_unref(res_url); +} +END_TEST + +/** + * url access leaf test + */ +START_TEST(nsurl_access_leaf_test) +{ + nserror err; + nsurl *res_url; + const struct test_triplets *tst = &access_tests[_i]; + + /* not testing create, this should always succeed */ + err = nsurl_create(tst->test1, &res_url); + ck_assert(err == NSERROR_OK); + + ck_assert_str_eq(nsurl_access_leaf(res_url), tst->res); + + nsurl_unref(res_url); + +} +END_TEST + +/** + * url length test + * + * uses access dataset and test unit + */ +START_TEST(nsurl_length_test) +{ + nserror err; + nsurl *res_url; + const struct test_triplets *tst = &access_tests[_i]; + + /* not testing create, this should always succeed */ + err = nsurl_create(tst->test1, &res_url); + ck_assert(err == NSERROR_OK); + + ck_assert_int_eq(nsurl_length(res_url), strlen(tst->test2)); + + nsurl_unref(res_url); + +} +END_TEST + + static const struct test_pairs nice_tests[] = { { "about:", NULL }, { "www.foo.org", "www_foo_org" }, @@ -122,6 +225,38 @@ static const struct test_pairs nice_tests[] = { { "http://www.f.org//index.en", "www_f_org" }, }; +/** + * url nice filename without stripping + */ +START_TEST(nsurl_nice_nostrip_test) +{ + nserror err; + nsurl *res_url; + char *res_str; + const struct test_pairs *tst = &nice_tests[_i]; + + /* not testing create, this should always succeed */ + err = nsurl_create(tst->test, &res_url); + ck_assert(err == NSERROR_OK); + + err = nsurl_nice(res_url, &res_str, false); + if (tst->res == NULL) { + /* result must be invalid (bad input) */ + ck_assert(err != NSERROR_OK); + } else { + /* result must be valid */ + ck_assert(err == NSERROR_OK); + + ck_assert_str_eq(res_str, tst->res); + + free(res_str); + } + nsurl_unref(res_url); + +} +END_TEST + + static const struct test_pairs nice_strip_tests[] = { { "about:", NULL }, { "www.foo.org", "www_foo_org" }, @@ -135,6 +270,38 @@ static const struct test_pairs nice_strip_tests[] = { { "http://www.f.org//index.en", "www_f_org" }, }; +/** + * url nice filename with stripping + */ +START_TEST(nsurl_nice_strip_test) +{ + nserror err; + nsurl *res_url; + char *res_str; + const struct test_pairs *tst = &nice_strip_tests[_i]; + + /* not testing create, this should always succeed */ + err = nsurl_create(tst->test, &res_url); + ck_assert(err == NSERROR_OK); + + err = nsurl_nice(res_url, &res_str, true); + if (tst->res == NULL) { + /* result must be invalid (bad input) */ + ck_assert(err != NSERROR_OK); + } else { + /* result must be valid */ + ck_assert(err == NSERROR_OK); + + ck_assert_str_eq(res_str, tst->res); + + free(res_str); + } + nsurl_unref(res_url); + +} +END_TEST + + /** * simple joins that all use http://a/b/c/d;p?q as a base */ @@ -211,79 +378,22 @@ static const struct test_pairs join_tests[] = { }; /** - * more complex joins that specify a base to join to - */ -static const struct test_triplets join_complex_tests[] = { - /* problematic real world urls for regression */ - { "http://www.bridgetmckenna.com/blog/self-editing-for-everyone-part-1-the-most-hated-writing-advice-ever", - "http://The%20Old%20Organ%20Trail%20http://www.amazon.com/gp/product/B007B57MCQ/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B007B57MCQ&linkCode=as2&tag=brimck0f-20", - "http://the old organ trail http:" }, -}; - -/** - * query replacement tests - */ -static const struct test_triplets replace_query_tests[] = { - { "http://netsurf-browser.org/?magical=true", - "?magical=true&result=win", - "http://netsurf-browser.org/?magical=true&result=win"}, - - { "http://netsurf-browser.org/?magical=true#fragment", - "?magical=true&result=win", - "http://netsurf-browser.org/?magical=true&result=win#fragment"}, - - { "http://netsurf-browser.org/#fragment", - "?magical=true&result=win", - "http://netsurf-browser.org/?magical=true&result=win#fragment"}, - - { "http://netsurf-browser.org/path", - "?magical=true", - "http://netsurf-browser.org/path?magical=true"}, - -}; - - - -/** - * url creation test - */ -START_TEST(nsurl_create_test) -{ - nserror err; - nsurl *res; - const struct test_pairs *tst = &create_tests[_i]; - - err = nsurl_create(tst->test, &res); - if (tst->res == NULL) { - /* result must be invalid */ - ck_assert(err != NSERROR_OK); - - } else { - /* result must be valid */ - ck_assert(err == NSERROR_OK); - - ck_assert_str_eq(nsurl_access(res), tst->res); - - nsurl_unref(res); - } -} -END_TEST - -/** - * url nice filename without stripping + * url joining */ -START_TEST(nsurl_nice_nostrip_test) +START_TEST(nsurl_join_test) { nserror err; - nsurl *res_url; - char *res_str; - const struct test_pairs *tst = &nice_tests[_i]; + nsurl *base_url; + nsurl *joined; + char *string; + size_t len; + const struct test_pairs *tst = &join_tests[_i]; /* not testing create, this should always succeed */ - err = nsurl_create(tst->test, &res_url); + err = nsurl_create(base_str, &base_url); ck_assert(err == NSERROR_OK); - err = nsurl_nice(res_url, &res_str, false); + err = nsurl_join(base_url, tst->test, &joined); if (tst->res == NULL) { /* result must be invalid (bad input) */ ck_assert(err != NSERROR_OK); @@ -291,94 +401,47 @@ START_TEST(nsurl_nice_nostrip_test) /* result must be valid */ ck_assert(err == NSERROR_OK); - ck_assert_str_eq(res_str, tst->res); - - free(res_str); - } - nsurl_unref(res_url); - -} -END_TEST - -/** - * url nice filename with stripping - */ -START_TEST(nsurl_nice_strip_test) -{ - nserror err; - nsurl *res_url; - char *res_str; - const struct test_pairs *tst = &nice_strip_tests[_i]; - - /* not testing create, this should always succeed */ - err = nsurl_create(tst->test, &res_url); - ck_assert(err == NSERROR_OK); - - err = nsurl_nice(res_url, &res_str, true); - if (tst->res == NULL) { - /* result must be invalid (bad input) */ - ck_assert(err != NSERROR_OK); - } else { - /* result must be valid */ + err = nsurl_get(joined, NSURL_WITH_FRAGMENT, &string, &len); ck_assert(err == NSERROR_OK); - ck_assert_str_eq(res_str, tst->res); + ck_assert_str_eq(string, tst->res); - free(res_str); + free(string); + nsurl_unref(joined); } - nsurl_unref(res_url); + nsurl_unref(base_url); } END_TEST + /** - * replace query + * more complex joins that specify a base to join to */ -START_TEST(nsurl_replace_query_test) -{ - nserror err; - nsurl *res_url; - nsurl *joined; - const struct test_triplets *tst = &replace_query_tests[_i]; - - /* not testing create, this should always succeed */ - err = nsurl_create(tst->test1, &res_url); - ck_assert(err == NSERROR_OK); - - err = nsurl_replace_query(res_url, tst->test2, &joined); - if (tst->res == NULL) { - /* result must be invalid (bad input) */ - ck_assert(err != NSERROR_OK); - } else { - /* result must be valid */ - ck_assert(err == NSERROR_OK); - - ck_assert_str_eq(nsurl_access(joined), tst->res); - - nsurl_unref(joined); - } - nsurl_unref(res_url); - -} -END_TEST +static const struct test_triplets join_complex_tests[] = { + /* problematic real world urls for regression */ + { "http://www.bridgetmckenna.com/blog/self-editing-for-everyone-part-1-the-most-hated-writing-advice-ever", + "http://The%20Old%20Organ%20Trail%20http://www.amazon.com/gp/product/B007B57MCQ/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B007B57MCQ&linkCode=as2&tag=brimck0f-20", + "http://the old organ trail http:" }, +}; /** - * url joining + * complex url joining */ -START_TEST(nsurl_join_test) +START_TEST(nsurl_join_complex_test) { nserror err; nsurl *base_url; nsurl *joined; char *string; size_t len; - const struct test_pairs *tst = &join_tests[_i]; + const struct test_triplets *tst = &join_complex_tests[_i]; /* not testing create, this should always succeed */ - err = nsurl_create(base_str, &base_url); + err = nsurl_create(tst->test1, &base_url); ck_assert(err == NSERROR_OK); - err = nsurl_join(base_url, tst->test, &joined); + err = nsurl_join(base_url, tst->test2, &joined); if (tst->res == NULL) { /* result must be invalid (bad input) */ ck_assert(err != NSERROR_OK); @@ -399,23 +462,44 @@ START_TEST(nsurl_join_test) } END_TEST + /** - * complex url joining + * query replacement tests */ -START_TEST(nsurl_join_complex_test) +static const struct test_triplets replace_query_tests[] = { + { "http://netsurf-browser.org/?magical=true", + "?magical=true&result=win", + "http://netsurf-browser.org/?magical=true&result=win"}, + + { "http://netsurf-browser.org/?magical=true#fragment", + "?magical=true&result=win", + "http://netsurf-browser.org/?magical=true&result=win#fragment"}, + + { "http://netsurf-browser.org/#fragment", + "?magical=true&result=win", + "http://netsurf-browser.org/?magical=true&result=win#fragment"}, + + { "http://netsurf-browser.org/path", + "?magical=true", + "http://netsurf-browser.org/path?magical=true"}, + +}; + +/** + * replace query + */ +START_TEST(nsurl_replace_query_test) { nserror err; - nsurl *base_url; + nsurl *res_url; nsurl *joined; - char *string; - size_t len; - const struct test_triplets *tst = &join_complex_tests[_i]; + const struct test_triplets *tst = &replace_query_tests[_i]; /* not testing create, this should always succeed */ - err = nsurl_create(tst->test1, &base_url); + err = nsurl_create(tst->test1, &res_url); ck_assert(err == NSERROR_OK); - err = nsurl_join(base_url, tst->test2, &joined); + err = nsurl_replace_query(res_url, tst->test2, &joined); if (tst->res == NULL) { /* result must be invalid (bad input) */ ck_assert(err != NSERROR_OK); @@ -423,15 +507,11 @@ START_TEST(nsurl_join_complex_test) /* result must be valid */ ck_assert(err == NSERROR_OK); - err = nsurl_get(joined, NSURL_WITH_FRAGMENT, &string, &len); - ck_assert(err == NSERROR_OK); - - ck_assert_str_eq(string, tst->res); + ck_assert_str_eq(nsurl_access(joined), tst->res); - free(string); nsurl_unref(joined); } - nsurl_unref(base_url); + nsurl_unref(res_url); } END_TEST @@ -461,10 +541,11 @@ START_TEST(nsurl_ref_test) } END_TEST + /** * check creation asserts on NULL parameter */ -START_TEST(nsurl_api_create_test) +START_TEST(nsurl_api_assert_create_test) { nserror err; nsurl *res1; @@ -477,7 +558,7 @@ END_TEST /** * check ref asserts on NULL parameter */ -START_TEST(nsurl_api_ref_test) +START_TEST(nsurl_api_assert_ref_test) { nsurl_ref(NULL); } @@ -486,7 +567,7 @@ END_TEST /** * check unref asserts on NULL parameter */ -START_TEST(nsurl_api_unref_test) +START_TEST(nsurl_api_assert_unref_test) { nsurl_unref(NULL); } @@ -495,7 +576,7 @@ END_TEST /** * check compare asserts on NULL parameter */ -START_TEST(nsurl_api_compare1_test) +START_TEST(nsurl_api_assert_compare1_test) { nserror err; nsurl *res; @@ -515,7 +596,7 @@ END_TEST /** * check compare asserts on NULL parameter */ -START_TEST(nsurl_api_compare2_test) +START_TEST(nsurl_api_assert_compare2_test) { nserror err; nsurl *res; @@ -533,7 +614,7 @@ END_TEST /** * check get asserts on NULL parameter */ -START_TEST(nsurl_api_get_test) +START_TEST(nsurl_api_assert_get_test) { nserror err; char *url_s = NULL; @@ -549,7 +630,7 @@ END_TEST /** * check get component asserts on NULL parameter */ -START_TEST(nsurl_api_get_component1_test) +START_TEST(nsurl_api_assert_get_component1_test) { lwc_string *lwcs; @@ -561,7 +642,7 @@ END_TEST /** * check get component asserts on bad component parameter */ -START_TEST(nsurl_api_get_component2_test) +START_TEST(nsurl_api_assert_get_component2_test) { nserror err; nsurl *res; @@ -580,7 +661,7 @@ END_TEST /** * check has component asserts on NULL parameter */ -START_TEST(nsurl_api_has_component1_test) +START_TEST(nsurl_api_assert_has_component1_test) { bool has; @@ -592,7 +673,7 @@ END_TEST /** * check has component asserts on bad component parameter */ -START_TEST(nsurl_api_has_component2_test) +START_TEST(nsurl_api_assert_has_component2_test) { nserror err; nsurl *res; @@ -612,7 +693,7 @@ END_TEST /** * check access asserts on NULL parameter */ -START_TEST(nsurl_api_access_test) +START_TEST(nsurl_api_assert_access_test) { const char *res_s = NULL; @@ -625,7 +706,7 @@ END_TEST /** * check access asserts on NULL parameter */ -START_TEST(nsurl_api_access_leaf_test) +START_TEST(nsurl_api_assert_access_leaf_test) { const char *res_s = NULL; @@ -638,7 +719,7 @@ END_TEST /** * check length asserts on NULL parameter */ -START_TEST(nsurl_api_length_test) +START_TEST(nsurl_api_assert_length_test) { size_t res = 0; @@ -651,7 +732,7 @@ END_TEST /** * check hash asserts on NULL parameter */ -START_TEST(nsurl_api_hash_test) +START_TEST(nsurl_api_assert_hash_test) { uint32_t res = 0; @@ -661,6 +742,168 @@ START_TEST(nsurl_api_hash_test) } END_TEST +/** + * check join asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_join1_test) +{ + const char *rel = "moo"; + nsurl *res; + nserror err; + + err = nsurl_join(NULL, rel, &res); + ck_assert(err != NSERROR_OK); +} +END_TEST + +/** + * check join asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_join2_test) +{ + nsurl *url; + nsurl *res; + nserror err; + + err = nsurl_create(base_str, &url); + ck_assert(err == NSERROR_OK); + + err = nsurl_join(url, NULL, &res); + ck_assert(err != NSERROR_OK); + + nsurl_unref(url); +} +END_TEST + +/** + * check defragment asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_defragment_test) +{ + nsurl *res; + nserror err; + + err = nsurl_defragment(NULL, &res); + ck_assert(err != NSERROR_OK); +} +END_TEST + + +/** + * check refragment join asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_refragment1_test) +{ + nsurl *res; + nserror err; + + err = nsurl_refragment(NULL, corestring_lwc_http, &res); + ck_assert(err != NSERROR_OK); +} +END_TEST + +/** + * check refragment asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_refragment2_test) +{ + nsurl *url; + nsurl *res; + nserror err; + + err = nsurl_create(base_str, &url); + ck_assert(err == NSERROR_OK); + + err = nsurl_refragment(url, NULL, &res); + ck_assert(err != NSERROR_OK); + + nsurl_unref(url); +} +END_TEST + +/** + * check query replacement asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_replace_query1_test) +{ + const char *rel = "moo"; + nsurl *res; + nserror err; + + err = nsurl_replace_query(NULL, rel, &res); + ck_assert(err != NSERROR_OK); +} +END_TEST + +/** + * check query replacement asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_replace_query2_test) +{ + nsurl *url; + nsurl *res; + nserror err; + + err = nsurl_create(base_str, &url); + ck_assert(err == NSERROR_OK); + + err = nsurl_replace_query(url, NULL, &res); + ck_assert(err != NSERROR_OK); + + nsurl_unref(url); +} +END_TEST + +/** + * check query replacement asserts on bad parameter + */ +START_TEST(nsurl_api_assert_replace_query3_test) +{ + nsurl *url; + nsurl *res; + nserror err; + const char *rel = "moo"; + + err = nsurl_create(base_str, &url); + ck_assert(err == NSERROR_OK); + + err = nsurl_replace_query(url, rel, &res); + ck_assert(err != NSERROR_OK); + + nsurl_unref(url); +} +END_TEST + +/** + * check nice asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_nice_test) +{ + char *res_s = NULL; + nserror err; + + err = nsurl_nice(NULL, &res_s, false); + ck_assert(err != NSERROR_OK); + + ck_assert(res_s == NULL); +} +END_TEST + +/** + * check parent asserts on NULL parameter + */ +START_TEST(nsurl_api_assert_parent_test) +{ + nsurl *res; + nserror err; + + err = nsurl_parent(NULL, &res); + ck_assert(err != NSERROR_OK); +} +END_TEST + + +/* Fixtures */ static void corestring_create(void) { @@ -674,11 +917,14 @@ static void corestring_teardown(void) lwc_iterate_strings(netsurf_lwc_iterator, NULL); } +/* suite generation */ + Suite *nsurl_suite(void) { Suite *s; - TCase *tc_api; + TCase *tc_api_assert; TCase *tc_create; + TCase *tc_access; TCase *tc_nice_nostrip; TCase *tc_nice_strip; TCase *tc_replace_query; @@ -686,28 +932,63 @@ Suite *nsurl_suite(void) s = suite_create("nsurl"); - /* Basic API operation sanity checks e.g. passing NULL parameters */ - tc_api = tcase_create("API"); + /* Basic API operation assert checks */ + tc_api_assert = tcase_create("API asserts"); - tcase_add_unchecked_fixture(tc_api, + tcase_add_unchecked_fixture(tc_api_assert, corestring_create, corestring_teardown); - tcase_add_test_raise_signal(tc_api, nsurl_api_create_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_ref_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_unref_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_compare1_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_compare2_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_get_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_get_component1_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_get_component2_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_has_component1_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_has_component2_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_access_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_access_leaf_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_length_test, 6); - tcase_add_test_raise_signal(tc_api, nsurl_api_hash_test, 6); - suite_add_tcase(s, tc_api); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_create_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_ref_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_unref_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_compare1_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_compare2_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_get_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_get_component1_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_get_component2_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_has_component1_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_has_component2_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_access_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_access_leaf_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_length_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_hash_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_join1_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_join2_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_defragment_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_refragment1_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_refragment2_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_replace_query1_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_replace_query2_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_replace_query3_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_nice_test, 6); + tcase_add_test_raise_signal(tc_api_assert, + nsurl_api_assert_parent_test, 6); + + suite_add_tcase(s, tc_api_assert); /* url creation */ tc_create = tcase_create("Create"); @@ -716,12 +997,29 @@ Suite *nsurl_suite(void) corestring_create, corestring_teardown); - tcase_add_test(tc_create, nsurl_ref_test); tcase_add_loop_test(tc_create, nsurl_create_test, 0, NELEMS(create_tests)); + tcase_add_test(tc_create, nsurl_ref_test); suite_add_tcase(s, tc_create); + /* url access and length */ + tc_access = tcase_create("Access"); + + tcase_add_unchecked_fixture(tc_access, + corestring_create, + corestring_teardown); + tcase_add_loop_test(tc_access, + nsurl_access_test, + 0, NELEMS(access_tests)); + tcase_add_loop_test(tc_access, + nsurl_access_leaf_test, + 0, NELEMS(access_tests)); + tcase_add_loop_test(tc_access, + nsurl_length_test, + 0, NELEMS(access_tests)); + suite_add_tcase(s, tc_access); + /* nice filename without strip */ tc_nice_nostrip = tcase_create("Nice (nostrip)"); diff --git a/utils/nsurl.c b/utils/nsurl.c index 8431916be..8d53be84f 100644 --- a/utils/nsurl.c +++ b/utils/nsurl.c @@ -2004,6 +2004,8 @@ nserror nsurl_defragment(const nsurl *url, nsurl **no_frag) size_t length; char *pos; + assert(url != NULL); + /* check for source url having no fragment already */ if (url->components.fragment == NULL) { *no_frag = (nsurl *)url; @@ -2226,6 +2228,8 @@ nserror nsurl_nice(const nsurl *url, char **result, bool remove_extensions) bool match; char *name; + assert(url != NULL); + *result = 0; /* extract the last component of the path, if possible */ -- cgit v1.2.3