morgan/systemd
1
0
Fork 0
mirror of https://github.com/morgan9e/systemd synced 2026-04-14 16:37:19 +09:00
Code Issues Packages Projects Releases Wiki Activity

test-cpu-set-util: use ASSERT_XYZ() macros

Browse Source
This commit is contained in:
Yu Watanabe
2025-06-18 03:54:43 +09:00
committed by Luca Boccassi
parent 64fcb07199
commit 079a135eee
1 changed files with 165 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
src/test/test-cpu-set-util.c
View File

@@ -4,343 +4,243 @@
#include "cpu-set-util.h"
#include "tests.h"
#define ASSERT_CPUSET_EMPTY(c) \
ASSERT_NULL(c.set); \
ASSERT_EQ(c.allocated, 0u)
#define ASSERT_CPUSET_ALLOCATED(c) \
ASSERT_GE(c.allocated, DIV_ROUND_UP(sizeof(__cpu_mask), 8))
#define ASSERT_CPUSET_COUNT(c, n) \
ASSERT_NOT_NULL(c.set); \
ASSERT_CPUSET_ALLOCATED(c); \
ASSERT_EQ(CPU_COUNT_S(c.allocated, c.set), n)
#define ASSERT_CPUSET_ISSET(c, i) \
ASSERT_TRUE(CPU_ISSET_S(i, c.allocated, c.set));
#define ASSERT_CPUSET_STRING(c, str, range, mask) \
{ \
_cleanup_free_ char *s = NULL; \
ASSERT_NOT_NULL(s = cpu_set_to_string(&c)); \
log_info("cpu_set_to_string: %s", s); \
ASSERT_STREQ(s, str); \
s = mfree(s); \
ASSERT_NOT_NULL(s = cpu_set_to_range_string(&c)); \
log_info("cpu_set_to_range_string: %s", s); \
ASSERT_STREQ(s, range); \
s = mfree(s); \
ASSERT_NOT_NULL(s = cpu_set_to_mask_string(&c)); \
log_info("cpu_set_to_mask_string: %s", s); \
ASSERT_STREQ(s, mask); \
}
TEST(parse_cpu_set) {
CPUSet c = {};
_cleanup_free_ char *str = NULL;
int cpu;
/* empty */
ASSERT_CPUSET_EMPTY(c);
ASSERT_CPUSET_STRING(c, "", "", "0");
cpu_set_reset(&c);
/* Single value */
assert_se(parse_cpu_set_full("0", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.set);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_ISSET_S(0, c.allocated, c.set));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 1);
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "0");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "1");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 1);
ASSERT_CPUSET_ISSET(c, 0);
ASSERT_CPUSET_STRING(c, "0", "0", "1");
cpu_set_reset(&c);
/* Simple range (from CPUAffinity example) */
assert_se(parse_cpu_set_full("1 2 4", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.set);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_ISSET_S(1, c.allocated, c.set));
assert_se(CPU_ISSET_S(2, c.allocated, c.set));
assert_se(CPU_ISSET_S(4, c.allocated, c.set));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 3);
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "1-2 4");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "16");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("1 2 4", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 3);
ASSERT_CPUSET_ISSET(c, 1);
ASSERT_CPUSET_ISSET(c, 2);
ASSERT_CPUSET_ISSET(c, 4);
ASSERT_CPUSET_STRING(c, "1 2 4", "1-2 4", "16");
cpu_set_reset(&c);
/* A more interesting range */
assert_se(parse_cpu_set_full("0 1 2 3 8 9 10 11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
for (cpu = 0; cpu < 4; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
for (cpu = 8; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "0-3 8-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "f0f");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0 1 2 3 8 9 10 11", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 8);
for (unsigned i = 0; i < 4; i++)
ASSERT_CPUSET_ISSET(c, i);
for (unsigned i = 8; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "0 1 2 3 8 9 10 11", "0-3 8-11", "f0f");
cpu_set_reset(&c);
/* Quoted strings */
assert_se(parse_cpu_set_full("8 '9' 10 \"11\"", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 4);
for (cpu = 8; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "8-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "f00");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("8 '9' 10 \"11\"", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 4);
for (unsigned i = 8; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "8 9 10 11", "8-11", "f00");
cpu_set_reset(&c);
/* Use commas as separators */
assert_se(parse_cpu_set_full("0,1,2,3 8,9,10,11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
for (cpu = 0; cpu < 4; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
for (cpu = 8; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0,1,2,3 8,9,10,11", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 8);
for (unsigned i = 0; i < 4; i++)
ASSERT_CPUSET_ISSET(c, i);
for (unsigned i = 8; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "0 1 2 3 8 9 10 11", "0-3 8-11", "f0f");
cpu_set_reset(&c);
/* Commas with spaces (and trailing comma, space) */
assert_se(parse_cpu_set_full("0, 1, 2, 3, 4, 5, 6, 7, 63, ", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 9);
for (cpu = 0; cpu < 8; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(CPU_ISSET_S(63, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "0-7 63");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "80000000,000000ff");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0, 1, 2, 3, 4, 5, 6, 7, 63, ", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 9);
for (unsigned i = 0; i < 8; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_ISSET(c, 63);
ASSERT_CPUSET_STRING(c, "0 1 2 3 4 5 6 7 63", "0-7 63", "80000000,000000ff");
cpu_set_reset(&c);
/* Ranges */
assert_se(parse_cpu_set_full("0-3,8-11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
for (cpu = 0; cpu < 4; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
for (cpu = 8; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0-3,8-11", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 8);
for (unsigned i = 0; i < 4; i++)
ASSERT_CPUSET_ISSET(c, i);
for (unsigned i = 8; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "0 1 2 3 8 9 10 11", "0-3 8-11", "f0f");
cpu_set_reset(&c);
assert_se(parse_cpu_set_full("36-39,44-47", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
for (cpu = 36; cpu < 40; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
for (cpu = 44; cpu < 48; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "f0f0,00000000");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("36-39,44-47", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 8);
for (unsigned i = 36; i < 40; i++)
ASSERT_CPUSET_ISSET(c, i);
for (unsigned i = 44; i < 48; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "36 37 38 39 44 45 46 47", "36-39 44-47", "f0f0,00000000");
cpu_set_reset(&c);
assert_se(parse_cpu_set_full("64-71", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
for (cpu = 64; cpu < 72; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "ff,00000000,00000000");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("64-71", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 8);
for (unsigned i = 64; i < 72; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "64 65 66 67 68 69 70 71", "64-71", "ff,00000000,00000000");
cpu_set_reset(&c);
/* Ranges with trailing comma, space */
assert_se(parse_cpu_set_full("0-3 8-11, ", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
for (cpu = 0; cpu < 4; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
for (cpu = 8; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "0-3 8-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "f0f");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0-3 8-11, ", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 8);
for (unsigned i = 0; i < 4; i++)
ASSERT_CPUSET_ISSET(c, i);
for (unsigned i = 8; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "0 1 2 3 8 9 10 11", "0-3 8-11", "f0f");
cpu_set_reset(&c);
/* Negative range (returns empty cpu_set) */
assert_se(parse_cpu_set_full("3-0", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 0);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "0");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("3-0", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 0);
ASSERT_CPUSET_STRING(c, "", "", "0");
cpu_set_reset(&c);
/* Overlapping ranges */
assert_se(parse_cpu_set_full("0-7 4-11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 12);
for (cpu = 0; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "0-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "fff");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0-7 4-11", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 12);
for (unsigned i = 0; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "0 1 2 3 4 5 6 7 8 9 10 11", "0-11", "fff");
cpu_set_reset(&c);
/* Mix ranges and individual CPUs */
assert_se(parse_cpu_set_full("0,2 4-11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
assert_se(CPU_COUNT_S(c.allocated, c.set) == 10);
assert_se(CPU_ISSET_S(0, c.allocated, c.set));
assert_se(CPU_ISSET_S(2, c.allocated, c.set));
for (cpu = 4; cpu < 12; cpu++)
assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "0 2 4-11");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "ff5");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("0,2 4-11", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 10);
ASSERT_CPUSET_ISSET(c, 0);
ASSERT_CPUSET_ISSET(c, 2);
for (unsigned i = 4; i < 12; i++)
ASSERT_CPUSET_ISSET(c, i);
ASSERT_CPUSET_STRING(c, "0 2 4 5 6 7 8 9 10 11", "0 2 4-11", "ff5");
cpu_set_reset(&c);
/* Garbage */
assert_se(parse_cpu_set_full("0 1 2 3 garbage", &c, true, NULL, "fake", 1, "CPUAffinity") == -EINVAL);
assert_se(!c.set);
assert_se(c.allocated == 0);
ASSERT_ERROR(parse_cpu_set_full("0 1 2 3 garbage", &c, true, NULL, "fake", 1, "CPUAffinity"), EINVAL);
ASSERT_CPUSET_EMPTY(c);
/* Range with garbage */
assert_se(parse_cpu_set_full("0-3 8-garbage", &c, true, NULL, "fake", 1, "CPUAffinity") == -EINVAL);
assert_se(!c.set);
assert_se(c.allocated == 0);
ASSERT_ERROR(parse_cpu_set_full("0-3 8-garbage", &c, true, NULL, "fake", 1, "CPUAffinity"), EINVAL);
ASSERT_CPUSET_EMPTY(c);
/* Empty string */
assert_se(parse_cpu_set_full("", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
assert_se(!c.set); /* empty string returns NULL */
assert_se(c.allocated == 0);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
ASSERT_STREQ(str, "0");
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_EMPTY(c); /* empty string returns NULL */
/* Runaway quoted string */
assert_se(parse_cpu_set_full("0 1 2 3 \"4 5 6 7 ", &c, true, NULL, "fake", 1, "CPUAffinity") == -EINVAL);
assert_se(!c.set);
assert_se(c.allocated == 0);
ASSERT_ERROR(parse_cpu_set_full("0 1 2 3 \"4 5 6 7 ", &c, true, NULL, "fake", 1, "CPUAffinity"), EINVAL);
ASSERT_CPUSET_EMPTY(c);
/* Maximum allocation */
assert_se(parse_cpu_set_full("8000-8191", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
assert_se(CPU_COUNT_S(c.allocated, c.set) == 192);
assert_se(str = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", str);
str = mfree(str);
assert_se(str = cpu_set_to_range_string(&c));
log_info("cpu_set_to_range_string: %s", str);
ASSERT_STREQ(str, "8000-8191");
str = mfree(str);
assert_se(str = cpu_set_to_mask_string(&c));
log_info("cpu_set_to_mask_string: %s", str);
for (size_t i = 0; i < strlen(str); i++) {
if (i < 54) {
if (i >= 8 && (i + 1) % 9 == 0)
assert_se(str[i] == ',');
else
assert_se(str[i] == 'f');
}
else {
if (i >= 8 && (i + 1) % 9 == 0)
assert_se(str[i] == ',');
else
assert_se(str[i] == '0');
}
}
str = mfree(str);
ASSERT_OK(parse_cpu_set_full("8000-8191", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 192);
_cleanup_free_ char *expected_str = NULL;
for (size_t i = 8000; i < 8192; i++)
ASSERT_OK(strextendf_with_separator(&expected_str, " ", "%zu", i));
_cleanup_free_ char *expected_mask = NULL;
for (size_t i = 0; i < 8192 / 32; i++)
ASSERT_NOT_NULL(strextend_with_separator(&expected_mask, ",", i < 6 ? "ffffffff" : "00000000"));
ASSERT_CPUSET_STRING(c, expected_str, "8000-8191", expected_mask);
cpu_set_reset(&c);
}
TEST(parse_cpu_set_extend) {
CPUSet c = {};
_cleanup_free_ char *s1 = NULL, *s2 = NULL;
assert_se(parse_cpu_set_extend("1 3", &c, true, NULL, "fake", 1, "CPUAffinity") == 1);
assert_se(CPU_COUNT_S(c.allocated, c.set) == 2);
assert_se(s1 = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", s1);
ASSERT_OK_POSITIVE(parse_cpu_set_extend("1 3", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 2);
ASSERT_CPUSET_STRING(c, "1 3", "1 3", "a");
assert_se(parse_cpu_set_extend("4", &c, true, NULL, "fake", 1, "CPUAffinity") == 1);
assert_se(CPU_COUNT_S(c.allocated, c.set) == 3);
assert_se(s2 = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", s2);
ASSERT_OK_POSITIVE(parse_cpu_set_extend("4", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 3);
ASSERT_CPUSET_STRING(c, "1 3 4", "1 3-4", "1a");
assert_se(parse_cpu_set_extend("", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
assert_se(!c.set);
assert_se(c.allocated == 0);
log_info("cpu_set_to_string: (null)");
ASSERT_OK_ZERO(parse_cpu_set_extend("", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_EMPTY(c);
}
TEST(cpu_set_to_from_dbus) {
_cleanup_(cpu_set_reset) CPUSet c = {}, c2 = {};
_cleanup_free_ char *s = NULL;
assert_se(parse_cpu_set_extend("1 3 8 100-200", &c, true, NULL, "fake", 1, "CPUAffinity") == 1);
assert_se(s = cpu_set_to_string(&c));
log_info("cpu_set_to_string: %s", s);
assert_se(CPU_COUNT_S(c.allocated, c.set) == 104);
ASSERT_OK_POSITIVE(parse_cpu_set_extend("1 3 8 100-200", &c, true, NULL, "fake", 1, "CPUAffinity"));
ASSERT_CPUSET_COUNT(c, 104);
_cleanup_free_ char *expected_str = strdup("1 3 8");
ASSERT_NOT_NULL(expected_str);
for (size_t i = 100; i <= 200; i++)
ASSERT_OK(strextendf_with_separator(&expected_str, " ", "%zu", i));
ASSERT_CPUSET_STRING(c, expected_str, "1 3 8 100-200", "1ff,ffffffff,ffffffff,fffffff0,00000000,00000000,0000010a");
_cleanup_free_ uint8_t *array = NULL;
size_t allocated;
static const char expected[32] =
"\x0A\x01\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\xF0\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
"\xFF\xFF\xFF\xFF\xFF\x01";
"\x0A\x01\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\xF0\xFF\xFF\xFF"
"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
"\xFF\x01";
assert_se(cpu_set_to_dbus(&c, &array, &allocated) == 0);
assert_se(array);
assert_se(allocated == c.allocated);
ASSERT_OK(cpu_set_to_dbus(&c, &array, &allocated));
ASSERT_NOT_NULL(array);
ASSERT_EQ(allocated, c.allocated);
assert_se(allocated <= sizeof expected);
assert_se(allocated >= DIV_ROUND_UP(201u, 8u)); /* We need at least 201 bits for our mask */
assert_se(memcmp(array, expected, allocated) == 0);
ASSERT_LE(allocated, sizeof expected);
ASSERT_GE(allocated, DIV_ROUND_UP(201u, 8u)); /* We need at least 201 bits for our mask */
ASSERT_EQ(memcmp(array, expected, allocated), 0);
assert_se(cpu_set_from_dbus(array, allocated, &c2) == 0);
assert_se(c2.set);
assert_se(c2.allocated == c.allocated);
assert_se(memcmp(c.set, c2.set, c.allocated) == 0);
ASSERT_OK(cpu_set_from_dbus(array, allocated, &c2));
ASSERT_CPUSET_COUNT(c2, 104);
ASSERT_EQ(memcmp_nn(c.set, c.allocated, c2.set, c2.allocated), 0);
}
TEST(cpus_in_affinity_mask) {
int r;
r = cpus_in_affinity_mask();
assert_se(r > 0);
ASSERT_OK_POSITIVE(r = cpus_in_affinity_mask());
log_info("cpus_in_affinity_mask: %d", r);
}