From 5809c451e8a6413af27fd73b5b533d612e9740bd Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sun, 7 Sep 2025 03:00:39 +0900 Subject: [PATCH 1/9] test-efi-string: migrate to use ASSERT_OK() and friends --- src/boot/test-efi-string.c | 780 +++++++++++++++++++------------------ 1 file changed, 397 insertions(+), 383 deletions(-) diff --git a/src/boot/test-efi-string.c b/src/boot/test-efi-string.c index 4d8300aa91..e0d3bd9b71 100644 --- a/src/boot/test-efi-string.c +++ b/src/boot/test-efi-string.c @@ -9,360 +9,360 @@ #include "tests.h" TEST(strlen8) { - assert_se(strlen8(NULL) == 0); - assert_se(strlen8("") == 0); - assert_se(strlen8("1") == 1); - assert_se(strlen8("11") == 2); - assert_se(strlen8("123456789") == 9); - assert_se(strlen8("12\0004") == 2); + ASSERT_EQ(strlen8(NULL), 0u); + ASSERT_EQ(strlen8(""), 0u); + ASSERT_EQ(strlen8("1"), 1u); + ASSERT_EQ(strlen8("11"), 2u); + ASSERT_EQ(strlen8("123456789"), 9u); + ASSERT_EQ(strlen8("12\0004"), 2u); } TEST(strlen16) { - assert_se(strlen16(NULL) == 0); - assert_se(strlen16(u"") == 0); - assert_se(strlen16(u"1") == 1); - assert_se(strlen16(u"11") == 2); - assert_se(strlen16(u"123456789") == 9); - assert_se(strlen16(u"12\0004") == 2); + ASSERT_EQ(strlen16(NULL), 0u); + ASSERT_EQ(strlen16(u""), 0u); + ASSERT_EQ(strlen16(u"1"), 1u); + ASSERT_EQ(strlen16(u"11"), 2u); + ASSERT_EQ(strlen16(u"123456789"), 9u); + ASSERT_EQ(strlen16(u"12\0004"), 2u); } TEST(strnlen8) { - assert_se(strnlen8(NULL, 0) == 0); - assert_se(strnlen8(NULL, 10) == 0); - assert_se(strnlen8("", 10) == 0); - assert_se(strnlen8("1", 10) == 1); - assert_se(strnlen8("11", 1) == 1); - assert_se(strnlen8("123456789", 7) == 7); - assert_se(strnlen8("12\0004", 5) == 2); + ASSERT_EQ(strnlen8(NULL, 0), 0u); + ASSERT_EQ(strnlen8(NULL, 10), 0u); + ASSERT_EQ(strnlen8("", 10), 0u); + ASSERT_EQ(strnlen8("1", 10), 1u); + ASSERT_EQ(strnlen8("11", 1), 1u); + ASSERT_EQ(strnlen8("123456789", 7), 7u); + ASSERT_EQ(strnlen8("12\0004", 5), 2u); } TEST(strnlen16) { - assert_se(strnlen16(NULL, 0) == 0); - assert_se(strnlen16(NULL, 10) == 0); - assert_se(strnlen16(u"", 10) == 0); - assert_se(strnlen16(u"1", 10) == 1); - assert_se(strnlen16(u"11", 1) == 1); - assert_se(strnlen16(u"123456789", 7) == 7); - assert_se(strnlen16(u"12\0004", 5) == 2); + ASSERT_EQ(strnlen16(NULL, 0), 0u); + ASSERT_EQ(strnlen16(NULL, 10), 0u); + ASSERT_EQ(strnlen16(u"", 10), 0u); + ASSERT_EQ(strnlen16(u"1", 10), 1u); + ASSERT_EQ(strnlen16(u"11", 1), 1u); + ASSERT_EQ(strnlen16(u"123456789", 7), 7u); + ASSERT_EQ(strnlen16(u"12\0004", 5), 2u); } TEST(strsize8) { - assert_se(strsize8(NULL) == 0); - assert_se(strsize8("") == 1); - assert_se(strsize8("1") == 2); - assert_se(strsize8("11") == 3); - assert_se(strsize8("123456789") == 10); - assert_se(strsize8("12\0004") == 3); + ASSERT_EQ(strsize8(NULL), 0u); + ASSERT_EQ(strsize8(""), 1u); + ASSERT_EQ(strsize8("1"), 2u); + ASSERT_EQ(strsize8("11"), 3u); + ASSERT_EQ(strsize8("123456789"), 10u); + ASSERT_EQ(strsize8("12\0004"), 3u); } TEST(strsize16) { - assert_se(strsize16(NULL) == 0); - assert_se(strsize16(u"") == 2); - assert_se(strsize16(u"1") == 4); - assert_se(strsize16(u"11") == 6); - assert_se(strsize16(u"123456789") == 20); - assert_se(strsize16(u"12\0004") == 6); + ASSERT_EQ(strsize16(NULL), 0u); + ASSERT_EQ(strsize16(u""), 2u); + ASSERT_EQ(strsize16(u"1"), 4u); + ASSERT_EQ(strsize16(u"11"), 6u); + ASSERT_EQ(strsize16(u"123456789"), 20u); + ASSERT_EQ(strsize16(u"12\0004"), 6u); } TEST(strtolower8) { char s[] = "\0001234abcDEF!\0zZ"; - strtolower8(NULL); + ASSERT_NULL(strtolower8(NULL)); - strtolower8(s); - assert_se(memcmp(s, "\0001234abcDEF!\0zZ", sizeof(s)) == 0); + ASSERT_PTR_EQ(strtolower8(s), s); + ASSERT_EQ(memcmp(s, "\0001234abcDEF!\0zZ", sizeof(s)), 0); s[0] = '#'; - strtolower8(s); - assert_se(memcmp(s, "#1234abcdef!\0zZ", sizeof(s)) == 0); + ASSERT_PTR_EQ(strtolower8(s), s); + ASSERT_EQ(memcmp(s, "#1234abcdef!\0zZ", sizeof(s)), 0); } TEST(strtolower16) { char16_t s[] = u"\0001234abcDEF!\0zZ"; - strtolower16(NULL); + ASSERT_NULL(strtolower16(NULL)); - strtolower16(s); - assert_se(memcmp(s, u"\0001234abcDEF!\0zZ", sizeof(s)) == 0); + ASSERT_PTR_EQ(strtolower16(s), s); + ASSERT_EQ(memcmp(s, u"\0001234abcDEF!\0zZ", sizeof(s)), 0); s[0] = '#'; - strtolower16(s); - assert_se(memcmp(s, u"#1234abcdef!\0zZ", sizeof(s)) == 0); + ASSERT_PTR_EQ(strtolower16(s), s); + ASSERT_EQ(memcmp(s, u"#1234abcdef!\0zZ", sizeof(s)), 0); } TEST(strncmp8) { - assert_se(strncmp8(NULL, "", 10) < 0); - assert_se(strncmp8("", NULL, 10) > 0); - assert_se(strncmp8(NULL, NULL, 0) == 0); - assert_se(strncmp8(NULL, NULL, 10) == 0); - assert_se(strncmp8("", "", 10) == 0); - assert_se(strncmp8("abc", "abc", 2) == 0); - assert_se(strncmp8("aBc", "aBc", 3) == 0); - assert_se(strncmp8("aBC", "aBC", 4) == 0); - assert_se(strncmp8("", "a", 0) == 0); - assert_se(strncmp8("b", "a", 0) == 0); - assert_se(strncmp8("", "a", 3) < 0); - assert_se(strncmp8("=", "=", 1) == 0); - assert_se(strncmp8("A", "a", 1) < 0); - assert_se(strncmp8("a", "A", 2) > 0); - assert_se(strncmp8("a", "Aa", 2) > 0); - assert_se(strncmp8("12\00034", "12345", 4) < 0); - assert_se(strncmp8("12\00034", "12345", SIZE_MAX) < 0); - assert_se(strncmp8("abc\0def", "abc", SIZE_MAX) == 0); - assert_se(strncmp8("abc\0def", "abcdef", SIZE_MAX) < 0); + ASSERT_LT(strncmp8(NULL, "", 10), 0); + ASSERT_GT(strncmp8("", NULL, 10), 0); + ASSERT_EQ(strncmp8(NULL, NULL, 0), 0); + ASSERT_EQ(strncmp8(NULL, NULL, 10), 0); + ASSERT_EQ(strncmp8("", "", 10), 0); + ASSERT_EQ(strncmp8("abc", "abc", 2), 0); + ASSERT_EQ(strncmp8("aBc", "aBc", 3), 0); + ASSERT_EQ(strncmp8("aBC", "aBC", 4), 0); + ASSERT_EQ(strncmp8("", "a", 0), 0); + ASSERT_EQ(strncmp8("b", "a", 0), 0); + ASSERT_LT(strncmp8("", "a", 3), 0); + ASSERT_EQ(strncmp8("=", "=", 1), 0); + ASSERT_LT(strncmp8("A", "a", 1), 0); + ASSERT_GT(strncmp8("a", "A", 2), 0); + ASSERT_GT(strncmp8("a", "Aa", 2), 0); + ASSERT_LT(strncmp8("12\00034", "12345", 4), 0); + ASSERT_LT(strncmp8("12\00034", "12345", SIZE_MAX), 0); + ASSERT_EQ(strncmp8("abc\0def", "abc", SIZE_MAX), 0); + ASSERT_LT(strncmp8("abc\0def", "abcdef", SIZE_MAX), 0); - assert_se(strncmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MIN }, 1) == 0); - assert_se(strncmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MAX }, 1) == 0); - assert_se(strncmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MAX }, 1) < 0); - assert_se(strncmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MIN }, 1) > 0); + ASSERT_EQ(strncmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MIN }, 1), 0); + ASSERT_EQ(strncmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MAX }, 1), 0); + ASSERT_LT(strncmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MAX }, 1), 0); + ASSERT_GT(strncmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MIN }, 1), 0); } TEST(strncmp16) { - assert_se(strncmp16(NULL, u"", 10) < 0); - assert_se(strncmp16(u"", NULL, 10) > 0); - assert_se(strncmp16(NULL, NULL, 0) == 0); - assert_se(strncmp16(NULL, NULL, 10) == 0); - assert_se(strncmp16(u"", u"", 0) == 0); - assert_se(strncmp16(u"", u"", 10) == 0); - assert_se(strncmp16(u"abc", u"abc", 2) == 0); - assert_se(strncmp16(u"aBc", u"aBc", 3) == 0); - assert_se(strncmp16(u"aBC", u"aBC", 4) == 0); - assert_se(strncmp16(u"", u"a", 0) == 0); - assert_se(strncmp16(u"b", u"a", 0) == 0); - assert_se(strncmp16(u"", u"a", 3) < 0); - assert_se(strncmp16(u"=", u"=", 1) == 0); - assert_se(strncmp16(u"A", u"a", 1) < 0); - assert_se(strncmp16(u"a", u"A", 2) > 0); - assert_se(strncmp16(u"a", u"Aa", 2) > 0); - assert_se(strncmp16(u"12\00034", u"12345", 4) < 0); - assert_se(strncmp16(u"12\00034", u"12345", SIZE_MAX) < 0); - assert_se(strncmp16(u"abc\0def", u"abc", SIZE_MAX) == 0); - assert_se(strncmp16(u"abc\0def", u"abcdef", SIZE_MAX) < 0); + ASSERT_LT(strncmp16(NULL, u"", 10), 0); + ASSERT_GT(strncmp16(u"", NULL, 10), 0); + ASSERT_EQ(strncmp16(NULL, NULL, 0), 0); + ASSERT_EQ(strncmp16(NULL, NULL, 10), 0); + ASSERT_EQ(strncmp16(u"", u"", 0), 0); + ASSERT_EQ(strncmp16(u"", u"", 10), 0); + ASSERT_EQ(strncmp16(u"abc", u"abc", 2), 0); + ASSERT_EQ(strncmp16(u"aBc", u"aBc", 3), 0); + ASSERT_EQ(strncmp16(u"aBC", u"aBC", 4), 0); + ASSERT_EQ(strncmp16(u"", u"a", 0), 0); + ASSERT_EQ(strncmp16(u"b", u"a", 0), 0); + ASSERT_LT(strncmp16(u"", u"a", 3), 0); + ASSERT_EQ(strncmp16(u"=", u"=", 1), 0); + ASSERT_LT(strncmp16(u"A", u"a", 1), 0); + ASSERT_GT(strncmp16(u"a", u"A", 2), 0); + ASSERT_GT(strncmp16(u"a", u"Aa", 2), 0); + ASSERT_LT(strncmp16(u"12\00034", u"12345", 4), 0); + ASSERT_LT(strncmp16(u"12\00034", u"12345", SIZE_MAX), 0); + ASSERT_EQ(strncmp16(u"abc\0def", u"abc", SIZE_MAX), 0); + ASSERT_LT(strncmp16(u"abc\0def", u"abcdef", SIZE_MAX), 0); - assert_se(strncmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ UINT16_MAX }, 1) == 0); - assert_se(strncmp16((char16_t[]){ 0 }, (char16_t[]){ UINT16_MAX }, 1) < 0); - assert_se(strncmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ 0 }, 1) > 0); + ASSERT_EQ(strncmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ UINT16_MAX }, 1), 0); + ASSERT_LT(strncmp16((char16_t[]){ 0 }, (char16_t[]){ UINT16_MAX }, 1), 0); + ASSERT_GT(strncmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ 0 }, 1), 0); } TEST(strncasecmp8) { - assert_se(strncasecmp8(NULL, "", 10) < 0); - assert_se(strncasecmp8("", NULL, 10) > 0); - assert_se(strncasecmp8(NULL, NULL, 0) == 0); - assert_se(strncasecmp8(NULL, NULL, 10) == 0); - assert_se(strncasecmp8("", "", 10) == 0); - assert_se(strncasecmp8("abc", "abc", 2) == 0); - assert_se(strncasecmp8("aBc", "AbC", 3) == 0); - assert_se(strncasecmp8("aBC", "Abc", 4) == 0); - assert_se(strncasecmp8("", "a", 0) == 0); - assert_se(strncasecmp8("b", "a", 0) == 0); - assert_se(strncasecmp8("", "a", 3) < 0); - assert_se(strncasecmp8("=", "=", 1) == 0); - assert_se(strncasecmp8("A", "a", 1) == 0); - assert_se(strncasecmp8("a", "A", 2) == 0); - assert_se(strncasecmp8("a", "Aa", 2) < 0); - assert_se(strncasecmp8("12\00034", "12345", 4) < 0); - assert_se(strncasecmp8("12\00034", "12345", SIZE_MAX) < 0); - assert_se(strncasecmp8("abc\0def", "ABC", SIZE_MAX) == 0); - assert_se(strncasecmp8("abc\0def", "ABCDEF", SIZE_MAX) < 0); + ASSERT_LT(strncasecmp8(NULL, "", 10), 0); + ASSERT_GT(strncasecmp8("", NULL, 10), 0); + ASSERT_EQ(strncasecmp8(NULL, NULL, 0), 0); + ASSERT_EQ(strncasecmp8(NULL, NULL, 10), 0); + ASSERT_EQ(strncasecmp8("", "", 10), 0); + ASSERT_EQ(strncasecmp8("abc", "abc", 2), 0); + ASSERT_EQ(strncasecmp8("aBc", "AbC", 3), 0); + ASSERT_EQ(strncasecmp8("aBC", "Abc", 4), 0); + ASSERT_EQ(strncasecmp8("", "a", 0), 0); + ASSERT_EQ(strncasecmp8("b", "a", 0), 0); + ASSERT_LT(strncasecmp8("", "a", 3), 0); + ASSERT_EQ(strncasecmp8("=", "=", 1), 0); + ASSERT_EQ(strncasecmp8("A", "a", 1), 0); + ASSERT_EQ(strncasecmp8("a", "A", 2), 0); + ASSERT_LT(strncasecmp8("a", "Aa", 2), 0); + ASSERT_LT(strncasecmp8("12\00034", "12345", 4), 0); + ASSERT_LT(strncasecmp8("12\00034", "12345", SIZE_MAX), 0); + ASSERT_EQ(strncasecmp8("abc\0def", "ABC", SIZE_MAX), 0); + ASSERT_LT(strncasecmp8("abc\0def", "ABCDEF", SIZE_MAX), 0); - assert_se(strncasecmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MIN }, 1) == 0); - assert_se(strncasecmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MAX }, 1) == 0); - assert_se(strncasecmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MAX }, 1) < 0); - assert_se(strncasecmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MIN }, 1) > 0); + ASSERT_EQ(strncasecmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MIN }, 1), 0); + ASSERT_EQ(strncasecmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MAX }, 1), 0); + ASSERT_LT(strncasecmp8((char[]){ CHAR_MIN }, (char[]){ CHAR_MAX }, 1), 0); + ASSERT_GT(strncasecmp8((char[]){ CHAR_MAX }, (char[]){ CHAR_MIN }, 1), 0); } TEST(strncasecmp16) { - assert_se(strncasecmp16(NULL, u"", 10) < 0); - assert_se(strncasecmp16(u"", NULL, 10) > 0); - assert_se(strncasecmp16(NULL, NULL, 0) == 0); - assert_se(strncasecmp16(NULL, NULL, 10) == 0); - assert_se(strncasecmp16(u"", u"", 10) == 0); - assert_se(strncasecmp16(u"abc", u"abc", 2) == 0); - assert_se(strncasecmp16(u"aBc", u"AbC", 3) == 0); - assert_se(strncasecmp16(u"aBC", u"Abc", 4) == 0); - assert_se(strncasecmp16(u"", u"a", 0) == 0); - assert_se(strncasecmp16(u"b", u"a", 0) == 0); - assert_se(strncasecmp16(u"", u"a", 3) < 0); - assert_se(strncasecmp16(u"=", u"=", 1) == 0); - assert_se(strncasecmp16(u"A", u"a", 1) == 0); - assert_se(strncasecmp16(u"a", u"A", 2) == 0); - assert_se(strncasecmp16(u"a", u"Aa", 2) < 0); - assert_se(strncasecmp16(u"12\00034", u"12345", 4) < 0); - assert_se(strncasecmp16(u"12\00034", u"12345", SIZE_MAX) < 0); - assert_se(strncasecmp16(u"abc\0def", u"ABC", SIZE_MAX) == 0); - assert_se(strncasecmp16(u"abc\0def", u"ABCDEF", SIZE_MAX) < 0); + ASSERT_LT(strncasecmp16(NULL, u"", 10), 0); + ASSERT_GT(strncasecmp16(u"", NULL, 10), 0); + ASSERT_EQ(strncasecmp16(NULL, NULL, 0), 0); + ASSERT_EQ(strncasecmp16(NULL, NULL, 10), 0); + ASSERT_EQ(strncasecmp16(u"", u"", 10), 0); + ASSERT_EQ(strncasecmp16(u"abc", u"abc", 2), 0); + ASSERT_EQ(strncasecmp16(u"aBc", u"AbC", 3), 0); + ASSERT_EQ(strncasecmp16(u"aBC", u"Abc", 4), 0); + ASSERT_EQ(strncasecmp16(u"", u"a", 0), 0); + ASSERT_EQ(strncasecmp16(u"b", u"a", 0), 0); + ASSERT_LT(strncasecmp16(u"", u"a", 3), 0); + ASSERT_EQ(strncasecmp16(u"=", u"=", 1), 0); + ASSERT_EQ(strncasecmp16(u"A", u"a", 1), 0); + ASSERT_EQ(strncasecmp16(u"a", u"A", 2), 0); + ASSERT_LT(strncasecmp16(u"a", u"Aa", 2), 0); + ASSERT_LT(strncasecmp16(u"12\00034", u"12345", 4), 0); + ASSERT_LT(strncasecmp16(u"12\00034", u"12345", SIZE_MAX), 0); + ASSERT_EQ(strncasecmp16(u"abc\0def", u"ABC", SIZE_MAX), 0); + ASSERT_LT(strncasecmp16(u"abc\0def", u"ABCDEF", SIZE_MAX), 0); - assert_se(strncasecmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ UINT16_MAX }, 1) == 0); - assert_se(strncasecmp16((char16_t[]){ 0 }, (char16_t[]){ UINT16_MAX }, 1) < 0); - assert_se(strncasecmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ 0 }, 1) > 0); + ASSERT_EQ(strncasecmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ UINT16_MAX }, 1), 0); + ASSERT_LT(strncasecmp16((char16_t[]){ 0 }, (char16_t[]){ UINT16_MAX }, 1), 0); + ASSERT_GT(strncasecmp16((char16_t[]){ UINT16_MAX }, (char16_t[]){ 0 }, 1), 0); } TEST(strcpy8) { char buf[128]; - assert_se(strcpy8(buf, "123") == buf); - assert_se(streq8(buf, "123")); - assert_se(strcpy8(buf, "") == buf); - assert_se(streq8(buf, "")); - assert_se(strcpy8(buf, "A") == buf); - assert_se(streq8(buf, "A")); - assert_se(strcpy8(buf, NULL) == buf); - assert_se(streq8(buf, "")); + ASSERT_PTR_EQ(strcpy8(buf, "123"), buf); + ASSERT_TRUE(streq8(buf, "123")); + ASSERT_PTR_EQ(strcpy8(buf, ""), buf); + ASSERT_TRUE(streq8(buf, "")); + ASSERT_PTR_EQ(strcpy8(buf, "A"), buf); + ASSERT_TRUE(streq8(buf, "A")); + ASSERT_PTR_EQ(strcpy8(buf, NULL), buf); + ASSERT_TRUE(streq8(buf, "")); } TEST(strcpy16) { char16_t buf[128]; - assert_se(strcpy16(buf, u"123") == buf); - assert_se(streq16(buf, u"123")); - assert_se(strcpy16(buf, u"") == buf); - assert_se(streq16(buf, u"")); - assert_se(strcpy16(buf, u"A") == buf); - assert_se(streq16(buf, u"A")); - assert_se(strcpy16(buf, NULL) == buf); - assert_se(streq16(buf, u"")); + ASSERT_PTR_EQ(strcpy16(buf, u"123"), buf); + ASSERT_TRUE(streq16(buf, u"123")); + ASSERT_PTR_EQ(strcpy16(buf, u""), buf); + ASSERT_TRUE(streq16(buf, u"")); + ASSERT_PTR_EQ(strcpy16(buf, u"A"), buf); + ASSERT_TRUE(streq16(buf, u"A")); + ASSERT_PTR_EQ(strcpy16(buf, NULL), buf); + ASSERT_TRUE(streq16(buf, u"")); } TEST(strchr8) { - assert_se(!strchr8(NULL, 'a')); - assert_se(!strchr8("", 'a')); - assert_se(!strchr8("123", 'a')); + ASSERT_NULL(strchr8(NULL, 'a')); + ASSERT_NULL(strchr8("", 'a')); + ASSERT_NULL(strchr8("123", 'a')); const char str[] = "abcaBc"; - assert_se(strchr8(str, 'a') == &str[0]); - assert_se(strchr8(str, 'c') == &str[2]); - assert_se(strchr8(str, 'B') == &str[4]); + ASSERT_PTR_EQ(strchr8(str, 'a'), &str[0]); + ASSERT_PTR_EQ(strchr8(str, 'c'), &str[2]); + ASSERT_PTR_EQ(strchr8(str, 'B'), &str[4]); - assert_se(strchr8(str, 0) == str + strlen8(str)); + ASSERT_PTR_EQ(strchr8(str, 0), str + strlen8(str)); } TEST(strchr16) { - assert_se(!strchr16(NULL, 'a')); - assert_se(!strchr16(u"", 'a')); - assert_se(!strchr16(u"123", 'a')); + ASSERT_NULL(strchr16(NULL, 'a')); + ASSERT_NULL(strchr16(u"", 'a')); + ASSERT_NULL(strchr16(u"123", 'a')); const char16_t str[] = u"abcaBc"; - assert_se(strchr16(str, 'a') == &str[0]); - assert_se(strchr16(str, 'c') == &str[2]); - assert_se(strchr16(str, 'B') == &str[4]); + ASSERT_PTR_EQ(strchr16(str, 'a'), &str[0]); + ASSERT_PTR_EQ(strchr16(str, 'c'), &str[2]); + ASSERT_PTR_EQ(strchr16(str, 'B'), &str[4]); - assert_se(strchr16(str, 0) == str + strlen16(str)); + ASSERT_PTR_EQ(strchr16(str, 0), str + strlen16(str)); } TEST(xstrndup8) { char *s = NULL; - assert_se(xstrndup8(NULL, 0) == NULL); - assert_se(xstrndup8(NULL, 10) == NULL); + ASSERT_NULL(xstrndup8(NULL, 0)); + ASSERT_NULL(xstrndup8(NULL, 10)); - assert_se(s = xstrndup8("", 10)); - assert_se(streq8(s, "")); + ASSERT_NOT_NULL(s = xstrndup8("", 10)); + ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrndup8("abc", 0)); - assert_se(streq8(s, "")); + ASSERT_NOT_NULL(s = xstrndup8("abc", 0)); + ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrndup8("ABC", 3)); - assert_se(streq8(s, "ABC")); + ASSERT_NOT_NULL(s = xstrndup8("ABC", 3)); + ASSERT_TRUE(streq8(s, "ABC")); free(s); - assert_se(s = xstrndup8("123abcDEF", 5)); - assert_se(streq8(s, "123ab")); + ASSERT_NOT_NULL(s = xstrndup8("123abcDEF", 5)); + ASSERT_TRUE(streq8(s, "123ab")); free(s); } TEST(xstrdup8) { char *s = NULL; - assert_se(xstrdup8(NULL) == NULL); + ASSERT_NULL(xstrdup8(NULL)); - assert_se(s = xstrdup8("")); - assert_se(streq8(s, "")); + ASSERT_NOT_NULL(s = xstrdup8("")); + ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrdup8("1")); - assert_se(streq8(s, "1")); + ASSERT_NOT_NULL(s = xstrdup8("1")); + ASSERT_TRUE(streq8(s, "1")); free(s); - assert_se(s = xstrdup8("123abcDEF")); - assert_se(streq8(s, "123abcDEF")); + ASSERT_NOT_NULL(s = xstrdup8("123abcDEF")); + ASSERT_TRUE(streq8(s, "123abcDEF")); free(s); } TEST(xstrndup16) { char16_t *s = NULL; - assert_se(xstrndup16(NULL, 0) == NULL); - assert_se(xstrndup16(NULL, 10) == NULL); + ASSERT_NULL(xstrndup16(NULL, 0)); + ASSERT_NULL(xstrndup16(NULL, 10)); - assert_se(s = xstrndup16(u"", 10)); - assert_se(streq16(s, u"")); + ASSERT_NOT_NULL(s = xstrndup16(u"", 10)); + ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrndup16(u"abc", 0)); - assert_se(streq16(s, u"")); + ASSERT_NOT_NULL(s = xstrndup16(u"abc", 0)); + ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrndup16(u"ABC", 3)); - assert_se(streq16(s, u"ABC")); + ASSERT_NOT_NULL(s = xstrndup16(u"ABC", 3)); + ASSERT_TRUE(streq16(s, u"ABC")); free(s); - assert_se(s = xstrndup16(u"123abcDEF", 5)); - assert_se(streq16(s, u"123ab")); + ASSERT_NOT_NULL(s = xstrndup16(u"123abcDEF", 5)); + ASSERT_TRUE(streq16(s, u"123ab")); free(s); } TEST(xstrdup16) { char16_t *s = NULL; - assert_se(xstrdup16(NULL) == NULL); + ASSERT_NULL(xstrdup16(NULL)); - assert_se(s = xstrdup16(u"")); - assert_se(streq16(s, u"")); + ASSERT_NOT_NULL(s = xstrdup16(u"")); + ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrdup16(u"1")); - assert_se(streq16(s, u"1")); + ASSERT_NOT_NULL(s = xstrdup16(u"1")); + ASSERT_TRUE(streq16(s, u"1")); free(s); - assert_se(s = xstrdup16(u"123abcDEF")); - assert_se(streq16(s, u"123abcDEF")); + ASSERT_NOT_NULL(s = xstrdup16(u"123abcDEF")); + ASSERT_TRUE(streq16(s, u"123abcDEF")); free(s); } TEST(xstrn8_to_16) { char16_t *s = NULL; - assert_se(s = xstrn8_to_16(NULL, 0)); + ASSERT_NOT_NULL(s = xstrn8_to_16(NULL, 0)); ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrn8_to_16("", 0)); + ASSERT_NOT_NULL(s = xstrn8_to_16("", 0)); ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrn8_to_16("a", 0)); + ASSERT_NOT_NULL(s = xstrn8_to_16("a", 0)); ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrn8_to_16("", 1)); + ASSERT_NOT_NULL(s = xstrn8_to_16("", 1)); ASSERT_TRUE(streq16(s, u"")); free(s); - assert_se(s = xstrn8_to_16("1", 1)); + ASSERT_NOT_NULL(s = xstrn8_to_16("1", 1)); ASSERT_TRUE(streq16(s, u"1")); free(s); - assert_se(s = xstr8_to_16("abcxyzABCXYZ09 .,-_#*!\"§$%&/()=?`~")); + ASSERT_NOT_NULL(s = xstr8_to_16("abcxyzABCXYZ09 .,-_#*!\"§$%&/()=?`~")); ASSERT_TRUE(streq16(s, u"abcxyzABCXYZ09 .,-_#*!\"§$%&/()=?`~")); free(s); - assert_se(s = xstr8_to_16("ÿⱿ𝇉 😺")); + ASSERT_NOT_NULL(s = xstr8_to_16("ÿⱿ𝇉 😺")); ASSERT_TRUE(streq16(s, u"ÿⱿ ")); free(s); - assert_se(s = xstrn8_to_16("¶¶", 3)); + ASSERT_NOT_NULL(s = xstrn8_to_16("¶¶", 3)); ASSERT_TRUE(streq16(s, u"¶")); free(s); } @@ -370,50 +370,50 @@ TEST(xstrn8_to_16) { TEST(xstrn16_to_ascii) { char *s; - assert_se(s = xstrn16_to_ascii(NULL, 0)); + ASSERT_NOT_NULL(s = xstrn16_to_ascii(NULL, 0)); ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrn16_to_ascii(u"", 0)); + ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"", 0)); ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrn16_to_ascii(u"a", 0)); + ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"a", 0)); ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrn16_to_ascii(u"", 1)); + ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"", 1)); ASSERT_TRUE(streq8(s, "")); free(s); - assert_se(s = xstrn16_to_ascii(u"1", 1)); + ASSERT_NOT_NULL(s = xstrn16_to_ascii(u"1", 1)); ASSERT_TRUE(streq8(s, "1")); free(s); - assert_se(s = xstr16_to_ascii(u"abcxyzABCXYZ09 .,-_#*!\"$%&/()=?`~")); + ASSERT_NOT_NULL(s = xstr16_to_ascii(u"abcxyzABCXYZ09 .,-_#*!\"$%&/()=?`~")); ASSERT_TRUE(streq8(s, "abcxyzABCXYZ09 .,-_#*!\"$%&/()=?`~")); free(s); - assert_se(!xstr16_to_ascii(u"ÿⱿ𝇉 😺")); - assert_se(!xstr16_to_ascii(u"¶¶")); + ASSERT_NULL(xstr16_to_ascii(u"ÿⱿ𝇉 😺")); + ASSERT_NULL(xstr16_to_ascii(u"¶¶")); } TEST(startswith8) { - assert_se(streq8(startswith8("", ""), "")); - assert_se(streq8(startswith8("x", ""), "x")); - assert_se(!startswith8("", "x")); - assert_se(!startswith8("", "xxxxxxxx")); - assert_se(streq8(startswith8("xxx", "x"), "xx")); - assert_se(streq8(startswith8("xxx", "xx"), "x")); - assert_se(streq8(startswith8("xxx", "xxx"), "")); - assert_se(!startswith8("xxx", "xxxx")); - assert_se(!startswith8(NULL, "")); + ASSERT_TRUE(streq8(startswith8("", ""), "")); + ASSERT_TRUE(streq8(startswith8("x", ""), "x")); + ASSERT_NULL(startswith8("", "x")); + ASSERT_NULL(startswith8("", "xxxxxxxx")); + ASSERT_TRUE(streq8(startswith8("xxx", "x"), "xx")); + ASSERT_TRUE(streq8(startswith8("xxx", "xx"), "x")); + ASSERT_TRUE(streq8(startswith8("xxx", "xxx"), "")); + ASSERT_NULL(startswith8("xxx", "xxxx")); + ASSERT_NULL(startswith8(NULL, "")); } #define TEST_FNMATCH_ONE(pattern, haystack, expect) \ ({ \ - assert_se(fnmatch(pattern, haystack, 0) == (expect ? 0 : FNM_NOMATCH)); \ - assert_se(efi_fnmatch(u##pattern, u##haystack) == expect); \ + ASSERT_EQ(fnmatch(pattern, haystack, 0), expect ? 0 : FNM_NOMATCH); \ + ASSERT_EQ(efi_fnmatch(u##pattern, u##haystack), expect); \ }) TEST(efi_fnmatch) { @@ -477,74 +477,86 @@ TEST(parse_number8) { uint64_t u; const char *tail; - assert_se(!parse_number8(NULL, &u, NULL)); - assert_se(!parse_number8("", &u, NULL)); - assert_se(!parse_number8("a1", &u, NULL)); - assert_se(!parse_number8("1a", &u, NULL)); - assert_se(!parse_number8("-42", &u, NULL)); - assert_se(!parse_number8("18446744073709551616", &u, NULL)); + ASSERT_FALSE(parse_number8(NULL, &u, NULL)); + ASSERT_FALSE(parse_number8("", &u, NULL)); + ASSERT_FALSE(parse_number8("a1", &u, NULL)); + ASSERT_FALSE(parse_number8("1a", &u, NULL)); + ASSERT_FALSE(parse_number8("-42", &u, NULL)); + ASSERT_FALSE(parse_number8("18446744073709551616", &u, NULL)); - assert_se(parse_number8("0", &u, NULL)); - assert_se(u == 0); - assert_se(parse_number8("1", &u, NULL)); - assert_se(u == 1); - assert_se(parse_number8("999", &u, NULL)); - assert_se(u == 999); - assert_se(parse_number8("18446744073709551615", &u, NULL)); - assert_se(u == UINT64_MAX); - assert_se(parse_number8("42", &u, &tail)); - assert_se(u == 42); - assert_se(streq8(tail, "")); - assert_se(parse_number8("54321rest", &u, &tail)); - assert_se(u == 54321); - assert_se(streq8(tail, "rest")); + ASSERT_TRUE(parse_number8("0", &u, NULL)); + ASSERT_EQ(u, 0u); + ASSERT_TRUE(parse_number8("1", &u, NULL)); + ASSERT_EQ(u, 1u); + ASSERT_TRUE(parse_number8("999", &u, NULL)); + ASSERT_EQ(u, 999u); + ASSERT_TRUE(parse_number8("18446744073709551615", &u, NULL)); + ASSERT_EQ(u, UINT64_MAX); + ASSERT_TRUE(parse_number8("42", &u, &tail)); + ASSERT_EQ(u, 42u); + ASSERT_TRUE(streq8(tail, "")); + ASSERT_TRUE(parse_number8("54321rest", &u, &tail)); + ASSERT_EQ(u, 54321u); + ASSERT_TRUE(streq8(tail, "rest")); } TEST(parse_number16) { uint64_t u; const char16_t *tail; - assert_se(!parse_number16(NULL, &u, NULL)); - assert_se(!parse_number16(u"", &u, NULL)); - assert_se(!parse_number16(u"a1", &u, NULL)); - assert_se(!parse_number16(u"1a", &u, NULL)); - assert_se(!parse_number16(u"-42", &u, NULL)); - assert_se(!parse_number16(u"18446744073709551616", &u, NULL)); + ASSERT_FALSE(parse_number16(NULL, &u, NULL)); + ASSERT_FALSE(parse_number16(u"", &u, NULL)); + ASSERT_FALSE(parse_number16(u"a1", &u, NULL)); + ASSERT_FALSE(parse_number16(u"1a", &u, NULL)); + ASSERT_FALSE(parse_number16(u"-42", &u, NULL)); + ASSERT_FALSE(parse_number16(u"18446744073709551616", &u, NULL)); - assert_se(parse_number16(u"0", &u, NULL)); - assert_se(u == 0); - assert_se(parse_number16(u"1", &u, NULL)); - assert_se(u == 1); - assert_se(parse_number16(u"999", &u, NULL)); - assert_se(u == 999); - assert_se(parse_number16(u"18446744073709551615", &u, NULL)); - assert_se(u == UINT64_MAX); - assert_se(parse_number16(u"42", &u, &tail)); - assert_se(u == 42); - assert_se(streq16(tail, u"")); - assert_se(parse_number16(u"54321rest", &u, &tail)); - assert_se(u == 54321); - assert_se(streq16(tail, u"rest")); + ASSERT_TRUE(parse_number16(u"0", &u, NULL)); + ASSERT_EQ(u, 0u); + ASSERT_TRUE(parse_number16(u"1", &u, NULL)); + ASSERT_EQ(u, 1u); + ASSERT_TRUE(parse_number16(u"999", &u, NULL)); + ASSERT_EQ(u, 999u); + ASSERT_TRUE(parse_number16(u"18446744073709551615", &u, NULL)); + ASSERT_EQ(u, UINT64_MAX); + ASSERT_TRUE(parse_number16(u"42", &u, &tail)); + ASSERT_EQ(u, 42u); + ASSERT_TRUE(streq16(tail, u"")); + ASSERT_TRUE(parse_number16(u"54321rest", &u, &tail)); + ASSERT_EQ(u, 54321u); + ASSERT_TRUE(streq16(tail, u"rest")); } TEST(parse_boolean) { bool b; - assert_se(!parse_boolean(NULL, &b)); - assert_se(!parse_boolean("", &b)); - assert_se(!parse_boolean("ja", &b)); - assert_se(parse_boolean("1", &b) && b == true); - assert_se(parse_boolean("y", &b) && b == true); - assert_se(parse_boolean("yes", &b) && b == true); - assert_se(parse_boolean("t", &b) && b == true); - assert_se(parse_boolean("true", &b) && b == true); - assert_se(parse_boolean("on", &b) && b == true); - assert_se(parse_boolean("0", &b) && b == false); - assert_se(parse_boolean("n", &b) && b == false); - assert_se(parse_boolean("no", &b) && b == false); - assert_se(parse_boolean("f", &b) && b == false); - assert_se(parse_boolean("false", &b) && b == false); - assert_se(parse_boolean("off", &b) && b == false); + ASSERT_FALSE(parse_boolean(NULL, &b)); + ASSERT_FALSE(parse_boolean("", &b)); + ASSERT_FALSE(parse_boolean("ja", &b)); + ASSERT_TRUE(parse_boolean("1", &b)); + ASSERT_TRUE(b); + ASSERT_TRUE(parse_boolean("y", &b)); + ASSERT_TRUE(b); + ASSERT_TRUE(parse_boolean("yes", &b)); + ASSERT_TRUE(b); + ASSERT_TRUE(parse_boolean("t", &b)); + ASSERT_TRUE(b); + ASSERT_TRUE(parse_boolean("true", &b)); + ASSERT_TRUE(b); + ASSERT_TRUE(parse_boolean("on", &b)); + ASSERT_TRUE(b); + ASSERT_TRUE(parse_boolean("0", &b)); + ASSERT_FALSE(b); + ASSERT_TRUE(parse_boolean("n", &b)); + ASSERT_FALSE(b); + ASSERT_TRUE(parse_boolean("no", &b)); + ASSERT_FALSE(b); + ASSERT_TRUE(parse_boolean("f", &b)); + ASSERT_FALSE(b); + ASSERT_TRUE(parse_boolean("false", &b)); + ASSERT_FALSE(b); + ASSERT_TRUE(parse_boolean("off", &b)); + ASSERT_FALSE(b); } TEST(line_get_key_value) { @@ -561,46 +573,46 @@ TEST(line_get_key_value) { size_t pos = 0; char *key, *value; - assert_se(!line_get_key_value((char[]){ "" }, "=", &pos, &key, &value)); - assert_se(!line_get_key_value((char[]){ "\t" }, " \t", &pos, &key, &value)); + ASSERT_NULL(line_get_key_value((char[]){ "" }, "=", &pos, &key, &value)); + ASSERT_NULL(line_get_key_value((char[]){ "\t" }, " \t", &pos, &key, &value)); pos = 0; - assert_se(line_get_key_value(s1, "=", &pos, &key, &value)); - assert_se(streq8(key, "key")); - assert_se(streq8(value, "value")); - assert_se(line_get_key_value(s1, "=", &pos, &key, &value)); - assert_se(streq8(key, "k-e-y")); - assert_se(streq8(value, "quoted value")); - assert_se(line_get_key_value(s1, "=", &pos, &key, &value)); - assert_se(streq8(key, "wrong")); - assert_se(streq8(value, " 'quotes'")); - assert_se(line_get_key_value(s1, "=", &pos, &key, &value)); - assert_se(streq8(key, "odd")); - assert_se(streq8(value, " stripping # with comments")); - assert_se(!line_get_key_value(s1, "=", &pos, &key, &value)); + ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "key")); + ASSERT_TRUE(streq8(value, "value")); + ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "k-e-y")); + ASSERT_TRUE(streq8(value, "quoted value")); + ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "wrong")); + ASSERT_TRUE(streq8(value, " 'quotes'")); + ASSERT_NOT_NULL(line_get_key_value(s1, "=", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "odd")); + ASSERT_TRUE(streq8(value, " stripping # with comments")); + ASSERT_NULL(line_get_key_value(s1, "=", &pos, &key, &value)); pos = 0; - assert_se(line_get_key_value(s2, " \t", &pos, &key, &value)); - assert_se(streq8(key, "this")); - assert_se(streq8(value, "parser")); - assert_se(line_get_key_value(s2, " \t", &pos, &key, &value)); - assert_se(streq8(key, "also")); - assert_se(streq8(value, "used")); - assert_se(line_get_key_value(s2, " \t", &pos, &key, &value)); - assert_se(streq8(key, "for")); - assert_se(streq8(value, "the conf")); - assert_se(line_get_key_value(s2, " \t", &pos, &key, &value)); - assert_se(streq8(key, "format")); - assert_se(streq8(value, "!!")); - assert_se(!line_get_key_value(s2, " \t", &pos, &key, &value)); + ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "this")); + ASSERT_TRUE(streq8(value, "parser")); + ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "also")); + ASSERT_TRUE(streq8(value, "used")); + ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "for")); + ASSERT_TRUE(streq8(value, "the conf")); + ASSERT_NOT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value)); + ASSERT_TRUE(streq8(key, "format")); + ASSERT_TRUE(streq8(value, "!!")); + ASSERT_NULL(line_get_key_value(s2, " \t", &pos, &key, &value)); /* Let's make sure we don't fail on real os-release data. */ _cleanup_free_ char *osrel = NULL; if (read_full_file("/usr/lib/os-release", &osrel, NULL) >= 0) { pos = 0; while (line_get_key_value(osrel, "=", &pos, &key, &value)) { - assert_se(key); - assert_se(value); + ASSERT_NOT_NULL(key); + ASSERT_NOT_NULL(value); printf("%s = %s\n", key, value); } } @@ -609,34 +621,36 @@ TEST(line_get_key_value) { TEST(hexdump) { char16_t *hex; - hex = hexdump(NULL, 0); - assert(streq16(hex, u"")); + ASSERT_NOT_NULL(hex = hexdump(NULL, 0)); + ASSERT_TRUE(streq16(hex, u"")); free(hex); - hex = hexdump("1", 2); - assert(streq16(hex, u"3100")); + ASSERT_NOT_NULL(hex = hexdump("1", 2)); + ASSERT_TRUE(streq16(hex, u"3100")); free(hex); - hex = hexdump("abc", 4); - assert(streq16(hex, u"61626300")); + ASSERT_NOT_NULL(hex = hexdump("abc", 4)); + ASSERT_TRUE(streq16(hex, u"61626300")); free(hex); - hex = hexdump((uint8_t[]){ 0x0, 0x42, 0xFF, 0xF1, 0x1F }, 5); - assert(streq16(hex, u"0042fff11f")); + ASSERT_NOT_NULL(hex = hexdump((uint8_t[]){ 0x0, 0x42, 0xFF, 0xF1, 0x1F }, 5)); + ASSERT_TRUE(streq16(hex, u"0042fff11f")); free(hex); } _printf_(1, 2) static void test_printf_one(const char *format, ...) { va_list ap, ap_efi; + int r; + va_start(ap, format); va_copy(ap_efi, ap); _cleanup_free_ char *buf = NULL; - int r = vasprintf(&buf, format, ap); - assert_se(r >= 0); + ASSERT_OK(r = vasprintf(&buf, format, ap)); log_info("/* %s(%s) -> \"%.100s\" */", __func__, format, buf); - _cleanup_free_ char16_t *buf_efi = xvasprintf_status(0, format, ap_efi); + _cleanup_free_ char16_t *buf_efi = NULL; + ASSERT_NOT_NULL(buf_efi = xvasprintf_status(0, format, ap_efi)); bool eq = true; for (size_t i = 0; i <= (size_t) r; i++) { @@ -646,7 +660,7 @@ _printf_(1, 2) static void test_printf_one(const char *format, ...) { } log_info("%.100s", buf); - assert_se(eq); + ASSERT_TRUE(eq); va_end(ap); va_end(ap_efi); @@ -747,90 +761,90 @@ TEST(xvasprintf_status) { /* Non printf-compatible behavior tests below. */ char16_t *s; - assert_se(s = xasprintf_status(0, "\n \r \r\n")); - assert_se(streq16(s, u"\r\n \r \r\r\n")); + ASSERT_NOT_NULL(s = xasprintf_status(0, "\n \r \r\n")); + ASSERT_TRUE(streq16(s, u"\r\n \r \r\r\n")); s = mfree(s); - assert_se(s = xasprintf_status(EFI_SUCCESS, "%m")); - assert_se(streq16(s, u"Success")); + ASSERT_NOT_NULL(s = xasprintf_status(EFI_SUCCESS, "%m")); + ASSERT_TRUE(streq16(s, u"Success")); s = mfree(s); - assert_se(s = xasprintf_status(EFI_SUCCESS, "%15m")); - assert_se(streq16(s, u" Success")); + ASSERT_NOT_NULL(s = xasprintf_status(EFI_SUCCESS, "%15m")); + ASSERT_TRUE(streq16(s, u" Success")); s = mfree(s); - assert_se(s = xasprintf_status(EFI_LOAD_ERROR, "%m")); - assert_se(streq16(s, u"Load error")); + ASSERT_NOT_NULL(s = xasprintf_status(EFI_LOAD_ERROR, "%m")); + ASSERT_TRUE(streq16(s, u"Load error")); s = mfree(s); - assert_se(s = xasprintf_status(0x42, "%m")); - assert_se(streq16(s, u"0x42")); + ASSERT_NOT_NULL(s = xasprintf_status(0x42, "%m")); + ASSERT_TRUE(streq16(s, u"0x42")); s = mfree(s); } TEST(efi_memchr) { - assert_se(streq8(efi_memchr("abcde", 'c', 5), "cde")); - assert_se(streq8(efi_memchr("abcde", 'c', 3), "cde")); - assert_se(streq8(efi_memchr("abcde", 'c', 2), NULL)); - assert_se(streq8(efi_memchr("abcde", 'c', 7), "cde")); - assert_se(streq8(efi_memchr("abcde", 'q', 5), NULL)); - assert_se(streq8(efi_memchr("abcde", 'q', 0), NULL)); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 5), "cde")); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 3), "cde")); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 2), NULL)); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'c', 7), "cde")); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'q', 5), NULL)); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'q', 0), NULL)); /* Test that the character is interpreted as unsigned char. */ - assert_se(streq8(efi_memchr("abcde", 'a', 6), efi_memchr("abcde", 'a' + 0x100, 6))); - assert_se(streq8(efi_memchr("abcde", 0, 6), "")); - assert_se(efi_memchr(NULL, 0, 0) == NULL); + ASSERT_TRUE(streq8(efi_memchr("abcde", 'a', 6), efi_memchr("abcde", 'a' + 0x100, 6))); + ASSERT_TRUE(streq8(efi_memchr("abcde", 0, 6), "")); + ASSERT_NULL(efi_memchr(NULL, 0, 0)); } TEST(efi_memcmp) { - assert_se(efi_memcmp(NULL, NULL, 0) == 0); - assert_se(efi_memcmp(NULL, NULL, 1) == 0); - assert_se(efi_memcmp(NULL, "", 1) < 0); - assert_se(efi_memcmp("", NULL, 1) > 0); - assert_se(efi_memcmp("", "", 0) == 0); - assert_se(efi_memcmp("", "", 1) == 0); - assert_se(efi_memcmp("1", "1", 1) == 0); - assert_se(efi_memcmp("1", "2", 1) < 0); - assert_se(efi_memcmp("A", "a", 1) < 0); - assert_se(efi_memcmp("a", "A", 1) > 0); - assert_se(efi_memcmp("abc", "ab", 2) == 0); - assert_se(efi_memcmp("ab", "abc", 3) < 0); - assert_se(efi_memcmp("abc", "ab", 3) > 0); - assert_se(efi_memcmp("ab\000bd", "ab\000bd", 6) == 0); - assert_se(efi_memcmp("ab\000b\0", "ab\000bd", 6) < 0); + ASSERT_EQ(efi_memcmp(NULL, NULL, 0), 0); + ASSERT_EQ(efi_memcmp(NULL, NULL, 1), 0); + ASSERT_LT(efi_memcmp(NULL, "", 1), 0); + ASSERT_GT(efi_memcmp("", NULL, 1), 0); + ASSERT_EQ(efi_memcmp("", "", 0), 0); + ASSERT_EQ(efi_memcmp("", "", 1), 0); + ASSERT_EQ(efi_memcmp("1", "1", 1), 0); + ASSERT_LT(efi_memcmp("1", "2", 1), 0); + ASSERT_LT(efi_memcmp("A", "a", 1), 0); + ASSERT_GT(efi_memcmp("a", "A", 1), 0); + ASSERT_EQ(efi_memcmp("abc", "ab", 2), 0); + ASSERT_LT(efi_memcmp("ab", "abc", 3), 0); + ASSERT_GT(efi_memcmp("abc", "ab", 3), 0); + ASSERT_EQ(efi_memcmp("ab\000bd", "ab\000bd", 6), 0); + ASSERT_LT(efi_memcmp("ab\000b\0", "ab\000bd", 6), 0); } TEST(efi_memcpy) { char buf[10]; - assert_se(!efi_memcpy(NULL, NULL, 0)); - assert_se(!efi_memcpy(NULL, "", 1)); - assert_se(efi_memcpy(buf, NULL, 0) == buf); - assert_se(efi_memcpy(buf, NULL, 1) == buf); - assert_se(efi_memcpy(buf, "a", 0) == buf); + ASSERT_NULL(efi_memcpy(NULL, NULL, 0)); + ASSERT_NULL(efi_memcpy(NULL, "", 1)); + ASSERT_PTR_EQ(efi_memcpy(buf, NULL, 0), buf); + ASSERT_PTR_EQ(efi_memcpy(buf, NULL, 1), buf); + ASSERT_PTR_EQ(efi_memcpy(buf, "a", 0), buf); - assert_se(efi_memcpy(buf, "", 1) == buf); - assert_se(memcmp(buf, "", 1) == 0); - assert_se(efi_memcpy(buf, "1", 1) == buf); - assert_se(memcmp(buf, "1", 1) == 0); - assert_se(efi_memcpy(buf, "23", 3) == buf); - assert_se(memcmp(buf, "23", 3) == 0); - assert_se(efi_memcpy(buf, "45\0ab\0\0\0c", 9) == buf); - assert_se(memcmp(buf, "45\0ab\0\0\0c", 9) == 0); + ASSERT_PTR_EQ(efi_memcpy(buf, "", 1), buf); + ASSERT_EQ(memcmp(buf, "", 1), 0); + ASSERT_PTR_EQ(efi_memcpy(buf, "1", 1), buf); + ASSERT_EQ(memcmp(buf, "1", 1), 0); + ASSERT_PTR_EQ(efi_memcpy(buf, "23", 3), buf); + ASSERT_EQ(memcmp(buf, "23", 3), 0); + ASSERT_PTR_EQ(efi_memcpy(buf, "45\0ab\0\0\0c", 9), buf); + ASSERT_EQ(memcmp(buf, "45\0ab\0\0\0c", 9), 0); } TEST(efi_memset) { char buf[10]; - assert_se(!efi_memset(NULL, '1', 0)); - assert_se(!efi_memset(NULL, '1', 1)); - assert_se(efi_memset(buf, '1', 0) == buf); + ASSERT_NULL(efi_memset(NULL, '1', 0)); + ASSERT_NULL(efi_memset(NULL, '1', 1)); + ASSERT_PTR_EQ(efi_memset(buf, '1', 0), buf); - assert_se(efi_memset(buf, '2', 1) == buf); - assert_se(memcmp(buf, "2", 1) == 0); - assert_se(efi_memset(buf, '4', 4) == buf); - assert_se(memcmp(buf, "4444", 4) == 0); - assert_se(efi_memset(buf, 'a', 10) == buf); - assert_se(memcmp(buf, "aaaaaaaaaa", 10) == 0); + ASSERT_PTR_EQ(efi_memset(buf, '2', 1), buf); + ASSERT_EQ(memcmp(buf, "2", 1), 0); + ASSERT_PTR_EQ(efi_memset(buf, '4', 4), buf); + ASSERT_EQ(memcmp(buf, "4444", 4), 0); + ASSERT_PTR_EQ(efi_memset(buf, 'a', 10), buf); + ASSERT_EQ(memcmp(buf, "aaaaaaaaaa", 10), 0); } TEST(efi_strspn) { From 6e219a09c2353ddbf52a66536db6c2b5593a903b Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sun, 7 Sep 2025 03:30:21 +0900 Subject: [PATCH 2/9] test-parse-util: use newlocale() and freelocale() to set temporarl locale This also drops unnecessary call of strtod(), as it is a test for safe_atod(). --- src/test/test-parse-util.c | 31 +++++-------------------------- 1 file changed, 5 insertions(+), 26 deletions(-) diff --git a/src/test/test-parse-util.c b/src/test/test-parse-util.c index 2a54dae2a4..37d0280cad 100644 --- a/src/test/test-parse-util.c +++ b/src/test/test-parse-util.c @@ -6,6 +6,7 @@ #include #include +#include "locale-util.h" #include "parse-util.h" #include "tests.h" @@ -655,7 +656,6 @@ TEST(safe_atoux64) { TEST(safe_atod) { double d; - char *e; ASSERT_ERROR(safe_atod("junk", &d), EINVAL); @@ -663,39 +663,18 @@ TEST(safe_atod) { assert_se(fabs(d - 0.2244) < 0.000001); ASSERT_ERROR(safe_atod("0,5", &d), EINVAL); - - errno = 0; - strtod("0,5", &e); - assert_se(*e == ','); - ASSERT_ERROR(safe_atod("", &d), EINVAL); /* Check if this really is locale independent */ - if (setlocale(LC_NUMERIC, "de_DE.utf8")) { - - ASSERT_OK_ZERO(safe_atod("0.2244", &d)); - assert_se(fabs(d - 0.2244) < 0.000001); - - ASSERT_ERROR(safe_atod("0,5", &d), EINVAL); - - errno = 0; - assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001); - - ASSERT_ERROR(safe_atod("", &d), EINVAL); - } - - /* And check again, reset */ - ASSERT_NOT_NULL(setlocale(LC_NUMERIC, "C")); + _cleanup_(freelocalep) locale_t loc = + newlocale(LC_NUMERIC_MASK, "de_DE.utf8", (locale_t) 0); + if (!loc) + return (void) log_tests_skipped_errno(errno, "locale de_DE.utf8 not found"); ASSERT_OK_ZERO(safe_atod("0.2244", &d)); assert_se(fabs(d - 0.2244) < 0.000001); ASSERT_ERROR(safe_atod("0,5", &d), EINVAL); - - errno = 0; - strtod("0,5", &e); - assert_se(*e == ','); - ASSERT_ERROR(safe_atod("", &d), EINVAL); } From abd0eb20e430eb9e7f1e422eb7500748540194c7 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sun, 7 Sep 2025 04:50:04 +0900 Subject: [PATCH 3/9] test-seccomp-util: several cleanups - use safe_fork() with FORK_WAIT - introduce CHECK_SECCOMP() macro about common checks, - ignore ENOSYS from sched_setscheduler(). --- src/test/test-seccomp.c | 311 ++++++++++------------------------------ 1 file changed, 76 insertions(+), 235 deletions(-) diff --git a/src/test/test-seccomp.c b/src/test/test-seccomp.c index a1230ec27c..13c65a93cd 100644 --- a/src/test/test-seccomp.c +++ b/src/test/test-seccomp.c @@ -42,9 +42,13 @@ # define SECCOMP_RESTRICT_ADDRESS_FAMILIES_BROKEN 0 #endif -static bool have_seccomp_privs(void) { - return geteuid() == 0 && have_effective_cap(CAP_SYS_ADMIN) > 0; /* If we are root but CAP_SYS_ADMIN we can't do caps (unless we also do NNP) */ -} +#define CHECK_SECCOMP(refuse_container) \ + if (!is_seccomp_available()) \ + return (void) log_tests_skipped("Seccomp not available"); \ + if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) \ + return (void) log_tests_skipped("Not privileged"); \ + if (refuse_container && detect_container() > 0) \ + return (void) log_tests_skipped("Running in container"); TEST(parse_syscall_and_errno) { _cleanup_free_ char *n = NULL; @@ -166,17 +170,11 @@ TEST(syscall_filter_set_find) { } TEST(filter_sets) { - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + int r; + + CHECK_SECCOMP(/* skip_container = */ false); for (unsigned i = 0; i < _SYSCALL_FILTER_SET_MAX; i++) { - pid_t pid; #if HAVE_VALGRIND_VALGRIND_H if (RUNNING_ON_VALGRIND && IN_SET(i, SYSCALL_FILTER_SET_DEFAULT, SYSCALL_FILTER_SET_BASIC_IO, SYSCALL_FILTER_SET_SIGNAL)) { @@ -195,11 +193,9 @@ TEST(filter_sets) { log_info("Testing %s", syscall_filter_sets[i].name); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { /* Child? */ - int fd, r; + ASSERT_OK(r = safe_fork("(filter_sets)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { + int fd; /* If we look at the default set (or one that includes it), allow-list instead of deny-list */ if (IN_SET(i, SYSCALL_FILTER_SET_DEFAULT, @@ -222,8 +218,6 @@ TEST(filter_sets) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check(syscall_filter_sets[i].name, pid, WAIT_LOG) == EXIT_SUCCESS); } } @@ -263,12 +257,10 @@ TEST(filter_sets_ordered) { TEST(restrict_namespace) { char *s = NULL; unsigned long ul; - pid_t pid; + int r; - if (!have_namespaces()) { - log_notice("Testing without namespaces, skipping %s", __func__); - return; - } + if (!have_namespaces()) + return (void) log_tests_skipped("Testing without namespaces"); assert_se(namespace_flags_to_string(0, &s) == 0 && isempty(s)); s = mfree(s); @@ -297,19 +289,10 @@ TEST(restrict_namespace) { assert_se(namespace_flags_from_string(s, &ul) == 0 && ul == NAMESPACE_FLAGS_ALL); s = mfree(s); - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping remaining tests in %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping remaining tests in %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(restrict-namespace)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { assert_se(seccomp_restrict_namespaces(CLONE_NEWNS|CLONE_NEWNET) >= 0); @@ -337,7 +320,7 @@ TEST(restrict_namespace) { assert_se(setns(0, 0) == -1); assert_se(errno == EPERM); - pid = raw_clone(CLONE_NEWNS); + pid_t pid = raw_clone(CLONE_NEWNS); assert_se(pid >= 0); if (pid == 0) _exit(EXIT_SUCCESS); @@ -357,37 +340,21 @@ TEST(restrict_namespace) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("nsseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(protect_sysctl) { - pid_t pid; - _cleanup_free_ char *seccomp = NULL; - - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + int r; /* in containers _sysctl() is likely missing anyway */ - if (detect_container() > 0) { - log_notice("Testing in container, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ true); + _cleanup_free_ char *seccomp = NULL; assert_se(get_proc_field("/proc/self/status", "Seccomp", &seccomp) == 0); if (!streq(seccomp, "0")) log_warning("Warning: seccomp filter detected, results may be unreliable for %s", __func__); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(protect-sysctl)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { #if defined __NR__sysctl && __NR__sysctl >= 0 assert_se(syscall(__NR__sysctl, NULL) < 0); assert_se(IN_SET(errno, EFAULT, ENOSYS)); @@ -409,32 +376,16 @@ TEST(protect_sysctl) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("sysctlseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(protect_syslog) { - pid_t pid; - - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + int r; /* in containers syslog() is likely missing anyway */ - if (detect_container() > 0) { - log_notice("Testing in container, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ true); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(protect-syslog)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { #if defined __NR_syslog && __NR_syslog >= 0 assert_se(syscall(__NR_syslog, -1, NULL, 0) < 0); assert_se(errno == EINVAL); @@ -449,26 +400,15 @@ TEST(protect_syslog) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("syslogseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(restrict_address_families) { - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(restrict-address-families)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { int fd; Set *s; @@ -536,34 +476,23 @@ TEST(restrict_address_families) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("socketseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(restrict_realtime) { - pid_t pid; - - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + int r; /* in containers RT privs are likely missing anyway */ - if (detect_container() > 0) { - log_notice("Testing in container, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ true); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(restrict-realtime)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { /* On some CI environments, the restriction may be already enabled. */ if (sched_setscheduler(0, SCHED_FIFO, &(struct sched_param) { .sched_priority = 1 }) < 0) { + if (errno == ENOSYS) { + log_tests_skipped("sched_setscheduler() is not available or already filtered"); + _exit(EXIT_SUCCESS); + } + log_full_errno(errno == EPERM ? LOG_DEBUG : LOG_WARNING, errno, "Failed to set scheduler parameter for FIFO: %m"); assert(errno == EPERM); @@ -591,21 +520,13 @@ TEST(restrict_realtime) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("realtimeseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(memory_deny_write_execute_mmap) { - pid_t pid; + int r; + + CHECK_SECCOMP(/* skip_container = */ false); - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } #if HAVE_VALGRIND_VALGRIND_H if (RUNNING_ON_VALGRIND) { log_notice("Running on valgrind, skipping %s", __func__); @@ -617,10 +538,8 @@ TEST(memory_deny_write_execute_mmap) { return; #endif - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(memory_deny_write_execute_mmap)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { void *p; p = mmap(NULL, page_size(), PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); @@ -649,14 +568,11 @@ TEST(memory_deny_write_execute_mmap) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("memoryseccomp-mmap", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(memory_deny_write_execute_shmat) { - int shmid; - pid_t pid; uint32_t arch; + int r, shmid; SECCOMP_FOREACH_LOCAL_ARCH(arch) { log_debug("arch %s: SCMP_SYS(mmap) = %d", seccomp_arch_to_string(arch), SCMP_SYS(mmap)); @@ -666,14 +582,8 @@ TEST(memory_deny_write_execute_shmat) { log_debug("arch %s: SCMP_SYS(shmdt) = %d", seccomp_arch_to_string(arch), SCMP_SYS(shmdt)); } - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs() || have_effective_cap(CAP_IPC_OWNER) <= 0) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); + #if HAVE_VALGRIND_VALGRIND_H if (RUNNING_ON_VALGRIND) { log_notice("Running on valgrind, skipping %s", __func__); @@ -688,10 +598,8 @@ TEST(memory_deny_write_execute_shmat) { shmid = shmget(IPC_PRIVATE, page_size(), 0); assert_se(shmid >= 0); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(memory-deny-write-execute)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { void *p; p = shmat(shmid, NULL, 0); @@ -722,26 +630,15 @@ TEST(memory_deny_write_execute_shmat) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("memoryseccomp-shmat", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(restrict_archs) { - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(restrict-archs)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { _cleanup_set_free_ Set *s = NULL; assert_se(access("/", F_OK) >= 0); @@ -760,26 +657,15 @@ TEST(restrict_archs) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("archseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(load_syscall_filter_set_raw) { - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(load-filter)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { _cleanup_hashmap_free_ Hashmap *s = NULL; assert_se(access("/", F_OK) >= 0); @@ -873,26 +759,15 @@ TEST(load_syscall_filter_set_raw) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("syscallrawseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(native_syscalls_filtered) { - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(native-syscalls)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { _cleanup_set_free_ Set *arch_s = NULL; _cleanup_hashmap_free_ Hashmap *s = NULL; @@ -931,32 +806,21 @@ TEST(native_syscalls_filtered) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("nativeseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(lock_personality) { unsigned long current_opinionated; - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); assert_se(opinionated_personality(¤t_opinionated) >= 0); log_info("current personality=0x%lX", (unsigned long) safe_personality(PERSONALITY_INVALID)); log_info("current opinionated personality=0x%lX", current_opinionated); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(lock-personality)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { unsigned long current; assert_se(seccomp_lock_personality(current_opinionated) >= 0); @@ -988,8 +852,6 @@ TEST(lock_personality) { assert_se((current & OPINIONATED_PERSONALITY_MASK) == current_opinionated); _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("lockpersonalityseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } static int real_open(const char *path, int flags, mode_t mode) { @@ -1023,21 +885,12 @@ static int try_fchmodat2(int dirfd, const char *path, mode_t mode, int flags) { } TEST(restrict_suid_sgid) { - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(suid-sgid)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { char path[] = "/tmp/suidsgidXXXXXX", dir[] = "/tmp/suidsgiddirXXXXXX"; int fd = -EBADF, k = -EBADF; const char *z; @@ -1224,8 +1077,6 @@ TEST(restrict_suid_sgid) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("suidsgidseccomp", pid, WAIT_LOG) == EXIT_SUCCESS); } static void test_seccomp_suppress_sync_child(void) { @@ -1258,25 +1109,15 @@ static void test_seccomp_suppress_sync_child(void) { } TEST(seccomp_suppress_sync) { - pid_t pid; + int r; - if (!is_seccomp_available()) { - log_notice("Seccomp not available, skipping %s", __func__); - return; - } - if (!have_seccomp_privs()) { - log_notice("Not privileged, skipping %s", __func__); - return; - } + CHECK_SECCOMP(/* skip_container = */ false); - ASSERT_OK_ERRNO(pid = fork()); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(suppress-sync)", FORK_LOG | FORK_WAIT, NULL)); + if (r == 0) { test_seccomp_suppress_sync_child(); _exit(EXIT_SUCCESS); } - - ASSERT_EQ(wait_for_terminate_and_check("seccomp_suppress_sync", pid, WAIT_LOG), EXIT_SUCCESS); } DEFINE_TEST_MAIN(LOG_DEBUG); From 87a87b02b92d6cabbb86fe2c5829d3824d4c1265 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sun, 7 Sep 2025 13:55:45 +0900 Subject: [PATCH 4/9] test-udev: pass test_env to make the test use systemd-detect-virt in build directory Otherwise, the test fails if the running host does not have systemd-detect-virt. --- test/meson.build | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/meson.build b/test/meson.build index 4cdd2f4303..505a14aa81 100644 --- a/test/meson.build +++ b/test/meson.build @@ -192,7 +192,7 @@ if want_tests != 'false' test('test-udev', test_udev_py, args : ['-v'], - env : ['UDEV_RULE_RUNNER=' + exe.full_path()], + env : test_env + { 'UDEV_RULE_RUNNER' : exe.full_path() }, depends : exe, timeout : 180, suite : 'udev') From aa5aac9e40b17a0571d0bf92d93e3b2ece98777a Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sun, 7 Sep 2025 13:32:51 +0900 Subject: [PATCH 5/9] test-sysusers: show diffs in stderr Otherwise, the diffs are eaten by 'meson test' command unless --verbose option is specified. --- test/test-sysusers.sh.in | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/test-sysusers.sh.in b/test/test-sysusers.sh.in index fdeae2c898..3218923590 100755 --- a/test/test-sysusers.sh.in +++ b/test/test-sysusers.sh.in @@ -35,12 +35,12 @@ preprocess() { } compare() { - if ! diff -u "$TESTDIR/etc/passwd" <(preprocess "$1.expected-passwd" "$3"); then + if ! diff -u "$TESTDIR/etc/passwd" <(preprocess "$1.expected-passwd" "$3") >&2; then echo >&2 "**** Unexpected output for $f $2" exit 1 fi - if ! diff -u "$TESTDIR/etc/group" <(preprocess "$1.expected-group" "$3"); then + if ! diff -u "$TESTDIR/etc/group" <(preprocess "$1.expected-group" "$3") >&2; then echo >&2 "**** Unexpected output for $f $2" exit 1 fi @@ -167,7 +167,7 @@ for f in $(find "$SOURCE"/unhappy-*.input | sort -V); do prepare_testdir "${f%.input}" cp "$f" "$TESTDIR/usr/lib/sysusers.d/test.conf" SYSTEMD_LOG_LEVEL=info "$SYSUSERS" --root="$TESTDIR" 2>&1 | tail -n1 | sed -r 's/^[^:]+:[^:]+://' >"$TESTDIR/err" - if ! diff -u "$TESTDIR/err" "${f%.*}.expected-err"; then + if ! diff -u "$TESTDIR/err" "${f%.*}.expected-err" >&2; then echo >&2 "**** Unexpected error output for $f" cat >&2 "$TESTDIR/err" exit 1 From 2ff79a81a8dd5f3222d2be44f0d8c3b774b765d8 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sat, 6 Sep 2025 19:46:42 +0900 Subject: [PATCH 6/9] test-mount-util: several cleanups - use safe_fork() with common flags, - introduce macro for checking privilege. --- src/test/test-mount-util.c | 256 ++++++++++++++----------------------- 1 file changed, 94 insertions(+), 162 deletions(-) diff --git a/src/test/test-mount-util.c b/src/test/test-mount-util.c index 6894429b6a..a83de3f2b0 100644 --- a/src/test/test-mount-util.c +++ b/src/test/test-mount-util.c @@ -24,6 +24,20 @@ #include "tests.h" #include "tmpfile-util.h" +#define FORK_COMMON_FLAGS \ + (FORK_CLOSE_ALL_FDS | \ + FORK_RESET_SIGNALS | \ + FORK_DEATHSIG_SIGTERM | \ + FORK_LOG | \ + FORK_REOPEN_LOG | \ + FORK_WAIT | \ + FORK_NEW_MOUNTNS | \ + FORK_MOUNTNS_SLAVE) + +#define CHECK_PRIV \ + if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) \ + return (void) log_tests_skipped("Not privileged"); + TEST(mount_option_mangle) { char *opts = NULL; unsigned long f; @@ -132,11 +146,9 @@ TEST(mount_flags_to_string) { TEST(bind_remount_recursive) { _cleanup_(rm_rf_physical_and_freep) char *tmp = NULL; _cleanup_free_ char *subdir = NULL; + int r; - if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) { - (void) log_tests_skipped("not running privileged"); - return; - } + CHECK_PRIV; assert_se(mkdtemp_malloc("/tmp/XXXXXX", &tmp) >= 0); subdir = path_join(tmp, "subdir"); @@ -144,15 +156,9 @@ TEST(bind_remount_recursive) { assert_se(mkdir(subdir, 0755) >= 0); FOREACH_STRING(p, "/usr", "/sys", "/", tmp) { - pid_t pid; - - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { + ASSERT_OK(r = safe_fork("(bind-remount-recursive)", FORK_COMMON_FLAGS, NULL)); + if (r == 0) { /* child */ struct statvfs svfs; - /* child */ - assert_se(detach_mount_namespace() >= 0); /* Check that the subdir is writable (it must be because it's in /tmp) */ assert_se(statvfs(subdir, &svfs) >= 0); @@ -178,29 +184,18 @@ TEST(bind_remount_recursive) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("test-remount-rec", pid, WAIT_LOG) == EXIT_SUCCESS); } } TEST(bind_remount_one) { - pid_t pid; + int r; - if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) { - (void) log_tests_skipped("not running privileged"); - return; - } - - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { - /* child */ + CHECK_PRIV; + ASSERT_OK(r = safe_fork("(remount-one-with-mountinfo)", FORK_COMMON_FLAGS, NULL)); + if (r == 0) { /* child */ _cleanup_fclose_ FILE *proc_self_mountinfo = NULL; - assert_se(detach_mount_namespace() >= 0); - assert_se(fopen_unlocked("/proc/self/mountinfo", "re", &proc_self_mountinfo) >= 0); assert_se(bind_remount_one_with_mountinfo("/run", MS_RDONLY, MS_RDONLY, proc_self_mountinfo) >= 0); @@ -212,16 +207,8 @@ TEST(bind_remount_one) { _exit(EXIT_SUCCESS); } - assert_se(wait_for_terminate_and_check("test-remount-one-with-mountinfo", pid, WAIT_LOG) == EXIT_SUCCESS); - - pid = fork(); - assert_se(pid >= 0); - - if (pid == 0) { - /* child */ - - assert_se(detach_mount_namespace() >= 0); - + ASSERT_OK(r = safe_fork("(remount-one)", FORK_COMMON_FLAGS, NULL)); + if (r == 0) { /* child */ assert_se(bind_remount_one("/run", MS_RDONLY, MS_RDONLY) >= 0); assert_se(bind_remount_one("/run", MS_NOEXEC, MS_RDONLY|MS_NOEXEC) >= 0); assert_se(bind_remount_one("/proc/idontexist", MS_RDONLY, MS_RDONLY) == -ENOENT); @@ -230,8 +217,6 @@ TEST(bind_remount_one) { _exit(EXIT_SUCCESS); } - - assert_se(wait_for_terminate_and_check("test-remount-one", pid, WAIT_LOG) == EXIT_SUCCESS); } TEST(make_mount_point_inode) { @@ -283,10 +268,7 @@ TEST(make_mount_switch_root) { _cleanup_free_ char *s = NULL; int r; - if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) { - (void) log_tests_skipped("not running privileged"); - return; - } + CHECK_PRIV; assert_se(mkdtemp_malloc(NULL, &t) >= 0); @@ -305,18 +287,7 @@ TEST(make_mount_switch_root) { }; FOREACH_ELEMENT(i, table) { - r = safe_fork("(switch-root)", - FORK_RESET_SIGNALS | - FORK_CLOSE_ALL_FDS | - FORK_DEATHSIG_SIGTERM | - FORK_WAIT | - FORK_REOPEN_LOG | - FORK_LOG | - FORK_NEW_MOUNTNS | - FORK_MOUNTNS_SLAVE, - NULL); - assert_se(r >= 0); - + ASSERT_OK(r = safe_fork("(switch-root)", FORK_COMMON_FLAGS, NULL)); if (r == 0) { assert_se(make_mount_point(i->path) >= 0); assert_se(mount_switch_root_full(i->path, /* mount_propagation_flag= */ 0, i->force_ms_move) >= 0); @@ -357,23 +328,10 @@ TEST(umount_recursive) { int r; + CHECK_PRIV; + FOREACH_ELEMENT(t, test_table) { - - r = safe_fork("(umount-rec)", - FORK_RESET_SIGNALS | - FORK_CLOSE_ALL_FDS | - FORK_DEATHSIG_SIGTERM | - FORK_WAIT | - FORK_REOPEN_LOG | - FORK_LOG | - FORK_NEW_MOUNTNS | - FORK_MOUNTNS_SLAVE, - NULL); - - if (ERRNO_IS_NEG_PRIVILEGE(r)) - return (void) log_notice("Skipping umount_recursive() test, lacking privileges"); - - assert_se(r >= 0); + ASSERT_OK(r = safe_fork("(umount-rec)", FORK_COMMON_FLAGS, NULL)); if (r == 0) { /* child */ _cleanup_(mnt_free_tablep) struct libmnt_table *table = NULL; _cleanup_(mnt_free_iterp) struct libmnt_iter *iter = NULL; @@ -422,10 +380,7 @@ TEST(fd_make_mount_point) { _cleanup_free_ char *s = NULL; int r; - if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) { - (void) log_tests_skipped("not running privileged"); - return; - } + CHECK_PRIV; assert_se(mkdtemp_malloc(NULL, &t) >= 0); @@ -433,18 +388,7 @@ TEST(fd_make_mount_point) { assert_se(s); assert_se(mkdir(s, 0700) >= 0); - r = safe_fork("(make_mount-point)", - FORK_RESET_SIGNALS | - FORK_CLOSE_ALL_FDS | - FORK_DEATHSIG_SIGTERM | - FORK_WAIT | - FORK_REOPEN_LOG | - FORK_LOG | - FORK_NEW_MOUNTNS | - FORK_MOUNTNS_SLAVE, - NULL); - assert_se(r >= 0); - + ASSERT_OK(r = safe_fork("(make-mount-point)", FORK_COMMON_FLAGS, NULL)); if (r == 0) { _cleanup_close_ int fd = -EBADF, fd2 = -EBADF; @@ -468,72 +412,78 @@ TEST(fd_make_mount_point) { TEST(bind_mount_submounts) { _cleanup_(rmdir_and_freep) char *a = NULL, *b = NULL; - _cleanup_free_ char *x = NULL; int r; + CHECK_PRIV; + assert_se(mkdtemp_malloc(NULL, &a) >= 0); - r = mount_nofollow_verbose(LOG_INFO, "tmpfs", a, "tmpfs", 0, NULL); - if (ERRNO_IS_NEG_PRIVILEGE(r)) - return (void) log_tests_skipped("Skipping bind_mount_submounts() test, lacking privileges"); - - assert_se(r >= 0); - - assert_se(x = path_join(a, "foo")); - assert_se(touch(x) >= 0); - free(x); - - assert_se(x = path_join(a, "x")); - assert_se(mkdir(x, 0755) >= 0); - assert_se(mount_nofollow_verbose(LOG_INFO, "tmpfs", x, "tmpfs", 0, NULL) >= 0); - free(x); - - assert_se(x = path_join(a, "x/xx")); - assert_se(touch(x) >= 0); - free(x); - - assert_se(x = path_join(a, "y")); - assert_se(mkdir(x, 0755) >= 0); - assert_se(mount_nofollow_verbose(LOG_INFO, "tmpfs", x, "tmpfs", 0, NULL) >= 0); - free(x); - - assert_se(x = path_join(a, "y/yy")); - assert_se(touch(x) >= 0); - free(x); - assert_se(mkdtemp_malloc(NULL, &b) >= 0); - assert_se(mount_nofollow_verbose(LOG_INFO, "tmpfs", b, "tmpfs", 0, NULL) >= 0); - assert_se(x = path_join(b, "x")); - assert_se(mkdir(x, 0755) >= 0); - free(x); + ASSERT_OK(r = safe_fork("(bind-mount-submounts)", FORK_COMMON_FLAGS, NULL)); + if (r == 0) { + char *x; - assert_se(x = path_join(b, "y")); - assert_se(mkdir(x, 0755) >= 0); - free(x); + ASSERT_OK(mount_nofollow_verbose(LOG_INFO, "tmpfs", a, "tmpfs", 0, NULL)); - assert_se(bind_mount_submounts(a, b) >= 0); + assert_se(x = path_join(a, "foo")); + assert_se(touch(x) >= 0); + free(x); - assert_se(x = path_join(b, "foo")); - assert_se(access(x, F_OK) < 0 && errno == ENOENT); - free(x); + assert_se(x = path_join(a, "x")); + assert_se(mkdir(x, 0755) >= 0); + assert_se(mount_nofollow_verbose(LOG_INFO, "tmpfs", x, "tmpfs", 0, NULL) >= 0); + free(x); - assert_se(x = path_join(b, "x/xx")); - assert_se(access(x, F_OK) >= 0); - free(x); + assert_se(x = path_join(a, "x/xx")); + assert_se(touch(x) >= 0); + free(x); - assert_se(x = path_join(b, "y/yy")); - assert_se(access(x, F_OK) >= 0); - free(x); + assert_se(x = path_join(a, "y")); + assert_se(mkdir(x, 0755) >= 0); + assert_se(mount_nofollow_verbose(LOG_INFO, "tmpfs", x, "tmpfs", 0, NULL) >= 0); + free(x); - assert_se(x = path_join(b, "x")); - assert_se(path_is_mount_point(x) > 0); - free(x); + assert_se(x = path_join(a, "y/yy")); + assert_se(touch(x) >= 0); + free(x); - assert_se(x = path_join(b, "y")); - assert_se(path_is_mount_point(x) > 0); + assert_se(mount_nofollow_verbose(LOG_INFO, "tmpfs", b, "tmpfs", 0, NULL) >= 0); - assert_se(umount_recursive(a, 0) >= 0); - assert_se(umount_recursive(b, 0) >= 0); + assert_se(x = path_join(b, "x")); + assert_se(mkdir(x, 0755) >= 0); + free(x); + + assert_se(x = path_join(b, "y")); + assert_se(mkdir(x, 0755) >= 0); + free(x); + + assert_se(bind_mount_submounts(a, b) >= 0); + + assert_se(x = path_join(b, "foo")); + assert_se(access(x, F_OK) < 0 && errno == ENOENT); + free(x); + + assert_se(x = path_join(b, "x/xx")); + assert_se(access(x, F_OK) >= 0); + free(x); + + assert_se(x = path_join(b, "y/yy")); + assert_se(access(x, F_OK) >= 0); + free(x); + + assert_se(x = path_join(b, "x")); + assert_se(path_is_mount_point(x) > 0); + free(x); + + assert_se(x = path_join(b, "y")); + assert_se(path_is_mount_point(x) > 0); + free(x); + + assert_se(umount_recursive(a, 0) >= 0); + assert_se(umount_recursive(b, 0) >= 0); + + _exit(EXIT_SUCCESS); + } } TEST(path_is_network_fs_harder) { @@ -553,26 +503,12 @@ TEST(path_is_network_fs_harder) { log_debug("path_is_network_fs_harder_at(root, %s) → %i: %s", q, r, r < 0 ? STRERROR(r) : yes_no(r)); } - if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) { - (void) log_tests_skipped("not running privileged"); - return; - } + CHECK_PRIV; _cleanup_(rm_rf_physical_and_freep) char *t = NULL; assert_se(mkdtemp_malloc("/tmp/test-mount-util.path_is_network_fs_harder.XXXXXXX", &t) >= 0); - r = safe_fork("(make_mount-point)", - FORK_RESET_SIGNALS | - FORK_CLOSE_ALL_FDS | - FORK_DEATHSIG_SIGTERM | - FORK_WAIT | - FORK_REOPEN_LOG | - FORK_LOG | - FORK_NEW_MOUNTNS | - FORK_MOUNTNS_SLAVE, - NULL); - ASSERT_OK(r); - + ASSERT_OK(r = safe_fork("(path-is-network-fs-harder)", FORK_COMMON_FLAGS, NULL)); if (r == 0) { ASSERT_OK(mount_nofollow_verbose(LOG_INFO, "tmpfs", t, "tmpfs", 0, NULL)); ASSERT_OK_ZERO(path_is_network_fs_harder(t)); @@ -587,7 +523,7 @@ TEST(path_is_network_fs_harder) { } TEST(umountat) { - int r; + CHECK_PRIV; _cleanup_(rm_rf_physical_and_freep) char *p = NULL; _cleanup_close_ int dfd = mkdtemp_open(NULL, O_CLOEXEC, &p); @@ -597,11 +533,7 @@ TEST(umountat) { _cleanup_free_ char *q = ASSERT_PTR(path_join(p, "foo")); - r = mount_nofollow_verbose(LOG_ERR, "tmpfs", q, "tmpfs", 0, NULL); - if (ERRNO_IS_NEG_PRIVILEGE(r)) - return (void) log_tests_skipped("not running privileged"); - - ASSERT_OK(r); + ASSERT_OK(mount_nofollow_verbose(LOG_ERR, "tmpfs", q, "tmpfs", 0, NULL)); ASSERT_OK(umountat_detach_verbose(LOG_ERR, dfd, "foo")); ASSERT_ERROR(umountat_detach_verbose(LOG_ERR, dfd, "foo"), EINVAL); } From 6a616e62ad43fb52eacf083508253aeb9f57da5d Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Tue, 9 Sep 2025 15:15:02 +0900 Subject: [PATCH 7/9] test: skip several test cases when running in chroot When we are running in chroot, safe_fork() with FORK_MOUNTNS_SLAVE fails with the following eror: ``` Failed to set mount propagation to MS_SLAVE for all mounts: Invalid argument ``` Let's skip the test cases when we are running in chroot. --- src/libsystemd/sd-device/test-sd-device.c | 8 ++++++-- src/test/test-execute.c | 3 +++ src/test/test-mount-util.c | 5 ++++- src/test/test-mountpoint-util.c | 7 +++++++ 4 files changed, 20 insertions(+), 3 deletions(-) diff --git a/src/libsystemd/sd-device/test-sd-device.c b/src/libsystemd/sd-device/test-sd-device.c index e1ee9e433f..dc4a32e8a1 100644 --- a/src/libsystemd/sd-device/test-sd-device.c +++ b/src/libsystemd/sd-device/test-sd-device.c @@ -5,6 +5,7 @@ #include "sd-event.h" +#include "capability-util.h" #include "device-internal.h" #include "device-private.h" #include "device-util.h" @@ -25,14 +26,17 @@ #include "tests.h" #include "tmpfile-util.h" #include "udev-util.h" +#include "virt.h" TEST(mdio_bus) { int r; /* For issue #37711 */ - if (getuid() != 0) - return (void) log_tests_skipped("not running as root"); + if (getuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) + return (void) log_tests_skipped("Not privileged"); + if (running_in_chroot() > 0) + return (void) log_tests_skipped("Running in chroot"); ASSERT_OK(r = safe_fork("(mdio_bus)", FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|FORK_REOPEN_LOG|FORK_LOG|FORK_WAIT|FORK_NEW_MOUNTNS|FORK_MOUNTNS_SLAVE, NULL)); if (r == 0) { diff --git a/src/test/test-execute.c b/src/test/test-execute.c index 4dad93cfb4..916ade7960 100644 --- a/src/test/test-execute.c +++ b/src/test/test-execute.c @@ -1613,6 +1613,9 @@ static int intro(void) { if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) return log_tests_skipped("not privileged"); + if (running_in_chroot() > 0) + return log_tests_skipped("running in chroot"); + if (enter_cgroup_subroot(NULL) == -ENOMEDIUM) return log_tests_skipped("cgroupfs not available"); diff --git a/src/test/test-mount-util.c b/src/test/test-mount-util.c index a83de3f2b0..57d9a050a5 100644 --- a/src/test/test-mount-util.c +++ b/src/test/test-mount-util.c @@ -23,6 +23,7 @@ #include "strv.h" #include "tests.h" #include "tmpfile-util.h" +#include "virt.h" #define FORK_COMMON_FLAGS \ (FORK_CLOSE_ALL_FDS | \ @@ -36,7 +37,9 @@ #define CHECK_PRIV \ if (geteuid() != 0 || have_effective_cap(CAP_SYS_ADMIN) <= 0) \ - return (void) log_tests_skipped("Not privileged"); + return (void) log_tests_skipped("Not privileged"); \ + if (running_in_chroot() > 0) \ + return (void) log_tests_skipped("running in chroot"); TEST(mount_option_mangle) { char *opts = NULL; diff --git a/src/test/test-mountpoint-util.c b/src/test/test-mountpoint-util.c index ceb59ce455..1da10e9ccc 100644 --- a/src/test/test-mountpoint-util.c +++ b/src/test/test-mountpoint-util.c @@ -18,6 +18,7 @@ #include "string-util.h" #include "tests.h" #include "tmpfile-util.h" +#include "virt.h" static void test_mount_propagation_flag_one(const char *name, int ret, unsigned long expected) { unsigned long flags; @@ -455,6 +456,12 @@ static int intro(void) { /* let's move into our own mount namespace with all propagation from the host turned off, so * that /proc/self/mountinfo is static and constant for the whole time our test runs. */ + if (running_in_chroot() > 0) { + /* We cannot remount file system with MS_PRIVATE when running in chroot. */ + log_notice("Running in chroot, proceeding in originating mount namespace."); + return EXIT_SUCCESS; + } + if (unshare(CLONE_NEWNS) < 0) { if (!ERRNO_IS_PRIVILEGE(errno)) return log_error_errno(errno, "Failed to detach mount namespace: %m"); From 194e05642f74993d7be80724f2560f1a698931ec Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sat, 30 Aug 2025 08:08:04 +0900 Subject: [PATCH 8/9] test: reenable test for cg_get_keyed_attribute() The test case was mistakenly disabled by a412a1b92ab234a57c646f6779471772b2c355ec. Co-authored-by: Natalie Vock --- src/test/test-cgroup-util.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/test-cgroup-util.c b/src/test/test-cgroup-util.c index 7c8cfaaa11..552e9a5d28 100644 --- a/src/test/test-cgroup-util.c +++ b/src/test/test-cgroup-util.c @@ -432,7 +432,7 @@ TEST(cg_get_keyed_attribute) { int r; r = cg_get_keyed_attribute("cpu", "/init.scope", "no_such_file", STRV_MAKE("no_such_attr"), &val); - if (IN_SET(r, -ENOMEDIUM, -ENOENT) || ERRNO_IS_PRIVILEGE(r)) { + if (r == -ENOMEDIUM || ERRNO_IS_PRIVILEGE(r)) { log_info_errno(r, "Skipping most of %s, /sys/fs/cgroup not accessible: %m", __func__); return; } From b83f9acfef0ccfdf7c372ec4f267a984e1626b3e Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Sat, 30 Aug 2025 21:59:44 +0900 Subject: [PATCH 9/9] test: rearrange test-cgroup and test-cgroup-util --- src/test/meson.build | 2 +- .../{test-cgroup.c => test-cgroup-setup.c} | 73 ------------------- src/test/test-cgroup-util.c | 72 ++++++++++++++++++ 3 files changed, 73 insertions(+), 74 deletions(-) rename src/test/{test-cgroup.c => test-cgroup-setup.c} (60%) diff --git a/src/test/meson.build b/src/test/meson.build index da04b82d47..2a4d77a8ef 100644 --- a/src/test/meson.build +++ b/src/test/meson.build @@ -68,8 +68,8 @@ simple_tests += files( 'test-bus-unit-util.c', 'test-bus-util.c', 'test-calendarspec.c', + 'test-cgroup-setup.c', 'test-cgroup-util.c', - 'test-cgroup.c', 'test-chase.c', 'test-chid.c', 'test-clock.c', diff --git a/src/test/test-cgroup.c b/src/test/test-cgroup-setup.c similarity index 60% rename from src/test/test-cgroup.c rename to src/test/test-cgroup-setup.c index a14043442f..ce20c956d2 100644 --- a/src/test/test-cgroup.c +++ b/src/test/test-cgroup-setup.c @@ -3,43 +3,11 @@ #include "cgroup-setup.h" #include "cgroup-util.h" #include "errno-util.h" -#include "fd-util.h" #include "path-util.h" #include "process-util.h" -#include "stat-util.h" #include "string-util.h" #include "tests.h" -TEST(cg_split_spec) { - char *c, *p; - - ASSERT_OK_ZERO(cg_split_spec("foobar:/", &c, &p)); - ASSERT_STREQ(c, "foobar"); - ASSERT_STREQ(p, "/"); - c = mfree(c); - p = mfree(p); - - ASSERT_OK_ZERO(cg_split_spec("foobar:", &c, &p)); - c = mfree(c); - p = mfree(p); - - ASSERT_FAIL(cg_split_spec("foobar:asdfd", &c, &p)); - ASSERT_FAIL(cg_split_spec(":///", &c, &p)); - ASSERT_FAIL(cg_split_spec(":", &c, &p)); - ASSERT_FAIL(cg_split_spec("", &c, &p)); - ASSERT_FAIL(cg_split_spec("fo/obar:/", &c, &p)); - - ASSERT_OK(cg_split_spec("/", &c, &p)); - ASSERT_NULL(c); - ASSERT_STREQ(p, "/"); - p = mfree(p); - - ASSERT_OK(cg_split_spec("foo", &c, &p)); - ASSERT_STREQ(c, "foo"); - ASSERT_NULL(p); - c = mfree(c); -} - TEST(cg_create) { int r; @@ -118,45 +86,4 @@ TEST(cg_create) { ASSERT_OK(cg_trim(test_b, true)); } -TEST(id) { - _cleanup_free_ char *p = NULL, *p2 = NULL; - _cleanup_close_ int fd = -EBADF, fd2 = -EBADF; - uint64_t id, id2; - int r; - - r = cg_all_unified(); - if (IN_SET(r, -ENOMEDIUM, -ENOENT)) - return (void) log_tests_skipped("cgroupfs is not mounted"); - if (r == 0) - return (void) log_tests_skipped("skipping cgroupid test, not running in unified mode"); - ASSERT_OK_POSITIVE(r); - - fd = cg_path_open(SYSTEMD_CGROUP_CONTROLLER, "/"); - ASSERT_OK(fd); - - ASSERT_OK(fd_get_path(fd, &p)); - ASSERT_TRUE(path_equal(p, "/sys/fs/cgroup")); - - ASSERT_OK(cg_fd_get_cgroupid(fd, &id)); - - fd2 = cg_cgroupid_open(fd, id); - - if (ERRNO_IS_NEG_PRIVILEGE(fd2)) - log_notice("Skipping open-by-cgroup-id test because lacking privs."); - else if (ERRNO_IS_NEG_NOT_SUPPORTED(fd2)) - log_notice("Skipping open-by-cgroup-id test because syscall is missing or blocked."); - else { - ASSERT_OK(fd2); - - ASSERT_OK(fd_get_path(fd2, &p2)); - ASSERT_TRUE(path_equal(p2, "/sys/fs/cgroup")); - - ASSERT_OK(cg_fd_get_cgroupid(fd2, &id2)); - - ASSERT_EQ(id, id2); - - ASSERT_OK_EQ(inode_same_at(fd, NULL, fd2, NULL, AT_EMPTY_PATH), true); - } -} - DEFINE_TEST_MAIN(LOG_DEBUG); diff --git a/src/test/test-cgroup-util.c b/src/test/test-cgroup-util.c index 552e9a5d28..fea0733173 100644 --- a/src/test/test-cgroup-util.c +++ b/src/test/test-cgroup-util.c @@ -11,6 +11,7 @@ #include "pidref.h" #include "process-util.h" #include "special.h" +#include "stat-util.h" #include "string-util.h" #include "tests.h" @@ -334,6 +335,36 @@ TEST(controller_is_valid) { assert_se(!cg_controller_is_valid("tatü")); } +TEST(cg_split_spec) { + char *c, *p; + + ASSERT_OK_ZERO(cg_split_spec("foobar:/", &c, &p)); + ASSERT_STREQ(c, "foobar"); + ASSERT_STREQ(p, "/"); + c = mfree(c); + p = mfree(p); + + ASSERT_OK_ZERO(cg_split_spec("foobar:", &c, &p)); + c = mfree(c); + p = mfree(p); + + ASSERT_FAIL(cg_split_spec("foobar:asdfd", &c, &p)); + ASSERT_FAIL(cg_split_spec(":///", &c, &p)); + ASSERT_FAIL(cg_split_spec(":", &c, &p)); + ASSERT_FAIL(cg_split_spec("", &c, &p)); + ASSERT_FAIL(cg_split_spec("fo/obar:/", &c, &p)); + + ASSERT_OK(cg_split_spec("/", &c, &p)); + ASSERT_NULL(c); + ASSERT_STREQ(p, "/"); + p = mfree(p); + + ASSERT_OK(cg_split_spec("foo", &c, &p)); + ASSERT_STREQ(c, "foo"); + ASSERT_NULL(p); + c = mfree(c); +} + static void test_slice_to_path_one(const char *unit, const char *path, int error) { _cleanup_free_ char *ret = NULL; int r; @@ -473,4 +504,45 @@ TEST(bfq_weight_conversion) { assert_se(BFQ_WEIGHT(10000) == 1000); } +TEST(cgroupid) { + _cleanup_free_ char *p = NULL, *p2 = NULL; + _cleanup_close_ int fd = -EBADF, fd2 = -EBADF; + uint64_t id, id2; + int r; + + r = cg_all_unified(); + if (IN_SET(r, -ENOMEDIUM, -ENOENT)) + return (void) log_tests_skipped("cgroupfs is not mounted"); + if (r == 0) + return (void) log_tests_skipped("skipping cgroupid test, not running in unified mode"); + ASSERT_OK_POSITIVE(r); + + fd = cg_path_open(SYSTEMD_CGROUP_CONTROLLER, "/"); + ASSERT_OK(fd); + + ASSERT_OK(fd_get_path(fd, &p)); + ASSERT_TRUE(path_equal(p, "/sys/fs/cgroup")); + + ASSERT_OK(cg_fd_get_cgroupid(fd, &id)); + + fd2 = cg_cgroupid_open(fd, id); + + if (ERRNO_IS_NEG_PRIVILEGE(fd2)) + log_notice("Skipping open-by-cgroup-id test because lacking privs."); + else if (ERRNO_IS_NEG_NOT_SUPPORTED(fd2)) + log_notice("Skipping open-by-cgroup-id test because syscall is missing or blocked."); + else { + ASSERT_OK(fd2); + + ASSERT_OK(fd_get_path(fd2, &p2)); + ASSERT_TRUE(path_equal(p2, "/sys/fs/cgroup")); + + ASSERT_OK(cg_fd_get_cgroupid(fd2, &id2)); + + ASSERT_EQ(id, id2); + + ASSERT_OK_EQ(inode_same_at(fd, NULL, fd2, NULL, AT_EMPTY_PATH), true); + } +} + DEFINE_TEST_MAIN(LOG_DEBUG);