[5/6] t-strvec: use TEST_RUN

Commit Message

René Scharfe June 29, 2024, 3:46 p.m. UTC

The macro TEST takes a single expression.  If a test requires multiple
statements then they need to be placed in a function that's called in
the TEST expression.

Remove the overhead of defining and calling single-use functions by
using TEST_RUN instead.

Signed-off-by: René Scharfe <[e-mail]>
---
 t/unit-tests/t-strvec.c | 356 ++++++++++++++++++----------------------
 1 file changed, 156 insertions(+), 200 deletions(-)

--
2.45.2

Comments

Phillip Wood July 2, 2024, 3:14 p.m. UTC | #1

Hi René

On 29/06/2024 16:46, René Scharfe wrote:
> The macro TEST takes a single expression.  If a test requires multiple
> statements then they need to be placed in a function that's called in
> the TEST expression.
> 
> Remove the overhead of defining and calling single-use functions by
> using TEST_RUN instead.

I'm not sure what the overhead is that you keep referring to - the 
compiler will inline functions that are only called once so I presume 
you mean overhead for test authors or contributors reading the code?

This is not related to you changes but while looking at this patch I 
noticed that the existing code in check_strvec_loc() contains

		if (!check_uint(vec->nr, >, nr) ||
		    !check_uint(vec->alloc, >, nr) ||
		    !check_str(vec->v[nr], str)) {
			struct strbuf msg = STRBUF_INIT;
			strbuf_addf(&msg, "strvec index %"PRIuMAX, (uintmax_t) nr);
			test_assert(loc, msg.buf, 0);
			strbuf_release(&msg);
			va_end(ap);
			return;

Which looks like it should be using test_msg() instead of writing a 
message to an strbuf and calling test_assert().

The conversion itself looks correct. It is a shame that each test has to 
have boilerplate to initalize and free the strvec but that comes from 
the existing implementation.

Best Wishes

Phillip

> Signed-off-by: René Scharfe <[e-mail]>
> ---
>   t/unit-tests/t-strvec.c | 356 ++++++++++++++++++----------------------
>   1 file changed, 156 insertions(+), 200 deletions(-)
> 
> diff --git a/t/unit-tests/t-strvec.c b/t/unit-tests/t-strvec.c
> index d4615ab06d..00ff7d4ae8 100644
> --- a/t/unit-tests/t-strvec.c
> +++ b/t/unit-tests/t-strvec.c
> @@ -36,237 +36,193 @@ static void check_strvec_loc(const char *loc, struct strvec *vec, ...)
>   	check_pointer_eq(vec->v[nr], NULL);
>   }
> 
> -static void t_static_init(void)
> +int cmd_main(int argc, const char **argv)
>   {
> -	struct strvec vec = STRVEC_INIT;
> -	check_pointer_eq(vec.v, empty_strvec);
> -	check_uint(vec.nr, ==, 0);
> -	check_uint(vec.alloc, ==, 0);
> -}
> +	if (TEST_RUN("static initialization")) {
> +		struct strvec vec = STRVEC_INIT;
> +		check_pointer_eq(vec.v, empty_strvec);
> +		check_uint(vec.nr, ==, 0);
> +		check_uint(vec.alloc, ==, 0);
> +	}
> 
> -static void t_dynamic_init(void)
> -{
> -	struct strvec vec;
> -	strvec_init(&vec);
> -	check_pointer_eq(vec.v, empty_strvec);
> -	check_uint(vec.nr, ==, 0);
> -	check_uint(vec.alloc, ==, 0);
> -}
> +	if (TEST_RUN("dynamic initialization")) {
> +		struct strvec vec;
> +		strvec_init(&vec);
> +		check_pointer_eq(vec.v, empty_strvec);
> +		check_uint(vec.nr, ==, 0);
> +		check_uint(vec.alloc, ==, 0);
> +	}
> 
> -static void t_clear(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_push(&vec, "foo");
> -	strvec_clear(&vec);
> -	check_pointer_eq(vec.v, empty_strvec);
> -	check_uint(vec.nr, ==, 0);
> -	check_uint(vec.alloc, ==, 0);
> -}
> +	if (TEST_RUN("clear")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_push(&vec, "foo");
> +		strvec_clear(&vec);
> +		check_pointer_eq(vec.v, empty_strvec);
> +		check_uint(vec.nr, ==, 0);
> +		check_uint(vec.alloc, ==, 0);
> +	}
> 
> -static void t_push(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> +	if (TEST_RUN("push")) {
> +		struct strvec vec = STRVEC_INIT;
> 
> -	strvec_push(&vec, "foo");
> -	check_strvec(&vec, "foo", NULL);
> +		strvec_push(&vec, "foo");
> +		check_strvec(&vec, "foo", NULL);
> 
> -	strvec_push(&vec, "bar");
> -	check_strvec(&vec, "foo", "bar", NULL);
> +		strvec_push(&vec, "bar");
> +		check_strvec(&vec, "foo", "bar", NULL);
> 
> -	strvec_clear(&vec);
> -}
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_pushf(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushf(&vec, "foo: %d", 1);
> -	check_strvec(&vec, "foo: 1", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("pushf")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushf(&vec, "foo: %d", 1);
> +		check_strvec(&vec, "foo: 1", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_pushl(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	check_strvec(&vec, "foo", "bar", "baz", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("pushl")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		check_strvec(&vec, "foo", "bar", "baz", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_pushv(void)
> -{
> -	const char *strings[] = {
> -		"foo", "bar", "baz", NULL,
> -	};
> -	struct strvec vec = STRVEC_INIT;
> +	if (TEST_RUN("pushv")) {
> +		const char *strings[] = {
> +			"foo", "bar", "baz", NULL,
> +		};
> +		struct strvec vec = STRVEC_INIT;
> 
> -	strvec_pushv(&vec, strings);
> -	check_strvec(&vec, "foo", "bar", "baz", NULL);
> +		strvec_pushv(&vec, strings);
> +		check_strvec(&vec, "foo", "bar", "baz", NULL);
> 
> -	strvec_clear(&vec);
> -}
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_replace_at_head(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_replace(&vec, 0, "replaced");
> -	check_strvec(&vec, "replaced", "bar", "baz", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("replace at head")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_replace(&vec, 0, "replaced");
> +		check_strvec(&vec, "replaced", "bar", "baz", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_replace_at_tail(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_replace(&vec, 2, "replaced");
> -	check_strvec(&vec, "foo", "bar", "replaced", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("replace at tail")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_replace(&vec, 2, "replaced");
> +		check_strvec(&vec, "foo", "bar", "replaced", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_replace_in_between(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_replace(&vec, 1, "replaced");
> -	check_strvec(&vec, "foo", "replaced", "baz", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("replace in between")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_replace(&vec, 1, "replaced");
> +		check_strvec(&vec, "foo", "replaced", "baz", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_replace_with_substring(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", NULL);
> -	strvec_replace(&vec, 0, vec.v[0] + 1);
> -	check_strvec(&vec, "oo", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("replace with substring")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", NULL);
> +		strvec_replace(&vec, 0, vec.v[0] + 1);
> +		check_strvec(&vec, "oo", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_remove_at_head(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_remove(&vec, 0);
> -	check_strvec(&vec, "bar", "baz", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("remove at head")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_remove(&vec, 0);
> +		check_strvec(&vec, "bar", "baz", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_remove_at_tail(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_remove(&vec, 2);
> -	check_strvec(&vec, "foo", "bar", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("remove at tail")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_remove(&vec, 2);
> +		check_strvec(&vec, "foo", "bar", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_remove_in_between(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_remove(&vec, 1);
> -	check_strvec(&vec, "foo", "baz", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("remove in between")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_remove(&vec, 1);
> +		check_strvec(&vec, "foo", "baz", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_pop_empty_array(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pop(&vec);
> -	check_strvec(&vec, NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("pop with empty array")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pop(&vec);
> +		check_strvec(&vec, NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_pop_non_empty_array(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> -	strvec_pop(&vec);
> -	check_strvec(&vec, "foo", "bar", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("pop with non-empty array")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
> +		strvec_pop(&vec);
> +		check_strvec(&vec, "foo", "bar", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_split_empty_string(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_split(&vec, "");
> -	check_strvec(&vec, NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("split empty string")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_split(&vec, "");
> +		check_strvec(&vec, NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_split_single_item(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_split(&vec, "foo");
> -	check_strvec(&vec, "foo", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("split single item")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_split(&vec, "foo");
> +		check_strvec(&vec, "foo", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_split_multiple_items(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_split(&vec, "foo bar baz");
> -	check_strvec(&vec, "foo", "bar", "baz", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("split multiple items")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_split(&vec, "foo bar baz");
> +		check_strvec(&vec, "foo", "bar", "baz", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_split_whitespace_only(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_split(&vec, " \t\n");
> -	check_strvec(&vec, NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("split whitespace only")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_split(&vec, " \t\n");
> +		check_strvec(&vec, NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_split_multiple_consecutive_whitespaces(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	strvec_split(&vec, "foo\n\t bar");
> -	check_strvec(&vec, "foo", "bar", NULL);
> -	strvec_clear(&vec);
> -}
> +	if (TEST_RUN("split multiple consecutive whitespaces")) {
> +		struct strvec vec = STRVEC_INIT;
> +		strvec_split(&vec, "foo\n\t bar");
> +		check_strvec(&vec, "foo", "bar", NULL);
> +		strvec_clear(&vec);
> +	}
> 
> -static void t_detach(void)
> -{
> -	struct strvec vec = STRVEC_INIT;
> -	const char **detached;
> +	if (TEST_RUN("detach")) {
> +		struct strvec vec = STRVEC_INIT;
> +		const char **detached;
> 
> -	strvec_push(&vec, "foo");
> +		strvec_push(&vec, "foo");
> 
> -	detached = strvec_detach(&vec);
> -	check_str(detached[0], "foo");
> -	check_pointer_eq(detached[1], NULL);
> +		detached = strvec_detach(&vec);
> +		check_str(detached[0], "foo");
> +		check_pointer_eq(detached[1], NULL);
> 
> -	check_pointer_eq(vec.v, empty_strvec);
> -	check_uint(vec.nr, ==, 0);
> -	check_uint(vec.alloc, ==, 0);
> +		check_pointer_eq(vec.v, empty_strvec);
> +		check_uint(vec.nr, ==, 0);
> +		check_uint(vec.alloc, ==, 0);
> 
> -	free((char *) detached[0]);
> -	free(detached);
> -}
> +		free((char *) detached[0]);
> +		free(detached);
> +	}
> 
> -int cmd_main(int argc, const char **argv)
> -{
> -	TEST(t_static_init(), "static initialization");
> -	TEST(t_dynamic_init(), "dynamic initialization");
> -	TEST(t_clear(), "clear");
> -	TEST(t_push(), "push");
> -	TEST(t_pushf(), "pushf");
> -	TEST(t_pushl(), "pushl");
> -	TEST(t_pushv(), "pushv");
> -	TEST(t_replace_at_head(), "replace at head");
> -	TEST(t_replace_in_between(), "replace in between");
> -	TEST(t_replace_at_tail(), "replace at tail");
> -	TEST(t_replace_with_substring(), "replace with substring");
> -	TEST(t_remove_at_head(), "remove at head");
> -	TEST(t_remove_in_between(), "remove in between");
> -	TEST(t_remove_at_tail(), "remove at tail");
> -	TEST(t_pop_empty_array(), "pop with empty array");
> -	TEST(t_pop_non_empty_array(), "pop with non-empty array");
> -	TEST(t_split_empty_string(), "split empty string");
> -	TEST(t_split_single_item(), "split single item");
> -	TEST(t_split_multiple_items(), "split multiple items");
> -	TEST(t_split_whitespace_only(), "split whitespace only");
> -	TEST(t_split_multiple_consecutive_whitespaces(), "split multiple consecutive whitespaces");
> -	TEST(t_detach(), "detach");
>   	return test_done();
>   }
> --
> 2.45.2

René Scharfe July 2, 2024, 8:55 p.m. UTC | #2

Am 02.07.24 um 17:14 schrieb [e-mail]:
> Hi René
>
> On 29/06/2024 16:46, René Scharfe wrote:
>> The macro TEST takes a single expression.  If a test requires
>> multiple statements then they need to be placed in a function
>> that's called in the TEST expression.
>>
>> Remove the overhead of defining and calling single-use functions
>> by using TEST_RUN instead.
>
> I'm not sure what the overhead is that you keep referring to - the
> compiler will inline functions that are only called once so I presume
> you mean overhead for test authors or contributors reading the code?

Yes, I mean the additional effort for developers to come up with
function names and write single-call functions, and for readers to
mentally connect test description and function.  Of course you still can
do that with TEST_RUN, but unlike TEST it doesn't force you.

I don't care much about changed duration of compilation or execution
here -- it shouldn't be much either way.

> This is not related to you changes but while looking at this patch I
> noticed that the existing code in check_strvec_loc() contains
>
>
>         if (!check_uint(vec->nr, >, nr) ||
>             !check_uint(vec->alloc, >, nr) ||
>             !check_str(vec->v[nr], str)) {
>             struct strbuf msg = STRBUF_INIT;
>             strbuf_addf(&msg, "strvec index %"PRIuMAX, (uintmax_t) nr);
>             test_assert(loc, msg.buf, 0);
>             strbuf_release(&msg);
>             va_end(ap);
>             return;
>
> Which looks like it should be using test_msg() instead of writing a
> message to an strbuf and calling test_assert().

Erm, yes, good find.  You know something isn't right if you see an
assert(0) or similar..

> The conversion itself looks correct. It is a shame that each test has
> to have boilerplate to initalize and free the strvec but that comes
> from the existing implementation.

I see that as a benefit: You can see what each test does at a glance;
no tricks, no dependencies.  Just exercise steps and checks.

René

Patch

diff --git a/t/unit-tests/t-strvec.c b/t/unit-tests/t-strvec.c
index d4615ab06d..00ff7d4ae8 100644
--- a/t/unit-tests/t-strvec.c
+++ b/t/unit-tests/t-strvec.c
@@ -36,237 +36,193 @@  static void check_strvec_loc(const char *loc, struct strvec *vec, ...)
 	check_pointer_eq(vec->v[nr], NULL);
 }

-static void t_static_init(void)
+int cmd_main(int argc, const char **argv)
 {
-	struct strvec vec = STRVEC_INIT;
-	check_pointer_eq(vec.v, empty_strvec);
-	check_uint(vec.nr, ==, 0);
-	check_uint(vec.alloc, ==, 0);
-}
+	if (TEST_RUN("static initialization")) {
+		struct strvec vec = STRVEC_INIT;
+		check_pointer_eq(vec.v, empty_strvec);
+		check_uint(vec.nr, ==, 0);
+		check_uint(vec.alloc, ==, 0);
+	}

-static void t_dynamic_init(void)
-{
-	struct strvec vec;
-	strvec_init(&vec);
-	check_pointer_eq(vec.v, empty_strvec);
-	check_uint(vec.nr, ==, 0);
-	check_uint(vec.alloc, ==, 0);
-}
+	if (TEST_RUN("dynamic initialization")) {
+		struct strvec vec;
+		strvec_init(&vec);
+		check_pointer_eq(vec.v, empty_strvec);
+		check_uint(vec.nr, ==, 0);
+		check_uint(vec.alloc, ==, 0);
+	}

-static void t_clear(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_push(&vec, "foo");
-	strvec_clear(&vec);
-	check_pointer_eq(vec.v, empty_strvec);
-	check_uint(vec.nr, ==, 0);
-	check_uint(vec.alloc, ==, 0);
-}
+	if (TEST_RUN("clear")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_push(&vec, "foo");
+		strvec_clear(&vec);
+		check_pointer_eq(vec.v, empty_strvec);
+		check_uint(vec.nr, ==, 0);
+		check_uint(vec.alloc, ==, 0);
+	}

-static void t_push(void)
-{
-	struct strvec vec = STRVEC_INIT;
+	if (TEST_RUN("push")) {
+		struct strvec vec = STRVEC_INIT;

-	strvec_push(&vec, "foo");
-	check_strvec(&vec, "foo", NULL);
+		strvec_push(&vec, "foo");
+		check_strvec(&vec, "foo", NULL);

-	strvec_push(&vec, "bar");
-	check_strvec(&vec, "foo", "bar", NULL);
+		strvec_push(&vec, "bar");
+		check_strvec(&vec, "foo", "bar", NULL);

-	strvec_clear(&vec);
-}
+		strvec_clear(&vec);
+	}

-static void t_pushf(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushf(&vec, "foo: %d", 1);
-	check_strvec(&vec, "foo: 1", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("pushf")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushf(&vec, "foo: %d", 1);
+		check_strvec(&vec, "foo: 1", NULL);
+		strvec_clear(&vec);
+	}

-static void t_pushl(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	check_strvec(&vec, "foo", "bar", "baz", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("pushl")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		check_strvec(&vec, "foo", "bar", "baz", NULL);
+		strvec_clear(&vec);
+	}

-static void t_pushv(void)
-{
-	const char *strings[] = {
-		"foo", "bar", "baz", NULL,
-	};
-	struct strvec vec = STRVEC_INIT;
+	if (TEST_RUN("pushv")) {
+		const char *strings[] = {
+			"foo", "bar", "baz", NULL,
+		};
+		struct strvec vec = STRVEC_INIT;

-	strvec_pushv(&vec, strings);
-	check_strvec(&vec, "foo", "bar", "baz", NULL);
+		strvec_pushv(&vec, strings);
+		check_strvec(&vec, "foo", "bar", "baz", NULL);

-	strvec_clear(&vec);
-}
+		strvec_clear(&vec);
+	}

-static void t_replace_at_head(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_replace(&vec, 0, "replaced");
-	check_strvec(&vec, "replaced", "bar", "baz", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("replace at head")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_replace(&vec, 0, "replaced");
+		check_strvec(&vec, "replaced", "bar", "baz", NULL);
+		strvec_clear(&vec);
+	}

-static void t_replace_at_tail(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_replace(&vec, 2, "replaced");
-	check_strvec(&vec, "foo", "bar", "replaced", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("replace at tail")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_replace(&vec, 2, "replaced");
+		check_strvec(&vec, "foo", "bar", "replaced", NULL);
+		strvec_clear(&vec);
+	}

-static void t_replace_in_between(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_replace(&vec, 1, "replaced");
-	check_strvec(&vec, "foo", "replaced", "baz", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("replace in between")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_replace(&vec, 1, "replaced");
+		check_strvec(&vec, "foo", "replaced", "baz", NULL);
+		strvec_clear(&vec);
+	}

-static void t_replace_with_substring(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", NULL);
-	strvec_replace(&vec, 0, vec.v[0] + 1);
-	check_strvec(&vec, "oo", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("replace with substring")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", NULL);
+		strvec_replace(&vec, 0, vec.v[0] + 1);
+		check_strvec(&vec, "oo", NULL);
+		strvec_clear(&vec);
+	}

-static void t_remove_at_head(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_remove(&vec, 0);
-	check_strvec(&vec, "bar", "baz", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("remove at head")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_remove(&vec, 0);
+		check_strvec(&vec, "bar", "baz", NULL);
+		strvec_clear(&vec);
+	}

-static void t_remove_at_tail(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_remove(&vec, 2);
-	check_strvec(&vec, "foo", "bar", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("remove at tail")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_remove(&vec, 2);
+		check_strvec(&vec, "foo", "bar", NULL);
+		strvec_clear(&vec);
+	}

-static void t_remove_in_between(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_remove(&vec, 1);
-	check_strvec(&vec, "foo", "baz", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("remove in between")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_remove(&vec, 1);
+		check_strvec(&vec, "foo", "baz", NULL);
+		strvec_clear(&vec);
+	}

-static void t_pop_empty_array(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pop(&vec);
-	check_strvec(&vec, NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("pop with empty array")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pop(&vec);
+		check_strvec(&vec, NULL);
+		strvec_clear(&vec);
+	}

-static void t_pop_non_empty_array(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_pushl(&vec, "foo", "bar", "baz", NULL);
-	strvec_pop(&vec);
-	check_strvec(&vec, "foo", "bar", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("pop with non-empty array")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_pushl(&vec, "foo", "bar", "baz", NULL);
+		strvec_pop(&vec);
+		check_strvec(&vec, "foo", "bar", NULL);
+		strvec_clear(&vec);
+	}

-static void t_split_empty_string(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_split(&vec, "");
-	check_strvec(&vec, NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("split empty string")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_split(&vec, "");
+		check_strvec(&vec, NULL);
+		strvec_clear(&vec);
+	}

-static void t_split_single_item(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_split(&vec, "foo");
-	check_strvec(&vec, "foo", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("split single item")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_split(&vec, "foo");
+		check_strvec(&vec, "foo", NULL);
+		strvec_clear(&vec);
+	}

-static void t_split_multiple_items(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_split(&vec, "foo bar baz");
-	check_strvec(&vec, "foo", "bar", "baz", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("split multiple items")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_split(&vec, "foo bar baz");
+		check_strvec(&vec, "foo", "bar", "baz", NULL);
+		strvec_clear(&vec);
+	}

-static void t_split_whitespace_only(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_split(&vec, " \t\n");
-	check_strvec(&vec, NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("split whitespace only")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_split(&vec, " \t\n");
+		check_strvec(&vec, NULL);
+		strvec_clear(&vec);
+	}

-static void t_split_multiple_consecutive_whitespaces(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	strvec_split(&vec, "foo\n\t bar");
-	check_strvec(&vec, "foo", "bar", NULL);
-	strvec_clear(&vec);
-}
+	if (TEST_RUN("split multiple consecutive whitespaces")) {
+		struct strvec vec = STRVEC_INIT;
+		strvec_split(&vec, "foo\n\t bar");
+		check_strvec(&vec, "foo", "bar", NULL);
+		strvec_clear(&vec);
+	}

-static void t_detach(void)
-{
-	struct strvec vec = STRVEC_INIT;
-	const char **detached;
+	if (TEST_RUN("detach")) {
+		struct strvec vec = STRVEC_INIT;
+		const char **detached;

-	strvec_push(&vec, "foo");
+		strvec_push(&vec, "foo");

-	detached = strvec_detach(&vec);
-	check_str(detached[0], "foo");
-	check_pointer_eq(detached[1], NULL);
+		detached = strvec_detach(&vec);
+		check_str(detached[0], "foo");
+		check_pointer_eq(detached[1], NULL);

-	check_pointer_eq(vec.v, empty_strvec);
-	check_uint(vec.nr, ==, 0);
-	check_uint(vec.alloc, ==, 0);
+		check_pointer_eq(vec.v, empty_strvec);
+		check_uint(vec.nr, ==, 0);
+		check_uint(vec.alloc, ==, 0);

-	free((char *) detached[0]);
-	free(detached);
-}
+		free((char *) detached[0]);
+		free(detached);
+	}

-int cmd_main(int argc, const char **argv)
-{
-	TEST(t_static_init(), "static initialization");
-	TEST(t_dynamic_init(), "dynamic initialization");
-	TEST(t_clear(), "clear");
-	TEST(t_push(), "push");
-	TEST(t_pushf(), "pushf");
-	TEST(t_pushl(), "pushl");
-	TEST(t_pushv(), "pushv");
-	TEST(t_replace_at_head(), "replace at head");
-	TEST(t_replace_in_between(), "replace in between");
-	TEST(t_replace_at_tail(), "replace at tail");
-	TEST(t_replace_with_substring(), "replace with substring");
-	TEST(t_remove_at_head(), "remove at head");
-	TEST(t_remove_in_between(), "remove in between");
-	TEST(t_remove_at_tail(), "remove at tail");
-	TEST(t_pop_empty_array(), "pop with empty array");
-	TEST(t_pop_non_empty_array(), "pop with non-empty array");
-	TEST(t_split_empty_string(), "split empty string");
-	TEST(t_split_single_item(), "split single item");
-	TEST(t_split_multiple_items(), "split multiple items");
-	TEST(t_split_whitespace_only(), "split whitespace only");
-	TEST(t_split_multiple_consecutive_whitespaces(), "split multiple consecutive whitespaces");
-	TEST(t_detach(), "detach");
 	return test_done();
 }