@matheusbsbs / matheus-bagliano / commits / e8ed7d1974

t: harmonize t-reftable-merged.c with coding guidelines

Harmonize the newly ported test unit-tests/t-reftable-merged.c with the following guidelines: - Single line control flow statements like 'for' and 'if' must omit curly braces. - Structs must be 0-initialized with '= { 0 }' instead of '= { NULL }'. - Array indices should preferably be of type 'size_t', not 'int'. - It is fine to use C99 initial declaration in 'for' loop. While at it, use 'ARRAY_SIZE(x)' to store the number of elements in an array instead of hardcoding them. 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 e8ed7d1974af3d38e7c6f2ad07fd4ea49ae29474

1 file changed +28 -40

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

+28 -40

@@ -27,11 +27,11 @@ static int noop_flush(void *arg)

27 }

29 static void write_test_table(struct strbuf *buf,

30 - struct reftable_ref_record refs[], int n)

30 + struct reftable_ref_record refs[], size_t n)

31 {

32 uint64_t min = 0xffffffff;

33 uint64_t max = 0;

34 - int i = 0;

34 + size_t i;

35 int err;

37 struct reftable_write_options opts = {

@@ -40,12 +40,10 @@ static void write_test_table(struct strbuf *buf,

40 struct reftable_writer *w = NULL;

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

42 uint64_t ui = refs[i].update_index;

43 - if (ui > max) {

43 + if (ui > max)

44 max = ui;

45 - }

46 - if (ui < min) {

45 + if (ui < min)

46 min = ui;

48 - }

47 }

49 w = reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);

@@ -65,10 +63,9 @@ static void write_test_table(struct strbuf *buf,

63 }

65 static void write_test_log_table(struct strbuf *buf,

68 - struct reftable_log_record logs[], int n,

66 + struct reftable_log_record logs[], size_t n,

67 uint64_t update_index)

68 {

71 - int i = 0;

69 int err;

71 struct reftable_write_options opts = {

@@ -79,7 +76,7 @@ static void write_test_log_table(struct strbuf *buf,

76 w = reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);

77 reftable_writer_set_limits(w, update_index, update_index);

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

79 + for (size_t i = 0; i < n; i++) {

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

81 check(!err);

82 }

@@ -93,7 +90,7 @@ static void write_test_log_table(struct strbuf *buf,

90 static struct reftable_merged_table *

91 merged_table_from_records(struct reftable_ref_record **refs,

92 struct reftable_block_source **source,

96 - struct reftable_reader ***readers, int *sizes,

93 + struct reftable_reader ***readers, size_t *sizes,

94 struct strbuf *buf, size_t n)

95 {

96 struct reftable_merged_table *mt = NULL;

@@ -121,8 +118,7 @@ merged_table_from_records(struct reftable_ref_record **refs,

118

119 static void readers_destroy(struct reftable_reader **readers, size_t n)

120 {

124 - int i = 0;

125 - for (; i < n; i++)

121 + for (size_t i = 0; i < n; i++)

122 reftable_reader_free(readers[i]);

123 reftable_free(readers);

124 }

@@ -142,15 +138,14 @@ static void t_merged_single_record(void)

138 } };

139

140 struct reftable_ref_record *refs[] = { r1, r2 };

145 - int sizes[] = { 1, 1 };

141 + size_t sizes[] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2) };

142 struct strbuf bufs[2] = { STRBUF_INIT, STRBUF_INIT };

143 struct reftable_block_source *bs = NULL;

144 struct reftable_reader **readers = NULL;

145 struct reftable_merged_table *mt =

146 merged_table_from_records(refs, &bs, &readers, sizes, bufs, 2);

151 - int i;

152 - struct reftable_ref_record ref = { NULL };

153 - struct reftable_iterator it = { NULL };

147 + struct reftable_ref_record ref = { 0 };

148 + struct reftable_iterator it = { 0 };

149 int err;

150

151 merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);

@@ -164,9 +159,8 @@ static void t_merged_single_record(void)

159 reftable_iterator_destroy(&it);

160 readers_destroy(readers, 2);

161 reftable_merged_table_free(mt);

167 - for (i = 0; i < ARRAY_SIZE(bufs); i++) {

162 + for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)

163 strbuf_release(&bufs[i]);

169 - }

164 reftable_free(bs);

165 }

166

@@ -220,18 +214,18 @@ static void t_merged_refs(void)

214 };

215

216 struct reftable_ref_record *refs[] = { r1, r2, r3 };

223 - int sizes[3] = { 3, 1, 2 };

217 + size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };

218 struct strbuf bufs[3] = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };

219 struct reftable_block_source *bs = NULL;

220 struct reftable_reader **readers = NULL;

221 struct reftable_merged_table *mt =

222 merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);

229 - struct reftable_iterator it = { NULL };

223 + struct reftable_iterator it = { 0 };

224 int err;

225 struct reftable_ref_record *out = NULL;

226 size_t len = 0;

227 size_t cap = 0;

234 - int i = 0;

228 + size_t i;

229

230 merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);

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

@@ -240,7 +234,7 @@ static void t_merged_refs(void)

234 check_int(reftable_merged_table_min_update_index(mt), ==, 1);

235

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

243 - struct reftable_ref_record ref = { NULL };

237 + struct reftable_ref_record ref = { 0 };

238 int err = reftable_iterator_next_ref(&it, &ref);

239 if (err > 0)

240 break;

@@ -251,18 +245,15 @@ static void t_merged_refs(void)

245 reftable_iterator_destroy(&it);

246

247 check_int(ARRAY_SIZE(want), ==, len);

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

248 + for (i = 0; i < len; i++)

249 check(reftable_ref_record_equal(want[i], &out[i],

250 GIT_SHA1_RAWSZ));

257 - }

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

251 + for (i = 0; i < len; i++)

252 reftable_ref_record_release(&out[i]);

260 - }

253 reftable_free(out);

254

263 - for (i = 0; i < 3; i++) {

255 + for (i = 0; i < 3; i++)

256 strbuf_release(&bufs[i]);

265 - }

257 readers_destroy(readers, 3);

258 reftable_merged_table_free(mt);

259 reftable_free(bs);

@@ -271,7 +262,7 @@ static void t_merged_refs(void)

262 static struct reftable_merged_table *

263 merged_table_from_log_records(struct reftable_log_record **logs,

264 struct reftable_block_source **source,

274 - struct reftable_reader ***readers, int *sizes,

265 + struct reftable_reader ***readers, size_t *sizes,

266 struct strbuf *buf, size_t n)

267 {

268 struct reftable_merged_table *mt = NULL;

@@ -352,18 +343,18 @@ static void t_merged_logs(void)

343 };

344

345 struct reftable_log_record *logs[] = { r1, r2, r3 };

355 - int sizes[3] = { 2, 1, 1 };

346 + size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };

347 struct strbuf bufs[3] = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };

348 struct reftable_block_source *bs = NULL;

349 struct reftable_reader **readers = NULL;

350 struct reftable_merged_table *mt = merged_table_from_log_records(

351 logs, &bs, &readers, sizes, bufs, 3);

361 - struct reftable_iterator it = { NULL };

352 + struct reftable_iterator it = { 0 };

353 int err;

354 struct reftable_log_record *out = NULL;

355 size_t len = 0;

356 size_t cap = 0;

366 - int i = 0;

357 + size_t i;

358

359 merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);

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

@@ -372,7 +363,7 @@ static void t_merged_logs(void)

363 check_int(reftable_merged_table_min_update_index(mt), ==, 1);

364

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

375 - struct reftable_log_record log = { NULL };

366 + struct reftable_log_record log = { 0 };

367 int err = reftable_iterator_next_log(&it, &log);

368 if (err > 0)

369 break;

@@ -383,10 +374,9 @@ static void t_merged_logs(void)

374 reftable_iterator_destroy(&it);

375

376 check_int(ARRAY_SIZE(want), ==, len);

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

377 + for (i = 0; i < len; i++)

378 check(reftable_log_record_equal(want[i], &out[i],

379 GIT_SHA1_RAWSZ));

389 - }

380

381 merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);

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

@@ -397,14 +387,12 @@ static void t_merged_logs(void)

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

388 reftable_iterator_destroy(&it);

389

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

390 + for (i = 0; i < len; i++)

391 reftable_log_record_release(&out[i]);

402 - }

392 reftable_free(out);

393

405 - for (i = 0; i < 3; i++) {

394 + for (i = 0; i < 3; i++)

395 strbuf_release(&bufs[i]);

407 - }

396 readers_destroy(readers, 3);

397 reftable_merged_table_free(mt);

398 reftable_free(bs);

@@ -422,7 +410,7 @@ static void t_default_write_opts(void)

410 .update_index = 1,

411 };

412 int err;

425 - struct reftable_block_source source = { NULL };

413 + struct reftable_block_source source = { 0 };

414 struct reftable_table *tab = reftable_calloc(1, sizeof(*tab));

415 uint32_t hash_id;

416 struct reftable_reader *rd = NULL;