@matheusbsbs / matheus-bagliano / commits / 9cdfd1d7df

t: move reftable/merged_test.c to the unit testing framework

reftable/merged_test.c exercises the functions defined in reftable/merged.{c, h}. Migrate reftable/merged_test.c to the unit testing framework. Migration involves refactoring the tests to use the unit testing framework instead of reftable's test framework and renaming the tests according to unit-tests' naming conventions. Also, move strbuf_add_void() and noop_flush() from reftable/test_framework.c to the ported test. This is because both these functions are used in the merged tests and reftable/test_framework.{c, h} is not #included in the ported test. Mentored-by: Patrick Steinhardt <ps@pks.im> Mentored-by: Christian Couder <chriscool@tuxfamily.org> Signed-off-by: Chandra Pratap <chandrapratap3519@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Chandra Pratap committed Jul 12, 2024 at 11:08 UTC 9cdfd1d7df81f911e8c4f120f3aaf1b0d981e8a1

4 files changed +60 -57

Makefile

+1 -1

@@ -1340,6 +1340,7 @@ UNIT_TEST_PROGRAMS += t-mem-pool

1340 UNIT_TEST_PROGRAMS += t-oidtree

1341 UNIT_TEST_PROGRAMS += t-prio-queue

1342 UNIT_TEST_PROGRAMS += t-reftable-basics

1343 +UNIT_TEST_PROGRAMS += t-reftable-merged

1344 UNIT_TEST_PROGRAMS += t-strbuf

1345 UNIT_TEST_PROGRAMS += t-strcmp-offset

1346 UNIT_TEST_PROGRAMS += t-strvec

@@ -2679,7 +2680,6 @@ REFTABLE_OBJS += reftable/writer.o

2680

2681 REFTABLE_TEST_OBJS += reftable/block_test.o

2682 REFTABLE_TEST_OBJS += reftable/dump.o

2682 -REFTABLE_TEST_OBJS += reftable/merged_test.o

2683 REFTABLE_TEST_OBJS += reftable/pq_test.o

2684 REFTABLE_TEST_OBJS += reftable/record_test.o

2685 REFTABLE_TEST_OBJS += reftable/readwrite_test.o

reftable/reftable-tests.h

-1

@@ -11,7 +11,6 @@ https://developers.google.com/open-source/licenses/bsd

12 int basics_test_main(int argc, const char **argv);

13 int block_test_main(int argc, const char **argv);

14 -int merged_test_main(int argc, const char **argv);

14 int pq_test_main(int argc, const char **argv);

15 int record_test_main(int argc, const char **argv);

16 int readwrite_test_main(int argc, const char **argv);

t/helper/test-reftable.c

-1

@@ -10,7 +10,6 @@ int cmd__reftable(int argc, const char **argv)

10 tree_test_main(argc, argv);

11 pq_test_main(argc, argv);

12 readwrite_test_main(argc, argv);

13 - merged_test_main(argc, argv);

13 stack_test_main(argc, argv);

14 return 0;

15 }

t/unit-tests/t-reftable-merged.c renamed

+59 -54

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

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

7 */

9 -#include "merged.h"

10 -

11 -#include "system.h"

9 +#include "test-lib.h"

10 +#include "reftable/blocksource.h"

11 +#include "reftable/constants.h"

12 +#include "reftable/merged.h"

13 +#include "reftable/reader.h"

14 +#include "reftable/reftable-generic.h"

15 +#include "reftable/reftable-merged.h"

16 +#include "reftable/reftable-writer.h"

17 +

18 +static ssize_t strbuf_add_void(void *b, const void *data, size_t sz)

19 +{

20 + strbuf_add(b, data, sz);

21 + return sz;

22 +}

13 -#include "basics.h"

14 -#include "blocksource.h"

15 -#include "constants.h"

16 -#include "reader.h"

17 -#include "record.h"

18 -#include "test_framework.h"

19 -#include "reftable-merged.h"

20 -#include "reftable-tests.h"

21 -#include "reftable-generic.h"

22 -#include "reftable-writer.h"

24 +static int noop_flush(void *arg)

25 +{

26 + return 0;

27 +}

29 static void write_test_table(struct strbuf *buf,

30 struct reftable_ref_record refs[], int n)

@@ -49,12 +54,12 @@ static void write_test_table(struct strbuf *buf,

54 for (i = 0; i < n; i++) {

55 uint64_t before = refs[i].update_index;

56 int n = reftable_writer_add_ref(w, &refs[i]);

52 - EXPECT(n == 0);

53 - EXPECT(before == refs[i].update_index);

57 + check_int(n, ==, 0);

58 + check_int(before, ==, refs[i].update_index);

59 }

61 err = reftable_writer_close(w);

57 - EXPECT_ERR(err);

62 + check(!err);

64 reftable_writer_free(w);

65 }

@@ -76,11 +81,11 @@ static void write_test_log_table(struct strbuf *buf,

82 for (i = 0; i < n; i++) {

83 int err = reftable_writer_add_log(w, &logs[i]);

79 - EXPECT_ERR(err);

84 + check(!err);

85 }

87 err = reftable_writer_close(w);

83 - EXPECT_ERR(err);

88 + check(!err);

90 reftable_writer_free(w);

91 }

@@ -105,12 +110,12 @@ merged_table_from_records(struct reftable_ref_record **refs,

110

111 err = reftable_new_reader(&(*readers)[i], &(*source)[i],

112 "name");

108 - EXPECT_ERR(err);

113 + check(!err);

114 reftable_table_from_reader(&tabs[i], (*readers)[i]);

115 }

116

117 err = reftable_new_merged_table(&mt, tabs, n, GIT_SHA1_FORMAT_ID);

113 - EXPECT_ERR(err);

118 + check(!err);

119 return mt;

120 }

121

@@ -122,7 +127,7 @@ static void readers_destroy(struct reftable_reader **readers, size_t n)

127 reftable_free(readers);

128 }

129

125 -static void test_merged_between(void)

130 +static void t_merged_single_record(void)

131 {

132 struct reftable_ref_record r1[] = { {

133 .refname = (char *) "b",

@@ -150,11 +155,11 @@ static void test_merged_between(void)

155

156 merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);

157 err = reftable_iterator_seek_ref(&it, "a");

153 - EXPECT_ERR(err);

158 + check(!err);

159

160 err = reftable_iterator_next_ref(&it, &ref);

156 - EXPECT_ERR(err);

157 - EXPECT(ref.update_index == 2);

161 + check(!err);

162 + check_int(ref.update_index, ==, 2);

163 reftable_ref_record_release(&ref);

164 reftable_iterator_destroy(&it);

165 readers_destroy(readers, 2);

@@ -165,7 +170,7 @@ static void test_merged_between(void)

170 reftable_free(bs);

171 }

172

168 -static void test_merged(void)

173 +static void t_merged_refs(void)

174 {

175 struct reftable_ref_record r1[] = {

176 {

@@ -230,9 +235,9 @@ static void test_merged(void)

235

236 merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);

237 err = reftable_iterator_seek_ref(&it, "a");

233 - EXPECT_ERR(err);

234 - EXPECT(reftable_merged_table_hash_id(mt) == GIT_SHA1_FORMAT_ID);

235 - EXPECT(reftable_merged_table_min_update_index(mt) == 1);

238 + check(!err);

239 + check_int(reftable_merged_table_hash_id(mt), ==, GIT_SHA1_FORMAT_ID);

240 + check_int(reftable_merged_table_min_update_index(mt), ==, 1);

241

242 while (len < 100) { /* cap loops/recursion. */

243 struct reftable_ref_record ref = { NULL };

@@ -245,9 +250,9 @@ static void test_merged(void)

250 }

251 reftable_iterator_destroy(&it);

252

248 - EXPECT(ARRAY_SIZE(want) == len);

253 + check_int(ARRAY_SIZE(want), ==, len);

254 for (i = 0; i < len; i++) {

250 - EXPECT(reftable_ref_record_equal(want[i], &out[i],

255 + check(reftable_ref_record_equal(want[i], &out[i],

256 GIT_SHA1_RAWSZ));

257 }

258 for (i = 0; i < len; i++) {

@@ -283,16 +288,16 @@ merged_table_from_log_records(struct reftable_log_record **logs,

288

289 err = reftable_new_reader(&(*readers)[i], &(*source)[i],

290 "name");

286 - EXPECT_ERR(err);

291 + check(!err);

292 reftable_table_from_reader(&tabs[i], (*readers)[i]);

293 }

294

295 err = reftable_new_merged_table(&mt, tabs, n, GIT_SHA1_FORMAT_ID);

291 - EXPECT_ERR(err);

296 + check(!err);

297 return mt;

298 }

299

295 -static void test_merged_logs(void)

300 +static void t_merged_logs(void)

301 {

302 struct reftable_log_record r1[] = {

303 {

@@ -362,9 +367,9 @@ static void test_merged_logs(void)

367

368 merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);

369 err = reftable_iterator_seek_log(&it, "a");

365 - EXPECT_ERR(err);

366 - EXPECT(reftable_merged_table_hash_id(mt) == GIT_SHA1_FORMAT_ID);

367 - EXPECT(reftable_merged_table_min_update_index(mt) == 1);

370 + check(!err);

371 + check_int(reftable_merged_table_hash_id(mt), ==, GIT_SHA1_FORMAT_ID);

372 + check_int(reftable_merged_table_min_update_index(mt), ==, 1);

373

374 while (len < 100) { /* cap loops/recursion. */

375 struct reftable_log_record log = { NULL };

@@ -377,19 +382,19 @@ static void test_merged_logs(void)

382 }

383 reftable_iterator_destroy(&it);

384

380 - EXPECT(ARRAY_SIZE(want) == len);

385 + check_int(ARRAY_SIZE(want), ==, len);

386 for (i = 0; i < len; i++) {

382 - EXPECT(reftable_log_record_equal(want[i], &out[i],

387 + check(reftable_log_record_equal(want[i], &out[i],

388 GIT_SHA1_RAWSZ));

389 }

390

391 merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);

392 err = reftable_iterator_seek_log_at(&it, "a", 2);

388 - EXPECT_ERR(err);

393 + check(!err);

394 reftable_log_record_release(&out[0]);

395 err = reftable_iterator_next_log(&it, &out[0]);

391 - EXPECT_ERR(err);

392 - EXPECT(reftable_log_record_equal(&out[0], &r3[0], GIT_SHA1_RAWSZ));

396 + check(!err);

397 + check(reftable_log_record_equal(&out[0], &r3[0], GIT_SHA1_RAWSZ));

398 reftable_iterator_destroy(&it);

399

400 for (i = 0; i < len; i++) {

@@ -405,7 +410,7 @@ static void test_merged_logs(void)

410 reftable_free(bs);

411 }

412

408 -static void test_default_write_opts(void)

413 +static void t_default_write_opts(void)

414 {

415 struct reftable_write_options opts = { 0 };

416 struct strbuf buf = STRBUF_INIT;

@@ -426,36 +431,36 @@ static void test_default_write_opts(void)

431 reftable_writer_set_limits(w, 1, 1);

432

433 err = reftable_writer_add_ref(w, &rec);

429 - EXPECT_ERR(err);

434 + check(!err);

435

436 err = reftable_writer_close(w);

432 - EXPECT_ERR(err);

437 + check(!err);

438 reftable_writer_free(w);

439

440 block_source_from_strbuf(&source, &buf);

441

442 err = reftable_new_reader(&rd, &source, "filename");

438 - EXPECT_ERR(err);

443 + check(!err);

444

445 hash_id = reftable_reader_hash_id(rd);

441 - EXPECT(hash_id == GIT_SHA1_FORMAT_ID);

446 + check_int(hash_id, ==, GIT_SHA1_FORMAT_ID);

447

448 reftable_table_from_reader(&tab[0], rd);

449 err = reftable_new_merged_table(&merged, tab, 1, GIT_SHA1_FORMAT_ID);

445 - EXPECT_ERR(err);

450 + check(!err);

451

452 reftable_reader_free(rd);

453 reftable_merged_table_free(merged);

454 strbuf_release(&buf);

455 }

456

452 -/* XXX test refs_for(oid) */

457

454 -int merged_test_main(int argc, const char *argv[])

458 +int cmd_main(int argc, const char *argv[])

459 {

456 - RUN_TEST(test_merged_logs);

457 - RUN_TEST(test_merged_between);

458 - RUN_TEST(test_merged);

459 - RUN_TEST(test_default_write_opts);

460 - return 0;

460 + TEST(t_default_write_opts(), "merged table with default write opts");

461 + TEST(t_merged_logs(), "merged table with multiple log updates for same ref");

462 + TEST(t_merged_refs(), "merged table with multiple updates to same ref");

463 + TEST(t_merged_single_record(), "ref ocurring in only one record can be fetched");

464 +

465 + return test_done();

466 }