t/unit-tests: convert reftable table test to use clar
Adapt reftable table 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
18a992b7b7f213deeede5aa923f13f6aee4e206e
3 files changed
+38
-44
Makefile
+1
-1
@@ -1368,6 +1368,7 @@ 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-table
1372
CLAR_TEST_SUITES += u-reftable-tree
1373
CLAR_TEST_SUITES += u-strbuf
1374
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1384,7 +1385,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
1385
UNIT_TEST_PROGRAMS += t-reftable-readwrite
1386
UNIT_TEST_PROGRAMS += t-reftable-record
1387
UNIT_TEST_PROGRAMS += t-reftable-stack
1387
-UNIT_TEST_PROGRAMS += t-reftable-table
1388
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
1389
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
1390
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
t/meson.build
+2
-3
@@ -12,6 +12,7 @@ clar_test_suites = [
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-table.c',
16
'unit-tests/u-reftable-tree.c',
17
'unit-tests/u-strbuf.c',
18
'unit-tests/u-strcmp-offset.c',
@@ -59,11 +60,9 @@ clar_unit_tests = executable('unit-tests',
60
test('unit-tests', clar_unit_tests)
61
62
unit_test_programs = [
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',
66
- 'unit-tests/t-reftable-table.c',
66
]
67
68
foreach unit_test_program : unit_test_programs
@@ -1233,4 +1232,4 @@ if perl.found() and time.found()
1232
timeout: 0,
1233
)
1234
endforeach
1236
-endif
1235
+endif
\ No newline at end of file
t/unit-tests/u-reftable-table.c
renamed
+35
-40
@@ -1,12 +1,12 @@
1
-#include "test-lib.h"
2
-#include "lib-reftable.h"
1
+#include "unit-test.h"
2
+#include "lib-reftable-clar.h"
3
#include "reftable/blocksource.h"
4
#include "reftable/constants.h"
5
#include "reftable/iter.h"
6
#include "reftable/table.h"
7
#include "strbuf.h"
8
9
-static int t_table_seek_once(void)
9
+void test_reftable_table__seek_once(void)
10
{
11
struct reftable_ref_record records[] = {
12
{
@@ -22,32 +22,32 @@ static int t_table_seek_once(void)
22
struct reftable_buf buf = REFTABLE_BUF_INIT;
23
int ret;
24
25
- t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
25
+ cl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
26
block_source_from_buf(&source, &buf);
27
28
ret = reftable_table_new(&table, &source, "name");
29
- check(!ret);
29
+ cl_assert(!ret);
30
31
reftable_table_init_ref_iterator(table, &it);
32
ret = reftable_iterator_seek_ref(&it, "");
33
- check(!ret);
33
+ cl_assert(!ret);
34
ret = reftable_iterator_next_ref(&it, &ref);
35
- check(!ret);
35
+ cl_assert(!ret);
36
37
- ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
38
- check_int(ret, ==, 1);
37
+ ret = reftable_ref_record_equal(&ref, &records[0],
38
+ REFTABLE_HASH_SIZE_SHA1);
39
+ cl_assert_equal_i(ret, 1);
40
41
ret = reftable_iterator_next_ref(&it, &ref);
41
- check_int(ret, ==, 1);
42
+ cl_assert_equal_i(ret, 1);
43
44
reftable_ref_record_release(&ref);
45
reftable_iterator_destroy(&it);
46
reftable_table_decref(table);
47
reftable_buf_release(&buf);
47
- return 0;
48
}
49
50
-static int t_table_reseek(void)
50
+void test_reftable_table__reseek(void)
51
{
52
struct reftable_ref_record records[] = {
53
{
@@ -63,35 +63,35 @@ static int t_table_reseek(void)
63
struct reftable_buf buf = REFTABLE_BUF_INIT;
64
int ret;
65
66
- t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
66
+ cl_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records),
67
+ NULL, 0, NULL);
68
block_source_from_buf(&source, &buf);
69
70
ret = reftable_table_new(&table, &source, "name");
70
- check(!ret);
71
+ cl_assert(!ret);
72
73
reftable_table_init_ref_iterator(table, &it);
74
75
for (size_t i = 0; i < 5; i++) {
76
ret = reftable_iterator_seek_ref(&it, "");
76
- check(!ret);
77
+ cl_assert(!ret);
78
ret = reftable_iterator_next_ref(&it, &ref);
78
- check(!ret);
79
+ cl_assert(!ret);
80
81
ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
81
- check_int(ret, ==, 1);
82
+ cl_assert_equal_i(ret, 1);
83
84
ret = reftable_iterator_next_ref(&it, &ref);
84
- check_int(ret, ==, 1);
85
+ cl_assert_equal_i(ret, 1);
86
}
87
88
reftable_ref_record_release(&ref);
89
reftable_iterator_destroy(&it);
90
reftable_table_decref(table);
91
reftable_buf_release(&buf);
91
- return 0;
92
}
93
94
-static int t_table_block_iterator(void)
94
+void test_reftable_table__block_iterator(void)
95
{
96
struct reftable_block_source source = { 0 };
97
struct reftable_table_iterator it = { 0 };
@@ -147,14 +147,14 @@ static int t_table_block_iterator(void)
147
(uintmax_t) i);
148
}
149
150
- t_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);
150
+ cl_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);
151
block_source_from_buf(&source, &buf);
152
153
ret = reftable_table_new(&table, &source, "name");
154
- check(!ret);
154
+ cl_assert(!ret);
155
156
ret = reftable_table_iterator_init(&it, table);
157
- check(!ret);
157
+ cl_assert(!ret);
158
159
for (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) {
160
struct reftable_iterator record_it = { 0 };
@@ -163,22 +163,26 @@ static int t_table_block_iterator(void)
163
};
164
165
ret = reftable_table_iterator_next(&it, &block);
166
- check(!ret);
166
+ cl_assert(!ret);
167
168
- check_int(block->block_type, ==, expected_blocks[i].block_type);
169
- check_int(block->header_off, ==, expected_blocks[i].header_off);
170
- check_int(block->restart_count, ==, expected_blocks[i].restart_count);
168
+ cl_assert_equal_i(block->block_type,
169
+ expected_blocks[i].block_type);
170
+ cl_assert_equal_i(block->header_off,
171
+ expected_blocks[i].header_off);
172
+ cl_assert_equal_i(block->restart_count,
173
+ expected_blocks[i].restart_count);
174
175
ret = reftable_block_init_iterator(block, &record_it);
173
- check(!ret);
176
+ cl_assert(!ret);
177
178
for (size_t j = 0; ; j++) {
179
ret = iterator_next(&record_it, &record);
180
if (ret > 0) {
178
- check_int(j, ==, expected_blocks[i].record_count);
181
+ cl_assert_equal_i(j,
182
+ expected_blocks[i].record_count);
183
break;
184
}
181
- check(!ret);
185
+ cl_assert(!ret);
186
}
187
188
reftable_iterator_destroy(&record_it);
@@ -186,7 +190,7 @@ static int t_table_block_iterator(void)
190
}
191
192
ret = reftable_table_iterator_next(&it, &block);
189
- check_int(ret, ==, 1);
193
+ cl_assert_equal_i(ret, 1);
194
195
for (size_t i = 0; i < nrecords; i++)
196
reftable_free(records[i].refname);
@@ -194,13 +198,4 @@ static int t_table_block_iterator(void)
198
reftable_table_decref(table);
199
reftable_buf_release(&buf);
200
reftable_free(records);
197
- return 0;
198
-}
199
-
200
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
201
-{
202
- TEST(t_table_seek_once(), "table can seek once");
203
- TEST(t_table_reseek(), "table can reseek multiple times");
204
- TEST(t_table_block_iterator(), "table can iterate through blocks");
205
- return test_done();
201
}