t/unit-tests: introduce reftable library
We have recently migrated all of the reftable unit tests that were part of the reftable library into our own unit testing framework. As part of that migration we have duplicated some of the functionality that was part of the reftable test framework into each of the migrated test suites. This was a sensible decision to not have all of the migrations dependent on each other, but now that the migration is done it makes sense to deduplicate the functionality again. Introduce a new reftable test library that hosts some shared code and adapt tests to use it. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
Patrick Steinhardt committed
Sep 16, 2024 at 10:50 UTC
a4f50bb1e9b6840bb4583ac4bc6d93bea9704879
6 files changed
+177
-179
Makefile
+1
@@ -1358,6 +1358,7 @@ UNIT_TEST_PROGRAMS += t-urlmatch-normalization
1358
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
1359
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
1360
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
1361
+UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
1362
1363
# xdiff and reftable libs may in turn depend on what is in libgit.a
1364
GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) $(REFTABLE_LIB) $(LIB_FILE)
t/unit-tests/lib-reftable.c
new
+93
@@ -0,0 +1,93 @@
1
+#include "lib-reftable.h"
2
+#include "test-lib.h"
3
+#include "reftable/constants.h"
4
+#include "reftable/writer.h"
5
+
6
+void t_reftable_set_hash(uint8_t *p, int i, uint32_t id)
7
+{
8
+ memset(p, (uint8_t)i, hash_size(id));
9
+}
10
+
11
+static ssize_t strbuf_writer_write(void *b, const void *data, size_t sz)
12
+{
13
+ strbuf_add(b, data, sz);
14
+ return sz;
15
+}
16
+
17
+static int strbuf_writer_flush(void *arg UNUSED)
18
+{
19
+ return 0;
20
+}
21
+
22
+struct reftable_writer *t_reftable_strbuf_writer(struct strbuf *buf,
23
+ struct reftable_write_options *opts)
24
+{
25
+ return reftable_new_writer(&strbuf_writer_write,
26
+ &strbuf_writer_flush,
27
+ buf, opts);
28
+}
29
+
30
+void t_reftable_write_to_buf(struct strbuf *buf,
31
+ struct reftable_ref_record *refs,
32
+ size_t nrefs,
33
+ struct reftable_log_record *logs,
34
+ size_t nlogs,
35
+ struct reftable_write_options *_opts)
36
+{
37
+ struct reftable_write_options opts = { 0 };
38
+ const struct reftable_stats *stats;
39
+ struct reftable_writer *writer;
40
+ uint64_t min = 0xffffffff;
41
+ uint64_t max = 0;
42
+ int ret;
43
+
44
+ if (_opts)
45
+ opts = *_opts;
46
+
47
+ for (size_t i = 0; i < nrefs; i++) {
48
+ uint64_t ui = refs[i].update_index;
49
+ if (ui > max)
50
+ max = ui;
51
+ if (ui < min)
52
+ min = ui;
53
+ }
54
+ for (size_t i = 0; i < nlogs; i++) {
55
+ uint64_t ui = logs[i].update_index;
56
+ if (ui > max)
57
+ max = ui;
58
+ if (ui < min)
59
+ min = ui;
60
+ }
61
+
62
+ writer = t_reftable_strbuf_writer(buf, &opts);
63
+ reftable_writer_set_limits(writer, min, max);
64
+
65
+ if (nrefs) {
66
+ ret = reftable_writer_add_refs(writer, refs, nrefs);
67
+ check_int(ret, ==, 0);
68
+ }
69
+
70
+ if (nlogs) {
71
+ ret = reftable_writer_add_logs(writer, logs, nlogs);
72
+ check_int(ret, ==, 0);
73
+ }
74
+
75
+ ret = reftable_writer_close(writer);
76
+ check_int(ret, ==, 0);
77
+
78
+ stats = reftable_writer_stats(writer);
79
+ for (size_t i = 0; i < stats->ref_stats.blocks; i++) {
80
+ size_t off = i * (opts.block_size ? opts.block_size
81
+ : DEFAULT_BLOCK_SIZE);
82
+ if (!off)
83
+ off = header_size(opts.hash_id == GIT_SHA256_FORMAT_ID ? 2 : 1);
84
+ check_char(buf->buf[off], ==, 'r');
85
+ }
86
+
87
+ if (nrefs)
88
+ check_int(stats->ref_stats.blocks, >, 0);
89
+ if (nlogs)
90
+ check_int(stats->log_stats.blocks, >, 0);
91
+
92
+ reftable_writer_free(writer);
93
+}
t/unit-tests/lib-reftable.h
new
+20
@@ -0,0 +1,20 @@
1
+#ifndef LIB_REFTABLE_H
2
+#define LIB_REFTABLE_H
3
+
4
+#include "git-compat-util.h"
5
+#include "strbuf.h"
6
+#include "reftable/reftable-writer.h"
7
+
8
+void t_reftable_set_hash(uint8_t *p, int i, uint32_t id);
9
+
10
+struct reftable_writer *t_reftable_strbuf_writer(struct strbuf *buf,
11
+ struct reftable_write_options *opts);
12
+
13
+void t_reftable_write_to_buf(struct strbuf *buf,
14
+ struct reftable_ref_record *refs,
15
+ size_t nrecords,
16
+ struct reftable_log_record *logs,
17
+ size_t nlogs,
18
+ struct reftable_write_options *opts);
19
+
20
+#endif
t/unit-tests/t-reftable-merged.c
+11
-76
@@ -7,6 +7,7 @@ https://developers.google.com/open-source/licenses/bsd
7
*/
8
9
#include "test-lib.h"
10
+#include "lib-reftable.h"
11
#include "reftable/blocksource.h"
12
#include "reftable/constants.h"
13
#include "reftable/merged.h"
@@ -15,77 +16,6 @@ https://developers.google.com/open-source/licenses/bsd
16
#include "reftable/reftable-merged.h"
17
#include "reftable/reftable-writer.h"
18
18
-static ssize_t strbuf_add_void(void *b, const void *data, const size_t sz)
19
-{
20
- strbuf_add(b, data, sz);
21
- return sz;
22
-}
23
-
24
-static int noop_flush(void *arg UNUSED)
25
-{
26
- return 0;
27
-}
28
-
29
-static void write_test_table(struct strbuf *buf,
30
- struct reftable_ref_record refs[], const size_t n)
31
-{
32
- uint64_t min = 0xffffffff;
33
- uint64_t max = 0;
34
- size_t i;
35
- int err;
36
-
37
- struct reftable_write_options opts = {
38
- .block_size = 256,
39
- };
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)
44
- max = ui;
45
- if (ui < min)
46
- min = ui;
47
- }
48
-
49
- w = reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);
50
- reftable_writer_set_limits(w, min, max);
51
-
52
- for (i = 0; i < n; i++) {
53
- uint64_t before = refs[i].update_index;
54
- int n = reftable_writer_add_ref(w, &refs[i]);
55
- check_int(n, ==, 0);
56
- check_int(before, ==, refs[i].update_index);
57
- }
58
-
59
- err = reftable_writer_close(w);
60
- check(!err);
61
-
62
- reftable_writer_free(w);
63
-}
64
-
65
-static void write_test_log_table(struct strbuf *buf, struct reftable_log_record logs[],
66
- const size_t n, const uint64_t update_index)
67
-{
68
- int err;
69
-
70
- struct reftable_write_options opts = {
71
- .block_size = 256,
72
- .exact_log_message = 1,
73
- };
74
- struct reftable_writer *w = NULL;
75
- w = reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);
76
- reftable_writer_set_limits(w, update_index, update_index);
77
-
78
- for (size_t i = 0; i < n; i++) {
79
- int err = reftable_writer_add_log(w, &logs[i]);
80
- check(!err);
81
- }
82
-
83
- err = reftable_writer_close(w);
84
- check(!err);
85
-
86
- reftable_writer_free(w);
87
-}
88
-
19
static struct reftable_merged_table *
20
merged_table_from_records(struct reftable_ref_record **refs,
21
struct reftable_block_source **source,
@@ -93,13 +23,16 @@ merged_table_from_records(struct reftable_ref_record **refs,
23
struct strbuf *buf, const size_t n)
24
{
25
struct reftable_merged_table *mt = NULL;
26
+ struct reftable_write_options opts = {
27
+ .block_size = 256,
28
+ };
29
int err;
30
31
REFTABLE_CALLOC_ARRAY(*readers, n);
32
REFTABLE_CALLOC_ARRAY(*source, n);
33
34
for (size_t i = 0; i < n; i++) {
102
- write_test_table(&buf[i], refs[i], sizes[i]);
35
+ t_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
36
block_source_from_strbuf(&(*source)[i], &buf[i]);
37
38
err = reftable_reader_new(&(*readers)[i], &(*source)[i],
@@ -268,13 +201,17 @@ merged_table_from_log_records(struct reftable_log_record **logs,
201
struct strbuf *buf, const size_t n)
202
{
203
struct reftable_merged_table *mt = NULL;
204
+ struct reftable_write_options opts = {
205
+ .block_size = 256,
206
+ .exact_log_message = 1,
207
+ };
208
int err;
209
210
REFTABLE_CALLOC_ARRAY(*readers, n);
211
REFTABLE_CALLOC_ARRAY(*source, n);
212
213
for (size_t i = 0; i < n; i++) {
277
- write_test_log_table(&buf[i], logs[i], sizes[i], i + 1);
214
+ t_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
215
block_source_from_strbuf(&(*source)[i], &buf[i]);
216
217
err = reftable_reader_new(&(*readers)[i], &(*source)[i],
@@ -402,9 +339,7 @@ static void t_default_write_opts(void)
339
{
340
struct reftable_write_options opts = { 0 };
341
struct strbuf buf = STRBUF_INIT;
405
- struct reftable_writer *w =
406
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
407
-
342
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
343
struct reftable_ref_record rec = {
344
.refname = (char *) "master",
345
.update_index = 1,
t/unit-tests/t-reftable-readwrite.c
+40
-90
@@ -7,6 +7,7 @@ https://developers.google.com/open-source/licenses/bsd
7
*/
8
9
#include "test-lib.h"
10
+#include "lib-reftable.h"
11
#include "reftable/basics.h"
12
#include "reftable/blocksource.h"
13
#include "reftable/reader.h"
@@ -15,22 +16,6 @@ https://developers.google.com/open-source/licenses/bsd
16
17
static const int update_index = 5;
18
18
-static void set_test_hash(uint8_t *p, int i)
19
-{
20
- memset(p, (uint8_t)i, hash_size(GIT_SHA1_FORMAT_ID));
21
-}
22
-
23
-static ssize_t strbuf_add_void(void *b, const void *data, size_t sz)
24
-{
25
- strbuf_add(b, data, sz);
26
- return sz;
27
-}
28
-
29
-static int noop_flush(void *arg UNUSED)
30
-{
31
- return 0;
32
-}
33
-
19
static void t_buffer(void)
20
{
21
struct strbuf buf = STRBUF_INIT;
@@ -62,61 +47,34 @@ static void write_table(char ***names, struct strbuf *buf, int N,
47
.block_size = block_size,
48
.hash_id = hash_id,
49
};
65
- struct reftable_writer *w =
66
- reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);
67
- struct reftable_ref_record ref = { 0 };
68
- int i = 0, n;
69
- struct reftable_log_record log = { 0 };
70
- const struct reftable_stats *stats = NULL;
50
+ struct reftable_ref_record *refs;
51
+ struct reftable_log_record *logs;
52
+ int i;
53
54
REFTABLE_CALLOC_ARRAY(*names, N + 1);
55
+ REFTABLE_CALLOC_ARRAY(refs, N);
56
+ REFTABLE_CALLOC_ARRAY(logs, N);
57
74
- reftable_writer_set_limits(w, update_index, update_index);
58
for (i = 0; i < N; i++) {
76
- char name[100];
77
- int n;
78
-
79
- snprintf(name, sizeof(name), "refs/heads/branch%02d", i);
80
-
81
- ref.refname = name;
82
- ref.update_index = update_index;
83
- ref.value_type = REFTABLE_REF_VAL1;
84
- set_test_hash(ref.value.val1, i);
85
- (*names)[i] = xstrdup(name);
86
-
87
- n = reftable_writer_add_ref(w, &ref);
88
- check_int(n, ==, 0);
59
+ refs[i].refname = (*names)[i] = xstrfmt("refs/heads/branch%02d", i);
60
+ refs[i].update_index = update_index;
61
+ refs[i].value_type = REFTABLE_REF_VAL1;
62
+ t_reftable_set_hash(refs[i].value.val1, i, GIT_SHA1_FORMAT_ID);
63
}
64
65
for (i = 0; i < N; i++) {
92
- char name[100];
93
- int n;
94
-
95
- snprintf(name, sizeof(name), "refs/heads/branch%02d", i);
96
-
97
- log.refname = name;
98
- log.update_index = update_index;
99
- log.value_type = REFTABLE_LOG_UPDATE;
100
- set_test_hash(log.value.update.new_hash, i);
101
- log.value.update.message = (char *) "message";
102
-
103
- n = reftable_writer_add_log(w, &log);
104
- check_int(n, ==, 0);
66
+ logs[i].refname = (*names)[i];
67
+ logs[i].update_index = update_index;
68
+ logs[i].value_type = REFTABLE_LOG_UPDATE;
69
+ t_reftable_set_hash(logs[i].value.update.new_hash, i,
70
+ GIT_SHA1_FORMAT_ID);
71
+ logs[i].value.update.message = (char *) "message";
72
}
73
107
- n = reftable_writer_close(w);
108
- check_int(n, ==, 0);
109
-
110
- stats = reftable_writer_stats(w);
111
- for (i = 0; i < stats->ref_stats.blocks; i++) {
112
- int off = i * opts.block_size;
113
- if (!off)
114
- off = header_size((hash_id == GIT_SHA256_FORMAT_ID) ? 2 : 1);
115
- check_char(buf->buf[off], ==, 'r');
116
- }
74
+ t_reftable_write_to_buf(buf, refs, N, logs, N, &opts);
75
118
- check_int(stats->log_stats.blocks, >, 0);
119
- reftable_writer_free(w);
76
+ free(refs);
77
+ free(logs);
78
}
79
80
static void t_log_buffer_size(void)
@@ -138,8 +96,7 @@ static void t_log_buffer_size(void)
96
.time = 0x5e430672,
97
.message = (char *) "commit: 9\n",
98
} } };
141
- struct reftable_writer *w =
142
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
99
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
100
101
/* This tests buffer extension for log compression. Must use a random
102
hash, to ensure that the compressed part is larger than the original.
@@ -181,8 +138,7 @@ static void t_log_overflow(void)
138
},
139
},
140
};
184
- struct reftable_writer *w =
185
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
141
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
142
143
memset(msg, 'x', sizeof(msg) - 1);
144
reftable_writer_set_limits(w, update_index, update_index);
@@ -208,8 +164,7 @@ static void t_log_write_read(void)
164
struct reftable_reader *reader;
165
struct reftable_block_source source = { 0 };
166
struct strbuf buf = STRBUF_INIT;
211
- struct reftable_writer *w =
212
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
167
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
168
const struct reftable_stats *stats = NULL;
169
reftable_writer_set_limits(w, 0, N);
170
for (i = 0; i < N; i++) {
@@ -229,8 +184,10 @@ static void t_log_write_read(void)
184
log.refname = names[i];
185
log.update_index = i;
186
log.value_type = REFTABLE_LOG_UPDATE;
232
- set_test_hash(log.value.update.old_hash, i);
233
- set_test_hash(log.value.update.new_hash, i + 1);
187
+ t_reftable_set_hash(log.value.update.old_hash, i,
188
+ GIT_SHA1_FORMAT_ID);
189
+ t_reftable_set_hash(log.value.update.new_hash, i + 1,
190
+ GIT_SHA1_FORMAT_ID);
191
192
err = reftable_writer_add_log(w, &log);
193
check(!err);
@@ -297,8 +254,7 @@ static void t_log_zlib_corruption(void)
254
struct reftable_reader *reader;
255
struct reftable_block_source source = { 0 };
256
struct strbuf buf = STRBUF_INIT;
300
- struct reftable_writer *w =
301
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
257
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
258
const struct reftable_stats *stats = NULL;
259
char message[100] = { 0 };
260
int err, i, n;
@@ -528,15 +484,12 @@ static void t_table_refs_for(int indexed)
484
int err;
485
struct reftable_reader *reader;
486
struct reftable_block_source source = { 0 };
531
-
487
struct strbuf buf = STRBUF_INIT;
533
- struct reftable_writer *w =
534
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
535
-
488
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
489
struct reftable_iterator it = { 0 };
490
int j;
491
539
- set_test_hash(want_hash, 4);
492
+ t_reftable_set_hash(want_hash, 4, GIT_SHA1_FORMAT_ID);
493
494
for (i = 0; i < N; i++) {
495
uint8_t hash[GIT_SHA1_RAWSZ];
@@ -552,8 +505,10 @@ static void t_table_refs_for(int indexed)
505
ref.refname = name;
506
507
ref.value_type = REFTABLE_REF_VAL2;
555
- set_test_hash(ref.value.val2.value, i / 4);
556
- set_test_hash(ref.value.val2.target_value, 3 + i / 4);
508
+ t_reftable_set_hash(ref.value.val2.value, i / 4,
509
+ GIT_SHA1_FORMAT_ID);
510
+ t_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4,
511
+ GIT_SHA1_FORMAT_ID);
512
513
/* 80 bytes / entry, so 3 entries per block. Yields 17
514
*/
@@ -618,8 +573,7 @@ static void t_write_empty_table(void)
573
{
574
struct reftable_write_options opts = { 0 };
575
struct strbuf buf = STRBUF_INIT;
621
- struct reftable_writer *w =
622
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
576
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
577
struct reftable_block_source source = { 0 };
578
struct reftable_reader *rd = NULL;
579
struct reftable_ref_record rec = { 0 };
@@ -657,8 +611,7 @@ static void t_write_object_id_min_length(void)
611
.block_size = 75,
612
};
613
struct strbuf buf = STRBUF_INIT;
660
- struct reftable_writer *w =
661
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
614
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
615
struct reftable_ref_record ref = {
616
.update_index = 1,
617
.value_type = REFTABLE_REF_VAL1,
@@ -692,8 +645,7 @@ static void t_write_object_id_length(void)
645
.block_size = 75,
646
};
647
struct strbuf buf = STRBUF_INIT;
695
- struct reftable_writer *w =
696
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
648
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
649
struct reftable_ref_record ref = {
650
.update_index = 1,
651
.value_type = REFTABLE_REF_VAL1,
@@ -726,8 +678,7 @@ static void t_write_empty_key(void)
678
{
679
struct reftable_write_options opts = { 0 };
680
struct strbuf buf = STRBUF_INIT;
729
- struct reftable_writer *w =
730
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
681
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
682
struct reftable_ref_record ref = {
683
.refname = (char *) "",
684
.update_index = 1,
@@ -749,8 +700,7 @@ static void t_write_key_order(void)
700
{
701
struct reftable_write_options opts = { 0 };
702
struct strbuf buf = STRBUF_INIT;
752
- struct reftable_writer *w =
753
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
703
+ struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
704
struct reftable_ref_record refs[2] = {
705
{
706
.refname = (char *) "b",
@@ -798,7 +748,7 @@ static void t_write_multiple_indices(void)
748
struct reftable_reader *reader;
749
int err, i;
750
801
- writer = reftable_new_writer(&strbuf_add_void, &noop_flush, &writer_buf, &opts);
751
+ writer = t_reftable_strbuf_writer(&writer_buf, &opts);
752
reftable_writer_set_limits(writer, 1, 1);
753
for (i = 0; i < 100; i++) {
754
struct reftable_ref_record ref = {
@@ -876,7 +826,7 @@ static void t_write_multi_level_index(void)
826
struct reftable_reader *reader;
827
int err;
828
879
- writer = reftable_new_writer(&strbuf_add_void, &noop_flush, &writer_buf, &opts);
829
+ writer = t_reftable_strbuf_writer(&writer_buf, &opts);
830
reftable_writer_set_limits(writer, 1, 1);
831
for (size_t i = 0; i < 200; i++) {
832
struct reftable_ref_record ref = {
t/unit-tests/t-reftable-stack.c
+12
-13
@@ -7,17 +7,13 @@ https://developers.google.com/open-source/licenses/bsd
7
*/
8
9
#include "test-lib.h"
10
+#include "lib-reftable.h"
11
#include "reftable/merged.h"
12
#include "reftable/reader.h"
13
#include "reftable/reftable-error.h"
14
#include "reftable/stack.h"
15
#include <dirent.h>
16
16
-static void set_test_hash(uint8_t *p, int i)
17
-{
18
- memset(p, (uint8_t)i, hash_size(GIT_SHA1_FORMAT_ID));
19
-}
20
-
17
static void clear_dir(const char *dirname)
18
{
19
struct strbuf path = STRBUF_INIT;
@@ -125,7 +121,7 @@ static void write_n_ref_tables(struct reftable_stack *st,
121
strbuf_reset(&buf);
122
strbuf_addf(&buf, "refs/heads/branch-%04"PRIuMAX, (uintmax_t)i);
123
ref.refname = buf.buf;
128
- set_test_hash(ref.value.val1, i);
124
+ t_reftable_set_hash(ref.value.val1, i, GIT_SHA1_FORMAT_ID);
125
126
err = reftable_stack_add(st, &write_test_ref, &ref);
127
check(!err);
@@ -470,13 +466,13 @@ static void t_reftable_stack_add(void)
466
refs[i].refname = xstrdup(buf);
467
refs[i].update_index = i + 1;
468
refs[i].value_type = REFTABLE_REF_VAL1;
473
- set_test_hash(refs[i].value.val1, i);
469
+ t_reftable_set_hash(refs[i].value.val1, i, GIT_SHA1_FORMAT_ID);
470
471
logs[i].refname = xstrdup(buf);
472
logs[i].update_index = N + i + 1;
473
logs[i].value_type = REFTABLE_LOG_UPDATE;
474
logs[i].value.update.email = xstrdup("identity@invalid");
479
- set_test_hash(logs[i].value.update.new_hash, i);
475
+ t_reftable_set_hash(logs[i].value.update.new_hash, i, GIT_SHA1_FORMAT_ID);
476
}
477
478
for (i = 0; i < N; i++) {
@@ -562,14 +558,14 @@ static void t_reftable_stack_iterator(void)
558
refs[i].refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);
559
refs[i].update_index = i + 1;
560
refs[i].value_type = REFTABLE_REF_VAL1;
565
- set_test_hash(refs[i].value.val1, i);
561
+ t_reftable_set_hash(refs[i].value.val1, i, GIT_SHA1_FORMAT_ID);
562
563
logs[i].refname = xstrfmt("branch%02"PRIuMAX, (uintmax_t)i);
564
logs[i].update_index = i + 1;
565
logs[i].value_type = REFTABLE_LOG_UPDATE;
566
logs[i].value.update.email = xstrdup("johndoe@invalid");
567
logs[i].value.update.message = xstrdup("commit\n");
572
- set_test_hash(logs[i].value.update.new_hash, i);
568
+ t_reftable_set_hash(logs[i].value.update.new_hash, i, GIT_SHA1_FORMAT_ID);
569
}
570
571
for (i = 0; i < N; i++) {
@@ -704,7 +700,8 @@ static void t_reftable_stack_tombstone(void)
700
refs[i].update_index = i + 1;
701
if (i % 2 == 0) {
702
refs[i].value_type = REFTABLE_REF_VAL1;
707
- set_test_hash(refs[i].value.val1, i);
703
+ t_reftable_set_hash(refs[i].value.val1, i,
704
+ GIT_SHA1_FORMAT_ID);
705
}
706
707
logs[i].refname = xstrdup(buf);
@@ -712,7 +709,8 @@ static void t_reftable_stack_tombstone(void)
709
logs[i].update_index = 42;
710
if (i % 2 == 0) {
711
logs[i].value_type = REFTABLE_LOG_UPDATE;
715
- set_test_hash(logs[i].value.update.new_hash, i);
712
+ t_reftable_set_hash(logs[i].value.update.new_hash, i,
713
+ GIT_SHA1_FORMAT_ID);
714
logs[i].value.update.email =
715
xstrdup("identity@invalid");
716
}
@@ -844,7 +842,8 @@ static void t_reflog_expire(void)
842
logs[i].value_type = REFTABLE_LOG_UPDATE;
843
logs[i].value.update.time = i;
844
logs[i].value.update.email = xstrdup("identity@invalid");
847
- set_test_hash(logs[i].value.update.new_hash, i);
845
+ t_reftable_set_hash(logs[i].value.update.new_hash, i,
846
+ GIT_SHA1_FORMAT_ID);
847
}
848
849
for (i = 1; i <= N; i++) {