* [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar
@ 2025-06-02 12:25 Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions Seyi Kuforiji
` (10 more replies)
0 siblings, 11 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Hello,
This small patch series marks the final batch of our existing unit test
files transitioned to the Clar testing framework. It covers all the
reftable-related test files, and is part of our ongoing effort to
standardize our testing framework to enhance its maintainability.
Changes in v3:
- some code refactoring based on review, which includes initial creation
of reftable helper functions to
t/unit-tests/lib-reftable-clar-test.{c,h} files in the initial commit
Thanks
Seyi
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
Seyi Kuforiji (10):
t/unit-tests: implement clar specific reftable test helper functions
t/unit-tests: convert reftable basics test to use clar test framework
t/unit-tests: convert reftable block test to use clar
t/unit-tests: convert reftable merged test to use clar
t/unit-tests: convert reftable pq test to use clar
t/unit-tests: convert reftable table test to use clar
t/unit-tests: convert reftable readwrite test to use clar
t/unit-tests: convert reftable record test to use clar
t/unit-tests: convert reftable stack test to use clar
t/unit-tests: finalize migration of reftable-related tests
Makefile | 22 +-
t/Makefile | 1 -
t/meson.build | 42 +-
t/unit-tests/lib-reftable.c | 35 +-
t/unit-tests/lib-reftable.h | 15 +-
t/unit-tests/t-reftable-basics.c | 219 ------
t/unit-tests/u-reftable-basics.c | 227 ++++++
...{t-reftable-block.c => u-reftable-block.c} | 164 ++--
...-reftable-merged.c => u-reftable-merged.c} | 160 ++--
.../{t-reftable-pq.c => u-reftable-pq.c} | 59 +-
...ble-readwrite.c => u-reftable-readwrite.c} | 384 ++++-----
...-reftable-record.c => u-reftable-record.c} | 217 +++---
...{t-reftable-stack.c => u-reftable-stack.c} | 726 +++++++-----------
...{t-reftable-table.c => u-reftable-table.c} | 71 +-
14 files changed, 1021 insertions(+), 1321 deletions(-)
delete mode 100644 t/unit-tests/t-reftable-basics.c
create mode 100644 t/unit-tests/u-reftable-basics.c
rename t/unit-tests/{t-reftable-block.c => u-reftable-block.c} (74%)
rename t/unit-tests/{t-reftable-merged.c => u-reftable-merged.c} (77%)
rename t/unit-tests/{t-reftable-pq.c => u-reftable-pq.c} (64%)
rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (69%)
rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (63%)
rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)
rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (76%)
Range-diff against v2:
1: d85c5694ca ! 1: 53a64f5551 t/unit-tests: implement reftable test helper functions in unit-test.{c,h}
@@ Metadata
Author: Seyi Kuforiji <kuforiji98@gmail.com>
## Commit message ##
- t/unit-tests: implement reftable test helper functions in unit-test.{c,h}
+ t/unit-tests: implement clar specific reftable test helper functions
Helper functions defined in `t/unit-tests/lib-reftable.{c,h}` are
- required for the reftable-related test files to run efficeintly. In the
- current implementation these functions are designed to conform with our
+ required for the reftable-related test files to run. In the current
+ implementation these functions are designed to conform with our
homegrown unit-testing structure. So in other to convert the reftable
test files, there is need for a clar specific implementation of these
helper functions.
- type cast `for (size_t i = 0; i < (size_t)stats->ref_stats.blocks;
- i++)`, implement equivalent helper functions in unit-test.{c,h} to use
- clar. These functions conform with the clar testing framework and become
- available for all reftable-related test files implemented using the clar
- testing framework, which requires them. This will be used by subsequent
- commits.
+ Implement equivalent helper functions in `lib-reftable-clar.{c,h}` to
+ use clar. These functions conform with the clar testing framework and
+ become available for all reftable-related test files implemented using
+ the clar testing framework, which requires them. This will be used by
+ subsequent commits.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
- ## t/unit-tests/unit-test.c ##
+ ## Makefile ##
+@@ Makefile: 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
++CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
+
+ UNIT_TEST_PROGRAMS += t-reftable-basics
+ UNIT_TEST_PROGRAMS += t-reftable-block
+
+ ## 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'
++ 'unit-tests/lib-oid.c',
++ 'unit-tests/lib-reftable-clar.c'
+ ]
+
+ clar_decls_h = custom_target(
+
+ ## t/unit-tests/lib-reftable-clar.c (new) ##
@@
- #include "unit-test.h"
- #include "hex.h"
- #include "parse-options.h"
++#include "unit-test.h"
++#include "lib-reftable-clar.h"
++#include "hex.h"
++#include "parse-options.h"
+#include "reftable/constants.h"
+#include "reftable/writer.h"
- #include "strbuf.h"
- #include "string-list.h"
- #include "strvec.h"
-
++#include "strbuf.h"
++#include "string-list.h"
++#include "strvec.h"
++
+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)
+{
+ memset(p, (uint8_t)i, hash_size(id));
@@ t/unit-tests/unit-test.c
+ struct reftable_writer *writer;
+ int ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,
+ buf, opts);
-+ cl_assert(ret == 0);
++ cl_assert(!ret);
+ return writer;
+}
+
@@ t/unit-tests/unit-test.c
+ }
+
+ writer = cl_reftable_strbuf_writer(buf, &opts);
-+ reftable_writer_set_limits(writer, min, max);
++ ret = reftable_writer_set_limits(writer, min, max);
++ cl_assert_equal_i(ret, 0);
+
+ if (nrefs) {
+ ret = reftable_writer_add_refs(writer, refs, nrefs);
@@ t/unit-tests/unit-test.c
+
+ reftable_writer_free(writer);
+}
-+
- static const char * const unit_test_usage[] = {
- N_("unit-test [<options>]"),
- NULL,
- ## t/unit-tests/unit-test.h ##
+ ## t/unit-tests/lib-reftable-clar.h (new) ##
@@
- #include "git-compat-util.h"
- #include "clar/clar.h"
- #include "clar-decls.h"
++#include "git-compat-util.h"
++#include "clar/clar.h"
++#include "clar-decls.h"
+#include "git-compat-util.h"
+#include "reftable/reftable-writer.h"
- #include "strbuf.h"
-
++#include "strbuf.h"
++
+struct reftable_buf;
+
+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);
+
+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
-+ struct reftable_write_options *opts);
++ struct reftable_write_options *opts);
+
+void cl_reftable_write_to_buf(struct reftable_buf *buf,
+ struct reftable_ref_record *refs,
@@ t/unit-tests/unit-test.h
+ struct reftable_log_record *logs,
+ size_t nlogs,
+ struct reftable_write_options *opts);
-+
- #define cl_failf(fmt, ...) do { \
- char desc[4096]; \
- snprintf(desc, sizeof(desc), fmt, __VA_ARGS__); \
2: d24faa0176 ! 2: fec29d94d8 t/unit-tests: convert reftable basics test to use clar test framework
@@ Makefile: CLAR_TEST_SUITES += u-oid-array
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-basics
UNIT_TEST_PROGRAMS += t-reftable-block
@@ t/unit-tests/u-reftable-basics.c (new)
+*/
+
+#include "unit-test.h"
++#include "lib-reftable-clar.h"
+#include "reftable/basics.h"
+
+struct integer_needle_lesseq_args {
@@ t/unit-tests/u-reftable-basics.c (new)
+ &integer_needle_lesseq, &args);
+ cl_assert_equal_i(idx, testcases[i].expected_idx);
+ }
-+
+}
+
+void test_reftable_basics__names_length(void)
@@ t/unit-tests/u-reftable-basics.c (new)
+ free_names(out);
+}
+
++void test_reftable_basics__parse_names_drop_empty_string(void)
++{
++ char in[] = "a\n\nb\n";
++ char **out = parse_names(in, strlen(in));
++ cl_assert(out != NULL);
++ cl_assert_equal_s(out[0], "a");
++ /* simply '\n' should be dropped as empty string */
++ cl_assert_equal_s(out[1], "b");
++ cl_assert(out[2] == NULL);
++ free_names(out);
++}
++
+void test_reftable_basics__common_prefix_size(void)
+{
+ struct reftable_buf a = REFTABLE_BUF_INIT;
@@ t/unit-tests/u-reftable-basics.c (new)
+ };
+
+ for (size_t i = 0; i < ARRAY_SIZE(cases); i++) {
-+ reftable_buf_reset(&a);
-+ reftable_buf_reset(&b);
+ cl_assert_equal_i(reftable_buf_addstr(&a, cases[i].a), 0);
+ cl_assert_equal_i(reftable_buf_addstr(&b, cases[i].b), 0);
+ cl_assert_equal_i(common_prefix_size(&a, &b), cases[i].want);
++ reftable_buf_reset(&a);
++ reftable_buf_reset(&b);
+ }
+ reftable_buf_release(&a);
+ reftable_buf_release(&b);
+}
+
++void test_reftable_basics__put_get_be64(void)
++{
++ uint64_t in = 0x1122334455667788;
++ uint8_t dest[8];
++ uint64_t out;
++ reftable_put_be64(dest, in);
++ out = reftable_get_be64(dest);
++ cl_assert(in == out);
++}
++
++void test_reftable_basics__put_get_be32(void)
++{
++ uint32_t in = 0x11223344;
++ uint8_t dest[4];
++ uint32_t out;
++ reftable_put_be32(dest, in);
++ out = reftable_get_be32(dest);
++ cl_assert_equal_i(in, out);
++}
++
+void test_reftable_basics__put_get_be24(void)
+{
+ uint32_t in = 0x112233;
@@ t/unit-tests/u-reftable-basics.c (new)
+ cl_assert_equal_i(in, out);
+}
+
-+void test_reftable_basics__grow_alloc(void)
++void test_reftable_basics__alloc_grow(void)
+{
+ int *arr = NULL, *old_arr;
+ size_t alloc = 0, old_alloc;
@@ t/unit-tests/u-reftable-basics.c (new)
+ reftable_free(arr);
+}
+
-+void test_reftable_basics__grow_alloc_or_null(void)
++void test_reftable_basics__alloc_grow_or_null(void)
+{
+ int *arr = NULL;
+ size_t alloc = 0, old_alloc;
3: d9eb47645b ! 3: 57d7541caa t/unit-tests: convert reftable block test to use clar
@@ Makefile: CLAR_TEST_SUITES += u-oidmap
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-block
UNIT_TEST_PROGRAMS += t-reftable-merged
UNIT_TEST_PROGRAMS += t-reftable-pq
- UNIT_TEST_PROGRAMS += t-reftable-reader
+ UNIT_TEST_PROGRAMS += t-reftable-readwrite
## t/meson.build ##
@@ t/meson.build: clar_test_suites = [
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
- 'unit-tests/t-reftable-block.c',
'unit-tests/t-reftable-merged.c',
'unit-tests/t-reftable-pq.c',
- 'unit-tests/t-reftable-reader.c',
+ 'unit-tests/t-reftable-readwrite.c',
## t/unit-tests/t-reftable-block.c => t/unit-tests/u-reftable-block.c ##
@@ t/unit-tests/u-reftable-block.c: license that can be found in the LICENSE file or at
@@ t/unit-tests/u-reftable-block.c: license that can be found in the LICENSE file o
-#include "test-lib.h"
+#include "unit-test.h"
++#include "lib-reftable-clar.h"
#include "reftable/block.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
@@ t/unit-tests/u-reftable-block.c: license that can be found in the LICENSE file o
const int header_off = 21; /* random */
struct reftable_record recs[30];
@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
- struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
-
- REFTABLE_CALLOC_ARRAY(block.data, block_size);
-- check(block.data != NULL);
-+ cl_assert(block.data != NULL);
- block.len = block_size;
- block_source_from_buf(&block.source ,&buf);
- ret = block_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size,
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
+
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+- check(block_data.buf != NULL);
++ cl_assert(block_data.buf != NULL);
+ block_data.len = block_size;
+
+- ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,
++ ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF,
++ (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
}
for (i = 0; i < N; i++) {
-@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
reftable_record_key(&recs[i], &want);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
want.len--;
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
- block_reader_release(&br);
+ reftable_block_release(&block);
@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
reftable_record_release(&recs[i]);
}
@@ t/unit-tests/u-reftable-block.c: static void t_ref_block_read_write(void)
const int header_off = 21;
struct reftable_record recs[30];
@@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)
- struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
-
- REFTABLE_CALLOC_ARRAY(block.data, block_size);
-- check(block.data != NULL);
-+ cl_assert(block.data != NULL);
- block.len = block_size;
- block_source_from_buf(&block.source ,&buf);
- ret = block_writer_init(&bw, BLOCK_TYPE_LOG, block.data, block_size,
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
+
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+- check(block_data.buf != NULL);
++ cl_assert(block_data.buf != NULL);
+ block_data.len = block_size;
+
+ ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
@@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)
}
for (i = 0; i < N; i++) {
- block_iter_reset(&it);
reftable_buf_reset(&want);
- check(!reftable_buf_addstr(&want, recs[i].u.log.refname));
+ cl_assert(reftable_buf_addstr(&want, recs[i].u.log.refname) == 0);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
want.len--;
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
- block_reader_release(&br);
+ reftable_block_release(&block);
@@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)
reftable_record_release(&recs[i]);
}
@@ t/unit-tests/u-reftable-block.c: static void t_log_block_read_write(void)
const int header_off = 21;
struct reftable_record recs[30];
@@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)
- struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
-
- REFTABLE_CALLOC_ARRAY(block.data, block_size);
-- check(block.data != NULL);
-+ cl_assert(block.data != NULL);
- block.len = block_size;
- block_source_from_buf(&block.source, &buf);
- ret = block_writer_init(&bw, BLOCK_TYPE_OBJ, block.data, block_size,
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
+
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+- check(block_data.buf != NULL);
++ cl_assert(block_data.buf != NULL);
+ block_data.len = block_size;
+
+ ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
@@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)
}
for (i = 0; i < N; i++) {
-@@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)
reftable_record_key(&recs[i], &want);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
- block_reader_release(&br);
+ reftable_block_release(&block);
@@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)
reftable_record_release(&recs[i]);
}
@@ t/unit-tests/u-reftable-block.c: static void t_obj_block_read_write(void)
const int header_off = 21;
struct reftable_record recs[30];
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
- struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
-
- REFTABLE_CALLOC_ARRAY(block.data, block_size);
-- check(block.data != NULL);
-+ cl_assert(block.data != NULL);
- block.len = block_size;
- block_source_from_buf(&block.source, &buf);
- ret = block_writer_init(&bw, BLOCK_TYPE_INDEX, block.data, block_size,
+ struct reftable_buf block_data = REFTABLE_BUF_INIT;
+
+ REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+- check(block_data.buf != NULL);
++ cl_assert(block_data.buf != NULL);
+ block_data.len = block_size;
+
+ ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
reftable_buf_init(&recs[i].u.idx.last_key);
- recs[i].type = BLOCK_TYPE_INDEX;
+ recs[i].type = REFTABLE_BLOCK_TYPE_INDEX;
- check(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));
-+ cl_assert(reftable_buf_addstr(&recs[i].u.idx.last_key, buf) == 0);
++ cl_assert(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));
recs[i].u.idx.offset = i;
ret = block_writer_add(&bw, &recs[i]);
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
}
for (i = 0; i < N; i++) {
-@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
reftable_record_key(&recs[i], &want);
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
want.len--;
- ret = block_iter_seek_key(&it, &br, &want);
+ ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
+ cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
- block_reader_release(&br);
+ reftable_block_release(&block);
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
- for (i = 0; i < N; i++)
reftable_record_release(&recs[i]);
}
+
+-static void t_block_iterator(void)
++void test_reftable_block__iterator(void)
+ {
+ struct reftable_block_source source = { 0 };
+ struct block_writer writer = {
+@@ t/unit-tests/u-reftable-block.c: static void t_block_iterator(void)
+
+ data.len = 1024;
+ REFTABLE_CALLOC_ARRAY(data.buf, data.len);
+- check(data.buf != NULL);
++ cl_assert(data.buf != NULL);
+
+- err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) data.buf, data.len,
++ err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF,
++ (uint8_t *) data.buf, data.len,
+ 0, hash_size(REFTABLE_HASH_SHA1));
+- check(!err);
++ cl_assert(!err);
+
+ for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {
+ expected_refs[i] = (struct reftable_record) {
+@@ t/unit-tests/u-reftable-block.c: static void t_block_iterator(void)
+ memset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);
+
+ err = block_writer_add(&writer, &expected_refs[i]);
+- check_int(err, ==, 0);
++ cl_assert_equal_i(err, 0);
+ }
+
+ err = block_writer_finish(&writer);
+- check_int(err, >, 0);
++ cl_assert(err > 0);
+
+ block_source_from_buf(&source, &data);
+ reftable_block_init(&block, &source, 0, 0, data.len,
+ REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);
+
+ err = reftable_block_init_iterator(&block, &it);
+- check_int(err, ==, 0);
++ cl_assert_equal_i(err, 0);
+
+ for (size_t i = 0; ; i++) {
+ err = reftable_iterator_next_ref(&it, &ref);
+ if (err > 0) {
+- check_int(i, ==, ARRAY_SIZE(expected_refs));
++ cl_assert_equal_i(i, ARRAY_SIZE(expected_refs));
+ break;
+ }
+- check_int(err, ==, 0);
++ cl_assert_equal_i(err, 0);
+
+- check(reftable_ref_record_equal(&ref, &expected_refs[i].u.ref,
+- REFTABLE_HASH_SIZE_SHA1));
++ cl_assert(reftable_ref_record_equal(&ref,
++ &expected_refs[i].u.ref, REFTABLE_HASH_SIZE_SHA1));
+ }
+
+ err = reftable_iterator_seek_ref(&it, "refs/heads/does-not-exist");
+- check_int(err, ==, 0);
++ cl_assert_equal_i(err, 0);
+ err = reftable_iterator_next_ref(&it, &ref);
+- check_int(err, ==, 1);
++ cl_assert_equal_i(err, 1);
+
+ err = reftable_iterator_seek_ref(&it, "refs/heads/branch-13");
+- check_int(err, ==, 0);
++ cl_assert_equal_i(err, 0);
+ err = reftable_iterator_next_ref(&it, &ref);
+- check_int(err, ==, 0);
+- check(reftable_ref_record_equal(&ref, &expected_refs[13].u.ref,
+- REFTABLE_HASH_SIZE_SHA1));
++ cl_assert_equal_i(err, 0);
++ cl_assert(reftable_ref_record_equal(&ref,
++ &expected_refs[13].u.ref,REFTABLE_HASH_SIZE_SHA1));
+
+ for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)
+ reftable_free(expected_refs[i].u.ref.refname);
+@@ t/unit-tests/u-reftable-block.c: static void t_block_iterator(void)
+ block_writer_release(&writer);
+ reftable_buf_release(&data);
+ }
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
@@ t/unit-tests/u-reftable-block.c: static void t_index_block_read_write(void)
- TEST(t_log_block_read_write(), "read-write operations on log blocks work");
- TEST(t_obj_block_read_write(), "read-write operations on obj blocks work");
- TEST(t_ref_block_read_write(), "read-write operations on ref blocks work");
+- TEST(t_block_iterator(), "block iterator works");
-
- return test_done();
-}
4: 6ffc7cdfc6 ! 4: db11c0eb30 t/unit-tests: convert reftable merged test to use clar
@@ Makefile: CLAR_TEST_SUITES += u-oidtree
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-merged
UNIT_TEST_PROGRAMS += t-reftable-pq
- UNIT_TEST_PROGRAMS += t-reftable-reader
UNIT_TEST_PROGRAMS += t-reftable-readwrite
+ UNIT_TEST_PROGRAMS += t-reftable-record
## t/meson.build ##
@@ t/meson.build: clar_test_suites = [
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
unit_test_programs = [
- 'unit-tests/t-reftable-merged.c',
'unit-tests/t-reftable-pq.c',
- 'unit-tests/t-reftable-reader.c',
'unit-tests/t-reftable-readwrite.c',
+ 'unit-tests/t-reftable-record.c',
## t/unit-tests/t-reftable-merged.c => t/unit-tests/u-reftable-merged.c ##
@@ t/unit-tests/u-reftable-merged.c: license that can be found in the LICENSE file or at
@@ t/unit-tests/u-reftable-merged.c: license that can be found in the LICENSE file
*/
-#include "test-lib.h"
+-#include "lib-reftable.h"
+#include "unit-test.h"
- #include "lib-reftable.h"
++#include "lib-reftable-clar.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
+ #include "reftable/merged.h"
@@ t/unit-tests/u-reftable-merged.c: merged_table_from_records(struct reftable_ref_record **refs,
int err;
- REFTABLE_CALLOC_ARRAY(*readers, n);
-- check(*readers != NULL);
-+ cl_assert(*readers != NULL);
+ REFTABLE_CALLOC_ARRAY(*tables, n);
+- check(*tables != NULL);
++ cl_assert(*tables != NULL);
REFTABLE_CALLOC_ARRAY(*source, n);
- check(*source != NULL);
+ cl_assert(*source != NULL);
@@ t/unit-tests/u-reftable-merged.c: merged_table_from_records(struct reftable_ref_
+ cl_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
block_source_from_buf(&(*source)[i], &buf[i]);
- err = reftable_reader_new(&(*readers)[i], &(*source)[i],
- "name");
+ err = reftable_table_new(&(*tables)[i], &(*source)[i],
+ "name");
- check(!err);
-+ cl_assert(err == 0);
++ cl_assert(!err);
}
- err = reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1);
+ err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
- check(!err);
-+ cl_assert(err == 0);
++ cl_assert(!err);
return mt;
}
-@@ t/unit-tests/u-reftable-merged.c: static void readers_destroy(struct reftable_reader **readers, const size_t n)
- reftable_free(readers);
+@@ t/unit-tests/u-reftable-merged.c: static void tables_destroy(struct reftable_table **tables, const size_t n)
+ reftable_free(tables);
}
-static void t_merged_single_record(void)
-+void test_reftable_merged__merged_single_record(void)
++void test_reftable_merged__single_record(void)
{
struct reftable_ref_record r1[] = { {
.refname = (char *) "b",
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_single_record(void)
int err;
- err = merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+ err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
- check(!err);
-+ cl_assert(err == 0);
++ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "a");
- check(!err);
+ cl_assert(err == 0);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_single_record(void)
- check(!err);
- check(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(err == 0);
-+ cl_assert(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1) != 0);
++ cl_assert(reftable_ref_record_equal(&r2[0], &ref,
++ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it);
- readers_destroy(readers, 3);
+ tables_destroy(tables, 3);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_single_record(void)
reftable_free(bs);
}
-static void t_merged_refs(void)
-+void test_reftable_merged__merged_refs(void)
++void test_reftable_merged__refs(void)
{
struct reftable_ref_record r1[] = {
{
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_refs(void)
size_t i;
- err = merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+ err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
- check(!err);
-+ cl_assert(err == 0);
++ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "a");
- check(!err);
- check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_refs(void)
- check(reftable_ref_record_equal(want[i], &out[i],
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_ref_record_equal(want[i], &out[i],
-+ REFTABLE_HASH_SIZE_SHA1) != 0);
++ REFTABLE_HASH_SIZE_SHA1) != 0);
for (i = 0; i < len; i++)
reftable_ref_record_release(&out[i]);
reftable_free(out);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_refs(void)
}
-static void t_merged_seek_multiple_times(void)
-+void test_reftable_merged__merged_seek_multiple_times(void)
++void test_reftable_merged__seek_multiple_times(void)
{
struct reftable_ref_record r1[] = {
{
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times(void)
- check(err == 1);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[1],
-+ REFTABLE_HASH_SIZE_SHA1), 1);
++ REFTABLE_HASH_SIZE_SHA1), 1);
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times(void)
- check(err == 1);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[1],
-+ REFTABLE_HASH_SIZE_SHA1), 1);
++ REFTABLE_HASH_SIZE_SHA1), 1);
- err = reftable_iterator_next_ref(&it, &rec);
- check(err > 0);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times(void)
}
-static void t_merged_seek_multiple_times_without_draining(void)
-+void test_reftable_merged__merged_seek_multiple_times_no_drain(void)
++void test_reftable_merged__seek_multiple_times_no_drain(void)
{
struct reftable_ref_record r1[] = {
{
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times_witho
struct reftable_merged_table *mt;
- int err;
- mt = merged_table_from_records(refs, &sources, &readers, sizes, bufs, 2);
- merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+ mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
+ merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
- err = reftable_iterator_seek_ref(&it, "b");
- check(!err);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times_witho
+ cl_assert(reftable_iterator_seek_ref(&it, "b") == 0);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[0],
-+ REFTABLE_HASH_SIZE_SHA1), 1);
++ REFTABLE_HASH_SIZE_SHA1), 1);
- err = reftable_iterator_seek_ref(&it, "a");
- check(!err);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_seek_multiple_times_witho
+ cl_assert(reftable_iterator_seek_ref(&it, "a") == 0);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[0],
-+ REFTABLE_HASH_SIZE_SHA1), 1);
++ REFTABLE_HASH_SIZE_SHA1), 1);
for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
reftable_buf_release(&bufs[i]);
@@ t/unit-tests/u-reftable-merged.c: merged_table_from_log_records(struct reftable_log_record **logs,
int err;
- REFTABLE_CALLOC_ARRAY(*readers, n);
-- check(*readers != NULL);
-+ cl_assert(*readers != NULL);
+ REFTABLE_CALLOC_ARRAY(*tables, n);
+- check(*tables != NULL);
++ cl_assert(*tables != NULL);
REFTABLE_CALLOC_ARRAY(*source, n);
- check(*source != NULL);
+ cl_assert(*source != NULL);
@@ t/unit-tests/u-reftable-merged.c: merged_table_from_log_records(struct reftable_
+ cl_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
block_source_from_buf(&(*source)[i], &buf[i]);
- err = reftable_reader_new(&(*readers)[i], &(*source)[i],
- "name");
+ err = reftable_table_new(&(*tables)[i], &(*source)[i],
+ "name");
- check(!err);
-+ cl_assert(err == 0);
++ cl_assert(!err);
}
-- err = reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1);
+ err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
- check(!err);
-+ cl_assert(reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1) == 0);
++ cl_assert(!err);
return mt;
}
-static void t_merged_logs(void)
-+void test_reftable_merged__merged_logs(void)
++void test_reftable_merged__logs(void)
{
struct reftable_log_record r1[] = {
{
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_logs(void)
struct reftable_merged_table *mt = merged_table_from_log_records(
- logs, &bs, &readers, sizes, bufs, 3);
+ logs, &bs, &tables, sizes, bufs, 3);
struct reftable_iterator it = { 0 };
- int err;
struct reftable_log_record *out = NULL;
size_t len = 0;
size_t cap = 0;
size_t i;
++ int err;
-- err = merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+ err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
- check(!err);
-- err = reftable_iterator_seek_log(&it, "a");
++ cl_assert(!err);
+ err = reftable_iterator_seek_log(&it, "a");
- check(!err);
- check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);
- check_int(reftable_merged_table_min_update_index(mt), ==, 1);
- check_int(reftable_merged_table_max_update_index(mt), ==, 3);
-+ cl_assert(merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG) == 0);
-+ cl_assert(reftable_iterator_seek_log(&it, "a") == 0);
++ cl_assert(!err);
+ cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);
+ cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);
+ cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);
@@ t/unit-tests/u-reftable-merged.c: static void t_merged_logs(void)
- check(reftable_log_record_equal(want[i], &out[i],
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_log_record_equal(want[i], &out[i],
-+ REFTABLE_HASH_SIZE_SHA1) != 0);
++ REFTABLE_HASH_SIZE_SHA1) != 0);
-- err = merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+ err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
- check(!err);
-- err = reftable_iterator_seek_log_at(&it, "a", 2);
++ cl_assert(!err);
+ err = reftable_iterator_seek_log_at(&it, "a", 2);
- check(!err);
-+ cl_assert(merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG) == 0);
-+ cl_assert(reftable_iterator_seek_log_at(&it, "a", 2) == 0);
++ cl_assert(!err);
reftable_log_record_release(&out[0]);
- err = reftable_iterator_next_log(&it, &out[0]);
- check(!err);
- check(reftable_log_record_equal(&out[0], &r3[0], REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_iterator_next_log(&it, &out[0]) == 0);
+ cl_assert(reftable_log_record_equal(&out[0], &r3[0],
-+ REFTABLE_HASH_SIZE_SHA1) != 0);
++ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_iterator_destroy(&it);
for (i = 0; i < len; i++)
@@ t/unit-tests/u-reftable-merged.c: static void t_default_write_opts(void)
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&rd, &source, "filename");
+ err = reftable_table_new(&table, &source, "filename");
- check(!err);
-+ cl_assert(reftable_reader_new(&rd, &source, "filename") == 0);
++ cl_assert(!err);
- hash_id = reftable_reader_hash_id(rd);
+ hash_id = reftable_table_hash_id(table);
- check_int(hash_id, ==, REFTABLE_HASH_SHA1);
+ cl_assert_equal_i(hash_id, REFTABLE_HASH_SHA1);
- err = reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA256);
+ err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
-- err = reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA1);
-- check(!err);
+ cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
-+ cl_assert(reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA1) == 0);
+ err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);
+- check(!err);
++ cl_assert(!err);
- reftable_reader_decref(rd);
+ reftable_table_decref(table);
reftable_merged_table_free(merged);
reftable_buf_release(&buf);
}
5: 19b08968a0 ! 5: 60cf81862a t/unit-tests: convert reftable pq test to use clar
@@ Makefile: CLAR_TEST_SUITES += u-prio-queue
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-pq
- UNIT_TEST_PROGRAMS += t-reftable-reader
UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
+ UNIT_TEST_PROGRAMS += t-reftable-stack
## t/meson.build ##
@@ t/meson.build: clar_test_suites = [
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
unit_test_programs = [
- 'unit-tests/t-reftable-pq.c',
- 'unit-tests/t-reftable-reader.c',
++ 'unit-tests/t-reftable-reader.c',
'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c',
+ 'unit-tests/t-reftable-stack.c',
## t/unit-tests/t-reftable-pq.c => t/unit-tests/u-reftable-pq.c ##
@@ t/unit-tests/u-reftable-pq.c: license that can be found in the LICENSE file or at
@@ t/unit-tests/u-reftable-pq.c: license that can be found in the LICENSE file or a
-#include "test-lib.h"
+#include "unit-test.h"
++#include "lib-reftable-clar.h"
#include "reftable/constants.h"
#include "reftable/pq.h"
#include "strbuf.h"
@@ t/unit-tests/u-reftable-pq.c: static void t_pq_record(void)
char *last = NULL;
for (i = 0; i < N; i++) {
-- check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
-+ cl_assert(reftable_record_init(&recs[i], BLOCK_TYPE_REF) == 0);
+- check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
++ cl_assert(!reftable_record_init(&recs[i],
++ REFTABLE_BLOCK_TYPE_REF));
recs[i].u.ref.refname = xstrfmt("%02"PRIuMAX, (uintmax_t)i);
}
@@ t/unit-tests/u-reftable-pq.c: static void t_pq_record(void)
merged_iter_pqueue_check(&pq);
- check(pq_entry_equal(&top, &e));
-- check(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
-+ cl_assert(pq_entry_equal(&top, &e) != 0);
-+ cl_assert(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
+- check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
++ cl_assert(pq_entry_equal(&top, &e));
++ cl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
if (last)
- check_int(strcmp(last, e.rec->u.ref.refname), <, 0);
+ cl_assert(strcmp(last, e.rec->u.ref.refname) < 0);
@@ t/unit-tests/u-reftable-pq.c: static void t_pq_index(void)
size_t N = ARRAY_SIZE(recs), i;
for (i = 0; i < N; i++) {
-- check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
-+ cl_assert(reftable_record_init(&recs[i], BLOCK_TYPE_REF) == 0);
+- check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
++ cl_assert(!reftable_record_init(&recs[i],
++ REFTABLE_BLOCK_TYPE_REF));
recs[i].u.ref.refname = (char *) "refs/heads/master";
}
@@ t/unit-tests/u-reftable-pq.c: static void t_pq_index(void)
merged_iter_pqueue_check(&pq);
- check(pq_entry_equal(&top, &e));
-- check(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
+- check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
- check_int(e.index, ==, i);
-+ cl_assert(pq_entry_equal(&top, &e) != 0);
-+ cl_assert(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
++ cl_assert(pq_entry_equal(&top, &e));
++ cl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
+ cl_assert_equal_i(e.index, i);
if (last)
- check_str(last, e.rec->u.ref.refname);
@@ t/unit-tests/u-reftable-pq.c: static void t_pq_index(void)
size_t N = ARRAY_SIZE(recs), i;
for (i = 0; i < N; i++) {
-- check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
-+ cl_assert(reftable_record_init(&recs[i], BLOCK_TYPE_REF) == 0);
+- check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
++ cl_assert(!reftable_record_init(&recs[i],
++ REFTABLE_BLOCK_TYPE_REF));
recs[i].u.ref.refname = (char *) "refs/heads/master";
}
6: b34d6714ed < -: ---------- t/unit-tests: convert reftable reader test to use clar
-: ---------- > 6: 0eec9f7601 t/unit-tests: convert reftable table test to use clar
7: 05c909ea94 ! 7: 36bdd9b003 t/unit-tests: convert reftable readwrite test to use clar
@@ Commit message
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
## Makefile ##
-@@ Makefile: CLAR_TEST_SUITES += u-reftable-block
+@@ Makefile: CLAR_TEST_SUITES += u-reftable-basics
+ CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-pq
- CLAR_TEST_SUITES += u-reftable-reader
+CLAR_TEST_SUITES += u-reftable-readwrite
+ CLAR_TEST_SUITES += u-reftable-table
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
- CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
## t/meson.build ##
@@ t/meson.build: clar_test_suites = [
+ 'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-pq.c',
- 'unit-tests/u-reftable-reader.c',
+ 'unit-tests/u-reftable-readwrite.c',
+ 'unit-tests/u-reftable-table.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
- 'unit-tests/u-strcmp-offset.c',
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
@@ t/unit-tests/u-reftable-readwrite.c: license that can be found in the LICENSE fi
#define DISABLE_SIGN_COMPARE_WARNINGS
-#include "test-lib.h"
+-#include "lib-reftable.h"
+#include "unit-test.h"
- #include "lib-reftable.h"
++#include "lib-reftable-clar.h"
#include "reftable/basics.h"
#include "reftable/blocksource.h"
+ #include "reftable/reftable-error.h"
@@ t/unit-tests/u-reftable-readwrite.c: license that can be found in the LICENSE file or at
static const int update_index = 5;
@@ t/unit-tests/u-reftable-readwrite.c: license that can be found in the LICENSE fi
{
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 };
- struct reftable_block out = { 0 };
+ struct reftable_block_data out = { 0 };
int n;
uint8_t in[] = "hello";
- check(!reftable_buf_add(&buf, in, sizeof(in)));
@@ t/unit-tests/u-reftable-readwrite.c: license that can be found in the LICENSE fi
block_source_from_buf(&source, &buf);
- check_int(block_source_size(&source), ==, 6);
+ cl_assert_equal_i(block_source_size(&source), 6);
- n = block_source_read_block(&source, &out, 0, sizeof(in));
+ n = block_source_read_data(&source, &out, 0, sizeof(in));
- check_int(n, ==, sizeof(in));
- check(!memcmp(in, out.data, n));
+ cl_assert_equal_i(n, sizeof(in));
-+ cl_assert(memcmp(in, out.data, n) == 0);
- reftable_block_done(&out);
++ cl_assert(!memcmp(in, out.data, n));
+ block_source_release_data(&out);
-- n = block_source_read_block(&source, &out, 1, 2);
+ n = block_source_read_data(&source, &out, 1, 2);
- check_int(n, ==, 2);
- check(!memcmp(out.data, "el", 2));
-+ cl_assert_equal_i(block_source_read_block(&source, &out, 1, 2), 2);
-+ cl_assert(memcmp(out.data, "el", 2) == 0);
++ cl_assert_equal_i(n, 2);
++ cl_assert(!memcmp(out.data, "el", 2));
- reftable_block_done(&out);
+ block_source_release_data(&out);
block_source_close(&source);
@@ t/unit-tests/u-reftable-readwrite.c: static void write_table(char ***names, struct reftable_buf *buf, int N,
int i;
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_limits(void)
struct reftable_write_options opts = {
.block_size = 256,
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
- struct reftable_reader *reader;
+ struct reftable_table *table;
struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
- int N = 2, err, i, n;
+ int N = 2, i;
char **names;
++ int err;
names = reftable_calloc(N + 1, sizeof(*names));
- check(names != NULL);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.log");
+ err = reftable_table_new(&table, &source, "file.log");
- check(!err);
--
-- err = reftable_reader_init_ref_iterator(reader, &it);
++ cl_assert(!err);
+
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
--
-- err = reftable_iterator_seek_ref(&it, names[N - 1]);
++ cl_assert(!err);
+
+ err = reftable_iterator_seek_ref(&it, names[N - 1]);
- check(!err);
--
-- err = reftable_iterator_next_ref(&it, &ref);
++ cl_assert(!err);
+
+ err = reftable_iterator_next_ref(&it, &ref);
- check(!err);
-+ cl_assert(reftable_reader_new(&reader, &source, "file.log") == 0);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, names[N - 1]) == 0);
-+ cl_assert(reftable_iterator_next_ref(&it, &ref) == 0);
++ cl_assert(!err);
/* end of iteration. */
- err = reftable_iterator_next_ref(&it, &ref);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
reftable_iterator_destroy(&it);
reftable_ref_record_release(&ref);
-- err = reftable_reader_init_log_iterator(reader, &it);
+ err = reftable_table_init_log_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_log(&it, "");
++ cl_assert(!err);
+ err = reftable_iterator_seek_log(&it, "");
- check(!err);
-+ cl_assert(reftable_reader_init_log_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_log(&it, "") == 0);
++ cl_assert(!err);
for (i = 0; ; i++) {
int err = reftable_iterator_next_log(&it, &log);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
/* cleanup. */
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
- reftable_reader_decref(reader);
+ reftable_table_decref(table);
}
-static void t_log_zlib_corruption(void)
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_write_read(void)
struct reftable_write_options opts = {
.block_size = 256,
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)
- struct reftable_reader *reader;
+ struct reftable_table *table;
struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)
char message[100] = { 0 };
- int err, i, n;
+ int i;
++ int err;
struct reftable_log_record log = {
.refname = (char *) "refname",
.value_type = REFTABLE_LOG_UPDATE,
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)
w = NULL;
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)
-
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.log");
+ err = reftable_table_new(&table, &source, "file.log");
- check(!err);
--
-- err = reftable_reader_init_log_iterator(reader, &it);
++ cl_assert(!err);
+
+ err = reftable_table_init_log_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_log(&it, "refname");
++ cl_assert(!err);
+ err = reftable_iterator_seek_log(&it, "refname");
- check_int(err, ==, REFTABLE_ZLIB_ERROR);
-+ cl_assert(reftable_reader_new(&reader, &source, "file.log") == 0);
-+ cl_assert(reftable_reader_init_log_iterator(reader, &it) == 0);
-+ cl_assert_equal_i(reftable_iterator_seek_log(&it, "refname"), REFTABLE_ZLIB_ERROR);
++ cl_assert_equal_i(err, REFTABLE_ZLIB_ERROR);
reftable_iterator_destroy(&it);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_log_zlib_corruption(void)
char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT;
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_sequential(void)
- struct reftable_iterator it = { 0 };
- struct reftable_block_source source = { 0 };
- struct reftable_reader *reader;
-- int err = 0;
- int j = 0;
-
- write_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);
-
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.ref");
+ err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
--
-- err = reftable_reader_init_ref_iterator(reader, &it);
++ cl_assert(!err);
+
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_ref(&it, "");
++ cl_assert(!err);
+ err = reftable_iterator_seek_ref(&it, "");
- check(!err);
-+ cl_assert(reftable_reader_new(&reader, &source, "file.ref") == 0);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, "") == 0);
++ cl_assert(!err);
for (j = 0; ; j++) {
struct reftable_ref_record ref = { 0 };
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_sequential(v
+ cl_assert_equal_i(j, N);
reftable_iterator_destroy(&it);
- reftable_reader_decref(reader);
+ reftable_table_decref(table);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_sequential(void)
free_names(names);
}
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_sequential(v
char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT;
int N = 50;
- struct reftable_reader *reader;
+ struct reftable_table *table;
struct reftable_block_source source = { 0 };
- int err;
struct reftable_log_record log = { 0 };
struct reftable_iterator it = { 0 };
++ int err;
-@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_api(void)
+ write_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.ref");
+ err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
-+ cl_assert(reftable_reader_new(&reader, &source, "file.ref") == 0);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, names[0]) == 0);
++ cl_assert(!err);
-- err = reftable_reader_init_ref_iterator(reader, &it);
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_ref(&it, names[0]);
++ cl_assert(!err);
+ err = reftable_iterator_seek_ref(&it, names[0]);
- check(!err);
--
-- err = reftable_iterator_next_log(&it, &log);
++ cl_assert(!err);
+
+ err = reftable_iterator_next_log(&it, &log);
- check_int(err, ==, REFTABLE_API_ERROR);
-+ cl_assert_equal_i(reftable_iterator_next_log(&it, &log), REFTABLE_API_ERROR);
++ cl_assert_equal_i(err, REFTABLE_API_ERROR);
reftable_buf_release(&buf);
free_names(names);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
-
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.ref");
+ err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
-- check_int(hash_id, ==, reftable_reader_hash_id(reader));
-+ cl_assert(reftable_reader_new(&reader, &source, "file.ref") == 0);
-+ cl_assert_equal_i(hash_id, reftable_reader_hash_id(reader));
+- check_int(hash_id, ==, reftable_table_hash_id(table));
++ cl_assert(!err);
++ cl_assert_equal_i(hash_id, reftable_table_hash_id(table));
if (!index) {
- reader->ref_offsets.index_offset = 0;
+ table->ref_offsets.index_offset = 0;
} else {
-- check_int(reader->ref_offsets.index_offset, >, 0);
-+ cl_assert(reader->ref_offsets.index_offset > 0);
+- check_int(table->ref_offsets.index_offset, >, 0);
++ cl_assert(table->ref_offsets.index_offset > 0);
}
for (i = 1; i < N; i++) {
-- err = reftable_reader_init_ref_iterator(reader, &it);
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_ref(&it, names[i]);
++ cl_assert(!err);
+ err = reftable_iterator_seek_ref(&it, names[i]);
- check(!err);
-- err = reftable_iterator_next_ref(&it, &ref);
++ cl_assert(!err);
+ err = reftable_iterator_next_ref(&it, &ref);
- check(!err);
- check_str(names[i], ref.refname);
- check_int(REFTABLE_REF_VAL1, ==, ref.value_type);
- check_int(i, ==, ref.value.val1[0]);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, names[i]) == 0);
-+ cl_assert(reftable_iterator_next_ref(&it, &ref) == 0);
++ cl_assert(!err);
+ cl_assert_equal_s(names[i], ref.refname);
+ cl_assert_equal_i(REFTABLE_REF_VAL1, ref.value_type);
+ cl_assert_equal_i(i, ref.value.val1[0]);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_seek(int ind
+ cl_assert(reftable_buf_addstr(&pastLast, names[N - 1]) == 0);
+ cl_assert(reftable_buf_addstr(&pastLast, "/") == 0);
-- err = reftable_reader_init_ref_iterator(reader, &it);
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
++ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, pastLast.buf);
if (err == 0) {
struct reftable_ref_record ref = { 0 };
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_seek(int ind
reftable_buf_release(&pastLast);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
- reftable_reader_decref(reader);
+ reftable_table_decref(table);
}
-static void t_table_read_write_seek_linear(void)
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_read_write_seek(int ind
t_table_read_write_seek(1, REFTABLE_HASH_SHA1);
}
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
- struct reftable_reader *reader;
+ struct reftable_table *table;
struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
struct reftable_iterator it = { 0 };
- int N = 50, n, j, err, i;
+ int N = 50, j, i;
++ int err;
want_names = reftable_calloc(N + 1, sizeof(*want_names));
- check(want_names != NULL);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
reftable_writer_free(w);
w = NULL;
-
+@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.ref");
+ err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
-+ cl_assert(reftable_reader_new(&reader, &source, "file.ref") == 0);
++ cl_assert(!err);
if (!indexed)
- reader->obj_offsets.is_present = 0;
+ table->obj_offsets.is_present = 0;
-- err = reftable_reader_init_ref_iterator(reader, &it);
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_ref(&it, "");
++ cl_assert(!err);
+ err = reftable_iterator_seek_ref(&it, "");
- check(!err);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, "") == 0);
++ cl_assert(!err);
reftable_iterator_destroy(&it);
-- err = reftable_reader_refs_for(reader, &it, want_hash);
+ err = reftable_table_refs_for(table, &it, want_hash);
- check(!err);
-+ cl_assert(reftable_reader_refs_for(reader, &it, want_hash) == 0);
++ cl_assert(!err);
for (j = 0; ; j++) {
int err = reftable_iterator_next_ref(&it, &ref);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
reftable_buf_release(&buf);
free_names(want_names);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
- reftable_reader_decref(reader);
+ reftable_table_decref(table);
}
-static void t_table_refs_for_no_index(void)
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_block_source source = { 0 };
- struct reftable_reader *rd = NULL;
+ struct reftable_table *table = NULL;
struct reftable_ref_record rec = { 0 };
- struct reftable_iterator it = { 0 };
-- int err;
+@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_empty_table(void)
reftable_writer_set_limits(w, 1, 1);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_table_refs_for(int indexed)
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&rd, &source, "filename");
+ err = reftable_table_new(&table, &source, "filename");
- check(!err);
--
-- err = reftable_reader_init_ref_iterator(rd, &it);
++ cl_assert(!err);
+
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_ref(&it, "");
++ cl_assert(!err);
+ err = reftable_iterator_seek_ref(&it, "");
- check(!err);
--
-- err = reftable_iterator_next_ref(&it, &rec);
++ cl_assert(!err);
+
+ err = reftable_iterator_next_ref(&it, &rec);
- check_int(err, >, 0);
-+ cl_assert(reftable_reader_new(&rd, &source, "filename") == 0);
-+ cl_assert(reftable_reader_init_ref_iterator(rd, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, "") == 0);
-+ cl_assert(reftable_iterator_next_ref(&it, &rec) > 0);
++ cl_assert(err > 0);
reftable_iterator_destroy(&it);
- reftable_reader_decref(rd);
+ reftable_table_decref(table);
reftable_buf_release(&buf);
}
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_key_order(void)
.block_size = 100,
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multiple_indices(void)
struct reftable_writer *writer;
- struct reftable_reader *reader;
+ struct reftable_table *table;
char buf[128];
- int err, i;
+ int i;
++ int err;
- writer = t_reftable_strbuf_writer(&writer_buf, &opts);
+ writer = cl_reftable_strbuf_writer(&writer_buf, &opts);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multiple_indices(void)
+ cl_assert(stats->log_stats.index_offset > 0);
block_source_from_buf(&source, &writer_buf);
-- err = reftable_reader_new(&reader, &source, "filename");
+ err = reftable_table_new(&table, &source, "filename");
- check(!err);
-+ cl_assert(reftable_reader_new(&reader, &source, "filename") == 0);
++ cl_assert(!err);
/*
* Seeking the log uses the log index now. In case there is any
* confusion regarding indices we would notice here.
*/
-- err = reftable_reader_init_log_iterator(reader, &it);
+ err = reftable_table_init_log_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_log(&it, "");
++ cl_assert(!err);
+ err = reftable_iterator_seek_log(&it, "");
- check(!err);
-+ cl_assert(reftable_reader_init_log_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_log(&it, "") == 0);
++ cl_assert(!err);
reftable_iterator_destroy(&it);
reftable_writer_free(writer);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multiple_indices(void)
struct reftable_write_options opts = {
.block_size = 100,
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multi_level_index(void)
- const struct reftable_stats *stats;
- struct reftable_writer *writer;
- struct reftable_reader *reader;
-- int err;
+ struct reftable_table *table;
+ int err;
- writer = t_reftable_strbuf_writer(&writer_buf, &opts);
+ writer = cl_reftable_strbuf_writer(&writer_buf, &opts);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multi_level_index(void)
+ cl_assert_equal_i(stats->ref_stats.max_index_level, 2);
block_source_from_buf(&source, &writer_buf);
-- err = reftable_reader_new(&reader, &source, "filename");
+ err = reftable_table_new(&table, &source, "filename");
- check(!err);
-+ cl_assert(reftable_reader_new(&reader, &source, "filename") == 0);
++ cl_assert(!err);
/*
* Seeking the last ref should work as expected.
*/
-- err = reftable_reader_init_ref_iterator(reader, &it);
+ err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
-- err = reftable_iterator_seek_ref(&it, "refs/heads/199");
++ cl_assert(!err);
+ err = reftable_iterator_seek_ref(&it, "refs/heads/199");
- check(!err);
-+ cl_assert(reftable_reader_init_ref_iterator(reader, &it) == 0);
-+ cl_assert(reftable_iterator_seek_ref(&it, "refs/heads/199") == 0);
++ cl_assert(!err);
reftable_iterator_destroy(&it);
reftable_writer_free(writer);
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multi_level_index(void)
{
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 };
- struct reftable_reader *reader;
-- int err;
+@@ t/unit-tests/u-reftable-readwrite.c: static void t_corrupt_table_empty(void)
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.log");
+ err = reftable_table_new(&table, &source, "file.log");
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
-+ cl_assert_equal_i(reftable_reader_new(&reader, &source,
-+ "file.log"),REFTABLE_FORMAT_ERROR);
++ cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
}
-static void t_corrupt_table(void)
@@ t/unit-tests/u-reftable-readwrite.c: static void t_write_multi_level_index(void)
uint8_t zeros[1024] = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 };
- struct reftable_reader *reader;
-- int err;
+ struct reftable_table *table;
+ int err;
- check(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
-+ cl_assert(reftable_buf_add(&buf, zeros, sizeof(zeros)) == 0);
++
++ cl_assert(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
block_source_from_buf(&source, &buf);
-- err = reftable_reader_new(&reader, &source, "file.log");
+ err = reftable_table_new(&table, &source, "file.log");
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
-+ cl_assert_equal_i(reftable_reader_new(&reader, &source,
-+ "file.log"), REFTABLE_FORMAT_ERROR);
++ cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
reftable_buf_release(&buf);
}
8: 1515cf15b7 ! 8: df744c1458 t/unit-tests: convert reftable record test to use clar
@@ Commit message
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
## Makefile ##
-@@ Makefile: CLAR_TEST_SUITES += u-reftable-merged
- CLAR_TEST_SUITES += u-reftable-pq
- CLAR_TEST_SUITES += u-reftable-reader
- CLAR_TEST_SUITES += u-reftable-readwrite
-+CLAR_TEST_SUITES += u-reftable-record
- CLAR_TEST_SUITES += u-reftable-tree
- CLAR_TEST_SUITES += u-strbuf
- CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
## t/meson.build ##
-@@ t/meson.build: clar_test_suites = [
- 'unit-tests/u-reftable-pq.c',
- 'unit-tests/u-reftable-reader.c',
- 'unit-tests/u-reftable-readwrite.c',
-+ 'unit-tests/u-reftable-record.c',
- 'unit-tests/u-reftable-tree.c',
- 'unit-tests/u-strbuf.c',
- 'unit-tests/u-strcmp-offset.c',
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
@@ t/unit-tests/t-reftable-record.c => t/unit-tests/u-reftable-record.c
-#include "test-lib.h"
+#include "unit-test.h"
++#include "lib-reftable-clar.h"
#include "reftable/basics.h"
#include "reftable/constants.h"
#include "reftable/record.h"
@@ t/unit-tests/u-reftable-record.c: static void t_reftable_log_record_roundtrip(vo
+ cl_assert(reftable_log_record_is_deletion(&in[2]) == 0);
for (size_t i = 0; i < ARRAY_SIZE(in); i++) {
- struct reftable_record rec = { .type = BLOCK_TYPE_LOG };
+ struct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };
@@ t/unit-tests/u-reftable-record.c: static void t_reftable_log_record_roundtrip(void)
reftable_record_key(&rec, &key);
@@ t/unit-tests/u-reftable-record.c: static void t_reftable_index_record_comparison
+void test_reftable_record__index_record_roundtrip(void)
{
struct reftable_record in = {
- .type = BLOCK_TYPE_INDEX,
+ .type = REFTABLE_BLOCK_TYPE_INDEX,
@@ t/unit-tests/u-reftable-record.c: static void t_reftable_index_record_roundtrip(void)
int n, m;
uint8_t extra;
9: dcbb2b6e56 ! 9: 4a247de9e4 t/unit-tests: convert reftable stack test to use clar
@@ Commit message
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
## Makefile ##
-@@ Makefile: CLAR_TEST_SUITES += u-reftable-pq
- CLAR_TEST_SUITES += u-reftable-reader
+@@ Makefile: CLAR_TEST_SUITES += u-reftable-block
+ CLAR_TEST_SUITES += u-reftable-merged
+ CLAR_TEST_SUITES += u-reftable-pq
CLAR_TEST_SUITES += u-reftable-readwrite
- CLAR_TEST_SUITES += u-reftable-record
+CLAR_TEST_SUITES += u-reftable-stack
+ CLAR_TEST_SUITES += u-reftable-table
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
- CLAR_TEST_SUITES += u-strcmp-offset
-@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
- CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
+@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
+ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-stack
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
@@ Makefile: CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/clar/clar.o
## t/meson.build ##
@@ t/meson.build: clar_test_suites = [
- 'unit-tests/u-reftable-reader.c',
+ 'unit-tests/u-reftable-merged.c',
+ 'unit-tests/u-reftable-pq.c',
'unit-tests/u-reftable-readwrite.c',
- 'unit-tests/u-reftable-record.c',
++ 'unit-tests/u-reftable-record.c',
+ 'unit-tests/u-reftable-stack.c',
+ 'unit-tests/u-reftable-table.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
- 'unit-tests/u-strcmp-offset.c',
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
@@ t/meson.build: clar_unit_tests = executable('unit-tests',
]
foreach unit_test_program : unit_test_programs
-@@ t/meson.build: integration_tests = [
+@@ t/meson.build: benchmarks = [
# sufficient to catch missing test suites in our CI though.
foreach glob, tests : {
't[0-9][0-9][0-9][0-9]-*.sh': integration_tests,
+- 'perf/p[0-9][0-9][0-9][0-9]-*.sh': benchmarks,
- 'unit-tests/t-*.c': unit_test_programs,
'unit-tests/u-*.c': clar_test_suites,
}
@@ t/unit-tests/u-reftable-stack.c: license that can be found in the LICENSE file o
#define DISABLE_SIGN_COMPARE_WARNINGS
-#include "test-lib.h"
+-#include "lib-reftable.h"
+#include "unit-test.h"
- #include "lib-reftable.h"
#include "dir.h"
++#include "lib-reftable-clar.h"
#include "reftable/merged.h"
+ #include "reftable/reftable-error.h"
+ #include "reftable/stack.h"
@@ t/unit-tests/u-reftable-stack.c: static char *get_tmp_template(int linenumber)
static char *get_tmp_dir(int linenumber)
{
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add_one(void)
};
struct reftable_ref_record dest = { 0 };
struct stat stat_result = { 0 };
-- err = reftable_new_stack(&st, dir, &opts);
++ int err;
++
+ err = reftable_new_stack(&st, dir, &opts);
- check(!err);
--
-- err = reftable_stack_add(st, write_test_ref, &ref);
++ cl_assert(!err);
+
+ err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
--
-- err = reftable_stack_read_ref(st, ref.refname, &dest);
++ cl_assert(!err);
+
+ err = reftable_stack_read_ref(st, ref.refname, &dest);
- check(!err);
- check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
-- check_int(st->readers_len, >, 0);
-+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
-+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
-+ cl_assert(reftable_stack_read_ref(st, ref.refname, &dest) == 0);
-+ cl_assert(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1) != 0);
-+ cl_assert(st->readers_len > 0);
+- check_int(st->tables_len, >, 0);
++ cl_assert(!err);
++ cl_assert(reftable_ref_record_equal(&ref, &dest,
++ REFTABLE_HASH_SIZE_SHA1));
++ cl_assert(st->tables_len > 0);
#ifndef GIT_WINDOWS_NATIVE
- check(!reftable_buf_addstr(&scratch, dir));
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add_one(void)
+ cl_assert(reftable_buf_addstr(&scratch, dir) == 0);
+ cl_assert(reftable_buf_addstr(&scratch, "/") == 0);
/* do not try at home; not an external API for reftable. */
-- check(!reftable_buf_addstr(&scratch, st->readers[0]->name));
-- err = stat(scratch.buf, &stat_result);
+- check(!reftable_buf_addstr(&scratch, st->tables[0]->name));
++ cl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));
+ err = stat(scratch.buf, &stat_result);
- check(!err);
- check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
-+ cl_assert(reftable_buf_addstr(&scratch, st->readers[0]->name) == 0);
-+ cl_assert(stat(scratch.buf, &stat_result) == 0);
-+ cl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);
++ cl_assert(!err);
++ cl_assert_equal_i((stat_result.st_mode & 0777),
++ opts.default_permissions);
#else
(void) stat_result;
#endif
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_api_pe
* all tables in the stack.
*/
if (i != n)
-- check_int(st->merged->readers_len, ==, i + 1);
-+ cl_assert_equal_i(st->merged->readers_len, i + 1);
+- check_int(st->merged->tables_len, ==, i + 1);
++ cl_assert_equal_i(st->merged->tables_len, i + 1);
else
-- check_int(st->merged->readers_len, ==, 1);
-+ cl_assert_equal_i(st->merged->readers_len, 1);
+- check_int(st->merged->tables_len, ==, 1);
++ cl_assert_equal_i(st->merged->tables_len, 1);
}
reftable_stack_destroy(st);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_transaction_api_pe
struct reftable_ref_record ref = {
.refname = (char *) "refs/heads/master",
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_fails_gracefully(void)
- struct reftable_stack *st;
- struct reftable_buf table_path = REFTABLE_BUF_INIT;
char *dir = get_tmp_dir(__LINE__);
-- int err;
+ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
-
- err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
-- check_int(st->merged->readers_len, ==, 1);
+- check_int(st->merged->tables_len, ==, 1);
- check_int(st->stats.attempts, ==, 0);
- check_int(st->stats.failures, ==, 0);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
-+ cl_assert_equal_i(st->merged->readers_len, 1);
++ cl_assert_equal_i(st->merged->tables_len, 1);
+ cl_assert_equal_i(st->stats.attempts, 0);
+ cl_assert_equal_i(st->stats.failures, 0);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_fa
*/
- check(!reftable_buf_addstr(&table_path, dir));
- check(!reftable_buf_addstr(&table_path, "/"));
-- check(!reftable_buf_addstr(&table_path, st->readers[0]->name));
+- check(!reftable_buf_addstr(&table_path, st->tables[0]->name));
- check(!reftable_buf_addstr(&table_path, ".lock"));
-+ cl_assert(reftable_buf_addstr(&table_path, dir) == 0);
-+ cl_assert(reftable_buf_addstr(&table_path, "/") == 0);
-+ cl_assert(reftable_buf_addstr(&table_path, st->readers[0]->name) == 0);
-+ cl_assert(reftable_buf_addstr(&table_path, ".lock") == 0);
++ cl_assert(!reftable_buf_addstr(&table_path, dir));
++ cl_assert(!reftable_buf_addstr(&table_path, "/"));
++ cl_assert(!reftable_buf_addstr(&table_path,
++ st->tables[0]->name));
++ cl_assert(!reftable_buf_addstr(&table_path, ".lock"));
write_file_buf(table_path.buf, "", 0);
ref.update_index = 2;
-- err = reftable_stack_add(st, write_test_ref, &ref);
+ err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
-- check_int(st->merged->readers_len, ==, 2);
+- check_int(st->merged->tables_len, ==, 2);
- check_int(st->stats.attempts, ==, 1);
- check_int(st->stats.failures, ==, 1);
-+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
-+ cl_assert_equal_i(st->merged->readers_len, 2);
++ cl_assert(!err);
++ cl_assert_equal_i(st->merged->tables_len, 2);
+ cl_assert_equal_i(st->stats.attempts, 1);
+ cl_assert_equal_i(st->stats.failures, 1);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_update_index_check
.exact_log_message = 1,
.default_permissions = 0660,
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)
+ struct reftable_buf path = REFTABLE_BUF_INIT;
struct stat stat_result;
size_t i, N = ARRAY_SIZE(refs);
++ int err;
-- err = reftable_new_stack(&st, dir, &opts);
+ err = reftable_new_stack(&st, dir, &opts);
- check(!err);
-+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
++ cl_assert(!err);
for (i = 0; i < N; i++) {
char buf[256];
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add(void)
+ cl_assert(reftable_buf_addstr(&path, dir) == 0);
+ cl_assert(reftable_buf_addstr(&path, "/") == 0);
/* do not try at home; not an external API for reftable. */
-- check(!reftable_buf_addstr(&path, st->readers[0]->name));
-- err = stat(path.buf, &stat_result);
+- check(!reftable_buf_addstr(&path, st->tables[0]->name));
++ cl_assert(!reftable_buf_addstr(&path, st->tables[0]->name));
+ err = stat(path.buf, &stat_result);
- check(!err);
- check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
-+ cl_assert(reftable_buf_addstr(&path, st->readers[0]->name) == 0);
-+ cl_assert(stat(path.buf, &stat_result) == 0);
++ cl_assert(!err);
+ cl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);
#else
(void) stat_result;
@@ t/unit-tests/u-reftable-stack.c: static int fastlogN(uint64_t sz, uint64_t N)
char *dir = get_tmp_dir(__LINE__);
- int err;
size_t i, N = 100;
++ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
@@ t/unit-tests/u-reftable-stack.c: static int fastlogN(uint64_t sz, uint64_t N)
for (i = 0; i < N; i++) {
char name[100];
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction(void)
- };
snprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
-- err = reftable_stack_add(st, write_test_ref, &ref);
+ err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
--
-- err = reftable_stack_auto_compact(st);
++ cl_assert(!err);
+
+ err = reftable_stack_auto_compact(st);
- check(!err);
-- check(i < 2 || st->merged->readers_len < 2 * fastlogN(i, 2));
-+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
-+ cl_assert(reftable_stack_auto_compact(st) == 0);
-+ cl_assert(i < 2 || st->merged->readers_len < 2 * fastlogN(i, 2));
+- check(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
++ cl_assert(!err);
++ cl_assert(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
}
- check_int(reftable_stack_compaction_stats(st)->entries_written, <,
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction(vo
char *dir = get_tmp_dir(__LINE__);
- int err;
size_t N = 100;
++ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction(vo
for (size_t i = 0; i < N; i++) {
char name[20];
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_factor(void)
- };
xsnprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
-- err = reftable_stack_add(st, &write_test_ref, &ref);
+ err = reftable_stack_add(st, &write_test_ref, &ref);
- check(!err);
--
-- check(i < 5 || st->merged->readers_len < 5 * fastlogN(i, 5));
-+ cl_assert(reftable_stack_add(st, &write_test_ref, &ref) == 0);
-+ cl_assert(i < 5 || st->merged->readers_len < 5 * fastlogN(i, 5));
++ cl_assert(!err);
+
+- check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
++ cl_assert(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
}
reftable_stack_destroy(st);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_fa
struct reftable_write_options opts = {
.disable_auto_compact = 1,
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_with_locked_tables(void)
- struct reftable_stack *st = NULL;
- struct reftable_buf buf = REFTABLE_BUF_INIT;
char *dir = get_tmp_dir(__LINE__);
-- int err;
+ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
write_n_ref_tables(st, 5);
-- check_int(st->merged->readers_len, ==, 5);
-+ cl_assert_equal_i(st->merged->readers_len, 5);
+- check_int(st->merged->tables_len, ==, 5);
++ cl_assert_equal_i(st->merged->tables_len, 5);
/*
* Given that all tables we have written should be roughly the same
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_wi
*/
- check(!reftable_buf_addstr(&buf, dir));
- check(!reftable_buf_addstr(&buf, "/"));
-- check(!reftable_buf_addstr(&buf, st->readers[2]->name));
+- check(!reftable_buf_addstr(&buf, st->tables[2]->name));
- check(!reftable_buf_addstr(&buf, ".lock"));
-+ cl_assert(reftable_buf_addstr(&buf, dir) == 0);
-+ cl_assert(reftable_buf_addstr(&buf, "/") == 0);
-+ cl_assert(reftable_buf_addstr(&buf, st->readers[2]->name) == 0);
-+ cl_assert(reftable_buf_addstr(&buf, ".lock") == 0);
++ cl_assert(!reftable_buf_addstr(&buf, dir));
++ cl_assert(!reftable_buf_addstr(&buf, "/"));
++ cl_assert(!reftable_buf_addstr(&buf, st->tables[2]->name));
++ cl_assert(!reftable_buf_addstr(&buf, ".lock"));
write_file_buf(buf.buf, "", 0);
/*
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_auto_compaction_with_locked_tables(void)
- * would in theory compact all tables, due to the preexisting lock we
* only compact the newest two tables.
*/
-- err = reftable_stack_auto_compact(st);
+ err = reftable_stack_auto_compact(st);
- check(!err);
- check_int(st->stats.failures, ==, 0);
-- check_int(st->merged->readers_len, ==, 4);
-+ cl_assert(reftable_stack_auto_compact(st) == 0);
+- check_int(st->merged->tables_len, ==, 4);
++ cl_assert(!err);
+ cl_assert_equal_i(st->stats.failures, 0);
-+ cl_assert_equal_i(st->merged->readers_len, 4);
++ cl_assert_equal_i(st->merged->tables_len, 4);
reftable_stack_destroy(st);
reftable_buf_release(&buf);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add_performs_auto_
* all tables in the stack.
*/
if (i != n)
-- check_int(st->merged->readers_len, ==, i + 1);
-+ cl_assert_equal_i(st->merged->readers_len, i + 1);
+- check_int(st->merged->tables_len, ==, i + 1);
++ cl_assert_equal_i(st->merged->tables_len, i + 1);
else
-- check_int(st->merged->readers_len, ==, 1);
-+ cl_assert_equal_i(st->merged->readers_len, 1);
+- check_int(st->merged->tables_len, ==, 1);
++ cl_assert_equal_i(st->merged->tables_len, 1);
}
reftable_stack_destroy(st);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_add_performs_auto_
struct reftable_write_options opts = {
.disable_auto_compact = 1,
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_with_locked_tables(void)
- struct reftable_stack *st = NULL;
- struct reftable_buf buf = REFTABLE_BUF_INIT;
char *dir = get_tmp_dir(__LINE__);
-- int err;
+ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
write_n_ref_tables(st, 3);
-- check_int(st->merged->readers_len, ==, 3);
-+ cl_assert_equal_i(st->merged->readers_len, 3);
+- check_int(st->merged->tables_len, ==, 3);
++ cl_assert_equal_i(st->merged->tables_len, 3);
/* Lock one of the tables that we're about to compact. */
- check(!reftable_buf_addstr(&buf, dir));
- check(!reftable_buf_addstr(&buf, "/"));
-- check(!reftable_buf_addstr(&buf, st->readers[1]->name));
+- check(!reftable_buf_addstr(&buf, st->tables[1]->name));
- check(!reftable_buf_addstr(&buf, ".lock"));
-+ cl_assert(reftable_buf_addstr(&buf, dir) == 0);
-+ cl_assert(reftable_buf_addstr(&buf, "/") == 0);
-+ cl_assert(reftable_buf_addstr(&buf, st->readers[1]->name) == 0);
-+ cl_assert(reftable_buf_addstr(&buf, ".lock") == 0);
++ cl_assert(!reftable_buf_addstr(&buf, dir));
++ cl_assert(!reftable_buf_addstr(&buf, "/"));
++ cl_assert(!reftable_buf_addstr(&buf, st->tables[1]->name));
++ cl_assert(!reftable_buf_addstr(&buf, ".lock"));
write_file_buf(buf.buf, "", 0);
/*
- * Compaction is expected to fail given that we were not able to
+@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_with_locked_tables(void)
* compact all tables.
*/
-- err = reftable_stack_compact_all(st, NULL);
+ err = reftable_stack_compact_all(st, NULL);
- check_int(err, ==, REFTABLE_LOCK_ERROR);
- check_int(st->stats.failures, ==, 1);
-- check_int(st->merged->readers_len, ==, 3);
-+ cl_assert_equal_i(reftable_stack_compact_all(st, NULL), REFTABLE_LOCK_ERROR);
+- check_int(st->merged->tables_len, ==, 3);
++ cl_assert_equal_i(err, REFTABLE_LOCK_ERROR);
+ cl_assert_equal_i(st->stats.failures, 1);
-+ cl_assert_equal_i(st->merged->readers_len, 3);
++ cl_assert_equal_i(st->merged->tables_len, 3);
reftable_stack_destroy(st);
reftable_buf_release(&buf);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_with_lo
}
@@ t/unit-tests/u-reftable-stack.c: static void unclean_stack_close(struct reftable_stack *st)
- REFTABLE_FREE_AND_NULL(st->readers);
+ REFTABLE_FREE_AND_NULL(st->tables);
}
-static void t_reftable_stack_compaction_concurrent_clean(void)
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_compaction_concurr
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL, *st2 = NULL;
- struct reftable_ref_record rec = { 0 };
- struct reftable_iterator it = { 0 };
- char *dir = get_tmp_dir(__LINE__);
-- int err;
+@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_read_across_reload(void)
+ int err;
/* Create a first stack and set up an iterator for it. */
- err = reftable_new_stack(&st1, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st1, dir, &opts) == 0);
write_n_ref_tables(st1, 2);
-- check_int(st1->merged->readers_len, ==, 2);
-+ cl_assert_equal_i(st1->merged->readers_len, 2);
+- check_int(st1->merged->tables_len, ==, 2);
++ cl_assert_equal_i(st1->merged->tables_len, 2);
reftable_stack_init_ref_iterator(st1, &it);
- err = reftable_iterator_seek_ref(&it, "");
- check(!err);
+ cl_assert(reftable_iterator_seek_ref(&it, "") == 0);
/* Set up a second stack for the same directory and compact it. */
-- err = reftable_new_stack(&st2, dir, &opts);
+ err = reftable_new_stack(&st2, dir, &opts);
- check(!err);
-- check_int(st2->merged->readers_len, ==, 2);
-- err = reftable_stack_compact_all(st2, NULL);
+- check_int(st2->merged->tables_len, ==, 2);
++ cl_assert(!err);
++ cl_assert_equal_i(st2->merged->tables_len, 2);
+ err = reftable_stack_compact_all(st2, NULL);
- check(!err);
-- check_int(st2->merged->readers_len, ==, 1);
-+ cl_assert(reftable_new_stack(&st2, dir, &opts) == 0);
-+ cl_assert_equal_i(st2->merged->readers_len, 2);
-+ cl_assert(reftable_stack_compact_all(st2, NULL) == 0);
-+ cl_assert_equal_i(st2->merged->readers_len, 1);
+- check_int(st2->merged->tables_len, ==, 1);
++ cl_assert(!err);
++ cl_assert_equal_i(st2->merged->tables_len, 1);
/*
* Verify that we can continue to use the old iterator even after we
* have reloaded its stack.
*/
-- err = reftable_stack_reload(st1);
+ err = reftable_stack_reload(st1);
- check(!err);
-- check_int(st1->merged->readers_len, ==, 1);
-- err = reftable_iterator_next_ref(&it, &rec);
+- check_int(st1->merged->tables_len, ==, 1);
++ cl_assert(!err);
++ cl_assert_equal_i(st1->merged->tables_len, 1);
+ err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- check_str(rec.refname, "refs/heads/branch-0000");
-- err = reftable_iterator_next_ref(&it, &rec);
++ cl_assert(!err);
++ cl_assert_equal_s(rec.refname, "refs/heads/branch-0000");
+ err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- check_str(rec.refname, "refs/heads/branch-0001");
-- err = reftable_iterator_next_ref(&it, &rec);
-- check_int(err, >, 0);
-+ cl_assert(reftable_stack_reload(st1) == 0);
-+ cl_assert_equal_i(st1->merged->readers_len, 1);
-+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
-+ cl_assert_equal_s(rec.refname, "refs/heads/branch-0000");
-+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
++ cl_assert(!err);
+ cl_assert_equal_s(rec.refname, "refs/heads/branch-0001");
-+ cl_assert(reftable_iterator_next_ref(&it, &rec) > 0);
+ err = reftable_iterator_next_ref(&it, &rec);
+- check_int(err, >, 0);
++ cl_assert(err > 0);
reftable_ref_record_release(&rec);
reftable_iterator_destroy(&it);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_read_across_reload
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_reload_with_missing_table(void)
- struct reftable_iterator it = { 0 };
- struct reftable_buf table_path = REFTABLE_BUF_INIT, content = REFTABLE_BUF_INIT;
- char *dir = get_tmp_dir(__LINE__);
-- int err;
+ int err;
/* Create a first stack and set up an iterator for it. */
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
write_n_ref_tables(st, 2);
-- check_int(st->merged->readers_len, ==, 2);
-+ cl_assert_equal_i(st->merged->readers_len, 2);
+- check_int(st->merged->tables_len, ==, 2);
++ cl_assert_equal_i(st->merged->tables_len, 2);
reftable_stack_init_ref_iterator(st, &it);
- err = reftable_iterator_seek_ref(&it, "");
- check(!err);
@@ t/unit-tests/u-reftable-stack.c: static void t_reftable_stack_reload_with_missin
/*
* Update the tables.list file with some garbage data, while reusing
- * our old readers. This should trigger a partial reload of the stack,
- * where we try to reuse our old readers.
+ * our old tables. This should trigger a partial reload of the stack,
+ * where we try to reuse our old tables.
*/
-- check(!reftable_buf_addstr(&content, st->readers[0]->name));
+- check(!reftable_buf_addstr(&content, st->tables[0]->name));
- check(!reftable_buf_addstr(&content, "\n"));
-- check(!reftable_buf_addstr(&content, st->readers[1]->name));
+- check(!reftable_buf_addstr(&content, st->tables[1]->name));
- check(!reftable_buf_addstr(&content, "\n"));
- check(!reftable_buf_addstr(&content, "garbage\n"));
- check(!reftable_buf_addstr(&table_path, st->list_file));
- check(!reftable_buf_addstr(&table_path, ".lock"));
-+ cl_assert(reftable_buf_addstr(&content, st->readers[0]->name) == 0);
-+ cl_assert(reftable_buf_addstr(&content, "\n") == 0);
-+ cl_assert(reftable_buf_addstr(&content, st->readers[1]->name) == 0);
-+ cl_assert(reftable_buf_addstr(&content, "\n") == 0);
-+ cl_assert(reftable_buf_addstr(&content, "garbage\n") == 0);
-+ cl_assert(reftable_buf_addstr(&table_path, st->list_file) == 0);
-+ cl_assert(reftable_buf_addstr(&table_path, ".lock") == 0);
++ cl_assert(!reftable_buf_addstr(&content, st->tables[0]->name));
++ cl_assert(!reftable_buf_addstr(&content, "\n"));
++ cl_assert(!reftable_buf_addstr(&content, st->tables[1]->name));
++ cl_assert(!reftable_buf_addstr(&content, "\n"));
++ cl_assert(!reftable_buf_addstr(&content, "garbage\n"));
++ cl_assert(!reftable_buf_addstr(&table_path, st->list_file));
++ cl_assert(!reftable_buf_addstr(&table_path, ".lock"));
write_file_buf(table_path.buf, content.buf, content.len);
- err = rename(table_path.buf, st->list_file);
- check(!err);
+ cl_assert(rename(table_path.buf, st->list_file) == 0);
-- err = reftable_stack_reload(st);
+ err = reftable_stack_reload(st);
- check_int(err, ==, -4);
-- check_int(st->merged->readers_len, ==, 2);
-+ cl_assert_equal_i(reftable_stack_reload(st), -4);
-+ cl_assert_equal_i(st->merged->readers_len, 2);
+- check_int(st->merged->tables_len, ==, 2);
++ cl_assert_equal_i(err, -4);
++ cl_assert_equal_i(st->merged->tables_len, 2);
/*
* Even though the reload has failed, we should be able to continue
10: 79aa0145aa < -: ---------- t/unit-tests: adapt lib-reftable{c,h} helper functions to clar
-: ---------- > 10: 7ea45d3600 t/unit-tests: finalize migration of reftable-related tests
--
2.43.0
^ permalink raw reply [flat|nested] 26+ messages in thread
* [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 13:23 ` Kristoffer Haugsbakk
2025-06-02 12:25 ` [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework Seyi Kuforiji
` (9 subsequent siblings)
10 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Helper functions defined in `t/unit-tests/lib-reftable.{c,h}` are
required for the reftable-related test files to run. In the current
implementation these functions are designed to conform with our
homegrown unit-testing structure. So in other to convert the reftable
test files, there is need for a clar specific implementation of these
helper functions.
Implement equivalent helper functions in `lib-reftable-clar.{c,h}` to
use clar. These functions conform with the clar testing framework and
become available for all reftable-related test files implemented using
the clar testing framework, which requires them. This will be used by
subsequent commits.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 1 +
t/meson.build | 3 +-
t/unit-tests/lib-reftable-clar.c | 101 +++++++++++++++++++++++++++++++
t/unit-tests/lib-reftable-clar.h | 20 ++++++
4 files changed, 124 insertions(+), 1 deletion(-)
create mode 100644 t/unit-tests/lib-reftable-clar.c
create mode 100644 t/unit-tests/lib-reftable-clar.h
diff --git a/Makefile b/Makefile
index 70d1543b6b..e4fa038508 100644
--- a/Makefile
+++ b/Makefile
@@ -1375,6 +1375,7 @@ 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
+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
UNIT_TEST_PROGRAMS += t-reftable-basics
UNIT_TEST_PROGRAMS += t-reftable-block
diff --git a/t/meson.build b/t/meson.build
index d052fc3e23..f77f21536e 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -19,7 +19,8 @@ clar_test_suites = [
clar_sources = [
'unit-tests/clar/clar.c',
'unit-tests/unit-test.c',
- 'unit-tests/lib-oid.c'
+ 'unit-tests/lib-oid.c',
+ 'unit-tests/lib-reftable-clar.c'
]
clar_decls_h = custom_target(
diff --git a/t/unit-tests/lib-reftable-clar.c b/t/unit-tests/lib-reftable-clar.c
new file mode 100644
index 0000000000..64e40a106e
--- /dev/null
+++ b/t/unit-tests/lib-reftable-clar.c
@@ -0,0 +1,101 @@
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
+#include "hex.h"
+#include "parse-options.h"
+#include "reftable/constants.h"
+#include "reftable/writer.h"
+#include "strbuf.h"
+#include "string-list.h"
+#include "strvec.h"
+
+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)
+{
+ memset(p, (uint8_t)i, hash_size(id));
+}
+
+static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)
+{
+ strbuf_add(b, data, sz);
+ return sz;
+}
+
+static int strbuf_writer_flush(void *arg UNUSED)
+{
+ return 0;
+}
+
+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
+ struct reftable_write_options *opts)
+{
+ struct reftable_writer *writer;
+ int ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,
+ buf, opts);
+ cl_assert(!ret);
+ return writer;
+}
+
+void cl_reftable_write_to_buf(struct reftable_buf *buf,
+ struct reftable_ref_record *refs,
+ size_t nrefs,
+ struct reftable_log_record *logs,
+ size_t nlogs,
+ struct reftable_write_options *_opts)
+{
+ struct reftable_write_options opts = { 0 };
+ const struct reftable_stats *stats;
+ struct reftable_writer *writer;
+ uint64_t min = 0xffffffff;
+ uint64_t max = 0;
+ int ret;
+
+ if (_opts)
+ opts = *_opts;
+
+ for (size_t i = 0; i < nrefs; i++) {
+ uint64_t ui = refs[i].update_index;
+ if (ui > max)
+ max = ui;
+ if (ui < min)
+ min = ui;
+ }
+ for (size_t i = 0; i < nlogs; i++) {
+ uint64_t ui = logs[i].update_index;
+ if (ui > max)
+ max = ui;
+ if (ui < min)
+ min = ui;
+ }
+
+ writer = cl_reftable_strbuf_writer(buf, &opts);
+ ret = reftable_writer_set_limits(writer, min, max);
+ cl_assert_equal_i(ret, 0);
+
+ if (nrefs) {
+ ret = reftable_writer_add_refs(writer, refs, nrefs);
+ cl_assert_equal_i(ret, 0);
+ }
+
+ if (nlogs) {
+ ret = reftable_writer_add_logs(writer, logs, nlogs);
+ cl_assert_equal_i(ret, 0);
+ }
+
+ ret = reftable_writer_close(writer);
+ cl_assert_equal_i(ret, 0);
+
+ stats = reftable_writer_stats(writer);
+ for (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {
+ size_t off = i * (opts.block_size ? opts.block_size
+ : DEFAULT_BLOCK_SIZE);
+ if (!off)
+ off = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);
+ cl_assert(buf->buf[off] == 'r');
+ }
+
+ if (nrefs)
+ cl_assert(stats->ref_stats.blocks > 0);
+ if (nlogs)
+ cl_assert(stats->log_stats.blocks > 0);
+
+ reftable_writer_free(writer);
+}
diff --git a/t/unit-tests/lib-reftable-clar.h b/t/unit-tests/lib-reftable-clar.h
new file mode 100644
index 0000000000..b562648973
--- /dev/null
+++ b/t/unit-tests/lib-reftable-clar.h
@@ -0,0 +1,20 @@
+#include "git-compat-util.h"
+#include "clar/clar.h"
+#include "clar-decls.h"
+#include "git-compat-util.h"
+#include "reftable/reftable-writer.h"
+#include "strbuf.h"
+
+struct reftable_buf;
+
+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);
+
+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
+ struct reftable_write_options *opts);
+
+void cl_reftable_write_to_buf(struct reftable_buf *buf,
+ struct reftable_ref_record *refs,
+ size_t nrecords,
+ struct reftable_log_record *logs,
+ size_t nlogs,
+ struct reftable_write_options *opts);
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-03 13:51 ` Patrick Steinhardt
2025-06-02 12:25 ` [PATCH v3 03/10] t/unit-tests: convert reftable block test to use clar Seyi Kuforiji
` (8 subsequent siblings)
10 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable basics test file to clar by using clar assertions
where necessary.Break up test edge case to improve modularity and
clarity.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 2 +-
t/meson.build | 2 +-
t/unit-tests/t-reftable-basics.c | 219 -----------------------------
t/unit-tests/u-reftable-basics.c | 227 +++++++++++++++++++++++++++++++
4 files changed, 229 insertions(+), 221 deletions(-)
delete mode 100644 t/unit-tests/t-reftable-basics.c
create mode 100644 t/unit-tests/u-reftable-basics.c
diff --git a/Makefile b/Makefile
index e4fa038508..a01103e3a6 100644
--- a/Makefile
+++ b/Makefile
@@ -1364,6 +1364,7 @@ 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-basics
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1377,7 +1378,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-basics
UNIT_TEST_PROGRAMS += t-reftable-block
UNIT_TEST_PROGRAMS += t-reftable-merged
UNIT_TEST_PROGRAMS += t-reftable-pq
diff --git a/t/meson.build b/t/meson.build
index f77f21536e..e00e8d41d6 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -8,6 +8,7 @@ clar_test_suites = [
'unit-tests/u-oidmap.c',
'unit-tests/u-oidtree.c',
'unit-tests/u-prio-queue.c',
+ 'unit-tests/u-reftable-basics.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
@@ -55,7 +56,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-basics.c',
'unit-tests/t-reftable-block.c',
'unit-tests/t-reftable-merged.c',
'unit-tests/t-reftable-pq.c',
diff --git a/t/unit-tests/t-reftable-basics.c b/t/unit-tests/t-reftable-basics.c
deleted file mode 100644
index c9e751e49e..0000000000
--- a/t/unit-tests/t-reftable-basics.c
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
-Copyright 2020 Google LLC
-
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file or at
-https://developers.google.com/open-source/licenses/bsd
-*/
-
-#include "test-lib.h"
-#include "reftable/basics.h"
-
-struct integer_needle_lesseq_args {
- int needle;
- int *haystack;
-};
-
-static int integer_needle_lesseq(size_t i, void *_args)
-{
- struct integer_needle_lesseq_args *args = _args;
- return args->needle <= args->haystack[i];
-}
-
-static void *realloc_stub(void *p UNUSED, size_t size UNUSED)
-{
- return NULL;
-}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- if_test ("binary search with binsearch works") {
- int haystack[] = { 2, 4, 6, 8, 10 };
- struct {
- int needle;
- size_t expected_idx;
- } testcases[] = {
- {-9000, 0},
- {-1, 0},
- {0, 0},
- {2, 0},
- {3, 1},
- {4, 1},
- {7, 3},
- {9, 4},
- {10, 4},
- {11, 5},
- {9000, 5},
- };
-
- for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {
- struct integer_needle_lesseq_args args = {
- .haystack = haystack,
- .needle = testcases[i].needle,
- };
- size_t idx;
-
- idx = binsearch(ARRAY_SIZE(haystack),
- &integer_needle_lesseq, &args);
- check_int(idx, ==, testcases[i].expected_idx);
- }
- }
-
- if_test ("names_length returns size of a NULL-terminated string array") {
- const char *a[] = { "a", "b", NULL };
- check_int(names_length(a), ==, 2);
- }
-
- if_test ("names_equal compares NULL-terminated string arrays") {
- const char *a[] = { "a", "b", "c", NULL };
- const char *b[] = { "a", "b", "d", NULL };
- const char *c[] = { "a", "b", NULL };
-
- check(names_equal(a, a));
- check(!names_equal(a, b));
- check(!names_equal(a, c));
- }
-
- if_test ("parse_names works for basic input") {
- char in1[] = "line\n";
- char in2[] = "a\nb\nc";
- char **out = parse_names(in1, strlen(in1));
- check(out != NULL);
- check_str(out[0], "line");
- check(!out[1]);
- free_names(out);
-
- out = parse_names(in2, strlen(in2));
- check(out != NULL);
- check_str(out[0], "a");
- check_str(out[1], "b");
- check_str(out[2], "c");
- check(!out[3]);
- free_names(out);
- }
-
- if_test ("parse_names drops empty string") {
- char in[] = "a\n\nb\n";
- char **out = parse_names(in, strlen(in));
- check(out != NULL);
- check_str(out[0], "a");
- /* simply '\n' should be dropped as empty string */
- check_str(out[1], "b");
- check(!out[2]);
- free_names(out);
- }
-
- if_test ("common_prefix_size works") {
- struct reftable_buf a = REFTABLE_BUF_INIT;
- struct reftable_buf b = REFTABLE_BUF_INIT;
- struct {
- const char *a, *b;
- int want;
- } cases[] = {
- {"abcdef", "abc", 3},
- { "abc", "ab", 2 },
- { "", "abc", 0 },
- { "abc", "abd", 2 },
- { "abc", "pqr", 0 },
- };
-
- for (size_t i = 0; i < ARRAY_SIZE(cases); i++) {
- check(!reftable_buf_addstr(&a, cases[i].a));
- check(!reftable_buf_addstr(&b, cases[i].b));
- check_uint(common_prefix_size(&a, &b), ==, cases[i].want);
- reftable_buf_reset(&a);
- reftable_buf_reset(&b);
- }
- reftable_buf_release(&a);
- reftable_buf_release(&b);
- }
-
- if_test ("reftable_put_be64 and reftable_get_be64 work") {
- uint64_t in = 0x1122334455667788;
- uint8_t dest[8];
- uint64_t out;
- reftable_put_be64(dest, in);
- out = reftable_get_be64(dest);
- check_int(in, ==, out);
- }
-
- if_test ("reftable_put_be32 and reftable_get_be32 work") {
- uint32_t in = 0x11223344;
- uint8_t dest[4];
- uint32_t out;
- reftable_put_be32(dest, in);
- out = reftable_get_be32(dest);
- check_int(in, ==, out);
- }
-
- if_test ("reftable_put_be24 and reftable_get_be24 work") {
- uint32_t in = 0x112233;
- uint8_t dest[3];
- uint32_t out;
- reftable_put_be24(dest, in);
- out = reftable_get_be24(dest);
- check_int(in, ==, out);
- }
-
- if_test ("put_be16 and get_be16 work") {
- uint32_t in = 0xfef1;
- uint8_t dest[3];
- uint32_t out;
- reftable_put_be16(dest, in);
- out = reftable_get_be16(dest);
- check_int(in, ==, out);
- }
-
- if_test ("REFTABLE_ALLOC_GROW works") {
- int *arr = NULL, *old_arr;
- size_t alloc = 0, old_alloc;
-
- check(!REFTABLE_ALLOC_GROW(arr, 1, alloc));
- check(arr != NULL);
- check_uint(alloc, >=, 1);
- arr[0] = 42;
-
- old_alloc = alloc;
- old_arr = arr;
- reftable_set_alloc(NULL, realloc_stub, NULL);
- check(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));
- check(arr == old_arr);
- check_uint(alloc, ==, old_alloc);
-
- old_alloc = alloc;
- reftable_set_alloc(NULL, NULL, NULL);
- check(!REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));
- check(arr != NULL);
- check_uint(alloc, >, old_alloc);
- arr[alloc - 1] = 42;
-
- reftable_free(arr);
- }
-
- if_test ("REFTABLE_ALLOC_GROW_OR_NULL works") {
- int *arr = NULL;
- size_t alloc = 0, old_alloc;
-
- REFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);
- check(arr != NULL);
- check_uint(alloc, >=, 1);
- arr[0] = 42;
-
- old_alloc = alloc;
- REFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);
- check(arr != NULL);
- check_uint(alloc, >, old_alloc);
- arr[alloc - 1] = 42;
-
- old_alloc = alloc;
- reftable_set_alloc(NULL, realloc_stub, NULL);
- REFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);
- check(arr == NULL);
- check_uint(alloc, ==, 0);
- reftable_set_alloc(NULL, NULL, NULL);
-
- reftable_free(arr);
- }
-
- return test_done();
-}
diff --git a/t/unit-tests/u-reftable-basics.c b/t/unit-tests/u-reftable-basics.c
new file mode 100644
index 0000000000..f105c22d15
--- /dev/null
+++ b/t/unit-tests/u-reftable-basics.c
@@ -0,0 +1,227 @@
+/*
+Copyright 2020 Google LLC
+
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file or at
+https://developers.google.com/open-source/licenses/bsd
+*/
+
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
+#include "reftable/basics.h"
+
+struct integer_needle_lesseq_args {
+ int needle;
+ int *haystack;
+};
+
+static int integer_needle_lesseq(size_t i, void *_args)
+{
+ struct integer_needle_lesseq_args *args = _args;
+ return args->needle <= args->haystack[i];
+}
+
+static void *realloc_stub(void *p UNUSED, size_t size UNUSED)
+{
+ return NULL;
+}
+
+void test_reftable_basics__binsearch(void)
+{
+ int haystack[] = { 2, 4, 6, 8, 10 };
+ struct {
+ int needle;
+ size_t expected_idx;
+ } testcases[] = {
+ {-9000, 0},
+ {-1, 0},
+ {0, 0},
+ {2, 0},
+ {3, 1},
+ {4, 1},
+ {7, 3},
+ {9, 4},
+ {10, 4},
+ {11, 5},
+ {9000, 5},
+ };
+
+ for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {
+ struct integer_needle_lesseq_args args = {
+ .haystack = haystack,
+ .needle = testcases[i].needle,
+ };
+ size_t idx;
+
+ idx = binsearch(ARRAY_SIZE(haystack),
+ &integer_needle_lesseq, &args);
+ cl_assert_equal_i(idx, testcases[i].expected_idx);
+ }
+}
+
+void test_reftable_basics__names_length(void)
+{
+ const char *a[] = { "a", "b", NULL };
+ cl_assert_equal_i(names_length(a), 2);
+}
+
+void test_reftable_basics__names_equal(void)
+{
+ const char *a[] = { "a", "b", "c", NULL };
+ const char *b[] = { "a", "b", "d", NULL };
+ const char *c[] = { "a", "b", NULL };
+
+ cl_assert(names_equal(a, a));
+ cl_assert(!names_equal(a, b));
+ cl_assert(!names_equal(a, c));
+}
+
+void test_reftable_basics__parse_names(void)
+{
+ char in1[] = "line\n";
+ char in2[] = "a\nb\nc";
+ char **out = parse_names(in1, strlen(in1));
+ cl_assert(out != NULL);
+ cl_assert_equal_s(out[0], "line");
+ cl_assert(!out[1]);
+ free_names(out);
+
+ out = parse_names(in2, strlen(in2));
+ cl_assert(out != NULL);
+ cl_assert_equal_s(out[0], "a");
+ cl_assert_equal_s(out[1], "b");
+ cl_assert_equal_s(out[2], "c");
+ cl_assert(!out[3]);
+ free_names(out);
+}
+
+void test_reftable_basics__parse_names_drop_empty_string(void)
+{
+ char in[] = "a\n\nb\n";
+ char **out = parse_names(in, strlen(in));
+ cl_assert(out != NULL);
+ cl_assert_equal_s(out[0], "a");
+ /* simply '\n' should be dropped as empty string */
+ cl_assert_equal_s(out[1], "b");
+ cl_assert(out[2] == NULL);
+ free_names(out);
+}
+
+void test_reftable_basics__common_prefix_size(void)
+{
+ struct reftable_buf a = REFTABLE_BUF_INIT;
+ struct reftable_buf b = REFTABLE_BUF_INIT;
+ struct {
+ const char *a, *b;
+ int want;
+ } cases[] = {
+ {"abcdef", "abc", 3},
+ { "abc", "ab", 2 },
+ { "", "abc", 0 },
+ { "abc", "abd", 2 },
+ { "abc", "pqr", 0 },
+ };
+
+ for (size_t i = 0; i < ARRAY_SIZE(cases); i++) {
+ cl_assert_equal_i(reftable_buf_addstr(&a, cases[i].a), 0);
+ cl_assert_equal_i(reftable_buf_addstr(&b, cases[i].b), 0);
+ cl_assert_equal_i(common_prefix_size(&a, &b), cases[i].want);
+ reftable_buf_reset(&a);
+ reftable_buf_reset(&b);
+ }
+ reftable_buf_release(&a);
+ reftable_buf_release(&b);
+}
+
+void test_reftable_basics__put_get_be64(void)
+{
+ uint64_t in = 0x1122334455667788;
+ uint8_t dest[8];
+ uint64_t out;
+ reftable_put_be64(dest, in);
+ out = reftable_get_be64(dest);
+ cl_assert(in == out);
+}
+
+void test_reftable_basics__put_get_be32(void)
+{
+ uint32_t in = 0x11223344;
+ uint8_t dest[4];
+ uint32_t out;
+ reftable_put_be32(dest, in);
+ out = reftable_get_be32(dest);
+ cl_assert_equal_i(in, out);
+}
+
+void test_reftable_basics__put_get_be24(void)
+{
+ uint32_t in = 0x112233;
+ uint8_t dest[3];
+ uint32_t out;
+ reftable_put_be24(dest, in);
+ out = reftable_get_be24(dest);
+ cl_assert_equal_i(in, out);
+}
+
+void test_reftable_basics__put_get_be16(void)
+{
+ uint32_t in = 0xfef1;
+ uint8_t dest[3];
+ uint32_t out;
+ reftable_put_be16(dest, in);
+ out = reftable_get_be16(dest);
+ cl_assert_equal_i(in, out);
+}
+
+void test_reftable_basics__alloc_grow(void)
+{
+ int *arr = NULL, *old_arr;
+ size_t alloc = 0, old_alloc;
+
+ cl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, 1, alloc), 0);
+ cl_assert(arr != NULL);
+ cl_assert(alloc >= 1);
+ arr[0] = 42;
+
+ old_alloc = alloc;
+ old_arr = arr;
+ reftable_set_alloc(NULL, realloc_stub, NULL);
+ cl_assert(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc));
+ cl_assert(arr == old_arr);
+ cl_assert_equal_i(alloc, old_alloc);
+
+ old_alloc = alloc;
+ reftable_set_alloc(NULL, NULL, NULL);
+ cl_assert_equal_i(REFTABLE_ALLOC_GROW(arr, old_alloc + 1, alloc), 0);
+ cl_assert(arr != NULL);
+ cl_assert(alloc > old_alloc);
+ arr[alloc - 1] = 42;
+
+ reftable_free(arr);
+}
+
+void test_reftable_basics__alloc_grow_or_null(void)
+{
+ int *arr = NULL;
+ size_t alloc = 0, old_alloc;
+
+ REFTABLE_ALLOC_GROW_OR_NULL(arr, 1, alloc);
+ cl_assert(arr != NULL);
+ cl_assert(alloc >= 1);
+ arr[0] = 42;
+
+ old_alloc = alloc;
+ REFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);
+ cl_assert(arr != NULL);
+ cl_assert(alloc > old_alloc);
+ arr[alloc - 1] = 42;
+
+ old_alloc = alloc;
+ reftable_set_alloc(NULL, realloc_stub, NULL);
+ REFTABLE_ALLOC_GROW_OR_NULL(arr, old_alloc + 1, alloc);
+ cl_assert(arr == NULL);
+ cl_assert_equal_i(alloc, 0);
+ reftable_set_alloc(NULL, NULL, NULL);
+
+ reftable_free(arr);
+}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 03/10] t/unit-tests: convert reftable block test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-03 14:18 ` Patrick Steinhardt
2025-06-02 12:25 ` [PATCH v3 04/10] t/unit-tests: convert reftable merged " Seyi Kuforiji
` (7 subsequent siblings)
10 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable block test file to use clar testing framework by using
clar assertions where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 2 +-
t/meson.build | 2 +-
...{t-reftable-block.c => u-reftable-block.c} | 164 +++++++++---------
3 files changed, 80 insertions(+), 88 deletions(-)
rename t/unit-tests/{t-reftable-block.c => u-reftable-block.c} (74%)
diff --git a/Makefile b/Makefile
index a01103e3a6..d01dfd179b 100644
--- a/Makefile
+++ b/Makefile
@@ -1365,6 +1365,7 @@ CLAR_TEST_SUITES += u-oidmap
CLAR_TEST_SUITES += u-oidtree
CLAR_TEST_SUITES += u-prio-queue
CLAR_TEST_SUITES += u-reftable-basics
+CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1378,7 +1379,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-block
UNIT_TEST_PROGRAMS += t-reftable-merged
UNIT_TEST_PROGRAMS += t-reftable-pq
UNIT_TEST_PROGRAMS += t-reftable-readwrite
diff --git a/t/meson.build b/t/meson.build
index e00e8d41d6..b1d9dea9e7 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -9,6 +9,7 @@ clar_test_suites = [
'unit-tests/u-oidtree.c',
'unit-tests/u-prio-queue.c',
'unit-tests/u-reftable-basics.c',
+ 'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
@@ -56,7 +57,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-block.c',
'unit-tests/t-reftable-merged.c',
'unit-tests/t-reftable-pq.c',
'unit-tests/t-reftable-readwrite.c',
diff --git a/t/unit-tests/t-reftable-block.c b/t/unit-tests/u-reftable-block.c
similarity index 74%
rename from t/unit-tests/t-reftable-block.c
rename to t/unit-tests/u-reftable-block.c
index 52f1dae1c9..5d1419b801 100644
--- a/t/unit-tests/t-reftable-block.c
+++ b/t/unit-tests/u-reftable-block.c
@@ -6,14 +6,15 @@ license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd
*/
-#include "test-lib.h"
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
#include "reftable/block.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
#include "reftable/reftable-error.h"
#include "strbuf.h"
-static void t_ref_block_read_write(void)
+void test_reftable_block__index_read_write(void)
{
const int header_off = 21; /* random */
struct reftable_record recs[30];
@@ -34,17 +35,18 @@ static void t_ref_block_read_write(void)
struct reftable_buf block_data = REFTABLE_BUF_INIT;
REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
- check(block_data.buf != NULL);
+ cl_assert(block_data.buf != NULL);
block_data.len = block_size;
- ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,
+ ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF,
+ (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
rec.u.ref.refname = (char *) "";
rec.u.ref.value_type = REFTABLE_REF_DELETION;
ret = block_writer_add(&bw, &rec);
- check_int(ret, ==, REFTABLE_API_ERROR);
+ cl_assert_equal_i(ret, REFTABLE_API_ERROR);
for (i = 0; i < N; i++) {
rec.u.ref.refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);
@@ -55,11 +57,11 @@ static void t_ref_block_read_write(void)
ret = block_writer_add(&bw, &rec);
rec.u.ref.refname = NULL;
rec.u.ref.value_type = REFTABLE_REF_DELETION;
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
}
ret = block_writer_finish(&bw);
- check_int(ret, >, 0);
+ cl_assert(ret > 0);
block_writer_release(&bw);
@@ -71,32 +73,32 @@ static void t_ref_block_read_write(void)
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
- check_int(ret, >=, 0);
+ cl_assert(ret >= 0);
if (ret > 0) {
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
break;
}
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
for (i = 0; i < N; i++) {
reftable_record_key(&recs[i], &want);
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
want.len--;
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
- check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(ret, 0);
+ cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
reftable_block_release(&block);
@@ -108,7 +110,7 @@ static void t_ref_block_read_write(void)
reftable_record_release(&recs[i]);
}
-static void t_log_block_read_write(void)
+void test_reftable_block__log_read_write(void)
{
const int header_off = 21;
struct reftable_record recs[30];
@@ -129,12 +131,12 @@ static void t_log_block_read_write(void)
struct reftable_buf block_data = REFTABLE_BUF_INIT;
REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
- check(block_data.buf != NULL);
+ cl_assert(block_data.buf != NULL);
block_data.len = block_size;
ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
for (i = 0; i < N; i++) {
rec.u.log.refname = xstrfmt("branch%02"PRIuMAX , (uintmax_t)i);
@@ -145,11 +147,11 @@ static void t_log_block_read_write(void)
ret = block_writer_add(&bw, &rec);
rec.u.log.refname = NULL;
rec.u.log.value_type = REFTABLE_LOG_DELETION;
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
}
ret = block_writer_finish(&bw);
- check_int(ret, >, 0);
+ cl_assert(ret > 0);
block_writer_release(&bw);
@@ -161,33 +163,33 @@ static void t_log_block_read_write(void)
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
- check_int(ret, >=, 0);
+ cl_assert(ret >= 0);
if (ret > 0) {
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
break;
}
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
for (i = 0; i < N; i++) {
reftable_buf_reset(&want);
- check(!reftable_buf_addstr(&want, recs[i].u.log.refname));
+ cl_assert(reftable_buf_addstr(&want, recs[i].u.log.refname) == 0);
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
want.len--;
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
- check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(ret, 0);
+ cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
reftable_block_release(&block);
@@ -199,7 +201,7 @@ static void t_log_block_read_write(void)
reftable_record_release(&recs[i]);
}
-static void t_obj_block_read_write(void)
+void test_reftable_block__obj_read_write(void)
{
const int header_off = 21;
struct reftable_record recs[30];
@@ -220,12 +222,12 @@ static void t_obj_block_read_write(void)
struct reftable_buf block_data = REFTABLE_BUF_INIT;
REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
- check(block_data.buf != NULL);
+ cl_assert(block_data.buf != NULL);
block_data.len = block_size;
ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
for (i = 0; i < N; i++) {
uint8_t bytes[] = { i, i + 1, i + 2, i + 3, i + 5 }, *allocated;
@@ -238,11 +240,11 @@ static void t_obj_block_read_write(void)
ret = block_writer_add(&bw, &rec);
rec.u.obj.hash_prefix = NULL;
rec.u.obj.hash_prefix_len = 0;
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
}
ret = block_writer_finish(&bw);
- check_int(ret, >, 0);
+ cl_assert(ret > 0);
block_writer_release(&bw);
@@ -254,24 +256,24 @@ static void t_obj_block_read_write(void)
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
- check_int(ret, >=, 0);
+ cl_assert(ret >= 0);
if (ret > 0) {
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
break;
}
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
for (i = 0; i < N; i++) {
reftable_record_key(&recs[i], &want);
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
reftable_block_release(&block);
@@ -283,7 +285,7 @@ static void t_obj_block_read_write(void)
reftable_record_release(&recs[i]);
}
-static void t_index_block_read_write(void)
+void test_reftable_block__ref_read_write(void)
{
const int header_off = 21;
struct reftable_record recs[30];
@@ -305,12 +307,12 @@ static void t_index_block_read_write(void)
struct reftable_buf block_data = REFTABLE_BUF_INIT;
REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
- check(block_data.buf != NULL);
+ cl_assert(block_data.buf != NULL);
block_data.len = block_size;
ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,
header_off, hash_size(REFTABLE_HASH_SHA1));
- check(!ret);
+ cl_assert(ret == 0);
for (i = 0; i < N; i++) {
char buf[128];
@@ -319,15 +321,15 @@ static void t_index_block_read_write(void)
reftable_buf_init(&recs[i].u.idx.last_key);
recs[i].type = REFTABLE_BLOCK_TYPE_INDEX;
- check(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));
+ cl_assert(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));
recs[i].u.idx.offset = i;
ret = block_writer_add(&bw, &recs[i]);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
}
ret = block_writer_finish(&bw);
- check_int(ret, >, 0);
+ cl_assert(ret > 0);
block_writer_release(&bw);
@@ -339,32 +341,32 @@ static void t_index_block_read_write(void)
for (i = 0; ; i++) {
ret = block_iter_next(&it, &rec);
- check_int(ret, >=, 0);
+ cl_assert(ret >= 0);
if (ret > 0) {
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
break;
}
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
for (i = 0; i < N; i++) {
reftable_record_key(&recs[i], &want);
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
- check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
want.len--;
ret = block_iter_seek_key(&it, &want);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
ret = block_iter_next(&it, &rec);
- check_int(ret, ==, 0);
- check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(ret, 0);
+ cl_assert_equal_i(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1), 1);
}
reftable_block_release(&block);
@@ -376,7 +378,7 @@ static void t_index_block_read_write(void)
reftable_record_release(&recs[i]);
}
-static void t_block_iterator(void)
+void test_reftable_block__iterator(void)
{
struct reftable_block_source source = { 0 };
struct block_writer writer = {
@@ -391,11 +393,12 @@ static void t_block_iterator(void)
data.len = 1024;
REFTABLE_CALLOC_ARRAY(data.buf, data.len);
- check(data.buf != NULL);
+ cl_assert(data.buf != NULL);
- err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) data.buf, data.len,
+ err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF,
+ (uint8_t *) data.buf, data.len,
0, hash_size(REFTABLE_HASH_SHA1));
- check(!err);
+ cl_assert(!err);
for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {
expected_refs[i] = (struct reftable_record) {
@@ -408,42 +411,42 @@ static void t_block_iterator(void)
memset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);
err = block_writer_add(&writer, &expected_refs[i]);
- check_int(err, ==, 0);
+ cl_assert_equal_i(err, 0);
}
err = block_writer_finish(&writer);
- check_int(err, >, 0);
+ cl_assert(err > 0);
block_source_from_buf(&source, &data);
reftable_block_init(&block, &source, 0, 0, data.len,
REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);
err = reftable_block_init_iterator(&block, &it);
- check_int(err, ==, 0);
+ cl_assert_equal_i(err, 0);
for (size_t i = 0; ; i++) {
err = reftable_iterator_next_ref(&it, &ref);
if (err > 0) {
- check_int(i, ==, ARRAY_SIZE(expected_refs));
+ cl_assert_equal_i(i, ARRAY_SIZE(expected_refs));
break;
}
- check_int(err, ==, 0);
+ cl_assert_equal_i(err, 0);
- check(reftable_ref_record_equal(&ref, &expected_refs[i].u.ref,
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_ref_record_equal(&ref,
+ &expected_refs[i].u.ref, REFTABLE_HASH_SIZE_SHA1));
}
err = reftable_iterator_seek_ref(&it, "refs/heads/does-not-exist");
- check_int(err, ==, 0);
+ cl_assert_equal_i(err, 0);
err = reftable_iterator_next_ref(&it, &ref);
- check_int(err, ==, 1);
+ cl_assert_equal_i(err, 1);
err = reftable_iterator_seek_ref(&it, "refs/heads/branch-13");
- check_int(err, ==, 0);
+ cl_assert_equal_i(err, 0);
err = reftable_iterator_next_ref(&it, &ref);
- check_int(err, ==, 0);
- check(reftable_ref_record_equal(&ref, &expected_refs[13].u.ref,
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert_equal_i(err, 0);
+ cl_assert(reftable_ref_record_equal(&ref,
+ &expected_refs[13].u.ref,REFTABLE_HASH_SIZE_SHA1));
for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)
reftable_free(expected_refs[i].u.ref.refname);
@@ -453,14 +456,3 @@ static void t_block_iterator(void)
block_writer_release(&writer);
reftable_buf_release(&data);
}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_index_block_read_write(), "read-write operations on index blocks work");
- TEST(t_log_block_read_write(), "read-write operations on log blocks work");
- TEST(t_obj_block_read_write(), "read-write operations on obj blocks work");
- TEST(t_ref_block_read_write(), "read-write operations on ref blocks work");
- TEST(t_block_iterator(), "block iterator works");
-
- return test_done();
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 04/10] t/unit-tests: convert reftable merged test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (2 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 03/10] t/unit-tests: convert reftable block test to use clar Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 05/10] t/unit-tests: convert reftable pq " Seyi Kuforiji
` (6 subsequent siblings)
10 siblings, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable merged test file to use clar testing framework by using
clar assertions where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 2 +-
t/meson.build | 2 +-
...-reftable-merged.c => u-reftable-merged.c} | 162 ++++++++----------
3 files changed, 72 insertions(+), 94 deletions(-)
rename t/unit-tests/{t-reftable-merged.c => u-reftable-merged.c} (77%)
diff --git a/Makefile b/Makefile
index d01dfd179b..fb0ef10ff2 100644
--- a/Makefile
+++ b/Makefile
@@ -1366,6 +1366,7 @@ CLAR_TEST_SUITES += u-oidtree
CLAR_TEST_SUITES += u-prio-queue
CLAR_TEST_SUITES += u-reftable-basics
CLAR_TEST_SUITES += u-reftable-block
+CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1379,7 +1380,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-merged
UNIT_TEST_PROGRAMS += t-reftable-pq
UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
diff --git a/t/meson.build b/t/meson.build
index b1d9dea9e7..d25dfb0c92 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -10,6 +10,7 @@ clar_test_suites = [
'unit-tests/u-prio-queue.c',
'unit-tests/u-reftable-basics.c',
'unit-tests/u-reftable-block.c',
+ 'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
@@ -57,7 +58,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-merged.c',
'unit-tests/t-reftable-pq.c',
'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c',
diff --git a/t/unit-tests/t-reftable-merged.c b/t/unit-tests/u-reftable-merged.c
similarity index 77%
rename from t/unit-tests/t-reftable-merged.c
rename to t/unit-tests/u-reftable-merged.c
index 18c3251a56..e5b9dda4f4 100644
--- a/t/unit-tests/t-reftable-merged.c
+++ b/t/unit-tests/u-reftable-merged.c
@@ -6,8 +6,8 @@ license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd
*/
-#include "test-lib.h"
-#include "lib-reftable.h"
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
#include "reftable/merged.h"
@@ -29,21 +29,21 @@ merged_table_from_records(struct reftable_ref_record **refs,
int err;
REFTABLE_CALLOC_ARRAY(*tables, n);
- check(*tables != NULL);
+ cl_assert(*tables != NULL);
REFTABLE_CALLOC_ARRAY(*source, n);
- check(*source != NULL);
+ cl_assert(*source != NULL);
for (size_t i = 0; i < n; i++) {
- t_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
+ cl_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
block_source_from_buf(&(*source)[i], &buf[i]);
err = reftable_table_new(&(*tables)[i], &(*source)[i],
"name");
- check(!err);
+ cl_assert(!err);
}
err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
- check(!err);
+ cl_assert(!err);
return mt;
}
@@ -54,7 +54,7 @@ static void tables_destroy(struct reftable_table **tables, const size_t n)
reftable_free(tables);
}
-static void t_merged_single_record(void)
+void test_reftable_merged__single_record(void)
{
struct reftable_ref_record r1[] = { {
.refname = (char *) "b",
@@ -85,13 +85,14 @@ static void t_merged_single_record(void)
int err;
err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "a");
- check(!err);
+ cl_assert(err == 0);
err = reftable_iterator_next_ref(&it, &ref);
- check(!err);
- check(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(err == 0);
+ cl_assert(reftable_ref_record_equal(&r2[0], &ref,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it);
tables_destroy(tables, 3);
@@ -101,7 +102,7 @@ static void t_merged_single_record(void)
reftable_free(bs);
}
-static void t_merged_refs(void)
+void test_reftable_merged__refs(void)
{
struct reftable_ref_record r1[] = {
{
@@ -165,12 +166,12 @@ static void t_merged_refs(void)
size_t i;
err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "a");
- check(!err);
- check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);
- check_int(reftable_merged_table_min_update_index(mt), ==, 1);
- check_int(reftable_merged_table_max_update_index(mt), ==, 3);
+ cl_assert(err == 0);
+ cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);
+ cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);
+ cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);
while (len < 100) { /* cap loops/recursion. */
struct reftable_ref_record ref = { 0 };
@@ -178,15 +179,15 @@ static void t_merged_refs(void)
if (err > 0)
break;
- check(!REFTABLE_ALLOC_GROW(out, len + 1, cap));
+ cl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);
out[len++] = ref;
}
reftable_iterator_destroy(&it);
- check_int(ARRAY_SIZE(want), ==, len);
+ cl_assert_equal_i(ARRAY_SIZE(want), len);
for (i = 0; i < len; i++)
- check(reftable_ref_record_equal(want[i], &out[i],
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_ref_record_equal(want[i], &out[i],
+ REFTABLE_HASH_SIZE_SHA1) != 0);
for (i = 0; i < len; i++)
reftable_ref_record_release(&out[i]);
reftable_free(out);
@@ -198,7 +199,7 @@ static void t_merged_refs(void)
reftable_free(bs);
}
-static void t_merged_seek_multiple_times(void)
+void test_reftable_merged__seek_multiple_times(void)
{
struct reftable_ref_record r1[] = {
{
@@ -248,20 +249,17 @@ static void t_merged_seek_multiple_times(void)
for (size_t i = 0; i < 5; i++) {
int err = reftable_iterator_seek_ref(&it, "c");
- check(!err);
+ cl_assert(err == 0);
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- err = reftable_ref_record_equal(&rec, &r1[1], REFTABLE_HASH_SIZE_SHA1);
- check(err == 1);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[1],
+ REFTABLE_HASH_SIZE_SHA1), 1);
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- err = reftable_ref_record_equal(&rec, &r2[1], REFTABLE_HASH_SIZE_SHA1);
- check(err == 1);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[1],
+ REFTABLE_HASH_SIZE_SHA1), 1);
- err = reftable_iterator_next_ref(&it, &rec);
- check(err > 0);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) > 0);
}
for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
@@ -273,7 +271,7 @@ static void t_merged_seek_multiple_times(void)
reftable_free(sources);
}
-static void t_merged_seek_multiple_times_without_draining(void)
+void test_reftable_merged__seek_multiple_times_no_drain(void)
{
struct reftable_ref_record r1[] = {
{
@@ -317,24 +315,19 @@ static void t_merged_seek_multiple_times_without_draining(void)
struct reftable_ref_record rec = { 0 };
struct reftable_iterator it = { 0 };
struct reftable_merged_table *mt;
- int err;
mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
- err = reftable_iterator_seek_ref(&it, "b");
- check(!err);
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- err = reftable_ref_record_equal(&rec, &r2[0], REFTABLE_HASH_SIZE_SHA1);
- check(err == 1);
+ cl_assert(reftable_iterator_seek_ref(&it, "b") == 0);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r2[0],
+ REFTABLE_HASH_SIZE_SHA1), 1);
- err = reftable_iterator_seek_ref(&it, "a");
- check(!err);
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- err = reftable_ref_record_equal(&rec, &r1[0], REFTABLE_HASH_SIZE_SHA1);
- check(err == 1);
+ cl_assert(reftable_iterator_seek_ref(&it, "a") == 0);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_i(reftable_ref_record_equal(&rec, &r1[0],
+ REFTABLE_HASH_SIZE_SHA1), 1);
for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
reftable_buf_release(&bufs[i]);
@@ -359,25 +352,25 @@ merged_table_from_log_records(struct reftable_log_record **logs,
int err;
REFTABLE_CALLOC_ARRAY(*tables, n);
- check(*tables != NULL);
+ cl_assert(*tables != NULL);
REFTABLE_CALLOC_ARRAY(*source, n);
- check(*source != NULL);
+ cl_assert(*source != NULL);
for (size_t i = 0; i < n; i++) {
- t_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
+ cl_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
block_source_from_buf(&(*source)[i], &buf[i]);
err = reftable_table_new(&(*tables)[i], &(*source)[i],
"name");
- check(!err);
+ cl_assert(!err);
}
err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
- check(!err);
+ cl_assert(!err);
return mt;
}
-static void t_merged_logs(void)
+void test_reftable_merged__logs(void)
{
struct reftable_log_record r1[] = {
{
@@ -439,19 +432,19 @@ static void t_merged_logs(void)
struct reftable_merged_table *mt = merged_table_from_log_records(
logs, &bs, &tables, sizes, bufs, 3);
struct reftable_iterator it = { 0 };
- int err;
struct reftable_log_record *out = NULL;
size_t len = 0;
size_t cap = 0;
size_t i;
+ int err;
err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_log(&it, "a");
- check(!err);
- check_int(reftable_merged_table_hash_id(mt), ==, REFTABLE_HASH_SHA1);
- check_int(reftable_merged_table_min_update_index(mt), ==, 1);
- check_int(reftable_merged_table_max_update_index(mt), ==, 3);
+ cl_assert(!err);
+ cl_assert_equal_i(reftable_merged_table_hash_id(mt), REFTABLE_HASH_SHA1);
+ cl_assert_equal_i(reftable_merged_table_min_update_index(mt), 1);
+ cl_assert_equal_i(reftable_merged_table_max_update_index(mt), 3);
while (len < 100) { /* cap loops/recursion. */
struct reftable_log_record log = { 0 };
@@ -459,24 +452,24 @@ static void t_merged_logs(void)
if (err > 0)
break;
- check(!REFTABLE_ALLOC_GROW(out, len + 1, cap));
+ cl_assert(REFTABLE_ALLOC_GROW(out, len + 1, cap) == 0);
out[len++] = log;
}
reftable_iterator_destroy(&it);
- check_int(ARRAY_SIZE(want), ==, len);
+ cl_assert_equal_i(ARRAY_SIZE(want), len);
for (i = 0; i < len; i++)
- check(reftable_log_record_equal(want[i], &out[i],
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_log_record_equal(want[i], &out[i],
+ REFTABLE_HASH_SIZE_SHA1) != 0);
err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_log_at(&it, "a", 2);
- check(!err);
+ cl_assert(!err);
reftable_log_record_release(&out[0]);
- err = reftable_iterator_next_log(&it, &out[0]);
- check(!err);
- check(reftable_log_record_equal(&out[0], &r3[0], REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_iterator_next_log(&it, &out[0]) == 0);
+ cl_assert(reftable_log_record_equal(&out[0], &r3[0],
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_iterator_destroy(&it);
for (i = 0; i < len; i++)
@@ -490,11 +483,11 @@ static void t_merged_logs(void)
reftable_free(bs);
}
-static void t_default_write_opts(void)
+void test_reftable_merged__default_write_opts(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record rec = {
.refname = (char *) "master",
.update_index = 1,
@@ -507,40 +500,25 @@ static void t_default_write_opts(void)
reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_add_ref(w, &rec);
- check(!err);
+ cl_assert(reftable_writer_add_ref(w, &rec) == 0);
- err = reftable_writer_close(w);
- check(!err);
+ cl_assert(reftable_writer_close(w) == 0);
reftable_writer_free(w);
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "filename");
- check(!err);
+ cl_assert(!err);
hash_id = reftable_table_hash_id(table);
- check_int(hash_id, ==, REFTABLE_HASH_SHA1);
+ cl_assert_equal_i(hash_id, REFTABLE_HASH_SHA1);
err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
+ cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);
- check(!err);
+ cl_assert(!err);
reftable_table_decref(table);
reftable_merged_table_free(merged);
reftable_buf_release(&buf);
}
-
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_default_write_opts(), "merged table with default write opts");
- TEST(t_merged_logs(), "merged table with multiple log updates for same ref");
- TEST(t_merged_refs(), "merged table with multiple updates to same ref");
- TEST(t_merged_seek_multiple_times(), "merged table can seek multiple times");
- TEST(t_merged_seek_multiple_times_without_draining(), "merged table can seek multiple times without draining");
- TEST(t_merged_single_record(), "ref occurring in only one record can be fetched");
-
- return test_done();
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 05/10] t/unit-tests: convert reftable pq test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (3 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 04/10] t/unit-tests: convert reftable merged " Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 06/10] t/unit-tests: convert reftable table " Seyi Kuforiji
` (5 subsequent siblings)
10 siblings, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable priority queue test file to use clar by using clar
assertions where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 2 +-
t/meson.build | 3 +-
.../{t-reftable-pq.c => u-reftable-pq.c} | 59 +++++++++----------
3 files changed, 30 insertions(+), 34 deletions(-)
rename t/unit-tests/{t-reftable-pq.c => u-reftable-pq.c} (64%)
diff --git a/Makefile b/Makefile
index fb0ef10ff2..3cccc73073 100644
--- a/Makefile
+++ b/Makefile
@@ -1367,6 +1367,7 @@ CLAR_TEST_SUITES += u-prio-queue
CLAR_TEST_SUITES += u-reftable-basics
CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged
+CLAR_TEST_SUITES += u-reftable-pq
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1380,7 +1381,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-pq
UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
diff --git a/t/meson.build b/t/meson.build
index d25dfb0c92..ac4394b7a2 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -11,6 +11,7 @@ clar_test_suites = [
'unit-tests/u-reftable-basics.c',
'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-merged.c',
+ 'unit-tests/u-reftable-pq.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
@@ -58,7 +59,7 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-pq.c',
+ 'unit-tests/t-reftable-reader.c',
'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c',
diff --git a/t/unit-tests/t-reftable-pq.c b/t/unit-tests/u-reftable-pq.c
similarity index 64%
rename from t/unit-tests/t-reftable-pq.c
rename to t/unit-tests/u-reftable-pq.c
index fb5a4eb187..b3d64f55de 100644
--- a/t/unit-tests/t-reftable-pq.c
+++ b/t/unit-tests/u-reftable-pq.c
@@ -6,7 +6,8 @@ license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd
*/
-#include "test-lib.h"
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
#include "reftable/constants.h"
#include "reftable/pq.h"
#include "strbuf.h"
@@ -15,18 +16,18 @@ static void merged_iter_pqueue_check(const struct merged_iter_pqueue *pq)
{
for (size_t i = 1; i < pq->len; i++) {
size_t parent = (i - 1) / 2;
- check(pq_less(&pq->heap[parent], &pq->heap[i]));
+ cl_assert(pq_less(&pq->heap[parent], &pq->heap[i]) != 0);
}
}
static int pq_entry_equal(struct pq_entry *a, struct pq_entry *b)
{
int cmp;
- check(!reftable_record_cmp(a->rec, b->rec, &cmp));
+ cl_assert(reftable_record_cmp(a->rec, b->rec, &cmp) == 0);
return !cmp && (a->index == b->index);
}
-static void t_pq_record(void)
+void test_reftable_pq__record(void)
{
struct merged_iter_pqueue pq = { 0 };
struct reftable_record recs[54];
@@ -34,7 +35,8 @@ static void t_pq_record(void)
char *last = NULL;
for (i = 0; i < N; i++) {
- check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
+ cl_assert(!reftable_record_init(&recs[i],
+ REFTABLE_BLOCK_TYPE_REF));
recs[i].u.ref.refname = xstrfmt("%02"PRIuMAX, (uintmax_t)i);
}
@@ -53,13 +55,13 @@ static void t_pq_record(void)
struct pq_entry top = merged_iter_pqueue_top(pq);
struct pq_entry e;
- check(!merged_iter_pqueue_remove(&pq, &e));
+ cl_assert(merged_iter_pqueue_remove(&pq, &e) == 0);
merged_iter_pqueue_check(&pq);
- check(pq_entry_equal(&top, &e));
- check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
+ cl_assert(pq_entry_equal(&top, &e));
+ cl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
if (last)
- check_int(strcmp(last, e.rec->u.ref.refname), <, 0);
+ cl_assert(strcmp(last, e.rec->u.ref.refname) < 0);
last = e.rec->u.ref.refname;
}
@@ -68,7 +70,7 @@ static void t_pq_record(void)
merged_iter_pqueue_release(&pq);
}
-static void t_pq_index(void)
+void test_reftable_pq__index(void)
{
struct merged_iter_pqueue pq = { 0 };
struct reftable_record recs[13];
@@ -76,7 +78,8 @@ static void t_pq_index(void)
size_t N = ARRAY_SIZE(recs), i;
for (i = 0; i < N; i++) {
- check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
+ cl_assert(!reftable_record_init(&recs[i],
+ REFTABLE_BLOCK_TYPE_REF));
recs[i].u.ref.refname = (char *) "refs/heads/master";
}
@@ -96,28 +99,29 @@ static void t_pq_index(void)
struct pq_entry top = merged_iter_pqueue_top(pq);
struct pq_entry e;
- check(!merged_iter_pqueue_remove(&pq, &e));
+ cl_assert(merged_iter_pqueue_remove(&pq, &e) == 0);
merged_iter_pqueue_check(&pq);
- check(pq_entry_equal(&top, &e));
- check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
- check_int(e.index, ==, i);
+ cl_assert(pq_entry_equal(&top, &e));
+ cl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
+ cl_assert_equal_i(e.index, i);
if (last)
- check_str(last, e.rec->u.ref.refname);
+ cl_assert_equal_s(last, e.rec->u.ref.refname);
last = e.rec->u.ref.refname;
}
merged_iter_pqueue_release(&pq);
}
-static void t_merged_iter_pqueue_top(void)
+void test_reftable_pq__merged_iter_pqueue_top(void)
{
struct merged_iter_pqueue pq = { 0 };
struct reftable_record recs[13];
size_t N = ARRAY_SIZE(recs), i;
for (i = 0; i < N; i++) {
- check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
+ cl_assert(!reftable_record_init(&recs[i],
+ REFTABLE_BLOCK_TYPE_REF));
recs[i].u.ref.refname = (char *) "refs/heads/master";
}
@@ -137,25 +141,16 @@ static void t_merged_iter_pqueue_top(void)
struct pq_entry top = merged_iter_pqueue_top(pq);
struct pq_entry e;
- check(!merged_iter_pqueue_remove(&pq, &e));
+ cl_assert(merged_iter_pqueue_remove(&pq, &e) == 0);
merged_iter_pqueue_check(&pq);
- check(pq_entry_equal(&top, &e));
- check(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(pq_entry_equal(&top, &e) != 0);
+ cl_assert(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1) != 0);
for (size_t j = 0; i < pq.len; j++) {
- check(pq_less(&top, &pq.heap[j]));
- check_int(top.index, >, j);
+ cl_assert(pq_less(&top, &pq.heap[j]) != 0);
+ cl_assert(top.index > j);
}
}
merged_iter_pqueue_release(&pq);
}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_pq_record(), "pq works with record-based comparison");
- TEST(t_pq_index(), "pq works with index-based comparison");
- TEST(t_merged_iter_pqueue_top(), "merged_iter_pqueue_top works");
-
- return test_done();
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 06/10] t/unit-tests: convert reftable table test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (4 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 05/10] t/unit-tests: convert reftable pq " Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 19:33 ` Junio C Hamano
2025-06-02 12:25 ` [PATCH v3 07/10] t/unit-tests: convert reftable readwrite " Seyi Kuforiji
` (4 subsequent siblings)
10 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable table test file to use clar by using clar assertions
where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 4 +-
t/meson.build | 5 +-
...{t-reftable-table.c => u-reftable-table.c} | 73 +++++++++----------
3 files changed, 38 insertions(+), 44 deletions(-)
rename t/unit-tests/{t-reftable-table.c => u-reftable-table.c} (75%)
diff --git a/Makefile b/Makefile
index 3cccc73073..0227fdb3e1 100644
--- a/Makefile
+++ b/Makefile
@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics
CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-pq
+CLAR_TEST_SUITES += u-reftable-table
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1384,7 +1385,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
-UNIT_TEST_PROGRAMS += t-reftable-table
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-reftable.o
@@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)
$(OBJCOPY) --localize-hidden $^ $@
contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)
- $(AR) $(ARFLAGS) $@ $^
+ $(AR) $(ARFLAGS) $@ $^
\ No newline at end of file
diff --git a/t/meson.build b/t/meson.build
index ac4394b7a2..46d3a8580b 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -12,6 +12,7 @@ clar_test_suites = [
'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-pq.c',
+ 'unit-tests/u-reftable-table.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
@@ -59,11 +60,9 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-reader.c',
'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c',
- 'unit-tests/t-reftable-table.c',
]
foreach unit_test_program : unit_test_programs
@@ -1233,4 +1232,4 @@ if perl.found() and time.found()
timeout: 0,
)
endforeach
-endif
+endif
\ No newline at end of file
diff --git a/t/unit-tests/t-reftable-table.c b/t/unit-tests/u-reftable-table.c
similarity index 75%
rename from t/unit-tests/t-reftable-table.c
rename to t/unit-tests/u-reftable-table.c
index 7e1eb533d0..25ea672e6a 100644
--- a/t/unit-tests/t-reftable-table.c
+++ b/t/unit-tests/u-reftable-table.c
@@ -1,12 +1,12 @@
#include "test-lib.h"
-#include "lib-reftable.h"
+#include "lib-reftable-clar.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
#include "reftable/iter.h"
#include "reftable/table.h"
#include "strbuf.h"
-static int t_table_seek_once(void)
+void test_reftable_table__seek_once(void)
{
struct reftable_ref_record records[] = {
{
@@ -22,32 +22,32 @@ static int t_table_seek_once(void)
struct reftable_buf buf = REFTABLE_BUF_INIT;
int ret;
- t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
+ cl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
block_source_from_buf(&source, &buf);
ret = reftable_table_new(&table, &source, "name");
- check(!ret);
+ cl_assert(!ret);
reftable_table_init_ref_iterator(table, &it);
ret = reftable_iterator_seek_ref(&it, "");
- check(!ret);
+ cl_assert(!ret);
ret = reftable_iterator_next_ref(&it, &ref);
- check(!ret);
+ cl_assert(!ret);
- ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
- check_int(ret, ==, 1);
+ ret = reftable_ref_record_equal(&ref, &records[0],
+ REFTABLE_HASH_SIZE_SHA1);
+ cl_assert_equal_i(ret, 1);
ret = reftable_iterator_next_ref(&it, &ref);
- check_int(ret, ==, 1);
+ cl_assert_equal_i(ret, 1);
reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it);
reftable_table_decref(table);
reftable_buf_release(&buf);
- return 0;
}
-static int t_table_reseek(void)
+void test_reftable_table__reseek(void)
{
struct reftable_ref_record records[] = {
{
@@ -63,35 +63,35 @@ static int t_table_reseek(void)
struct reftable_buf buf = REFTABLE_BUF_INIT;
int ret;
- t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
+ cl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records),
+ NULL, 0, NULL);
block_source_from_buf(&source, &buf);
ret = reftable_table_new(&table, &source, "name");
- check(!ret);
+ cl_assert(!ret);
reftable_table_init_ref_iterator(table, &it);
for (size_t i = 0; i < 5; i++) {
ret = reftable_iterator_seek_ref(&it, "");
- check(!ret);
+ cl_assert(!ret);
ret = reftable_iterator_next_ref(&it, &ref);
- check(!ret);
+ cl_assert(!ret);
ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
- check_int(ret, ==, 1);
+ cl_assert_equal_i(ret, 1);
ret = reftable_iterator_next_ref(&it, &ref);
- check_int(ret, ==, 1);
+ cl_assert_equal_i(ret, 1);
}
reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it);
reftable_table_decref(table);
reftable_buf_release(&buf);
- return 0;
}
-static int t_table_block_iterator(void)
+void test_reftable_table__block_iterator(void)
{
struct reftable_block_source source = { 0 };
struct reftable_table_iterator it = { 0 };
@@ -147,14 +147,14 @@ static int t_table_block_iterator(void)
(uintmax_t) i);
}
- t_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);
+ cl_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);
block_source_from_buf(&source, &buf);
ret = reftable_table_new(&table, &source, "name");
- check(!ret);
+ cl_assert(!ret);
ret = reftable_table_iterator_init(&it, table);
- check(!ret);
+ cl_assert(!ret);
for (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) {
struct reftable_iterator record_it = { 0 };
@@ -163,22 +163,26 @@ static int t_table_block_iterator(void)
};
ret = reftable_table_iterator_next(&it, &block);
- check(!ret);
+ cl_assert(!ret);
- check_int(block->block_type, ==, expected_blocks[i].block_type);
- check_int(block->header_off, ==, expected_blocks[i].header_off);
- check_int(block->restart_count, ==, expected_blocks[i].restart_count);
+ cl_assert_equal_i(block->block_type,
+ expected_blocks[i].block_type);
+ cl_assert_equal_i(block->header_off,
+ expected_blocks[i].header_off);
+ cl_assert_equal_i(block->restart_count,
+ expected_blocks[i].restart_count);
ret = reftable_block_init_iterator(block, &record_it);
- check(!ret);
+ cl_assert(!ret);
for (size_t j = 0; ; j++) {
ret = iterator_next(&record_it, &record);
if (ret > 0) {
- check_int(j, ==, expected_blocks[i].record_count);
+ cl_assert_equal_i(j,
+ expected_blocks[i].record_count);
break;
}
- check(!ret);
+ cl_assert(!ret);
}
reftable_iterator_destroy(&record_it);
@@ -186,7 +190,7 @@ static int t_table_block_iterator(void)
}
ret = reftable_table_iterator_next(&it, &block);
- check_int(ret, ==, 1);
+ cl_assert_equal_i(ret, 1);
for (size_t i = 0; i < nrecords; i++)
reftable_free(records[i].refname);
@@ -194,13 +198,4 @@ static int t_table_block_iterator(void)
reftable_table_decref(table);
reftable_buf_release(&buf);
reftable_free(records);
- return 0;
-}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_table_seek_once(), "table can seek once");
- TEST(t_table_reseek(), "table can reseek multiple times");
- TEST(t_table_block_iterator(), "table can iterate through blocks");
- return test_done();
}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 07/10] t/unit-tests: convert reftable readwrite test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (5 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 06/10] t/unit-tests: convert reftable table " Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 08/10] t/unit-tests: convert reftable record " Seyi Kuforiji
` (3 subsequent siblings)
10 siblings, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable readwrite test file to use clar by using clar assertions
where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 2 +-
t/meson.build | 2 +-
...ble-readwrite.c => u-reftable-readwrite.c} | 386 ++++++++----------
3 files changed, 165 insertions(+), 225 deletions(-)
rename t/unit-tests/{t-reftable-readwrite.c => u-reftable-readwrite.c} (68%)
diff --git a/Makefile b/Makefile
index 0227fdb3e1..d86ef5a142 100644
--- a/Makefile
+++ b/Makefile
@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics
CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-pq
+CLAR_TEST_SUITES += u-reftable-readwrite
CLAR_TEST_SUITES += u-reftable-table
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
@@ -1382,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
diff --git a/t/meson.build b/t/meson.build
index 46d3a8580b..5189176472 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -12,6 +12,7 @@ clar_test_suites = [
'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-pq.c',
+ 'unit-tests/u-reftable-readwrite.c',
'unit-tests/u-reftable-table.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
@@ -60,7 +61,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c',
]
diff --git a/t/unit-tests/t-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c
similarity index 68%
rename from t/unit-tests/t-reftable-readwrite.c
rename to t/unit-tests/u-reftable-readwrite.c
index 4c49129439..f1c6a04429 100644
--- a/t/unit-tests/t-reftable-readwrite.c
+++ b/t/unit-tests/u-reftable-readwrite.c
@@ -8,8 +8,8 @@ license that can be found in the LICENSE file or at
#define DISABLE_SIGN_COMPARE_WARNINGS
-#include "test-lib.h"
-#include "lib-reftable.h"
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
#include "reftable/basics.h"
#include "reftable/blocksource.h"
#include "reftable/reftable-error.h"
@@ -19,24 +19,24 @@ license that can be found in the LICENSE file or at
static const int update_index = 5;
-static void t_buffer(void)
+void test_reftable_readwrite__buffer(void)
{
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 };
struct reftable_block_data out = { 0 };
int n;
uint8_t in[] = "hello";
- check(!reftable_buf_add(&buf, in, sizeof(in)));
+ cl_assert(reftable_buf_add(&buf, in, sizeof(in)) == 0);
block_source_from_buf(&source, &buf);
- check_int(block_source_size(&source), ==, 6);
+ cl_assert_equal_i(block_source_size(&source), 6);
n = block_source_read_data(&source, &out, 0, sizeof(in));
- check_int(n, ==, sizeof(in));
- check(!memcmp(in, out.data, n));
+ cl_assert_equal_i(n, sizeof(in));
+ cl_assert(!memcmp(in, out.data, n));
block_source_release_data(&out);
n = block_source_read_data(&source, &out, 1, 2);
- check_int(n, ==, 2);
- check(!memcmp(out.data, "el", 2));
+ cl_assert_equal_i(n, 2);
+ cl_assert(!memcmp(out.data, "el", 2));
block_source_release_data(&out);
block_source_close(&source);
@@ -55,41 +55,40 @@ static void write_table(char ***names, struct reftable_buf *buf, int N,
int i;
REFTABLE_CALLOC_ARRAY(*names, N + 1);
- check(*names != NULL);
+ cl_assert(*names != NULL);
REFTABLE_CALLOC_ARRAY(refs, N);
- check(refs != NULL);
+ cl_assert(refs != NULL);
REFTABLE_CALLOC_ARRAY(logs, N);
- check(logs != NULL);
+ cl_assert(logs != NULL);
for (i = 0; i < N; i++) {
refs[i].refname = (*names)[i] = xstrfmt("refs/heads/branch%02d", i);
refs[i].update_index = update_index;
refs[i].value_type = REFTABLE_REF_VAL1;
- t_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);
}
for (i = 0; i < N; i++) {
logs[i].refname = (*names)[i];
logs[i].update_index = update_index;
logs[i].value_type = REFTABLE_LOG_UPDATE;
- t_reftable_set_hash(logs[i].value.update.new_hash, i,
+ cl_reftable_set_hash(logs[i].value.update.new_hash, i,
REFTABLE_HASH_SHA1);
logs[i].value.update.message = (char *) "message";
}
- t_reftable_write_to_buf(buf, refs, N, logs, N, &opts);
+ cl_reftable_write_to_buf(buf, refs, N, logs, N, &opts);
reftable_free(refs);
reftable_free(logs);
}
-static void t_log_buffer_size(void)
+void test_reftable_readwrite__log_buffer_size(void)
{
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_write_options opts = {
.block_size = 4096,
};
- int err;
int i;
struct reftable_log_record
log = { .refname = (char *) "refs/heads/master",
@@ -102,7 +101,7 @@ static void t_log_buffer_size(void)
.time = 0x5e430672,
.message = (char *) "commit: 9\n",
} } };
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
/* This tests buffer extension for log compression. Must use a random
hash, to ensure that the compressed part is larger than the original.
@@ -112,22 +111,19 @@ static void t_log_buffer_size(void)
log.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256);
}
reftable_writer_set_limits(w, update_index, update_index);
- err = reftable_writer_add_log(w, &log);
- check(!err);
- err = reftable_writer_close(w);
- check(!err);
+ cl_assert(reftable_writer_add_log(w, &log) == 0);
+ cl_assert(reftable_writer_close(w) == 0);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_log_overflow(void)
+void test_reftable_readwrite__log_overflow(void)
{
struct reftable_buf buf = REFTABLE_BUF_INIT;
char msg[256] = { 0 };
struct reftable_write_options opts = {
.block_size = ARRAY_SIZE(msg),
};
- int err;
struct reftable_log_record log = {
.refname = (char *) "refs/heads/master",
.update_index = update_index,
@@ -144,21 +140,20 @@ static void t_log_overflow(void)
},
},
};
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
memset(msg, 'x', sizeof(msg) - 1);
reftable_writer_set_limits(w, update_index, update_index);
- err = reftable_writer_add_log(w, &log);
- check_int(err, ==, REFTABLE_ENTRY_TOO_BIG_ERROR);
+ cl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_ENTRY_TOO_BIG_ERROR);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_log_write_limits(void)
+void test_reftable_readwrite__log_write_limits(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_log_record log = {
.refname = (char *)"refs/head/master",
.update_index = 0,
@@ -174,29 +169,25 @@ static void t_log_write_limits(void)
},
},
};
- int err;
reftable_writer_set_limits(w, 1, 1);
/* write with update_index (0) below set limits (1, 1) */
- err = reftable_writer_add_log(w, &log);
- check_int(err, ==, 0);
+ cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
/* write with update_index (1) in the set limits (1, 1) */
log.update_index = 1;
- err = reftable_writer_add_log(w, &log);
- check_int(err, ==, 0);
+ cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
/* write with update_index (3) above set limits (1, 1) */
log.update_index = 3;
- err = reftable_writer_add_log(w, &log);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_API_ERROR);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_log_write_read(void)
+void test_reftable_readwrite__log_write_read(void)
{
struct reftable_write_options opts = {
.block_size = 256,
@@ -207,13 +198,14 @@ static void t_log_write_read(void)
struct reftable_table *table;
struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
const struct reftable_stats *stats = NULL;
- int N = 2, err, i, n;
+ int N = 2, i;
char **names;
+ int err;
names = reftable_calloc(N + 1, sizeof(*names));
- check(names != NULL);
+ cl_assert(names != NULL);
reftable_writer_set_limits(w, 0, N);
@@ -225,8 +217,7 @@ static void t_log_write_read(void)
ref.refname = name;
ref.update_index = i;
- err = reftable_writer_add_ref(w, &ref);
- check(!err);
+ cl_assert(reftable_writer_add_ref(w, &ref) == 0);
}
for (i = 0; i < N; i++) {
@@ -235,60 +226,57 @@ static void t_log_write_read(void)
log.refname = names[i];
log.update_index = i;
log.value_type = REFTABLE_LOG_UPDATE;
- t_reftable_set_hash(log.value.update.old_hash, i,
+ cl_reftable_set_hash(log.value.update.old_hash, i,
REFTABLE_HASH_SHA1);
- t_reftable_set_hash(log.value.update.new_hash, i + 1,
+ cl_reftable_set_hash(log.value.update.new_hash, i + 1,
REFTABLE_HASH_SHA1);
- err = reftable_writer_add_log(w, &log);
- check(!err);
+ cl_assert(reftable_writer_add_log(w, &log) == 0);
}
- n = reftable_writer_close(w);
- check_int(n, ==, 0);
+ cl_assert_equal_i(reftable_writer_close(w), 0);
stats = reftable_writer_stats(w);
- check_int(stats->log_stats.blocks, >, 0);
+ cl_assert(stats->log_stats.blocks > 0);
reftable_writer_free(w);
w = NULL;
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log");
- check(!err);
+ cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, names[N - 1]);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_next_ref(&it, &ref);
- check(!err);
+ cl_assert(!err);
/* end of iteration. */
- err = reftable_iterator_next_ref(&it, &ref);
- check_int(err, >, 0);
+ cl_assert(reftable_iterator_next_ref(&it, &ref) > 0);
reftable_iterator_destroy(&it);
reftable_ref_record_release(&ref);
err = reftable_table_init_log_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_log(&it, "");
- check(!err);
+ cl_assert(!err);
for (i = 0; ; i++) {
int err = reftable_iterator_next_log(&it, &log);
if (err > 0)
break;
- check(!err);
- check_str(names[i], log.refname);
- check_int(i, ==, log.update_index);
+ cl_assert(err == 0);
+ cl_assert_equal_s(names[i], log.refname);
+ cl_assert_equal_i(i, log.update_index);
reftable_log_record_release(&log);
}
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
reftable_iterator_destroy(&it);
/* cleanup. */
@@ -297,7 +285,7 @@ static void t_log_write_read(void)
reftable_table_decref(table);
}
-static void t_log_zlib_corruption(void)
+void test_reftable_readwrite__log_zlib_corruption(void)
{
struct reftable_write_options opts = {
.block_size = 256,
@@ -306,10 +294,11 @@ static void t_log_zlib_corruption(void)
struct reftable_table *table;
struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
const struct reftable_stats *stats = NULL;
char message[100] = { 0 };
- int err, i, n;
+ int i;
+ int err;
struct reftable_log_record log = {
.refname = (char *) "refname",
.value_type = REFTABLE_LOG_UPDATE,
@@ -329,14 +318,11 @@ static void t_log_zlib_corruption(void)
reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_add_log(w, &log);
- check(!err);
-
- n = reftable_writer_close(w);
- check_int(n, ==, 0);
+ cl_assert(reftable_writer_add_log(w, &log) == 0);
+ cl_assert_equal_i(reftable_writer_close(w), 0);
stats = reftable_writer_stats(w);
- check_int(stats->log_stats.blocks, >, 0);
+ cl_assert(stats->log_stats.blocks > 0);
reftable_writer_free(w);
w = NULL;
@@ -346,12 +332,12 @@ static void t_log_zlib_corruption(void)
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log");
- check(!err);
+ cl_assert(!err);
err = reftable_table_init_log_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_log(&it, "refname");
- check_int(err, ==, REFTABLE_ZLIB_ERROR);
+ cl_assert_equal_i(err, REFTABLE_ZLIB_ERROR);
reftable_iterator_destroy(&it);
@@ -360,7 +346,7 @@ static void t_log_zlib_corruption(void)
reftable_buf_release(&buf);
}
-static void t_table_read_write_sequential(void)
+void test_reftable_readwrite__table_read_write_sequential(void)
{
char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT;
@@ -376,24 +362,24 @@ static void t_table_read_write_sequential(void)
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
+ cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "");
- check(!err);
+ cl_assert(!err);
for (j = 0; ; j++) {
struct reftable_ref_record ref = { 0 };
int r = reftable_iterator_next_ref(&it, &ref);
- check_int(r, >=, 0);
+ cl_assert(r >= 0);
if (r > 0)
break;
- check_str(names[j], ref.refname);
- check_int(update_index, ==, ref.update_index);
+ cl_assert_equal_s(names[j], ref.refname);
+ cl_assert_equal_i(update_index, ref.update_index);
reftable_ref_record_release(&ref);
}
- check_int(j, ==, N);
+ cl_assert_equal_i(j, N);
reftable_iterator_destroy(&it);
reftable_table_decref(table);
@@ -401,42 +387,42 @@ static void t_table_read_write_sequential(void)
free_names(names);
}
-static void t_table_write_small_table(void)
+void test_reftable_readwrite__table_write_small_table(void)
{
char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT;
int N = 1;
write_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1);
- check_int(buf.len, <, 200);
+ cl_assert(buf.len < 200);
reftable_buf_release(&buf);
free_names(names);
}
-static void t_table_read_api(void)
+void test_reftable_readwrite__table_read_api(void)
{
char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT;
int N = 50;
struct reftable_table *table;
struct reftable_block_source source = { 0 };
- int err;
struct reftable_log_record log = { 0 };
struct reftable_iterator it = { 0 };
+ int err;
write_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
+ cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, names[0]);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_next_log(&it, &log);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert_equal_i(err, REFTABLE_API_ERROR);
reftable_buf_release(&buf);
free_names(names);
@@ -464,42 +450,42 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
- check_int(hash_id, ==, reftable_table_hash_id(table));
+ cl_assert(!err);
+ cl_assert_equal_i(hash_id, reftable_table_hash_id(table));
if (!index) {
table->ref_offsets.index_offset = 0;
} else {
- check_int(table->ref_offsets.index_offset, >, 0);
+ cl_assert(table->ref_offsets.index_offset > 0);
}
for (i = 1; i < N; i++) {
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, names[i]);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_next_ref(&it, &ref);
- check(!err);
- check_str(names[i], ref.refname);
- check_int(REFTABLE_REF_VAL1, ==, ref.value_type);
- check_int(i, ==, ref.value.val1[0]);
+ cl_assert(!err);
+ cl_assert_equal_s(names[i], ref.refname);
+ cl_assert_equal_i(REFTABLE_REF_VAL1, ref.value_type);
+ cl_assert_equal_i(i, ref.value.val1[0]);
reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it);
}
- check(!reftable_buf_addstr(&pastLast, names[N - 1]));
- check(!reftable_buf_addstr(&pastLast, "/"));
+ cl_assert(reftable_buf_addstr(&pastLast, names[N - 1]) == 0);
+ cl_assert(reftable_buf_addstr(&pastLast, "/") == 0);
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, pastLast.buf);
if (err == 0) {
struct reftable_ref_record ref = { 0 };
int err = reftable_iterator_next_ref(&it, &ref);
- check_int(err, >, 0);
+ cl_assert(err > 0);
} else {
- check_int(err, >, 0);
+ cl_assert(err > 0);
}
reftable_buf_release(&pastLast);
@@ -510,17 +496,17 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
reftable_table_decref(table);
}
-static void t_table_read_write_seek_linear(void)
+void test_reftable_readwrite__table_read_write_seek_linear(void)
{
t_table_read_write_seek(0, REFTABLE_HASH_SHA1);
}
-static void t_table_read_write_seek_linear_sha256(void)
+void test_reftable_readwrite__table_read_write_seek_linear_sha256(void)
{
t_table_read_write_seek(0, REFTABLE_HASH_SHA256);
}
-static void t_table_read_write_seek_index(void)
+void test_reftable_readwrite__table_read_write_seek_index(void)
{
t_table_read_write_seek(1, REFTABLE_HASH_SHA1);
}
@@ -538,14 +524,15 @@ static void t_table_refs_for(int indexed)
struct reftable_table *table;
struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_iterator it = { 0 };
- int N = 50, n, j, err, i;
+ int N = 50, j, i;
+ int err;
want_names = reftable_calloc(N + 1, sizeof(*want_names));
- check(want_names != NULL);
+ cl_assert(want_names != NULL);
- t_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);
for (i = 0; i < N; i++) {
uint8_t hash[REFTABLE_HASH_SIZE_SHA1];
@@ -561,24 +548,22 @@ static void t_table_refs_for(int indexed)
ref.refname = name;
ref.value_type = REFTABLE_REF_VAL2;
- t_reftable_set_hash(ref.value.val2.value, i / 4,
+ cl_reftable_set_hash(ref.value.val2.value, i / 4,
REFTABLE_HASH_SHA1);
- t_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,
+ cl_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,
REFTABLE_HASH_SHA1);
/* 80 bytes / entry, so 3 entries per block. Yields 17
*/
/* blocks. */
- n = reftable_writer_add_ref(w, &ref);
- check_int(n, ==, 0);
+ cl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);
if (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) ||
!memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1))
want_names[want_names_len++] = xstrdup(name);
}
- n = reftable_writer_close(w);
- check_int(n, ==, 0);
+ cl_assert_equal_i(reftable_writer_close(w), 0);
reftable_writer_free(w);
w = NULL;
@@ -586,29 +571,29 @@ static void t_table_refs_for(int indexed)
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref");
- check(!err);
+ cl_assert(!err);
if (!indexed)
table->obj_offsets.is_present = 0;
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "");
- check(!err);
+ cl_assert(!err);
reftable_iterator_destroy(&it);
err = reftable_table_refs_for(table, &it, want_hash);
- check(!err);
+ cl_assert(!err);
for (j = 0; ; j++) {
int err = reftable_iterator_next_ref(&it, &ref);
- check_int(err, >=, 0);
+ cl_assert(err >= 0);
if (err > 0)
break;
- check_int(j, <, want_names_len);
- check_str(ref.refname, want_names[j]);
+ cl_assert(j < want_names_len);
+ cl_assert_equal_s(ref.refname, want_names[j]);
reftable_ref_record_release(&ref);
}
- check_int(j, ==, want_names_len);
+ cl_assert_equal_i(j, want_names_len);
reftable_buf_release(&buf);
free_names(want_names);
@@ -616,21 +601,21 @@ static void t_table_refs_for(int indexed)
reftable_table_decref(table);
}
-static void t_table_refs_for_no_index(void)
+void test_reftable_readwrite__table_refs_for_no_index(void)
{
t_table_refs_for(0);
}
-static void t_table_refs_for_obj_index(void)
+void test_reftable_readwrite__table_refs_for_obj_index(void)
{
t_table_refs_for(1);
}
-static void t_write_empty_table(void)
+void test_reftable_readwrite__write_empty_table(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_block_source source = { 0 };
struct reftable_table *table = NULL;
struct reftable_ref_record rec = { 0 };
@@ -639,43 +624,41 @@ static void t_write_empty_table(void)
reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_close(w);
- check_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);
+ cl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);
reftable_writer_free(w);
- check_uint(buf.len, ==, header_size(1) + footer_size(1));
+ cl_assert_equal_i(buf.len, header_size(1) + footer_size(1));
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "filename");
- check(!err);
+ cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "");
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_next_ref(&it, &rec);
- check_int(err, >, 0);
+ cl_assert(err > 0);
reftable_iterator_destroy(&it);
reftable_table_decref(table);
reftable_buf_release(&buf);
}
-static void t_write_object_id_min_length(void)
+void test_reftable_readwrite__write_object_id_min_length(void)
{
struct reftable_write_options opts = {
.block_size = 75,
};
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record ref = {
.update_index = 1,
.value_type = REFTABLE_REF_VAL1,
.value.val1 = {42},
};
- int err;
int i;
reftable_writer_set_limits(w, 1, 1);
@@ -686,30 +669,27 @@ static void t_write_object_id_min_length(void)
char name[256];
snprintf(name, sizeof(name), "ref%05d", i);
ref.refname = name;
- err = reftable_writer_add_ref(w, &ref);
- check(!err);
+ cl_assert(reftable_writer_add_ref(w, &ref) == 0);
}
- err = reftable_writer_close(w);
- check(!err);
- check_int(reftable_writer_stats(w)->object_id_len, ==, 2);
+ cl_assert(reftable_writer_close(w) == 0);
+ cl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 2);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_write_object_id_length(void)
+void test_reftable_readwrite__write_object_id_length(void)
{
struct reftable_write_options opts = {
.block_size = 75,
};
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record ref = {
.update_index = 1,
.value_type = REFTABLE_REF_VAL1,
.value.val1 = {42},
};
- int err;
int i;
reftable_writer_set_limits(w, 1, 1);
@@ -721,44 +701,38 @@ static void t_write_object_id_length(void)
snprintf(name, sizeof(name), "ref%05d", i);
ref.refname = name;
ref.value.val1[15] = i;
- err = reftable_writer_add_ref(w, &ref);
- check(!err);
+ cl_assert(reftable_writer_add_ref(w, &ref) == 0);
}
- err = reftable_writer_close(w);
- check(!err);
- check_int(reftable_writer_stats(w)->object_id_len, ==, 16);
+ cl_assert(reftable_writer_close(w) == 0);
+ cl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 16);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_write_empty_key(void)
+void test_reftable_readwrite__write_empty_key(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record ref = {
.refname = (char *) "",
.update_index = 1,
.value_type = REFTABLE_REF_DELETION,
};
- int err;
reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_add_ref(w, &ref);
- check_int(err, ==, REFTABLE_API_ERROR);
-
- err = reftable_writer_close(w);
- check_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);
+ cl_assert_equal_i(reftable_writer_add_ref(w, &ref), REFTABLE_API_ERROR);
+ cl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_write_key_order(void)
+void test_reftable_readwrite__write_key_order(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
- struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
+ struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record refs[2] = {
{
.refname = (char *) "b",
@@ -776,24 +750,20 @@ static void t_write_key_order(void)
},
}
};
- int err;
reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_add_ref(w, &refs[0]);
- check(!err);
- err = reftable_writer_add_ref(w, &refs[1]);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert(reftable_writer_add_ref(w, &refs[0]) == 0);
+ cl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]), REFTABLE_API_ERROR);
refs[0].update_index = 2;
- err = reftable_writer_add_ref(w, &refs[0]);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), REFTABLE_API_ERROR);
reftable_writer_close(w);
reftable_writer_free(w);
reftable_buf_release(&buf);
}
-static void t_write_multiple_indices(void)
+void test_reftable_readwrite__write_multiple_indices(void)
{
struct reftable_write_options opts = {
.block_size = 100,
@@ -805,9 +775,10 @@ static void t_write_multiple_indices(void)
struct reftable_writer *writer;
struct reftable_table *table;
char buf[128];
- int err, i;
+ int i;
+ int err;
- writer = t_reftable_strbuf_writer(&writer_buf, &opts);
+ writer = cl_reftable_strbuf_writer(&writer_buf, &opts);
reftable_writer_set_limits(writer, 1, 1);
for (i = 0; i < 100; i++) {
struct reftable_ref_record ref = {
@@ -819,8 +790,7 @@ static void t_write_multiple_indices(void)
snprintf(buf, sizeof(buf), "refs/heads/%04d", i);
ref.refname = buf;
- err = reftable_writer_add_ref(writer, &ref);
- check(!err);
+ cl_assert(reftable_writer_add_ref(writer, &ref) == 0);
}
for (i = 0; i < 100; i++) {
@@ -836,8 +806,7 @@ static void t_write_multiple_indices(void)
snprintf(buf, sizeof(buf), "refs/heads/%04d", i);
log.refname = buf;
- err = reftable_writer_add_log(writer, &log);
- check(!err);
+ cl_assert(reftable_writer_add_log(writer, &log) == 0);
}
reftable_writer_close(writer);
@@ -847,22 +816,22 @@ static void t_write_multiple_indices(void)
* for each of the block types.
*/
stats = reftable_writer_stats(writer);
- check_int(stats->ref_stats.index_offset, >, 0);
- check_int(stats->obj_stats.index_offset, >, 0);
- check_int(stats->log_stats.index_offset, >, 0);
+ cl_assert(stats->ref_stats.index_offset > 0);
+ cl_assert(stats->obj_stats.index_offset > 0);
+ cl_assert(stats->log_stats.index_offset > 0);
block_source_from_buf(&source, &writer_buf);
err = reftable_table_new(&table, &source, "filename");
- check(!err);
+ cl_assert(!err);
/*
* Seeking the log uses the log index now. In case there is any
* confusion regarding indices we would notice here.
*/
err = reftable_table_init_log_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_log(&it, "");
- check(!err);
+ cl_assert(!err);
reftable_iterator_destroy(&it);
reftable_writer_free(writer);
@@ -870,7 +839,7 @@ static void t_write_multiple_indices(void)
reftable_buf_release(&writer_buf);
}
-static void t_write_multi_level_index(void)
+void test_reftable_readwrite__write_multi_level_index(void)
{
struct reftable_write_options opts = {
.block_size = 100,
@@ -883,7 +852,7 @@ static void t_write_multi_level_index(void)
struct reftable_table *table;
int err;
- writer = t_reftable_strbuf_writer(&writer_buf, &opts);
+ writer = cl_reftable_strbuf_writer(&writer_buf, &opts);
reftable_writer_set_limits(writer, 1, 1);
for (size_t i = 0; i < 200; i++) {
struct reftable_ref_record ref = {
@@ -896,8 +865,7 @@ static void t_write_multi_level_index(void)
snprintf(buf, sizeof(buf), "refs/heads/%03" PRIuMAX, (uintmax_t)i);
ref.refname = buf;
- err = reftable_writer_add_ref(writer, &ref);
- check(!err);
+ cl_assert(reftable_writer_add_ref(writer, &ref) == 0);
}
reftable_writer_close(writer);
@@ -906,19 +874,19 @@ static void t_write_multi_level_index(void)
* multi-level index.
*/
stats = reftable_writer_stats(writer);
- check_int(stats->ref_stats.max_index_level, ==, 2);
+ cl_assert_equal_i(stats->ref_stats.max_index_level, 2);
block_source_from_buf(&source, &writer_buf);
err = reftable_table_new(&table, &source, "filename");
- check(!err);
+ cl_assert(!err);
/*
* Seeking the last ref should work as expected.
*/
err = reftable_table_init_ref_iterator(table, &it);
- check(!err);
+ cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "refs/heads/199");
- check(!err);
+ cl_assert(!err);
reftable_iterator_destroy(&it);
reftable_writer_free(writer);
@@ -927,7 +895,7 @@ static void t_write_multi_level_index(void)
reftable_buf_release(&buf);
}
-static void t_corrupt_table_empty(void)
+void test_reftable_readwrite__corrupt_table_empty(void)
{
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 };
@@ -936,50 +904,22 @@ static void t_corrupt_table_empty(void)
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log");
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
+ cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
}
-static void t_corrupt_table(void)
+void test_reftable_readwrite__corrupt_table(void)
{
uint8_t zeros[1024] = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 };
struct reftable_table *table;
int err;
- check(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
+
+ cl_assert(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log");
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
+ cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
reftable_buf_release(&buf);
}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_buffer(), "strbuf works as blocksource");
- TEST(t_corrupt_table(), "read-write on corrupted table");
- TEST(t_corrupt_table_empty(), "read-write on an empty table");
- TEST(t_log_buffer_size(), "buffer extension for log compression");
- TEST(t_log_overflow(), "log overflow returns expected error");
- TEST(t_log_write_limits(), "writer limits for writing log records");
- TEST(t_log_write_read(), "read-write on log records");
- TEST(t_log_zlib_corruption(), "reading corrupted log record returns expected error");
- TEST(t_table_read_api(), "read on a table");
- TEST(t_table_read_write_seek_index(), "read-write on a table with index");
- TEST(t_table_read_write_seek_linear(), "read-write on a table without index (SHA1)");
- TEST(t_table_read_write_seek_linear_sha256(), "read-write on a table without index (SHA256)");
- TEST(t_table_read_write_sequential(), "sequential read-write on a table");
- TEST(t_table_refs_for_no_index(), "refs-only table with no index");
- TEST(t_table_refs_for_obj_index(), "refs-only table with index");
- TEST(t_table_write_small_table(), "write_table works");
- TEST(t_write_empty_key(), "write on refs with empty keys");
- TEST(t_write_empty_table(), "read-write on empty tables");
- TEST(t_write_key_order(), "refs must be written in increasing order");
- TEST(t_write_multi_level_index(), "table with multi-level index");
- TEST(t_write_multiple_indices(), "table with indices for multiple block types");
- TEST(t_write_object_id_length(), "prefix compression on writing refs");
- TEST(t_write_object_id_min_length(), "prefix compression on writing refs");
-
- return test_done();
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 08/10] t/unit-tests: convert reftable record test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (6 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 07/10] t/unit-tests: convert reftable readwrite " Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 09/10] t/unit-tests: convert reftable stack " Seyi Kuforiji
` (2 subsequent siblings)
10 siblings, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable record test file to use clar by using clar assertions
where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 1 -
t/meson.build | 1 -
...-reftable-record.c => u-reftable-record.c} | 217 ++++++++----------
3 files changed, 99 insertions(+), 120 deletions(-)
rename t/unit-tests/{t-reftable-record.c => u-reftable-record.c} (63%)
diff --git a/Makefile b/Makefile
index d86ef5a142..3b41342ddb 100644
--- a/Makefile
+++ b/Makefile
@@ -1383,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
diff --git a/t/meson.build b/t/meson.build
index 5189176472..297937f307 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -61,7 +61,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c',
]
diff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/u-reftable-record.c
similarity index 63%
rename from t/unit-tests/t-reftable-record.c
rename to t/unit-tests/u-reftable-record.c
index 553a007664..137a7ab815 100644
--- a/t/unit-tests/t-reftable-record.c
+++ b/t/unit-tests/u-reftable-record.c
@@ -6,7 +6,8 @@
https://developers.google.com/open-source/licenses/bsd
*/
-#include "test-lib.h"
+#include "unit-test.h"
+#include "lib-reftable-clar.h"
#include "reftable/basics.h"
#include "reftable/constants.h"
#include "reftable/record.h"
@@ -17,16 +18,16 @@ static void t_copy(struct reftable_record *rec)
uint8_t typ;
typ = reftable_record_type(rec);
- check(!reftable_record_init(©, typ));
+ cl_assert(reftable_record_init(©, typ) == 0);
reftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);
/* do it twice to catch memory leaks */
reftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);
- check(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_record_release(©);
}
-static void t_varint_roundtrip(void)
+void test_reftable_record__varint_roundtrip(void)
{
uint64_t inputs[] = { 0,
1,
@@ -49,16 +50,16 @@ static void t_varint_roundtrip(void)
int n = put_var_int(&out, in);
uint64_t got = 0;
- check_int(n, >, 0);
+ cl_assert(n > 0);
out.len = n;
n = get_var_int(&got, &out);
- check_int(n, >, 0);
+ cl_assert(n > 0);
- check_int(got, ==, in);
+ cl_assert_equal_i(got, in);
}
}
-static void t_varint_overflow(void)
+void test_reftable_record__varint_overflow(void)
{
unsigned char buf[] = {
0xFF, 0xFF, 0xFF, 0xFF,
@@ -70,8 +71,7 @@ static void t_varint_overflow(void)
.len = sizeof(buf),
};
uint64_t value;
- int err = get_var_int(&value, &view);
- check_int(err, ==, -1);
+ cl_assert_equal_i(get_var_int(&value, &view), -1);
}
static void set_hash(uint8_t *h, int j)
@@ -80,7 +80,7 @@ static void set_hash(uint8_t *h, int j)
h[i] = (j >> i) & 0xff;
}
-static void t_reftable_ref_record_comparison(void)
+void test_reftable_record__ref_record_comparison(void)
{
struct reftable_record in[3] = {
{
@@ -102,21 +102,21 @@ static void t_reftable_ref_record_comparison(void)
};
int cmp;
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
in[1].u.ref.value_type = in[0].u.ref.value_type;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
}
-static void t_reftable_ref_record_compare_name(void)
+void test_reftable_record__ref_record_compare_name(void)
{
struct reftable_ref_record recs[3] = {
{
@@ -130,12 +130,12 @@ static void t_reftable_ref_record_compare_name(void)
},
};
- check_int(reftable_ref_record_compare_name(&recs[0], &recs[1]), <, 0);
- check_int(reftable_ref_record_compare_name(&recs[1], &recs[0]), >, 0);
- check_int(reftable_ref_record_compare_name(&recs[0], &recs[2]), ==, 0);
+ cl_assert(reftable_ref_record_compare_name(&recs[0], &recs[1]) < 0);
+ cl_assert(reftable_ref_record_compare_name(&recs[1], &recs[0]) > 0);
+ cl_assert_equal_i(reftable_ref_record_compare_name(&recs[0], &recs[2]), 0);
}
-static void t_reftable_ref_record_roundtrip(void)
+void test_reftable_record__ref_record_roundtrip(void)
{
struct reftable_buf scratch = REFTABLE_BUF_INIT;
@@ -172,19 +172,19 @@ static void t_reftable_ref_record_roundtrip(void)
t_copy(&in);
- check_int(reftable_record_val_type(&in), ==, i);
- check_int(reftable_record_is_deletion(&in), ==, i == REFTABLE_REF_DELETION);
+ cl_assert_equal_i(reftable_record_val_type(&in), i);
+ cl_assert_equal_i(reftable_record_is_deletion(&in), i == REFTABLE_REF_DELETION);
reftable_record_key(&in, &key);
n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >, 0);
+ cl_assert(n > 0);
/* decode into a non-zero reftable_record to test for leaks. */
m = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);
- check_int(n, ==, m);
+ cl_assert_equal_i(n, m);
- check(reftable_ref_record_equal(&in.u.ref, &out.u.ref,
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_ref_record_equal(&in.u.ref, &out.u.ref,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_record_release(&in);
reftable_buf_release(&key);
@@ -194,7 +194,7 @@ static void t_reftable_ref_record_roundtrip(void)
reftable_buf_release(&scratch);
}
-static void t_reftable_log_record_comparison(void)
+void test_reftable_record__log_record_comparison(void)
{
struct reftable_record in[3] = {
{
@@ -215,21 +215,21 @@ static void t_reftable_log_record_comparison(void)
};
int cmp;
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
/* comparison should be reversed for equal keys, because
* comparison is now performed on the basis of update indices */
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check_int(cmp, <, 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp < 0);
in[1].u.log.update_index = in[0].u.log.update_index;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
}
-static void t_reftable_log_record_compare_key(void)
+void test_reftable_record__log_record_compare_key(void)
{
struct reftable_log_record logs[3] = {
{
@@ -246,19 +246,19 @@ static void t_reftable_log_record_compare_key(void)
},
};
- check_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);
- check_int(reftable_log_record_compare_key(&logs[1], &logs[0]), >, 0);
+ cl_assert(reftable_log_record_compare_key(&logs[0], &logs[1]) < 0);
+ cl_assert(reftable_log_record_compare_key(&logs[1], &logs[0]) > 0);
logs[1].update_index = logs[0].update_index;
- check_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);
+ cl_assert(reftable_log_record_compare_key(&logs[0], &logs[1]) < 0);
- check_int(reftable_log_record_compare_key(&logs[0], &logs[2]), >, 0);
- check_int(reftable_log_record_compare_key(&logs[2], &logs[0]), <, 0);
+ cl_assert(reftable_log_record_compare_key(&logs[0], &logs[2]) > 0);
+ cl_assert(reftable_log_record_compare_key(&logs[2], &logs[0]) < 0);
logs[2].update_index = logs[0].update_index;
- check_int(reftable_log_record_compare_key(&logs[0], &logs[2]), ==, 0);
+ cl_assert_equal_i(reftable_log_record_compare_key(&logs[0], &logs[2]), 0);
}
-static void t_reftable_log_record_roundtrip(void)
+void test_reftable_record__log_record_roundtrip(void)
{
struct reftable_log_record in[] = {
{
@@ -292,9 +292,9 @@ static void t_reftable_log_record_roundtrip(void)
set_hash(in[2].value.update.new_hash, 3);
set_hash(in[2].value.update.old_hash, 4);
- check(!reftable_log_record_is_deletion(&in[0]));
- check(reftable_log_record_is_deletion(&in[1]));
- check(!reftable_log_record_is_deletion(&in[2]));
+ cl_assert(reftable_log_record_is_deletion(&in[0]) == 0);
+ cl_assert(reftable_log_record_is_deletion(&in[1]) != 0);
+ cl_assert(reftable_log_record_is_deletion(&in[2]) == 0);
for (size_t i = 0; i < ARRAY_SIZE(in); i++) {
struct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };
@@ -328,14 +328,14 @@ static void t_reftable_log_record_roundtrip(void)
reftable_record_key(&rec, &key);
n = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >=, 0);
+ cl_assert(n >= 0);
valtype = reftable_record_val_type(&rec);
m = reftable_record_decode(&out, key, valtype, dest,
REFTABLE_HASH_SIZE_SHA1, &scratch);
- check_int(n, ==, m);
+ cl_assert_equal_i(n, m);
- check(reftable_log_record_equal(&in[i], &out.u.log,
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_log_record_equal(&in[i], &out.u.log,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_log_record_release(&in[i]);
reftable_buf_release(&key);
reftable_record_release(&out);
@@ -344,7 +344,7 @@ static void t_reftable_log_record_roundtrip(void)
reftable_buf_release(&scratch);
}
-static void t_key_roundtrip(void)
+void test_reftable_record__key_roundtrip(void)
{
uint8_t buffer[1024] = { 0 };
struct string_view dest = {
@@ -359,25 +359,25 @@ static void t_key_roundtrip(void)
int n, m;
uint8_t rt_extra;
- check(!reftable_buf_addstr(&last_key, "refs/heads/master"));
- check(!reftable_buf_addstr(&key, "refs/tags/bla"));
+ cl_assert(reftable_buf_addstr(&last_key, "refs/heads/master") == 0);
+ cl_assert(reftable_buf_addstr(&key, "refs/tags/bla") == 0);
extra = 6;
n = reftable_encode_key(&restart, dest, last_key, key, extra);
- check(!restart);
- check_int(n, >, 0);
+ cl_assert(restart == 0);
+ cl_assert(n > 0);
- check(!reftable_buf_addstr(&roundtrip, "refs/heads/master"));
+ cl_assert(reftable_buf_addstr(&roundtrip, "refs/heads/master") == 0);
m = reftable_decode_key(&roundtrip, &rt_extra, dest);
- check_int(n, ==, m);
- check(!reftable_buf_cmp(&key, &roundtrip));
- check_int(rt_extra, ==, extra);
+ cl_assert_equal_i(n, m);
+ cl_assert(reftable_buf_cmp(&key, &roundtrip) == 0);
+ cl_assert_equal_i(rt_extra, extra);
reftable_buf_release(&last_key);
reftable_buf_release(&key);
reftable_buf_release(&roundtrip);
}
-static void t_reftable_obj_record_comparison(void)
+void test_reftable_record__obj_record_comparison(void)
{
uint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };
@@ -405,21 +405,21 @@ static void t_reftable_obj_record_comparison(void)
};
int cmp;
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
in[1].u.obj.offset_len = in[0].u.obj.offset_len;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
}
-static void t_reftable_obj_record_roundtrip(void)
+void test_reftable_record__obj_record_roundtrip(void)
{
uint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };
uint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };
@@ -460,17 +460,17 @@ static void t_reftable_obj_record_roundtrip(void)
int n, m;
uint8_t extra;
- check(!reftable_record_is_deletion(&in));
+ cl_assert(reftable_record_is_deletion(&in) == 0);
t_copy(&in);
reftable_record_key(&in, &key);
n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >, 0);
+ cl_assert(n > 0);
extra = reftable_record_val_type(&in);
m = reftable_record_decode(&out, key, extra, dest,
REFTABLE_HASH_SIZE_SHA1, &scratch);
- check_int(n, ==, m);
+ cl_assert_equal_i(n, m);
- check(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_buf_release(&key);
reftable_record_release(&out);
}
@@ -478,7 +478,7 @@ static void t_reftable_obj_record_roundtrip(void)
reftable_buf_release(&scratch);
}
-static void t_reftable_index_record_comparison(void)
+void test_reftable_record__index_record_comparison(void)
{
struct reftable_record in[3] = {
{
@@ -499,28 +499,28 @@ static void t_reftable_index_record_comparison(void)
};
int cmp;
- check(!reftable_buf_addstr(&in[0].u.idx.last_key, "refs/heads/master"));
- check(!reftable_buf_addstr(&in[1].u.idx.last_key, "refs/heads/master"));
- check(!reftable_buf_addstr(&in[2].u.idx.last_key, "refs/heads/branch"));
+ cl_assert(reftable_buf_addstr(&in[0].u.idx.last_key, "refs/heads/master") == 0);
+ cl_assert(reftable_buf_addstr(&in[1].u.idx.last_key, "refs/heads/master") == 0);
+ cl_assert(reftable_buf_addstr(&in[2].u.idx.last_key, "refs/heads/branch") == 0);
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
in[1].u.idx.offset = in[0].u.idx.offset;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
for (size_t i = 0; i < ARRAY_SIZE(in); i++)
reftable_record_release(&in[i]);
}
-static void t_reftable_index_record_roundtrip(void)
+void test_reftable_record__index_record_roundtrip(void)
{
struct reftable_record in = {
.type = REFTABLE_BLOCK_TYPE_INDEX,
@@ -543,43 +543,24 @@ static void t_reftable_index_record_roundtrip(void)
int n, m;
uint8_t extra;
- check(!reftable_buf_addstr(&in.u.idx.last_key, "refs/heads/master"));
+ cl_assert(reftable_buf_addstr(&in.u.idx.last_key, "refs/heads/master") == 0);
reftable_record_key(&in, &key);
t_copy(&in);
- check(!reftable_record_is_deletion(&in));
- check(!reftable_buf_cmp(&key, &in.u.idx.last_key));
+ cl_assert(reftable_record_is_deletion(&in) == 0);
+ cl_assert(reftable_buf_cmp(&key, &in.u.idx.last_key) == 0);
n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >, 0);
+ cl_assert(n > 0);
extra = reftable_record_val_type(&in);
m = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,
&scratch);
- check_int(m, ==, n);
+ cl_assert_equal_i(m, n);
- check(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_record_release(&out);
reftable_buf_release(&key);
reftable_buf_release(&scratch);
reftable_buf_release(&in.u.idx.last_key);
}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_reftable_ref_record_comparison(), "comparison operations work on ref record");
- TEST(t_reftable_log_record_comparison(), "comparison operations work on log record");
- TEST(t_reftable_index_record_comparison(), "comparison operations work on index record");
- TEST(t_reftable_obj_record_comparison(), "comparison operations work on obj record");
- TEST(t_reftable_ref_record_compare_name(), "reftable_ref_record_compare_name works");
- TEST(t_reftable_log_record_compare_key(), "reftable_log_record_compare_key works");
- TEST(t_reftable_log_record_roundtrip(), "record operations work on log record");
- TEST(t_reftable_ref_record_roundtrip(), "record operations work on ref record");
- TEST(t_varint_roundtrip(), "put_var_int and get_var_int work");
- TEST(t_varint_overflow(), "get_var_int notices an integer overflow");
- TEST(t_key_roundtrip(), "reftable_encode_key and reftable_decode_key work");
- TEST(t_reftable_obj_record_roundtrip(), "record operations work on obj record");
- TEST(t_reftable_index_record_roundtrip(), "record operations work on index record");
-
- return test_done();
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 09/10] t/unit-tests: convert reftable stack test to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (7 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 08/10] t/unit-tests: convert reftable record " Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests Seyi Kuforiji
2025-06-03 18:41 ` [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Junio C Hamano
10 siblings, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
Adapt reftable stack test file to use clar by using clar assertions
where necessary.
This marks the end of all unit tests migrated away from the
`unit-tests/t-*.c` pattern, there are no longer any files matching that
glob. Remove the sanity check for `t-*.c` files to prevent Meson
configuration errors during CI and local builds.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 2 +-
t/meson.build | 5 +-
...{t-reftable-stack.c => u-reftable-stack.c} | 726 +++++++-----------
3 files changed, 282 insertions(+), 451 deletions(-)
rename t/unit-tests/{t-reftable-stack.c => u-reftable-stack.c} (59%)
diff --git a/Makefile b/Makefile
index 3b41342ddb..8ed8f234f4 100644
--- a/Makefile
+++ b/Makefile
@@ -1369,6 +1369,7 @@ CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-pq
CLAR_TEST_SUITES += u-reftable-readwrite
+CLAR_TEST_SUITES += u-reftable-stack
CLAR_TEST_SUITES += u-reftable-table
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
@@ -1383,7 +1384,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
-UNIT_TEST_PROGRAMS += t-reftable-stack
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-reftable.o
diff --git a/t/meson.build b/t/meson.build
index 297937f307..fcbb659263 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -13,6 +13,8 @@ clar_test_suites = [
'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-pq.c',
'unit-tests/u-reftable-readwrite.c',
+ 'unit-tests/u-reftable-record.c',
+ 'unit-tests/u-reftable-stack.c',
'unit-tests/u-reftable-table.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
@@ -61,7 +63,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-stack.c',
]
foreach unit_test_program : unit_test_programs
@@ -1163,8 +1164,6 @@ benchmarks = [
# sufficient to catch missing test suites in our CI though.
foreach glob, tests : {
't[0-9][0-9][0-9][0-9]-*.sh': integration_tests,
- 'perf/p[0-9][0-9][0-9][0-9]-*.sh': benchmarks,
- 'unit-tests/t-*.c': unit_test_programs,
'unit-tests/u-*.c': clar_test_suites,
}
actual_tests = run_command(shell, '-c', 'ls ' + glob,
diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/u-reftable-stack.c
similarity index 59%
rename from t/unit-tests/t-reftable-stack.c
rename to t/unit-tests/u-reftable-stack.c
index 2f49c97519..8d6cfba22c 100644
--- a/t/unit-tests/t-reftable-stack.c
+++ b/t/unit-tests/u-reftable-stack.c
@@ -8,9 +8,9 @@ license that can be found in the LICENSE file or at
#define DISABLE_SIGN_COMPARE_WARNINGS
-#include "test-lib.h"
-#include "lib-reftable.h"
+#include "unit-test.h"
#include "dir.h"
+#include "lib-reftable-clar.h"
#include "reftable/merged.h"
#include "reftable/reftable-error.h"
#include "reftable/stack.h"
@@ -70,11 +70,11 @@ static char *get_tmp_template(int linenumber)
static char *get_tmp_dir(int linenumber)
{
char *dir = get_tmp_template(linenumber);
- check(mkdtemp(dir) != NULL);
+ cl_assert(mkdtemp(dir) != NULL);
return dir;
}
-static void t_read_file(void)
+void test_reftable_stack__read_file(void)
{
char *fn = get_tmp_template(__LINE__);
struct tempfile *tmp = mks_tempfile(fn);
@@ -84,17 +84,17 @@ static void t_read_file(void)
char **names = NULL;
const char *want[] = { "line1", "line2", "line3" };
- check_int(fd, >, 0);
+ cl_assert(fd > 0);
n = write_in_full(fd, out, strlen(out));
- check_int(n, ==, strlen(out));
+ cl_assert_equal_i(n, strlen(out));
err = close(fd);
- check_int(err, >=, 0);
+ cl_assert(err >= 0);
err = read_lines(fn, &names);
- check(!err);
+ cl_assert(err == 0);
for (size_t i = 0; names[i]; i++)
- check_str(want[i], names[i]);
+ cl_assert_equal_s(want[i], names[i]);
free_names(names);
(void) remove(fn);
delete_tempfile(&tmp);
@@ -103,8 +103,8 @@ static void t_read_file(void)
static int write_test_ref(struct reftable_writer *wr, void *arg)
{
struct reftable_ref_record *ref = arg;
- check(!reftable_writer_set_limits(wr, ref->update_index,
- ref->update_index));
+ cl_assert(reftable_writer_set_limits(wr, ref->update_index,
+ ref->update_index) == 0);
return reftable_writer_add_ref(wr, ref);
}
@@ -112,7 +112,6 @@ static void write_n_ref_tables(struct reftable_stack *st,
size_t n)
{
int disable_auto_compact;
- int err;
disable_auto_compact = st->opts.disable_auto_compact;
st->opts.disable_auto_compact = 1;
@@ -126,10 +125,9 @@ static void write_n_ref_tables(struct reftable_stack *st,
snprintf(buf, sizeof(buf), "refs/heads/branch-%04"PRIuMAX, (uintmax_t)i);
ref.refname = buf;
- t_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);
- err = reftable_stack_add(st, &write_test_ref, &ref);
- check(!err);
+ cl_assert(reftable_stack_add(st, &write_test_ref, &ref) == 0);
}
st->opts.disable_auto_compact = disable_auto_compact;
@@ -144,12 +142,12 @@ static int write_test_log(struct reftable_writer *wr, void *arg)
{
struct write_log_arg *wla = arg;
- check(!reftable_writer_set_limits(wr, wla->update_index,
- wla->update_index));
+ cl_assert(reftable_writer_set_limits(wr, wla->update_index,
+ wla->update_index) == 0);
return reftable_writer_add_log(wr, wla->log);
}
-static void t_reftable_stack_add_one(void)
+void test_reftable_stack__add_one(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_buf scratch = REFTABLE_BUF_INIT;
@@ -158,7 +156,6 @@ static void t_reftable_stack_add_one(void)
.default_permissions = 0660,
};
struct reftable_stack *st = NULL;
- int err;
struct reftable_ref_record ref = {
.refname = (char *) "HEAD",
.update_index = 1,
@@ -167,32 +164,35 @@ static void t_reftable_stack_add_one(void)
};
struct reftable_ref_record dest = { 0 };
struct stat stat_result = { 0 };
+ int err;
+
err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(!err);
err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
+ cl_assert(!err);
err = reftable_stack_read_ref(st, ref.refname, &dest);
- check(!err);
- check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
- check_int(st->tables_len, >, 0);
+ cl_assert(!err);
+ cl_assert(reftable_ref_record_equal(&ref, &dest,
+ REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(st->tables_len > 0);
#ifndef GIT_WINDOWS_NATIVE
- check(!reftable_buf_addstr(&scratch, dir));
- check(!reftable_buf_addstr(&scratch, "/tables.list"));
- err = stat(scratch.buf, &stat_result);
- check(!err);
- check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
+ cl_assert(reftable_buf_addstr(&scratch, dir) == 0);
+ cl_assert(reftable_buf_addstr(&scratch, "/tables.list") == 0);
+ cl_assert(stat(scratch.buf, &stat_result) == 0);
+ cl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);
reftable_buf_reset(&scratch);
- check(!reftable_buf_addstr(&scratch, dir));
- check(!reftable_buf_addstr(&scratch, "/"));
+ cl_assert(reftable_buf_addstr(&scratch, dir) == 0);
+ cl_assert(reftable_buf_addstr(&scratch, "/") == 0);
/* do not try at home; not an external API for reftable. */
- check(!reftable_buf_addstr(&scratch, st->tables[0]->name));
+ cl_assert(!reftable_buf_addstr(&scratch, st->tables[0]->name));
err = stat(scratch.buf, &stat_result);
- check(!err);
- check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
+ cl_assert(!err);
+ cl_assert_equal_i((stat_result.st_mode & 0777),
+ opts.default_permissions);
#else
(void) stat_result;
#endif
@@ -204,14 +204,13 @@ static void t_reftable_stack_add_one(void)
umask(mask);
}
-static void t_reftable_stack_uptodate(void)
+void test_reftable_stack__uptodate(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL;
struct reftable_stack *st2 = NULL;
char *dir = get_tmp_dir(__LINE__);
- int err;
struct reftable_ref_record ref1 = {
.refname = (char *) "HEAD",
.update_index = 1,
@@ -229,34 +228,23 @@ static void t_reftable_stack_uptodate(void)
/* simulate multi-process access to the same stack
by creating two stacks for the same directory.
*/
- err = reftable_new_stack(&st1, dir, &opts);
- check(!err);
-
- err = reftable_new_stack(&st2, dir, &opts);
- check(!err);
-
- err = reftable_stack_add(st1, write_test_ref, &ref1);
- check(!err);
-
- err = reftable_stack_add(st2, write_test_ref, &ref2);
- check_int(err, ==, REFTABLE_OUTDATED_ERROR);
-
- err = reftable_stack_reload(st2);
- check(!err);
-
- err = reftable_stack_add(st2, write_test_ref, &ref2);
- check(!err);
+ cl_assert(reftable_new_stack(&st1, dir, &opts) == 0);
+ cl_assert(reftable_new_stack(&st2, dir, &opts) == 0);
+ cl_assert(reftable_stack_add(st1, write_test_ref, &ref1) == 0);
+ cl_assert_equal_i(reftable_stack_add(st2, write_test_ref, &ref2),
+ REFTABLE_OUTDATED_ERROR);
+ cl_assert(reftable_stack_reload(st2) == 0);
+ cl_assert(reftable_stack_add(st2, write_test_ref, &ref2) == 0);
reftable_stack_destroy(st1);
reftable_stack_destroy(st2);
clear_dir(dir);
}
-static void t_reftable_stack_transaction_api(void)
+void test_reftable_stack__transaction_api(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
- int err;
struct reftable_addition *add = NULL;
struct reftable_ref_record ref = {
@@ -267,37 +255,29 @@ static void t_reftable_stack_transaction_api(void)
};
struct reftable_ref_record dest = { 0 };
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
reftable_addition_destroy(add);
- err = reftable_stack_new_addition(&add, st, 0);
- check(!err);
-
- err = reftable_addition_add(add, write_test_ref, &ref);
- check(!err);
-
- err = reftable_addition_commit(add);
- check(!err);
+ cl_assert(reftable_stack_new_addition(&add, st, 0) == 0);
+ cl_assert(reftable_addition_add(add, write_test_ref, &ref) == 0);
+ cl_assert(reftable_addition_commit(add) == 0);
reftable_addition_destroy(add);
- err = reftable_stack_read_ref(st, ref.refname, &dest);
- check(!err);
- check_int(REFTABLE_REF_SYMREF, ==, dest.value_type);
- check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_stack_read_ref(st, ref.refname, &dest) == 0);
+ cl_assert_equal_i(REFTABLE_REF_SYMREF, dest.value_type);
+ cl_assert(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&dest);
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_transaction_with_reload(void)
+void test_reftable_stack__transaction_with_reload(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_stack *st1 = NULL, *st2 = NULL;
- int err;
struct reftable_addition *add = NULL;
struct reftable_ref_record refs[2] = {
{
@@ -315,17 +295,11 @@ static void t_reftable_stack_transaction_with_reload(void)
};
struct reftable_ref_record ref = { 0 };
- err = reftable_new_stack(&st1, dir, NULL);
- check(!err);
- err = reftable_new_stack(&st2, dir, NULL);
- check(!err);
-
- err = reftable_stack_new_addition(&add, st1, 0);
- check(!err);
- err = reftable_addition_add(add, write_test_ref, &refs[0]);
- check(!err);
- err = reftable_addition_commit(add);
- check(!err);
+ cl_assert(reftable_new_stack(&st1, dir, NULL) == 0);
+ cl_assert(reftable_new_stack(&st2, dir, NULL) == 0);
+ cl_assert(reftable_stack_new_addition(&add, st1, 0) == 0);
+ cl_assert(reftable_addition_add(add, write_test_ref, &refs[0]) == 0);
+ cl_assert(reftable_addition_commit(add) == 0);
reftable_addition_destroy(add);
/*
@@ -333,20 +307,18 @@ static void t_reftable_stack_transaction_with_reload(void)
* create the addition and lock the stack by default, but allow the
* reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set.
*/
- err = reftable_stack_new_addition(&add, st2, 0);
- check_int(err, ==, REFTABLE_OUTDATED_ERROR);
- err = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD);
- check(!err);
- err = reftable_addition_add(add, write_test_ref, &refs[1]);
- check(!err);
- err = reftable_addition_commit(add);
- check(!err);
+ cl_assert_equal_i(reftable_stack_new_addition(&add, st2, 0),
+ REFTABLE_OUTDATED_ERROR);
+ cl_assert(reftable_stack_new_addition(&add, st2,
+ REFTABLE_STACK_NEW_ADDITION_RELOAD) == 0);
+ cl_assert(reftable_addition_add(add, write_test_ref, &refs[1]) == 0);
+ cl_assert(reftable_addition_commit(add) == 0);
reftable_addition_destroy(add);
for (size_t i = 0; i < ARRAY_SIZE(refs); i++) {
- err = reftable_stack_read_ref(st2, refs[i].refname, &ref);
- check(!err);
- check(reftable_ref_record_equal(&refs[i], &ref, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_stack_read_ref(st2, refs[i].refname, &ref) == 0);
+ cl_assert(reftable_ref_record_equal(&refs[i], &ref,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
}
reftable_ref_record_release(&ref);
@@ -355,17 +327,15 @@ static void t_reftable_stack_transaction_with_reload(void)
clear_dir(dir);
}
-static void t_reftable_stack_transaction_api_performs_auto_compaction(void)
+void test_reftable_stack__transaction_api_performs_auto_compaction(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = {0};
struct reftable_addition *add = NULL;
struct reftable_stack *st = NULL;
size_t n = 20;
- int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
for (size_t i = 0; i <= n; i++) {
struct reftable_ref_record ref = {
@@ -385,14 +355,9 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)
*/
st->opts.disable_auto_compact = i != n;
- err = reftable_stack_new_addition(&add, st, 0);
- check(!err);
-
- err = reftable_addition_add(add, write_test_ref, &ref);
- check(!err);
-
- err = reftable_addition_commit(add);
- check(!err);
+ cl_assert(reftable_stack_new_addition(&add, st, 0) == 0);
+ cl_assert(reftable_addition_add(add, write_test_ref, &ref) == 0);
+ cl_assert(reftable_addition_commit(add) == 0);
reftable_addition_destroy(add);
@@ -402,16 +367,16 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)
* all tables in the stack.
*/
if (i != n)
- check_int(st->merged->tables_len, ==, i + 1);
+ cl_assert_equal_i(st->merged->tables_len, i + 1);
else
- check_int(st->merged->tables_len, ==, 1);
+ cl_assert_equal_i(st->merged->tables_len, 1);
}
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_auto_compaction_fails_gracefully(void)
+void test_reftable_stack__auto_compaction_fails_gracefully(void)
{
struct reftable_ref_record ref = {
.refname = (char *) "refs/heads/master",
@@ -425,32 +390,30 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
char *dir = get_tmp_dir(__LINE__);
int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
-
- err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
- check_int(st->merged->tables_len, ==, 1);
- check_int(st->stats.attempts, ==, 0);
- check_int(st->stats.failures, ==, 0);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
+ cl_assert_equal_i(st->merged->tables_len, 1);
+ cl_assert_equal_i(st->stats.attempts, 0);
+ cl_assert_equal_i(st->stats.failures, 0);
/*
* Lock the newly written table such that it cannot be compacted.
* Adding a new table to the stack should not be impacted by this, even
* though auto-compaction will now fail.
*/
- check(!reftable_buf_addstr(&table_path, dir));
- check(!reftable_buf_addstr(&table_path, "/"));
- check(!reftable_buf_addstr(&table_path, st->tables[0]->name));
- check(!reftable_buf_addstr(&table_path, ".lock"));
+ cl_assert(!reftable_buf_addstr(&table_path, dir));
+ cl_assert(!reftable_buf_addstr(&table_path, "/"));
+ cl_assert(!reftable_buf_addstr(&table_path,
+ st->tables[0]->name));
+ cl_assert(!reftable_buf_addstr(&table_path, ".lock"));
write_file_buf(table_path.buf, "", 0);
ref.update_index = 2;
err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
- check_int(st->merged->tables_len, ==, 2);
- check_int(st->stats.attempts, ==, 1);
- check_int(st->stats.failures, ==, 1);
+ cl_assert(!err);
+ cl_assert_equal_i(st->merged->tables_len, 2);
+ cl_assert_equal_i(st->stats.attempts, 1);
+ cl_assert_equal_i(st->stats.failures, 1);
reftable_stack_destroy(st);
reftable_buf_release(&table_path);
@@ -462,12 +425,11 @@ static int write_error(struct reftable_writer *wr UNUSED, void *arg)
return *((int *)arg);
}
-static void t_reftable_stack_update_index_check(void)
+void test_reftable_stack__update_index_check(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
- int err;
struct reftable_ref_record ref1 = {
.refname = (char *) "name1",
.update_index = 1,
@@ -481,39 +443,31 @@ static void t_reftable_stack_update_index_check(void)
.value.symref = (char *) "master",
};
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
-
- err = reftable_stack_add(st, write_test_ref, &ref1);
- check(!err);
-
- err = reftable_stack_add(st, write_test_ref, &ref2);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
+ cl_assert(reftable_stack_add(st, write_test_ref, &ref1) == 0);
+ cl_assert_equal_i(reftable_stack_add(st, write_test_ref,
+ &ref2), REFTABLE_API_ERROR);
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_lock_failure(void)
+void test_reftable_stack__lock_failure(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
- int err, i;
+ int i;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
- for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
- err = reftable_stack_add(st, write_error, &i);
- check_int(err, ==, i);
- }
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
+ for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--)
+ cl_assert_equal_i(reftable_stack_add(st, write_error, &i), i);
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_add(void)
+void test_reftable_stack__add(void)
{
- int err = 0;
struct reftable_write_options opts = {
.exact_log_message = 1,
.default_permissions = 0660,
@@ -526,9 +480,10 @@ static void t_reftable_stack_add(void)
struct reftable_buf path = REFTABLE_BUF_INIT;
struct stat stat_result;
size_t i, N = ARRAY_SIZE(refs);
+ int err;
err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(!err);
for (i = 0; i < N; i++) {
char buf[256];
@@ -536,66 +491,59 @@ static void t_reftable_stack_add(void)
refs[i].refname = xstrdup(buf);
refs[i].update_index = i + 1;
refs[i].value_type = REFTABLE_REF_VAL1;
- t_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);
logs[i].refname = xstrdup(buf);
logs[i].update_index = N + i + 1;
logs[i].value_type = REFTABLE_LOG_UPDATE;
logs[i].value.update.email = xstrdup("identity@invalid");
- t_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);
}
- for (i = 0; i < N; i++) {
- int err = reftable_stack_add(st, write_test_ref, &refs[i]);
- check(!err);
- }
+ for (i = 0; i < N; i++)
+ cl_assert(reftable_stack_add(st, write_test_ref, &refs[i]) == 0);
for (i = 0; i < N; i++) {
struct write_log_arg arg = {
.log = &logs[i],
.update_index = reftable_stack_next_update_index(st),
};
- int err = reftable_stack_add(st, write_test_log, &arg);
- check(!err);
+ cl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);
}
- err = reftable_stack_compact_all(st, NULL);
- check(!err);
+ cl_assert(reftable_stack_compact_all(st, NULL) == 0);
for (i = 0; i < N; i++) {
struct reftable_ref_record dest = { 0 };
- int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
- check(!err);
- check(reftable_ref_record_equal(&dest, refs + i,
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_stack_read_ref(st, refs[i].refname, &dest) == 0);
+ cl_assert(reftable_ref_record_equal(&dest, refs + i,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&dest);
}
for (i = 0; i < N; i++) {
struct reftable_log_record dest = { 0 };
- int err = reftable_stack_read_log(st, refs[i].refname, &dest);
- check(!err);
- check(reftable_log_record_equal(&dest, logs + i,
- REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_stack_read_log(st, refs[i].refname, &dest) == 0);
+ cl_assert(reftable_log_record_equal(&dest, logs + i,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_log_record_release(&dest);
}
#ifndef GIT_WINDOWS_NATIVE
- check(!reftable_buf_addstr(&path, dir));
- check(!reftable_buf_addstr(&path, "/tables.list"));
- err = stat(path.buf, &stat_result);
- check(!err);
- check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
+ cl_assert(reftable_buf_addstr(&path, dir) == 0);
+ cl_assert(reftable_buf_addstr(&path, "/tables.list") == 0);
+ cl_assert(stat(path.buf, &stat_result) == 0);
+ cl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);
reftable_buf_reset(&path);
- check(!reftable_buf_addstr(&path, dir));
- check(!reftable_buf_addstr(&path, "/"));
+ cl_assert(reftable_buf_addstr(&path, dir) == 0);
+ cl_assert(reftable_buf_addstr(&path, "/") == 0);
/* do not try at home; not an external API for reftable. */
- check(!reftable_buf_addstr(&path, st->tables[0]->name));
+ cl_assert(!reftable_buf_addstr(&path, st->tables[0]->name));
err = stat(path.buf, &stat_result);
- check(!err);
- check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
+ cl_assert(!err);
+ cl_assert_equal_i((stat_result.st_mode & 0777), opts.default_permissions);
#else
(void) stat_result;
#endif
@@ -610,7 +558,7 @@ static void t_reftable_stack_add(void)
clear_dir(dir);
}
-static void t_reftable_stack_iterator(void)
+void test_reftable_stack__iterator(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
@@ -621,27 +569,24 @@ static void t_reftable_stack_iterator(void)
size_t N = ARRAY_SIZE(refs), i;
int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
for (i = 0; i < N; i++) {
refs[i].refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);
refs[i].update_index = i + 1;
refs[i].value_type = REFTABLE_REF_VAL1;
- t_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1);
logs[i].refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);
logs[i].update_index = i + 1;
logs[i].value_type = REFTABLE_LOG_UPDATE;
logs[i].value.update.email = xstrdup("johndoe@invalid");
logs[i].value.update.message = xstrdup("commit\n");
- t_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);
+ cl_reftable_set_hash(logs[i].value.update.new_hash, i, REFTABLE_HASH_SHA1);
}
- for (i = 0; i < N; i++) {
- err = reftable_stack_add(st, write_test_ref, &refs[i]);
- check(!err);
- }
+ for (i = 0; i < N; i++)
+ cl_assert(reftable_stack_add(st, write_test_ref, &refs[i]) == 0);
for (i = 0; i < N; i++) {
struct write_log_arg arg = {
@@ -649,8 +594,7 @@ static void t_reftable_stack_iterator(void)
.update_index = reftable_stack_next_update_index(st),
};
- err = reftable_stack_add(st, write_test_log, &arg);
- check(!err);
+ cl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);
}
reftable_stack_init_ref_iterator(st, &it);
@@ -661,16 +605,16 @@ static void t_reftable_stack_iterator(void)
err = reftable_iterator_next_ref(&it, &ref);
if (err > 0)
break;
- check(!err);
- check(reftable_ref_record_equal(&ref, &refs[i], REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(err == 0);
+ cl_assert(reftable_ref_record_equal(&ref, &refs[i],
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&ref);
}
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
reftable_iterator_destroy(&it);
- err = reftable_stack_init_log_iterator(st, &it);
- check(!err);
+ cl_assert(reftable_stack_init_log_iterator(st, &it) == 0);
reftable_iterator_seek_log(&it, logs[0].refname);
for (i = 0; ; i++) {
@@ -679,11 +623,12 @@ static void t_reftable_stack_iterator(void)
err = reftable_iterator_next_log(&it, &log);
if (err > 0)
break;
- check(!err);
- check(reftable_log_record_equal(&log, &logs[i], REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(err == 0);
+ cl_assert(reftable_log_record_equal(&log, &logs[i],
+ REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_log_record_release(&log);
}
- check_int(i, ==, N);
+ cl_assert_equal_i(i, N);
reftable_stack_destroy(st);
reftable_iterator_destroy(&it);
@@ -694,9 +639,8 @@ static void t_reftable_stack_iterator(void)
clear_dir(dir);
}
-static void t_reftable_stack_log_normalize(void)
+void test_reftable_stack__log_normalize(void)
{
- int err = 0;
struct reftable_write_options opts = {
0,
};
@@ -721,28 +665,22 @@ static void t_reftable_stack_log_normalize(void)
.update_index = 1,
};
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
input.value.update.message = (char *) "one\ntwo";
- err = reftable_stack_add(st, write_test_log, &arg);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert_equal_i(reftable_stack_add(st, write_test_log,
+ &arg), REFTABLE_API_ERROR);
input.value.update.message = (char *) "one";
- err = reftable_stack_add(st, write_test_log, &arg);
- check(!err);
-
- err = reftable_stack_read_log(st, input.refname, &dest);
- check(!err);
- check_str(dest.value.update.message, "one\n");
+ cl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);
+ cl_assert(reftable_stack_read_log(st, input.refname, &dest) == 0);
+ cl_assert_equal_s(dest.value.update.message, "one\n");
input.value.update.message = (char *) "two\n";
arg.update_index = 2;
- err = reftable_stack_add(st, write_test_log, &arg);
- check(!err);
- err = reftable_stack_read_log(st, input.refname, &dest);
- check(!err);
- check_str(dest.value.update.message, "two\n");
+ cl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);
+ cl_assert(reftable_stack_read_log(st, input.refname, &dest) == 0);
+ cl_assert_equal_s(dest.value.update.message, "two\n");
/* cleanup */
reftable_stack_destroy(st);
@@ -750,20 +688,18 @@ static void t_reftable_stack_log_normalize(void)
clear_dir(dir);
}
-static void t_reftable_stack_tombstone(void)
+void test_reftable_stack__tombstone(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
- int err;
struct reftable_ref_record refs[2] = { 0 };
struct reftable_log_record logs[2] = { 0 };
size_t i, N = ARRAY_SIZE(refs);
struct reftable_ref_record dest = { 0 };
struct reftable_log_record log_dest = { 0 };
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
/* even entries add the refs, odd entries delete them. */
for (i = 0; i < N; i++) {
@@ -772,7 +708,7 @@ static void t_reftable_stack_tombstone(void)
refs[i].update_index = i + 1;
if (i % 2 == 0) {
refs[i].value_type = REFTABLE_REF_VAL1;
- t_reftable_set_hash(refs[i].value.val1, i,
+ cl_reftable_set_hash(refs[i].value.val1, i,
REFTABLE_HASH_SHA1);
}
@@ -785,42 +721,32 @@ static void t_reftable_stack_tombstone(void)
logs[i].update_index = 1;
if (i % 2 == 0) {
logs[i].value_type = REFTABLE_LOG_UPDATE;
- t_reftable_set_hash(logs[i].value.update.new_hash, i,
+ cl_reftable_set_hash(logs[i].value.update.new_hash, i,
REFTABLE_HASH_SHA1);
logs[i].value.update.email =
xstrdup("identity@invalid");
}
}
- for (i = 0; i < N; i++) {
- int err = reftable_stack_add(st, write_test_ref, &refs[i]);
- check(!err);
- }
+ for (i = 0; i < N; i++)
+ cl_assert(reftable_stack_add(st, write_test_ref, &refs[i]) == 0);
for (i = 0; i < N; i++) {
struct write_log_arg arg = {
.log = &logs[i],
.update_index = reftable_stack_next_update_index(st),
};
- int err = reftable_stack_add(st, write_test_log, &arg);
- check(!err);
+ cl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);
}
- err = reftable_stack_read_ref(st, "branch", &dest);
- check_int(err, ==, 1);
+ cl_assert_equal_i(reftable_stack_read_ref(st, "branch", &dest), 1);
reftable_ref_record_release(&dest);
- err = reftable_stack_read_log(st, "branch", &log_dest);
- check_int(err, ==, 1);
+ cl_assert_equal_i(reftable_stack_read_log(st, "branch", &log_dest), 1);
reftable_log_record_release(&log_dest);
- err = reftable_stack_compact_all(st, NULL);
- check(!err);
-
- err = reftable_stack_read_ref(st, "branch", &dest);
- check_int(err, ==, 1);
-
- err = reftable_stack_read_log(st, "branch", &log_dest);
- check_int(err, ==, 1);
+ cl_assert(reftable_stack_compact_all(st, NULL) == 0);
+ cl_assert_equal_i(reftable_stack_read_ref(st, "branch", &dest), 1);
+ cl_assert_equal_i(reftable_stack_read_log(st, "branch", &log_dest), 1);
reftable_ref_record_release(&dest);
reftable_log_record_release(&log_dest);
@@ -833,12 +759,11 @@ static void t_reftable_stack_tombstone(void)
clear_dir(dir);
}
-static void t_reftable_stack_hash_id(void)
+void test_reftable_stack__hash_id(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
- int err;
struct reftable_ref_record ref = {
.refname = (char *) "master",
@@ -852,62 +777,52 @@ static void t_reftable_stack_hash_id(void)
struct reftable_stack *st_default = NULL;
struct reftable_ref_record dest = { 0 };
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
-
- err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
/* can't read it with the wrong hash ID. */
- err = reftable_new_stack(&st32, dir, &opts32);
- check_int(err, ==, REFTABLE_FORMAT_ERROR);
+ cl_assert_equal_i(reftable_new_stack(&st32, dir, &opts32), REFTABLE_FORMAT_ERROR);
/* check that we can read it back with default opts too. */
- err = reftable_new_stack(&st_default, dir, &opts_default);
- check(!err);
-
- err = reftable_stack_read_ref(st_default, "master", &dest);
- check(!err);
-
- check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
+ cl_assert(reftable_new_stack(&st_default, dir, &opts_default) == 0);
+ cl_assert(reftable_stack_read_ref(st_default, "master", &dest) == 0);
+ cl_assert(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1) != 0);
reftable_ref_record_release(&dest);
reftable_stack_destroy(st);
reftable_stack_destroy(st_default);
clear_dir(dir);
}
-static void t_suggest_compaction_segment(void)
+void test_reftable_stack__suggest_compaction_segment(void)
{
uint64_t sizes[] = { 512, 64, 17, 16, 9, 9, 9, 16, 2, 16 };
struct segment min =
suggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);
- check_int(min.start, ==, 1);
- check_int(min.end, ==, 10);
+ cl_assert_equal_i(min.start, 1);
+ cl_assert_equal_i(min.end, 10);
}
-static void t_suggest_compaction_segment_nothing(void)
+void test_reftable_stack__suggest_compaction_segment_nothing(void)
{
uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
struct segment result =
suggest_compaction_segment(sizes, ARRAY_SIZE(sizes), 2);
- check_int(result.start, ==, result.end);
+ cl_assert_equal_i(result.start, result.end);
}
-static void t_reflog_expire(void)
+void test_reftable_stack__reflog_expire(void)
{
char *dir = get_tmp_dir(__LINE__);
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
struct reftable_log_record logs[20] = { 0 };
size_t i, N = ARRAY_SIZE(logs) - 1;
- int err;
struct reftable_log_expiry_config expiry = {
.time = 10,
};
struct reftable_log_record log = { 0 };
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
for (i = 1; i <= N; i++) {
char buf[256];
@@ -918,7 +833,7 @@ static void t_reflog_expire(void)
logs[i].value_type = REFTABLE_LOG_UPDATE;
logs[i].value.update.time = i;
logs[i].value.update.email = xstrdup("identity@invalid");
- t_reftable_set_hash(logs[i].value.update.new_hash, i,
+ cl_reftable_set_hash(logs[i].value.update.new_hash, i,
REFTABLE_HASH_SHA1);
}
@@ -927,31 +842,18 @@ static void t_reflog_expire(void)
.log = &logs[i],
.update_index = reftable_stack_next_update_index(st),
};
- int err = reftable_stack_add(st, write_test_log, &arg);
- check(!err);
+ cl_assert(reftable_stack_add(st, write_test_log, &arg) == 0);
}
- err = reftable_stack_compact_all(st, NULL);
- check(!err);
-
- err = reftable_stack_compact_all(st, &expiry);
- check(!err);
-
- err = reftable_stack_read_log(st, logs[9].refname, &log);
- check_int(err, ==, 1);
-
- err = reftable_stack_read_log(st, logs[11].refname, &log);
- check(!err);
+ cl_assert(reftable_stack_compact_all(st, NULL) == 0);
+ cl_assert(reftable_stack_compact_all(st, &expiry) == 0);
+ cl_assert_equal_i(reftable_stack_read_log(st, logs[9].refname, &log), 1);
+ cl_assert(reftable_stack_read_log(st, logs[11].refname, &log) == 0);
expiry.min_update_index = 15;
- err = reftable_stack_compact_all(st, &expiry);
- check(!err);
-
- err = reftable_stack_read_log(st, logs[14].refname, &log);
- check_int(err, ==, 1);
-
- err = reftable_stack_read_log(st, logs[16].refname, &log);
- check(!err);
+ cl_assert(reftable_stack_compact_all(st, &expiry) == 0);
+ cl_assert_equal_i(reftable_stack_read_log(st, logs[14].refname, &log), 1);
+ cl_assert(reftable_stack_read_log(st, logs[16].refname, &log) == 0);
/* cleanup */
reftable_stack_destroy(st);
@@ -963,26 +865,20 @@ static void t_reflog_expire(void)
static int write_nothing(struct reftable_writer *wr, void *arg UNUSED)
{
- check(!reftable_writer_set_limits(wr, 1, 1));
+ cl_assert(reftable_writer_set_limits(wr, 1, 1) == 0);
return 0;
}
-static void t_empty_add(void)
+void test_reftable_stack__empty_add(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
- int err;
char *dir = get_tmp_dir(__LINE__);
struct reftable_stack *st2 = NULL;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
-
- err = reftable_stack_add(st, write_nothing, NULL);
- check(!err);
-
- err = reftable_new_stack(&st2, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
+ cl_assert(reftable_stack_add(st, write_nothing, NULL) == 0);
+ cl_assert(reftable_new_stack(&st2, dir, &opts) == 0);
clear_dir(dir);
reftable_stack_destroy(st);
reftable_stack_destroy(st2);
@@ -998,18 +894,17 @@ static int fastlogN(uint64_t sz, uint64_t N)
return l - 1;
}
-static void t_reftable_stack_auto_compaction(void)
+void test_reftable_stack__auto_compaction(void)
{
struct reftable_write_options opts = {
.disable_auto_compact = 1,
};
struct reftable_stack *st = NULL;
char *dir = get_tmp_dir(__LINE__);
- int err;
size_t i, N = 100;
+ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
for (i = 0; i < N; i++) {
char name[100];
@@ -1022,32 +917,31 @@ static void t_reftable_stack_auto_compaction(void)
snprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
+ cl_assert(!err);
err = reftable_stack_auto_compact(st);
- check(!err);
- check(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
+ cl_assert(!err);
+ cl_assert(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
}
- check_int(reftable_stack_compaction_stats(st)->entries_written, <,
- (uint64_t)(N * fastlogN(N, 2)));
+ cl_assert(reftable_stack_compaction_stats(st)->entries_written <
+ (uint64_t)(N * fastlogN(N, 2)));
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_auto_compaction_factor(void)
+void test_reftable_stack__auto_compaction_factor(void)
{
struct reftable_write_options opts = {
.auto_compaction_factor = 5,
};
struct reftable_stack *st = NULL;
char *dir = get_tmp_dir(__LINE__);
- int err;
size_t N = 100;
+ int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
for (size_t i = 0; i < N; i++) {
char name[20];
@@ -1059,16 +953,16 @@ static void t_reftable_stack_auto_compaction_factor(void)
xsnprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
err = reftable_stack_add(st, &write_test_ref, &ref);
- check(!err);
+ cl_assert(!err);
- check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
+ cl_assert(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
}
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_auto_compaction_with_locked_tables(void)
+void test_reftable_stack__auto_compaction_with_locked_tables(void)
{
struct reftable_write_options opts = {
.disable_auto_compact = 1,
@@ -1078,21 +972,20 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
char *dir = get_tmp_dir(__LINE__);
int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
write_n_ref_tables(st, 5);
- check_int(st->merged->tables_len, ==, 5);
+ cl_assert_equal_i(st->merged->tables_len, 5);
/*
* Given that all tables we have written should be roughly the same
* size, we expect that auto-compaction will want to compact all of the
* tables. Locking any of the tables will keep it from doing so.
*/
- check(!reftable_buf_addstr(&buf, dir));
- check(!reftable_buf_addstr(&buf, "/"));
- check(!reftable_buf_addstr(&buf, st->tables[2]->name));
- check(!reftable_buf_addstr(&buf, ".lock"));
+ cl_assert(!reftable_buf_addstr(&buf, dir));
+ cl_assert(!reftable_buf_addstr(&buf, "/"));
+ cl_assert(!reftable_buf_addstr(&buf, st->tables[2]->name));
+ cl_assert(!reftable_buf_addstr(&buf, ".lock"));
write_file_buf(buf.buf, "", 0);
/*
@@ -1102,25 +995,23 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
* only compact the newest two tables.
*/
err = reftable_stack_auto_compact(st);
- check(!err);
- check_int(st->stats.failures, ==, 0);
- check_int(st->merged->tables_len, ==, 4);
+ cl_assert(!err);
+ cl_assert_equal_i(st->stats.failures, 0);
+ cl_assert_equal_i(st->merged->tables_len, 4);
reftable_stack_destroy(st);
reftable_buf_release(&buf);
clear_dir(dir);
}
-static void t_reftable_stack_add_performs_auto_compaction(void)
+void test_reftable_stack__add_performs_auto_compaction(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
char *dir = get_tmp_dir(__LINE__);
- int err;
size_t i, n = 20;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
for (i = 0; i <= n; i++) {
struct reftable_ref_record ref = {
@@ -1140,8 +1031,7 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
snprintf(buf, sizeof(buf), "branch-%04"PRIuMAX, (uintmax_t)i);
ref.refname = buf;
- err = reftable_stack_add(st, write_test_ref, &ref);
- check(!err);
+ cl_assert(reftable_stack_add(st, write_test_ref, &ref) == 0);
/*
* The stack length should grow continuously for all runs where
@@ -1149,16 +1039,16 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
* all tables in the stack.
*/
if (i != n)
- check_int(st->merged->tables_len, ==, i + 1);
+ cl_assert_equal_i(st->merged->tables_len, i + 1);
else
- check_int(st->merged->tables_len, ==, 1);
+ cl_assert_equal_i(st->merged->tables_len, 1);
}
reftable_stack_destroy(st);
clear_dir(dir);
}
-static void t_reftable_stack_compaction_with_locked_tables(void)
+void test_reftable_stack__compaction_with_locked_tables(void)
{
struct reftable_write_options opts = {
.disable_auto_compact = 1,
@@ -1168,17 +1058,16 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
char *dir = get_tmp_dir(__LINE__);
int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
write_n_ref_tables(st, 3);
- check_int(st->merged->tables_len, ==, 3);
+ cl_assert_equal_i(st->merged->tables_len, 3);
/* Lock one of the tables that we're about to compact. */
- check(!reftable_buf_addstr(&buf, dir));
- check(!reftable_buf_addstr(&buf, "/"));
- check(!reftable_buf_addstr(&buf, st->tables[1]->name));
- check(!reftable_buf_addstr(&buf, ".lock"));
+ cl_assert(!reftable_buf_addstr(&buf, dir));
+ cl_assert(!reftable_buf_addstr(&buf, "/"));
+ cl_assert(!reftable_buf_addstr(&buf, st->tables[1]->name));
+ cl_assert(!reftable_buf_addstr(&buf, ".lock"));
write_file_buf(buf.buf, "", 0);
/*
@@ -1186,36 +1075,31 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
* compact all tables.
*/
err = reftable_stack_compact_all(st, NULL);
- check_int(err, ==, REFTABLE_LOCK_ERROR);
- check_int(st->stats.failures, ==, 1);
- check_int(st->merged->tables_len, ==, 3);
+ cl_assert_equal_i(err, REFTABLE_LOCK_ERROR);
+ cl_assert_equal_i(st->stats.failures, 1);
+ cl_assert_equal_i(st->merged->tables_len, 3);
reftable_stack_destroy(st);
reftable_buf_release(&buf);
clear_dir(dir);
}
-static void t_reftable_stack_compaction_concurrent(void)
+void test_reftable_stack__compaction_concurrent(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL, *st2 = NULL;
char *dir = get_tmp_dir(__LINE__);
- int err;
- err = reftable_new_stack(&st1, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st1, dir, &opts) == 0);
write_n_ref_tables(st1, 3);
- err = reftable_new_stack(&st2, dir, &opts);
- check(!err);
-
- err = reftable_stack_compact_all(st1, NULL);
- check(!err);
+ cl_assert(reftable_new_stack(&st2, dir, &opts) == 0);
+ cl_assert(reftable_stack_compact_all(st1, NULL) == 0);
reftable_stack_destroy(st1);
reftable_stack_destroy(st2);
- check_int(count_dir_entries(dir), ==, 2);
+ cl_assert_equal_i(count_dir_entries(dir), 2);
clear_dir(dir);
}
@@ -1228,32 +1112,24 @@ static void unclean_stack_close(struct reftable_stack *st)
REFTABLE_FREE_AND_NULL(st->tables);
}
-static void t_reftable_stack_compaction_concurrent_clean(void)
+void test_reftable_stack__compaction_concurrent_clean(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
char *dir = get_tmp_dir(__LINE__);
- int err;
- err = reftable_new_stack(&st1, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st1, dir, &opts) == 0);
write_n_ref_tables(st1, 3);
- err = reftable_new_stack(&st2, dir, &opts);
- check(!err);
-
- err = reftable_stack_compact_all(st1, NULL);
- check(!err);
+ cl_assert(reftable_new_stack(&st2, dir, &opts) == 0);
+ cl_assert(reftable_stack_compact_all(st1, NULL) == 0);
unclean_stack_close(st1);
unclean_stack_close(st2);
- err = reftable_new_stack(&st3, dir, &opts);
- check(!err);
-
- err = reftable_stack_clean(st3);
- check(!err);
- check_int(count_dir_entries(dir), ==, 2);
+ cl_assert(reftable_new_stack(&st3, dir, &opts) == 0);
+ cl_assert(reftable_stack_clean(st3) == 0);
+ cl_assert_equal_i(count_dir_entries(dir), 2);
reftable_stack_destroy(st1);
reftable_stack_destroy(st2);
@@ -1262,7 +1138,7 @@ static void t_reftable_stack_compaction_concurrent_clean(void)
clear_dir(dir);
}
-static void t_reftable_stack_read_across_reload(void)
+void test_reftable_stack__read_across_reload(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st1 = NULL, *st2 = NULL;
@@ -1272,37 +1148,35 @@ static void t_reftable_stack_read_across_reload(void)
int err;
/* Create a first stack and set up an iterator for it. */
- err = reftable_new_stack(&st1, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st1, dir, &opts) == 0);
write_n_ref_tables(st1, 2);
- check_int(st1->merged->tables_len, ==, 2);
+ cl_assert_equal_i(st1->merged->tables_len, 2);
reftable_stack_init_ref_iterator(st1, &it);
- err = reftable_iterator_seek_ref(&it, "");
- check(!err);
+ cl_assert(reftable_iterator_seek_ref(&it, "") == 0);
/* Set up a second stack for the same directory and compact it. */
err = reftable_new_stack(&st2, dir, &opts);
- check(!err);
- check_int(st2->merged->tables_len, ==, 2);
+ cl_assert(!err);
+ cl_assert_equal_i(st2->merged->tables_len, 2);
err = reftable_stack_compact_all(st2, NULL);
- check(!err);
- check_int(st2->merged->tables_len, ==, 1);
+ cl_assert(!err);
+ cl_assert_equal_i(st2->merged->tables_len, 1);
/*
* Verify that we can continue to use the old iterator even after we
* have reloaded its stack.
*/
err = reftable_stack_reload(st1);
- check(!err);
- check_int(st1->merged->tables_len, ==, 1);
+ cl_assert(!err);
+ cl_assert_equal_i(st1->merged->tables_len, 1);
err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- check_str(rec.refname, "refs/heads/branch-0000");
+ cl_assert(!err);
+ cl_assert_equal_s(rec.refname, "refs/heads/branch-0000");
err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- check_str(rec.refname, "refs/heads/branch-0001");
+ cl_assert(!err);
+ cl_assert_equal_s(rec.refname, "refs/heads/branch-0001");
err = reftable_iterator_next_ref(&it, &rec);
- check_int(err, >, 0);
+ cl_assert(err > 0);
reftable_ref_record_release(&rec);
reftable_iterator_destroy(&it);
@@ -1311,7 +1185,7 @@ static void t_reftable_stack_read_across_reload(void)
clear_dir(dir);
}
-static void t_reftable_stack_reload_with_missing_table(void)
+void test_reftable_stack__reload_with_missing_table(void)
{
struct reftable_write_options opts = { 0 };
struct reftable_stack *st = NULL;
@@ -1322,46 +1196,40 @@ static void t_reftable_stack_reload_with_missing_table(void)
int err;
/* Create a first stack and set up an iterator for it. */
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
write_n_ref_tables(st, 2);
- check_int(st->merged->tables_len, ==, 2);
+ cl_assert_equal_i(st->merged->tables_len, 2);
reftable_stack_init_ref_iterator(st, &it);
- err = reftable_iterator_seek_ref(&it, "");
- check(!err);
+ cl_assert(reftable_iterator_seek_ref(&it, "") == 0);
/*
* Update the tables.list file with some garbage data, while reusing
* our old tables. This should trigger a partial reload of the stack,
* where we try to reuse our old tables.
*/
- check(!reftable_buf_addstr(&content, st->tables[0]->name));
- check(!reftable_buf_addstr(&content, "\n"));
- check(!reftable_buf_addstr(&content, st->tables[1]->name));
- check(!reftable_buf_addstr(&content, "\n"));
- check(!reftable_buf_addstr(&content, "garbage\n"));
- check(!reftable_buf_addstr(&table_path, st->list_file));
- check(!reftable_buf_addstr(&table_path, ".lock"));
+ cl_assert(!reftable_buf_addstr(&content, st->tables[0]->name));
+ cl_assert(!reftable_buf_addstr(&content, "\n"));
+ cl_assert(!reftable_buf_addstr(&content, st->tables[1]->name));
+ cl_assert(!reftable_buf_addstr(&content, "\n"));
+ cl_assert(!reftable_buf_addstr(&content, "garbage\n"));
+ cl_assert(!reftable_buf_addstr(&table_path, st->list_file));
+ cl_assert(!reftable_buf_addstr(&table_path, ".lock"));
write_file_buf(table_path.buf, content.buf, content.len);
- err = rename(table_path.buf, st->list_file);
- check(!err);
+ cl_assert(rename(table_path.buf, st->list_file) == 0);
err = reftable_stack_reload(st);
- check_int(err, ==, -4);
- check_int(st->merged->tables_len, ==, 2);
+ cl_assert_equal_i(err, -4);
+ cl_assert_equal_i(st->merged->tables_len, 2);
/*
* Even though the reload has failed, we should be able to continue
* using the iterator.
*/
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- check_str(rec.refname, "refs/heads/branch-0000");
- err = reftable_iterator_next_ref(&it, &rec);
- check(!err);
- check_str(rec.refname, "refs/heads/branch-0001");
- err = reftable_iterator_next_ref(&it, &rec);
- check_int(err, >, 0);
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_s(rec.refname, "refs/heads/branch-0000");
+ cl_assert(reftable_iterator_next_ref(&it, &rec) == 0);
+ cl_assert_equal_s(rec.refname, "refs/heads/branch-0001");
+ cl_assert(reftable_iterator_next_ref(&it, &rec) > 0);
reftable_ref_record_release(&rec);
reftable_iterator_destroy(&it);
@@ -1374,12 +1242,13 @@ static void t_reftable_stack_reload_with_missing_table(void)
static int write_limits_after_ref(struct reftable_writer *wr, void *arg)
{
struct reftable_ref_record *ref = arg;
- check(!reftable_writer_set_limits(wr, ref->update_index, ref->update_index));
- check(!reftable_writer_add_ref(wr, ref));
+ cl_assert(reftable_writer_set_limits(wr, ref->update_index,
+ ref->update_index) == 0);
+ cl_assert(reftable_writer_add_ref(wr, ref) == 0);
return reftable_writer_set_limits(wr, ref->update_index, ref->update_index);
}
-static void t_reftable_invalid_limit_updates(void)
+void test_reftable_stack__invalid_limit_updates(void)
{
struct reftable_ref_record ref = {
.refname = (char *) "HEAD",
@@ -1393,59 +1262,22 @@ static void t_reftable_invalid_limit_updates(void)
struct reftable_addition *add = NULL;
char *dir = get_tmp_dir(__LINE__);
struct reftable_stack *st = NULL;
- int err;
- err = reftable_new_stack(&st, dir, &opts);
- check(!err);
+ cl_assert(reftable_new_stack(&st, dir, &opts) == 0);
reftable_addition_destroy(add);
- err = reftable_stack_new_addition(&add, st, 0);
- check(!err);
+ cl_assert(reftable_stack_new_addition(&add, st, 0) == 0);
/*
* write_limits_after_ref also updates the update indexes after adding
* the record. This should cause an err to be returned, since the limits
* must be set at the start.
*/
- err = reftable_addition_add(add, write_limits_after_ref, &ref);
- check_int(err, ==, REFTABLE_API_ERROR);
+ cl_assert_equal_i(reftable_addition_add(add, write_limits_after_ref, &ref),
+ REFTABLE_API_ERROR);
reftable_addition_destroy(add);
reftable_stack_destroy(st);
clear_dir(dir);
}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_empty_add(), "empty addition to stack");
- TEST(t_read_file(), "read_lines works");
- TEST(t_reflog_expire(), "expire reflog entries");
- TEST(t_reftable_invalid_limit_updates(), "prevent limit updates after adding records");
- TEST(t_reftable_stack_add(), "add multiple refs and logs to stack");
- TEST(t_reftable_stack_add_one(), "add a single ref record to stack");
- TEST(t_reftable_stack_add_performs_auto_compaction(), "addition to stack triggers auto-compaction");
- TEST(t_reftable_stack_auto_compaction(), "stack must form geometric sequence after compaction");
- TEST(t_reftable_stack_auto_compaction_factor(), "auto-compaction with non-default geometric factor");
- TEST(t_reftable_stack_auto_compaction_fails_gracefully(), "failure on auto-compaction");
- TEST(t_reftable_stack_auto_compaction_with_locked_tables(), "auto compaction with locked tables");
- TEST(t_reftable_stack_compaction_concurrent(), "compaction with concurrent stack");
- TEST(t_reftable_stack_compaction_concurrent_clean(), "compaction with unclean stack shutdown");
- TEST(t_reftable_stack_compaction_with_locked_tables(), "compaction with locked tables");
- TEST(t_reftable_stack_hash_id(), "read stack with wrong hash ID");
- TEST(t_reftable_stack_iterator(), "log and ref iterator for reftable stack");
- TEST(t_reftable_stack_lock_failure(), "stack addition with lockfile failure");
- TEST(t_reftable_stack_log_normalize(), "log messages should be normalized");
- TEST(t_reftable_stack_read_across_reload(), "stack iterators work across reloads");
- TEST(t_reftable_stack_reload_with_missing_table(), "stack iteration with garbage tables");
- TEST(t_reftable_stack_tombstone(), "'tombstone' refs in stack");
- TEST(t_reftable_stack_transaction_api(), "update transaction to stack");
- TEST(t_reftable_stack_transaction_with_reload(), "transaction with reload");
- TEST(t_reftable_stack_transaction_api_performs_auto_compaction(), "update transaction triggers auto-compaction");
- TEST(t_reftable_stack_update_index_check(), "update transactions with equal update indices");
- TEST(t_reftable_stack_uptodate(), "stack must be reloaded before ref update");
- TEST(t_suggest_compaction_segment(), "suggest_compaction_segment with basic input");
- TEST(t_suggest_compaction_segment_nothing(), "suggest_compaction_segment with pre-compacted input");
-
- return test_done();
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (8 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 09/10] t/unit-tests: convert reftable stack " Seyi Kuforiji
@ 2025-06-02 12:25 ` Seyi Kuforiji
2025-06-03 13:51 ` Patrick Steinhardt
2025-06-03 18:41 ` [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Junio C Hamano
10 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-02 12:25 UTC (permalink / raw)
To: git; +Cc: ps, phillip.wood, Seyi Kuforiji
The old `lib-reftable.{c,h}` implemented helper functions for our
homegrown unit-testing framework. As part of migrating reftable-related
tests to the Clar framework, Clar-specific versions of these functions
in `lib-reftable-clar.{c,h}` were introduced.
Now that all test files using these helpers have been converted to Clar, we
can safely remove the original `lib-reftable.{c,h}` and rename the Clar-
specific versions back to `lib-reftable.{c,h}`. This restores a clean and
consistent naming scheme for shared test utilities.
Finally, update our build system to reflect the changes made and remove
redundant code related to the reftable tests and our old homegrown
unit-testing setup.
Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
---
Makefile | 6 +-
t/Makefile | 1 -
t/meson.build | 21 +-----
t/unit-tests/lib-reftable-clar.c | 101 ----------------------------
t/unit-tests/lib-reftable-clar.h | 20 ------
t/unit-tests/lib-reftable.c | 35 +++++-----
t/unit-tests/lib-reftable.h | 15 ++---
t/unit-tests/u-reftable-basics.c | 2 +-
t/unit-tests/u-reftable-block.c | 2 +-
t/unit-tests/u-reftable-merged.c | 2 +-
t/unit-tests/u-reftable-pq.c | 2 +-
t/unit-tests/u-reftable-readwrite.c | 2 +-
t/unit-tests/u-reftable-record.c | 2 +-
t/unit-tests/u-reftable-stack.c | 4 +-
t/unit-tests/u-reftable-table.c | 2 +-
15 files changed, 38 insertions(+), 179 deletions(-)
delete mode 100644 t/unit-tests/lib-reftable-clar.c
delete mode 100644 t/unit-tests/lib-reftable-clar.h
diff --git a/Makefile b/Makefile
index 8ed8f234f4..8d8f2d574d 100644
--- a/Makefile
+++ b/Makefile
@@ -1380,13 +1380,11 @@ CLAR_TEST_SUITES += u-urlmatch-normalization
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
-CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
+CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
-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-reftable.o
# xdiff and reftable libs may in turn depend on what is in libgit.a
GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)
diff --git a/t/Makefile b/t/Makefile
index 791e0a0978..757674e727 100644
--- a/t/Makefile
+++ b/t/Makefile
@@ -125,7 +125,6 @@ check-meson:
@mkdir -p mesontmp && \
printf "%s\n" \
"integration_tests t[0-9][0-9][0-9][0-9]-*.sh" \
- "unit_test_programs unit-tests/t-*.c" \
"clar_test_suites unit-tests/u-*.c" | \
while read -r variable pattern; do \
awk "/^$$variable = \[\$$/ {flag=1 ; next } /^]$$/ { flag=0 } flag { gsub(/^ \047/, \"\"); gsub(/\047,\$$/, \"\"); print }" meson.build >mesontmp/meson.txt && \
diff --git a/t/meson.build b/t/meson.build
index fcbb659263..be96a9639f 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -28,7 +28,7 @@ clar_sources = [
'unit-tests/clar/clar.c',
'unit-tests/unit-test.c',
'unit-tests/lib-oid.c',
- 'unit-tests/lib-reftable-clar.c'
+ 'unit-tests/lib-reftable.c'
]
clar_decls_h = custom_target(
@@ -62,25 +62,6 @@ clar_unit_tests = executable('unit-tests',
)
test('unit-tests', clar_unit_tests)
-unit_test_programs = [
-]
-
-foreach unit_test_program : unit_test_programs
- unit_test_name = fs.stem(unit_test_program)
- unit_test = executable(unit_test_name,
- sources: [
- 'unit-tests/test-lib.c',
- 'unit-tests/lib-reftable.c',
- unit_test_program,
- ],
- dependencies: [libgit_commonmain],
- )
- test(unit_test_name, unit_test,
- workdir: meson.current_source_dir(),
- timeout: 0,
- )
-endforeach
-
subdir('helper')
integration_tests = [
diff --git a/t/unit-tests/lib-reftable-clar.c b/t/unit-tests/lib-reftable-clar.c
deleted file mode 100644
index 64e40a106e..0000000000
--- a/t/unit-tests/lib-reftable-clar.c
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "unit-test.h"
-#include "lib-reftable-clar.h"
-#include "hex.h"
-#include "parse-options.h"
-#include "reftable/constants.h"
-#include "reftable/writer.h"
-#include "strbuf.h"
-#include "string-list.h"
-#include "strvec.h"
-
-void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)
-{
- memset(p, (uint8_t)i, hash_size(id));
-}
-
-static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)
-{
- strbuf_add(b, data, sz);
- return sz;
-}
-
-static int strbuf_writer_flush(void *arg UNUSED)
-{
- return 0;
-}
-
-struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
- struct reftable_write_options *opts)
-{
- struct reftable_writer *writer;
- int ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,
- buf, opts);
- cl_assert(!ret);
- return writer;
-}
-
-void cl_reftable_write_to_buf(struct reftable_buf *buf,
- struct reftable_ref_record *refs,
- size_t nrefs,
- struct reftable_log_record *logs,
- size_t nlogs,
- struct reftable_write_options *_opts)
-{
- struct reftable_write_options opts = { 0 };
- const struct reftable_stats *stats;
- struct reftable_writer *writer;
- uint64_t min = 0xffffffff;
- uint64_t max = 0;
- int ret;
-
- if (_opts)
- opts = *_opts;
-
- for (size_t i = 0; i < nrefs; i++) {
- uint64_t ui = refs[i].update_index;
- if (ui > max)
- max = ui;
- if (ui < min)
- min = ui;
- }
- for (size_t i = 0; i < nlogs; i++) {
- uint64_t ui = logs[i].update_index;
- if (ui > max)
- max = ui;
- if (ui < min)
- min = ui;
- }
-
- writer = cl_reftable_strbuf_writer(buf, &opts);
- ret = reftable_writer_set_limits(writer, min, max);
- cl_assert_equal_i(ret, 0);
-
- if (nrefs) {
- ret = reftable_writer_add_refs(writer, refs, nrefs);
- cl_assert_equal_i(ret, 0);
- }
-
- if (nlogs) {
- ret = reftable_writer_add_logs(writer, logs, nlogs);
- cl_assert_equal_i(ret, 0);
- }
-
- ret = reftable_writer_close(writer);
- cl_assert_equal_i(ret, 0);
-
- stats = reftable_writer_stats(writer);
- for (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {
- size_t off = i * (opts.block_size ? opts.block_size
- : DEFAULT_BLOCK_SIZE);
- if (!off)
- off = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);
- cl_assert(buf->buf[off] == 'r');
- }
-
- if (nrefs)
- cl_assert(stats->ref_stats.blocks > 0);
- if (nlogs)
- cl_assert(stats->log_stats.blocks > 0);
-
- reftable_writer_free(writer);
-}
diff --git a/t/unit-tests/lib-reftable-clar.h b/t/unit-tests/lib-reftable-clar.h
deleted file mode 100644
index b562648973..0000000000
--- a/t/unit-tests/lib-reftable-clar.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "git-compat-util.h"
-#include "clar/clar.h"
-#include "clar-decls.h"
-#include "git-compat-util.h"
-#include "reftable/reftable-writer.h"
-#include "strbuf.h"
-
-struct reftable_buf;
-
-void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);
-
-struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
- struct reftable_write_options *opts);
-
-void cl_reftable_write_to_buf(struct reftable_buf *buf,
- struct reftable_ref_record *refs,
- size_t nrecords,
- struct reftable_log_record *logs,
- size_t nlogs,
- struct reftable_write_options *opts);
diff --git a/t/unit-tests/lib-reftable.c b/t/unit-tests/lib-reftable.c
index 8a69612266..fdb5b11a20 100644
--- a/t/unit-tests/lib-reftable.c
+++ b/t/unit-tests/lib-reftable.c
@@ -1,12 +1,14 @@
-#define DISABLE_SIGN_COMPARE_WARNINGS
-
+#include "unit-test.h"
#include "lib-reftable.h"
-#include "test-lib.h"
+#include "hex.h"
+#include "parse-options.h"
#include "reftable/constants.h"
#include "reftable/writer.h"
#include "strbuf.h"
+#include "string-list.h"
+#include "strvec.h"
-void t_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)
+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id)
{
memset(p, (uint8_t)i, hash_size(id));
}
@@ -22,17 +24,17 @@ static int strbuf_writer_flush(void *arg UNUSED)
return 0;
}
-struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,
+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
struct reftable_write_options *opts)
{
struct reftable_writer *writer;
int ret = reftable_writer_new(&writer, &strbuf_writer_write, &strbuf_writer_flush,
buf, opts);
- check(!ret);
+ cl_assert(!ret);
return writer;
}
-void t_reftable_write_to_buf(struct reftable_buf *buf,
+void cl_reftable_write_to_buf(struct reftable_buf *buf,
struct reftable_ref_record *refs,
size_t nrefs,
struct reftable_log_record *logs,
@@ -64,35 +66,36 @@ void t_reftable_write_to_buf(struct reftable_buf *buf,
min = ui;
}
- writer = t_reftable_strbuf_writer(buf, &opts);
- reftable_writer_set_limits(writer, min, max);
+ writer = cl_reftable_strbuf_writer(buf, &opts);
+ ret = reftable_writer_set_limits(writer, min, max);
+ cl_assert(!ret);
if (nrefs) {
ret = reftable_writer_add_refs(writer, refs, nrefs);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
}
if (nlogs) {
ret = reftable_writer_add_logs(writer, logs, nlogs);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
}
ret = reftable_writer_close(writer);
- check_int(ret, ==, 0);
+ cl_assert_equal_i(ret, 0);
stats = reftable_writer_stats(writer);
- for (size_t i = 0; i < stats->ref_stats.blocks; i++) {
+ for (size_t i = 0; i < (size_t)stats->ref_stats.blocks; i++) {
size_t off = i * (opts.block_size ? opts.block_size
: DEFAULT_BLOCK_SIZE);
if (!off)
off = header_size(opts.hash_id == REFTABLE_HASH_SHA256 ? 2 : 1);
- check_char(buf->buf[off], ==, 'r');
+ cl_assert(buf->buf[off] == 'r');
}
if (nrefs)
- check_int(stats->ref_stats.blocks, >, 0);
+ cl_assert(stats->ref_stats.blocks > 0);
if (nlogs)
- check_int(stats->log_stats.blocks, >, 0);
+ cl_assert(stats->log_stats.blocks > 0);
reftable_writer_free(writer);
}
diff --git a/t/unit-tests/lib-reftable.h b/t/unit-tests/lib-reftable.h
index e4c360fa7e..d7e6d3136f 100644
--- a/t/unit-tests/lib-reftable.h
+++ b/t/unit-tests/lib-reftable.h
@@ -1,21 +1,20 @@
-#ifndef LIB_REFTABLE_H
-#define LIB_REFTABLE_H
-
+#include "git-compat-util.h"
+#include "clar/clar.h"
+#include "clar-decls.h"
#include "git-compat-util.h"
#include "reftable/reftable-writer.h"
+#include "strbuf.h"
struct reftable_buf;
-void t_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);
+void cl_reftable_set_hash(uint8_t *p, int i, enum reftable_hash id);
-struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,
+struct reftable_writer *cl_reftable_strbuf_writer(struct reftable_buf *buf,
struct reftable_write_options *opts);
-void t_reftable_write_to_buf(struct reftable_buf *buf,
+void cl_reftable_write_to_buf(struct reftable_buf *buf,
struct reftable_ref_record *refs,
size_t nrecords,
struct reftable_log_record *logs,
size_t nlogs,
struct reftable_write_options *opts);
-
-#endif
diff --git a/t/unit-tests/u-reftable-basics.c b/t/unit-tests/u-reftable-basics.c
index f105c22d15..a0471083e7 100644
--- a/t/unit-tests/u-reftable-basics.c
+++ b/t/unit-tests/u-reftable-basics.c
@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at
*/
#include "unit-test.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/basics.h"
struct integer_needle_lesseq_args {
diff --git a/t/unit-tests/u-reftable-block.c b/t/unit-tests/u-reftable-block.c
index 5d1419b801..bb0603464c 100644
--- a/t/unit-tests/u-reftable-block.c
+++ b/t/unit-tests/u-reftable-block.c
@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at
*/
#include "unit-test.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/block.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
diff --git a/t/unit-tests/u-reftable-merged.c b/t/unit-tests/u-reftable-merged.c
index e5b9dda4f4..656de01d6e 100644
--- a/t/unit-tests/u-reftable-merged.c
+++ b/t/unit-tests/u-reftable-merged.c
@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at
*/
#include "unit-test.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
#include "reftable/merged.h"
diff --git a/t/unit-tests/u-reftable-pq.c b/t/unit-tests/u-reftable-pq.c
index b3d64f55de..5526c55739 100644
--- a/t/unit-tests/u-reftable-pq.c
+++ b/t/unit-tests/u-reftable-pq.c
@@ -7,7 +7,7 @@ license that can be found in the LICENSE file or at
*/
#include "unit-test.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/constants.h"
#include "reftable/pq.h"
#include "strbuf.h"
diff --git a/t/unit-tests/u-reftable-readwrite.c b/t/unit-tests/u-reftable-readwrite.c
index f1c6a04429..d72b049a18 100644
--- a/t/unit-tests/u-reftable-readwrite.c
+++ b/t/unit-tests/u-reftable-readwrite.c
@@ -9,7 +9,7 @@ license that can be found in the LICENSE file or at
#define DISABLE_SIGN_COMPARE_WARNINGS
#include "unit-test.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/basics.h"
#include "reftable/blocksource.h"
#include "reftable/reftable-error.h"
diff --git a/t/unit-tests/u-reftable-record.c b/t/unit-tests/u-reftable-record.c
index 137a7ab815..e00e6e1881 100644
--- a/t/unit-tests/u-reftable-record.c
+++ b/t/unit-tests/u-reftable-record.c
@@ -7,7 +7,7 @@
*/
#include "unit-test.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/basics.h"
#include "reftable/constants.h"
#include "reftable/record.h"
diff --git a/t/unit-tests/u-reftable-stack.c b/t/unit-tests/u-reftable-stack.c
index 8d6cfba22c..60ceecbc72 100644
--- a/t/unit-tests/u-reftable-stack.c
+++ b/t/unit-tests/u-reftable-stack.c
@@ -10,7 +10,7 @@ license that can be found in the LICENSE file or at
#include "unit-test.h"
#include "dir.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/merged.h"
#include "reftable/reftable-error.h"
#include "reftable/stack.h"
@@ -480,7 +480,7 @@ void test_reftable_stack__add(void)
struct reftable_buf path = REFTABLE_BUF_INIT;
struct stat stat_result;
size_t i, N = ARRAY_SIZE(refs);
- int err;
+ int err = 0;
err = reftable_new_stack(&st, dir, &opts);
cl_assert(!err);
diff --git a/t/unit-tests/u-reftable-table.c b/t/unit-tests/u-reftable-table.c
index 25ea672e6a..5a00b4826e 100644
--- a/t/unit-tests/u-reftable-table.c
+++ b/t/unit-tests/u-reftable-table.c
@@ -1,5 +1,5 @@
#include "test-lib.h"
-#include "lib-reftable-clar.h"
+#include "lib-reftable.h"
#include "reftable/blocksource.h"
#include "reftable/constants.h"
#include "reftable/iter.h"
--
2.43.0
^ permalink raw reply related [flat|nested] 26+ messages in thread
* Re: [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions
2025-06-02 12:25 ` [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions Seyi Kuforiji
@ 2025-06-02 13:23 ` Kristoffer Haugsbakk
0 siblings, 0 replies; 26+ messages in thread
From: Kristoffer Haugsbakk @ 2025-06-02 13:23 UTC (permalink / raw)
To: Seyi Kuforiji, git; +Cc: Patrick Steinhardt, Phillip Wood
On Mon, Jun 2, 2025, at 14:25, Seyi Kuforiji wrote:
> Helper functions defined in `t/unit-tests/lib-reftable.{c,h}` are
> required for the reftable-related test files to run. In the current
> implementation these functions are designed to conform with our
> homegrown unit-testing structure. So in other to convert the reftable
nit: s/in other/in order/
> test files, there is need for a clar specific implementation of these
> helper functions.
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 06/10] t/unit-tests: convert reftable table test to use clar
2025-06-02 12:25 ` [PATCH v3 06/10] t/unit-tests: convert reftable table " Seyi Kuforiji
@ 2025-06-02 19:33 ` Junio C Hamano
2025-06-03 11:46 ` Seyi Kuforiji
2025-06-03 19:12 ` Junio C Hamano
0 siblings, 2 replies; 26+ messages in thread
From: Junio C Hamano @ 2025-06-02 19:33 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, ps, phillip.wood
Seyi Kuforiji <kuforiji98@gmail.com> writes:
> diff --git a/Makefile b/Makefile
> index 3cccc73073..0227fdb3e1 100644
> --- a/Makefile
> +++ b/Makefile
> ...
> @@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)
> $(OBJCOPY) --localize-hidden $^ $@
>
> contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)
> - $(AR) $(ARFLAGS) $@ $^
> + $(AR) $(ARFLAGS) $@ $^
> \ No newline at end of file
I'll fix this up before pushing this morning's integration result
out, but here is an occasion for a quick quiz.
Can anybody tell, without running "make <something>", what this
accidental and unintended change breaks? It may be rather
surprising ;-)
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 06/10] t/unit-tests: convert reftable table test to use clar
2025-06-02 19:33 ` Junio C Hamano
@ 2025-06-03 11:46 ` Seyi Kuforiji
2025-06-03 19:12 ` Junio C Hamano
1 sibling, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-03 11:46 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, ps, phillip.wood
On Mon, 2 Jun 2025 at 20:33, Junio C Hamano <gitster@pobox.com> wrote:
>
> Seyi Kuforiji <kuforiji98@gmail.com> writes:
>
> > diff --git a/Makefile b/Makefile
> > index 3cccc73073..0227fdb3e1 100644
> > --- a/Makefile
> > +++ b/Makefile
> > ...
> > @@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)
> > $(OBJCOPY) --localize-hidden $^ $@
> >
> > contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)
> > - $(AR) $(ARFLAGS) $@ $^
> > + $(AR) $(ARFLAGS) $@ $^
> > \ No newline at end of file
>
> I'll fix this up before pushing this morning's integration result
> out, but here is an occasion for a quick quiz.
>
> Can anybody tell, without running "make <something>", what this
> accidental and unintended change breaks? It may be rather
> surprising ;-)
>
>
Hi Junio,
I'm guessing this messes with the installation of dependencies, but
I'm not certain.
Thanks,
Seyi
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests
2025-06-02 12:25 ` [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests Seyi Kuforiji
@ 2025-06-03 13:51 ` Patrick Steinhardt
2025-06-05 12:56 ` Seyi Kuforiji
0 siblings, 1 reply; 26+ messages in thread
From: Patrick Steinhardt @ 2025-06-03 13:51 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, phillip.wood
On Mon, Jun 02, 2025 at 01:25:58PM +0100, Seyi Kuforiji wrote:
> diff --git a/Makefile b/Makefile
> index 8ed8f234f4..8d8f2d574d 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -1380,13 +1380,11 @@ CLAR_TEST_SUITES += u-urlmatch-normalization
> 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
> -CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
> +CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
> +CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
>
> -UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
> UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
Can't "test-lib.c" also be deleted now?
Patrick
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework
2025-06-02 12:25 ` [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework Seyi Kuforiji
@ 2025-06-03 13:51 ` Patrick Steinhardt
2025-06-03 14:03 ` Seyi Kuforiji
0 siblings, 1 reply; 26+ messages in thread
From: Patrick Steinhardt @ 2025-06-03 13:51 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, phillip.wood
On Mon, Jun 02, 2025 at 01:25:50PM +0100, Seyi Kuforiji wrote:
> Adapt reftable basics test file to clar by using clar assertions
> where necessary.Break up test edge case to improve modularity and
Nit: missing space.
> clarity.
>
> Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
> ---
> Makefile | 2 +-
> t/meson.build | 2 +-
> t/unit-tests/t-reftable-basics.c | 219 -----------------------------
> t/unit-tests/u-reftable-basics.c | 227 +++++++++++++++++++++++++++++++
> 4 files changed, 229 insertions(+), 221 deletions(-)
> delete mode 100644 t/unit-tests/t-reftable-basics.c
> create mode 100644 t/unit-tests/u-reftable-basics.c
Hm, these still show as deletion and addition :/ Did you try playing
around with the creation factor? What is the exact command that you have
used to generate these mails?
Patrick
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework
2025-06-03 13:51 ` Patrick Steinhardt
@ 2025-06-03 14:03 ` Seyi Kuforiji
2025-06-03 14:14 ` Patrick Steinhardt
0 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-03 14:03 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: git, phillip.wood
On Tue, 3 Jun 2025 at 14:51, Patrick Steinhardt <ps@pks.im> wrote:
>
> On Mon, Jun 02, 2025 at 01:25:50PM +0100, Seyi Kuforiji wrote:
> > Adapt reftable basics test file to clar by using clar assertions
> > where necessary.Break up test edge case to improve modularity and
>
> Nit: missing space.
>
> > clarity.
> >
> > Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
> > ---
> > Makefile | 2 +-
> > t/meson.build | 2 +-
> > t/unit-tests/t-reftable-basics.c | 219 -----------------------------
> > t/unit-tests/u-reftable-basics.c | 227 +++++++++++++++++++++++++++++++
> > 4 files changed, 229 insertions(+), 221 deletions(-)
> > delete mode 100644 t/unit-tests/t-reftable-basics.c
> > create mode 100644 t/unit-tests/u-reftable-basics.c
>
> Hm, these still show as deletion and addition :/ Did you try playing
> around with the creation factor? What is the exact command that you have
> used to generate these mails?
>
> Patrick
This was the only file that came out as a deletion and creation. Below
is the command I used:
`git format-patch -v3 --cover-letter --find-renames=20%
--range-diff=upstream/master..convert-reftable-clar-v2
upstream/master`
Thanks,
Seyi
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework
2025-06-03 14:03 ` Seyi Kuforiji
@ 2025-06-03 14:14 ` Patrick Steinhardt
0 siblings, 0 replies; 26+ messages in thread
From: Patrick Steinhardt @ 2025-06-03 14:14 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, phillip.wood
On Tue, Jun 03, 2025 at 03:03:45PM +0100, Seyi Kuforiji wrote:
> On Tue, 3 Jun 2025 at 14:51, Patrick Steinhardt <ps@pks.im> wrote:
> > On Mon, Jun 02, 2025 at 01:25:50PM +0100, Seyi Kuforiji wrote:
> > > Makefile | 2 +-
> > > t/meson.build | 2 +-
> > > t/unit-tests/t-reftable-basics.c | 219 -----------------------------
> > > t/unit-tests/u-reftable-basics.c | 227 +++++++++++++++++++++++++++++++
> > > 4 files changed, 229 insertions(+), 221 deletions(-)
> > > delete mode 100644 t/unit-tests/t-reftable-basics.c
> > > create mode 100644 t/unit-tests/u-reftable-basics.c
> >
> > Hm, these still show as deletion and addition :/ Did you try playing
> > around with the creation factor? What is the exact command that you have
> > used to generate these mails?
> >
> > Patrick
>
> This was the only file that came out as a deletion and creation. Below
> is the command I used:
>
> `git format-patch -v3 --cover-letter --find-renames=20%
> --range-diff=upstream/master..convert-reftable-clar-v2
> upstream/master`
Ah, true indeed. Never mind then, I think this is good enough :) Thanks!
Patrick
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 03/10] t/unit-tests: convert reftable block test to use clar
2025-06-02 12:25 ` [PATCH v3 03/10] t/unit-tests: convert reftable block test to use clar Seyi Kuforiji
@ 2025-06-03 14:18 ` Patrick Steinhardt
0 siblings, 0 replies; 26+ messages in thread
From: Patrick Steinhardt @ 2025-06-03 14:18 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, phillip.wood
On Mon, Jun 02, 2025 at 01:25:51PM +0100, Seyi Kuforiji wrote:
> diff --git a/t/unit-tests/t-reftable-block.c b/t/unit-tests/u-reftable-block.c
> similarity index 74%
> rename from t/unit-tests/t-reftable-block.c
> rename to t/unit-tests/u-reftable-block.c
> index 52f1dae1c9..5d1419b801 100644
> --- a/t/unit-tests/t-reftable-block.c
> +++ b/t/unit-tests/u-reftable-block.c
> @@ -6,14 +6,15 @@ license that can be found in the LICENSE file or at
> https://developers.google.com/open-source/licenses/bsd
> */
>
> -#include "test-lib.h"
> +#include "unit-test.h"
> +#include "lib-reftable-clar.h"
> #include "reftable/block.h"
> #include "reftable/blocksource.h"
> #include "reftable/constants.h"
> #include "reftable/reftable-error.h"
> #include "strbuf.h"
>
> -static void t_ref_block_read_write(void)
> +void test_reftable_block__index_read_write(void)
> {
> const int header_off = 21; /* random */
> struct reftable_record recs[30];
The name here still looks wrong to me. This is about writing ref blocks,
not index blocks.
> @@ -220,12 +222,12 @@ static void t_obj_block_read_write(void)
> struct reftable_buf block_data = REFTABLE_BUF_INIT;
>
> REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
> - check(block_data.buf != NULL);
> + cl_assert(block_data.buf != NULL);
> block_data.len = block_size;
>
> ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,
> header_off, hash_size(REFTABLE_HASH_SHA1));
> - check(!ret);
> + cl_assert(ret == 0);
All of these could be retained as `cl_assert(!ret)`, which is more
idiomatic in our codebase. Either that, or these should use
`cl_assert_equal_i()` to give better diagnostics.
Patrick
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
` (9 preceding siblings ...)
2025-06-02 12:25 ` [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests Seyi Kuforiji
@ 2025-06-03 18:41 ` Junio C Hamano
2025-06-04 10:09 ` Seyi Kuforiji
2025-06-04 10:09 ` Seyi Kuforiji
10 siblings, 2 replies; 26+ messages in thread
From: Junio C Hamano @ 2025-06-03 18:41 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, ps, phillip.wood
Seyi Kuforiji <kuforiji98@gmail.com> writes:
> This small patch series marks the final batch of our existing unit test
> files transitioned to the Clar testing framework. It covers all the
> reftable-related test files, and is part of our ongoing effort to
> standardize our testing framework to enhance its maintainability.
>
> Changes in v3:
> - some code refactoring based on review, which includes initial creation
> of reftable helper functions to
> t/unit-tests/lib-reftable-clar-test.{c,h} files in the initial commit
I guess this is no longer a "small patch series" ;-)
Are we done iterating, or will there be a small and final finishing
touch interation?
No need to rush, as we won't be merging things down to 'master'
until the 2.50 final gets tagged, but preparing a reasonably well
cooked topic in 'next' for the next cycle is always a good idea.
Thanks.
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 06/10] t/unit-tests: convert reftable table test to use clar
2025-06-02 19:33 ` Junio C Hamano
2025-06-03 11:46 ` Seyi Kuforiji
@ 2025-06-03 19:12 ` Junio C Hamano
1 sibling, 0 replies; 26+ messages in thread
From: Junio C Hamano @ 2025-06-03 19:12 UTC (permalink / raw)
To: git; +Cc: Seyi Kuforiji, ps, phillip.wood
Junio C Hamano <gitster@pobox.com> writes:
>> diff --git a/Makefile b/Makefile
>> index 3cccc73073..0227fdb3e1 100644
>> --- a/Makefile
>> +++ b/Makefile
>> ...
>> @@ -3972,4 +3972,4 @@ $(LIBGIT_HIDDEN_EXPORT): $(LIBGIT_PARTIAL_EXPORT)
>> $(OBJCOPY) --localize-hidden $^ $@
>>
>> contrib/libgit-sys/libgitpub.a: $(LIBGIT_HIDDEN_EXPORT)
>> - $(AR) $(ARFLAGS) $@ $^
>> + $(AR) $(ARFLAGS) $@ $^
>> \ No newline at end of file
>
> Can anybody tell, without running "make <something>", what this
> accidental and unintended change breaks? It may be rather
> surprising ;-)
After dropping the last newline from the top-level Makefile,
$ make check-docs
ends like this:
$ make check-docs
make -C Documentation lint-docs
make[1]: Entering directory '/home/gitster/git.git/Documentation'
GEN lint-docs-manpages
removed but documented: git
removed but documented: git-add
...
removed but documented: git-write-tree
removed but documented: scalar
removed but listed: git-add
removed but listed: git-am
...
removed but listed: git-write-tree
removed but listed: scalar
make[1]: *** [Makefile:504: lint-docs-manpages] Error 1
make[1]: Leaving directory '/home/gitster/git.git/Documentation'
make: *** [Makefile:3829: check-docs] Error 2
This is because of a cute Makefile trick used in lint-manpages
script is not written robustly enough, but that is not much less
interesting than the lesson we learn from this episode.
A more robust and traditional way to use the same Makefile trick is
to apply this patch to Documentation/lint-manpages.sh by the way.
Documentation/lint-manpages.sh | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git c/Documentation/lint-manpages.sh w/Documentation/lint-manpages.sh
index a0ea572382..65758a3159 100755
--- c/Documentation/lint-manpages.sh
+++ w/Documentation/lint-manpages.sh
@@ -2,11 +2,11 @@
extract_variable () {
(
- cat ../Makefile
cat <<EOF
print_variable:
@\$(foreach b,\$($1),echo XXX \$(b:\$X=) YYY;)
EOF
+ cat ../Makefile
) |
make -C .. -f - print_variable 2>/dev/null |
sed -n -e 's/.*XXX \(.*\) YYY.*/\1/p'
^ permalink raw reply related [flat|nested] 26+ messages in thread
* Re: [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar
2025-06-03 18:41 ` [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Junio C Hamano
@ 2025-06-04 10:09 ` Seyi Kuforiji
2025-06-04 10:09 ` Seyi Kuforiji
1 sibling, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-04 10:09 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, ps, phillip.wood
Hi Junio,
I'll make a v4 patch to clean up and finalize the series :)
Thanks
Seyi
On Tue, 3 Jun 2025 at 19:41, Junio C Hamano <gitster@pobox.com> wrote:
>
> Seyi Kuforiji <kuforiji98@gmail.com> writes:
>
> > This small patch series marks the final batch of our existing unit test
> > files transitioned to the Clar testing framework. It covers all the
> > reftable-related test files, and is part of our ongoing effort to
> > standardize our testing framework to enhance its maintainability.
> >
> > Changes in v3:
> > - some code refactoring based on review, which includes initial creation
> > of reftable helper functions to
> > t/unit-tests/lib-reftable-clar-test.{c,h} files in the initial commit
>
> I guess this is no longer a "small patch series" ;-)
>
> Are we done iterating, or will there be a small and final finishing
> touch interation?
>
> No need to rush, as we won't be merging things down to 'master'
> until the 2.50 final gets tagged, but preparing a reasonably well
> cooked topic in 'next' for the next cycle is always a good idea.
>
> Thanks.
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar
2025-06-03 18:41 ` [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Junio C Hamano
2025-06-04 10:09 ` Seyi Kuforiji
@ 2025-06-04 10:09 ` Seyi Kuforiji
1 sibling, 0 replies; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-04 10:09 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, ps, phillip.wood
On Tue, 3 Jun 2025 at 19:41, Junio C Hamano <gitster@pobox.com> wrote:
>
> Seyi Kuforiji <kuforiji98@gmail.com> writes:
>
> > This small patch series marks the final batch of our existing unit test
> > files transitioned to the Clar testing framework. It covers all the
> > reftable-related test files, and is part of our ongoing effort to
> > standardize our testing framework to enhance its maintainability.
> >
> > Changes in v3:
> > - some code refactoring based on review, which includes initial creation
> > of reftable helper functions to
> > t/unit-tests/lib-reftable-clar-test.{c,h} files in the initial commit
>
> I guess this is no longer a "small patch series" ;-)
>
> Are we done iterating, or will there be a small and final finishing
> touch interation?
>
> No need to rush, as we won't be merging things down to 'master'
> until the 2.50 final gets tagged, but preparing a reasonably well
> cooked topic in 'next' for the next cycle is always a good idea.
>
> Thanks.
Hi Junio,
I'll make a v4 patch to clean up and finalize the series :)
Thanks
Seyi
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests
2025-06-03 13:51 ` Patrick Steinhardt
@ 2025-06-05 12:56 ` Seyi Kuforiji
2025-06-05 13:24 ` Patrick Steinhardt
0 siblings, 1 reply; 26+ messages in thread
From: Seyi Kuforiji @ 2025-06-05 12:56 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: git, phillip.wood
On Tue, 3 Jun 2025 at 14:51, Patrick Steinhardt <ps@pks.im> wrote:
>
> On Mon, Jun 02, 2025 at 01:25:58PM +0100, Seyi Kuforiji wrote:
> > diff --git a/Makefile b/Makefile
> > index 8ed8f234f4..8d8f2d574d 100644
> > --- a/Makefile
> > +++ b/Makefile
> > @@ -1380,13 +1380,11 @@ CLAR_TEST_SUITES += u-urlmatch-normalization
> > 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
> > -CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
> > +CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
> > +CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
> >
> > -UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
> > UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
>
> Can't "test-lib.c" also be deleted now?
>
> Patrick
I don't think we can just yet, as `t/helper/test-example-tap` imports
the `test-lib.h.h` header file. Fixing that would be beyond the scope
of this patch series, don't you think?
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests
2025-06-05 12:56 ` Seyi Kuforiji
@ 2025-06-05 13:24 ` Patrick Steinhardt
2025-06-05 16:56 ` Junio C Hamano
0 siblings, 1 reply; 26+ messages in thread
From: Patrick Steinhardt @ 2025-06-05 13:24 UTC (permalink / raw)
To: Seyi Kuforiji; +Cc: git, phillip.wood
On Thu, Jun 05, 2025 at 01:56:43PM +0100, Seyi Kuforiji wrote:
> On Tue, 3 Jun 2025 at 14:51, Patrick Steinhardt <ps@pks.im> wrote:
> >
> > On Mon, Jun 02, 2025 at 01:25:58PM +0100, Seyi Kuforiji wrote:
> > > diff --git a/Makefile b/Makefile
> > > index 8ed8f234f4..8d8f2d574d 100644
> > > --- a/Makefile
> > > +++ b/Makefile
> > > @@ -1380,13 +1380,11 @@ CLAR_TEST_SUITES += u-urlmatch-normalization
> > > 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
> > > -CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
> > > +CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
> > > +CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
> > >
> > > -UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
> > > UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
> >
> > Can't "test-lib.c" also be deleted now?
> >
> > Patrick
>
> I don't think we can just yet, as `t/helper/test-example-tap` imports
> the `test-lib.h.h` header file. Fixing that would be beyond the scope
> of this patch series, don't you think?
Yup, agreed. It may be useful to point out this detail in the commit
message.
Patrick
^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests
2025-06-05 13:24 ` Patrick Steinhardt
@ 2025-06-05 16:56 ` Junio C Hamano
0 siblings, 0 replies; 26+ messages in thread
From: Junio C Hamano @ 2025-06-05 16:56 UTC (permalink / raw)
To: Patrick Steinhardt; +Cc: Seyi Kuforiji, git, phillip.wood
Patrick Steinhardt <ps@pks.im> writes:
>> I don't think we can just yet, as `t/helper/test-example-tap` imports
>> the `test-lib.h.h` header file. Fixing that would be beyond the scope
>> of this patch series, don't you think?
>
> Yup, agreed. It may be useful to point out this detail in the commit
> message.
Excellent suggestion.
Thanks.
^ permalink raw reply [flat|nested] 26+ messages in thread
end of thread, other threads:[~2025-06-05 16:56 UTC | newest]
Thread overview: 26+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-06-02 12:25 [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 01/10] t/unit-tests: implement clar specific reftable test helper functions Seyi Kuforiji
2025-06-02 13:23 ` Kristoffer Haugsbakk
2025-06-02 12:25 ` [PATCH v3 02/10] t/unit-tests: convert reftable basics test to use clar test framework Seyi Kuforiji
2025-06-03 13:51 ` Patrick Steinhardt
2025-06-03 14:03 ` Seyi Kuforiji
2025-06-03 14:14 ` Patrick Steinhardt
2025-06-02 12:25 ` [PATCH v3 03/10] t/unit-tests: convert reftable block test to use clar Seyi Kuforiji
2025-06-03 14:18 ` Patrick Steinhardt
2025-06-02 12:25 ` [PATCH v3 04/10] t/unit-tests: convert reftable merged " Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 05/10] t/unit-tests: convert reftable pq " Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 06/10] t/unit-tests: convert reftable table " Seyi Kuforiji
2025-06-02 19:33 ` Junio C Hamano
2025-06-03 11:46 ` Seyi Kuforiji
2025-06-03 19:12 ` Junio C Hamano
2025-06-02 12:25 ` [PATCH v3 07/10] t/unit-tests: convert reftable readwrite " Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 08/10] t/unit-tests: convert reftable record " Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 09/10] t/unit-tests: convert reftable stack " Seyi Kuforiji
2025-06-02 12:25 ` [PATCH v3 10/10] t/unit-tests: finalize migration of reftable-related tests Seyi Kuforiji
2025-06-03 13:51 ` Patrick Steinhardt
2025-06-05 12:56 ` Seyi Kuforiji
2025-06-05 13:24 ` Patrick Steinhardt
2025-06-05 16:56 ` Junio C Hamano
2025-06-03 18:41 ` [PATCH v3 00/10] t/unit-tests: convert unit-tests to use clar Junio C Hamano
2025-06-04 10:09 ` Seyi Kuforiji
2025-06-04 10:09 ` Seyi Kuforiji
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).