[thirdparty/systemd.git] / src / test / test-cpu-set-util.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include "alloc-util.h"
#include "cpu-set-util.h"
#include "string-util.h"
#include "macro.h"

static void test_parse_cpu_set(void) {
        CPUSet c = {};
        _cleanup_free_ char *str = NULL;
        int cpu;

        log_info("/* %s */", __func__);

        /* 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_se(streq(str, "0"));
        str = mfree(str);
        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_se(streq(str, "1-2 4"));
        str = mfree(str);
        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_se(streq(str, "0-3 8-11"));
        str = mfree(str);
        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_se(streq(str, "8-11"));
        str = mfree(str);
        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);
        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_se(streq(str, "0-7 63"));
        str = mfree(str);
        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);
        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_se(streq(str, "0-3 8-11"));
        str = mfree(str);
        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);
        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_se(streq(str, "0-11"));
        str = mfree(str);
        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_se(streq(str, "0 2 4-11"));
        str = mfree(str);
        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);

        /* 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);

        /* 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);

        /* 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);

        /* 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_se(streq(str, "8000-8191"));
        str = mfree(str);
        cpu_set_reset(&c);
}

static void test_parse_cpu_set_extend(void) {
        CPUSet c = {};
        _cleanup_free_ char *s1 = NULL, *s2 = NULL;

        log_info("/* %s */", __func__);

        assert_se(parse_cpu_set_extend("1 3", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
        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_se(parse_cpu_set_extend("4", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
        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_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)");
}

static void test_cpu_set_to_from_dbus(void) {
        _cleanup_(cpu_set_reset) CPUSet c = {}, c2 = {};
        _cleanup_free_ char *s = NULL;

        log_info("/* %s */", __func__);

        assert_se(parse_cpu_set_extend("1 3 8 100-200", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
        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);

        _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";

        assert_se(cpu_set_to_dbus(&c, &array, &allocated) == 0);
        assert_se(array);
        assert_se(allocated == c.allocated);

        assert(memcmp(array, expected, sizeof expected) == 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);
}

static void test_cpus_in_affinity_mask(void) {
        int r;

        r = cpus_in_affinity_mask();
        assert(r > 0);
        log_info("cpus_in_affinity_mask: %d", r);
}

int main(int argc, char *argv[]) {
        log_info("CPU_ALLOC_SIZE(1) = %zu", CPU_ALLOC_SIZE(1));
        log_info("CPU_ALLOC_SIZE(9) = %zu", CPU_ALLOC_SIZE(9));
        log_info("CPU_ALLOC_SIZE(64) = %zu", CPU_ALLOC_SIZE(64));
        log_info("CPU_ALLOC_SIZE(65) = %zu", CPU_ALLOC_SIZE(65));
        log_info("CPU_ALLOC_SIZE(1024) = %zu", CPU_ALLOC_SIZE(1024));
        log_info("CPU_ALLOC_SIZE(1025) = %zu", CPU_ALLOC_SIZE(1025));
        log_info("CPU_ALLOC_SIZE(8191) = %zu", CPU_ALLOC_SIZE(8191));

        test_parse_cpu_set();
        test_parse_cpu_set_extend();
        test_cpus_in_affinity_mask();
        test_cpu_set_to_from_dbus();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
7ba365a9 RC	2
	3	#include "alloc-util.h"
	4	#include "cpu-set-util.h"
71b28519	5	#include "string-util.h"
7ba365a9 RC	6	#include "macro.h"
	7
	8	static void test_parse_cpu_set(void) {
0985c7c4	9	CPUSet c = {};
a832893f	10	_cleanup_free_ char *str = NULL;
7ba365a9 RC	11	int cpu;
7ba365a9 RC	12
b54d7241 ZJS	13	log_info("/* %s */", __func__);
b54d7241 ZJS	14
71b28519 MS	15	/* Single value */
	16	assert_se(parse_cpu_set_full("0", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
	17	assert_se(c.set);
a299ce05	18	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
71b28519 MS	19	assert_se(CPU_ISSET_S(0, c.allocated, c.set));
	20	assert_se(CPU_COUNT_S(c.allocated, c.set) == 1);
	21
	22	assert_se(str = cpu_set_to_string(&c));
	23	log_info("cpu_set_to_string: %s", str);
	24	str = mfree(str);
	25	assert_se(str = cpu_set_to_range_string(&c));
	26	log_info("cpu_set_to_range_string: %s", str);
71923237	27	assert_se(streq(str, "0"));
71b28519 MS	28	str = mfree(str);
	29	cpu_set_reset(&c);
	30
7ba365a9	31	/* Simple range (from CPUAffinity example) */
1f57a176	32	assert_se(parse_cpu_set_full("1 2 4", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
0985c7c4	33	assert_se(c.set);
a299ce05	34	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4 ZJS	35	assert_se(CPU_ISSET_S(1, c.allocated, c.set));
0985c7c4 ZJS	36	assert_se(CPU_ISSET_S(2, c.allocated, c.set));
1f57a176 ZJS	37	assert_se(CPU_ISSET_S(4, c.allocated, c.set));
1f57a176 ZJS	38	assert_se(CPU_COUNT_S(c.allocated, c.set) == 3);
0985c7c4 ZJS	39
0985c7c4 ZJS	40	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	41	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	42	str = mfree(str);
71b28519 MS	43	assert_se(str = cpu_set_to_range_string(&c));
71b28519 MS	44	log_info("cpu_set_to_range_string: %s", str);
1f57a176	45	assert_se(streq(str, "1-2 4"));
71b28519	46	str = mfree(str);
0985c7c4	47	cpu_set_reset(&c);
7ba365a9 RC	48
7ba365a9 RC	49	/* A more interesting range */
0985c7c4	50	assert_se(parse_cpu_set_full("0 1 2 3 8 9 10 11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	51	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4	52	assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
7ba365a9	53	for (cpu = 0; cpu < 4; cpu++)
0985c7c4	54	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
7ba365a9	55	for (cpu = 8; cpu < 12; cpu++)
0985c7c4	56	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
71b28519	57
0985c7c4	58	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	59	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	60	str = mfree(str);
71b28519 MS	61	assert_se(str = cpu_set_to_range_string(&c));
	62	log_info("cpu_set_to_range_string: %s", str);
	63	assert_se(streq(str, "0-3 8-11"));
	64	str = mfree(str);
0985c7c4	65	cpu_set_reset(&c);
7ba365a9 RC	66
7ba365a9 RC	67	/* Quoted strings */
0985c7c4	68	assert_se(parse_cpu_set_full("8 '9' 10 \"11\"", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	69	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4	70	assert_se(CPU_COUNT_S(c.allocated, c.set) == 4);
7ba365a9	71	for (cpu = 8; cpu < 12; cpu++)
0985c7c4 ZJS	72	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
0985c7c4 ZJS	73	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	74	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	75	str = mfree(str);
71b28519 MS	76	assert_se(str = cpu_set_to_range_string(&c));
	77	log_info("cpu_set_to_range_string: %s", str);
	78	assert_se(streq(str, "8-11"));
	79	str = mfree(str);
0985c7c4	80	cpu_set_reset(&c);
7ba365a9 RC	81
7ba365a9 RC	82	/* Use commas as separators */
0985c7c4	83	assert_se(parse_cpu_set_full("0,1,2,3 8,9,10,11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	84	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4	85	assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
7ba365a9	86	for (cpu = 0; cpu < 4; cpu++)
0985c7c4	87	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
7ba365a9	88	for (cpu = 8; cpu < 12; cpu++)
0985c7c4 ZJS	89	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
0985c7c4 ZJS	90	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	91	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	92	str = mfree(str);
0985c7c4	93	cpu_set_reset(&c);
7ba365a9 RC	94
7ba365a9 RC	95	/* Commas with spaces (and trailing comma, space) */
71923237	96	assert_se(parse_cpu_set_full("0, 1, 2, 3, 4, 5, 6, 7, 63, ", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	97	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
71923237	98	assert_se(CPU_COUNT_S(c.allocated, c.set) == 9);
7ba365a9	99	for (cpu = 0; cpu < 8; cpu++)
0985c7c4	100	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
71923237 MS	101
71923237 MS	102	assert_se(CPU_ISSET_S(63, c.allocated, c.set));
0985c7c4	103	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	104	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	105	str = mfree(str);
71b28519 MS	106	assert_se(str = cpu_set_to_range_string(&c));
71b28519 MS	107	log_info("cpu_set_to_range_string: %s", str);
71923237	108	assert_se(streq(str, "0-7 63"));
71b28519	109	str = mfree(str);
0985c7c4	110	cpu_set_reset(&c);
7ba365a9 RC	111
7ba365a9 RC	112	/* Ranges */
0985c7c4	113	assert_se(parse_cpu_set_full("0-3,8-11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	114	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4	115	assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
7ba365a9	116	for (cpu = 0; cpu < 4; cpu++)
0985c7c4	117	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
7ba365a9	118	for (cpu = 8; cpu < 12; cpu++)
0985c7c4 ZJS	119	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
0985c7c4 ZJS	120	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	121	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	122	str = mfree(str);
0985c7c4	123	cpu_set_reset(&c);
7ba365a9 RC	124
7ba365a9 RC	125	/* Ranges with trailing comma, space */
0985c7c4	126	assert_se(parse_cpu_set_full("0-3 8-11, ", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	127	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4	128	assert_se(CPU_COUNT_S(c.allocated, c.set) == 8);
7ba365a9	129	for (cpu = 0; cpu < 4; cpu++)
0985c7c4	130	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
7ba365a9	131	for (cpu = 8; cpu < 12; cpu++)
0985c7c4 ZJS	132	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
0985c7c4 ZJS	133	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	134	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	135	str = mfree(str);
71b28519 MS	136	assert_se(str = cpu_set_to_range_string(&c));
	137	log_info("cpu_set_to_range_string: %s", str);
	138	assert_se(streq(str, "0-3 8-11"));
	139	str = mfree(str);
0985c7c4	140	cpu_set_reset(&c);
7ba365a9 RC	141
7ba365a9 RC	142	/* Negative range (returns empty cpu_set) */
0985c7c4	143	assert_se(parse_cpu_set_full("3-0", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	144	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4 ZJS	145	assert_se(CPU_COUNT_S(c.allocated, c.set) == 0);
0985c7c4 ZJS	146	cpu_set_reset(&c);
7ba365a9 RC	147
7ba365a9 RC	148	/* Overlapping ranges */
0985c7c4	149	assert_se(parse_cpu_set_full("0-7 4-11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	150	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4	151	assert_se(CPU_COUNT_S(c.allocated, c.set) == 12);
7ba365a9	152	for (cpu = 0; cpu < 12; cpu++)
0985c7c4 ZJS	153	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
0985c7c4 ZJS	154	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	155	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	156	str = mfree(str);
71b28519 MS	157	assert_se(str = cpu_set_to_range_string(&c));
	158	log_info("cpu_set_to_range_string: %s", str);
	159	assert_se(streq(str, "0-11"));
	160	str = mfree(str);
0985c7c4	161	cpu_set_reset(&c);
7ba365a9 RC	162
7ba365a9 RC	163	/* Mix ranges and individual CPUs */
71923237	164	assert_se(parse_cpu_set_full("0,2 4-11", &c, true, NULL, "fake", 1, "CPUAffinity") >= 0);
a299ce05	165	assert_se(c.allocated >= DIV_ROUND_UP(sizeof(__cpu_mask), 8));
0985c7c4 ZJS	166	assert_se(CPU_COUNT_S(c.allocated, c.set) == 10);
0985c7c4 ZJS	167	assert_se(CPU_ISSET_S(0, c.allocated, c.set));
71923237	168	assert_se(CPU_ISSET_S(2, c.allocated, c.set));
7ba365a9	169	for (cpu = 4; cpu < 12; cpu++)
0985c7c4 ZJS	170	assert_se(CPU_ISSET_S(cpu, c.allocated, c.set));
0985c7c4 ZJS	171	assert_se(str = cpu_set_to_string(&c));
a832893f ZJS	172	log_info("cpu_set_to_string: %s", str);
a832893f ZJS	173	str = mfree(str);
71b28519 MS	174	assert_se(str = cpu_set_to_range_string(&c));
71b28519 MS	175	log_info("cpu_set_to_range_string: %s", str);
71923237	176	assert_se(streq(str, "0 2 4-11"));
71b28519	177	str = mfree(str);
0985c7c4	178	cpu_set_reset(&c);
7ba365a9 RC	179
7ba365a9 RC	180	/* Garbage */
0985c7c4 ZJS	181	assert_se(parse_cpu_set_full("0 1 2 3 garbage", &c, true, NULL, "fake", 1, "CPUAffinity") == -EINVAL);
	182	assert_se(!c.set);
	183	assert_se(c.allocated == 0);
7ba365a9 RC	184
7ba365a9 RC	185	/* Range with garbage */
0985c7c4 ZJS	186	assert_se(parse_cpu_set_full("0-3 8-garbage", &c, true, NULL, "fake", 1, "CPUAffinity") == -EINVAL);
	187	assert_se(!c.set);
	188	assert_se(c.allocated == 0);
7ba365a9 RC	189
7ba365a9 RC	190	/* Empty string */
0985c7c4 ZJS	191	assert_se(parse_cpu_set_full("", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
	192	assert_se(!c.set); /* empty string returns NULL */
	193	assert_se(c.allocated == 0);
7ba365a9	194
efd08022	195	/* Runaway quoted string */
0985c7c4 ZJS	196	assert_se(parse_cpu_set_full("0 1 2 3 \"4 5 6 7 ", &c, true, NULL, "fake", 1, "CPUAffinity") == -EINVAL);
	197	assert_se(!c.set);
	198	assert_se(c.allocated == 0);
	199
	200	/* Maximum allocation */
	201	assert_se(parse_cpu_set_full("8000-8191", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
	202	assert_se(CPU_COUNT_S(c.allocated, c.set) == 192);
	203	assert_se(str = cpu_set_to_string(&c));
	204	log_info("cpu_set_to_string: %s", str);
	205	str = mfree(str);
71b28519 MS	206	assert_se(str = cpu_set_to_range_string(&c));
	207	log_info("cpu_set_to_range_string: %s", str);
	208	assert_se(streq(str, "8000-8191"));
	209	str = mfree(str);
0985c7c4	210	cpu_set_reset(&c);
7ba365a9 RC	211	}
7ba365a9 RC	212
b54d7241 ZJS	213	static void test_parse_cpu_set_extend(void) {
	214	CPUSet c = {};
	215	_cleanup_free_ char s1 = NULL, s2 = NULL;
	216
	217	log_info("/* %s */", __func__);
	218
	219	assert_se(parse_cpu_set_extend("1 3", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
	220	assert_se(CPU_COUNT_S(c.allocated, c.set) == 2);
	221	assert_se(s1 = cpu_set_to_string(&c));
	222	log_info("cpu_set_to_string: %s", s1);
	223
	224	assert_se(parse_cpu_set_extend("4", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
	225	assert_se(CPU_COUNT_S(c.allocated, c.set) == 3);
	226	assert_se(s2 = cpu_set_to_string(&c));
	227	log_info("cpu_set_to_string: %s", s2);
	228
	229	assert_se(parse_cpu_set_extend("", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
	230	assert_se(!c.set);
	231	assert_se(c.allocated == 0);
	232	log_info("cpu_set_to_string: (null)");
	233	}
	234
1bf0d6c2 ZJS	235	static void test_cpu_set_to_from_dbus(void) {
	236	_cleanup_(cpu_set_reset) CPUSet c = {}, c2 = {};
	237	_cleanup_free_ char *s = NULL;
	238
	239	log_info("/* %s */", __func__);
	240
	241	assert_se(parse_cpu_set_extend("1 3 8 100-200", &c, true, NULL, "fake", 1, "CPUAffinity") == 0);
	242	assert_se(s = cpu_set_to_string(&c));
	243	log_info("cpu_set_to_string: %s", s);
	244	assert_se(CPU_COUNT_S(c.allocated, c.set) == 104);
	245
	246	_cleanup_free_ uint8_t *array = NULL;
	247	size_t allocated;
	248	static const char expected[32] =
	249	"\x0A\x01\x00\x00\x00\x00\x00\x00\x00\x00"
	250	"\x00\x00\xF0\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
	251	"\xFF\xFF\xFF\xFF\xFF\x01";
	252
	253	assert_se(cpu_set_to_dbus(&c, &array, &allocated) == 0);
	254	assert_se(array);
	255	assert_se(allocated == c.allocated);
	256
	257	assert(memcmp(array, expected, sizeof expected) == 0);
	258
	259	assert_se(cpu_set_from_dbus(array, allocated, &c2) == 0);
	260	assert_se(c2.set);
	261	assert_se(c2.allocated == c.allocated);
	262	assert_se(memcmp(c.set, c2.set, c.allocated) == 0);
	263	}
	264
9d1345f0 ZJS	265	static void test_cpus_in_affinity_mask(void) {
	266	int r;
	267
	268	r = cpus_in_affinity_mask();
	269	assert(r > 0);
	270	log_info("cpus_in_affinity_mask: %d", r);
	271	}
	272
7ba365a9	273	int main(int argc, char *argv[]) {
0985c7c4 ZJS	274	log_info("CPU_ALLOC_SIZE(1) = %zu", CPU_ALLOC_SIZE(1));
	275	log_info("CPU_ALLOC_SIZE(9) = %zu", CPU_ALLOC_SIZE(9));
	276	log_info("CPU_ALLOC_SIZE(64) = %zu", CPU_ALLOC_SIZE(64));
	277	log_info("CPU_ALLOC_SIZE(65) = %zu", CPU_ALLOC_SIZE(65));
	278	log_info("CPU_ALLOC_SIZE(1024) = %zu", CPU_ALLOC_SIZE(1024));
	279	log_info("CPU_ALLOC_SIZE(1025) = %zu", CPU_ALLOC_SIZE(1025));
	280	log_info("CPU_ALLOC_SIZE(8191) = %zu", CPU_ALLOC_SIZE(8191));
	281
7ba365a9	282	test_parse_cpu_set();
b54d7241	283	test_parse_cpu_set_extend();
9d1345f0	284	test_cpus_in_affinity_mask();
1bf0d6c2	285	test_cpu_set_to_from_dbus();
7ba365a9 RC	286
	287	return 0;
	288	}