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

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

#include "random-util.h"
#include "set.h"
#include "strv.h"
#include "tests.h"

const bool mempool_use_allowed = VALGRIND;

TEST(set_steal_first) {
        _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++;
}

TEST(set_free_with_destructor) {
        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);

TEST(set_free_with_hash_ops) {
        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);
}

TEST(set_put) {
        _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);
}

TEST(set_put_strndup) {
        _cleanup_set_free_ Set *m = NULL;

        assert_se(set_put_strndup(&m, "12345", 0) == 1);
        assert_se(set_put_strndup(&m, "12345", 1) == 1);
        assert_se(set_put_strndup(&m, "12345", 2) == 1);
        assert_se(set_put_strndup(&m, "12345", 3) == 1);
        assert_se(set_put_strndup(&m, "12345", 4) == 1);
        assert_se(set_put_strndup(&m, "12345", 5) == 1);
        assert_se(set_put_strndup(&m, "12345", 6) == 0);

        assert_se(set_contains(m, ""));
        assert_se(set_contains(m, "1"));
        assert_se(set_contains(m, "12"));
        assert_se(set_contains(m, "123"));
        assert_se(set_contains(m, "1234"));
        assert_se(set_contains(m, "12345"));

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

TEST(set_put_strdup) {
        _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_contains(m, "aaa"));
        assert_se(set_contains(m, "bbb"));

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

TEST(set_put_strdupv) {
        _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_contains(m, "aaa"));
        assert_se(set_contains(m, "bbb"));
        assert_se(set_contains(m, "ccc"));

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

TEST(set_ensure_allocated) {
        _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);
}

TEST(set_copy) {
        Set *s, *copy;
        char *key1, *key2, *key3, *key4;

        key1 = strdup("key1");
        assert_se(key1);
        key2 = strdup("key2");
        assert_se(key2);
        key3 = strdup("key3");
        assert_se(key3);
        key4 = strdup("key4");
        assert_se(key4);

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

        assert_se(set_put(s, key1) >= 0);
        assert_se(set_put(s, key2) >= 0);
        assert_se(set_put(s, key3) >= 0);
        assert_se(set_put(s, key4) >= 0);

        copy = set_copy(s);
        assert_se(copy);

        assert_se(set_equal(s, copy));

        set_free(s);
        set_free_free(copy);
}

TEST(set_ensure_put) {
        _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);
}

TEST(set_ensure_consume) {
        _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);
}

TEST(set_strjoin) {
        _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"));
}

TEST(set_equal) {
        _cleanup_set_free_ Set *a = NULL, *b = NULL;
        void *p;
        int r;

        assert_se(a = set_new(NULL));
        assert_se(b = set_new(NULL));

        assert_se(set_equal(a, a));
        assert_se(set_equal(b, b));
        assert_se(set_equal(a, b));
        assert_se(set_equal(b, a));
        assert_se(set_equal(NULL, a));
        assert_se(set_equal(NULL, b));
        assert_se(set_equal(a, NULL));
        assert_se(set_equal(b, NULL));
        assert_se(set_equal(NULL, NULL));

        for (unsigned i = 0; i < 333; i++) {
                p = INT32_TO_PTR(1 + (random_u32() & 0xFFFU));

                r = set_put(a, p);
                assert_se(r >= 0 || r == -EEXIST);
        }

        assert_se(set_put(a, INT32_TO_PTR(0x1000U)) >= 0);

        assert_se(set_size(a) >= 2);
        assert_se(set_size(a) <= 334);

        assert_se(!set_equal(a, b));
        assert_se(!set_equal(b, a));
        assert_se(!set_equal(a, NULL));

        SET_FOREACH(p, a)
                assert_se(set_put(b, p) >= 0);

        assert_se(set_equal(a, b));
        assert_se(set_equal(b, a));

        assert_se(set_remove(a, INT32_TO_PTR(0x1000U)) == INT32_TO_PTR(0x1000U));

        assert_se(!set_equal(a, b));
        assert_se(!set_equal(b, a));

        assert_se(set_remove(b, INT32_TO_PTR(0x1000U)) == INT32_TO_PTR(0x1000U));

        assert_se(set_equal(a, b));
        assert_se(set_equal(b, a));

        assert_se(set_put(b, INT32_TO_PTR(0x1001U)) >= 0);

        assert_se(!set_equal(a, b));
        assert_se(!set_equal(b, a));

        assert_se(set_put(a, INT32_TO_PTR(0x1001U)) >= 0);

        assert_se(set_equal(a, b));
        assert_se(set_equal(b, a));

        set_clear(a);

        assert_se(!set_equal(a, b));
        assert_se(!set_equal(b, a));

        set_clear(b);

        assert_se(set_equal(a, b));
        assert_se(set_equal(b, a));
}

TEST(set_fnmatch) {
        _cleanup_set_free_ Set *match = NULL, *nomatch = NULL;

        assert_se(set_put_strdup(&match, "aaa") >= 0);
        assert_se(set_put_strdup(&match, "bbb*") >= 0);
        assert_se(set_put_strdup(&match, "*ccc") >= 0);

        assert_se(set_put_strdup(&nomatch, "a*") >= 0);
        assert_se(set_put_strdup(&nomatch, "bbb") >= 0);
        assert_se(set_put_strdup(&nomatch, "ccc*") >= 0);

        assert_se(set_fnmatch(NULL, NULL, ""));
        assert_se(set_fnmatch(NULL, NULL, "hoge"));

        assert_se(set_fnmatch(match, NULL, "aaa"));
        assert_se(set_fnmatch(match, NULL, "bbb"));
        assert_se(set_fnmatch(match, NULL, "bbbXXX"));
        assert_se(set_fnmatch(match, NULL, "ccc"));
        assert_se(set_fnmatch(match, NULL, "XXXccc"));
        assert_se(!set_fnmatch(match, NULL, ""));
        assert_se(!set_fnmatch(match, NULL, "aaaa"));
        assert_se(!set_fnmatch(match, NULL, "XXbbb"));
        assert_se(!set_fnmatch(match, NULL, "cccXX"));

        assert_se(set_fnmatch(NULL, nomatch, ""));
        assert_se(set_fnmatch(NULL, nomatch, "Xa"));
        assert_se(set_fnmatch(NULL, nomatch, "bbbb"));
        assert_se(set_fnmatch(NULL, nomatch, "XXXccc"));
        assert_se(!set_fnmatch(NULL, nomatch, "a"));
        assert_se(!set_fnmatch(NULL, nomatch, "aXXXX"));
        assert_se(!set_fnmatch(NULL, nomatch, "bbb"));
        assert_se(!set_fnmatch(NULL, nomatch, "ccc"));
        assert_se(!set_fnmatch(NULL, nomatch, "cccXXX"));

        assert_se(set_fnmatch(match, nomatch, "bbbbb"));
        assert_se(set_fnmatch(match, nomatch, "XXccc"));
        assert_se(!set_fnmatch(match, nomatch, ""));
        assert_se(!set_fnmatch(match, nomatch, "a"));
        assert_se(!set_fnmatch(match, nomatch, "aaa"));
        assert_se(!set_fnmatch(match, nomatch, "b"));
        assert_se(!set_fnmatch(match, nomatch, "bbb"));
        assert_se(!set_fnmatch(match, nomatch, "ccc"));
        assert_se(!set_fnmatch(match, nomatch, "ccccc"));
        assert_se(!set_fnmatch(match, nomatch, "cccXX"));
}

DEFINE_TEST_MAIN(LOG_INFO);
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
647f6824	2
e4304fb8	3	#include "random-util.h"
647f6824	4	#include "set.h"
ef79eae0	5	#include "strv.h"
4f7452a8	6	#include "tests.h"
647f6824	7
de747a00 ZJS	8	const bool mempool_use_allowed = VALGRIND;
de747a00 ZJS	9
4f7452a8	10	TEST(set_steal_first) {
647f6824 ZJS	11	_cleanup_set_free_ Set *m = NULL;
	12	int seen[3] = {};
	13	char *val;
	14
	15	m = set_new(&string_hash_ops);
	16	assert_se(m);
	17
	18	assert_se(set_put(m, (void*) "1") == 1);
	19	assert_se(set_put(m, (void*) "22") == 1);
	20	assert_se(set_put(m, (void*) "333") == 1);
	21
	22	while ((val = set_steal_first(m)))
	23	seen[strlen(val) - 1]++;
	24
bdf7026e	25	assert_se(seen[0] == 1 && seen[1] == 1 && seen[2] == 1);
647f6824 ZJS	26
	27	assert_se(set_isempty(m));
	28	}
	29
224b0e7a ZJS	30	typedef struct Item {
	31	int seen;
	32	} Item;
	33	static void item_seen(Item *item) {
	34	item->seen++;
	35	}
	36
4f7452a8	37	TEST(set_free_with_destructor) {
224b0e7a ZJS	38	Set *m;
	39	struct Item items[4] = {};
	40	unsigned i;
	41
	42	assert_se(m = set_new(NULL));
	43	for (i = 0; i < ELEMENTSOF(items) - 1; i++)
	44	assert_se(set_put(m, items + i) == 1);
	45
	46	m = set_free_with_destructor(m, item_seen);
	47	assert_se(items[0].seen == 1);
	48	assert_se(items[1].seen == 1);
	49	assert_se(items[2].seen == 1);
	50	assert_se(items[3].seen == 0);
	51	}
	52
98233ee5 YW	53	DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(item_hash_ops, void, trivial_hash_func, trivial_compare_func, Item, item_seen);
98233ee5 YW	54
4f7452a8	55	TEST(set_free_with_hash_ops) {
98233ee5 YW	56	Set *m;
	57	struct Item items[4] = {};
	58	unsigned i;
	59
	60	assert_se(m = set_new(&item_hash_ops));
	61	for (i = 0; i < ELEMENTSOF(items) - 1; i++)
	62	assert_se(set_put(m, items + i) == 1);
	63
	64	m = set_free(m);
	65	assert_se(items[0].seen == 1);
	66	assert_se(items[1].seen == 1);
	67	assert_se(items[2].seen == 1);
	68	assert_se(items[3].seen == 0);
	69	}
	70
4f7452a8	71	TEST(set_put) {
756c09e6 RC	72	_cleanup_set_free_ Set *m = NULL;
	73
	74	m = set_new(&string_hash_ops);
	75	assert_se(m);
	76
	77	assert_se(set_put(m, (void*) "1") == 1);
	78	assert_se(set_put(m, (void*) "22") == 1);
	79	assert_se(set_put(m, (void*) "333") == 1);
	80	assert_se(set_put(m, (void*) "333") == 0);
	81	assert_se(set_remove(m, (void*) "333"));
	82	assert_se(set_put(m, (void*) "333") == 1);
	83	assert_se(set_put(m, (void*) "333") == 0);
	84	assert_se(set_put(m, (void*) "22") == 0);
ef79eae0 ZJS	85
	86	_cleanup_free_ char **t = set_get_strv(m);
	87	assert_se(strv_contains(t, "1"));
	88	assert_se(strv_contains(t, "22"));
	89	assert_se(strv_contains(t, "333"));
	90	assert_se(strv_length(t) == 3);
756c09e6 RC	91	}
756c09e6 RC	92
cb649d12 YW	93	TEST(set_put_strndup) {
	94	_cleanup_set_free_ Set *m = NULL;
	95
	96	assert_se(set_put_strndup(&m, "12345", 0) == 1);
	97	assert_se(set_put_strndup(&m, "12345", 1) == 1);
	98	assert_se(set_put_strndup(&m, "12345", 2) == 1);
	99	assert_se(set_put_strndup(&m, "12345", 3) == 1);
	100	assert_se(set_put_strndup(&m, "12345", 4) == 1);
	101	assert_se(set_put_strndup(&m, "12345", 5) == 1);
	102	assert_se(set_put_strndup(&m, "12345", 6) == 0);
	103
	104	assert_se(set_contains(m, ""));
	105	assert_se(set_contains(m, "1"));
	106	assert_se(set_contains(m, "12"));
	107	assert_se(set_contains(m, "123"));
	108	assert_se(set_contains(m, "1234"));
	109	assert_se(set_contains(m, "12345"));
	110
	111	assert_se(set_size(m) == 6);
	112	}
	113
4f7452a8	114	TEST(set_put_strdup) {
de747a00 ZJS	115	_cleanup_set_free_ Set *m = NULL;
	116
	117	assert_se(set_put_strdup(&m, "aaa") == 1);
	118	assert_se(set_put_strdup(&m, "aaa") == 0);
	119	assert_se(set_put_strdup(&m, "bbb") == 1);
	120	assert_se(set_put_strdup(&m, "bbb") == 0);
	121	assert_se(set_put_strdup(&m, "aaa") == 0);
cb649d12 YW	122
	123	assert_se(set_contains(m, "aaa"));
	124	assert_se(set_contains(m, "bbb"));
	125
de747a00 ZJS	126	assert_se(set_size(m) == 2);
	127	}
	128
4f7452a8	129	TEST(set_put_strdupv) {
de747a00 ZJS	130	_cleanup_set_free_ Set *m = NULL;
	131
	132	assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "aaa")) == 2);
	133	assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "ccc")) == 1);
cb649d12 YW	134
	135	assert_se(set_contains(m, "aaa"));
	136	assert_se(set_contains(m, "bbb"));
	137	assert_se(set_contains(m, "ccc"));
	138
de747a00 ZJS	139	assert_se(set_size(m) == 3);
	140	}
	141
4f7452a8	142	TEST(set_ensure_allocated) {
0f9ccd95 ZJS	143	_cleanup_set_free_ Set *m = NULL;
	144
	145	assert_se(set_ensure_allocated(&m, &string_hash_ops) == 1);
	146	assert_se(set_ensure_allocated(&m, &string_hash_ops) == 0);
	147	assert_se(set_ensure_allocated(&m, NULL) == 0);
	148	assert_se(set_size(m) == 0);
	149	}
	150
4f7452a8	151	TEST(set_copy) {
5ef8b072 MG	152	Set s, copy;
	153	char key1, key2, key3, key4;
	154
5ef8b072 MG	155	key1 = strdup("key1");
	156	assert_se(key1);
	157	key2 = strdup("key2");
	158	assert_se(key2);
	159	key3 = strdup("key3");
	160	assert_se(key3);
	161	key4 = strdup("key4");
	162	assert_se(key4);
	163
	164	s = set_new(&string_hash_ops);
	165	assert_se(s);
	166
	167	assert_se(set_put(s, key1) >= 0);
	168	assert_se(set_put(s, key2) >= 0);
	169	assert_se(set_put(s, key3) >= 0);
	170	assert_se(set_put(s, key4) >= 0);
	171
	172	copy = set_copy(s);
	173	assert_se(copy);
	174
f21b863e	175	assert_se(set_equal(s, copy));
5ef8b072 MG	176
	177	set_free(s);
	178	set_free_free(copy);
	179	}
	180
4f7452a8	181	TEST(set_ensure_put) {
0f9ccd95 ZJS	182	_cleanup_set_free_ Set *m = NULL;
	183
	184	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 1);
	185	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
	186	assert_se(set_ensure_put(&m, NULL, "a") == 0);
	187	assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 1);
	188	assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 0);
	189	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
	190	assert_se(set_size(m) == 2);
	191	}
	192
4f7452a8	193	TEST(set_ensure_consume) {
fcc1d031 ZJS	194	_cleanup_set_free_ Set *m = NULL;
	195	char s, t;
	196
	197	assert_se(s = strdup("a"));
	198	assert_se(set_ensure_consume(&m, &string_hash_ops_free, s) == 1);
	199
	200	assert_se(t = strdup("a"));
	201	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	202
	203	assert_se(t = strdup("a"));
	204	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	205
	206	assert_se(t = strdup("b"));
	207	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 1);
	208
	209	assert_se(t = strdup("b"));
	210	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	211
	212	assert_se(set_size(m) == 2);
	213	}
	214
4f7452a8	215	TEST(set_strjoin) {
4dbce717 YW	216	_cleanup_set_free_ Set *m = NULL;
	217	_cleanup_free_ char *joined = NULL;
	218
8d80f275 YW	219	/* Empty set */
8d80f275 YW	220	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	221	assert_se(!joined);
8d80f275	222	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	223	assert_se(!joined);
8d80f275	224	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
4dbce717	225	assert_se(!joined);
8d80f275 YW	226	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
	227	assert_se(!joined);
	228	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
	229	assert_se(!joined);
	230	assert_se(set_strjoin(m, "", true, &joined) >= 0);
	231	assert_se(!joined);
	232	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	233	assert_se(!joined);
	234	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
4dbce717 YW	235	assert_se(!joined);
4dbce717 YW	236
8d80f275	237	/* Single entry */
4dbce717	238	assert_se(set_put_strdup(&m, "aaa") == 1);
8d80f275	239	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	240	assert_se(streq(joined, "aaa"));
4dbce717	241	joined = mfree(joined);
8d80f275	242	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	243	assert_se(streq(joined, "aaa"));
4dbce717	244	joined = mfree(joined);
8d80f275 YW	245	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
	246	assert_se(streq(joined, "aaa"));
	247	joined = mfree(joined);
	248	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
	249	assert_se(streq(joined, "aaa"));
	250	joined = mfree(joined);
	251	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
4dbce717	252	assert_se(streq(joined, "aaa"));
4dbce717	253	joined = mfree(joined);
8d80f275	254	assert_se(set_strjoin(m, "", true, &joined) >= 0);
4dbce717	255	assert_se(streq(joined, "aaa"));
8d80f275 YW	256	joined = mfree(joined);
	257	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	258	assert_se(streq(joined, " aaa "));
	259	joined = mfree(joined);
	260	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
	261	assert_se(streq(joined, "xxxaaaxxx"));
4dbce717	262
8d80f275	263	/* Two entries */
4dbce717 YW	264	assert_se(set_put_strdup(&m, "bbb") == 1);
4dbce717 YW	265	assert_se(set_put_strdup(&m, "aaa") == 0);
4dbce717	266	joined = mfree(joined);
8d80f275	267	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	268	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
4dbce717	269	joined = mfree(joined);
8d80f275	270	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	271	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
4dbce717	272	joined = mfree(joined);
8d80f275	273	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
4dbce717	274	assert_se(STR_IN_SET(joined, "aaa bbb", "bbb aaa"));
4dbce717	275	joined = mfree(joined);
8d80f275	276	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
4dbce717	277	assert_se(STR_IN_SET(joined, "aaaxxxbbb", "bbbxxxaaa"));
8d80f275 YW	278	joined = mfree(joined);
	279	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
	280	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
	281	joined = mfree(joined);
	282	assert_se(set_strjoin(m, "", true, &joined) >= 0);
	283	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
	284	joined = mfree(joined);
	285	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	286	assert_se(STR_IN_SET(joined, " aaa bbb ", " bbb aaa "));
	287	joined = mfree(joined);
	288	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
	289	assert_se(STR_IN_SET(joined, "xxxaaaxxxbbbxxx", "xxxbbbxxxaaaxxx"));
4dbce717 YW	290	}
4dbce717 YW	291
4f7452a8	292	TEST(set_equal) {
e4304fb8 LP	293	_cleanup_set_free_ Set a = NULL, b = NULL;
	294	void *p;
	295	int r;
	296
	297	assert_se(a = set_new(NULL));
	298	assert_se(b = set_new(NULL));
	299
	300	assert_se(set_equal(a, a));
	301	assert_se(set_equal(b, b));
	302	assert_se(set_equal(a, b));
	303	assert_se(set_equal(b, a));
	304	assert_se(set_equal(NULL, a));
	305	assert_se(set_equal(NULL, b));
	306	assert_se(set_equal(a, NULL));
	307	assert_se(set_equal(b, NULL));
	308	assert_se(set_equal(NULL, NULL));
	309
	310	for (unsigned i = 0; i < 333; i++) {
	311	p = INT32_TO_PTR(1 + (random_u32() & 0xFFFU));
	312
	313	r = set_put(a, p);
	314	assert_se(r >= 0 \|\| r == -EEXIST);
	315	}
	316
	317	assert_se(set_put(a, INT32_TO_PTR(0x1000U)) >= 0);
	318
	319	assert_se(set_size(a) >= 2);
	320	assert_se(set_size(a) <= 334);
	321
	322	assert_se(!set_equal(a, b));
	323	assert_se(!set_equal(b, a));
	324	assert_se(!set_equal(a, NULL));
	325
	326	SET_FOREACH(p, a)
	327	assert_se(set_put(b, p) >= 0);
	328
	329	assert_se(set_equal(a, b));
	330	assert_se(set_equal(b, a));
	331
	332	assert_se(set_remove(a, INT32_TO_PTR(0x1000U)) == INT32_TO_PTR(0x1000U));
	333
	334	assert_se(!set_equal(a, b));
	335	assert_se(!set_equal(b, a));
	336
	337	assert_se(set_remove(b, INT32_TO_PTR(0x1000U)) == INT32_TO_PTR(0x1000U));
	338
	339	assert_se(set_equal(a, b));
	340	assert_se(set_equal(b, a));
	341
	342	assert_se(set_put(b, INT32_TO_PTR(0x1001U)) >= 0);
	343
	344	assert_se(!set_equal(a, b));
	345	assert_se(!set_equal(b, a));
	346
	347	assert_se(set_put(a, INT32_TO_PTR(0x1001U)) >= 0);
	348
	349	assert_se(set_equal(a, b));
	350	assert_se(set_equal(b, a));
	351
	352	set_clear(a);
	353
	354	assert_se(!set_equal(a, b));
	355	assert_se(!set_equal(b, a));
	356
357	set_clear(b);
358
359	assert_se(set_equal(a, b));
360	assert_se(set_equal(b, a));
361	}
362
d25d4f18 YW	363	TEST(set_fnmatch) {
	364	_cleanup_set_free_ Set match = NULL, nomatch = NULL;
	365
	366	assert_se(set_put_strdup(&match, "aaa") >= 0);
	367	assert_se(set_put_strdup(&match, "bbb*") >= 0);
	368	assert_se(set_put_strdup(&match, "*ccc") >= 0);
	369
	370	assert_se(set_put_strdup(&nomatch, "a*") >= 0);
	371	assert_se(set_put_strdup(&nomatch, "bbb") >= 0);
	372	assert_se(set_put_strdup(&nomatch, "ccc*") >= 0);
	373
	374	assert_se(set_fnmatch(NULL, NULL, ""));
	375	assert_se(set_fnmatch(NULL, NULL, "hoge"));
	376
	377	assert_se(set_fnmatch(match, NULL, "aaa"));
	378	assert_se(set_fnmatch(match, NULL, "bbb"));
	379	assert_se(set_fnmatch(match, NULL, "bbbXXX"));
	380	assert_se(set_fnmatch(match, NULL, "ccc"));
	381	assert_se(set_fnmatch(match, NULL, "XXXccc"));
	382	assert_se(!set_fnmatch(match, NULL, ""));
	383	assert_se(!set_fnmatch(match, NULL, "aaaa"));
	384	assert_se(!set_fnmatch(match, NULL, "XXbbb"));
	385	assert_se(!set_fnmatch(match, NULL, "cccXX"));
	386
	387	assert_se(set_fnmatch(NULL, nomatch, ""));
	388	assert_se(set_fnmatch(NULL, nomatch, "Xa"));
	389	assert_se(set_fnmatch(NULL, nomatch, "bbbb"));
	390	assert_se(set_fnmatch(NULL, nomatch, "XXXccc"));
	391	assert_se(!set_fnmatch(NULL, nomatch, "a"));
	392	assert_se(!set_fnmatch(NULL, nomatch, "aXXXX"));
	393	assert_se(!set_fnmatch(NULL, nomatch, "bbb"));
	394	assert_se(!set_fnmatch(NULL, nomatch, "ccc"));
	395	assert_se(!set_fnmatch(NULL, nomatch, "cccXXX"));
	396
	397	assert_se(set_fnmatch(match, nomatch, "bbbbb"));
	398	assert_se(set_fnmatch(match, nomatch, "XXccc"));
	399	assert_se(!set_fnmatch(match, nomatch, ""));
	400	assert_se(!set_fnmatch(match, nomatch, "a"));
	401	assert_se(!set_fnmatch(match, nomatch, "aaa"));
	402	assert_se(!set_fnmatch(match, nomatch, "b"));
	403	assert_se(!set_fnmatch(match, nomatch, "bbb"));
	404	assert_se(!set_fnmatch(match, nomatch, "ccc"));
	405	assert_se(!set_fnmatch(match, nomatch, "ccccc"));
	406	assert_se(!set_fnmatch(match, nomatch, "cccXX"));
	407	}
	408
4f7452a8	409	DEFINE_TEST_MAIN(LOG_INFO);