[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"

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"));
}

static void test_set_equal(void) {
        _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));
}

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();
        test_set_equal();

        return 0;
}
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"
647f6824	6
de747a00 ZJS	7	const bool mempool_use_allowed = VALGRIND;
de747a00 ZJS	8
647f6824 ZJS	9	static void test_set_steal_first(void) {
	10	_cleanup_set_free_ Set *m = NULL;
	11	int seen[3] = {};
	12	char *val;
	13
	14	m = set_new(&string_hash_ops);
	15	assert_se(m);
	16
	17	assert_se(set_put(m, (void*) "1") == 1);
	18	assert_se(set_put(m, (void*) "22") == 1);
	19	assert_se(set_put(m, (void*) "333") == 1);
	20
	21	while ((val = set_steal_first(m)))
	22	seen[strlen(val) - 1]++;
	23
bdf7026e	24	assert_se(seen[0] == 1 && seen[1] == 1 && seen[2] == 1);
647f6824 ZJS	25
	26	assert_se(set_isempty(m));
	27	}
	28
224b0e7a ZJS	29	typedef struct Item {
	30	int seen;
	31	} Item;
	32	static void item_seen(Item *item) {
	33	item->seen++;
	34	}
	35
	36	static void test_set_free_with_destructor(void) {
	37	Set *m;
	38	struct Item items[4] = {};
	39	unsigned i;
	40
	41	assert_se(m = set_new(NULL));
	42	for (i = 0; i < ELEMENTSOF(items) - 1; i++)
	43	assert_se(set_put(m, items + i) == 1);
	44
	45	m = set_free_with_destructor(m, item_seen);
	46	assert_se(items[0].seen == 1);
	47	assert_se(items[1].seen == 1);
	48	assert_se(items[2].seen == 1);
	49	assert_se(items[3].seen == 0);
	50	}
	51
98233ee5 YW	52	DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(item_hash_ops, void, trivial_hash_func, trivial_compare_func, Item, item_seen);
	53
	54	static void test_set_free_with_hash_ops(void) {
	55	Set *m;
	56	struct Item items[4] = {};
	57	unsigned i;
	58
	59	assert_se(m = set_new(&item_hash_ops));
	60	for (i = 0; i < ELEMENTSOF(items) - 1; i++)
	61	assert_se(set_put(m, items + i) == 1);
	62
	63	m = set_free(m);
	64	assert_se(items[0].seen == 1);
	65	assert_se(items[1].seen == 1);
	66	assert_se(items[2].seen == 1);
	67	assert_se(items[3].seen == 0);
	68	}
	69
756c09e6 RC	70	static void test_set_put(void) {
	71	_cleanup_set_free_ Set *m = NULL;
	72
	73	m = set_new(&string_hash_ops);
	74	assert_se(m);
	75
	76	assert_se(set_put(m, (void*) "1") == 1);
	77	assert_se(set_put(m, (void*) "22") == 1);
	78	assert_se(set_put(m, (void*) "333") == 1);
	79	assert_se(set_put(m, (void*) "333") == 0);
	80	assert_se(set_remove(m, (void*) "333"));
	81	assert_se(set_put(m, (void*) "333") == 1);
	82	assert_se(set_put(m, (void*) "333") == 0);
	83	assert_se(set_put(m, (void*) "22") == 0);
ef79eae0 ZJS	84
	85	_cleanup_free_ char **t = set_get_strv(m);
	86	assert_se(strv_contains(t, "1"));
	87	assert_se(strv_contains(t, "22"));
	88	assert_se(strv_contains(t, "333"));
	89	assert_se(strv_length(t) == 3);
756c09e6 RC	90	}
756c09e6 RC	91
de747a00 ZJS	92	static void test_set_put_strdup(void) {
	93	_cleanup_set_free_ Set *m = NULL;
	94
	95	assert_se(set_put_strdup(&m, "aaa") == 1);
	96	assert_se(set_put_strdup(&m, "aaa") == 0);
	97	assert_se(set_put_strdup(&m, "bbb") == 1);
	98	assert_se(set_put_strdup(&m, "bbb") == 0);
	99	assert_se(set_put_strdup(&m, "aaa") == 0);
	100	assert_se(set_size(m) == 2);
	101	}
	102
	103	static void test_set_put_strdupv(void) {
	104	_cleanup_set_free_ Set *m = NULL;
	105
	106	assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "aaa")) == 2);
	107	assert_se(set_put_strdupv(&m, STRV_MAKE("aaa", "aaa", "bbb", "bbb", "ccc")) == 1);
	108	assert_se(set_size(m) == 3);
	109	}
	110
0f9ccd95 ZJS	111	static void test_set_ensure_allocated(void) {
	112	_cleanup_set_free_ Set *m = NULL;
	113
	114	assert_se(set_ensure_allocated(&m, &string_hash_ops) == 1);
	115	assert_se(set_ensure_allocated(&m, &string_hash_ops) == 0);
	116	assert_se(set_ensure_allocated(&m, NULL) == 0);
	117	assert_se(set_size(m) == 0);
	118	}
	119
	120	static void test_set_ensure_put(void) {
	121	_cleanup_set_free_ Set *m = NULL;
	122
	123	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 1);
	124	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
	125	assert_se(set_ensure_put(&m, NULL, "a") == 0);
	126	assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 1);
	127	assert_se(set_ensure_put(&m, &string_hash_ops, "b") == 0);
	128	assert_se(set_ensure_put(&m, &string_hash_ops, "a") == 0);
	129	assert_se(set_size(m) == 2);
	130	}
	131
fcc1d031 ZJS	132	static void test_set_ensure_consume(void) {
	133	_cleanup_set_free_ Set *m = NULL;
	134	char s, t;
	135
	136	assert_se(s = strdup("a"));
	137	assert_se(set_ensure_consume(&m, &string_hash_ops_free, s) == 1);
	138
	139	assert_se(t = strdup("a"));
	140	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	141
	142	assert_se(t = strdup("a"));
	143	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	144
	145	assert_se(t = strdup("b"));
	146	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 1);
	147
	148	assert_se(t = strdup("b"));
	149	assert_se(set_ensure_consume(&m, &string_hash_ops_free, t) == 0);
	150
	151	assert_se(set_size(m) == 2);
	152	}
	153
4dbce717 YW	154	static void test_set_strjoin(void) {
	155	_cleanup_set_free_ Set *m = NULL;
	156	_cleanup_free_ char *joined = NULL;
	157
8d80f275 YW	158	/* Empty set */
8d80f275 YW	159	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	160	assert_se(!joined);
8d80f275	161	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	162	assert_se(!joined);
8d80f275	163	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
4dbce717	164	assert_se(!joined);
8d80f275 YW	165	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
	166	assert_se(!joined);
	167	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
	168	assert_se(!joined);
	169	assert_se(set_strjoin(m, "", true, &joined) >= 0);
	170	assert_se(!joined);
	171	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	172	assert_se(!joined);
	173	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
4dbce717 YW	174	assert_se(!joined);
4dbce717 YW	175
8d80f275	176	/* Single entry */
4dbce717	177	assert_se(set_put_strdup(&m, "aaa") == 1);
8d80f275	178	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	179	assert_se(streq(joined, "aaa"));
4dbce717	180	joined = mfree(joined);
8d80f275	181	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	182	assert_se(streq(joined, "aaa"));
4dbce717	183	joined = mfree(joined);
8d80f275 YW	184	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
	185	assert_se(streq(joined, "aaa"));
	186	joined = mfree(joined);
	187	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
	188	assert_se(streq(joined, "aaa"));
	189	joined = mfree(joined);
	190	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
4dbce717	191	assert_se(streq(joined, "aaa"));
4dbce717	192	joined = mfree(joined);
8d80f275	193	assert_se(set_strjoin(m, "", true, &joined) >= 0);
4dbce717	194	assert_se(streq(joined, "aaa"));
8d80f275 YW	195	joined = mfree(joined);
	196	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	197	assert_se(streq(joined, " aaa "));
	198	joined = mfree(joined);
	199	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
	200	assert_se(streq(joined, "xxxaaaxxx"));
4dbce717	201
8d80f275	202	/* Two entries */
4dbce717 YW	203	assert_se(set_put_strdup(&m, "bbb") == 1);
4dbce717 YW	204	assert_se(set_put_strdup(&m, "aaa") == 0);
4dbce717	205	joined = mfree(joined);
8d80f275	206	assert_se(set_strjoin(m, NULL, false, &joined) >= 0);
4dbce717	207	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
4dbce717	208	joined = mfree(joined);
8d80f275	209	assert_se(set_strjoin(m, "", false, &joined) >= 0);
4dbce717	210	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
4dbce717	211	joined = mfree(joined);
8d80f275	212	assert_se(set_strjoin(m, " ", false, &joined) >= 0);
4dbce717	213	assert_se(STR_IN_SET(joined, "aaa bbb", "bbb aaa"));
4dbce717	214	joined = mfree(joined);
8d80f275	215	assert_se(set_strjoin(m, "xxx", false, &joined) >= 0);
4dbce717	216	assert_se(STR_IN_SET(joined, "aaaxxxbbb", "bbbxxxaaa"));
8d80f275 YW	217	joined = mfree(joined);
	218	assert_se(set_strjoin(m, NULL, true, &joined) >= 0);
	219	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
	220	joined = mfree(joined);
	221	assert_se(set_strjoin(m, "", true, &joined) >= 0);
	222	assert_se(STR_IN_SET(joined, "aaabbb", "bbbaaa"));
	223	joined = mfree(joined);
	224	assert_se(set_strjoin(m, " ", true, &joined) >= 0);
	225	assert_se(STR_IN_SET(joined, " aaa bbb ", " bbb aaa "));
	226	joined = mfree(joined);
	227	assert_se(set_strjoin(m, "xxx", true, &joined) >= 0);
	228	assert_se(STR_IN_SET(joined, "xxxaaaxxxbbbxxx", "xxxbbbxxxaaaxxx"));
4dbce717 YW	229	}
4dbce717 YW	230
e4304fb8 LP	231	static void test_set_equal(void) {
	232	_cleanup_set_free_ Set a = NULL, b = NULL;
	233	void *p;
	234	int r;
	235
	236	assert_se(a = set_new(NULL));
	237	assert_se(b = set_new(NULL));
	238
	239	assert_se(set_equal(a, a));
	240	assert_se(set_equal(b, b));
	241	assert_se(set_equal(a, b));
	242	assert_se(set_equal(b, a));
	243	assert_se(set_equal(NULL, a));
	244	assert_se(set_equal(NULL, b));
	245	assert_se(set_equal(a, NULL));
	246	assert_se(set_equal(b, NULL));
	247	assert_se(set_equal(NULL, NULL));
	248
	249	for (unsigned i = 0; i < 333; i++) {
	250	p = INT32_TO_PTR(1 + (random_u32() & 0xFFFU));
	251
	252	r = set_put(a, p);
	253	assert_se(r >= 0 \|\| r == -EEXIST);
	254	}
	255
	256	assert_se(set_put(a, INT32_TO_PTR(0x1000U)) >= 0);
	257
	258	assert_se(set_size(a) >= 2);
	259	assert_se(set_size(a) <= 334);
	260
	261	assert_se(!set_equal(a, b));
	262	assert_se(!set_equal(b, a));
	263	assert_se(!set_equal(a, NULL));
	264
	265	SET_FOREACH(p, a)
	266	assert_se(set_put(b, p) >= 0);
	267
	268	assert_se(set_equal(a, b));
	269	assert_se(set_equal(b, a));
	270
	271	assert_se(set_remove(a, INT32_TO_PTR(0x1000U)) == INT32_TO_PTR(0x1000U));
	272
	273	assert_se(!set_equal(a, b));
	274	assert_se(!set_equal(b, a));
	275
	276	assert_se(set_remove(b, INT32_TO_PTR(0x1000U)) == INT32_TO_PTR(0x1000U));
	277
	278	assert_se(set_equal(a, b));
	279	assert_se(set_equal(b, a));
	280
	281	assert_se(set_put(b, INT32_TO_PTR(0x1001U)) >= 0);
	282
	283	assert_se(!set_equal(a, b));
	284	assert_se(!set_equal(b, a));
	285
	286	assert_se(set_put(a, INT32_TO_PTR(0x1001U)) >= 0);
	287
	288	assert_se(set_equal(a, b));
	289	assert_se(set_equal(b, a));
	290
	291	set_clear(a);
	292
	293	assert_se(!set_equal(a, b));
	294	assert_se(!set_equal(b, a));
295
296	set_clear(b);
297
298	assert_se(set_equal(a, b));
299	assert_se(set_equal(b, a));
300	}
301
647f6824 ZJS	302	int main(int argc, const char *argv[]) {
647f6824 ZJS	303	test_set_steal_first();
224b0e7a	304	test_set_free_with_destructor();
98233ee5	305	test_set_free_with_hash_ops();
756c09e6	306	test_set_put();
de747a00 ZJS	307	test_set_put_strdup();
de747a00 ZJS	308	test_set_put_strdupv();
0f9ccd95 ZJS	309	test_set_ensure_allocated();
0f9ccd95 ZJS	310	test_set_ensure_put();
fcc1d031	311	test_set_ensure_consume();
4dbce717	312	test_set_strjoin();
e4304fb8	313	test_set_equal();
647f6824 ZJS	314
	315	return 0;
	316	}