Skip to contentSkip to conversation

t/unit-tests: convert unit-tests to use clar

PATCH In review Seyi Kuforiji 4 participants 30 messages Feb 20, 2025 – Feb 25, 2025

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

cover t/unit-tests: convert unit-tests to use clar

Hello,

This small patch series transitions a couple more of our existing unit test files to the Clar testing framework. This change is part of our ongoing effort to standardize our testing framework to enhance maintainability.

Thanks
Seyi

Seyi Kuforiji (5):
t/unit-tests: implement oid helper functions in unit-tests.{c,h} t/unit-tests: convert oid-array test to use clar test framework t/unit-tests: convert oidmap test to use clar test framework t/unit-tests: convert oidtree test to use clar test framework t/unit-tests: remove lib-oid.{c,h,o}

 Makefile                                      |   7 +-
 t/meson.build                                 |   7 +-
 t/unit-tests/lib-oid.c                        |  52 ------
 t/unit-tests/lib-oid.h                        |  25 ---
 t/unit-tests/{t-oid-array.c => u-oid-array.c} | 123 +++++++-------
 t/unit-tests/{t-oidmap.c => u-oidmap.c}       | 153 ++++++------------
 t/unit-tests/{t-oidtree.c => u-oidtree.c}     |  78 ++++-----
 t/unit-tests/unit-test.c                      |  42 +++++
 t/unit-tests/unit-test.h                      |  19 +++
 9 files changed, 212 insertions(+), 294 deletions(-)
 delete mode 100644 t/unit-tests/lib-oid.c
 delete mode 100644 t/unit-tests/lib-oid.h
 rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (35%)
 rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%)
 rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (44%)
Signature · 1 line
2.47.0.86.g15030f9556
#1 lore raw

PATCH 1/5 t/unit-tests: implement oid helper functions in unit-tests.{c,h}

get_oid_arbitrary_hex() and init_hash_algo() are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in the t/unit-tests/lib-oid.{c,h} which is utilized by oid-related tests in the homegrown unit tests structure.

Implement equivalent functions in unit-tests.{c,h}. Both these functions become available for oid-related test files implemented using the clar testing framework, which requires them. This will be used by subsequent commits.

---
 t/unit-tests/unit-test.c | 42 ++++++++++++++++++++++++++++++++++++++++
 t/unit-tests/unit-test.h | 19 ++++++++++++++++++
 2 files changed, 61 insertions(+)
t/unit-tests/unit-test.c +42 -0
index fa8818842a..13d54f192a 100644
@@ -1,5 +1,7 @@
 #include "unit-test.h"
+#include "hex.h"
 #include "parse-options.h"
+#include "strbuf.h"
 #include "string-list.h"
 #include "strvec.h"
 
@@ -62,3 +64,43 @@ int cmd_main(int argc, const char **argv)
 	strvec_clear(&args);
 	return ret;
 }
+
+int init_hash_algo(void)
+{
+	static int algo = -1;
+
+	if (algo < 0) {
+		const char *algo_name = getenv("GIT_TEST_DEFAULT_HASH");
+		algo = algo_name ? hash_algo_by_name(algo_name) : GIT_HASH_SHA1;
+
+		cl_assert(algo != GIT_HASH_UNKNOWN);
+	}
+	return algo;
+}
+
+static void cl_parse_oid(const char *hex, struct object_id *oid,
+				       const struct git_hash_algo *algop)
+{
+	int ret;
+	size_t sz = strlen(hex);
+	struct strbuf buf = STRBUF_INIT;
+
+	cl_assert(sz <= algop->hexsz);
+
+	strbuf_add(&buf, hex, sz);
+	strbuf_addchars(&buf, '0', algop->hexsz - sz);
+
+	ret = get_oid_hex_algop(buf.buf, oid, algop);
+	cl_assert_equal_i(ret, 0);
+
+	strbuf_release(&buf);
+}
+
+
+void cl_parse_any_oid(const char *hex, struct object_id *oid)
+{
+	int hash_algo = init_hash_algo();
+
+	cl_assert(hash_algo != GIT_HASH_UNKNOWN);
+	cl_parse_oid(hex, oid, &hash_algos[hash_algo]);
+}
t/unit-tests/unit-test.h +19 -0
index 85e5d6a948..ebed51212f 100644
@@ -8,3 +8,22 @@
 	snprintf(desc, sizeof(desc), fmt, __VA_ARGS__); \
 	clar__fail(__FILE__, __func__, __LINE__, "Test failed.", desc, 1); \
 } while (0)
+
+/*
+ * Convert arbitrary hex string to object_id.
+ * For example, passing "abc12" will generate
+ * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
+ * create object_id with that.
+ * WARNING: passing a string of length more than the hexsz of respective hash
+ * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
+ * environment variable.
+ */
+void cl_parse_any_oid(const char *s, struct object_id *oid);
+/*
+ * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
+ * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
+ * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
+ * cl_assert(algo != GIT_HASH_UNKNOWN) before returning to verify if the
+ * GIT_TEST_DEFAULT_HASH's value is valid or not.
+ */
+int init_hash_algo(void);
Signature · 1 line
2.47.0.86.g15030f9556
#2 lore raw

Re: [PATCH 1/5] t/unit-tests: implement oid helper functions in unit-tests.{c,h}

Hi Seyi

Quoted 10 lines · Seyi Kuforiji

get_oid_arbitrary_hex() and init_hash_algo() are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in the t/unit-tests/lib-oid.{c,h} which is utilized by oid-related tests in the homegrown unit tests structure.

Implement equivalent functions in unit-tests.{c,h}. Both these functions become available for oid-related test files implemented using the clar testing framework, which requires them. This will be used by subsequent commits.

It is nice to see these tests being moved over to clar but I'm not sure that moving these functions into this file is good idea. All the unit tests need to link against unit-tests.o but only a subset will want access to these functions. Putting them in this file means that all the tests will now depend on code from strbuf.o and hex.o. I think we could add the new functions to lib-oid.c and then remove the old ones when there are not needed any more.

Best Wishes

Phillip

Quoted 90 lines
---
  t/unit-tests/unit-test.c | 42 ++++++++++++++++++++++++++++++++++++++++
  t/unit-tests/unit-test.h | 19 ++++++++++++++++++
  2 files changed, 61 insertions(+)
t/unit-tests/unit-test.c +42 -0
index fa8818842a..13d54f192a 100644
@@ -1,5 +1,7 @@
  #include "unit-test.h"
+#include "hex.h"
  #include "parse-options.h"
+#include "strbuf.h"
  #include "string-list.h"
  #include "strvec.h"
 
@@ -62,3 +64,43 @@ int cmd_main(int argc, const char **argv)
  	strvec_clear(&args);
  	return ret;
  }
+
+int init_hash_algo(void)
+{
+	static int algo = -1;
+
+	if (algo < 0) {
+		const char *algo_name = getenv("GIT_TEST_DEFAULT_HASH");
+		algo = algo_name ? hash_algo_by_name(algo_name) : GIT_HASH_SHA1;
+
+		cl_assert(algo != GIT_HASH_UNKNOWN);
+	}
+	return algo;
+}
+
+static void cl_parse_oid(const char *hex, struct object_id *oid,
+				       const struct git_hash_algo *algop)
+{
+	int ret;
+	size_t sz = strlen(hex);
+	struct strbuf buf = STRBUF_INIT;
+
+	cl_assert(sz <= algop->hexsz);
+
+	strbuf_add(&buf, hex, sz);
+	strbuf_addchars(&buf, '0', algop->hexsz - sz);
+
+	ret = get_oid_hex_algop(buf.buf, oid, algop);
+	cl_assert_equal_i(ret, 0);
+
+	strbuf_release(&buf);
+}
+
+
+void cl_parse_any_oid(const char *hex, struct object_id *oid)
+{
+	int hash_algo = init_hash_algo();
+
+	cl_assert(hash_algo != GIT_HASH_UNKNOWN);
+	cl_parse_oid(hex, oid, &hash_algos[hash_algo]);
+}
t/unit-tests/unit-test.h +19 -0
index 85e5d6a948..ebed51212f 100644
@@ -8,3 +8,22 @@
  	snprintf(desc, sizeof(desc), fmt, __VA_ARGS__); \
  	clar__fail(__FILE__, __func__, __LINE__, "Test failed.", desc, 1); \
  } while (0)
+
+/*
+ * Convert arbitrary hex string to object_id.
+ * For example, passing "abc12" will generate
+ * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
+ * create object_id with that.
+ * WARNING: passing a string of length more than the hexsz of respective hash
+ * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
+ * environment variable.
+ */
+void cl_parse_any_oid(const char *s, struct object_id *oid);
+/*
+ * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
+ * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
+ * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
+ * cl_assert(algo != GIT_HASH_UNKNOWN) before returning to verify if the
+ * GIT_TEST_DEFAULT_HASH's value is valid or not.
+ */
+int init_hash_algo(void);
#3 lore raw

Re: [PATCH 1/5] t/unit-tests: implement oid helper functions in unit-tests.{c,h}

Quoted 14 lines · Phillip Wood

Hi Seyi

Quoted 10 lines · Seyi Kuforiji

get_oid_arbitrary_hex() and init_hash_algo() are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in the t/unit-tests/lib-oid.{c,h} which is utilized by oid-related tests in the homegrown unit tests structure.

Implement equivalent functions in unit-tests.{c,h}. Both these functions become available for oid-related test files implemented using the clar testing framework, which requires them. This will be used by subsequent commits.

Quoted 7 lines

It is nice to see these tests being moved over to clar but I'm not sure that moving these functions into this file is good idea. All the unit tests need to link against unit-tests.o but only a subset will want access to these functions. Putting them in this file means that all the tests will now depend on code from strbuf.o and hex.o. I think we could add the new functions to lib-oid.c and then remove the old ones when there are not needed any more.

That should probably work, yeah. In that case we'd have to rename init_hash_algo(), e.g. to something like cl_setup_hash_algo(), to clearly show that it is part of the clar testing framework. I think having a common prefix for such helper functions would be good anyway so that the symbols never conflict with symbols we have in libgit.

Patrick

#4 lore raw

Re: [PATCH 1/5] t/unit-tests: implement oid helper functions in unit-tests.{c,h}

In reply to Seyi Kuforiji
Quoted 9 lines · Seyi Kuforiji
t/unit-tests/unit-test.h +1 -0
index 85e5d6a948..ebed51212f 100644
@@ -8,3 +8,22 @@
 	snprintf(desc, sizeof(desc), fmt, __VA_ARGS__); \
 	clar__fail(__FILE__, __func__, __LINE__, "Test failed.", desc, 1); \
 } while (0)
+

t/unit-tests/unit-test.h line 21

Quoted 10 lines
t/unit-tests/unit-test.h +10 -0
+/*
+ * Convert arbitrary hex string to object_id.
+ * For example, passing "abc12" will generate
+ * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
+ * create object_id with that.
+ * WARNING: passing a string of length more than the hexsz of respective hash
+ * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
+ * environment variable.
+ */
+void cl_parse_any_oid(const char *s, struct object_id *oid);

Nit: let's add a space between the function decarations. I'd also add a blank line into the comments before the "For example" paragraph and after it to make it easier to parse.

Patrick

#5 lore raw

Re: [PATCH 1/5] t/unit-tests: implement oid helper functions in unit-tests.{c,h}

In reply to Seyi Kuforiji

Hi Seyi

Quoted 4 lines · Seyi Kuforiji
t/unit-tests/unit-test.c +4 -0
+static void cl_parse_oid(const char *hex, struct object_id *oid,
+				       const struct git_hash_algo *algop)
+{
+	int ret;

t/unit-tests/unit-test.c int cmd_main(int argc, const char **argv) · line 94

Quoted 10 lines
t/unit-tests/unit-test.c +10 -0
+	size_t sz = strlen(hex);
+	struct strbuf buf = STRBUF_INIT;
+
+	cl_assert(sz <= algop->hexsz);
+
+	strbuf_add(&buf, hex, sz);
+	strbuf_addchars(&buf, '0', algop->hexsz - sz);
+
+	ret = get_oid_hex_algop(buf.buf, oid, algop);
+	cl_assert_equal_i(ret, 0);

These last two lines would be better written as

	cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);

So that if it fails the message shows which function was being called

Best Wishes

Phillip

#6 lore raw

PATCH 2/5 t/unit-tests: convert oid-array test to use clar

In reply to Seyi Kuforiji

Adapt oid-array test script to clar framework by using clar assertions where necessary. Remove descriptions from macros to reduce redundancy, and move test input arrays to global scope for reuse across multiple test functions. Introduce test_oid_array__initialize() to explicitly initialize the hash algorithm.

These changes streamline the test suite, making individual tests self-contained and reducing redundant code.

---
 Makefile                                      |   2 +-
 t/meson.build                                 |   2 +-
 t/unit-tests/{t-oid-array.c => u-oid-array.c} | 123 +++++++++---------
 3 files changed, 65 insertions(+), 62 deletions(-)
 rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (35%)
Makefile +1 -1
index bcf5ed3f85..f8e061365b 100644
@@ -1356,6 +1356,7 @@ CLAR_TEST_SUITES += u-example-decorate
 CLAR_TEST_SUITES += u-hash
 CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
+CLAR_TEST_SUITES += u-oid-array
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1366,7 +1367,6 @@ CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 
-UNIT_TEST_PROGRAMS += t-oid-array
 UNIT_TEST_PROGRAMS += t-oidmap
 UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
t/meson.build +1 -1
index 780939d49f..93410a8545 100644
@@ -4,6 +4,7 @@ clar_test_suites = [
   'unit-tests/u-hash.c',
   'unit-tests/u-hashmap.c',
   'unit-tests/u-mem-pool.c',
+  'unit-tests/u-oid-array.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -48,7 +49,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oid-array.c',
   'unit-tests/t-oidmap.c',
   'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +63 -60

176 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#7 lore raw

Re: [PATCH 2/5] t/unit-tests: convert oid-array test to use clar

Hi Seyi

Quoted 8 lines · Seyi Kuforiji

Adapt oid-array test script to clar framework by using clar assertions where necessary. Remove descriptions from macros to reduce redundancy, and move test input arrays to global scope for reuse across multiple test functions. Introduce test_oid_array__initialize() to explicitly initialize the hash algorithm.

These changes streamline the test suite, making individual tests self-contained and reducing redundant code.

I think these conversion look correct but once again we're losing valuable debugging information because we haven't added better assertions to clar.

Quoted 4 lines
  	oid_array_for_each_unique(&input, add_to_oid_array, &actual);
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +0 -3
-	if (!check_uint(actual.nr, ==, expect.nr))
-		return;
-

t/unit-tests/u-oid-array.c static void t_enumeration(const char **input_args, size_t input_sz, · line 40

Quoted 10 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +4 -6
-	for (i = 0; i < actual.nr; i++) {
-		if (!check(oideq(&actual.oid[i], &expect.oid[i])))
-			test_msg("expected: %s\n       got: %s\n     index: %" PRIuMAX,
-				 oid_to_hex(&expect.oid[i]), oid_to_hex(&actual.oid[i]),
-				 (uintmax_t)i);
-	}
+	cl_assert_equal_i(actual.nr, expect.nr);
+
+	for (i = 0; i < actual.nr; i++)
+		cl_assert(oideq(&actual.oid[i], &expect.oid[i]));

If this fails the poor person debugging it will have no idea why as there is now no indication of which two oids were being compared.

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 62

Quoted 5 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +2 -3
-	if (!check_int(ret, <=, upper_bound) ||
-	    !check_int(ret, >=, lower_bound))
-		test_msg("oid query for lookup: %s", oid_to_hex(&oid_query));
+	cl_assert(ret <= upper_bound);
+	cl_assert(ret >= lower_bound);

This is another case where we could do with better assertions in clar

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 75

Quoted 8 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +2 -3
-static void setup(void)
+void test_oid_array__initialize(void)
  {
  	/* The hash algo is used by oid_array_lookup() internally */
  	int algo = init_hash_algo();
-	if (check_int(algo, !=, GIT_HASH_UNKNOWN))
-		repo_set_hash_algo(the_repository, algo);
+	cl_assert(algo != GIT_HASH_UNKNOWN);

init_has_algo() in unit-test.c already does this.

Best Wishes

Phillip

Quoted 76 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +42 -22
+	repo_set_hash_algo(the_repository, algo);
  }
 
-int cmd_main(int argc UNUSED, const char **argv UNUSED)
+static const char *arr_input[] = { "88", "44", "aa", "55" };
+static const char *arr_input_dup[] = { "88", "44", "aa", "55",
+				       "88", "44", "aa", "55",
+				       "88", "44", "aa", "55" };
+static const char *res_sorted[] = { "44", "55", "88", "aa" };
+
+void test_oid_array__enumerate_unique(void)
  {
-	const char *arr_input[] = { "88", "44", "aa", "55" };
-	const char *arr_input_dup[] = { "88", "44", "aa", "55",
-					"88", "44", "aa", "55",
-					"88", "44", "aa", "55" };
-	const char *res_sorted[] = { "44", "55", "88", "aa" };
-	const char *nearly_55;
+	TEST_ENUMERATION(arr_input, res_sorted);
+}
+
+void test_oid_array__enumerate_duplicate(void)
+{
+	TEST_ENUMERATION(arr_input_dup, res_sorted);
+}
+
+void test_oid_array__lookup(void)
+{
+	TEST_LOOKUP(arr_input, "55", 1, 1);
+}
 
-	if (!TEST(setup(), "setup"))
-		test_skip_all("hash algo initialization failed");
+void test_oid_array__lookup_non_existent(void)
+{
+	TEST_LOOKUP(arr_input, "33", INT_MIN, -1);
+}
+
+void test_oid_array__lookup_duplicates(void)
+{
+	TEST_LOOKUP(arr_input_dup, "55", 3, 5);
+}
 
-	TEST_ENUMERATION(arr_input, res_sorted, "ordered enumeration");
-	TEST_ENUMERATION(arr_input_dup, res_sorted,
-			 "ordered enumeration with duplicate suppression");
+void test_oid_array__lookup_non_existent_dup(void)
+{
+	TEST_LOOKUP(arr_input_dup, "66", INT_MIN, -1);
+}
 
-	TEST_LOOKUP(arr_input, "55", 1, 1, "lookup");
-	TEST_LOOKUP(arr_input, "33", INT_MIN, -1, "lookup non-existent entry");
-	TEST_LOOKUP(arr_input_dup, "55", 3, 5, "lookup with duplicates");
-	TEST_LOOKUP(arr_input_dup, "66", INT_MIN, -1,
-		    "lookup non-existent entry with duplicates");
+void test_oid_array__lookup_almost_dup(void)
+{
+	const char *nearly_55;
 
  	nearly_55 = init_hash_algo() == GIT_HASH_SHA1 ?
  			"5500000000000000000000000000000000000001" :
  			"5500000000000000000000000000000000000000000000000000000000000001";
-	TEST_LOOKUP(((const char *[]){ "55", nearly_55 }), "55", 0, 0,
-		    "lookup with almost duplicate values");
-	TEST_LOOKUP(((const char *[]){ "55", "55" }), "55", 0, 1,
-		    "lookup with single duplicate value");
 
-	return test_done();
+	TEST_LOOKUP(((const char *[]){ "55", nearly_55 }), "55", 0, 0);
+}
+
+void test_oid_array__lookup_single_dup(void)
+{
+	TEST_LOOKUP(((const char *[]){ "55", "55" }), "55", 0, 1);
  }
#8 lore raw

Re: [PATCH 2/5] t/unit-tests: convert oid-array test to use clar

Quoted 10 lines · Phillip Wood

Hi Seyi

Quoted 6 lines · Seyi Kuforiji

Adapt oid-array test script to clar framework by using clar assertions where necessary. Remove descriptions from macros to reduce redundancy, and move test input arrays to global scope for reuse across multiple test functions. Introduce test_oid_array__initialize() to explicitly initialize the hash algorithm.

Quoted 7 lines
Quoted 2 lines

These changes streamline the test suite, making individual tests self-contained and reducing redundant code.

I think these conversion look correct but once again we're losing valuable debugging information because we haven't added better assertions to clear.

I understand your concern about losing debugging information, but it is more beneficial to prioritize clarity and simplicity in unit tests. Unit tests should be short and easy, and adding extra debugging messages increases complexity, making them harder to maintain and read. The assertion failures already indicate where an issue occurs, allowing whoever is debugging to inspect the test inputs directly if needed.

Assertion failures are rarely hit in real-world scenarios, and when they do occur, one can manually print values or use a debugger to investigate. This makes the additional debugging messages unnecessary in most cases. The lack of explicit debugging output is not a significant issue in practice. Furthermore, there are plans to collaborate with Clar upstream to equip common assertions with the ability to print custom messages in a formatted string where an error occurs. This would allow our test to be simple and easy to read and also maintain some of our custom debug messages.

Quoted 26 lines
Quoted 4 lines
      oid_array_for_each_unique(&input, add_to_oid_array, &actual);
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +0 -3
-     if (!check_uint(actual.nr, ==, expect.nr))
-             return;
-

t/unit-tests/u-oid-array.c static void t_enumeration(const char **input_args, size_t input_sz, · line 40

Quoted 10 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +4 -6
-     for (i = 0; i < actual.nr; i++) {
-             if (!check(oideq(&actual.oid[i], &expect.oid[i])))
-                     test_msg("expected: %s\n       got: %s\n     index: %" PRIuMAX,
-                              oid_to_hex(&expect.oid[i]), oid_to_hex(&actual.oid[i]),
-                              (uintmax_t)i);
-     }
+     cl_assert_equal_i(actual.nr, expect.nr);
+
+     for (i = 0; i < actual.nr; i++)
+             cl_assert(oideq(&actual.oid[i], &expect.oid[i]));

If this fails the poor person debugging it will have no idea why as there is now no indication of which two oids were being compared.

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 62

Quoted 5 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +2 -3
-     if (!check_int(ret, <=, upper_bound) ||
-         !check_int(ret, >=, lower_bound))
-             test_msg("oid query for lookup: %s", oid_to_hex(&oid_query));
+     cl_assert(ret <= upper_bound);
+     cl_assert(ret >= lower_bound);

This is another case where we could do with better assertions in clar

Quoted 11 lines

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 75

Quoted 8 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +2 -3
-static void setup(void)
+void test_oid_array__initialize(void)
  {
      /* The hash algo is used by oid_array_lookup() internally */
      int algo = init_hash_algo();
-     if (check_int(algo, !=, GIT_HASH_UNKNOWN))
-             repo_set_hash_algo(the_repository, algo);
+     cl_assert(algo != GIT_HASH_UNKNOWN);

init_has_algo() in unit-test.c already does this.

Thanks for spotting this! Will fix this in an updated patch.

Quoted 73 lines

Best Wishes

Phillip

Quoted 68 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +36 -21
+     repo_set_hash_algo(the_repository, algo);
  }
 
-int cmd_main(int argc UNUSED, const char **argv UNUSED)
+static const char *arr_input[] = { "88", "44", "aa", "55" };
+static const char *arr_input_dup[] = { "88", "44", "aa", "55",
+                                    "88", "44", "aa", "55",
+                                    "88", "44", "aa", "55" };
+static const char *res_sorted[] = { "44", "55", "88", "aa" };
+
+void test_oid_array__enumerate_unique(void)
  {
-     const char *arr_input[] = { "88", "44", "aa", "55" };
-     const char *arr_input_dup[] = { "88", "44", "aa", "55",
-                                     "88", "44", "aa", "55",
-                                     "88", "44", "aa", "55" };
-     const char *res_sorted[] = { "44", "55", "88", "aa" };
-     const char *nearly_55;
+     TEST_ENUMERATION(arr_input, res_sorted);
+}
+
+void test_oid_array__enumerate_duplicate(void)
+{
+     TEST_ENUMERATION(arr_input_dup, res_sorted);
+}
+
+void test_oid_array__lookup(void)
+{
+     TEST_LOOKUP(arr_input, "55", 1, 1);
+}
 
-     if (!TEST(setup(), "setup"))
-             test_skip_all("hash algo initialization failed");
+void test_oid_array__lookup_non_existent(void)
+{
+     TEST_LOOKUP(arr_input, "33", INT_MIN, -1);
+}
+
+void test_oid_array__lookup_duplicates(void)
+{
+     TEST_LOOKUP(arr_input_dup, "55", 3, 5);
+}
 
-     TEST_ENUMERATION(arr_input, res_sorted, "ordered enumeration");
-     TEST_ENUMERATION(arr_input_dup, res_sorted,
-                      "ordered enumeration with duplicate suppression");
+void test_oid_array__lookup_non_existent_dup(void)
+{
+     TEST_LOOKUP(arr_input_dup, "66", INT_MIN, -1);
+}
 
-     TEST_LOOKUP(arr_input, "55", 1, 1, "lookup");
-     TEST_LOOKUP(arr_input, "33", INT_MIN, -1, "lookup non-existent entry");
-     TEST_LOOKUP(arr_input_dup, "55", 3, 5, "lookup with duplicates");
-     TEST_LOOKUP(arr_input_dup, "66", INT_MIN, -1,
-                 "lookup non-existent entry with duplicates");
+void test_oid_array__lookup_almost_dup(void)
+{
+     const char *nearly_55;
 
      nearly_55 = init_hash_algo() == GIT_HASH_SHA1 ?
                      "5500000000000000000000000000000000000001" :
                      "5500000000000000000000000000000000000000000000000000000000000001";
-     TEST_LOOKUP(((const char *[]){ "55", nearly_55 }), "55", 0, 0,
-                 "lookup with almost duplicate values");
-     TEST_LOOKUP(((const char *[]){ "55", "55" }), "55", 0, 1,
-                 "lookup with single duplicate value");
Quoted 9 lines

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 129

Quoted 8 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +6 -1
-     return test_done();
+     TEST_LOOKUP(((const char *[]){ "55", nearly_55 }), "55", 0, 0);
+}
+
+void test_oid_array__lookup_single_dup(void)
+{
+     TEST_LOOKUP(((const char *[]){ "55", "55" }), "55", 0, 1);
  }

Thanks
Seyi

#9 lore raw

Re: [PATCH 2/5] t/unit-tests: convert oid-array test to use clar

Hi Seyi

Quoted 19 lines · Seyi Chamber
Quoted 10 lines · Phillip Wood

Hi Seyi

Quoted 6 lines · Seyi Kuforiji

Adapt oid-array test script to clar framework by using clar assertions where necessary. Remove descriptions from macros to reduce redundancy, and move test input arrays to global scope for reuse across multiple test functions. Introduce test_oid_array__initialize() to explicitly initialize the hash algorithm.

Quoted 7 lines
Quoted 2 lines

These changes streamline the test suite, making individual tests self-contained and reducing redundant code.

I think these conversion look correct but once again we're losing valuable debugging information because we haven't added better assertions to clear.

Quoted 7 lines

I understand your concern about losing debugging information, but it is more beneficial to prioritize clarity and simplicity in unit tests. Unit tests should be short and easy, and adding extra debugging messages increases complexity, making them harder to maintain and read. The assertion failures already indicate where an issue occurs, allowing whoever is debugging to inspect the test inputs directly if needed.

If the test failure is on a CI run for a platform that the person debugging the failure does not have access to how are they going to do that? This is not a hypothetical concern as our CI runs the test suite on MacOs, Linux and Windows. Individual developers often only have access to one or to of those platforms. My experience of debugging CI test failures is that without decent diagnostic messages it is extremely difficult to figure out what went wrong if one does not have access to the platform where the test is failing.

Quoted 4 lines

Assertion failures are rarely hit in real-world scenarios, and when they do occur, one can manually print values or use a debugger to investigate. This makes the additional debugging messages unnecessary in most cases.

This seems to be arguing that because we expect the tests to pass we don't need to worry about how difficult it is to debug them when they fail. I do not agree with that line of argument.

Quoted 6 lines

The lack of explicit debugging output is not a
significant issue in practice. Furthermore, there are plans to collaborate with Clar upstream to equip common assertions with the ability to print custom messages in a formatted string where an error occurs. This would allow our test to be simple and easy to read and also maintain some of our custom debug messages.

Have you got any more details about this please? We already have cl_failf() in our codebase.

Best Wishes

Phillip

Quoted 126 lines
Quoted 28 lines
Quoted 6 lines

       oid_array_for_each_unique(&input, add_to_oid_array, &actual);
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +0 -3
-     if (!check_uint(actual.nr, ==, expect.nr))
-             return;
-

t/unit-tests/u-oid-array.c static void t_enumeration(const char **input_args, size_t input_sz, · line 40

Quoted 10 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +4 -6
-     for (i = 0; i < actual.nr; i++) {
-             if (!check(oideq(&actual.oid[i], &expect.oid[i])))
-                     test_msg("expected: %s\n       got: %s\n     index: %" PRIuMAX,
-                              oid_to_hex(&expect.oid[i]), oid_to_hex(&actual.oid[i]),
-                              (uintmax_t)i);
-     }
+     cl_assert_equal_i(actual.nr, expect.nr);
+
+     for (i = 0; i < actual.nr; i++)
+             cl_assert(oideq(&actual.oid[i], &expect.oid[i]));

If this fails the poor person debugging it will have no idea why as there is now no indication of which two oids were being compared.

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 62

Quoted 5 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +2 -3
-     if (!check_int(ret, <=, upper_bound) ||
-         !check_int(ret, >=, lower_bound))
-             test_msg("oid query for lookup: %s", oid_to_hex(&oid_query));
+     cl_assert(ret <= upper_bound);
+     cl_assert(ret >= lower_bound);

This is another case where we could do with better assertions in clar

Quoted 11 lines

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 75

Quoted 8 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +2 -3
-static void setup(void)
+void test_oid_array__initialize(void)
   {
       /* The hash algo is used by oid_array_lookup() internally */
       int algo = init_hash_algo();
-     if (check_int(algo, !=, GIT_HASH_UNKNOWN))
-             repo_set_hash_algo(the_repository, algo);
+     cl_assert(algo != GIT_HASH_UNKNOWN);

init_has_algo() in unit-test.c already does this.

Thanks for spotting this! Will fix this in an updated patch.

Quoted 73 lines

Best Wishes

Phillip

Quoted 68 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +36 -21
+     repo_set_hash_algo(the_repository, algo);
   }
 
-int cmd_main(int argc UNUSED, const char **argv UNUSED)
+static const char *arr_input[] = { "88", "44", "aa", "55" };
+static const char *arr_input_dup[] = { "88", "44", "aa", "55",
+                                    "88", "44", "aa", "55",
+                                    "88", "44", "aa", "55" };
+static const char *res_sorted[] = { "44", "55", "88", "aa" };
+
+void test_oid_array__enumerate_unique(void)
   {
-     const char *arr_input[] = { "88", "44", "aa", "55" };
-     const char *arr_input_dup[] = { "88", "44", "aa", "55",
-                                     "88", "44", "aa", "55",
-                                     "88", "44", "aa", "55" };
-     const char *res_sorted[] = { "44", "55", "88", "aa" };
-     const char *nearly_55;
+     TEST_ENUMERATION(arr_input, res_sorted);
+}
+
+void test_oid_array__enumerate_duplicate(void)
+{
+     TEST_ENUMERATION(arr_input_dup, res_sorted);
+}
+
+void test_oid_array__lookup(void)
+{
+     TEST_LOOKUP(arr_input, "55", 1, 1);
+}
 
-     if (!TEST(setup(), "setup"))
-             test_skip_all("hash algo initialization failed");
+void test_oid_array__lookup_non_existent(void)
+{
+     TEST_LOOKUP(arr_input, "33", INT_MIN, -1);
+}
+
+void test_oid_array__lookup_duplicates(void)
+{
+     TEST_LOOKUP(arr_input_dup, "55", 3, 5);
+}
 
-     TEST_ENUMERATION(arr_input, res_sorted, "ordered enumeration");
-     TEST_ENUMERATION(arr_input_dup, res_sorted,
-                      "ordered enumeration with duplicate suppression");
+void test_oid_array__lookup_non_existent_dup(void)
+{
+     TEST_LOOKUP(arr_input_dup, "66", INT_MIN, -1);
+}
 
-     TEST_LOOKUP(arr_input, "55", 1, 1, "lookup");
-     TEST_LOOKUP(arr_input, "33", INT_MIN, -1, "lookup non-existent entry");
-     TEST_LOOKUP(arr_input_dup, "55", 3, 5, "lookup with duplicates");
-     TEST_LOOKUP(arr_input_dup, "66", INT_MIN, -1,
-                 "lookup non-existent entry with duplicates");
+void test_oid_array__lookup_almost_dup(void)
+{
+     const char *nearly_55;
 
       nearly_55 = init_hash_algo() == GIT_HASH_SHA1 ?
                       "5500000000000000000000000000000000000001" :
                       "5500000000000000000000000000000000000000000000000000000000000001";
-     TEST_LOOKUP(((const char *[]){ "55", nearly_55 }), "55", 0, 0,
-                 "lookup with almost duplicate values");
-     TEST_LOOKUP(((const char *[]){ "55", "55" }), "55", 0, 1,
-                 "lookup with single duplicate value");
Quoted 9 lines

t/unit-tests/u-oid-array.c static void t_lookup(const char **input_hexes, size_t n, const char *query_hex, · line 129

Quoted 8 lines
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +6 -1
-     return test_done();
+     TEST_LOOKUP(((const char *[]){ "55", nearly_55 }), "55", 0, 0);
+}
+
+void test_oid_array__lookup_single_dup(void)
+{
+     TEST_LOOKUP(((const char *[]){ "55", "55" }), "55", 0, 1);
   }

Thanks
Seyi

#10 lore raw

PATCH 3/5 t/unit-tests: convert oidmap test to use clar

In reply to Seyi Kuforiji

Adapt oidmap test script to clar framework by using clar assertions where necessary. cl_parse_any_oid handles the necessary checks needed for the test to run smoothly.

Introduce 'test_oidmap__initialize handles the to set up of the global oidmap map with predefined key-value pairs, and test_oidmap__cleanup` frees the oidmap and its entries when all tests are completed.

This streamlines the test suite, making individual tests self-contained and reducing redundant code.

---
 Makefile                                |   2 +-
 t/meson.build                           |   2 +-
 t/unit-tests/{t-oidmap.c => u-oidmap.c} | 153 ++++++++----------------
 3 files changed, 54 insertions(+), 103 deletions(-)
 rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%)
Makefile +1 -1
index f8e061365b..58a6af1eb0 100644
@@ -1357,6 +1357,7 @@ CLAR_TEST_SUITES += u-hash
 CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
 CLAR_TEST_SUITES += u-oid-array
+CLAR_TEST_SUITES += u-oidmap
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1367,7 +1368,6 @@ CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 
-UNIT_TEST_PROGRAMS += t-oidmap
 UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
 UNIT_TEST_PROGRAMS += t-reftable-block
t/meson.build +1 -1
index 93410a8545..f9e0ae15df 100644
@@ -5,6 +5,7 @@ clar_test_suites = [
   'unit-tests/u-hashmap.c',
   'unit-tests/u-mem-pool.c',
   'unit-tests/u-oid-array.c',
+  'unit-tests/u-oidmap.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -49,7 +50,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oidmap.c',
   'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
   'unit-tests/t-reftable-block.c',
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +52 -101

215 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#11 lore raw

Re: [PATCH 3/5] t/unit-tests: convert oidmap test to use clar

Hi Seyi

Quoted 3 lines · Seyi Kuforiji

Adapt oidmap test script to clar framework by using clar assertions where necessary. cl_parse_any_oid handles the necessary checks needed for the test to run smoothly.

I'm not sure what the last half of this sentence means. What checks are performed and how does that lead to the test running smoothly?

Quoted 6 lines

Introduce 'test_oidmap__initialize handles the to set up of the global oidmap map with predefined key-value pairs, and test_oidmap__cleanup` frees the oidmap and its entries when all tests are completed.

This streamlines the test suite, making individual tests self-contained and reducing redundant code.

This seems to be saying that by sharing global state we're making the tests self-contained - I'm not sure how that can be true. We need to move to sharing a single oidmap between all the tests because clar's setup and teardown functions don't take a context pointer. That's fine but I don't see how it makes the tests self-contained.

Everything up to this point looks good.

Quoted 15 lines
  	while ((entry = oidmap_iter_next(&iter))) {
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +0 -14
-		int ret;
-		if (!check_int((ret = key_val_contains(entry, seen)), ==, 0)) {
-			switch (ret) {
-			case -1:
-				break; /* error message handled by get_oid_arbitrary_hex() */
-			case 1:
-				test_msg("obtained entry was not given in the input\n"
-					 "  name: %s\n   oid: %s\n",
-					 entry->name, oid_to_hex(&entry->entry.oid));
-				break;
-			case 2:
-				test_msg("duplicate entry detected\n"
-					 "  name: %s\n   oid: %s\n",
-					 entry->name, oid_to_hex(&entry->entry.oid));

t/unit-tests/u-oidmap.c static int key_val_contains(struct test_entry *entry, char seen[]) · line 127

Quoted 10 lines
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +1 -9
-				break;
-			default:
-				test_msg("BUG: invalid return value (%d) from key_val_contains()",
-					 ret);
-				break;
-			}
-		} else {
-			count++;
-		}
+		cl_assert_equal_i(key_val_contains(entry, seen), 0);

I think wed' be better to use clar_fail_f() so that we can keep the helpful error messages. Using cl_assert_equal_i() isn't terrible as if the test fails at least we know the error code but as we already have the logic in place to provide better messages lets adapt it.

There is a change of behavior here as before we'd loop through the whole list of entries detecting all the errors. Now we quit on the first error. I don't think that matters but it would be good to point out the change in the commit message.

Best Wishes

Phillip

#12 lore raw

Re: [PATCH 3/5] t/unit-tests: convert oidmap test to use clar

Quoted 11 lines · On Fri, 21 Feb 2025 at 11:04, <[email protected]> wrote:

Hi Seyi

Quoted 3 lines · Seyi Kuforiji

Adapt oidmap test script to clar framework by using clar assertions where necessary. cl_parse_any_oid handles the necessary checks needed for the test to run smoothly.

I'm not sure what the last half of this sentence means. What checks are performed and how does that lead to the test running smoothly?

cl_parse_any_oid() ensures the hash algorithm is set before parsing. This prevents issues from an uninitialized or invalid hash algorithm. Without these checks, the test could behave unpredictably. I’ll update the commit message to make this clearer.

Quoted 4 lines
Quoted 4 lines

Introduce 'test_oidmap__initialize handles the to set up of the global oidmap map with predefined key-value pairs, and test_oidmap__cleanup` frees the oidmap and its entries when all tests are completed.

Quoted 9 lines
Quoted 2 lines

This streamlines the test suite, making individual tests self-contained and reducing redundant code.

This seems to be saying that by sharing global state we're making the tests self-contained - I'm not sure how that can be true. We need to move to sharing a single oidmap between all the tests because clar's setup and teardown functions don't take a context pointer. That's fine but I don't see how it makes the tests self-contained.

Right! Thank you. I'll adjust the commit message accordingly.

Quoted 33 lines

Everything up to this point looks good.

Quoted 15 lines
      while ((entry = oidmap_iter_next(&iter))) {
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +0 -14
-             int ret;
-             if (!check_int((ret = key_val_contains(entry, seen)), ==, 0)) {
-                     switch (ret) {
-                     case -1:
-                             break; /* error message handled by get_oid_arbitrary_hex() */
-                     case 1:
-                             test_msg("obtained entry was not given in the input\n"
-                                      "  name: %s\n   oid: %s\n",
-                                      entry->name, oid_to_hex(&entry->entry.oid));
-                             break;
-                     case 2:
-                             test_msg("duplicate entry detected\n"
-                                      "  name: %s\n   oid: %s\n",
-                                      entry->name, oid_to_hex(&entry->entry.oid));

t/unit-tests/u-oidmap.c static int key_val_contains(struct test_entry *entry, char seen[]) · line 127

Quoted 10 lines
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +1 -9
-                             break;
-                     default:
-                             test_msg("BUG: invalid return value (%d) from key_val_contains()",
-                                      ret);
-                             break;
-                     }
-             } else {
-                     count++;
-             }
+             cl_assert_equal_i(key_val_contains(entry, seen), 0);

I think wed' be better to use clar_fail_f() so that we can keep the helpful error messages. Using cl_assert_equal_i() isn't terrible as if the test fails at least we know the error code but as we already have the logic in place to provide better messages lets adapt it.

Quoted 8 lines

There is a change of behavior here as before we'd loop through the whole list of entries detecting all the errors. Now we quit on the first error. I don't think that matters but it would be good to point out the change in the commit message.

Best Wishes

Phillip

Noted! thank you.
Seyi

#13 lore raw

PATCH 4/5 t/unit-tests: convert oidtree test to use clar

In reply to Seyi Kuforiji

Adapt oidtree test script to clar framework by using clar assertions where necessary. cl_parse_any_oid handles the necessary checks needed for the test to run smoothly.

Introduce 'test_oidtree__initialize handles the to set up of the global oidtree variable and test_oidtree__cleanup` frees the oidtree when all tests are completed.

This streamlines the test suite, making individual tests self-contained and reducing redundant code.

---
 Makefile                                  |  2 +-
 t/meson.build                             |  2 +-
 t/unit-tests/{t-oidtree.c => u-oidtree.c} | 78 +++++++++--------------
 3 files changed, 32 insertions(+), 50 deletions(-)
 rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (44%)
Makefile +1 -1
index 58a6af1eb0..feb01702c7 100644
@@ -1358,6 +1358,7 @@ CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
 CLAR_TEST_SUITES += u-oid-array
 CLAR_TEST_SUITES += u-oidmap
+CLAR_TEST_SUITES += u-oidtree
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1368,7 +1369,6 @@ CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 
-UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
 UNIT_TEST_PROGRAMS += t-reftable-block
 UNIT_TEST_PROGRAMS += t-reftable-merged
t/meson.build +1 -1
index f9e0ae15df..0b412a7c16 100644
@@ -6,6 +6,7 @@ clar_test_suites = [
   'unit-tests/u-mem-pool.c',
   'unit-tests/u-oid-array.c',
   'unit-tests/u-oidmap.c',
+  'unit-tests/u-oidtree.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -50,7 +51,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
   'unit-tests/t-reftable-block.c',
   'unit-tests/t-reftable-merged.c',
t/unit-tests/u-oidtree.c renamed from t/unit-tests/t-oidtree.c +30 -48

125 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#14 lore raw

Re: [PATCH 4/5] t/unit-tests: convert oidtree test to use clar

Hi Seyi

Quoted 10 lines · Seyi Kuforiji

Adapt oidtree test script to clar framework by using clar assertions where necessary. cl_parse_any_oid handles the necessary checks needed for the test to run smoothly.

Introduce 'test_oidtree__initialize handles the to set up of the global oidtree variable and test_oidtree__cleanup` frees the oidtree when all tests are completed.

This streamlines the test suite, making individual tests self-contained and reducing redundant code.

My comments on the commit message for the last patch apply here as well.

t/unit-tests/u-oidtree.c static enum cb_next check_each_cb(const struct object_id *oid, void *data) · line 48

Quoted 10 lines
t/unit-tests/u-oidtree.c renamed from t/unit-tests/t-oidtree.c +3 -6
-	if (!check_int(get_oid_arbitrary_hex(hex_iter->expected_hexes.v[hex_iter->i],
-					     &expected), ==, 0))
-		; /* the data is bogus and cannot be used */
-	else if (!check(oideq(oid, &expected)))
-		test_msg("expected: %s\n       got: %s\n     query: %s",
-			 oid_to_hex(&expected), oid_to_hex(oid), hex_iter->query);
+	cl_assert(hex_iter->i < hex_iter->expected_hexes.nr);
 
+	cl_parse_any_oid(hex_iter->expected_hexes.v[hex_iter->i],
+			 &expected);

using cl_parse_any_oid() means that it is safe to dispense with the check on the return value because we now do that check in cl_parse_oid().

t/unit-tests/u-oidtree.c static enum cb_next check_each_cb(const struct object_id *oid, void *data) · line 49

Quoted 1 line
t/unit-tests/u-oidtree.c renamed from t/unit-tests/t-oidtree.c +1 -0
+	cl_assert_equal_s(oid_to_hex(oid), oid_to_hex(&expected));

This is nice - we'll get a message containing the two oid's if they don't match. We should use the same trick in patch 2.

As with the last patch we now bail out after the first error, we should mention that in the commit message.

t/unit-tests/u-oidtree.c static void check_each(struct oidtree *ot, const char *query, ...) · line 71

Quoted 3 lines
t/unit-tests/u-oidtree.c renamed from t/unit-tests/t-oidtree.c +1 -2
-	if (!check_int(hex_iter.i, ==, hex_iter.expected_hexes.nr))
-		test_msg("error: could not find some 'object_id's for query ('%s')", query);
+	cl_assert_equal_i(hex_iter.i, hex_iter.expected_hexes.nr);

Using cl_failf() here would enable us to keep the message so that if the test fails we can see which query it was that failed.

Apart from that last point this is looking good

Best Wishes

Phillip

#15 lore raw

PATCH 5/5 t/unit-tests: remove lib-oid.{c,h,o}

In reply to Seyi Kuforiji

The lib-oid.c, lib-oid.h, and lib-oid.o files are no longer needed since their equivalent functions have been implemented in unit-test.c and unit-test.h. This removes redundant code and ensures all unit test-related functionality is consolidated in a single location.

Drop references to lib-oid from our Makefile, and meson.build files to prevent build errors due to missing files.

---
 Makefile               |  1 -
 t/meson.build          |  1 -
 t/unit-tests/lib-oid.c | 52 ------------------------------------------
 t/unit-tests/lib-oid.h | 25 --------------------
 4 files changed, 79 deletions(-)
 delete mode 100644 t/unit-tests/lib-oid.c
 delete mode 100644 t/unit-tests/lib-oid.h
Makefile +0 -1
index feb01702c7..6afa6587ba 100644
@@ -1381,7 +1381,6 @@ UNIT_TEST_PROGRAMS += t-trailer
 UNIT_TEST_PROGRAMS += t-urlmatch-normalization
 UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
 UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
-UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
 
 # xdiff and reftable libs may in turn depend on what is in libgit.a
t/meson.build +0 -1
index 0b412a7c16..c1c4aa32aa 100644
@@ -68,7 +68,6 @@ foreach unit_test_program : unit_test_programs
   unit_test = executable(unit_test_name,
     sources: [
       'unit-tests/test-lib.c',
-      'unit-tests/lib-oid.c',
       'unit-tests/lib-reftable.c',
       unit_test_program,
     ],
t/unit-tests/lib-oid.c deleted +0 -52

52 lines not on this page · raw message

t/unit-tests/lib-oid.h deleted +0 -25
deleted file mode 100644
index 4e77c04bd2..0000000000
@@ -1,25 +0,0 @@
-#ifndef LIB_OID_H
-#define LIB_OID_H
-
-#include "hash.h"
-
-/*
- * Convert arbitrary hex string to object_id.
- * For example, passing "abc12" will generate
- * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
- * create object_id with that.
- * WARNING: passing a string of length more than the hexsz of respective hash
- * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
- * environment variable.
- */
-int get_oid_arbitrary_hex(const char *s, struct object_id *oid);
-/*
- * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
- * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
- * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
- * check(algo != GIT_HASH_UNKNOWN) before returning to verify if the
- * GIT_TEST_DEFAULT_HASH's value is valid or not.
- */
-int init_hash_algo(void);
-
-#endif /* LIB_OID_H */
Signature · 1 line
2.47.0.86.g15030f9556
#16 lore raw
In reply to Seyi Kuforiji

Hi Seyi

Quoted 6 lines · Seyi Kuforiji

Hello,

This small patch series transitions a couple more of our existing unit test files to the Clar testing framework. This change is part of our ongoing effort to standardize our testing framework to enhance maintainability.

Overall I think the conversions are correct, but we'd be better to keep the diagnostic messages by using cl_failf().

Best Wishes

Phillip

Quoted 29 lines

Thanks
Seyi

Seyi Kuforiji (5):
t/unit-tests: implement oid helper functions in unit-tests.{c,h} t/unit-tests: convert oid-array test to use clar test framework t/unit-tests: convert oidmap test to use clar test framework t/unit-tests: convert oidtree test to use clar test framework t/unit-tests: remove lib-oid.{c,h,o}

  Makefile                                      |   7 +-
  t/meson.build                                 |   7 +-
  t/unit-tests/lib-oid.c                        |  52 ------
  t/unit-tests/lib-oid.h                        |  25 ---
  t/unit-tests/{t-oid-array.c => u-oid-array.c} | 123 +++++++-------
  t/unit-tests/{t-oidmap.c => u-oidmap.c}       | 153 ++++++------------
  t/unit-tests/{t-oidtree.c => u-oidtree.c}     |  78 ++++-----
  t/unit-tests/unit-test.c                      |  42 +++++
  t/unit-tests/unit-test.h                      |  19 +++
  9 files changed, 212 insertions(+), 294 deletions(-)

delete mode 100644 t/unit-tests/lib-oid.c
delete mode 100644 t/unit-tests/lib-oid.h
rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (35%) rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%) rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (44%)

#17 lore raw

v2 cover t/unit-tests: convert unit-tests to use clar

In reply to Seyi Kuforiji

Hello,

This small patch series transitions a couple more of our existing unit test files to the Clar testing framework. This change is part of our ongoing effort to standardize our testing framework to enhance maintainability.

Changes in v2:
- fixes to the commit messages and how they read
- some code refactoring based on review

Thanks
Seyi

Seyi Kuforiji (4):
t/unit-tests: implement clar specific oid helper functions t/unit-tests: convert oid-array test to use clar test framework t/unit-tests: convert oidmap test to use clar test framework t/unit-tests: convert oidtree test to use clar test framework

 Makefile                                      |   8 +-
 t/meson.build                                 |   8 +-
 t/unit-tests/lib-oid.c                        |  31 ++--
 t/unit-tests/lib-oid.h                        |   9 +-
 t/unit-tests/{t-oid-array.c => u-oid-array.c} | 125 +++++++-------
 t/unit-tests/{t-oidmap.c => u-oidmap.c}       | 153 +++++++-----------
 t/unit-tests/{t-oidtree.c => u-oidtree.c}     |  79 ++++-----
 t/unit-tests/unit-test.c                      |   2 +
 8 files changed, 177 insertions(+), 238 deletions(-)
 rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (34%)
 rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%)
 rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (45%)

Range-diff against v1:

1:  19192c6c89 < -:  ---------- t/unit-tests: implement oid helper functions in unit-tests.{c,h}
5:  e81ec73f27 ! 1:  7f14d0d574 t/unit-tests: remove lib-oid.{c,h,o}
    @@ Metadata
     Author: Seyi Kuforiji <[email protected]>
     
      ## Commit message ##
    -    t/unit-tests: remove lib-oid.{c,h,o}
    +    t/unit-tests: implement clar specific oid helper functions
     
    -    The `lib-oid.c`, `lib-oid.h`, and `lib-oid.o files` are no longer needed
    -    since their equivalent functions have been implemented in unit-test.c
    -    and unit-test.h. This removes redundant code and ensures all unit
    -    test-related functionality is consolidated in a single location.
    +    `get_oid_arbitrary_hex()` and `init_hash_algo()` are both required for
    +    oid-related tests to run without errors. In the current implementation,
    +    both functions are defined and declared in the
    +    `t/unit-tests/lib-oid.{c,h}` which is utilized by oid-related tests in
    +    the homegrown unit tests structure.
     
    -    Drop references to lib-oid from our `Makefile`, and `meson.build` files
    -    to prevent build errors due to missing files.
    +    Adapt functions in lib-oid.{c,h} to use clar. Both these functions
    +    become available for oid-related test files implemented using the clar
    +    testing framework, which requires them. This will be used by subsequent
    +    commits.
     
         Mentored-by: Patrick Steinhardt <[email protected]>
         Signed-off-by: Seyi Kuforiji <[email protected]>
     
      ## Makefile ##
    +@@ Makefile: CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)
    + CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
    + CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
    + CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
    ++CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
    + 
    + UNIT_TEST_PROGRAMS += t-oid-array
    + UNIT_TEST_PROGRAMS += t-oidmap
     @@ Makefile: UNIT_TEST_PROGRAMS += t-trailer
      UNIT_TEST_PROGRAMS += t-urlmatch-normalization
      UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
    @@ Makefile: UNIT_TEST_PROGRAMS += t-trailer
      # xdiff and reftable libs may in turn depend on what is in libgit.a
     
      ## t/meson.build ##
    +@@ t/meson.build: clar_test_suites = [
    + clar_sources = [
    +   'unit-tests/clar/clar.c',
    +   'unit-tests/unit-test.c',
    ++  'unit-tests/lib-oid.c'
    + ]
    + 
    + clar_decls_h = custom_target(
     @@ t/meson.build: foreach unit_test_program : unit_test_programs
        unit_test = executable(unit_test_name,
          sources: [
    @@ t/meson.build: foreach unit_test_program : unit_test_programs
            unit_test_program,
          ],
     
    - ## t/unit-tests/lib-oid.c (deleted) ##
    + ## t/unit-tests/lib-oid.c ##
     @@
     -#include "test-lib.h"
    --#include "lib-oid.h"
    --#include "strbuf.h"
    --#include "hex.h"
    --
    ++#include "unit-test.h"
    + #include "lib-oid.h"
    + #include "strbuf.h"
    + #include "hex.h"
    + 
     -int init_hash_algo(void)
    --{
    --	static int algo = -1;
    --
    --	if (algo < 0) {
    --		const char *algo_name = getenv("GIT_TEST_DEFAULT_HASH");
    --		algo = algo_name ? hash_algo_by_name(algo_name) : GIT_HASH_SHA1;
    --
    ++int cl_setup_hash_algo(void)
    + {
    + 	static int algo = -1;
    + 
    +@@ t/unit-tests/lib-oid.c: int init_hash_algo(void)
    + 		const char *algo_name = getenv("GIT_TEST_DEFAULT_HASH");
    + 		algo = algo_name ? hash_algo_by_name(algo_name) : GIT_HASH_SHA1;
    + 
     -		if (!check(algo != GIT_HASH_UNKNOWN))
     -			test_msg("BUG: invalid GIT_TEST_DEFAULT_HASH value ('%s')",
     -				 algo_name);
    --	}
    --	return algo;
    --}
    --
    ++		cl_assert(algo != GIT_HASH_UNKNOWN);
    + 	}
    + 	return algo;
    + }
    + 
     -static int get_oid_arbitrary_hex_algop(const char *hex, struct object_id *oid,
    --				       const struct git_hash_algo *algop)
    --{
    --	int ret;
    --	size_t sz = strlen(hex);
    --	struct strbuf buf = STRBUF_INIT;
    --
    ++static void cl_parse_oid(const char *hex, struct object_id *oid,
    + 				       const struct git_hash_algo *algop)
    + {
    + 	int ret;
    + 	size_t sz = strlen(hex);
    + 	struct strbuf buf = STRBUF_INIT;
    + 
     -	if (!check(sz <= algop->hexsz)) {
     -		test_msg("BUG: hex string (%s) bigger than maximum allowed (%lu)",
     -			 hex, (unsigned long)algop->hexsz);
     -		return -1;
     -	}
    --
    --	strbuf_add(&buf, hex, sz);
    --	strbuf_addchars(&buf, '0', algop->hexsz - sz);
    --
    ++	cl_assert(sz <= algop->hexsz);
    + 
    + 	strbuf_add(&buf, hex, sz);
    + 	strbuf_addchars(&buf, '0', algop->hexsz - sz);
    + 
     -	ret = get_oid_hex_algop(buf.buf, oid, algop);
     -	if (!check_int(ret, ==, 0))
     -		test_msg("BUG: invalid hex input (%s) provided", hex);
    --
    --	strbuf_release(&buf);
    ++	cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);
    + 
    + 	strbuf_release(&buf);
     -	return ret;
    --}
    --
    + }
    + 
     -int get_oid_arbitrary_hex(const char *hex, struct object_id *oid)
    --{
    ++
    ++void cl_parse_any_oid(const char *hex, struct object_id *oid)
    + {
     -	int hash_algo = init_hash_algo();
    --
    ++	int hash_algo = cl_setup_hash_algo();
    + 
     -	if (!check_int(hash_algo, !=, GIT_HASH_UNKNOWN))
     -		return -1;
     -	return get_oid_arbitrary_hex_algop(hex, oid, &hash_algos[hash_algo]);
    --}
    ++	cl_assert(hash_algo != GIT_HASH_UNKNOWN);
    ++	cl_parse_oid(hex, oid, &hash_algos[hash_algo]);
    + }
     
    - ## t/unit-tests/lib-oid.h (deleted) ##
    + ## t/unit-tests/lib-oid.h ##
    +@@
    + 
    + /*
    +  * Convert arbitrary hex string to object_id.
    ++ *
    +  * For example, passing "abc12" will generate
    +  * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
    +  * create object_id with that.
     @@
    --#ifndef LIB_OID_H
    --#define LIB_OID_H
    --
    --#include "hash.h"
    --
    --/*
    -- * Convert arbitrary hex string to object_id.
    -- * For example, passing "abc12" will generate
    -- * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
    -- * create object_id with that.
    -- * WARNING: passing a string of length more than the hexsz of respective hash
    -- * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
    -- * environment variable.
    -- */
    +  * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
    +  * environment variable.
    +  */
     -int get_oid_arbitrary_hex(const char *s, struct object_id *oid);
    --/*
    -- * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
    -- * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
    -- * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
    ++
    ++void cl_parse_any_oid (const char *s, struct object_id *oid);
    + /*
    +  * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
    +  * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
    +  * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
     - * check(algo != GIT_HASH_UNKNOWN) before returning to verify if the
    -- * GIT_TEST_DEFAULT_HASH's value is valid or not.
    -- */
    ++ * cl_assert(algo != GIT_HASH_UNKNOWN) before returning to verify if the
    +  * GIT_TEST_DEFAULT_HASH's value is valid or not.
    +  */
     -int init_hash_algo(void);
    --
    --#endif /* LIB_OID_H */
    ++
    ++int cl_setup_hash_algo(void);
    + 
    + #endif /* LIB_OID_H */
    +
    + ## t/unit-tests/unit-test.c ##
    +@@
    + #include "unit-test.h"
    ++#include "hex.h"
    + #include "parse-options.h"
    ++#include "strbuf.h"
    + #include "string-list.h"
    + #include "strvec.h"
    + 
2:  8a99bbdc31 ! 2:  430f5c5007 t/unit-tests: convert oid-array test to use clar test framework
    @@ Makefile: CLAR_TEST_SUITES += u-example-decorate
      CLAR_TEST_SUITES += u-prio-queue
      CLAR_TEST_SUITES += u-reftable-tree
      CLAR_TEST_SUITES += u-strbuf
    -@@ Makefile: CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
    - CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
    +@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
      CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
    + CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
      
     -UNIT_TEST_PROGRAMS += t-oid-array
      UNIT_TEST_PROGRAMS += t-oidmap
    @@ t/unit-tests/u-oid-array.c (new)
     +#define USE_THE_REPOSITORY_VARIABLE
     +
     +#include "unit-test.h"
    ++#include "lib-oid.h"
     +#include "oid-array.h"
     +#include "hex.h"
     +
    @@ t/unit-tests/u-oid-array.c (new)
     +void test_oid_array__initialize(void)
     +{
     +	/* The hash algo is used by oid_array_lookup() internally */
    -+	int algo = init_hash_algo();
    -+	cl_assert(algo != GIT_HASH_UNKNOWN);
    ++	int algo = cl_setup_hash_algo();
     +	repo_set_hash_algo(the_repository, algo);
     +}
     +
    @@ t/unit-tests/u-oid-array.c (new)
     +{
     +	const char *nearly_55;
     +
    -+	nearly_55 = init_hash_algo() == GIT_HASH_SHA1 ?
    ++	nearly_55 = cl_setup_hash_algo() == GIT_HASH_SHA1 ?
     +			"5500000000000000000000000000000000000001" :
     +			"5500000000000000000000000000000000000000000000000000000000000001";
     +
3:  c19545e2bc ! 3:  319cea1265 t/unit-tests: convert oidmap test to use clar test framework
    @@ Commit message
         t/unit-tests: convert oidmap test to use clar test framework
     
         Adapt oidmap test script to clar framework by using clar assertions
    -    where necessary. `cl_parse_any_oid` handles the necessary checks needed
    -    for the test to run smoothly.
    +    where necessary. `cl_parse_any_oid()` ensures the hash algorithm is set
    +    before parsing. This prevents issues from an uninitialized or invalid
    +    hash algorithm.
     
         Introduce 'test_oidmap__initialize` handles the to set up of the global
         oidmap map with predefined key-value pairs, and `test_oidmap__cleanup`
         frees the oidmap and its entries when all tests are completed.
     
    -    This streamlines the test suite, making individual tests self-contained
    -    and reducing redundant code.
    +    The test loops through all entries to detect multiple errors. With this
    +    change, it stops at the first error encountered, making it easier to
    +    address it.
     
         Mentored-by: Patrick Steinhardt <[email protected]>
         Signed-off-by: Seyi Kuforiji <[email protected]>
    @@ Makefile: CLAR_TEST_SUITES += u-hash
      CLAR_TEST_SUITES += u-prio-queue
      CLAR_TEST_SUITES += u-reftable-tree
      CLAR_TEST_SUITES += u-strbuf
    -@@ Makefile: CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
    - CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
    +@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
      CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
    + CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
      
     -UNIT_TEST_PROGRAMS += t-oidmap
      UNIT_TEST_PROGRAMS += t-oidtree
    @@ t/unit-tests/t-oidmap.c (deleted)
      ## t/unit-tests/u-oidmap.c (new) ##
     @@
     +#include "unit-test.h"
    ++#include "lib-oid.h"
     +#include "oidmap.h"
     +#include "hash.h"
     +#include "hex.h"
    @@ t/unit-tests/u-oidmap.c (new)
     +
     +	oidmap_iter_init(&map, &iter);
     +	while ((entry = oidmap_iter_next(&iter))) {
    -+		cl_assert_equal_i(key_val_contains(entry, seen), 0);
    ++		if (key_val_contains(entry, seen) != 0) {
    ++			cl_failf("Unexpected entry: name = %s, oid = %s",
    ++				 entry->name, oid_to_hex(&entry->entry.oid));
    ++		}
     +		count++;
     +	}
     +	cl_assert_equal_i(count, ARRAY_SIZE(key_val));
4:  733b53cd05 ! 4:  ea63a5c9f1 t/unit-tests: convert oidtree test to use clar test framework
    @@ Commit message
         t/unit-tests: convert oidtree test to use clar test framework
     
         Adapt oidtree test script to clar framework by using clar assertions
    -    where necessary. `cl_parse_any_oid` handles the necessary checks needed
    -    for the test to run smoothly.
    +    where necessary. `cl_parse_any_oid()` ensures the hash algorithm is set
    +    before parsing. This prevents issues from an uninitialized or invalid
    +    hash algorithm.
     
         Introduce 'test_oidtree__initialize` handles the to set up of the global
         oidtree variable and `test_oidtree__cleanup` frees the oidtree when all
         tests are completed.
     
    -    This streamlines the test suite, making individual tests self-contained
    -    and reducing redundant code.
    +    With this change, `check_each` stops at the first error encountered,
    +    making it easier to address it.
     
         Mentored-by: Patrick Steinhardt <[email protected]>
         Signed-off-by: Seyi Kuforiji <[email protected]>
    @@ Makefile: CLAR_TEST_SUITES += u-hashmap
      CLAR_TEST_SUITES += u-prio-queue
      CLAR_TEST_SUITES += u-reftable-tree
      CLAR_TEST_SUITES += u-strbuf
    -@@ Makefile: CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
    - CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
    +@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
      CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
    + CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
      
     -UNIT_TEST_PROGRAMS += t-oidtree
      UNIT_TEST_PROGRAMS += t-reftable-basics
    @@ t/unit-tests/t-oidtree.c (deleted)
      ## t/unit-tests/u-oidtree.c (new) ##
     @@
     +#include "unit-test.h"
    ++#include "lib-oid.h"
     +#include "oidtree.h"
     +#include "hash.h"
     +#include "hex.h"
    @@ t/unit-tests/u-oidtree.c (new)
     +	cl_parse_any_oid(query, &oid);
     +	oidtree_each(ot, &oid, strlen(query), check_each_cb, &hex_iter);
     +
    -+	cl_assert_equal_i(hex_iter.i, hex_iter.expected_hexes.nr);
    ++	if (hex_iter.i != hex_iter.expected_hexes.nr)
    ++		cl_failf("error: could not find some 'object_id's for query ('%s')", query);
    ++
     +	strvec_clear(&hex_iter.expected_hexes);
     +}
     +
Signature · 1 line
2.47.0.86.g15030f9556
#18 lore raw

PATCH v2 1/4 t/unit-tests: implement clar specific oid helper functions

get_oid_arbitrary_hex() and init_hash_algo() are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in the t/unit-tests/lib-oid.{c,h} which is utilized by oid-related tests in the homegrown unit tests structure.

Adapt functions in lib-oid.{c,h} to use clar. Both these functions become available for oid-related test files implemented using the clar testing framework, which requires them. This will be used by subsequent commits.

---
 Makefile                 |  2 +-
 t/meson.build            |  2 +-
 t/unit-tests/lib-oid.c   | 31 +++++++++++--------------------
 t/unit-tests/lib-oid.h   |  9 ++++++---
 t/unit-tests/unit-test.c |  2 ++
 5 files changed, 21 insertions(+), 25 deletions(-)
Makefile +1 -1
index bcf5ed3f85..81799488f0 100644
@@ -1365,6 +1365,7 @@ CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)
 CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
 UNIT_TEST_PROGRAMS += t-oid-array
 UNIT_TEST_PROGRAMS += t-oidmap
@@ -1381,7 +1382,6 @@ UNIT_TEST_PROGRAMS += t-trailer
 UNIT_TEST_PROGRAMS += t-urlmatch-normalization
 UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
 UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
-UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
 
 # xdiff and reftable libs may in turn depend on what is in libgit.a
t/meson.build +1 -1
index 780939d49f..862cf1cfd4 100644
@@ -14,6 +14,7 @@ clar_test_suites = [
 clar_sources = [
   'unit-tests/clar/clar.c',
   'unit-tests/unit-test.c',
+  'unit-tests/lib-oid.c'
 ]
 
 clar_decls_h = custom_target(
@@ -68,7 +69,6 @@ foreach unit_test_program : unit_test_programs
   unit_test = executable(unit_test_name,
     sources: [
       'unit-tests/test-lib.c',
-      'unit-tests/lib-oid.c',
       'unit-tests/lib-reftable.c',
       unit_test_program,
     ],
t/unit-tests/lib-oid.c +11 -20
index 8f0ccac532..8bf09ea1cb 100644
@@ -1,9 +1,9 @@
-#include "test-lib.h"
+#include "unit-test.h"
 #include "lib-oid.h"
 #include "strbuf.h"
 #include "hex.h"
 
-int init_hash_algo(void)
+int cl_setup_hash_algo(void)
 {
 	static int algo = -1;
 
@@ -11,42 +11,33 @@ int init_hash_algo(void)
 		const char *algo_name = getenv("GIT_TEST_DEFAULT_HASH");
 		algo = algo_name ? hash_algo_by_name(algo_name) : GIT_HASH_SHA1;
 
-		if (!check(algo != GIT_HASH_UNKNOWN))
-			test_msg("BUG: invalid GIT_TEST_DEFAULT_HASH value ('%s')",
-				 algo_name);
+		cl_assert(algo != GIT_HASH_UNKNOWN);
 	}
 	return algo;
 }
 
-static int get_oid_arbitrary_hex_algop(const char *hex, struct object_id *oid,
+static void cl_parse_oid(const char *hex, struct object_id *oid,
 				       const struct git_hash_algo *algop)
 {
 	int ret;
 	size_t sz = strlen(hex);
 	struct strbuf buf = STRBUF_INIT;
 
-	if (!check(sz <= algop->hexsz)) {
-		test_msg("BUG: hex string (%s) bigger than maximum allowed (%lu)",
-			 hex, (unsigned long)algop->hexsz);
-		return -1;
-	}
+	cl_assert(sz <= algop->hexsz);
 
 	strbuf_add(&buf, hex, sz);
 	strbuf_addchars(&buf, '0', algop->hexsz - sz);
 
-	ret = get_oid_hex_algop(buf.buf, oid, algop);
-	if (!check_int(ret, ==, 0))
-		test_msg("BUG: invalid hex input (%s) provided", hex);
+	cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);
 
 	strbuf_release(&buf);
-	return ret;
 }
 
-int get_oid_arbitrary_hex(const char *hex, struct object_id *oid)
+
+void cl_parse_any_oid(const char *hex, struct object_id *oid)
 {
-	int hash_algo = init_hash_algo();
+	int hash_algo = cl_setup_hash_algo();
 
-	if (!check_int(hash_algo, !=, GIT_HASH_UNKNOWN))
-		return -1;
-	return get_oid_arbitrary_hex_algop(hex, oid, &hash_algos[hash_algo]);
+	cl_assert(hash_algo != GIT_HASH_UNKNOWN);
+	cl_parse_oid(hex, oid, &hash_algos[hash_algo]);
 }
t/unit-tests/lib-oid.h +6 -3
index 4e77c04bd2..4031775104 100644
@@ -5,6 +5,7 @@
 
 /*
  * Convert arbitrary hex string to object_id.
+ *
  * For example, passing "abc12" will generate
  * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
  * create object_id with that.
@@ -12,14 +13,16 @@
  * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
  * environment variable.
  */
-int get_oid_arbitrary_hex(const char *s, struct object_id *oid);
+
+void cl_parse_any_oid (const char *s, struct object_id *oid);
 /*
  * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
  * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
  * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
- * check(algo != GIT_HASH_UNKNOWN) before returning to verify if the
+ * cl_assert(algo != GIT_HASH_UNKNOWN) before returning to verify if the
  * GIT_TEST_DEFAULT_HASH's value is valid or not.
  */
-int init_hash_algo(void);
+
+int cl_setup_hash_algo(void);
 
 #endif /* LIB_OID_H */
t/unit-tests/unit-test.c +2 -0
index fa8818842a..5af645048a 100644
@@ -1,5 +1,7 @@
 #include "unit-test.h"
+#include "hex.h"
 #include "parse-options.h"
+#include "strbuf.h"
 #include "string-list.h"
 #include "strvec.h"
 
Signature · 1 line
2.47.0.86.g15030f9556
#19 lore raw

Re: [PATCH v2 1/4] t/unit-tests: implement clar specific oid helper functions

Quoted 16 lines · Seyi Kuforiji
t/unit-tests/lib-oid.c +2 -6
-static int get_oid_arbitrary_hex_algop(const char *hex, struct object_id *oid,
+static void cl_parse_oid(const char *hex, struct object_id *oid,
 				       const struct git_hash_algo *algop)
 {
 	int ret;
 	size_t sz = strlen(hex);
 	struct strbuf buf = STRBUF_INIT;
 
-	if (!check(sz <= algop->hexsz)) {
-		test_msg("BUG: hex string (%s) bigger than maximum allowed (%lu)",
-			 hex, (unsigned long)algop->hexsz);
-		return -1;
-	}
+	cl_assert(sz <= algop->hexsz);
 
 	strbuf_add(&buf, hex, sz);

t/unit-tests/lib-oid.c int init_hash_algo(void) · line 34

Quoted 10 lines
t/unit-tests/lib-oid.c +1 -4
 	strbuf_addchars(&buf, '0', algop->hexsz - sz);
 
-	ret = get_oid_hex_algop(buf.buf, oid, algop);
-	if (!check_int(ret, ==, 0))
-		test_msg("BUG: invalid hex input (%s) provided", hex);
+	cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);
 
 	strbuf_release(&buf);
-	return ret;
 }

As you are not returning "ret" and making the function void, you made "int ret" an unused variable that needs removing.

Thanks.

#20 lore raw

Re: [PATCH v2 1/4] t/unit-tests: implement clar specific oid helper functions

Quoted 26 lines · Junio C Hamano
Quoted 23 lines · Seyi Kuforiji
t/unit-tests/lib-oid.c +3 -9
-static int get_oid_arbitrary_hex_algop(const char *hex, struct object_id *oid,
+static void cl_parse_oid(const char *hex, struct object_id *oid,
                                     const struct git_hash_algo *algop)
 {
      int ret;
      size_t sz = strlen(hex);
      struct strbuf buf = STRBUF_INIT;
 
-     if (!check(sz <= algop->hexsz)) {
-             test_msg("BUG: hex string (%s) bigger than maximum allowed (%lu)",
-                      hex, (unsigned long)algop->hexsz);
-             return -1;
-     }
+     cl_assert(sz <= algop->hexsz);
 
      strbuf_add(&buf, hex, sz);
      strbuf_addchars(&buf, '0', algop->hexsz - sz);
 
-     ret = get_oid_hex_algop(buf.buf, oid, algop);
-     if (!check_int(ret, ==, 0))
-             test_msg("BUG: invalid hex input (%s) provided", hex);
+     cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);
Quoted 8 lines
Quoted 3 lines
      strbuf_release(&buf);

- return ret;
}

As you are not returning "ret" and making the function void, you made "int ret" an unused variable that needs removing.

Thanks.

Hi Junio,

Do I send in a new patch series addressing this?

Thanks,
Seyi

#21 lore raw

Re: [PATCH v2 1/4] t/unit-tests: implement clar specific oid helper functions

Quoted 34 lines · Seyi Chamber
Quoted 33 lines · Junio C Hamano
Quoted 16 lines · Seyi Kuforiji
t/unit-tests/lib-oid.c +2 -6
-static int get_oid_arbitrary_hex_algop(const char *hex, struct object_id *oid,
+static void cl_parse_oid(const char *hex, struct object_id *oid,
                                     const struct git_hash_algo *algop)
 {
      int ret;
      size_t sz = strlen(hex);
      struct strbuf buf = STRBUF_INIT;
 
-     if (!check(sz <= algop->hexsz)) {
-             test_msg("BUG: hex string (%s) bigger than maximum allowed (%lu)",
-                      hex, (unsigned long)algop->hexsz);
-             return -1;
-     }
+     cl_assert(sz <= algop->hexsz);
 
      strbuf_add(&buf, hex, sz);

t/unit-tests/lib-oid.c int init_hash_algo(void) · line 34

Quoted 10 lines
t/unit-tests/lib-oid.c +1 -4
      strbuf_addchars(&buf, '0', algop->hexsz - sz);
 
-     ret = get_oid_hex_algop(buf.buf, oid, algop);
-     if (!check_int(ret, ==, 0))
-             test_msg("BUG: invalid hex input (%s) provided", hex);
+     cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);
 
      strbuf_release(&buf);
-     return ret;
 }

As you are not returning "ret" and making the function void, you made "int ret" an unused variable that needs removing.

Quoted 5 lines
Quoted 1 line

Thanks.

Hi Junio,

Do I send in a new patch series addressing this?

The expectation would be that you reroll the series and send out a new version thereof that gets rid of the return value in the same commit where you stop returning it.

This would typically be the case as long as your series has not yet been merged to next. Once it has been merged to next, you would have to send an entirely new patch series as a follow-up.

Patrick

#22 lore raw

PATCH v2 2/4 t/unit-tests: convert oid-array test to use clar test framework

In reply to Seyi Kuforiji

Adapt oid-array test script to clar framework by using clar assertions where necessary. Remove descriptions from macros to reduce redundancy, and move test input arrays to global scope for reuse across multiple test functions. Introduce test_oid_array__initialize() to explicitly initialize the hash algorithm.

These changes streamline the test suite, making individual tests self-contained and reducing redundant code.

---
 Makefile                                      |   2 +-
 t/meson.build                                 |   2 +-
 t/unit-tests/{t-oid-array.c => u-oid-array.c} | 125 +++++++++---------
 3 files changed, 66 insertions(+), 63 deletions(-)
 rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (34%)
Makefile +1 -1
index 81799488f0..c9b0320fcb 100644
@@ -1356,6 +1356,7 @@ CLAR_TEST_SUITES += u-example-decorate
 CLAR_TEST_SUITES += u-hash
 CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
+CLAR_TEST_SUITES += u-oid-array
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1367,7 +1368,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
-UNIT_TEST_PROGRAMS += t-oid-array
 UNIT_TEST_PROGRAMS += t-oidmap
 UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
t/meson.build +1 -1
index 862cf1cfd4..1b17a53acc 100644
@@ -4,6 +4,7 @@ clar_test_suites = [
   'unit-tests/u-hash.c',
   'unit-tests/u-hashmap.c',
   'unit-tests/u-mem-pool.c',
+  'unit-tests/u-oid-array.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -49,7 +50,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oid-array.c',
   'unit-tests/t-oidmap.c',
   'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +64 -61

177 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#23 lore raw

PATCH v2 3/4 t/unit-tests: convert oidmap test to use clar test framework

In reply to Seyi Kuforiji

Adapt oidmap test script to clar framework by using clar assertions where necessary. cl_parse_any_oid() ensures the hash algorithm is set before parsing. This prevents issues from an uninitialized or invalid hash algorithm.

Introduce 'test_oidmap__initialize handles the to set up of the global oidmap map with predefined key-value pairs, and test_oidmap__cleanup` frees the oidmap and its entries when all tests are completed.

The test loops through all entries to detect multiple errors. With this change, it stops at the first error encountered, making it easier to address it.

---
 Makefile                                |   2 +-
 t/meson.build                           |   2 +-
 t/unit-tests/{t-oidmap.c => u-oidmap.c} | 153 +++++++++---------------
 3 files changed, 56 insertions(+), 101 deletions(-)
 rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%)
Makefile +1 -1
index c9b0320fcb..e4e85e6007 100644
@@ -1357,6 +1357,7 @@ CLAR_TEST_SUITES += u-hash
 CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
 CLAR_TEST_SUITES += u-oid-array
+CLAR_TEST_SUITES += u-oidmap
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1368,7 +1369,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
-UNIT_TEST_PROGRAMS += t-oidmap
 UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
 UNIT_TEST_PROGRAMS += t-reftable-block
t/meson.build +1 -1
index 1b17a53acc..d5b83cdb72 100644
@@ -5,6 +5,7 @@ clar_test_suites = [
   'unit-tests/u-hashmap.c',
   'unit-tests/u-mem-pool.c',
   'unit-tests/u-oid-array.c',
+  'unit-tests/u-oidmap.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -50,7 +51,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oidmap.c',
   'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
   'unit-tests/t-reftable-block.c',
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +54 -99

216 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#24 lore raw

PATCH v2 4/4 t/unit-tests: convert oidtree test to use clar test framework

In reply to Seyi Kuforiji

Adapt oidtree test script to clar framework by using clar assertions where necessary. cl_parse_any_oid() ensures the hash algorithm is set before parsing. This prevents issues from an uninitialized or invalid hash algorithm.

Introduce 'test_oidtree__initialize handles the to set up of the global oidtree variable and test_oidtree__cleanup` frees the oidtree when all tests are completed.

With this change, check_each stops at the first error encountered, making it easier to address it.

---
 Makefile                                  |  2 +-
 t/meson.build                             |  2 +-
 t/unit-tests/{t-oidtree.c => u-oidtree.c} | 79 +++++++++--------------
 3 files changed, 34 insertions(+), 49 deletions(-)
 rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (45%)
Makefile +1 -1
index e4e85e6007..2b134efc70 100644
@@ -1358,6 +1358,7 @@ CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
 CLAR_TEST_SUITES += u-oid-array
 CLAR_TEST_SUITES += u-oidmap
+CLAR_TEST_SUITES += u-oidtree
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1369,7 +1370,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
-UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
 UNIT_TEST_PROGRAMS += t-reftable-block
 UNIT_TEST_PROGRAMS += t-reftable-merged
t/meson.build +1 -1
index d5b83cdb72..91699917ff 100644
@@ -6,6 +6,7 @@ clar_test_suites = [
   'unit-tests/u-mem-pool.c',
   'unit-tests/u-oid-array.c',
   'unit-tests/u-oidmap.c',
+  'unit-tests/u-oidtree.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -51,7 +52,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
   'unit-tests/t-reftable-block.c',
   'unit-tests/t-reftable-merged.c',
t/unit-tests/u-oidtree.c renamed from t/unit-tests/t-oidtree.c +32 -47

127 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#25 lore raw

v3 cover t/unit-tests: convert unit-tests to use clar

In reply to Seyi Kuforiji

Hello,

This small patch series transitions a couple more of our existing unit test files to the Clar testing framework. This change is part of our ongoing effort to standardize our testing framework to enhance maintainability.

Changes in v3:
- minor code change based on review

Thanks
Seyi

Seyi Kuforiji (4):
t/unit-tests: implement clar specific oid helper functions t/unit-tests: convert oid-array test to use clar test framework t/unit-tests: convert oidmap test to use clar test framework t/unit-tests: convert oidtree test to use clar test framework

 Makefile                                      |   8 +-
 t/meson.build                                 |   8 +-
 t/unit-tests/lib-oid.c                        |  32 ++--
 t/unit-tests/lib-oid.h                        |   9 +-
 t/unit-tests/{t-oid-array.c => u-oid-array.c} | 125 +++++++-------
 t/unit-tests/{t-oidmap.c => u-oidmap.c}       | 153 +++++++-----------
 t/unit-tests/{t-oidtree.c => u-oidtree.c}     |  79 ++++-----
 t/unit-tests/unit-test.c                      |   2 +
 8 files changed, 177 insertions(+), 239 deletions(-)
 rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (34%)
 rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%)
 rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (45%)

Range-diff against v2:
1: 7f14d0d574 ! 1: c5b6613617 t/unit-tests: implement clar specific oid helper functions
@@ t/unit-tests/lib-oid.c: int init_hash_algo(void)
+static void cl_parse_oid(const char *hex, struct object_id *oid,
const struct git_hash_algo *algop)
{
- int ret;
+- int ret;
size_t sz = strlen(hex);
struct strbuf buf = STRBUF_INIT;

2:  430f5c5007 = 2:  d6cc4985a6 t/unit-tests: convert oid-array test to use clar test framework
3:  319cea1265 = 3:  1087752df5 t/unit-tests: convert oidmap test to use clar test framework
4:  ea63a5c9f1 = 4:  cda8dc194c t/unit-tests: convert oidtree test to use clar test framework
Signature · 1 line
2.47.0.86.g15030f9556
#26 lore raw

PATCH v3 1/4 t/unit-tests: implement clar specific oid helper functions

get_oid_arbitrary_hex() and init_hash_algo() are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in the t/unit-tests/lib-oid.{c,h} which is utilized by oid-related tests in the homegrown unit tests structure.

Adapt functions in lib-oid.{c,h} to use clar. Both these functions become available for oid-related test files implemented using the clar testing framework, which requires them. This will be used by subsequent commits.

---
 Makefile                 |  2 +-
 t/meson.build            |  2 +-
 t/unit-tests/lib-oid.c   | 32 +++++++++++---------------------
 t/unit-tests/lib-oid.h   |  9 ++++++---
 t/unit-tests/unit-test.c |  2 ++
 5 files changed, 21 insertions(+), 26 deletions(-)
Makefile +1 -1
index bcf5ed3f85..81799488f0 100644
@@ -1365,6 +1365,7 @@ CLAR_TEST_PROG = $(UNIT_TEST_BIN)/unit-tests$(X)
 CLAR_TEST_OBJS = $(patsubst %,$(UNIT_TEST_DIR)/%.o,$(CLAR_TEST_SUITES))
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
 UNIT_TEST_PROGRAMS += t-oid-array
 UNIT_TEST_PROGRAMS += t-oidmap
@@ -1381,7 +1382,6 @@ UNIT_TEST_PROGRAMS += t-trailer
 UNIT_TEST_PROGRAMS += t-urlmatch-normalization
 UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
 UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
-UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
 
 # xdiff and reftable libs may in turn depend on what is in libgit.a
t/meson.build +1 -1
index 780939d49f..862cf1cfd4 100644
@@ -14,6 +14,7 @@ clar_test_suites = [
 clar_sources = [
   'unit-tests/clar/clar.c',
   'unit-tests/unit-test.c',
+  'unit-tests/lib-oid.c'
 ]
 
 clar_decls_h = custom_target(
@@ -68,7 +69,6 @@ foreach unit_test_program : unit_test_programs
   unit_test = executable(unit_test_name,
     sources: [
       'unit-tests/test-lib.c',
-      'unit-tests/lib-oid.c',
       'unit-tests/lib-reftable.c',
       unit_test_program,
     ],
t/unit-tests/lib-oid.c +11 -21
index 8f0ccac532..e0b3180f23 100644
@@ -1,9 +1,9 @@
-#include "test-lib.h"
+#include "unit-test.h"
 #include "lib-oid.h"
 #include "strbuf.h"
 #include "hex.h"
 
-int init_hash_algo(void)
+int cl_setup_hash_algo(void)
 {
 	static int algo = -1;
 
@@ -11,42 +11,32 @@ int init_hash_algo(void)
 		const char *algo_name = getenv("GIT_TEST_DEFAULT_HASH");
 		algo = algo_name ? hash_algo_by_name(algo_name) : GIT_HASH_SHA1;
 
-		if (!check(algo != GIT_HASH_UNKNOWN))
-			test_msg("BUG: invalid GIT_TEST_DEFAULT_HASH value ('%s')",
-				 algo_name);
+		cl_assert(algo != GIT_HASH_UNKNOWN);
 	}
 	return algo;
 }
 
-static int get_oid_arbitrary_hex_algop(const char *hex, struct object_id *oid,
+static void cl_parse_oid(const char *hex, struct object_id *oid,
 				       const struct git_hash_algo *algop)
 {
-	int ret;
 	size_t sz = strlen(hex);
 	struct strbuf buf = STRBUF_INIT;
 
-	if (!check(sz <= algop->hexsz)) {
-		test_msg("BUG: hex string (%s) bigger than maximum allowed (%lu)",
-			 hex, (unsigned long)algop->hexsz);
-		return -1;
-	}
+	cl_assert(sz <= algop->hexsz);
 
 	strbuf_add(&buf, hex, sz);
 	strbuf_addchars(&buf, '0', algop->hexsz - sz);
 
-	ret = get_oid_hex_algop(buf.buf, oid, algop);
-	if (!check_int(ret, ==, 0))
-		test_msg("BUG: invalid hex input (%s) provided", hex);
+	cl_assert_equal_i(get_oid_hex_algop(buf.buf, oid, algop), 0);
 
 	strbuf_release(&buf);
-	return ret;
 }
 
-int get_oid_arbitrary_hex(const char *hex, struct object_id *oid)
+
+void cl_parse_any_oid(const char *hex, struct object_id *oid)
 {
-	int hash_algo = init_hash_algo();
+	int hash_algo = cl_setup_hash_algo();
 
-	if (!check_int(hash_algo, !=, GIT_HASH_UNKNOWN))
-		return -1;
-	return get_oid_arbitrary_hex_algop(hex, oid, &hash_algos[hash_algo]);
+	cl_assert(hash_algo != GIT_HASH_UNKNOWN);
+	cl_parse_oid(hex, oid, &hash_algos[hash_algo]);
 }
t/unit-tests/lib-oid.h +6 -3
index 4e77c04bd2..4031775104 100644
@@ -5,6 +5,7 @@
 
 /*
  * Convert arbitrary hex string to object_id.
+ *
  * For example, passing "abc12" will generate
  * "abc1200000000000000000000000000000000000" hex of length 40 for SHA-1 and
  * create object_id with that.
@@ -12,14 +13,16 @@
  * algo is not allowed. The hash algo is decided based on GIT_TEST_DEFAULT_HASH
  * environment variable.
  */
-int get_oid_arbitrary_hex(const char *s, struct object_id *oid);
+
+void cl_parse_any_oid (const char *s, struct object_id *oid);
 /*
  * Returns one of GIT_HASH_{SHA1, SHA256, UNKNOWN} based on the value of
  * GIT_TEST_DEFAULT_HASH environment variable. The fallback value in the
  * absence of GIT_TEST_DEFAULT_HASH is GIT_HASH_SHA1. It also uses
- * check(algo != GIT_HASH_UNKNOWN) before returning to verify if the
+ * cl_assert(algo != GIT_HASH_UNKNOWN) before returning to verify if the
  * GIT_TEST_DEFAULT_HASH's value is valid or not.
  */
-int init_hash_algo(void);
+
+int cl_setup_hash_algo(void);
 
 #endif /* LIB_OID_H */
t/unit-tests/unit-test.c +2 -0
index fa8818842a..5af645048a 100644
@@ -1,5 +1,7 @@
 #include "unit-test.h"
+#include "hex.h"
 #include "parse-options.h"
+#include "strbuf.h"
 #include "string-list.h"
 #include "strvec.h"
 
Signature · 1 line
2.47.0.86.g15030f9556
#27 lore raw

PATCH v3 2/4 t/unit-tests: convert oid-array test to use clar test framework

In reply to Seyi Kuforiji

Adapt oid-array test script to clar framework by using clar assertions where necessary. Remove descriptions from macros to reduce redundancy, and move test input arrays to global scope for reuse across multiple test functions. Introduce test_oid_array__initialize() to explicitly initialize the hash algorithm.

These changes streamline the test suite, making individual tests self-contained and reducing redundant code.

---
 Makefile                                      |   2 +-
 t/meson.build                                 |   2 +-
 t/unit-tests/{t-oid-array.c => u-oid-array.c} | 125 +++++++++---------
 3 files changed, 66 insertions(+), 63 deletions(-)
 rename t/unit-tests/{t-oid-array.c => u-oid-array.c} (34%)
Makefile +1 -1
index 81799488f0..c9b0320fcb 100644
@@ -1356,6 +1356,7 @@ CLAR_TEST_SUITES += u-example-decorate
 CLAR_TEST_SUITES += u-hash
 CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
+CLAR_TEST_SUITES += u-oid-array
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1367,7 +1368,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
-UNIT_TEST_PROGRAMS += t-oid-array
 UNIT_TEST_PROGRAMS += t-oidmap
 UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
t/meson.build +1 -1
index 862cf1cfd4..1b17a53acc 100644
@@ -4,6 +4,7 @@ clar_test_suites = [
   'unit-tests/u-hash.c',
   'unit-tests/u-hashmap.c',
   'unit-tests/u-mem-pool.c',
+  'unit-tests/u-oid-array.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -49,7 +50,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oid-array.c',
   'unit-tests/t-oidmap.c',
   'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
t/unit-tests/u-oid-array.c renamed from t/unit-tests/t-oid-array.c +64 -61

177 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#28 lore raw

PATCH v3 3/4 t/unit-tests: convert oidmap test to use clar test framework

In reply to Seyi Kuforiji

Adapt oidmap test script to clar framework by using clar assertions where necessary. cl_parse_any_oid() ensures the hash algorithm is set before parsing. This prevents issues from an uninitialized or invalid hash algorithm.

Introduce 'test_oidmap__initialize handles the to set up of the global oidmap map with predefined key-value pairs, and test_oidmap__cleanup` frees the oidmap and its entries when all tests are completed.

The test loops through all entries to detect multiple errors. With this change, it stops at the first error encountered, making it easier to address it.

---
 Makefile                                |   2 +-
 t/meson.build                           |   2 +-
 t/unit-tests/{t-oidmap.c => u-oidmap.c} | 153 +++++++++---------------
 3 files changed, 56 insertions(+), 101 deletions(-)
 rename t/unit-tests/{t-oidmap.c => u-oidmap.c} (32%)
Makefile +1 -1
index c9b0320fcb..e4e85e6007 100644
@@ -1357,6 +1357,7 @@ CLAR_TEST_SUITES += u-hash
 CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
 CLAR_TEST_SUITES += u-oid-array
+CLAR_TEST_SUITES += u-oidmap
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1368,7 +1369,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
-UNIT_TEST_PROGRAMS += t-oidmap
 UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
 UNIT_TEST_PROGRAMS += t-reftable-block
t/meson.build +1 -1
index 1b17a53acc..d5b83cdb72 100644
@@ -5,6 +5,7 @@ clar_test_suites = [
   'unit-tests/u-hashmap.c',
   'unit-tests/u-mem-pool.c',
   'unit-tests/u-oid-array.c',
+  'unit-tests/u-oidmap.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -50,7 +51,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oidmap.c',
   'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
   'unit-tests/t-reftable-block.c',
t/unit-tests/u-oidmap.c renamed from t/unit-tests/t-oidmap.c +54 -99

216 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556
#29 lore raw

PATCH v3 4/4 t/unit-tests: convert oidtree test to use clar test framework

In reply to Seyi Kuforiji

Adapt oidtree test script to clar framework by using clar assertions where necessary. cl_parse_any_oid() ensures the hash algorithm is set before parsing. This prevents issues from an uninitialized or invalid hash algorithm.

Introduce 'test_oidtree__initialize handles the to set up of the global oidtree variable and test_oidtree__cleanup` frees the oidtree when all tests are completed.

With this change, check_each stops at the first error encountered, making it easier to address it.

---
 Makefile                                  |  2 +-
 t/meson.build                             |  2 +-
 t/unit-tests/{t-oidtree.c => u-oidtree.c} | 79 +++++++++--------------
 3 files changed, 34 insertions(+), 49 deletions(-)
 rename t/unit-tests/{t-oidtree.c => u-oidtree.c} (45%)
Makefile +1 -1
index e4e85e6007..2b134efc70 100644
@@ -1358,6 +1358,7 @@ CLAR_TEST_SUITES += u-hashmap
 CLAR_TEST_SUITES += u-mem-pool
 CLAR_TEST_SUITES += u-oid-array
 CLAR_TEST_SUITES += u-oidmap
+CLAR_TEST_SUITES += u-oidtree
 CLAR_TEST_SUITES += u-prio-queue
 CLAR_TEST_SUITES += u-reftable-tree
 CLAR_TEST_SUITES += u-strbuf
@@ -1369,7 +1370,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
 
-UNIT_TEST_PROGRAMS += t-oidtree
 UNIT_TEST_PROGRAMS += t-reftable-basics
 UNIT_TEST_PROGRAMS += t-reftable-block
 UNIT_TEST_PROGRAMS += t-reftable-merged
t/meson.build +1 -1
index d5b83cdb72..91699917ff 100644
@@ -6,6 +6,7 @@ clar_test_suites = [
   'unit-tests/u-mem-pool.c',
   'unit-tests/u-oid-array.c',
   'unit-tests/u-oidmap.c',
+  'unit-tests/u-oidtree.c',
   'unit-tests/u-prio-queue.c',
   'unit-tests/u-reftable-tree.c',
   'unit-tests/u-strbuf.c',
@@ -51,7 +52,6 @@ clar_unit_tests = executable('unit-tests',
 test('unit-tests', clar_unit_tests)
 
 unit_test_programs = [
-  'unit-tests/t-oidtree.c',
   'unit-tests/t-reftable-basics.c',
   'unit-tests/t-reftable-block.c',
   'unit-tests/t-reftable-merged.c',
t/unit-tests/u-oidtree.c renamed from t/unit-tests/t-oidtree.c +32 -47

127 lines not on this page · raw message

Signature · 1 line
2.47.0.86.g15030f9556