t/unit-tests: convert unit-tests to use clar
Subsystems (2)
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
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
@@ -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
@@ -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
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()andinit_hash_algo()are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in thet/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
Mentored-by Patrick Steinhardt <[email protected]>Signed-off-by Seyi Kuforiji <[email protected]>--- 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@@ -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@@ -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 );
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()andinit_hash_algo()are both required for oid-related tests to run without errors. In the current implementation, both functions are defined and declared in thet/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.cand 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
Re: [PATCH 1/5] t/unit-tests: implement oid helper functions in unit-tests.{c,h}
In reply to Seyi KuforijiQuoted 9 lines · Seyi Kuforiji
t/unit-tests/unit-test.h +1
-0@@ -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
Re: [PATCH 1/5] t/unit-tests: implement oid helper functions in unit-tests.{c,h}
In reply to Seyi KuforijiHi 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
PATCH 2/5 t/unit-tests: convert oid-array test to use clar
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
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 ); }
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()inunit-test.calready 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
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()inunit-test.calready 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
PATCH 3/5 t/unit-tests: convert oidmap test to use clar
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
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_oidhandles 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__initializehandles the to set up of the global oidmap map with predefined key-value pairs, andtest_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
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_oidhandles 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__initializehandles the to set up of the global oidmap map with predefined key-value pairs, andtest_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. Usingcl_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
PATCH 4/5 t/unit-tests: convert oidtree test to use clar
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
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_oidhandles the necessary checks needed for the test to run smoothly.Introduce '
test_oidtree__initializehandles the to set up of the global oidtree variable andtest_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
PATCH 5/5 t/unit-tests: remove lib-oid.{c,h,o}
In reply to Seyi KuforijiThe 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
@@ -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
@@ -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
@@ -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
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
SeyiMentored-by Patrick Steinhardt <[email protected]>Signed-off-by Seyi Kuforiji <[email protected]>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 100644t/unit-tests/lib-oid.h
renamet/unit-tests/{t-oid-array.c=>u-oid-array.c} (35%) renamet/unit-tests/{t-oidmap.c=>u-oidmap.c} (32%) renamet/unit-tests/{t-oidtree.c=>u-oidtree.c} (44%)
v2 cover t/unit-tests: convert unit-tests to use clar
In reply to Seyi KuforijiHello,
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
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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
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
-4strbuf_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.
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
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
-4strbuf_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
PATCH v2 2/4 t/unit-tests: convert oid-array test to use clar test framework
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
PATCH v2 3/4 t/unit-tests: convert oidmap test to use clar test framework
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
PATCH v2 4/4 t/unit-tests: convert oidtree test to use clar test framework
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
v3 cover t/unit-tests: convert unit-tests to use clar
In reply to Seyi KuforijiHello,
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
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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
PATCH v3 2/4 t/unit-tests: convert oid-array test to use clar test framework
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
PATCH v3 3/4 t/unit-tests: convert oidmap test to use clar test framework
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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
PATCH v3 4/4 t/unit-tests: convert oidtree test to use clar test framework
In reply to Seyi KuforijiAdapt 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
@@ -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
@@ -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