@matheusbsbs / matheus-bagliano / commits / a0aaa85c0c

t/unit-tests: convert reftable pq test to use clar

Adapt reftable priority queue test file to use clar by using clar assertions where necessary. Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Seyi Kuforiji committed Jul 24, 2025 at 15:28 UTC a0aaa85c0c70a0ace450351c525dcf3dcb2b0f20

3 files changed +30 -34

Makefile

+1 -1

@@ -1367,6 +1367,7 @@ CLAR_TEST_SUITES += u-prio-queue

1367 CLAR_TEST_SUITES += u-reftable-basics

1368 CLAR_TEST_SUITES += u-reftable-block

1369 CLAR_TEST_SUITES += u-reftable-merged

1370 +CLAR_TEST_SUITES += u-reftable-pq

1371 CLAR_TEST_SUITES += u-reftable-tree

1372 CLAR_TEST_SUITES += u-strbuf

1373 CLAR_TEST_SUITES += u-strcmp-offset

@@ -1380,7 +1381,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o

1381 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o

1382 CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o

1383

1383 -UNIT_TEST_PROGRAMS += t-reftable-pq

1384 UNIT_TEST_PROGRAMS += t-reftable-readwrite

1385 UNIT_TEST_PROGRAMS += t-reftable-record

1386 UNIT_TEST_PROGRAMS += t-reftable-stack

t/meson.build

+2 -1

@@ -11,6 +11,7 @@ clar_test_suites = [

11 'unit-tests/u-reftable-basics.c',

12 'unit-tests/u-reftable-block.c',

13 'unit-tests/u-reftable-merged.c',

14 + 'unit-tests/u-reftable-pq.c',

15 'unit-tests/u-reftable-tree.c',

16 'unit-tests/u-strbuf.c',

17 'unit-tests/u-strcmp-offset.c',

@@ -58,7 +59,7 @@ clar_unit_tests = executable('unit-tests',

59 test('unit-tests', clar_unit_tests)

61 unit_test_programs = [

61 - 'unit-tests/t-reftable-pq.c',

62 + 'unit-tests/t-reftable-reader.c',

63 'unit-tests/t-reftable-readwrite.c',

64 'unit-tests/t-reftable-record.c',

65 'unit-tests/t-reftable-stack.c',

t/unit-tests/u-reftable-pq.c renamed

+27 -32

@@ -6,7 +6,8 @@ license that can be found in the LICENSE file or at

6 https://developers.google.com/open-source/licenses/bsd

7 */

9 -#include "test-lib.h"

9 +#include "unit-test.h"

10 +#include "lib-reftable-clar.h"

11 #include "reftable/constants.h"

12 #include "reftable/pq.h"

13 #include "strbuf.h"

@@ -15,18 +16,18 @@ static void merged_iter_pqueue_check(const struct merged_iter_pqueue *pq)

16 {

17 for (size_t i = 1; i < pq->len; i++) {

18 size_t parent = (i - 1) / 2;

18 - check(pq_less(&pq->heap[parent], &pq->heap[i]));

19 + cl_assert(pq_less(&pq->heap[parent], &pq->heap[i]) != 0);

20 }

21 }

23 static int pq_entry_equal(struct pq_entry *a, struct pq_entry *b)

24 {

25 int cmp;

25 - check(!reftable_record_cmp(a->rec, b->rec, &cmp));

26 + cl_assert_equal_i(reftable_record_cmp(a->rec, b->rec, &cmp), 0);

27 return !cmp && (a->index == b->index);

28 }

29 -static void t_pq_record(void)

30 +void test_reftable_pq__record(void)

31 {

32 struct merged_iter_pqueue pq = { 0 };

33 struct reftable_record recs[54];

@@ -34,7 +35,8 @@ static void t_pq_record(void)

35 char *last = NULL;

37 for (i = 0; i < N; i++) {

37 - check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));

38 + cl_assert(!reftable_record_init(&recs[i],

39 + REFTABLE_BLOCK_TYPE_REF));

40 recs[i].u.ref.refname = xstrfmt("%02"PRIuMAX, (uintmax_t)i);

41 }

@@ -53,13 +55,13 @@ static void t_pq_record(void)

55 struct pq_entry top = merged_iter_pqueue_top(pq);

56 struct pq_entry e;

56 - check(!merged_iter_pqueue_remove(&pq, &e));

58 + cl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);

59 merged_iter_pqueue_check(&pq);

59 - check(pq_entry_equal(&top, &e));

60 - check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);

61 + cl_assert(pq_entry_equal(&top, &e));

62 + cl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);

63 if (last)

62 - check_int(strcmp(last, e.rec->u.ref.refname), <, 0);

64 + cl_assert(strcmp(last, e.rec->u.ref.refname) < 0);

65 last = e.rec->u.ref.refname;

66 }

@@ -68,7 +70,7 @@ static void t_pq_record(void)

70 merged_iter_pqueue_release(&pq);

71 }

71 -static void t_pq_index(void)

73 +void test_reftable_pq__index(void)

74 {

75 struct merged_iter_pqueue pq = { 0 };

76 struct reftable_record recs[13];

@@ -76,7 +78,8 @@ static void t_pq_index(void)

78 size_t N = ARRAY_SIZE(recs), i;

80 for (i = 0; i < N; i++) {

79 - check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));

81 + cl_assert(!reftable_record_init(&recs[i],

82 + REFTABLE_BLOCK_TYPE_REF));

83 recs[i].u.ref.refname = (char *) "refs/heads/master";

84 }

@@ -96,28 +99,29 @@ static void t_pq_index(void)

99 struct pq_entry top = merged_iter_pqueue_top(pq);

100 struct pq_entry e;

101

99 - check(!merged_iter_pqueue_remove(&pq, &e));

102 + cl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);

103 merged_iter_pqueue_check(&pq);

104

102 - check(pq_entry_equal(&top, &e));

103 - check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);

104 - check_int(e.index, ==, i);

105 + cl_assert(pq_entry_equal(&top, &e));

106 + cl_assert(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);

107 + cl_assert_equal_i(e.index, i);

108 if (last)

106 - check_str(last, e.rec->u.ref.refname);

109 + cl_assert_equal_s(last, e.rec->u.ref.refname);

110 last = e.rec->u.ref.refname;

111 }

112

113 merged_iter_pqueue_release(&pq);

114 }

115

113 -static void t_merged_iter_pqueue_top(void)

116 +void test_reftable_pq__merged_iter_pqueue_top(void)

117 {

118 struct merged_iter_pqueue pq = { 0 };

119 struct reftable_record recs[13];

120 size_t N = ARRAY_SIZE(recs), i;

121

122 for (i = 0; i < N; i++) {

120 - check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));

123 + cl_assert(!reftable_record_init(&recs[i],

124 + REFTABLE_BLOCK_TYPE_REF));

125 recs[i].u.ref.refname = (char *) "refs/heads/master";

126 }

127

@@ -137,25 +141,16 @@ static void t_merged_iter_pqueue_top(void)

141 struct pq_entry top = merged_iter_pqueue_top(pq);

142 struct pq_entry e;

143

140 - check(!merged_iter_pqueue_remove(&pq, &e));

144 + cl_assert_equal_i(merged_iter_pqueue_remove(&pq, &e), 0);

145

146 merged_iter_pqueue_check(&pq);

143 - check(pq_entry_equal(&top, &e));

144 - check(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1));

147 + cl_assert(pq_entry_equal(&top, &e) != 0);

148 + cl_assert(reftable_record_equal(top.rec, &recs[i], REFTABLE_HASH_SIZE_SHA1) != 0);

149 for (size_t j = 0; i < pq.len; j++) {

146 - check(pq_less(&top, &pq.heap[j]));

147 - check_int(top.index, >, j);

150 + cl_assert(pq_less(&top, &pq.heap[j]) != 0);

151 + cl_assert(top.index > j);

152 }

153 }

154

155 merged_iter_pqueue_release(&pq);

156 }

153 -

154 -int cmd_main(int argc UNUSED, const char *argv[] UNUSED)

155 -{

156 - TEST(t_pq_record(), "pq works with record-based comparison");

157 - TEST(t_pq_index(), "pq works with index-based comparison");

158 - TEST(t_merged_iter_pqueue_top(), "merged_iter_pqueue_top works");

159 -

160 - return test_done();

161 -}