git/list[1] front-page[2] threads[3] people[4] search[5] about
 

Re: [PATCH 5/6] t-strvec: use TEST_RUN

From
Pphillip.wood123@gmail.com <phillip.wood123@gmail.com>
Date
Jul 2, 2024, 15:14 UTC
Message-ID
<c122c0a6-9f38-489d-8286-b62bd4deefcc@gmail.com>
In-Reply-To
<27cdab5f-15b3-45fb-89e1-530a6c0817a6@web.de>
Hi René
On 29/06/2024 16:46, René Scharfe wrote:
Show 6 quoted lines
> 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
Show 405 quoted lines
> 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
Previous: René ScharfeNext: René Scharfe
Message 31 of 115 in “unit-tests: add and use TEST_RUN to simplify tests”
  1. 0/6 unit-tests: add and use TEST_RUN to simplify testsRené Scharfe, Jun 29, 2024
  2. 1/6 t0080: move expected output to a fileRené Scharfe, Jun 29, 2024
  3. Jeff KingJul 1, 2024
  4. Junio C HamanoJul 1, 2024
  5. Jeff KingJul 1, 2024
  6. Junio C HamanoJul 1, 2024
  7. Jeff KingJul 2, 2024
  8. René ScharfeJul 1, 2024
  9. Jeff KingJul 1, 2024
  10. 2/6 unit-tests: add TEST_RUNRené Scharfe, Jun 29, 2024
  11. phillip.wood123@gmail.comJul 2, 2024
  12. Junio C HamanoJul 2, 2024
  13. René ScharfeJul 2, 2024
  14. René ScharfeJul 2, 2024
  15. phillip.wood123@gmail.comJul 5, 2024
  16. René ScharfeJul 5, 2024
  17. René ScharfeJul 7, 2024
  18. phillip.wood123@gmail.comJul 8, 2024
  19. Junio C HamanoJul 8, 2024
  20. Junio C HamanoJul 11, 2024
  21. Phillip WoodJul 13, 2024
  22. Junio C HamanoJul 13, 2024
  23. phillip.wood123@gmail.comJul 8, 2024
  24. 3/6 t-ctype: use TEST_RUNRené Scharfe, Jun 29, 2024
  25. Josh SteadmonJul 1, 2024
  26. René ScharfeJul 1, 2024
  27. phillip.wood123@gmail.comJul 2, 2024
  28. René ScharfeJul 2, 2024
  29. 4/6 t-reftable-basics: use TEST_RUNRené Scharfe, Jun 29, 2024
  30. 5/6 t-strvec: use TEST_RUNRené Scharfe, Jun 29, 2024
  31. phillip.wood123@gmail.comJul 2, 2024
  32. René ScharfeJul 2, 2024
  33. 6/6 t-strbuf: use TEST_RUNRené Scharfe, Jun 29, 2024
  34. Josh SteadmonJul 1, 2024
  35. René ScharfeJul 1, 2024
  36. phillip.wood123@gmail.comJul 2, 2024
  37. René ScharfeJul 2, 2024
  38. phillip.wood123@gmail.comJul 4, 2024
  39. Phillip WoodJul 10, 2024
  40. René ScharfeJul 14, 2024
  41. Ghanshyam ThakkarJul 15, 2024
  42. Ghanshyam ThakkarJul 2, 2024
  43. René ScharfeJul 2, 2024
  44. Ghanshyam ThakkarJul 3, 2024
  45. Josh SteadmonJul 8, 2024
  46. Ghanshyam ThakkarJul 8, 2024
  47. Josh SteadmonJul 1, 2024
  48. Junio C HamanoJul 10, 2024
  49. Phillip WoodJul 11, 2024
  50. Junio C HamanoJul 11, 2024
  51. René ScharfeJul 14, 2024
  52. 0/6 unit-tests: add and use for_test to simplify testsRené Scharfe, Jul 21, 2024
  53. 1/6 t0080: move expected output to a fileRené Scharfe, Jul 21, 2024
  54. Jeff KingJul 23, 2024
  55. 2/6 unit-tests: add for_testRené Scharfe, Jul 21, 2024
  56. Kyle LippincottJul 22, 2024
  57. Junio C HamanoJul 22, 2024
  58. René ScharfeJul 22, 2024
  59. Junio C HamanoJul 22, 2024
  60. Kyle LippincottJul 22, 2024
  61. René ScharfeJul 23, 2024
  62. unit-tests: show location of checks outside of testsRené Scharfe, Jul 23, 2024
  63. Phillip WoodJul 23, 2024
  64. Kyle LippincottJul 22, 2024
  65. René ScharfeJul 23, 2024
  66. Patrick SteinhardtJul 23, 2024
  67. René ScharfeJul 23, 2024
  68. Patrick SteinhardtJul 23, 2024
  69. René ScharfeJul 23, 2024
  70. Patrick SteinhardtJul 23, 2024
  71. Phillip WoodJul 23, 2024
  72. René ScharfeJul 23, 2024
  73. Phillip WoodJul 23, 2024
  74. Phillip WoodJul 25, 2024
  75. René ScharfeJul 30, 2024
  76. 3/6 t-ctype: use for_testRené Scharfe, Jul 21, 2024
  77. 4/6 t-reftable-basics: use for_testRené Scharfe, Jul 21, 2024
  78. 5/6 t-strvec: use for_testRené Scharfe, Jul 21, 2024
  79. 6/6 t-strbuf: use for_testRené Scharfe, Jul 21, 2024
  80. Phillip WoodJul 23, 2024
  81. 0/7 add and use for_test to simplify testsRené Scharfe, Jul 24, 2024
  82. 1/7 t0080: use here-doc test bodyRené Scharfe, Jul 24, 2024
  83. 2/7 unit-tests: show location of checks outside of testsRené Scharfe, Jul 24, 2024
  84. 3/7 unit-tests: add for_testRené Scharfe, Jul 24, 2024
  85. Kyle LippincottJul 24, 2024
  86. Phillip WoodJul 25, 2024
  87. Junio C HamanoJul 25, 2024
  88. Kyle LippincottJul 25, 2024
  89. Junio C HamanoJul 26, 2024
  90. Patrick SteinhardtJul 26, 2024
  91. Junio C HamanoJul 26, 2024
  92. Patrick SteinhardtJul 29, 2024
  93. Junio C HamanoJul 29, 2024
  94. Patrick SteinhardtJul 30, 2024
  95. René ScharfeJul 30, 2024
  96. Patrick SteinhardtJul 31, 2024
  97. René ScharfeJul 31, 2024
  98. Patrick SteinhardtAug 1, 2024
  99. 4/7 t-ctype: use for_testRené Scharfe, Jul 24, 2024
  100. 5/7 t-reftable-basics: use for_testRené Scharfe, Jul 24, 2024
  101. 6/7 t-strvec: use for_testRené Scharfe, Jul 24, 2024
  102. 7/7 t-strbuf: use for_testRené Scharfe, Jul 24, 2024
  103. 0/6 add and use if_test to simplify testsRené Scharfe, Jul 30, 2024
  104. 1/6 t0080: use here-doc test bodyRené Scharfe, Jul 30, 2024
  105. Kyle LippincottJul 31, 2024
  106. 2/6 unit-tests: show location of checks outside of testsRené Scharfe, Jul 30, 2024
  107. Kyle LippincottJul 31, 2024
  108. René ScharfeAug 1, 2024
  109. 3/6 unit-tests: add if_testRené Scharfe, Jul 30, 2024
  110. Kyle LippincottJul 31, 2024
  111. René ScharfeAug 1, 2024
  112. Kyle LippincottAug 2, 2024
  113. 4/6 t-ctype: use if_testRené Scharfe, Jul 30, 2024
  114. 5/6 t-reftable-basics: use if_testRené Scharfe, Jul 30, 2024
  115. 6/6 t-strvec: use if_testRené Scharfe, Jul 30, 2024

Read the whole thread, see it on lore, or plain text.

$ cat FOOTERMessages come from the public archive at lore.kernel.org/git, fetched every hour. The front page is chosen and written each morning by an AI editor and can be wrong; the threads themselves are the record. About and API. For agents: an MCP server at https://gitlist.dev/mcp, and any thread, story or person page as Markdown by adding .md to its URL (or sending Accept: text/markdown). Details in /llms.txt.