picnoir
/
Systemd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Systemd/src/test/test-string-util.c

929 lines
35 KiB
C
Raw Normal View History

license: LGPL-2.1+ -> LGPL-2.1-or-later
2020-11-09 05:23:58 +01:00
/* SPDX-License-Identifier: LGPL-2.1-or-later */
string-util: rework memory_erase() so that it cannot be optimized away memory_erase() so far just called memset(), which the compiler might optimize away under certain conditions if it feels there's benefit in it. C11 knows a new memset_s() call that is like memset(), but may not be optimized away. Ideally, we'd just use that call, but glibc currently does not support it. Hence, implement our own simplistic version of it. We use a GCC pragma to turn off optimization for this call, and also use the "volatile" keyword on the pointers to ensure that gcc will use the pointers as-is. According to a variety of internet sources, either one does the trick. However, there are also reports that at least the volatile thing isn't fully correct, hence let's add some snake oil and employ both techniques. https://news.ycombinator.com/item?id=4711346
2015-11-01 20:28:55 +01:00
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
#include "alloc-util.h"
basic/string-util: add a convenience function to cescape mostly-ascii fields It's not supposed to be the most efficient, but instead fast and simple to use. I kept the logic in ellipsize_mem() to use unicode ellipsis even in non-unicode locales. I'm not quite convinced things should be this way, especially that with this patch it'd actually be simpler to always use "…" in unicode locale and "..." otherwise, but Lennart wanted it this way for some reason.
2018-05-17 10:55:21 +02:00
#include "locale-util.h"
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
#include "macro.h"
string-util: rework memory_erase() so that it cannot be optimized away memory_erase() so far just called memset(), which the compiler might optimize away under certain conditions if it feels there's benefit in it. C11 knows a new memset_s() call that is like memset(), but may not be optimized away. Ideally, we'd just use that call, but glibc currently does not support it. Hence, implement our own simplistic version of it. We use a GCC pragma to turn off optimization for this call, and also use the "volatile" keyword on the pointers to ensure that gcc will use the pointers as-is. According to a variety of internet sources, either one does the trick. However, there are also reports that at least the volatile thing isn't fully correct, hence let's add some snake oil and employ both techniques. https://news.ycombinator.com/item?id=4711346
2015-11-01 20:28:55 +01:00
#include "string-util.h"
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
#include "strv.h"
Introduce free_and_strndup and use it in bus-message.c v2: fix error in free_and_strndup() When the orignal and copied message were the same, but shorter than specified length l, memory read past the end of the buffer would be performed. A test case is included: a string that had an embedded NUL ("q\0") is used to replace "q". v3: Fix one more bug in free_and_strndup and add tests. v4: Some style fixed based on review, one more use of free_and_replace, and make the tests more comprehensive.
2018-07-09 07:03:01 +02:00
#include "tests.h"
test-ellipsize: add tests for ellipsize_mem, fix bugs First, ellipsize() and ellipsize_mem() should not read past the input buffer. Those functions take an explicit length for the input data, so they should not assume that the buffer is terminated by a nul. Second, ellipsization was off in various cases where wide on multi-byte characters were used. We had some basic test for ellipsize(), but apparently it wasn't enough to catch more serious cases. Should fix https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8686.
2018-06-02 17:08:46 +02:00
#include "utf8.h"
headers: remove unneeded includes from util.h This means we need to include many more headers in various files that simply included util.h before, but it seems cleaner to do it this way.
2019-03-27 11:32:41 +01:00
#include "util.h"
string-util: rework memory_erase() so that it cannot be optimized away memory_erase() so far just called memset(), which the compiler might optimize away under certain conditions if it feels there's benefit in it. C11 knows a new memset_s() call that is like memset(), but may not be optimized away. Ideally, we'd just use that call, but glibc currently does not support it. Hence, implement our own simplistic version of it. We use a GCC pragma to turn off optimization for this call, and also use the "volatile" keyword on the pointers to ensure that gcc will use the pointers as-is. According to a variety of internet sources, either one does the trick. However, there are also reports that at least the volatile thing isn't fully correct, hence let's add some snake oil and employ both techniques. https://news.ycombinator.com/item?id=4711346
2015-11-01 20:28:55 +01:00
string-util: readd string_erase() This was dropped in 8e27167cc9b8beda2bf49789b15f0b0301b95d17, but is actually useful for some usecases still.
2019-07-11 14:50:26 +02:00
static void test_string_erase(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: readd string_erase() This was dropped in 8e27167cc9b8beda2bf49789b15f0b0301b95d17, but is actually useful for some usecases still.
2019-07-11 14:50:26 +02:00
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
char *x;
string-util: readd string_erase() This was dropped in 8e27167cc9b8beda2bf49789b15f0b0301b95d17, but is actually useful for some usecases still.
2019-07-11 14:50:26 +02:00
x = strdupa("");
assert_se(streq(string_erase(x), ""));
x = strdupa("1");
assert_se(streq(string_erase(x), ""));
x = strdupa("123456789");
assert_se(streq(string_erase(x), ""));
assert_se(x[1] == '\0');
assert_se(x[2] == '\0');
assert_se(x[3] == '\0');
assert_se(x[4] == '\0');
assert_se(x[5] == '\0');
assert_se(x[6] == '\0');
assert_se(x[7] == '\0');
assert_se(x[8] == '\0');
assert_se(x[9] == '\0');
}
Introduce free_and_strndup and use it in bus-message.c v2: fix error in free_and_strndup() When the orignal and copied message were the same, but shorter than specified length l, memory read past the end of the buffer would be performed. A test case is included: a string that had an embedded NUL ("q\0") is used to replace "q". v3: Fix one more bug in free_and_strndup and add tests. v4: Some style fixed based on review, one more use of free_and_replace, and make the tests more comprehensive.
2018-07-09 07:03:01 +02:00
static void test_free_and_strndup_one(char **t, const char *src, size_t l, const char *expected, bool change) {
log_debug("%s: \"%s\", \"%s\", %zd (expect \"%s\", %s)",
__func__, strnull(*t), strnull(src), l, strnull(expected), yes_no(change));
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
int r = free_and_strndup(t, src, l);
Introduce free_and_strndup and use it in bus-message.c v2: fix error in free_and_strndup() When the orignal and copied message were the same, but shorter than specified length l, memory read past the end of the buffer would be performed. A test case is included: a string that had an embedded NUL ("q\0") is used to replace "q". v3: Fix one more bug in free_and_strndup and add tests. v4: Some style fixed based on review, one more use of free_and_replace, and make the tests more comprehensive.
2018-07-09 07:03:01 +02:00
assert_se(streq_ptr(*t, expected));
assert_se(r == change); /* check that change occurs only when necessary */
}
static void test_free_and_strndup(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
Introduce free_and_strndup and use it in bus-message.c v2: fix error in free_and_strndup() When the orignal and copied message were the same, but shorter than specified length l, memory read past the end of the buffer would be performed. A test case is included: a string that had an embedded NUL ("q\0") is used to replace "q". v3: Fix one more bug in free_and_strndup and add tests. v4: Some style fixed based on review, one more use of free_and_replace, and make the tests more comprehensive.
2018-07-09 07:03:01 +02:00
static const struct test_case {
const char *src;
size_t len;
const char *expected;
} cases[] = {
{"abc", 0, ""},
{"abc", 0, ""},
{"abc", 1, "a"},
{"abc", 2, "ab"},
{"abc", 3, "abc"},
{"abc", 4, "abc"},
{"abc", 5, "abc"},
{"abc", 5, "abc"},
{"abc", 4, "abc"},
{"abc", 3, "abc"},
{"abc", 2, "ab"},
{"abc", 1, "a"},
{"abc", 0, ""},
{"", 0, ""},
{"", 1, ""},
{"", 2, ""},
{"", 0, ""},
{"", 1, ""},
{"", 2, ""},
{"", 2, ""},
{"", 1, ""},
{"", 0, ""},
{NULL, 0, NULL},
{"foo", 3, "foo"},
{"foobar", 6, "foobar"},
};
_cleanup_free_ char *t = NULL;
const char *prev_expected = t;
for (unsigned i = 0; i < ELEMENTSOF(cases); i++) {
test_free_and_strndup_one(&t,
cases[i].src, cases[i].len, cases[i].expected,
!streq_ptr(cases[i].expected, prev_expected));
prev_expected = t;
}
}
basic: add new ascii_strcasecmp_n() call
2016-01-13 02:21:16 +01:00
static void test_ascii_strcasecmp_n(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
basic: add new ascii_strcasecmp_n() call
2016-01-13 02:21:16 +01:00
assert_se(ascii_strcasecmp_n("", "", 0) == 0);
assert_se(ascii_strcasecmp_n("", "", 1) == 0);
assert_se(ascii_strcasecmp_n("", "a", 1) < 0);
assert_se(ascii_strcasecmp_n("", "a", 2) < 0);
assert_se(ascii_strcasecmp_n("a", "", 1) > 0);
assert_se(ascii_strcasecmp_n("a", "", 2) > 0);
assert_se(ascii_strcasecmp_n("a", "a", 1) == 0);
assert_se(ascii_strcasecmp_n("a", "a", 2) == 0);
assert_se(ascii_strcasecmp_n("a", "b", 1) < 0);
assert_se(ascii_strcasecmp_n("a", "b", 2) < 0);
assert_se(ascii_strcasecmp_n("b", "a", 1) > 0);
assert_se(ascii_strcasecmp_n("b", "a", 2) > 0);
assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxYxxxx", 9) == 0);
assert_se(ascii_strcasecmp_n("xxxxxxxxx", "xxxxyxxxx", 9) < 0);
assert_se(ascii_strcasecmp_n("xxxxXxxxx", "xxxxyxxxx", 9) < 0);
assert_se(ascii_strcasecmp_n("xxxxxxxxx", "xxxxYxxxx", 9) < 0);
assert_se(ascii_strcasecmp_n("xxxxXxxxx", "xxxxYxxxx", 9) < 0);
assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxYxxxx", 9) == 0);
assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxxxxxx", 9) > 0);
assert_se(ascii_strcasecmp_n("xxxxyxxxx", "xxxxXxxxx", 9) > 0);
assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxxxxxx", 9) > 0);
assert_se(ascii_strcasecmp_n("xxxxYxxxx", "xxxxXxxxx", 9) > 0);
}
basic: add ascii_strcasecmp_nn() call In contrast to ascii_strcasecmp_nn() it takes two character buffers with their individual length. It will then compare the buffers up the smaller size of the two buffers, and finally the length themselves.
2016-01-13 19:45:05 +01:00
static void test_ascii_strcasecmp_nn(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
basic: add ascii_strcasecmp_nn() call In contrast to ascii_strcasecmp_nn() it takes two character buffers with their individual length. It will then compare the buffers up the smaller size of the two buffers, and finally the length themselves.
2016-01-13 19:45:05 +01:00
assert_se(ascii_strcasecmp_nn("", 0, "", 0) == 0);
assert_se(ascii_strcasecmp_nn("", 0, "", 1) < 0);
assert_se(ascii_strcasecmp_nn("", 1, "", 0) > 0);
assert_se(ascii_strcasecmp_nn("", 1, "", 1) == 0);
assert_se(ascii_strcasecmp_nn("aaaa", 4, "aaAa", 4) == 0);
assert_se(ascii_strcasecmp_nn("aaa", 3, "aaAa", 4) < 0);
assert_se(ascii_strcasecmp_nn("aaa", 4, "aaAa", 4) < 0);
assert_se(ascii_strcasecmp_nn("aaaa", 4, "aaA", 3) > 0);
assert_se(ascii_strcasecmp_nn("aaaa", 4, "AAA", 4) > 0);
assert_se(ascii_strcasecmp_nn("aaaa", 4, "bbbb", 4) < 0);
assert_se(ascii_strcasecmp_nn("aaAA", 4, "BBbb", 4) < 0);
assert_se(ascii_strcasecmp_nn("BBbb", 4, "aaaa", 4) > 0);
}
basic/string-util: add a convenience function to cescape mostly-ascii fields It's not supposed to be the most efficient, but instead fast and simple to use. I kept the logic in ellipsize_mem() to use unicode ellipsis even in non-unicode locales. I'm not quite convinced things should be this way, especially that with this patch it'd actually be simpler to always use "…" in unicode locale and "..." otherwise, but Lennart wanted it this way for some reason.
2018-05-17 10:55:21 +02:00
static void test_cellescape(void) {
char buf[40];
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: tweak cellescape() a bit For short buffer sizes cellescape() was a bit wasteful, as it might suffice to to drop a single character to find enough place for the full four byte ellipsis, if that one character was a four character escape. With this rework we'll guarantee to drop the minimum number of characters from the end to fit in the ellipsis. If the buffers we write to are large this doesn't matter much. However, if they are short (as they are when talking about the process comm field) then it starts to matter that we put as much information as we can in the space we get.
2018-06-01 21:45:23 +02:00
assert_se(streq(cellescape(buf, 1, ""), ""));
assert_se(streq(cellescape(buf, 1, "1"), ""));
assert_se(streq(cellescape(buf, 1, "12"), ""));
assert_se(streq(cellescape(buf, 2, ""), ""));
assert_se(streq(cellescape(buf, 2, "1"), "1"));
assert_se(streq(cellescape(buf, 2, "12"), "."));
assert_se(streq(cellescape(buf, 2, "123"), "."));
assert_se(streq(cellescape(buf, 3, ""), ""));
assert_se(streq(cellescape(buf, 3, "1"), "1"));
assert_se(streq(cellescape(buf, 3, "12"), "12"));
assert_se(streq(cellescape(buf, 3, "123"), ".."));
assert_se(streq(cellescape(buf, 3, "1234"), ".."));
assert_se(streq(cellescape(buf, 4, ""), ""));
assert_se(streq(cellescape(buf, 4, "1"), "1"));
assert_se(streq(cellescape(buf, 4, "12"), "12"));
assert_se(streq(cellescape(buf, 4, "123"), "123"));
assert_se(streq(cellescape(buf, 4, "1234"), is_locale_utf8() ? "…" : "..."));
assert_se(streq(cellescape(buf, 4, "12345"), is_locale_utf8() ? "…" : "..."));
assert_se(streq(cellescape(buf, 5, ""), ""));
assert_se(streq(cellescape(buf, 5, "1"), "1"));
assert_se(streq(cellescape(buf, 5, "12"), "12"));
assert_se(streq(cellescape(buf, 5, "123"), "123"));
assert_se(streq(cellescape(buf, 5, "1234"), "1234"));
assert_se(streq(cellescape(buf, 5, "12345"), is_locale_utf8() ? "1…" : "1..."));
assert_se(streq(cellescape(buf, 5, "123456"), is_locale_utf8() ? "1…" : "1..."));
assert_se(streq(cellescape(buf, 1, "\020"), ""));
assert_se(streq(cellescape(buf, 2, "\020"), "."));
assert_se(streq(cellescape(buf, 3, "\020"), ".."));
assert_se(streq(cellescape(buf, 4, "\020"), "…"));
assert_se(streq(cellescape(buf, 5, "\020"), "\\020"));
assert_se(streq(cellescape(buf, 5, "1234\020"), "1…"));
assert_se(streq(cellescape(buf, 6, "1234\020"), "12…"));
assert_se(streq(cellescape(buf, 7, "1234\020"), "123…"));
assert_se(streq(cellescape(buf, 8, "1234\020"), "1234…"));
assert_se(streq(cellescape(buf, 9, "1234\020"), "1234\\020"));
assert_se(streq(cellescape(buf, 1, "\t\n"), ""));
assert_se(streq(cellescape(buf, 2, "\t\n"), "."));
assert_se(streq(cellescape(buf, 3, "\t\n"), ".."));
assert_se(streq(cellescape(buf, 4, "\t\n"), "…"));
assert_se(streq(cellescape(buf, 5, "\t\n"), "\\t\\n"));
assert_se(streq(cellescape(buf, 5, "1234\t\n"), "1…"));
assert_se(streq(cellescape(buf, 6, "1234\t\n"), "12…"));
assert_se(streq(cellescape(buf, 7, "1234\t\n"), "123…"));
assert_se(streq(cellescape(buf, 8, "1234\t\n"), "1234…"));
assert_se(streq(cellescape(buf, 9, "1234\t\n"), "1234\\t\\n"));
assert_se(streq(cellescape(buf, 4, "x\t\020\n"), "…"));
assert_se(streq(cellescape(buf, 5, "x\t\020\n"), "x…"));
assert_se(streq(cellescape(buf, 6, "x\t\020\n"), "x…"));
assert_se(streq(cellescape(buf, 7, "x\t\020\n"), "x\\t…"));
assert_se(streq(cellescape(buf, 8, "x\t\020\n"), "x\\t…"));
assert_se(streq(cellescape(buf, 9, "x\t\020\n"), "x\\t…"));
assert_se(streq(cellescape(buf, 10, "x\t\020\n"), "x\\t\\020\\n"));
assert_se(streq(cellescape(buf, 6, "1\011"), "1\\t"));
assert_se(streq(cellescape(buf, 6, "1\020"), "1\\020"));
assert_se(streq(cellescape(buf, 6, "1\020x"), is_locale_utf8() ? "1…" : "1..."));
basic/string-util: add a convenience function to cescape mostly-ascii fields It's not supposed to be the most efficient, but instead fast and simple to use. I kept the logic in ellipsize_mem() to use unicode ellipsis even in non-unicode locales. I'm not quite convinced things should be this way, especially that with this patch it'd actually be simpler to always use "…" in unicode locale and "..." otherwise, but Lennart wanted it this way for some reason.
2018-05-17 10:55:21 +02:00
assert_se(streq(cellescape(buf, 40, "1\020"), "1\\020"));
assert_se(streq(cellescape(buf, 40, "1\020x"), "1\\020x"));
assert_se(streq(cellescape(buf, 40, "\a\b\f\n\r\t\v\\\"'"), "\\a\\b\\f\\n\\r\\t\\v\\\\\\\"\\'"));
string-util: tweak cellescape() a bit For short buffer sizes cellescape() was a bit wasteful, as it might suffice to to drop a single character to find enough place for the full four byte ellipsis, if that one character was a four character escape. With this rework we'll guarantee to drop the minimum number of characters from the end to fit in the ellipsis. If the buffers we write to are large this doesn't matter much. However, if they are short (as they are when talking about the process comm field) then it starts to matter that we put as much information as we can in the space we get.
2018-06-01 21:45:23 +02:00
assert_se(streq(cellescape(buf, 6, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a..."));
assert_se(streq(cellescape(buf, 7, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a…" : "\\a..."));
assert_se(streq(cellescape(buf, 8, "\a\b\f\n\r\t\v\\\"'"), is_locale_utf8() ? "\\a\\b…" : "\\a\\b..."));
basic/string-util: add a convenience function to cescape mostly-ascii fields It's not supposed to be the most efficient, but instead fast and simple to use. I kept the logic in ellipsize_mem() to use unicode ellipsis even in non-unicode locales. I'm not quite convinced things should be this way, especially that with this patch it'd actually be simpler to always use "…" in unicode locale and "..." otherwise, but Lennart wanted it this way for some reason.
2018-05-17 10:55:21 +02:00
assert_se(streq(cellescape(buf, sizeof buf, "1\020"), "1\\020"));
assert_se(streq(cellescape(buf, sizeof buf, "1\020x"), "1\\020x"));
}
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
static void test_streq_ptr(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
assert_se(streq_ptr(NULL, NULL));
assert_se(!streq_ptr("abc", "cdef"));
}
static void test_strstrip(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
char *ret, input[] = " hello, waldo. ";
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
ret = strstrip(input);
assert_se(streq(ret, "hello, waldo."));
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
}
static void test_strextend(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
_cleanup_free_ char *str = NULL;
assert_se(strextend(&str, NULL));
assert_se(streq_ptr(str, ""));
string-util: imply NULL termination of strextend() argument list The trailing NULL in the argument list is now implied (similar to what we already have in place in strjoin()).
2021-01-05 15:03:41 +01:00
assert_se(strextend(&str, "", "0", "", "", "123"));
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
assert_se(streq_ptr(str, "0123"));
string-util: imply NULL termination of strextend() argument list The trailing NULL in the argument list is now implied (similar to what we already have in place in strjoin()).
2021-01-05 15:03:41 +01:00
assert_se(strextend(&str, "456", "78", "9"));
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
assert_se(streq_ptr(str, "0123456789"));
}
static void test_strextend_with_separator(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
_cleanup_free_ char *str = NULL;
assert_se(strextend_with_separator(&str, NULL, NULL));
assert_se(streq_ptr(str, ""));
str = mfree(str);
assert_se(strextend_with_separator(&str, "...", NULL));
assert_se(streq_ptr(str, ""));
assert_se(strextend_with_separator(&str, "...", NULL));
assert_se(streq_ptr(str, ""));
str = mfree(str);
string-util: imply NULL termination of strextend() argument list The trailing NULL in the argument list is now implied (similar to what we already have in place in strjoin()).
2021-01-05 15:03:41 +01:00
assert_se(strextend_with_separator(&str, "xyz", "a", "bb", "ccc"));
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
assert_se(streq_ptr(str, "axyzbbxyzccc"));
str = mfree(str);
string-util: imply NULL termination of strextend() argument list The trailing NULL in the argument list is now implied (similar to what we already have in place in strjoin()).
2021-01-05 15:03:41 +01:00
assert_se(strextend_with_separator(&str, ",", "start", "", "1", "234"));
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
assert_se(streq_ptr(str, "start,,1,234"));
string-util: imply NULL termination of strextend() argument list The trailing NULL in the argument list is now implied (similar to what we already have in place in strjoin()).
2021-01-05 15:03:41 +01:00
assert_se(strextend_with_separator(&str, ";", "more", "5", "678"));
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
assert_se(streq_ptr(str, "start,,1,234;more;5;678"));
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
}
static void test_strrep(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
_cleanup_free_ char *one, *three, *zero;
one = strrep("waldo", 1);
three = strrep("waldo", 3);
zero = strrep("waldo", 0);
assert_se(streq(one, "waldo"));
assert_se(streq(three, "waldowaldowaldo"));
assert_se(streq(zero, ""));
}
static void test_string_has_cc(void) {
assert_se(string_has_cc("abc\1", NULL));
assert_se(string_has_cc("abc\x7f", NULL));
assert_se(string_has_cc("abc\x7f", NULL));
assert_se(string_has_cc("abc\t\x7f", "\t"));
assert_se(string_has_cc("abc\t\x7f", "\t"));
assert_se(string_has_cc("\x7f", "\t"));
assert_se(string_has_cc("\x7f", "\t\a"));
assert_se(!string_has_cc("abc\t\t", "\t"));
assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
assert_se(!string_has_cc("a\ab\tc", "\t\a"));
}
static void test_ascii_strlower(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
}
static void test_strshorten(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
char s[] = "foobar";
assert_se(strlen(strshorten(s, 6)) == 6);
assert_se(strlen(strshorten(s, 12)) == 6);
assert_se(strlen(strshorten(s, 2)) == 2);
assert_se(strlen(strshorten(s, 0)) == 0);
}
static void test_strjoina(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
char *actual;
actual = strjoina("", "foo", "bar");
assert_se(streq(actual, "foobar"));
actual = strjoina("foo", "bar", "baz");
assert_se(streq(actual, "foobarbaz"));
actual = strjoina("foo", "", "bar", "baz");
assert_se(streq(actual, "foobarbaz"));
actual = strjoina("foo");
assert_se(streq(actual, "foo"));
actual = strjoina(NULL);
assert_se(streq(actual, ""));
actual = strjoina(NULL, "foo");
assert_se(streq(actual, ""));
actual = strjoina("foo", NULL, "bar");
assert_se(streq(actual, "foo"));
}
test-string-util: add a test for strjoin() Strangely, we didn't have one so far. I mostly wanted to verify that NULL can be used in any spot at behaves the same as "".
2020-08-20 13:37:31 +02:00
static void test_strjoin(void) {
char *actual;
actual = strjoin("", "foo", "bar");
assert_se(streq(actual, "foobar"));
mfree(actual);
actual = strjoin("foo", "bar", "baz");
assert_se(streq(actual, "foobarbaz"));
mfree(actual);
actual = strjoin("foo", "", "bar", "baz");
assert_se(streq(actual, "foobarbaz"));
mfree(actual);
actual = strjoin("foo", NULL);
assert_se(streq(actual, "foo"));
mfree(actual);
actual = strjoin(NULL, NULL);
assert_se(streq(actual, ""));
mfree(actual);
actual = strjoin(NULL, "foo");
assert_se(streq(actual, ""));
mfree(actual);
actual = strjoin("foo", NULL, "bar");
assert_se(streq(actual, "foo"));
mfree(actual);
}
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
static void test_strcmp_ptr(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
assert_se(strcmp_ptr(NULL, NULL) == 0);
assert_se(strcmp_ptr("", NULL) > 0);
assert_se(strcmp_ptr("foo", NULL) > 0);
assert_se(strcmp_ptr(NULL, "") < 0);
assert_se(strcmp_ptr(NULL, "bar") < 0);
assert_se(strcmp_ptr("foo", "bar") > 0);
assert_se(strcmp_ptr("bar", "baz") < 0);
assert_se(strcmp_ptr("foo", "foo") == 0);
assert_se(strcmp_ptr("", "") == 0);
}
static void test_foreach_word(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
test-string-util: stop testing FOREACH_WORD
2020-07-31 15:07:23 +02:00
const char *test = "test abc d\te f ";
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
const char * const expected[] = {
"test",
"abc",
"d",
"e",
"f",
};
test-string-util: stop testing FOREACH_WORD
2020-07-31 15:07:23 +02:00
size_t i = 0;
int r;
for (const char *p = test;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&p, &word, NULL, 0);
if (r == 0) {
assert_se(i == ELEMENTSOF(expected));
break;
}
assert_se(r > 0);
assert_se(streq(expected[i++], word));
}
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
}
static void check(const char *test, char** expected, bool trailing) {
test-string-util: stop testing FOREACH_WORD
2020-07-31 15:07:23 +02:00
size_t i = 0;
int r;
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
printf("<<<%s>>>\n", test);
Drop FOREACH_WORD_QUOTED
2016-10-28 04:44:50 +02:00
for (;;) {
_cleanup_free_ char *word = NULL;
Rename EXTRACT_QUOTES to EXTRACT_UNQUOTE Whenever I see EXTRACT_QUOTES, I'm always confused whether it means to leave the quotes in or to take them out. Let's say "unquote", like we say "cunescape".
2019-06-28 11:15:05 +02:00
r = extract_first_word(&test, &word, NULL, EXTRACT_UNQUOTE);
Drop FOREACH_WORD_QUOTED
2016-10-28 04:44:50 +02:00
if (r == 0) {
assert_se(!trailing);
break;
} else if (r < 0) {
assert_se(trailing);
break;
}
assert_se(streq(word, expected[i++]));
printf("<%s>\n", word);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
}
assert_se(expected[i] == NULL);
}
static void test_foreach_word_quoted(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
STRV_MAKE("test",
"a",
"b",
"c",
"d",
"e",
"",
"",
"hhh",
"",
"",
"a b c"),
false);
check("test \"xxx",
STRV_MAKE("test"),
true);
check("test\\",
STRV_MAKE_EMPTY,
true);
}
static void test_endswith(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
assert_se(endswith("foobar", "bar"));
assert_se(endswith("foobar", ""));
assert_se(endswith("foobar", "foobar"));
assert_se(endswith("", ""));
assert_se(!endswith("foobar", "foo"));
assert_se(!endswith("foobar", "foobarfoofoo"));
}
static void test_endswith_no_case(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
assert_se(endswith_no_case("fooBAR", "bar"));
assert_se(endswith_no_case("foobar", ""));
assert_se(endswith_no_case("foobar", "FOOBAR"));
assert_se(endswith_no_case("", ""));
assert_se(!endswith_no_case("foobar", "FOO"));
assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));
}
static void test_delete_chars(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
char *s, input[] = " hello, waldo. abc";
s = delete_chars(input, WHITESPACE);
assert_se(streq(s, "hello,waldo.abc"));
assert_se(s == input);
}
static void test_delete_trailing_chars(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
char *s,
input1[] = " \n \r k \n \r ",
input2[] = "kkkkthiskkkiskkkaktestkkk",
input3[] = "abcdef";
s = delete_trailing_chars(input1, WHITESPACE);
assert_se(streq(s, " \n \r k"));
assert_se(s == input1);
s = delete_trailing_chars(input2, "kt");
assert_se(streq(s, "kkkkthiskkkiskkkaktes"));
assert_se(s == input2);
s = delete_trailing_chars(input3, WHITESPACE);
assert_se(streq(s, "abcdef"));
assert_se(s == input3);
s = delete_trailing_chars(input3, "fe");
assert_se(streq(s, "abcd"));
assert_se(s == input3);
}
test-string-util: add another test for stripping slashes I wrote this for my own "strip_trailing_chars" function, which was in the meanwhile obsoleted by "delete_trailing_chars". Let's just keep the test.
2017-11-01 16:59:30 +01:00
static void test_delete_trailing_slashes(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
test-string-util: add another test for stripping slashes I wrote this for my own "strip_trailing_chars" function, which was in the meanwhile obsoleted by "delete_trailing_chars". Let's just keep the test.
2017-11-01 16:59:30 +01:00
char s1[] = "foobar//",
s2[] = "foobar/",
s3[] = "foobar",
s4[] = "";
assert_se(streq(delete_trailing_chars(s1, "_"), "foobar//"));
assert_se(streq(delete_trailing_chars(s1, "/"), "foobar"));
assert_se(streq(delete_trailing_chars(s2, "/"), "foobar"));
assert_se(streq(delete_trailing_chars(s3, "/"), "foobar"));
assert_se(streq(delete_trailing_chars(s4, "/"), ""));
}
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
static void test_skip_leading_chars(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
char input1[] = " \n \r k \n \r ",
input2[] = "kkkkthiskkkiskkkaktestkkk",
input3[] = "abcdef";
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
assert_se(streq(skip_leading_chars(input1, WHITESPACE), "k \n \r "));
assert_se(streq(skip_leading_chars(input2, "k"), "thiskkkiskkkaktestkkk"));
assert_se(streq(skip_leading_chars(input2, "tk"), "hiskkkiskkkaktestkkk"));
assert_se(streq(skip_leading_chars(input3, WHITESPACE), "abcdef"));
assert_se(streq(skip_leading_chars(input3, "bcaef"), "def"));
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
}
static void test_in_charset(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
assert_se(in_charset("dddaaabbbcccc", "abcd"));
assert_se(!in_charset("dddaaabbbcccc", "abc f"));
}
static void test_split_pair(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
_cleanup_free_ char *a = NULL, *b = NULL;
assert_se(split_pair("", "", &a, &b) == -EINVAL);
assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
assert_se(split_pair("", "=", &a, &b) == -EINVAL);
assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
assert_se(streq(a, "foo"));
assert_se(streq(b, "bar"));
free(a);
free(b);
assert_se(split_pair("==", "==", &a, &b) >= 0);
assert_se(streq(a, ""));
assert_se(streq(b, ""));
free(a);
free(b);
assert_se(split_pair("===", "==", &a, &b) >= 0);
assert_se(streq(a, ""));
assert_se(streq(b, "="));
}
static void test_first_word(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
assert_se(first_word("Hello", ""));
assert_se(first_word("Hello", "Hello"));
assert_se(first_word("Hello world", "Hello"));
assert_se(first_word("Hello\tworld", "Hello"));
assert_se(first_word("Hello\nworld", "Hello"));
assert_se(first_word("Hello\rworld", "Hello"));
assert_se(first_word("Hello ", "Hello"));
assert_se(!first_word("Hello", "Hellooo"));
assert_se(!first_word("Hello", "xxxxx"));
assert_se(!first_word("Hellooo", "Hello"));
}
string-util: add strlen_ptr() helper strlen_ptr() is to strlen() what streq_ptr() is to streq(): i.e. it handles NULL strings in a smart way.
2017-07-20 11:38:15 +02:00
static void test_strlen_ptr(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: add strlen_ptr() helper strlen_ptr() is to strlen() what streq_ptr() is to streq(): i.e. it handles NULL strings in a smart way.
2017-07-20 11:38:15 +02:00
assert_se(strlen_ptr("foo") == 3);
assert_se(strlen_ptr("") == 0);
assert_se(strlen_ptr(NULL) == 0);
}
string-util: add new memory_startswith() helper We have code like this at various placer, let's make things shorter and more readable with a helper for it.
2018-05-30 13:07:37 +02:00
static void test_memory_startswith(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: add new memory_startswith() helper We have code like this at various placer, let's make things shorter and more readable with a helper for it.
2018-05-30 13:07:37 +02:00
assert_se(streq(memory_startswith("", 0, ""), ""));
assert_se(streq(memory_startswith("", 1, ""), ""));
assert_se(streq(memory_startswith("x", 2, ""), "x"));
assert_se(!memory_startswith("", 1, "x"));
assert_se(!memory_startswith("", 1, "xxxxxxxx"));
assert_se(streq(memory_startswith("xxx", 4, "x"), "xx"));
assert_se(streq(memory_startswith("xxx", 4, "xx"), "x"));
assert_se(streq(memory_startswith("xxx", 4, "xxx"), ""));
assert_se(!memory_startswith("xxx", 4, "xxxx"));
}
importd, basic/string-util: use case-insensitive comparison for HTTP headers According to RFC2616[1], HTTP header names are case-insensitive. So it's totally valid to have a header starting with either `Date:` or `date:`. However, when systemd-importd pulls an image from an HTTP server, it parses HTTP headers by comparing header names as-is, without any conversion. That causes failures when some HTTP servers return headers with different combinations of upper-/lower-cases. An example: https://alpha.release.flatcar-linux.net/amd64-usr/current/flatcar_developer_container.bin.bz2 returns `Etag: "pe89so9oir60"`, while https://alpha.release.core-os.net/amd64-usr/current/coreos_developer_container.bin.bz2 returns `ETag: "f03372edea9a1e7232e282c346099857"`. Since systemd-importd expects to see `ETag`, the etag for the Container Linux image is correctly interpreted as a part of the hidden file name. However, it cannot parse etag for Flatcar Linux, so the etag the Flatcar Linux image is not appended to the hidden file name. ``` $ sudo ls -al /var/lib/machines/ -r--r--r-- 1 root root 3303014400 Aug 21 20:07 '.raw-https:\x2f\x2falpha\x2erelease\x2ecore-os\x2enet\x2famd64-usr\x2fcurrent\x2fcoreos_developer_container\x2ebin\x2ebz2.\x22f03372edea9a1e7232e282c346099857\x22.raw' -r--r--r-- 1 root root 3303014400 Aug 17 06:15 '.raw-https:\x2f\x2falpha\x2erelease\x2eflatcar-linux\x2enet\x2famd64-usr\x2fcurrent\x2fflatcar_developer_container\x2ebin\x2ebz2.raw' ``` As a result, when the Flatcar image is removed and downloaded again, systemd-importd is not able to determine if the file has been already downloaded, so it always download it again. Then it fails to rename it to an expected name, because there's already a hidden file. To fix this issue, let's introduce a new helper function `memory_startswith_no_case()`, which compares memory regions in a case-insensitive way. Use this function in `curl_header_strdup()`. See also https://github.com/kinvolk/kube-spawn/issues/304 [1]: https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
2018-09-03 20:44:13 +02:00
static void test_memory_startswith_no_case(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
importd, basic/string-util: use case-insensitive comparison for HTTP headers According to RFC2616[1], HTTP header names are case-insensitive. So it's totally valid to have a header starting with either `Date:` or `date:`. However, when systemd-importd pulls an image from an HTTP server, it parses HTTP headers by comparing header names as-is, without any conversion. That causes failures when some HTTP servers return headers with different combinations of upper-/lower-cases. An example: https://alpha.release.flatcar-linux.net/amd64-usr/current/flatcar_developer_container.bin.bz2 returns `Etag: "pe89so9oir60"`, while https://alpha.release.core-os.net/amd64-usr/current/coreos_developer_container.bin.bz2 returns `ETag: "f03372edea9a1e7232e282c346099857"`. Since systemd-importd expects to see `ETag`, the etag for the Container Linux image is correctly interpreted as a part of the hidden file name. However, it cannot parse etag for Flatcar Linux, so the etag the Flatcar Linux image is not appended to the hidden file name. ``` $ sudo ls -al /var/lib/machines/ -r--r--r-- 1 root root 3303014400 Aug 21 20:07 '.raw-https:\x2f\x2falpha\x2erelease\x2ecore-os\x2enet\x2famd64-usr\x2fcurrent\x2fcoreos_developer_container\x2ebin\x2ebz2.\x22f03372edea9a1e7232e282c346099857\x22.raw' -r--r--r-- 1 root root 3303014400 Aug 17 06:15 '.raw-https:\x2f\x2falpha\x2erelease\x2eflatcar-linux\x2enet\x2famd64-usr\x2fcurrent\x2fflatcar_developer_container\x2ebin\x2ebz2.raw' ``` As a result, when the Flatcar image is removed and downloaded again, systemd-importd is not able to determine if the file has been already downloaded, so it always download it again. Then it fails to rename it to an expected name, because there's already a hidden file. To fix this issue, let's introduce a new helper function `memory_startswith_no_case()`, which compares memory regions in a case-insensitive way. Use this function in `curl_header_strdup()`. See also https://github.com/kinvolk/kube-spawn/issues/304 [1]: https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
2018-09-03 20:44:13 +02:00
assert_se(streq(memory_startswith_no_case("", 0, ""), ""));
assert_se(streq(memory_startswith_no_case("", 1, ""), ""));
assert_se(streq(memory_startswith_no_case("x", 2, ""), "x"));
assert_se(streq(memory_startswith_no_case("X", 2, ""), "X"));
assert_se(!memory_startswith_no_case("", 1, "X"));
assert_se(!memory_startswith_no_case("", 1, "xxxxXXXX"));
assert_se(streq(memory_startswith_no_case("xxx", 4, "X"), "xx"));
assert_se(streq(memory_startswith_no_case("XXX", 4, "x"), "XX"));
assert_se(streq(memory_startswith_no_case("XXX", 4, "X"), "XX"));
assert_se(streq(memory_startswith_no_case("xxx", 4, "XX"), "x"));
assert_se(streq(memory_startswith_no_case("XXX", 4, "xx"), "X"));
assert_se(streq(memory_startswith_no_case("XXX", 4, "XX"), "X"));
assert_se(streq(memory_startswith_no_case("xxx", 4, "XXX"), ""));
assert_se(streq(memory_startswith_no_case("XXX", 4, "xxx"), ""));
assert_se(streq(memory_startswith_no_case("XXX", 4, "XXX"), ""));
assert_se(memory_startswith_no_case((char[2]){'x', 'x'}, 2, "xx"));
assert_se(memory_startswith_no_case((char[2]){'x', 'X'}, 2, "xX"));
assert_se(memory_startswith_no_case((char[2]){'X', 'x'}, 2, "Xx"));
assert_se(memory_startswith_no_case((char[2]){'X', 'X'}, 2, "XX"));
}
string-util: let's add helper for truncating string after a specified number of lines
2020-01-13 16:07:06 +01:00
static void test_string_truncate_lines_one(const char *input, size_t n_lines, const char *output, bool truncation) {
_cleanup_free_ char *b = NULL;
int k;
assert_se((k = string_truncate_lines(input, n_lines, &b)) >= 0);
assert_se(streq(b, output));
assert_se(!!k == truncation);
}
static void test_string_truncate_lines(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: let's add helper for truncating string after a specified number of lines
2020-01-13 16:07:06 +01:00
test_string_truncate_lines_one("", 0, "", false);
test_string_truncate_lines_one("", 1, "", false);
test_string_truncate_lines_one("", 2, "", false);
test_string_truncate_lines_one("", 3, "", false);
test_string_truncate_lines_one("x", 0, "", true);
test_string_truncate_lines_one("x", 1, "x", false);
test_string_truncate_lines_one("x", 2, "x", false);
test_string_truncate_lines_one("x", 3, "x", false);
test_string_truncate_lines_one("x\n", 0, "", true);
test_string_truncate_lines_one("x\n", 1, "x", false);
test_string_truncate_lines_one("x\n", 2, "x", false);
test_string_truncate_lines_one("x\n", 3, "x", false);
test_string_truncate_lines_one("x\ny", 0, "", true);
test_string_truncate_lines_one("x\ny", 1, "x", true);
test_string_truncate_lines_one("x\ny", 2, "x\ny", false);
test_string_truncate_lines_one("x\ny", 3, "x\ny", false);
test_string_truncate_lines_one("x\ny\n", 0, "", true);
test_string_truncate_lines_one("x\ny\n", 1, "x", true);
test_string_truncate_lines_one("x\ny\n", 2, "x\ny", false);
test_string_truncate_lines_one("x\ny\n", 3, "x\ny", false);
test_string_truncate_lines_one("x\ny\nz", 0, "", true);
test_string_truncate_lines_one("x\ny\nz", 1, "x", true);
test_string_truncate_lines_one("x\ny\nz", 2, "x\ny", true);
test_string_truncate_lines_one("x\ny\nz", 3, "x\ny\nz", false);
test_string_truncate_lines_one("x\ny\nz\n", 0, "", true);
test_string_truncate_lines_one("x\ny\nz\n", 1, "x", true);
test_string_truncate_lines_one("x\ny\nz\n", 2, "x\ny", true);
test_string_truncate_lines_one("x\ny\nz\n", 3, "x\ny\nz", false);
test_string_truncate_lines_one("\n", 0, "", false);
test_string_truncate_lines_one("\n", 1, "", false);
test_string_truncate_lines_one("\n", 2, "", false);
test_string_truncate_lines_one("\n", 3, "", false);
test_string_truncate_lines_one("\n\n", 0, "", false);
test_string_truncate_lines_one("\n\n", 1, "", false);
test_string_truncate_lines_one("\n\n", 2, "", false);
test_string_truncate_lines_one("\n\n", 3, "", false);
test_string_truncate_lines_one("\n\n\n", 0, "", false);
test_string_truncate_lines_one("\n\n\n", 1, "", false);
test_string_truncate_lines_one("\n\n\n", 2, "", false);
test_string_truncate_lines_one("\n\n\n", 3, "", false);
test_string_truncate_lines_one("\nx\n\n", 0, "", true);
test_string_truncate_lines_one("\nx\n\n", 1, "", true);
test_string_truncate_lines_one("\nx\n\n", 2, "\nx", false);
test_string_truncate_lines_one("\nx\n\n", 3, "\nx", false);
test_string_truncate_lines_one("\n\nx\n", 0, "", true);
test_string_truncate_lines_one("\n\nx\n", 1, "", true);
test_string_truncate_lines_one("\n\nx\n", 2, "", true);
test_string_truncate_lines_one("\n\nx\n", 3, "\n\nx", false);
}
string-util: add helper for extracting n'th line of a string
2020-01-13 16:20:27 +01:00
static void test_string_extract_lines_one(const char *input, size_t i, const char *output, bool more) {
_cleanup_free_ char *b = NULL;
int k;
assert_se((k = string_extract_line(input, i, &b)) >= 0);
assert_se(streq(b ?: input, output));
assert_se(!!k == more);
}
static void test_string_extract_line(void) {
test-string-util,test-extract-word: add log headers
2020-07-30 11:31:03 +02:00
log_info("/* %s */", __func__);
string-util: add helper for extracting n'th line of a string
2020-01-13 16:20:27 +01:00
test_string_extract_lines_one("", 0, "", false);
test_string_extract_lines_one("", 1, "", false);
test_string_extract_lines_one("", 2, "", false);
test_string_extract_lines_one("", 3, "", false);
test_string_extract_lines_one("x", 0, "x", false);
test_string_extract_lines_one("x", 1, "", false);
test_string_extract_lines_one("x", 2, "", false);
test_string_extract_lines_one("x", 3, "", false);
test_string_extract_lines_one("x\n", 0, "x", false);
test_string_extract_lines_one("x\n", 1, "", false);
test_string_extract_lines_one("x\n", 2, "", false);
test_string_extract_lines_one("x\n", 3, "", false);
test_string_extract_lines_one("x\ny", 0, "x", true);
test_string_extract_lines_one("x\ny", 1, "y", false);
test_string_extract_lines_one("x\ny", 2, "", false);
test_string_extract_lines_one("x\ny", 3, "", false);
test_string_extract_lines_one("x\ny\n", 0, "x", true);
test_string_extract_lines_one("x\ny\n", 1, "y", false);
test_string_extract_lines_one("x\ny\n", 2, "", false);
test_string_extract_lines_one("x\ny\n", 3, "", false);
test_string_extract_lines_one("x\ny\nz", 0, "x", true);
test_string_extract_lines_one("x\ny\nz", 1, "y", true);
test_string_extract_lines_one("x\ny\nz", 2, "z", false);
test_string_extract_lines_one("x\ny\nz", 3, "", false);
test_string_extract_lines_one("\n", 0, "", false);
test_string_extract_lines_one("\n", 1, "", false);
test_string_extract_lines_one("\n", 2, "", false);
test_string_extract_lines_one("\n", 3, "", false);
test_string_extract_lines_one("\n\n", 0, "", true);
test_string_extract_lines_one("\n\n", 1, "", false);
test_string_extract_lines_one("\n\n", 2, "", false);
test_string_extract_lines_one("\n\n", 3, "", false);
test_string_extract_lines_one("\n\n\n", 0, "", true);
test_string_extract_lines_one("\n\n\n", 1, "", true);
test_string_extract_lines_one("\n\n\n", 2, "", false);
test_string_extract_lines_one("\n\n\n", 3, "", false);
test_string_extract_lines_one("\n\n\n\n", 0, "", true);
test_string_extract_lines_one("\n\n\n\n", 1, "", true);
test_string_extract_lines_one("\n\n\n\n", 2, "", true);
test_string_extract_lines_one("\n\n\n\n", 3, "", false);
test_string_extract_lines_one("\nx\n\n\n", 0, "", true);
test_string_extract_lines_one("\nx\n\n\n", 1, "x", true);
test_string_extract_lines_one("\nx\n\n\n", 2, "", true);
test_string_extract_lines_one("\nx\n\n\n", 3, "", false);
test_string_extract_lines_one("\n\nx\n\n", 0, "", true);
test_string_extract_lines_one("\n\nx\n\n", 1, "", true);
test_string_extract_lines_one("\n\nx\n\n", 2, "x", true);
test_string_extract_lines_one("\n\nx\n\n", 3, "", false);
test_string_extract_lines_one("\n\n\nx\n", 0, "", true);
test_string_extract_lines_one("\n\n\nx\n", 1, "", true);
test_string_extract_lines_one("\n\n\nx\n", 2, "", true);
test_string_extract_lines_one("\n\n\nx\n", 3, "x", false);
}
Add string_contains_word_strv() I had to move STRV_MAKE to macro.h. There is a circular dependency between extract-word.h, strv.h, and string-util.h that makes it hard to define the inline function otherwise.
2020-07-30 10:34:44 +02:00
static void test_string_contains_word_strv(void) {
log_info("/* %s */", __func__);
const char *w;
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), NULL));
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("a", "b"), &w));
assert_se(streq(w, "a"));
assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE("d"), &w));
assert_se(w == NULL);
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", "a"), &w));
assert_se(streq(w, "a"));
assert_se(string_contains_word_strv("b a b cc", NULL, STRV_MAKE("b", "a", "b"), &w));
assert_se(streq(w, "b"));
assert_se(string_contains_word_strv("a b cc", NULL, STRV_MAKE("b", ""), &w));
assert_se(streq(w, "b"));
assert_se(!string_contains_word_strv("a b cc", NULL, STRV_MAKE(""), &w));
assert_se(w == NULL);
assert_se(string_contains_word_strv("a b cc", " ", STRV_MAKE(""), &w));
assert_se(streq(w, ""));
}
basic: add string_contains_word() This wraps the common pattern of using extract_first_word() in a loop to look for a matching word.
2020-07-29 14:06:26 +02:00
static void test_string_contains_word(void) {
log_info("/* %s */", __func__);
assert_se( string_contains_word("a b cc", NULL, "a"));
assert_se( string_contains_word("a b cc", NULL, "b"));
assert_se(!string_contains_word("a b cc", NULL, "c"));
assert_se( string_contains_word("a b cc", NULL, "cc"));
assert_se(!string_contains_word("a b cc", NULL, "d"));
assert_se(!string_contains_word("a b cc", NULL, "a b"));
assert_se(!string_contains_word("a b cc", NULL, "a b c"));
assert_se(!string_contains_word("a b cc", NULL, "b c"));
assert_se(!string_contains_word("a b cc", NULL, "b cc"));
assert_se(!string_contains_word("a b cc", NULL, "a "));
assert_se(!string_contains_word("a b cc", NULL, " b "));
assert_se(!string_contains_word("a b cc", NULL, " cc"));
assert_se( string_contains_word(" a b\t\tcc", NULL, "a"));
assert_se( string_contains_word(" a b\t\tcc", NULL, "b"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "c"));
assert_se( string_contains_word(" a b\t\tcc", NULL, "cc"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "d"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "a b"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "a b\t\tc"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "b\t\tc"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "b\t\tcc"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, "a "));
assert_se(!string_contains_word(" a b\t\tcc", NULL, " b "));
assert_se(!string_contains_word(" a b\t\tcc", NULL, " cc"));
assert_se(!string_contains_word(" a b\t\tcc", NULL, ""));
assert_se(!string_contains_word(" a b\t\tcc", NULL, " "));
assert_se(!string_contains_word(" a b\t\tcc", NULL, " "));
assert_se( string_contains_word(" a b\t\tcc", " ", ""));
assert_se( string_contains_word(" a b\t\tcc", "\t", ""));
assert_se( string_contains_word(" a b\t\tcc", WHITESPACE, ""));
assert_se( string_contains_word("a:b:cc", ":#", "a"));
assert_se( string_contains_word("a:b:cc", ":#", "b"));
assert_se(!string_contains_word("a:b:cc", ":#", "c"));
assert_se( string_contains_word("a:b:cc", ":#", "cc"));
assert_se(!string_contains_word("a:b:cc", ":#", "d"));
assert_se(!string_contains_word("a:b:cc", ":#", "a:b"));
assert_se(!string_contains_word("a:b:cc", ":#", "a:b:c"));
assert_se(!string_contains_word("a:b:cc", ":#", "b:c"));
assert_se(!string_contains_word("a#b#cc", ":#", "b:cc"));
assert_se( string_contains_word("a#b#cc", ":#", "b"));
assert_se( string_contains_word("a#b#cc", ":#", "cc"));
assert_se(!string_contains_word("a:b:cc", ":#", "a:"));
assert_se(!string_contains_word("a:b cc", ":#", "b"));
assert_se( string_contains_word("a:b cc", ":#", "b cc"));
assert_se(!string_contains_word("a:b:cc", ":#", ":cc"));
}
string-util: rework memory_erase() so that it cannot be optimized away memory_erase() so far just called memset(), which the compiler might optimize away under certain conditions if it feels there's benefit in it. C11 knows a new memset_s() call that is like memset(), but may not be optimized away. Ideally, we'd just use that call, but glibc currently does not support it. Hence, implement our own simplistic version of it. We use a GCC pragma to turn off optimization for this call, and also use the "volatile" keyword on the pointers to ensure that gcc will use the pointers as-is. According to a variety of internet sources, either one does the trick. However, there are also reports that at least the volatile thing isn't fully correct, hence let's add some snake oil and employ both techniques. https://news.ycombinator.com/item?id=4711346
2015-11-01 20:28:55 +01:00
int main(int argc, char *argv[]) {
Introduce free_and_strndup and use it in bus-message.c v2: fix error in free_and_strndup() When the orignal and copied message were the same, but shorter than specified length l, memory read past the end of the buffer would be performed. A test case is included: a string that had an embedded NUL ("q\0") is used to replace "q". v3: Fix one more bug in free_and_strndup and add tests. v4: Some style fixed based on review, one more use of free_and_replace, and make the tests more comprehensive.
2018-07-09 07:03:01 +02:00
test_setup_logging(LOG_DEBUG);
string-util: readd string_erase() This was dropped in 8e27167cc9b8beda2bf49789b15f0b0301b95d17, but is actually useful for some usecases still.
2019-07-11 14:50:26 +02:00
test_string_erase();
Introduce free_and_strndup and use it in bus-message.c v2: fix error in free_and_strndup() When the orignal and copied message were the same, but shorter than specified length l, memory read past the end of the buffer would be performed. A test case is included: a string that had an embedded NUL ("q\0") is used to replace "q". v3: Fix one more bug in free_and_strndup and add tests. v4: Some style fixed based on review, one more use of free_and_replace, and make the tests more comprehensive.
2018-07-09 07:03:01 +02:00
test_free_and_strndup();
basic: add new ascii_strcasecmp_n() call
2016-01-13 02:21:16 +01:00
test_ascii_strcasecmp_n();
basic: add ascii_strcasecmp_nn() call In contrast to ascii_strcasecmp_nn() it takes two character buffers with their individual length. It will then compare the buffers up the smaller size of the two buffers, and finally the length themselves.
2016-01-13 19:45:05 +01:00
test_ascii_strcasecmp_nn();
basic/string-util: add a convenience function to cescape mostly-ascii fields It's not supposed to be the most efficient, but instead fast and simple to use. I kept the logic in ellipsize_mem() to use unicode ellipsis even in non-unicode locales. I'm not quite convinced things should be this way, especially that with this patch it'd actually be simpler to always use "…" in unicode locale and "..." otherwise, but Lennart wanted it this way for some reason.
2018-05-17 10:55:21 +02:00
test_cellescape();
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
test_streq_ptr();
test_strstrip();
test_strextend();
string-util: rework strextend() to optionally inset separators between each appended string This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
2017-11-28 16:37:53 +01:00
test_strextend_with_separator();
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
test_strrep();
test_string_has_cc();
test_ascii_strlower();
test_strshorten();
test_strjoina();
test-string-util: add a test for strjoin() Strangely, we didn't have one so far. I mostly wanted to verify that NULL can be used in any spot at behaves the same as "".
2020-08-20 13:37:31 +02:00
test_strjoin();
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
test_strcmp_ptr();
test_foreach_word();
test_foreach_word_quoted();
test_endswith();
test_endswith_no_case();
test_delete_chars();
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
test_delete_trailing_chars();
test-string-util: add another test for stripping slashes I wrote this for my own "strip_trailing_chars" function, which was in the meanwhile obsoleted by "delete_trailing_chars". Let's just keep the test.
2017-11-01 16:59:30 +01:00
test_delete_trailing_slashes();
string-util: add delete_trailing_chars() and skip_leading_chars() helpers And let's port over a couple of users to the new APIs.
2017-11-09 11:12:47 +01:00
test_skip_leading_chars();
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
test_in_charset();
test_split_pair();
test_first_word();
string-util: add strlen_ptr() helper strlen_ptr() is to strlen() what streq_ptr() is to streq(): i.e. it handles NULL strings in a smart way.
2017-07-20 11:38:15 +02:00
test_strlen_ptr();
string-util: add new memory_startswith() helper We have code like this at various placer, let's make things shorter and more readable with a helper for it.
2018-05-30 13:07:37 +02:00
test_memory_startswith();
importd, basic/string-util: use case-insensitive comparison for HTTP headers According to RFC2616[1], HTTP header names are case-insensitive. So it's totally valid to have a header starting with either `Date:` or `date:`. However, when systemd-importd pulls an image from an HTTP server, it parses HTTP headers by comparing header names as-is, without any conversion. That causes failures when some HTTP servers return headers with different combinations of upper-/lower-cases. An example: https://alpha.release.flatcar-linux.net/amd64-usr/current/flatcar_developer_container.bin.bz2 returns `Etag: "pe89so9oir60"`, while https://alpha.release.core-os.net/amd64-usr/current/coreos_developer_container.bin.bz2 returns `ETag: "f03372edea9a1e7232e282c346099857"`. Since systemd-importd expects to see `ETag`, the etag for the Container Linux image is correctly interpreted as a part of the hidden file name. However, it cannot parse etag for Flatcar Linux, so the etag the Flatcar Linux image is not appended to the hidden file name. ``` $ sudo ls -al /var/lib/machines/ -r--r--r-- 1 root root 3303014400 Aug 21 20:07 '.raw-https:\x2f\x2falpha\x2erelease\x2ecore-os\x2enet\x2famd64-usr\x2fcurrent\x2fcoreos_developer_container\x2ebin\x2ebz2.\x22f03372edea9a1e7232e282c346099857\x22.raw' -r--r--r-- 1 root root 3303014400 Aug 17 06:15 '.raw-https:\x2f\x2falpha\x2erelease\x2eflatcar-linux\x2enet\x2famd64-usr\x2fcurrent\x2fflatcar_developer_container\x2ebin\x2ebz2.raw' ``` As a result, when the Flatcar image is removed and downloaded again, systemd-importd is not able to determine if the file has been already downloaded, so it always download it again. Then it fails to rename it to an expected name, because there's already a hidden file. To fix this issue, let's introduce a new helper function `memory_startswith_no_case()`, which compares memory regions in a case-insensitive way. Use this function in `curl_header_strdup()`. See also https://github.com/kinvolk/kube-spawn/issues/304 [1]: https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
2018-09-03 20:44:13 +02:00
test_memory_startswith_no_case();
string-util: let's add helper for truncating string after a specified number of lines
2020-01-13 16:07:06 +01:00
test_string_truncate_lines();
string-util: add helper for extracting n'th line of a string
2020-01-13 16:20:27 +01:00
test_string_extract_line();
Add string_contains_word_strv() I had to move STRV_MAKE to macro.h. There is a circular dependency between extract-word.h, strv.h, and string-util.h that makes it hard to define the inline function otherwise.
2020-07-30 10:34:44 +02:00
test_string_contains_word_strv();
basic: add string_contains_word() This wraps the common pattern of using extract_first_word() in a loop to look for a matching word.
2020-07-29 14:06:26 +02:00
test_string_contains_word();
tests: move string related tests to test-string-util.c
2016-03-02 22:57:20 +01:00
string-util: rework memory_erase() so that it cannot be optimized away memory_erase() so far just called memset(), which the compiler might optimize away under certain conditions if it feels there's benefit in it. C11 knows a new memset_s() call that is like memset(), but may not be optimized away. Ideally, we'd just use that call, but glibc currently does not support it. Hence, implement our own simplistic version of it. We use a GCC pragma to turn off optimization for this call, and also use the "volatile" keyword on the pointers to ensure that gcc will use the pointers as-is. According to a variety of internet sources, either one does the trick. However, there are also reports that at least the volatile thing isn't fully correct, hence let's add some snake oil and employ both techniques. https://news.ycombinator.com/item?id=4711346
2015-11-01 20:28:55 +01:00
return 0;
}