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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "set.h"
#include "strv.h"

const bool mempool_use_allowed = VALGRIND;

static void test_set_steal_first(void) {
        _cleanup_set_free_ Set *m = NULL;
        int seen[3] = {};
        char *val;

        m = set_new(&string_hash_ops);
        assert_se(m);

        assert_se(set_put(m, (void*) "1") == 1);
        assert_se(set_put(m, (void*) "22") == 1);
        assert_se(set_put(m, (void*) "333") == 1);

        while ((val = set_steal_first(m)))
                seen[strlen(val) - 1]++;

        assert_se(seen[0] == 1 && seen[1] == 1 && seen[2] == 1);

        assert_se(set_isempty(m));
}

typedef struct Item {
        int seen;
} Item;
static void item_seen(Item *item) {
        item->seen++;
}

static void test_set_free_with_destructor(void) {
        Set *m;
        struct Item items[4] = {};
        unsigned i;

        assert_se(m = set_new(NULL));
        for (i = 0; i < ELEMENTSOF(items) - 1; i++)
                assert_se(set_put(m, items + i) == 1);

        m = set_free_with_destructor(m, item_seen);
        assert_se(items[0].seen == 1);
        assert_se(items[1].seen == 1);
        assert_se(items[2].seen == 1);
        assert_se(items[3].seen == 0);
}

DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(item_hash_ops, void, trivial_hash_func, trivial_compare_func, Item, item_seen);

static void test_set_free_with_hash_ops(void) {
        Set *m;
        struct Item items[4] = {};
        unsigned i;

        assert_se(m = set_new(&item_hash_ops));
        for (i = 0; i < ELEMENTSOF(items) - 1; i++)
                assert_se(set_put(m, items + i) == 1);

        m = set_free(m);
        assert_se(items[0].seen == 1);
        assert_se(items[1].seen == 1);
        assert_se(items[2].seen == 1);
        assert_se(items[3].seen == 0);
}

static void test_set_put(void) {
        _cleanup_set_free_ Set *m = NULL;

        m = set_new(&string_hash_ops);
        assert_se(m);

        assert_se(set_put(m, (void*) "1") == 1);
        assert_se(set_put(m, (void*) "22") == 1);
        assert_se(set_put(m, (void*) "333") == 1);
        assert_se(set_put(m, (void*) "333") == 0);
        assert_se(set_remove(m, (void*) "333"));
        assert_se(set_put(m, (void*) "333") == 1);
        assert_se(set_put(m, (void*) "333") == 0);
        assert_se(set_put(m, (void*) "22") == 0);

        _cleanup_free_ char **t = set_get_strv(m);
        assert_se(strv_contains(t, "1"));
        assert_se(strv_contains(t, "22"));
        assert_se(strv_contains(t, "333"));
        assert_se(strv_length(t) == 3);
}

static void test_set_put_strdup(void) {
        _cleanup_set_free_ Set *m = NULL;

        assert_se(set_put_strdup(&m, "aaa") == 1);
        assert_se(set_put_strdup(&m, "aaa") == 0);
        assert_se(set_put_strdup(&m, "bbb") == 1);
        assert_se(set_put_strdup(&m, "bbb") == 0);
        assert_se(set_put_strdup(&m, "aaa") == 0);
        assert_se(set_size(m) == 2);
}

static void test_set_put_strdupv(void) {
        _cleanup_set_free_ Set *m = NULL;

        assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "aaa")) == 2);
        assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "ccc")) == 1);
        assert_se(set_size(m) == 3);
}

static void test_set_ensure_allocated(void) {
        _cleanup_set_free_ Set *m = NULL;

        assert_se(set_ensure_allocated(&m, &string_hash_ops) == 1);
        assert_se(set_ensure_allocated(&m, &string_hash_ops) == 0);
        assert_se(set_ensure_allocated(&m, NULL) == 0);
        assert_se(set_size(m) == 0);
}

static void test_set_ensure_put(void) {
        _cleanup_set_free_ Set *m = NULL;

        assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 1);
        assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
        assert_se(set_ensure_put(&m, NULL, "a") == 0);
        assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 1);
        assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 0);
        assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
        assert_se(set_size(m) == 2);
}

static void test_set_ensure_consume(void) {
        _cleanup_set_free_ Set *m = NULL;
        char *s, *t;

        assert_se(s = strdup("a"));
        assert_se(set_ensure_consume(&m, &string_hash_ops_free, s) == 1);

        assert_se(t = strdup("a"));
        assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);

        assert_se(t = strdup("a"));
        assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);

        assert_se(t = strdup("b"));
        assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 1);

        assert_se(t = strdup("b"));
        assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);

        assert_se(set_size(m) == 2);
}

static void test_set_strjoin(void) {
        _cleanup_set_free_ Set *m = NULL;
        _cleanup_free_ char *joined = NULL;

        /* Empty set */
        assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, "", false, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, " ", false, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, "", true, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, " ", true, &joined) >= 0);
        assert_se(!joined);
        assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
        assert_se(!joined);

        /* Single entry */
        assert_se(set_put_strdup(&m, "aaa") == 1);
        assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
        assert_se(streq(joined, "aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "", false, &joined) >= 0);
        assert_se(streq(joined, "aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, " ", false, &joined) >= 0);
        assert_se(streq(joined, "aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
        assert_se(streq(joined, "aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
        assert_se(streq(joined, "aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "", true, &joined) >= 0);
        assert_se(streq(joined, "aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, " ", true, &joined) >= 0);
        assert_se(streq(joined, " aaa "));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
        assert_se(streq(joined, "xxxaaaxxx"));

        /* Two entries */
        assert_se(set_put_strdup(&m, "bbb") == 1);
        assert_se(set_put_strdup(&m, "aaa") == 0);
        joined = mfree(joined);
        assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "", false, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, " ", false, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "aaa bbb", "bbb aaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "aaaxxxbbb", "bbbxxxaaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "", true, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
        joined = mfree(joined);
        assert_se(set_strjoin(m, " ", true, &joined) >= 0);
        assert_se(STR_IN_SET(joined, " aaa bbb ", " bbb aaa "));
        joined = mfree(joined);
        assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
        assert_se(STR_IN_SET(joined, "xxxaaaxxxbbbxxx", "xxxbbbxxxaaaxxx"));
}

int main(int argc, const char *argv[]) {
        test_set_steal_first();
        test_set_free_with_destructor();
        test_set_free_with_hash_ops();
        test_set_put();
        test_set_put_strdup();
        test_set_put_strdupv();
        test_set_ensure_allocated();
        test_set_ensure_put();
        test_set_ensure_consume();
        test_set_strjoin();

        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
647f6824	2
647f6824	3	#include "set.h"
ef79eae0	4	#include "strv.h"
647f6824	5
de747a00 ZJS	6	const bool mempool_use_allowed = VALGRIND;
de747a00 ZJS	7
647f6824 ZJS	8	static void test_set_steal_first(void) {
	9	_cleanup_set_free_ Set *m = NULL;
	10	int seen[3] = {};
	11	char *val;
	12
	13	m = set_new(&string_hash_ops);
	14	assert_se(m);
	15
	16	assert_se(set_put(m, (void*) "1") == 1);
	17	assert_se(set_put(m, (void*) "22") == 1);
	18	assert_se(set_put(m, (void*) "333") == 1);
	19
	20	while ((val = set_steal_first(m)))
	21	seen[strlen(val) - 1]++;
	22
bdf7026e	23	assert_se(seen[0] == 1 && seen[1] == 1 && seen[2] == 1);
647f6824 ZJS	24
	25	assert_se(set_isempty(m));
	26	}
	27
224b0e7a ZJS	28	typedef struct Item {
	29	int seen;
	30	} Item;
	31	static void item_seen(Item *item) {
	32	item->seen++;
	33	}
	34
	35	static void test_set_free_with_destructor(void) {
	36	Set *m;
	37	struct Item items[4] = {};
	38	unsigned i;
	39
	40	assert_se(m = set_new(NULL));
	41	for (i = 0; i < ELEMENTSOF(items) - 1; i++)
	42	assert_se(set_put(m, items + i) == 1);
	43
	44	m = set_free_with_destructor(m, item_seen);
	45	assert_se(items[0].seen == 1);
	46	assert_se(items[1].seen == 1);
	47	assert_se(items[2].seen == 1);
	48	assert_se(items[3].seen == 0);
	49	}
	50
98233ee5 YW	51	DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(item_hash_ops, void, trivial_hash_func, trivial_compare_func, Item, item_seen);
	52
	53	static void test_set_free_with_hash_ops(void) {
	54	Set *m;
	55	struct Item items[4] = {};
	56	unsigned i;
	57
	58	assert_se(m = set_new(&item_hash_ops));
	59	for (i = 0; i < ELEMENTSOF(items) - 1; i++)
	60	assert_se(set_put(m, items + i) == 1);
	61
	62	m = set_free(m);
	63	assert_se(items[0].seen == 1);
	64	assert_se(items[1].seen == 1);
	65	assert_se(items[2].seen == 1);
	66	assert_se(items[3].seen == 0);
	67	}
	68
756c09e6 RC	69	static void test_set_put(void) {
	70	_cleanup_set_free_ Set *m = NULL;
	71
	72	m = set_new(&string_hash_ops);
	73	assert_se(m);
	74
	75	assert_se(set_put(m, (void*) "1") == 1);
	76	assert_se(set_put(m, (void*) "22") == 1);
	77	assert_se(set_put(m, (void*) "333") == 1);
	78	assert_se(set_put(m, (void*) "333") == 0);
	79	assert_se(set_remove(m, (void*) "333"));
	80	assert_se(set_put(m, (void*) "333") == 1);
	81	assert_se(set_put(m, (void*) "333") == 0);
	82	assert_se(set_put(m, (void*) "22") == 0);
ef79eae0 ZJS	83
	84	_cleanup_free_ char **t = set_get_strv(m);
	85	assert_se(strv_contains(t, "1"));
	86	assert_se(strv_contains(t, "22"));
	87	assert_se(strv_contains(t, "333"));
	88	assert_se(strv_length(t) == 3);
756c09e6 RC	89	}
756c09e6 RC	90
de747a00 ZJS	91	static void test_set_put_strdup(void) {
	92	_cleanup_set_free_ Set *m = NULL;
	93
	94	assert_se(set_put_strdup(&m, "aaa") == 1);
	95	assert_se(set_put_strdup(&m, "aaa") == 0);
	96	assert_se(set_put_strdup(&m, "bbb") == 1);
	97	assert_se(set_put_strdup(&m, "bbb") == 0);
	98	assert_se(set_put_strdup(&m, "aaa") == 0);
	99	assert_se(set_size(m) == 2);
	100	}
	101
	102	static void test_set_put_strdupv(void) {
	103	_cleanup_set_free_ Set *m = NULL;
	104
	105	assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "aaa")) == 2);
	106	assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "ccc")) == 1);
	107	assert_se(set_size(m) == 3);
	108	}
	109
0f9ccd95 ZJS	110	static void test_set_ensure_allocated(void) {
	111	_cleanup_set_free_ Set *m = NULL;
	112
	113	assert_se(set_ensure_allocated(&m, &string_hash_ops) == 1);
	114	assert_se(set_ensure_allocated(&m, &string_hash_ops) == 0);
	115	assert_se(set_ensure_allocated(&m, NULL) == 0);
	116	assert_se(set_size(m) == 0);
	117	}
	118
	119	static void test_set_ensure_put(void) {
	120	_cleanup_set_free_ Set *m = NULL;
	121
	122	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 1);
	123	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
	124	assert_se(set_ensure_put(&m, NULL, "a") == 0);
	125	assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 1);
	126	assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 0);
	127	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
	128	assert_se(set_size(m) == 2);
	129	}
	130
fcc1d031 ZJS	131	static void test_set_ensure_consume(void) {
	132	_cleanup_set_free_ Set *m = NULL;
	133	char s, t;
	134
	135	assert_se(s = strdup("a"));
	136	assert_se(set_ensure_consume(&m, &string_hash_ops_free, s) == 1);
	137
	138	assert_se(t = strdup("a"));
	139	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	140
	141	assert_se(t = strdup("a"));
	142	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	143
	144	assert_se(t = strdup("b"));
	145	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 1);
	146
	147	assert_se(t = strdup("b"));
	148	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	149
	150	assert_se(set_size(m) == 2);
	151	}
	152
4dbce717 YW	153	static void test_set_strjoin(void) {
	154	_cleanup_set_free_ Set *m = NULL;
	155	_cleanup_free_ char *joined = NULL;
	156
8d80f275 YW	157	/* Empty set */
8d80f275 YW	158	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	159	assert_se(!joined);
8d80f275	160	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	161	assert_se(!joined);
8d80f275	162	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
4dbce717	163	assert_se(!joined);
8d80f275 YW	164	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
	165	assert_se(!joined);
	166	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
	167	assert_se(!joined);
	168	assert_se(set_strjoin(m, "", true, &joined) >= 0);
	169	assert_se(!joined);
	170	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	171	assert_se(!joined);
	172	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
4dbce717 YW	173	assert_se(!joined);
4dbce717 YW	174
8d80f275	175	/* Single entry */
4dbce717	176	assert_se(set_put_strdup(&m, "aaa") == 1);
8d80f275	177	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	178	assert_se(streq(joined, "aaa"));
4dbce717	179	joined = mfree(joined);
8d80f275	180	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	181	assert_se(streq(joined, "aaa"));
4dbce717	182	joined = mfree(joined);
8d80f275 YW	183	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
	184	assert_se(streq(joined, "aaa"));
	185	joined = mfree(joined);
	186	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
	187	assert_se(streq(joined, "aaa"));
	188	joined = mfree(joined);
	189	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
4dbce717	190	assert_se(streq(joined, "aaa"));
4dbce717	191	joined = mfree(joined);
8d80f275	192	assert_se(set_strjoin(m, "", true, &joined) >= 0);
4dbce717	193	assert_se(streq(joined, "aaa"));
8d80f275 YW	194	joined = mfree(joined);
	195	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	196	assert_se(streq(joined, " aaa "));
	197	joined = mfree(joined);
	198	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
	199	assert_se(streq(joined, "xxxaaaxxx"));
4dbce717	200
8d80f275	201	/* Two entries */
4dbce717 YW	202	assert_se(set_put_strdup(&m, "bbb") == 1);
4dbce717 YW	203	assert_se(set_put_strdup(&m, "aaa") == 0);
4dbce717	204	joined = mfree(joined);
8d80f275	205	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	206	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
4dbce717	207	joined = mfree(joined);
8d80f275	208	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	209	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
4dbce717	210	joined = mfree(joined);
8d80f275	211	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
4dbce717	212	assert_se(STR_IN_SET(joined, "aaa bbb", "bbb aaa"));
4dbce717	213	joined = mfree(joined);
8d80f275	214	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
4dbce717	215	assert_se(STR_IN_SET(joined, "aaaxxxbbb", "bbbxxxaaa"));
8d80f275 YW	216	joined = mfree(joined);
	217	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
	218	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
	219	joined = mfree(joined);
	220	assert_se(set_strjoin(m, "", true, &joined) >= 0);
	221	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
	222	joined = mfree(joined);
	223	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	224	assert_se(STR_IN_SET(joined, " aaa bbb ", " bbb aaa "));
	225	joined = mfree(joined);
	226	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
	227	assert_se(STR_IN_SET(joined, "xxxaaaxxxbbbxxx", "xxxbbbxxxaaaxxx"));
4dbce717 YW	228	}
4dbce717 YW	229
647f6824 ZJS	230	int main(int argc, const char *argv[]) {
647f6824 ZJS	231	test_set_steal_first();
224b0e7a	232	test_set_free_with_destructor();
98233ee5	233	test_set_free_with_hash_ops();
756c09e6	234	test_set_put();
de747a00 ZJS	235	test_set_put_strdup();
de747a00 ZJS	236	test_set_put_strdupv();
0f9ccd95 ZJS	237	test_set_ensure_allocated();
0f9ccd95 ZJS	238	test_set_ensure_put();
fcc1d031	239	test_set_ensure_consume();
4dbce717	240	test_set_strjoin();
647f6824 ZJS	241
	242	return 0;
	243	}