testsuite: replace assert_return with TS_ASSERT

Mechanical change, done with:

sed -i  "s/assert_return/TS_ASSERT/;s/, EXIT_FAILURE//" testsuite/*.c

In addition, manually fixup the two multiline instances (test-strbuf.c
and test-util.c) and remove the no longer used macro.

Signed-off-by: Emil Velikov <emil.l.velikov@gmail.com>
Link: https://github.com/kmod-project/kmod/pull/375
Signed-off-by: Lucas De Marchi <ldemarchi@kernel.org>

diff --git a/testsuite/test-array.c b/testsuite/test-array.c
index 6e1f689666cccc40157e198d78a0d2e4aa9e6b07..7cd3e7ae421168219d7757b1c501f962d694c52e 100644 (file)
--- a/testsuite/test-array.c
+++ b/testsuite/test-array.c
@@ -20,8 +20,8 @@ static int test_array_append1(void)
 
        array_init(&array, 2);
        array_append(&array, c1);
-       assert_return(array.count == 1, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
+       TS_ASSERT(array.count == 1);
+       TS_ASSERT(array.array[0] == c1);
        array_free_array(&array);
 
        return 0;
@@ -39,10 +39,10 @@ static int test_array_append2(void)
        array_append(&array, c1);
        array_append(&array, c2);
        array_append(&array, c3);
-       assert_return(array.count == 3, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
-       assert_return(array.array[1] == c2, EXIT_FAILURE);
-       assert_return(array.array[2] == c3, EXIT_FAILURE);
+       TS_ASSERT(array.count == 3);
+       TS_ASSERT(array.array[0] == c1);
+       TS_ASSERT(array.array[1] == c2);
+       TS_ASSERT(array.array[2] == c3);
        array_free_array(&array);
 
        return 0;
@@ -63,10 +63,10 @@ static int test_array_append_unique(void)
        array_append_unique(&array, c3);
        array_append_unique(&array, c2);
        array_append_unique(&array, c1);
-       assert_return(array.count == 3, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
-       assert_return(array.array[1] == c2, EXIT_FAILURE);
-       assert_return(array.array[2] == c3, EXIT_FAILURE);
+       TS_ASSERT(array.count == 3);
+       TS_ASSERT(array.array[0] == c1);
+       TS_ASSERT(array.array[1] == c2);
+       TS_ASSERT(array.array[2] == c3);
        array_free_array(&array);
 
        return 0;
@@ -96,13 +96,13 @@ static int test_array_sort(void)
        array_append(&array, c3);
        array_append(&array, c1);
        array_sort(&array, strptrcmp);
-       assert_return(array.count == 6, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
-       assert_return(array.array[1] == c1, EXIT_FAILURE);
-       assert_return(array.array[2] == c2, EXIT_FAILURE);
-       assert_return(array.array[3] == c2, EXIT_FAILURE);
-       assert_return(array.array[4] == c3, EXIT_FAILURE);
-       assert_return(array.array[5] == c3, EXIT_FAILURE);
+       TS_ASSERT(array.count == 6);
+       TS_ASSERT(array.array[0] == c1);
+       TS_ASSERT(array.array[1] == c1);
+       TS_ASSERT(array.array[2] == c2);
+       TS_ASSERT(array.array[3] == c2);
+       TS_ASSERT(array.array[4] == c3);
+       TS_ASSERT(array.array[5] == c3);
        array_free_array(&array);
 
        return 0;
@@ -122,29 +122,29 @@ static int test_array_remove_at(void)
        array_append(&array, c3);
 
        array_remove_at(&array, 2);
-       assert_return(array.count == 2, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
-       assert_return(array.array[1] == c2, EXIT_FAILURE);
-       assert_return(array.total == 4, EXIT_FAILURE);
+       TS_ASSERT(array.count == 2);
+       TS_ASSERT(array.array[0] == c1);
+       TS_ASSERT(array.array[1] == c2);
+       TS_ASSERT(array.total == 4);
 
        array_remove_at(&array, 0);
-       assert_return(array.count == 1, EXIT_FAILURE);
-       assert_return(array.array[0] == c2, EXIT_FAILURE);
-       assert_return(array.total == 2, EXIT_FAILURE);
+       TS_ASSERT(array.count == 1);
+       TS_ASSERT(array.array[0] == c2);
+       TS_ASSERT(array.total == 2);
 
        array_remove_at(&array, 0);
-       assert_return(array.count == 0, EXIT_FAILURE);
-       assert_return(array.total == 2, EXIT_FAILURE);
+       TS_ASSERT(array.count == 0);
+       TS_ASSERT(array.total == 2);
 
        array_append(&array, c1);
        array_append(&array, c2);
        array_append(&array, c3);
 
        array_remove_at(&array, 1);
-       assert_return(array.count == 2, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
-       assert_return(array.array[1] == c3, EXIT_FAILURE);
-       assert_return(array.total == 4, EXIT_FAILURE);
+       TS_ASSERT(array.count == 2);
+       TS_ASSERT(array.array[0] == c1);
+       TS_ASSERT(array.array[1] == c3);
+       TS_ASSERT(array.total == 4);
 
        array_free_array(&array);
 
@@ -166,18 +166,18 @@ static int test_array_pop(void)
 
        array_pop(&array);
 
-       assert_return(array.count == 2, EXIT_FAILURE);
-       assert_return(array.array[0] == c1, EXIT_FAILURE);
-       assert_return(array.array[1] == c2, EXIT_FAILURE);
+       TS_ASSERT(array.count == 2);
+       TS_ASSERT(array.array[0] == c1);
+       TS_ASSERT(array.array[1] == c2);
 
        array_pop(&array);
        array_pop(&array);
 
-       assert_return(array.count == 0, EXIT_FAILURE);
+       TS_ASSERT(array.count == 0);
 
        array_pop(&array);
 
-       assert_return(array.count == 0, EXIT_FAILURE);
+       TS_ASSERT(array.count == 0);
 
        array_free_array(&array);
 

diff --git a/testsuite/test-hash.c b/testsuite/test-hash.c
index 810e7d2c8435428f20aa7bbbb41bf6663f5ed3cb..b21db727145907d46604d3cf5ad030ade440fbb6 100644 (file)
--- a/testsuite/test-hash.c
+++ b/testsuite/test-hash.c
@@ -25,7 +25,7 @@ static void countfreecalls(_maybe_unused_ void *v)
 static int test_hash_new(void)
 {
        struct hash *h = hash_new(8, NULL);
-       assert_return(h != NULL, EXIT_FAILURE);
+       TS_ASSERT(h != NULL);
        hash_free(h);
        return 0;
 }
@@ -41,7 +41,7 @@ static int test_hash_get_count(void)
        hash_add(h, k2, v2);
        hash_add(h, k3, v3);
 
-       assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+       TS_ASSERT(hash_get_count(h) == 3);
 
        hash_free(h);
        return 0;
@@ -63,13 +63,13 @@ static int test_hash_replace(void)
        /* replace v1 */
        r |= hash_add(h, k1, v4);
 
-       assert_return(r == 0, EXIT_FAILURE);
-       assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+       TS_ASSERT(r == 0);
+       TS_ASSERT(hash_get_count(h) == 3);
 
        v = hash_find(h, "k1");
-       assert_return(streq(v, v4), EXIT_FAILURE);
+       TS_ASSERT(streq(v, v4));
 
-       assert_return(freecount == 1, EXIT_FAILURE);
+       TS_ASSERT(freecount == 1);
 
        hash_free(h);
        return 0;
@@ -88,17 +88,17 @@ static int test_hash_replace_failing(void)
        r |= hash_add(h, k2, v2);
        r |= hash_add(h, k3, v3);
 
-       assert_return(r == 0, EXIT_FAILURE);
+       TS_ASSERT(r == 0);
 
        /* replace v1 */
        r = hash_add_unique(h, k1, v4);
-       assert_return(r != 0, EXIT_FAILURE);
-       assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+       TS_ASSERT(r != 0);
+       TS_ASSERT(hash_get_count(h) == 3);
 
        v = hash_find(h, "k1");
-       assert_return(streq(v, v1), EXIT_FAILURE);
+       TS_ASSERT(streq(v, v1));
 
-       assert_return(freecount == 0, EXIT_FAILURE);
+       TS_ASSERT(freecount == 0);
 
        hash_free(h);
        return 0;
@@ -124,12 +124,12 @@ static int test_hash_iter(void)
 
        for (hash_iter_init(h, &iter); hash_iter_next(&iter, &k, (const void **)&v);) {
                v2 = hash_find(h2, k);
-               assert_return(v2 != NULL, EXIT_FAILURE);
+               TS_ASSERT(v2 != NULL);
                hash_del(h2, k);
        }
 
-       assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
-       assert_return(hash_get_count(h2) == 0, EXIT_FAILURE);
+       TS_ASSERT(hash_get_count(h) == 3);
+       TS_ASSERT(hash_get_count(h2) == 0);
 
        hash_free(h);
        hash_free(h2);
@@ -157,12 +157,12 @@ static int test_hash_iter_after_del(void)
 
        for (hash_iter_init(h, &iter); hash_iter_next(&iter, &k, (const void **)&v);) {
                v2 = hash_find(h2, k);
-               assert_return(v2 != NULL, EXIT_FAILURE);
+               TS_ASSERT(v2 != NULL);
                hash_del(h2, k);
        }
 
-       assert_return(hash_get_count(h) == 2, EXIT_FAILURE);
-       assert_return(hash_get_count(h2) == 1, EXIT_FAILURE);
+       TS_ASSERT(hash_get_count(h) == 2);
+       TS_ASSERT(hash_get_count(h2) == 1);
 
        hash_free(h);
        hash_free(h2);
@@ -193,7 +193,7 @@ static int test_hash_del_nonexistent(void)
        int rc;
 
        rc = hash_del(h, k1);
-       assert_return(rc == -ENOENT, EXIT_FAILURE);
+       TS_ASSERT(rc == -ENOENT);
 
        hash_free(h);
 
@@ -214,13 +214,13 @@ static int test_hash_free(void)
 
        hash_del(h, k1);
 
-       assert_return(freecount == 1, EXIT_FAILURE);
+       TS_ASSERT(freecount == 1);
 
-       assert_return(hash_get_count(h) == 2, EXIT_FAILURE);
+       TS_ASSERT(hash_get_count(h) == 2);
 
        hash_free(h);
 
-       assert_return(freecount == 3, EXIT_FAILURE);
+       TS_ASSERT(freecount == 3);
 
        return 0;
 }
@@ -244,7 +244,7 @@ static int test_hash_add_unique(void)
                        hash_add_unique(h, k[idx], v[idx]);
                }
 
-               assert_return(hash_get_count(h) == N, EXIT_FAILURE);
+               TS_ASSERT(hash_get_count(h) == N);
                hash_free(h);
        }
        return 0;
@@ -268,7 +268,7 @@ static int test_hash_massive_add_del(void)
                k += 8;
        }
 
-       assert_return(hash_get_count(h) == N, EXIT_FAILURE);
+       TS_ASSERT(hash_get_count(h) == N);
 
        k = &buf[0];
        for (i = 0; i < N; i++) {
@@ -276,7 +276,7 @@ static int test_hash_massive_add_del(void)
                k += 8;
        }
 
-       assert_return(hash_get_count(h) == 0, EXIT_FAILURE);
+       TS_ASSERT(hash_get_count(h) == 0);
 
        hash_free(h);
        return 0;

diff --git a/testsuite/test-list.c b/testsuite/test-list.c
index 70f92545cf6a7611c5f3004405fd6c2e7485229b..793235cce82303a759520d262a2bf12e757e52a3 100644 (file)
--- a/testsuite/test-list.c
+++ b/testsuite/test-list.c
@@ -36,10 +36,10 @@ static int test_list_last(void)
 
        for (i = 0; i < N; i++)
                list = kmod_list_append(list, v[i]);
-       assert_return(len(list) == N, EXIT_FAILURE);
+       TS_ASSERT(len(list) == N);
 
        last = kmod_list_last(list);
-       assert_return(last->data == v[N - 1], EXIT_FAILURE);
+       TS_ASSERT(last->data == v[N - 1]);
 
        kmod_list_remove_all(list);
 
@@ -55,19 +55,19 @@ static int test_list_prev(void)
        const int N = ARRAY_SIZE(v);
 
        l = kmod_list_prev(list, list);
-       assert_return(l == NULL, EXIT_FAILURE);
+       TS_ASSERT(l == NULL);
 
        for (i = 0; i < N; i++)
                list = kmod_list_append(list, v[i]);
 
        l = kmod_list_prev(list, list);
-       assert_return(l == NULL, EXIT_FAILURE);
+       TS_ASSERT(l == NULL);
 
        l = list;
        for (i = 0; i < N - 1; i++) {
                l = kmod_list_next(list, l);
                p = kmod_list_prev(list, l);
-               assert_return(p->data == v[i], EXIT_FAILURE);
+               TS_ASSERT(p->data == v[i]);
        }
 
        kmod_list_remove_all(list);
@@ -89,10 +89,10 @@ static int test_list_remove_data(void)
 
        removed = v[N / 2];
        list = kmod_list_remove_data(list, removed);
-       assert_return(len(list) == N - 1, EXIT_FAILURE);
+       TS_ASSERT(len(list) == N - 1);
 
        kmod_list_foreach(l, list)
-               assert_return(l->data != removed, EXIT_FAILURE);
+               TS_ASSERT(l->data != removed);
 
        kmod_list_remove_all(list);
 
@@ -110,24 +110,24 @@ static int test_list_append_list(void)
 
        for (i = 0; i < M; i++)
                a = kmod_list_append(a, v[i]);
-       assert_return(len(a) == M, EXIT_FAILURE);
+       TS_ASSERT(len(a) == M);
 
        for (i = M; i < N; i++)
                b = kmod_list_append(b, v[i]);
-       assert_return(len(b) == N - M, EXIT_FAILURE);
+       TS_ASSERT(len(b) == N - M);
 
        a = kmod_list_append_list(a, NULL);
-       assert_return(len(a) == M, EXIT_FAILURE);
+       TS_ASSERT(len(a) == M);
 
        b = kmod_list_append_list(NULL, b);
-       assert_return(len(b) == N - M, EXIT_FAILURE);
+       TS_ASSERT(len(b) == N - M);
 
        c = kmod_list_append_list(a, b);
-       assert_return(len(c) == N, EXIT_FAILURE);
+       TS_ASSERT(len(c) == N);
 
        i = 0;
        kmod_list_foreach(l, c) {
-               assert_return(l->data == v[i], EXIT_FAILURE);
+               TS_ASSERT(l->data == v[i]);
                i++;
        }
 
@@ -144,27 +144,27 @@ static int test_list_insert_before(void)
        const char *v1 = "v1", *v2 = "v2", *v3 = "v3", *vx = "vx";
 
        list = kmod_list_insert_before(list, v3);
-       assert_return(len(list) == 1, EXIT_FAILURE);
+       TS_ASSERT(len(list) == 1);
 
        list = kmod_list_insert_before(list, v2);
        list = kmod_list_insert_before(list, v1);
-       assert_return(len(list) == 3, EXIT_FAILURE);
+       TS_ASSERT(len(list) == 3);
 
        l = list;
-       assert_return(l->data == v1, EXIT_FAILURE);
+       TS_ASSERT(l->data == v1);
 
        l = kmod_list_next(list, l);
-       assert_return(l->data == v2, EXIT_FAILURE);
+       TS_ASSERT(l->data == v2);
 
        l = kmod_list_insert_before(l, vx);
-       assert_return(len(list) == 4, EXIT_FAILURE);
-       assert_return(l->data == vx, EXIT_FAILURE);
+       TS_ASSERT(len(list) == 4);
+       TS_ASSERT(l->data == vx);
 
        l = kmod_list_next(list, l);
-       assert_return(l->data == v2, EXIT_FAILURE);
+       TS_ASSERT(l->data == v2);
 
        l = kmod_list_next(list, l);
-       assert_return(l->data == v3, EXIT_FAILURE);
+       TS_ASSERT(l->data == v3);
 
        kmod_list_remove_all(list);
 
@@ -179,27 +179,27 @@ static int test_list_insert_after(void)
        const char *v1 = "v1", *v2 = "v2", *v3 = "v3", *vx = "vx";
 
        list = kmod_list_insert_after(list, v1);
-       assert_return(len(list) == 1, EXIT_FAILURE);
+       TS_ASSERT(len(list) == 1);
 
        list = kmod_list_insert_after(list, v3);
        list = kmod_list_insert_after(list, v2);
-       assert_return(len(list) == 3, EXIT_FAILURE);
+       TS_ASSERT(len(list) == 3);
 
        l = list;
-       assert_return(l->data == v1, EXIT_FAILURE);
+       TS_ASSERT(l->data == v1);
 
        l = kmod_list_insert_after(l, vx);
-       assert_return(len(list) == 4, EXIT_FAILURE);
-       assert_return(l->data == v1, EXIT_FAILURE);
+       TS_ASSERT(len(list) == 4);
+       TS_ASSERT(l->data == v1);
 
        l = kmod_list_next(list, l);
-       assert_return(l->data == vx, EXIT_FAILURE);
+       TS_ASSERT(l->data == vx);
 
        l = kmod_list_next(list, l);
-       assert_return(l->data == v2, EXIT_FAILURE);
+       TS_ASSERT(l->data == v2);
 
        l = kmod_list_next(list, l);
-       assert_return(l->data == v3, EXIT_FAILURE);
+       TS_ASSERT(l->data == v3);
 
        kmod_list_remove_all(list);
 

diff --git a/testsuite/test-strbuf.c b/testsuite/test-strbuf.c
index 0be7148f7e116d72e11357c21fedee5263540ef8..5b944701ff1e2fbd2b59d7632b146c13150a8c03 100644 (file)
--- a/testsuite/test-strbuf.c
+++ b/testsuite/test-strbuf.c
@@ -29,8 +29,8 @@ static int test_strbuf_pushchar(void)
                strbuf_pushchar(&buf, *c);
 
        result = strbuf_str(&buf);
-       assert_return(result == buf.bytes, EXIT_FAILURE);
-       assert_return(streq(result, TEXT), EXIT_FAILURE);
+       TS_ASSERT(result == buf.bytes);
+       TS_ASSERT(streq(result, TEXT));
 
        return 0;
 }
@@ -60,15 +60,14 @@ static int test_strbuf_pushchars(void)
         */
        strbuf_popchar(&buf);
        result = strbuf_str(&buf);
-       assert_return(result == buf.bytes, EXIT_FAILURE);
-       assert_return(streq(result, TEXT), EXIT_FAILURE);
+       TS_ASSERT(result == buf.bytes);
+       TS_ASSERT(streq(result, TEXT));
 
        strbuf_popchars(&buf, lastwordlen);
        result = strbuf_str(&buf);
-       assert_return(!streq(TEXT, result), EXIT_FAILURE);
-       assert_return(strncmp(TEXT, result, strlen(TEXT) - lastwordlen) == 0,
-                     EXIT_FAILURE);
-       assert_return(result[strlen(TEXT) - lastwordlen] == '\0', EXIT_FAILURE);
+       TS_ASSERT(!streq(TEXT, result));
+       TS_ASSERT(strncmp(TEXT, result, strlen(TEXT) - lastwordlen) == 0);
+       TS_ASSERT(result[strlen(TEXT) - lastwordlen] == '\0');
 
        free(str);
 
@@ -87,15 +86,15 @@ static int test_strbuf_with_stack(void)
        DECLARE_STRBUF_WITH_STACK(buf3, sizeof(test) + 1);
 
        strbuf_pushchars(&buf, test);
-       assert_return(streq(test, strbuf_str(&buf)), EXIT_FAILURE);
+       TS_ASSERT(streq(test, strbuf_str(&buf)));
        p = strbuf_str(&buf);
-       assert_return(streq(test, p), EXIT_FAILURE);
+       TS_ASSERT(streq(test, p));
 
        strbuf_pushchars(&buf2, test);
-       assert_return(streq(test, strbuf_str(&buf2)), EXIT_FAILURE);
+       TS_ASSERT(streq(test, strbuf_str(&buf2)));
        /* It fits on stack, but when we steal, we get a copy on heap */
        p = strbuf_str(&buf2);
-       assert_return(streq(test, p), EXIT_FAILURE);
+       TS_ASSERT(streq(test, p));
 
        /*
         * Check assumption about buffer being on stack vs heap is indeed valid.
@@ -104,13 +103,13 @@ static int test_strbuf_with_stack(void)
        strbuf_clear(&buf3);
        stack_buf = buf3.bytes;
        strbuf_pushchars(&buf3, test);
-       assert_return(stack_buf == buf3.bytes, EXIT_FAILURE);
+       TS_ASSERT(stack_buf == buf3.bytes);
 
-       assert_return(streq(test, strbuf_str(&buf3)), EXIT_FAILURE);
-       assert_return(stack_buf == buf3.bytes, EXIT_FAILURE);
+       TS_ASSERT(streq(test, strbuf_str(&buf3)));
+       TS_ASSERT(stack_buf == buf3.bytes);
 
        strbuf_pushchars(&buf3, "-overflow");
-       assert_return(stack_buf != buf3.bytes, EXIT_FAILURE);
+       TS_ASSERT(stack_buf != buf3.bytes);
 
        return 0;
 }
@@ -120,13 +119,13 @@ static int test_strbuf_with_heap(void)
 {
        DECLARE_STRBUF(heapbuf);
 
-       assert_return(heapbuf.bytes == NULL, EXIT_FAILURE);
-       assert_return(heapbuf.size == 0, EXIT_FAILURE);
-       assert_return(heapbuf.used == 0, EXIT_FAILURE);
+       TS_ASSERT(heapbuf.bytes == NULL);
+       TS_ASSERT(heapbuf.size == 0);
+       TS_ASSERT(heapbuf.used == 0);
        strbuf_pushchars(&heapbuf, "-overflow");
-       assert_return(heapbuf.bytes != NULL, EXIT_FAILURE);
-       assert_return(heapbuf.size != 0, EXIT_FAILURE);
-       assert_return(heapbuf.used != 0, EXIT_FAILURE);
+       TS_ASSERT(heapbuf.bytes != NULL);
+       TS_ASSERT(heapbuf.size != 0);
+       TS_ASSERT(heapbuf.used != 0);
 
        return 0;
 }
@@ -140,7 +139,7 @@ static int test_strbuf_pushmem(void)
        strbuf_pushmem(&buf, "", 0);
        strbuf_pushmem(&buf, TEXT, strlen(TEXT) + 1);
 
-       assert_return(streq(TEXT, strbuf_str(&buf)), EXIT_FAILURE);
+       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
 
        return 0;
 }
@@ -151,21 +150,21 @@ static int test_strbuf_used(void)
        _cleanup_strbuf_ struct strbuf buf;
 
        strbuf_init(&buf);
-       assert_return(strbuf_used(&buf) == 0, EXIT_FAILURE);
+       TS_ASSERT(strbuf_used(&buf) == 0);
 
        strbuf_pushchars(&buf, TEXT);
-       assert_return(strbuf_used(&buf) == strlen(TEXT), EXIT_FAILURE);
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
 
        strbuf_pushchar(&buf, 'a');
        strbuf_popchar(&buf);
-       assert_return(strbuf_used(&buf) == strlen(TEXT), EXIT_FAILURE);
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
 
-       assert_return(streq(TEXT, strbuf_str(&buf)), EXIT_FAILURE);
-       assert_return(strbuf_used(&buf) == strlen(TEXT), EXIT_FAILURE);
+       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
 
        strbuf_pushchar(&buf, '\0');
-       assert_return(streq(TEXT, strbuf_str(&buf)), EXIT_FAILURE);
-       assert_return(strbuf_used(&buf) == strlen(TEXT) + 1, EXIT_FAILURE);
+       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT) + 1);
 
        return 0;
 }
@@ -177,11 +176,11 @@ static int test_strbuf_shrink_to(void)
 
        strbuf_init(&buf);
        strbuf_shrink_to(&buf, 0);
-       assert_return(strbuf_used(&buf) == 0, EXIT_FAILURE);
+       TS_ASSERT(strbuf_used(&buf) == 0);
 
        strbuf_pushchars(&buf, TEXT);
        strbuf_shrink_to(&buf, strlen(TEXT) - 1);
-       assert_return(strbuf_used(&buf) == strlen(TEXT) - 1, EXIT_FAILURE);
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT) - 1);
 
        return 0;
 }

diff --git a/testsuite/test-util.c b/testsuite/test-util.c
index eeefa3e0c6f05bef0c6ee303ed335179d7981e81..292fc04300477a27c336e38c8f2065433f506ba4 100644 (file)
--- a/testsuite/test-util.c
+++ b/testsuite/test-util.c
@@ -93,7 +93,7 @@ static int test_strchr_replace(void)
        const char *res = "thiC iC a teCt Ctring";
 
        strchr_replace(s, 's', 'C');
-       assert_return(streq(s, res), EXIT_FAILURE);
+       TS_ASSERT(streq(s, res));
 
        return EXIT_SUCCESS;
 }
@@ -118,9 +118,9 @@ static int test_underscores(void)
 
        for (size_t i = 0; i < ARRAY_SIZE(teststr); i++) {
                _cleanup_free_ char *val = strdup(teststr[i].val);
-               assert_return(val != NULL, EXIT_FAILURE);
-               assert_return(!underscores(val), EXIT_FAILURE);
-               assert_return(streq(val, teststr[i].res), EXIT_FAILURE);
+               TS_ASSERT(val != NULL);
+               TS_ASSERT(!underscores(val));
+               TS_ASSERT(streq(val, teststr[i].res));
        }
 
        return EXIT_SUCCESS;
@@ -152,10 +152,9 @@ static int test_path_ends_with_kmod_ext(void)
        };
 
        for (size_t i = 0; i < ARRAY_SIZE(teststr); i++) {
-               assert_return(path_ends_with_kmod_ext(teststr[i].val,
-                                                     strlen(teststr[i].val)) ==
-                                     teststr[i].res,
-                             EXIT_FAILURE);
+               TS_ASSERT(
+                       path_ends_with_kmod_ext(teststr[i].val, strlen(teststr[i].val)) ==
+                       teststr[i].res);
        }
 
        return EXIT_SUCCESS;
@@ -171,7 +170,7 @@ static int test_write_str_safe(void)
        int fd;
 
        fd = open(TEST_WRITE_STR_SAFE_FILE ".txt", O_CREAT | O_TRUNC | O_WRONLY, 0644);
-       assert_return(fd >= 0, EXIT_FAILURE);
+       TS_ASSERT(fd >= 0);
 
        write_str_safe(fd, s, strlen(s));
        close(fd);
@@ -197,11 +196,11 @@ static int test_uadd32_overflow(void)
        bool overflow;
 
        overflow = uadd32_overflow(UINT32_MAX - 1, 1, &res);
-       assert_return(!overflow, EXIT_FAILURE);
-       assert_return(res == UINT32_MAX, EXIT_FAILURE);
+       TS_ASSERT(!overflow);
+       TS_ASSERT(res == UINT32_MAX);
 
        overflow = uadd32_overflow(UINT32_MAX, 1, &res);
-       assert_return(overflow, EXIT_FAILURE);
+       TS_ASSERT(overflow);
 
        return EXIT_SUCCESS;
 }
@@ -214,11 +213,11 @@ static int test_uadd64_overflow(void)
        bool overflow;
 
        overflow = uadd64_overflow(UINT64_MAX - 1, 1, &res);
-       assert_return(!overflow, EXIT_FAILURE);
-       assert_return(res == UINT64_MAX, EXIT_FAILURE);
+       TS_ASSERT(!overflow);
+       TS_ASSERT(res == UINT64_MAX);
 
        overflow = uadd64_overflow(UINT64_MAX, 1, &res);
-       assert_return(overflow, EXIT_FAILURE);
+       TS_ASSERT(overflow);
 
        return EXIT_SUCCESS;
 }
@@ -231,11 +230,11 @@ static int test_umul32_overflow(void)
        bool overflow;
 
        overflow = umul32_overflow(UINT32_MAX / 0x10, 0x10, &res);
-       assert_return(!overflow, EXIT_FAILURE);
-       assert_return(res == (UINT32_MAX & ~0xf), EXIT_FAILURE);
+       TS_ASSERT(!overflow);
+       TS_ASSERT(res == (UINT32_MAX & ~0xf));
 
        overflow = umul32_overflow(UINT32_MAX, 0x10, &res);
-       assert_return(overflow, EXIT_FAILURE);
+       TS_ASSERT(overflow);
 
        return EXIT_SUCCESS;
 }
@@ -248,11 +247,11 @@ static int test_umul64_overflow(void)
        bool overflow;
 
        overflow = umul64_overflow(UINT64_MAX / 0x10, 0x10, &res);
-       assert_return(!overflow, EXIT_FAILURE);
-       assert_return(res == (UINT64_MAX & ~0xf), EXIT_FAILURE);
+       TS_ASSERT(!overflow);
+       TS_ASSERT(res == (UINT64_MAX & ~0xf));
 
        overflow = umul64_overflow(UINT64_MAX, 0x10, &res);
-       assert_return(overflow, EXIT_FAILURE);
+       TS_ASSERT(overflow);
 
        return EXIT_SUCCESS;
 }
@@ -265,31 +264,31 @@ static int test_backoff_time(void)
 
        /* Check exponential increments */
        get_backoff_delta_msec(now_msec() + 10, &delta);
-       assert_return(delta == 1, EXIT_FAILURE);
+       TS_ASSERT(delta == 1);
        get_backoff_delta_msec(now_msec() + 10, &delta);
-       assert_return(delta == 2, EXIT_FAILURE);
+       TS_ASSERT(delta == 2);
        get_backoff_delta_msec(now_msec() + 10, &delta);
-       assert_return(delta == 4, EXIT_FAILURE);
+       TS_ASSERT(delta == 4);
        get_backoff_delta_msec(now_msec() + 10, &delta);
-       assert_return(delta == 8, EXIT_FAILURE);
+       TS_ASSERT(delta == 8);
        get_backoff_delta_msec(now_msec() + 10, &delta);
-       assert_return(delta == 8, EXIT_FAILURE);
+       TS_ASSERT(delta == 8);
 
        {
                /* Check tail */
                delta = 4;
                get_backoff_delta_msec(now_msec() + 3, &delta);
-               assert_return(delta == 2, EXIT_FAILURE);
+               TS_ASSERT(delta == 2);
                get_backoff_delta_msec(now_msec() + 1, &delta);
-               assert_return(delta == 1, EXIT_FAILURE);
+               TS_ASSERT(delta == 1);
                get_backoff_delta_msec(now_msec(), &delta);
-               assert_return(delta == 0, EXIT_FAILURE);
+               TS_ASSERT(delta == 0);
        }
 
        /* Check when end time has passed */
        delta = 0;
        get_backoff_delta_msec(now_msec() - 10, &delta);
-       assert_return(delta == 0, EXIT_FAILURE);
+       TS_ASSERT(delta == 0);
 
        return EXIT_SUCCESS;
 }

diff --git a/testsuite/testsuite.h b/testsuite/testsuite.h
index 06de9a914c42ddce09c8e97b2949c64baeeaa865..366ed7168837b2d365b23d7bf8b23c78589bdcdf 100644 (file)
--- a/testsuite/testsuite.h
+++ b/testsuite/testsuite.h
@@ -119,8 +119,6 @@ int test_run(const struct test *t);
 #define WARN(fmt, ...) _LOG("WARN: ", fmt, ##__VA_ARGS__)
 #define ERR(fmt, ...) _LOG("ERR: ", fmt, ##__VA_ARGS__)
 
-#define assert_return(expr, r) TS_ASSERT(expr)
-
 #define TS_ASSERT(expr)                                                         \
        do {                                                                    \
                if ((!(expr))) {                                                \