2 Copyright 2020 Google LLC
4 Use of this source code is governed by a BSD-style
5 license that can be found in the LICENSE file or at
6 https://developers.google.com/open-source/licenses/bsd
13 #include "blocksource.h"
14 #include "constants.h"
17 #include "test_framework.h"
18 #include "reftable-tests.h"
19 #include "reftable-writer.h"
21 static const int update_index
= 5;
23 static void test_buffer(void)
25 struct strbuf buf
= STRBUF_INIT
;
26 struct reftable_block_source source
= { NULL
};
27 struct reftable_block out
= { NULL
};
29 uint8_t in
[] = "hello";
30 strbuf_add(&buf
, in
, sizeof(in
));
31 block_source_from_strbuf(&source
, &buf
);
32 EXPECT(block_source_size(&source
) == 6);
33 n
= block_source_read_block(&source
, &out
, 0, sizeof(in
));
34 EXPECT(n
== sizeof(in
));
35 EXPECT(!memcmp(in
, out
.data
, n
));
36 reftable_block_done(&out
);
38 n
= block_source_read_block(&source
, &out
, 1, 2);
40 EXPECT(!memcmp(out
.data
, "el", 2));
42 reftable_block_done(&out
);
43 block_source_close(&source
);
47 static void write_table(char ***names
, struct strbuf
*buf
, int N
,
48 int block_size
, uint32_t hash_id
)
50 struct reftable_write_options opts
= {
51 .block_size
= block_size
,
54 struct reftable_writer
*w
=
55 reftable_new_writer(&strbuf_add_void
, buf
, &opts
);
56 struct reftable_ref_record ref
= { NULL
};
58 struct reftable_log_record log
= { NULL
};
59 const struct reftable_stats
*stats
= NULL
;
60 *names
= reftable_calloc(sizeof(char *) * (N
+ 1));
61 reftable_writer_set_limits(w
, update_index
, update_index
);
62 for (i
= 0; i
< N
; i
++) {
63 uint8_t hash
[GIT_SHA256_RAWSZ
] = { 0 };
67 set_test_hash(hash
, i
);
69 snprintf(name
, sizeof(name
), "refs/heads/branch%02d", i
);
72 ref
.update_index
= update_index
;
73 ref
.value_type
= REFTABLE_REF_VAL1
;
74 ref
.value
.val1
= hash
;
75 (*names
)[i
] = xstrdup(name
);
77 n
= reftable_writer_add_ref(w
, &ref
);
81 for (i
= 0; i
< N
; i
++) {
82 uint8_t hash
[GIT_SHA256_RAWSZ
] = { 0 };
86 set_test_hash(hash
, i
);
88 snprintf(name
, sizeof(name
), "refs/heads/branch%02d", i
);
91 log
.update_index
= update_index
;
92 log
.value_type
= REFTABLE_LOG_UPDATE
;
93 log
.value
.update
.new_hash
= hash
;
94 log
.value
.update
.message
= "message";
96 n
= reftable_writer_add_log(w
, &log
);
100 n
= reftable_writer_close(w
);
103 stats
= writer_stats(w
);
104 for (i
= 0; i
< stats
->ref_stats
.blocks
; i
++) {
105 int off
= i
* opts
.block_size
;
108 (hash_id
== GIT_SHA256_FORMAT_ID
) ? 2 : 1);
110 EXPECT(buf
->buf
[off
] == 'r');
113 EXPECT(stats
->log_stats
.blocks
> 0);
114 reftable_writer_free(w
);
117 static void test_log_buffer_size(void)
119 struct strbuf buf
= STRBUF_INIT
;
120 struct reftable_write_options opts
= {
125 struct reftable_log_record
126 log
= { .refname
= "refs/heads/master",
128 .value_type
= REFTABLE_LOG_UPDATE
,
129 .value
= { .update
= {
130 .name
= "Han-Wen Nienhuys",
131 .email
= "hanwen@google.com",
134 .message
= "commit: 9\n",
136 struct reftable_writer
*w
=
137 reftable_new_writer(&strbuf_add_void
, &buf
, &opts
);
139 /* This tests buffer extension for log compression. Must use a random
140 hash, to ensure that the compressed part is larger than the original.
142 uint8_t hash1
[GIT_SHA1_RAWSZ
], hash2
[GIT_SHA1_RAWSZ
];
143 for (i
= 0; i
< GIT_SHA1_RAWSZ
; i
++) {
144 hash1
[i
] = (uint8_t)(rand() % 256);
145 hash2
[i
] = (uint8_t)(rand() % 256);
147 log
.value
.update
.old_hash
= hash1
;
148 log
.value
.update
.new_hash
= hash2
;
149 reftable_writer_set_limits(w
, update_index
, update_index
);
150 err
= reftable_writer_add_log(w
, &log
);
152 err
= reftable_writer_close(w
);
154 reftable_writer_free(w
);
155 strbuf_release(&buf
);
158 static void test_log_overflow(void)
160 struct strbuf buf
= STRBUF_INIT
;
161 char msg
[256] = { 0 };
162 struct reftable_write_options opts
= {
163 .block_size
= ARRAY_SIZE(msg
),
166 struct reftable_log_record
167 log
= { .refname
= "refs/heads/master",
169 .value_type
= REFTABLE_LOG_UPDATE
,
170 .value
= { .update
= {
171 .name
= "Han-Wen Nienhuys",
172 .email
= "hanwen@google.com",
177 struct reftable_writer
*w
=
178 reftable_new_writer(&strbuf_add_void
, &buf
, &opts
);
180 uint8_t hash1
[GIT_SHA1_RAWSZ
] = {1}, hash2
[GIT_SHA1_RAWSZ
] = { 2 };
182 memset(msg
, 'x', sizeof(msg
) - 1);
183 log
.value
.update
.old_hash
= hash1
;
184 log
.value
.update
.new_hash
= hash2
;
185 reftable_writer_set_limits(w
, update_index
, update_index
);
186 err
= reftable_writer_add_log(w
, &log
);
187 EXPECT(err
== REFTABLE_ENTRY_TOO_BIG_ERROR
);
188 reftable_writer_free(w
);
189 strbuf_release(&buf
);
192 static void test_log_write_read(void)
195 char **names
= reftable_calloc(sizeof(char *) * (N
+ 1));
197 struct reftable_write_options opts
= {
200 struct reftable_ref_record ref
= { NULL
};
202 struct reftable_log_record log
= { NULL
};
204 struct reftable_iterator it
= { NULL
};
205 struct reftable_reader rd
= { NULL
};
206 struct reftable_block_source source
= { NULL
};
207 struct strbuf buf
= STRBUF_INIT
;
208 struct reftable_writer
*w
=
209 reftable_new_writer(&strbuf_add_void
, &buf
, &opts
);
210 const struct reftable_stats
*stats
= NULL
;
211 reftable_writer_set_limits(w
, 0, N
);
212 for (i
= 0; i
< N
; i
++) {
214 struct reftable_ref_record ref
= { NULL
};
215 snprintf(name
, sizeof(name
), "b%02d%0*d", i
, 130, 7);
216 names
[i
] = xstrdup(name
);
218 ref
.update_index
= i
;
220 err
= reftable_writer_add_ref(w
, &ref
);
223 for (i
= 0; i
< N
; i
++) {
224 uint8_t hash1
[GIT_SHA1_RAWSZ
], hash2
[GIT_SHA1_RAWSZ
];
225 struct reftable_log_record log
= { NULL
};
226 set_test_hash(hash1
, i
);
227 set_test_hash(hash2
, i
+ 1);
229 log
.refname
= names
[i
];
230 log
.update_index
= i
;
231 log
.value_type
= REFTABLE_LOG_UPDATE
;
232 log
.value
.update
.old_hash
= hash1
;
233 log
.value
.update
.new_hash
= hash2
;
235 err
= reftable_writer_add_log(w
, &log
);
239 n
= reftable_writer_close(w
);
242 stats
= writer_stats(w
);
243 EXPECT(stats
->log_stats
.blocks
> 0);
244 reftable_writer_free(w
);
247 block_source_from_strbuf(&source
, &buf
);
249 err
= init_reader(&rd
, &source
, "file.log");
252 err
= reftable_reader_seek_ref(&rd
, &it
, names
[N
- 1]);
255 err
= reftable_iterator_next_ref(&it
, &ref
);
258 /* end of iteration. */
259 err
= reftable_iterator_next_ref(&it
, &ref
);
262 reftable_iterator_destroy(&it
);
263 reftable_ref_record_release(&ref
);
265 err
= reftable_reader_seek_log(&rd
, &it
, "");
270 int err
= reftable_iterator_next_log(&it
, &log
);
276 EXPECT_STREQ(names
[i
], log
.refname
);
277 EXPECT(i
== log
.update_index
);
279 reftable_log_record_release(&log
);
283 reftable_iterator_destroy(&it
);
286 strbuf_release(&buf
);
291 static void test_table_read_write_sequential(void)
294 struct strbuf buf
= STRBUF_INIT
;
296 struct reftable_iterator it
= { NULL
};
297 struct reftable_block_source source
= { NULL
};
298 struct reftable_reader rd
= { NULL
};
302 write_table(&names
, &buf
, N
, 256, GIT_SHA1_FORMAT_ID
);
304 block_source_from_strbuf(&source
, &buf
);
306 err
= init_reader(&rd
, &source
, "file.ref");
309 err
= reftable_reader_seek_ref(&rd
, &it
, "");
313 struct reftable_ref_record ref
= { NULL
};
314 int r
= reftable_iterator_next_ref(&it
, &ref
);
319 EXPECT(0 == strcmp(names
[j
], ref
.refname
));
320 EXPECT(update_index
== ref
.update_index
);
323 reftable_ref_record_release(&ref
);
326 reftable_iterator_destroy(&it
);
327 strbuf_release(&buf
);
333 static void test_table_write_small_table(void)
336 struct strbuf buf
= STRBUF_INIT
;
338 write_table(&names
, &buf
, N
, 4096, GIT_SHA1_FORMAT_ID
);
339 EXPECT(buf
.len
< 200);
340 strbuf_release(&buf
);
344 static void test_table_read_api(void)
347 struct strbuf buf
= STRBUF_INIT
;
349 struct reftable_reader rd
= { NULL
};
350 struct reftable_block_source source
= { NULL
};
353 struct reftable_log_record log
= { NULL
};
354 struct reftable_iterator it
= { NULL
};
356 write_table(&names
, &buf
, N
, 256, GIT_SHA1_FORMAT_ID
);
358 block_source_from_strbuf(&source
, &buf
);
360 err
= init_reader(&rd
, &source
, "file.ref");
363 err
= reftable_reader_seek_ref(&rd
, &it
, names
[0]);
366 err
= reftable_iterator_next_log(&it
, &log
);
367 EXPECT(err
== REFTABLE_API_ERROR
);
369 strbuf_release(&buf
);
370 for (i
= 0; i
< N
; i
++) {
371 reftable_free(names
[i
]);
373 reftable_iterator_destroy(&it
);
374 reftable_free(names
);
376 strbuf_release(&buf
);
379 static void test_table_read_write_seek(int index
, int hash_id
)
382 struct strbuf buf
= STRBUF_INIT
;
384 struct reftable_reader rd
= { NULL
};
385 struct reftable_block_source source
= { NULL
};
389 struct reftable_iterator it
= { NULL
};
390 struct strbuf pastLast
= STRBUF_INIT
;
391 struct reftable_ref_record ref
= { NULL
};
393 write_table(&names
, &buf
, N
, 256, hash_id
);
395 block_source_from_strbuf(&source
, &buf
);
397 err
= init_reader(&rd
, &source
, "file.ref");
399 EXPECT(hash_id
== reftable_reader_hash_id(&rd
));
402 rd
.ref_offsets
.index_offset
= 0;
404 EXPECT(rd
.ref_offsets
.index_offset
> 0);
407 for (i
= 1; i
< N
; i
++) {
408 int err
= reftable_reader_seek_ref(&rd
, &it
, names
[i
]);
410 err
= reftable_iterator_next_ref(&it
, &ref
);
412 EXPECT(0 == strcmp(names
[i
], ref
.refname
));
413 EXPECT(REFTABLE_REF_VAL1
== ref
.value_type
);
414 EXPECT(i
== ref
.value
.val1
[0]);
416 reftable_ref_record_release(&ref
);
417 reftable_iterator_destroy(&it
);
420 strbuf_addstr(&pastLast
, names
[N
- 1]);
421 strbuf_addstr(&pastLast
, "/");
423 err
= reftable_reader_seek_ref(&rd
, &it
, pastLast
.buf
);
425 struct reftable_ref_record ref
= { NULL
};
426 int err
= reftable_iterator_next_ref(&it
, &ref
);
432 strbuf_release(&pastLast
);
433 reftable_iterator_destroy(&it
);
435 strbuf_release(&buf
);
436 for (i
= 0; i
< N
; i
++) {
437 reftable_free(names
[i
]);
439 reftable_free(names
);
443 static void test_table_read_write_seek_linear(void)
445 test_table_read_write_seek(0, GIT_SHA1_FORMAT_ID
);
448 static void test_table_read_write_seek_linear_sha256(void)
450 test_table_read_write_seek(0, GIT_SHA256_FORMAT_ID
);
453 static void test_table_read_write_seek_index(void)
455 test_table_read_write_seek(1, GIT_SHA1_FORMAT_ID
);
458 static void test_table_refs_for(int indexed
)
461 char **want_names
= reftable_calloc(sizeof(char *) * (N
+ 1));
462 int want_names_len
= 0;
463 uint8_t want_hash
[GIT_SHA1_RAWSZ
];
465 struct reftable_write_options opts
= {
468 struct reftable_ref_record ref
= { NULL
};
472 struct reftable_reader rd
;
473 struct reftable_block_source source
= { NULL
};
475 struct strbuf buf
= STRBUF_INIT
;
476 struct reftable_writer
*w
=
477 reftable_new_writer(&strbuf_add_void
, &buf
, &opts
);
479 struct reftable_iterator it
= { NULL
};
482 set_test_hash(want_hash
, 4);
484 for (i
= 0; i
< N
; i
++) {
485 uint8_t hash
[GIT_SHA1_RAWSZ
];
486 char fill
[51] = { 0 };
488 uint8_t hash1
[GIT_SHA1_RAWSZ
];
489 uint8_t hash2
[GIT_SHA1_RAWSZ
];
490 struct reftable_ref_record ref
= { NULL
};
492 memset(hash
, i
, sizeof(hash
));
493 memset(fill
, 'x', 50);
494 /* Put the variable part in the start */
495 snprintf(name
, sizeof(name
), "br%02d%s", i
, fill
);
499 set_test_hash(hash1
, i
/ 4);
500 set_test_hash(hash2
, 3 + i
/ 4);
501 ref
.value_type
= REFTABLE_REF_VAL2
;
502 ref
.value
.val2
.value
= hash1
;
503 ref
.value
.val2
.target_value
= hash2
;
505 /* 80 bytes / entry, so 3 entries per block. Yields 17
508 n
= reftable_writer_add_ref(w
, &ref
);
511 if (!memcmp(hash1
, want_hash
, GIT_SHA1_RAWSZ
) ||
512 !memcmp(hash2
, want_hash
, GIT_SHA1_RAWSZ
)) {
513 want_names
[want_names_len
++] = xstrdup(name
);
517 n
= reftable_writer_close(w
);
520 reftable_writer_free(w
);
523 block_source_from_strbuf(&source
, &buf
);
525 err
= init_reader(&rd
, &source
, "file.ref");
528 rd
.obj_offsets
.is_present
= 0;
531 err
= reftable_reader_seek_ref(&rd
, &it
, "");
533 reftable_iterator_destroy(&it
);
535 err
= reftable_reader_refs_for(&rd
, &it
, want_hash
);
540 int err
= reftable_iterator_next_ref(&it
, &ref
);
546 EXPECT(j
< want_names_len
);
547 EXPECT(0 == strcmp(ref
.refname
, want_names
[j
]));
549 reftable_ref_record_release(&ref
);
551 EXPECT(j
== want_names_len
);
553 strbuf_release(&buf
);
554 free_names(want_names
);
555 reftable_iterator_destroy(&it
);
559 static void test_table_refs_for_no_index(void)
561 test_table_refs_for(0);
564 static void test_table_refs_for_obj_index(void)
566 test_table_refs_for(1);
569 static void test_write_empty_table(void)
571 struct reftable_write_options opts
= { 0 };
572 struct strbuf buf
= STRBUF_INIT
;
573 struct reftable_writer
*w
=
574 reftable_new_writer(&strbuf_add_void
, &buf
, &opts
);
575 struct reftable_block_source source
= { NULL
};
576 struct reftable_reader
*rd
= NULL
;
577 struct reftable_ref_record rec
= { NULL
};
578 struct reftable_iterator it
= { NULL
};
581 reftable_writer_set_limits(w
, 1, 1);
583 err
= reftable_writer_close(w
);
584 EXPECT(err
== REFTABLE_EMPTY_TABLE_ERROR
);
585 reftable_writer_free(w
);
587 EXPECT(buf
.len
== header_size(1) + footer_size(1));
589 block_source_from_strbuf(&source
, &buf
);
591 err
= reftable_new_reader(&rd
, &source
, "filename");
594 err
= reftable_reader_seek_ref(rd
, &it
, "");
597 err
= reftable_iterator_next_ref(&it
, &rec
);
600 reftable_iterator_destroy(&it
);
601 reftable_reader_free(rd
);
602 strbuf_release(&buf
);
605 static void test_write_key_order(void)
607 struct reftable_write_options opts
= { 0 };
608 struct strbuf buf
= STRBUF_INIT
;
609 struct reftable_writer
*w
=
610 reftable_new_writer(&strbuf_add_void
, &buf
, &opts
);
611 struct reftable_ref_record refs
[2] = {
615 .value_type
= REFTABLE_REF_SYMREF
,
622 .value_type
= REFTABLE_REF_SYMREF
,
630 reftable_writer_set_limits(w
, 1, 1);
631 err
= reftable_writer_add_ref(w
, &refs
[0]);
633 err
= reftable_writer_add_ref(w
, &refs
[1]);
635 EXPECT(err
== REFTABLE_API_ERROR
);
636 reftable_writer_close(w
);
637 reftable_writer_free(w
);
638 strbuf_release(&buf
);
641 static void test_corrupt_table_empty(void)
643 struct strbuf buf
= STRBUF_INIT
;
644 struct reftable_block_source source
= { NULL
};
645 struct reftable_reader rd
= { NULL
};
648 block_source_from_strbuf(&source
, &buf
);
649 err
= init_reader(&rd
, &source
, "file.log");
650 EXPECT(err
== REFTABLE_FORMAT_ERROR
);
653 static void test_corrupt_table(void)
655 uint8_t zeros
[1024] = { 0 };
656 struct strbuf buf
= STRBUF_INIT
;
657 struct reftable_block_source source
= { NULL
};
658 struct reftable_reader rd
= { NULL
};
660 strbuf_add(&buf
, zeros
, sizeof(zeros
));
662 block_source_from_strbuf(&source
, &buf
);
663 err
= init_reader(&rd
, &source
, "file.log");
664 EXPECT(err
== REFTABLE_FORMAT_ERROR
);
665 strbuf_release(&buf
);
668 int readwrite_test_main(int argc
, const char *argv
[])
670 RUN_TEST(test_corrupt_table
);
671 RUN_TEST(test_corrupt_table_empty
);
672 RUN_TEST(test_log_write_read
);
673 RUN_TEST(test_write_key_order
);
674 RUN_TEST(test_table_read_write_seek_linear_sha256
);
675 RUN_TEST(test_log_buffer_size
);
676 RUN_TEST(test_table_write_small_table
);
677 RUN_TEST(test_buffer
);
678 RUN_TEST(test_table_read_api
);
679 RUN_TEST(test_table_read_write_sequential
);
680 RUN_TEST(test_table_read_write_seek_linear
);
681 RUN_TEST(test_table_read_write_seek_index
);
682 RUN_TEST(test_table_refs_for_no_index
);
683 RUN_TEST(test_table_refs_for_obj_index
);
684 RUN_TEST(test_write_empty_table
);
685 RUN_TEST(test_log_overflow
);