From: phillip.wood123@gmail.com
To: "René Scharfe" <l.s.r@web.de>, "Git List" <git@vger.kernel.org>
Cc: Phillip Wood <phillip.wood@dunelm.org.uk>,
Josh Steadmon <steadmon@google.com>
Subject: Re: [PATCH 5/6] t-strvec: use TEST_RUN
Date: Tue, 2 Jul 2024 16:14:28 +0100 [thread overview]
Message-ID: <c122c0a6-9f38-489d-8286-b62bd4deefcc@gmail.com> (raw)
In-Reply-To: <27cdab5f-15b3-45fb-89e1-530a6c0817a6@web.de>
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 <l.s.r@web.de>
> ---
> 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
next prev parent reply other threads:[~2024-07-02 15:14 UTC|newest]
Thread overview: 115+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-06-29 15:33 [PATCH 0/6] unit-tests: add and use TEST_RUN to simplify tests René Scharfe
2024-06-29 15:35 ` [PATCH 1/6] t0080: move expected output to a file René Scharfe
2024-07-01 3:20 ` Jeff King
2024-07-01 19:17 ` Junio C Hamano
2024-07-01 22:10 ` Jeff King
2024-07-01 23:38 ` Junio C Hamano
2024-07-02 0:57 ` Jeff King
2024-07-01 19:51 ` René Scharfe
2024-07-01 22:18 ` Jeff King
2024-06-29 15:43 ` [PATCH 2/6] unit-tests: add TEST_RUN René Scharfe
2024-07-02 15:13 ` phillip.wood123
2024-07-02 15:51 ` Junio C Hamano
2024-07-02 20:55 ` René Scharfe
2024-07-02 20:55 ` René Scharfe
2024-07-05 9:42 ` phillip.wood123
2024-07-05 18:01 ` René Scharfe
2024-07-07 7:20 ` René Scharfe
2024-07-08 15:18 ` phillip.wood123
2024-07-08 15:39 ` Junio C Hamano
2024-07-11 15:34 ` Junio C Hamano
2024-07-13 13:27 ` Phillip Wood
2024-07-13 15:48 ` Junio C Hamano
2024-07-08 15:12 ` phillip.wood123
2024-06-29 15:44 ` [PATCH 3/6] t-ctype: use TEST_RUN René Scharfe
2024-07-01 19:49 ` Josh Steadmon
2024-07-01 20:04 ` René Scharfe
2024-07-02 15:14 ` phillip.wood123
2024-07-02 20:55 ` René Scharfe
2024-06-29 15:45 ` [PATCH 4/6] t-reftable-basics: " René Scharfe
2024-06-29 15:46 ` [PATCH 5/6] t-strvec: " René Scharfe
2024-07-02 15:14 ` phillip.wood123 [this message]
2024-07-02 20:55 ` René Scharfe
2024-06-29 15:47 ` [PATCH 6/6] t-strbuf: " René Scharfe
2024-07-01 19:58 ` Josh Steadmon
2024-07-01 20:18 ` René Scharfe
2024-07-02 15:14 ` phillip.wood123
2024-07-02 20:55 ` René Scharfe
2024-07-04 13:09 ` phillip.wood123
2024-07-10 13:55 ` Phillip Wood
2024-07-14 11:44 ` René Scharfe
2024-07-15 14:46 ` Ghanshyam Thakkar
2024-07-02 17:29 ` Ghanshyam Thakkar
2024-07-02 20:55 ` René Scharfe
2024-07-03 3:42 ` Ghanshyam Thakkar
2024-07-08 18:11 ` Josh Steadmon
2024-07-08 21:59 ` Ghanshyam Thakkar
2024-07-01 19:59 ` [PATCH 0/6] unit-tests: add and use TEST_RUN to simplify tests Josh Steadmon
2024-07-10 22:13 ` Junio C Hamano
2024-07-11 10:05 ` Phillip Wood
2024-07-11 15:12 ` Junio C Hamano
2024-07-14 10:35 ` René Scharfe
2024-07-21 6:12 ` [PATCH v2 0/6] unit-tests: add and use for_test " René Scharfe
2024-07-21 6:15 ` [PATCH v2 1/6] t0080: move expected output to a file René Scharfe
2024-07-23 20:54 ` Jeff King
2024-07-21 6:21 ` [PATCH v2 2/6] unit-tests: add for_test René Scharfe
2024-07-22 19:13 ` Kyle Lippincott
2024-07-22 19:36 ` Junio C Hamano
2024-07-22 20:31 ` René Scharfe
2024-07-22 20:41 ` Junio C Hamano
2024-07-22 22:47 ` Kyle Lippincott
2024-07-23 12:37 ` René Scharfe
2024-07-23 6:02 ` [PATCH v2] unit-tests: show location of checks outside of tests René Scharfe
2024-07-23 13:25 ` Phillip Wood
2024-07-22 22:41 ` [PATCH v2 2/6] unit-tests: add for_test Kyle Lippincott
2024-07-23 7:18 ` René Scharfe
2024-07-23 6:36 ` Patrick Steinhardt
2024-07-23 9:25 ` René Scharfe
2024-07-23 9:53 ` Patrick Steinhardt
2024-07-23 12:37 ` René Scharfe
2024-07-23 13:00 ` Patrick Steinhardt
2024-07-23 13:23 ` Phillip Wood
2024-07-23 13:58 ` René Scharfe
2024-07-23 13:24 ` Phillip Wood
2024-07-25 9:45 ` Phillip Wood
2024-07-30 14:00 ` René Scharfe
2024-07-21 6:22 ` [PATCH v2 3/6] t-ctype: use for_test René Scharfe
2024-07-21 6:23 ` [PATCH v2 4/6] t-reftable-basics: " René Scharfe
2024-07-21 6:24 ` [PATCH v2 5/6] t-strvec: " René Scharfe
2024-07-21 6:26 ` [PATCH v2 6/6] t-strbuf: " René Scharfe
2024-07-23 13:23 ` Phillip Wood
2024-07-24 14:42 ` [PATCH v3 0/7] add and use for_test to simplify tests René Scharfe
2024-07-24 14:48 ` [PATCH v3 1/7] t0080: use here-doc test body René Scharfe
2024-07-24 14:50 ` [PATCH v3 2/7] unit-tests: show location of checks outside of tests René Scharfe
2024-07-24 14:51 ` [PATCH v3 3/7] unit-tests: add for_test René Scharfe
2024-07-24 19:24 ` Kyle Lippincott
2024-07-25 9:45 ` Phillip Wood
2024-07-25 16:02 ` Junio C Hamano
2024-07-25 21:31 ` Kyle Lippincott
2024-07-26 2:41 ` Junio C Hamano
2024-07-26 12:56 ` Patrick Steinhardt
2024-07-26 15:59 ` Junio C Hamano
2024-07-29 9:48 ` Patrick Steinhardt
2024-07-29 18:55 ` Junio C Hamano
2024-07-30 4:49 ` Patrick Steinhardt
2024-07-30 14:00 ` René Scharfe
2024-07-31 5:19 ` Patrick Steinhardt
2024-07-31 16:48 ` René Scharfe
2024-08-01 6:51 ` Patrick Steinhardt
2024-07-24 14:52 ` [PATCH v3 4/7] t-ctype: use for_test René Scharfe
2024-07-24 14:54 ` [PATCH v3 5/7] t-reftable-basics: " René Scharfe
2024-07-24 14:54 ` [PATCH v3 6/7] t-strvec: " René Scharfe
2024-07-24 14:55 ` [PATCH v3 7/7] t-strbuf: " René Scharfe
2024-07-30 14:03 ` [PATCH v4 0/6] add and use if_test to simplify tests René Scharfe
2024-07-30 14:05 ` [PATCH v4 1/6] t0080: use here-doc test body René Scharfe
2024-07-31 20:52 ` Kyle Lippincott
2024-07-30 14:07 ` [PATCH v4 2/6] unit-tests: show location of checks outside of tests René Scharfe
2024-07-31 21:03 ` Kyle Lippincott
2024-08-01 7:23 ` René Scharfe
2024-07-30 14:08 ` [PATCH v4 3/6] unit-tests: add if_test René Scharfe
2024-07-31 22:04 ` Kyle Lippincott
2024-08-01 7:32 ` René Scharfe
2024-08-02 0:48 ` Kyle Lippincott
2024-07-30 14:10 ` [PATCH v4 4/6] t-ctype: use if_test René Scharfe
2024-07-30 14:10 ` [PATCH v4 5/6] t-reftable-basics: " René Scharfe
2024-07-30 14:12 ` [PATCH v4 6/6] t-strvec: " René Scharfe
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=c122c0a6-9f38-489d-8286-b62bd4deefcc@gmail.com \
--to=phillip.wood123@gmail.com \
--cc=git@vger.kernel.org \
--cc=l.s.r@web.de \
--cc=phillip.wood@dunelm.org.uk \
--cc=steadmon@google.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).