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"
16 #include "test_framework.h"
17 #include "reftable-tests.h"
18 #include "reftable-writer.h"
20 static const int update_index
= 5;
22 static void test_buffer(void)
24 struct strbuf buf
= STRBUF_INIT
;
25 struct reftable_block_source source
= { NULL
};
26 struct reftable_block out
= { NULL
};
28 uint8_t in
[] = "hello";
29 strbuf_add(&buf
, in
, sizeof(in
));
30 block_source_from_strbuf(&source
, &buf
);
31 EXPECT(block_source_size(&source
) == 6);
32 n
= block_source_read_block(&source
, &out
, 0, sizeof(in
));
33 EXPECT(n
== sizeof(in
));
34 EXPECT(!memcmp(in
, out
.data
, n
));
35 reftable_block_done(&out
);
37 n
= block_source_read_block(&source
, &out
, 1, 2);
39 EXPECT(!memcmp(out
.data
, "el", 2));
41 reftable_block_done(&out
);
42 block_source_close(&source
);
46 static void write_table(char ***names
, struct strbuf
*buf
, int N
,
47 int block_size
, uint32_t hash_id
)
49 struct reftable_write_options opts
= {
50 .block_size
= block_size
,
53 struct reftable_writer
*w
=
54 reftable_new_writer(&strbuf_add_void
, &noop_flush
, buf
, &opts
);
55 struct reftable_ref_record ref
= { NULL
};
57 struct reftable_log_record log
= { NULL
};
58 const struct reftable_stats
*stats
= NULL
;
60 REFTABLE_CALLOC_ARRAY(*names
, N
+ 1);
62 reftable_writer_set_limits(w
, update_index
, update_index
);
63 for (i
= 0; i
< N
; i
++) {
67 snprintf(name
, sizeof(name
), "refs/heads/branch%02d", i
);
70 ref
.update_index
= update_index
;
71 ref
.value_type
= REFTABLE_REF_VAL1
;
72 set_test_hash(ref
.value
.val1
, i
);
73 (*names
)[i
] = xstrdup(name
);
75 n
= reftable_writer_add_ref(w
, &ref
);
79 for (i
= 0; i
< N
; i
++) {
83 snprintf(name
, sizeof(name
), "refs/heads/branch%02d", i
);
86 log
.update_index
= update_index
;
87 log
.value_type
= REFTABLE_LOG_UPDATE
;
88 set_test_hash(log
.value
.update
.new_hash
, i
);
89 log
.value
.update
.message
= "message";
91 n
= reftable_writer_add_log(w
, &log
);
95 n
= reftable_writer_close(w
);
98 stats
= reftable_writer_stats(w
);
99 for (i
= 0; i
< stats
->ref_stats
.blocks
; i
++) {
100 int off
= i
* opts
.block_size
;
103 (hash_id
== GIT_SHA256_FORMAT_ID
) ? 2 : 1);
105 EXPECT(buf
->buf
[off
] == 'r');
108 EXPECT(stats
->log_stats
.blocks
> 0);
109 reftable_writer_free(w
);
112 static void test_log_buffer_size(void)
114 struct strbuf buf
= STRBUF_INIT
;
115 struct reftable_write_options opts
= {
120 struct reftable_log_record
121 log
= { .refname
= "refs/heads/master",
123 .value_type
= REFTABLE_LOG_UPDATE
,
124 .value
= { .update
= {
125 .name
= "Han-Wen Nienhuys",
126 .email
= "hanwen@google.com",
129 .message
= "commit: 9\n",
131 struct reftable_writer
*w
=
132 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
134 /* This tests buffer extension for log compression. Must use a random
135 hash, to ensure that the compressed part is larger than the original.
137 for (i
= 0; i
< GIT_SHA1_RAWSZ
; i
++) {
138 log
.value
.update
.old_hash
[i
] = (uint8_t)(git_rand() % 256);
139 log
.value
.update
.new_hash
[i
] = (uint8_t)(git_rand() % 256);
141 reftable_writer_set_limits(w
, update_index
, update_index
);
142 err
= reftable_writer_add_log(w
, &log
);
144 err
= reftable_writer_close(w
);
146 reftable_writer_free(w
);
147 strbuf_release(&buf
);
150 static void test_log_overflow(void)
152 struct strbuf buf
= STRBUF_INIT
;
153 char msg
[256] = { 0 };
154 struct reftable_write_options opts
= {
155 .block_size
= ARRAY_SIZE(msg
),
158 struct reftable_log_record log
= {
159 .refname
= "refs/heads/master",
161 .value_type
= REFTABLE_LOG_UPDATE
,
166 .name
= "Han-Wen Nienhuys",
167 .email
= "hanwen@google.com",
174 struct reftable_writer
*w
=
175 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
177 memset(msg
, 'x', sizeof(msg
) - 1);
178 reftable_writer_set_limits(w
, update_index
, update_index
);
179 err
= reftable_writer_add_log(w
, &log
);
180 EXPECT(err
== REFTABLE_ENTRY_TOO_BIG_ERROR
);
181 reftable_writer_free(w
);
182 strbuf_release(&buf
);
185 static void test_log_write_read(void)
188 char **names
= reftable_calloc(N
+ 1, sizeof(*names
));
190 struct reftable_write_options opts
= {
193 struct reftable_ref_record ref
= { NULL
};
195 struct reftable_log_record log
= { NULL
};
197 struct reftable_iterator it
= { NULL
};
198 struct reftable_reader rd
= { NULL
};
199 struct reftable_block_source source
= { NULL
};
200 struct strbuf buf
= STRBUF_INIT
;
201 struct reftable_writer
*w
=
202 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
203 const struct reftable_stats
*stats
= NULL
;
204 reftable_writer_set_limits(w
, 0, N
);
205 for (i
= 0; i
< N
; i
++) {
207 struct reftable_ref_record ref
= { NULL
};
208 snprintf(name
, sizeof(name
), "b%02d%0*d", i
, 130, 7);
209 names
[i
] = xstrdup(name
);
211 ref
.update_index
= i
;
213 err
= reftable_writer_add_ref(w
, &ref
);
216 for (i
= 0; i
< N
; i
++) {
217 struct reftable_log_record log
= { NULL
};
219 log
.refname
= names
[i
];
220 log
.update_index
= i
;
221 log
.value_type
= REFTABLE_LOG_UPDATE
;
222 set_test_hash(log
.value
.update
.old_hash
, i
);
223 set_test_hash(log
.value
.update
.new_hash
, i
+ 1);
225 err
= reftable_writer_add_log(w
, &log
);
229 n
= reftable_writer_close(w
);
232 stats
= reftable_writer_stats(w
);
233 EXPECT(stats
->log_stats
.blocks
> 0);
234 reftable_writer_free(w
);
237 block_source_from_strbuf(&source
, &buf
);
239 err
= init_reader(&rd
, &source
, "file.log");
242 err
= reftable_reader_seek_ref(&rd
, &it
, names
[N
- 1]);
245 err
= reftable_iterator_next_ref(&it
, &ref
);
248 /* end of iteration. */
249 err
= reftable_iterator_next_ref(&it
, &ref
);
252 reftable_iterator_destroy(&it
);
253 reftable_ref_record_release(&ref
);
255 err
= reftable_reader_seek_log(&rd
, &it
, "");
260 int err
= reftable_iterator_next_log(&it
, &log
);
266 EXPECT_STREQ(names
[i
], log
.refname
);
267 EXPECT(i
== log
.update_index
);
269 reftable_log_record_release(&log
);
273 reftable_iterator_destroy(&it
);
276 strbuf_release(&buf
);
281 static void test_log_zlib_corruption(void)
283 struct reftable_write_options opts
= {
286 struct reftable_iterator it
= { 0 };
287 struct reftable_reader rd
= { 0 };
288 struct reftable_block_source source
= { 0 };
289 struct strbuf buf
= STRBUF_INIT
;
290 struct reftable_writer
*w
=
291 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
292 const struct reftable_stats
*stats
= NULL
;
293 char message
[100] = { 0 };
295 struct reftable_log_record log
= {
296 .refname
= "refname",
297 .value_type
= REFTABLE_LOG_UPDATE
,
303 .email
= "myname@invalid",
309 for (i
= 0; i
< sizeof(message
) - 1; i
++)
310 message
[i
] = (uint8_t)(git_rand() % 64 + ' ');
312 reftable_writer_set_limits(w
, 1, 1);
314 err
= reftable_writer_add_log(w
, &log
);
317 n
= reftable_writer_close(w
);
320 stats
= reftable_writer_stats(w
);
321 EXPECT(stats
->log_stats
.blocks
> 0);
322 reftable_writer_free(w
);
325 /* corrupt the data. */
328 block_source_from_strbuf(&source
, &buf
);
330 err
= init_reader(&rd
, &source
, "file.log");
333 err
= reftable_reader_seek_log(&rd
, &it
, "refname");
334 EXPECT(err
== REFTABLE_ZLIB_ERROR
);
336 reftable_iterator_destroy(&it
);
339 strbuf_release(&buf
);
343 static void test_table_read_write_sequential(void)
346 struct strbuf buf
= STRBUF_INIT
;
348 struct reftable_iterator it
= { NULL
};
349 struct reftable_block_source source
= { NULL
};
350 struct reftable_reader rd
= { NULL
};
354 write_table(&names
, &buf
, N
, 256, GIT_SHA1_FORMAT_ID
);
356 block_source_from_strbuf(&source
, &buf
);
358 err
= init_reader(&rd
, &source
, "file.ref");
361 err
= reftable_reader_seek_ref(&rd
, &it
, "");
365 struct reftable_ref_record ref
= { NULL
};
366 int r
= reftable_iterator_next_ref(&it
, &ref
);
371 EXPECT(0 == strcmp(names
[j
], ref
.refname
));
372 EXPECT(update_index
== ref
.update_index
);
375 reftable_ref_record_release(&ref
);
378 reftable_iterator_destroy(&it
);
379 strbuf_release(&buf
);
385 static void test_table_write_small_table(void)
388 struct strbuf buf
= STRBUF_INIT
;
390 write_table(&names
, &buf
, N
, 4096, GIT_SHA1_FORMAT_ID
);
391 EXPECT(buf
.len
< 200);
392 strbuf_release(&buf
);
396 static void test_table_read_api(void)
399 struct strbuf buf
= STRBUF_INIT
;
401 struct reftable_reader rd
= { NULL
};
402 struct reftable_block_source source
= { NULL
};
405 struct reftable_log_record log
= { NULL
};
406 struct reftable_iterator it
= { NULL
};
408 write_table(&names
, &buf
, N
, 256, GIT_SHA1_FORMAT_ID
);
410 block_source_from_strbuf(&source
, &buf
);
412 err
= init_reader(&rd
, &source
, "file.ref");
415 err
= reftable_reader_seek_ref(&rd
, &it
, names
[0]);
418 err
= reftable_iterator_next_log(&it
, &log
);
419 EXPECT(err
== REFTABLE_API_ERROR
);
421 strbuf_release(&buf
);
422 for (i
= 0; i
< N
; i
++) {
423 reftable_free(names
[i
]);
425 reftable_iterator_destroy(&it
);
426 reftable_free(names
);
428 strbuf_release(&buf
);
431 static void test_table_read_write_seek(int index
, int hash_id
)
434 struct strbuf buf
= STRBUF_INIT
;
436 struct reftable_reader rd
= { NULL
};
437 struct reftable_block_source source
= { NULL
};
441 struct reftable_iterator it
= { NULL
};
442 struct strbuf pastLast
= STRBUF_INIT
;
443 struct reftable_ref_record ref
= { NULL
};
445 write_table(&names
, &buf
, N
, 256, hash_id
);
447 block_source_from_strbuf(&source
, &buf
);
449 err
= init_reader(&rd
, &source
, "file.ref");
451 EXPECT(hash_id
== reftable_reader_hash_id(&rd
));
454 rd
.ref_offsets
.index_offset
= 0;
456 EXPECT(rd
.ref_offsets
.index_offset
> 0);
459 for (i
= 1; i
< N
; i
++) {
460 int err
= reftable_reader_seek_ref(&rd
, &it
, names
[i
]);
462 err
= reftable_iterator_next_ref(&it
, &ref
);
464 EXPECT(0 == strcmp(names
[i
], ref
.refname
));
465 EXPECT(REFTABLE_REF_VAL1
== ref
.value_type
);
466 EXPECT(i
== ref
.value
.val1
[0]);
468 reftable_ref_record_release(&ref
);
469 reftable_iterator_destroy(&it
);
472 strbuf_addstr(&pastLast
, names
[N
- 1]);
473 strbuf_addstr(&pastLast
, "/");
475 err
= reftable_reader_seek_ref(&rd
, &it
, pastLast
.buf
);
477 struct reftable_ref_record ref
= { NULL
};
478 int err
= reftable_iterator_next_ref(&it
, &ref
);
484 strbuf_release(&pastLast
);
485 reftable_iterator_destroy(&it
);
487 strbuf_release(&buf
);
488 for (i
= 0; i
< N
; i
++) {
489 reftable_free(names
[i
]);
491 reftable_free(names
);
495 static void test_table_read_write_seek_linear(void)
497 test_table_read_write_seek(0, GIT_SHA1_FORMAT_ID
);
500 static void test_table_read_write_seek_linear_sha256(void)
502 test_table_read_write_seek(0, GIT_SHA256_FORMAT_ID
);
505 static void test_table_read_write_seek_index(void)
507 test_table_read_write_seek(1, GIT_SHA1_FORMAT_ID
);
510 static void test_table_refs_for(int indexed
)
513 char **want_names
= reftable_calloc(N
+ 1, sizeof(*want_names
));
514 int want_names_len
= 0;
515 uint8_t want_hash
[GIT_SHA1_RAWSZ
];
517 struct reftable_write_options opts
= {
520 struct reftable_ref_record ref
= { NULL
};
524 struct reftable_reader rd
;
525 struct reftable_block_source source
= { NULL
};
527 struct strbuf buf
= STRBUF_INIT
;
528 struct reftable_writer
*w
=
529 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
531 struct reftable_iterator it
= { NULL
};
534 set_test_hash(want_hash
, 4);
536 for (i
= 0; i
< N
; i
++) {
537 uint8_t hash
[GIT_SHA1_RAWSZ
];
538 char fill
[51] = { 0 };
540 struct reftable_ref_record ref
= { NULL
};
542 memset(hash
, i
, sizeof(hash
));
543 memset(fill
, 'x', 50);
544 /* Put the variable part in the start */
545 snprintf(name
, sizeof(name
), "br%02d%s", i
, fill
);
549 ref
.value_type
= REFTABLE_REF_VAL2
;
550 set_test_hash(ref
.value
.val2
.value
, i
/ 4);
551 set_test_hash(ref
.value
.val2
.target_value
, 3 + i
/ 4);
553 /* 80 bytes / entry, so 3 entries per block. Yields 17
556 n
= reftable_writer_add_ref(w
, &ref
);
559 if (!memcmp(ref
.value
.val2
.value
, want_hash
, GIT_SHA1_RAWSZ
) ||
560 !memcmp(ref
.value
.val2
.target_value
, want_hash
, GIT_SHA1_RAWSZ
)) {
561 want_names
[want_names_len
++] = xstrdup(name
);
565 n
= reftable_writer_close(w
);
568 reftable_writer_free(w
);
571 block_source_from_strbuf(&source
, &buf
);
573 err
= init_reader(&rd
, &source
, "file.ref");
576 rd
.obj_offsets
.is_present
= 0;
579 err
= reftable_reader_seek_ref(&rd
, &it
, "");
581 reftable_iterator_destroy(&it
);
583 err
= reftable_reader_refs_for(&rd
, &it
, want_hash
);
588 int err
= reftable_iterator_next_ref(&it
, &ref
);
594 EXPECT(j
< want_names_len
);
595 EXPECT(0 == strcmp(ref
.refname
, want_names
[j
]));
597 reftable_ref_record_release(&ref
);
599 EXPECT(j
== want_names_len
);
601 strbuf_release(&buf
);
602 free_names(want_names
);
603 reftable_iterator_destroy(&it
);
607 static void test_table_refs_for_no_index(void)
609 test_table_refs_for(0);
612 static void test_table_refs_for_obj_index(void)
614 test_table_refs_for(1);
617 static void test_write_empty_table(void)
619 struct reftable_write_options opts
= { 0 };
620 struct strbuf buf
= STRBUF_INIT
;
621 struct reftable_writer
*w
=
622 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
623 struct reftable_block_source source
= { NULL
};
624 struct reftable_reader
*rd
= NULL
;
625 struct reftable_ref_record rec
= { NULL
};
626 struct reftable_iterator it
= { NULL
};
629 reftable_writer_set_limits(w
, 1, 1);
631 err
= reftable_writer_close(w
);
632 EXPECT(err
== REFTABLE_EMPTY_TABLE_ERROR
);
633 reftable_writer_free(w
);
635 EXPECT(buf
.len
== header_size(1) + footer_size(1));
637 block_source_from_strbuf(&source
, &buf
);
639 err
= reftable_new_reader(&rd
, &source
, "filename");
642 err
= reftable_reader_seek_ref(rd
, &it
, "");
645 err
= reftable_iterator_next_ref(&it
, &rec
);
648 reftable_iterator_destroy(&it
);
649 reftable_reader_free(rd
);
650 strbuf_release(&buf
);
653 static void test_write_object_id_min_length(void)
655 struct reftable_write_options opts
= {
658 struct strbuf buf
= STRBUF_INIT
;
659 struct reftable_writer
*w
=
660 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
661 struct reftable_ref_record ref
= {
663 .value_type
= REFTABLE_REF_VAL1
,
669 reftable_writer_set_limits(w
, 1, 1);
671 /* Write the same hash in many refs. If there is only 1 hash, the
672 * disambiguating prefix is length 0 */
673 for (i
= 0; i
< 256; i
++) {
675 snprintf(name
, sizeof(name
), "ref%05d", i
);
677 err
= reftable_writer_add_ref(w
, &ref
);
681 err
= reftable_writer_close(w
);
683 EXPECT(reftable_writer_stats(w
)->object_id_len
== 2);
684 reftable_writer_free(w
);
685 strbuf_release(&buf
);
688 static void test_write_object_id_length(void)
690 struct reftable_write_options opts
= {
693 struct strbuf buf
= STRBUF_INIT
;
694 struct reftable_writer
*w
=
695 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
696 struct reftable_ref_record ref
= {
698 .value_type
= REFTABLE_REF_VAL1
,
704 reftable_writer_set_limits(w
, 1, 1);
706 /* Write the same hash in many refs. If there is only 1 hash, the
707 * disambiguating prefix is length 0 */
708 for (i
= 0; i
< 256; i
++) {
710 snprintf(name
, sizeof(name
), "ref%05d", i
);
712 ref
.value
.val1
[15] = i
;
713 err
= reftable_writer_add_ref(w
, &ref
);
717 err
= reftable_writer_close(w
);
719 EXPECT(reftable_writer_stats(w
)->object_id_len
== 16);
720 reftable_writer_free(w
);
721 strbuf_release(&buf
);
724 static void test_write_empty_key(void)
726 struct reftable_write_options opts
= { 0 };
727 struct strbuf buf
= STRBUF_INIT
;
728 struct reftable_writer
*w
=
729 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
730 struct reftable_ref_record ref
= {
733 .value_type
= REFTABLE_REF_DELETION
,
737 reftable_writer_set_limits(w
, 1, 1);
738 err
= reftable_writer_add_ref(w
, &ref
);
739 EXPECT(err
== REFTABLE_API_ERROR
);
741 err
= reftable_writer_close(w
);
742 EXPECT(err
== REFTABLE_EMPTY_TABLE_ERROR
);
743 reftable_writer_free(w
);
744 strbuf_release(&buf
);
747 static void test_write_key_order(void)
749 struct reftable_write_options opts
= { 0 };
750 struct strbuf buf
= STRBUF_INIT
;
751 struct reftable_writer
*w
=
752 reftable_new_writer(&strbuf_add_void
, &noop_flush
, &buf
, &opts
);
753 struct reftable_ref_record refs
[2] = {
757 .value_type
= REFTABLE_REF_SYMREF
,
764 .value_type
= REFTABLE_REF_SYMREF
,
772 reftable_writer_set_limits(w
, 1, 1);
773 err
= reftable_writer_add_ref(w
, &refs
[0]);
775 err
= reftable_writer_add_ref(w
, &refs
[1]);
776 EXPECT(err
== REFTABLE_API_ERROR
);
777 reftable_writer_close(w
);
778 reftable_writer_free(w
);
779 strbuf_release(&buf
);
782 static void test_write_multiple_indices(void)
784 struct reftable_write_options opts
= {
787 struct strbuf writer_buf
= STRBUF_INIT
, buf
= STRBUF_INIT
;
788 struct reftable_block_source source
= { 0 };
789 struct reftable_iterator it
= { 0 };
790 const struct reftable_stats
*stats
;
791 struct reftable_writer
*writer
;
792 struct reftable_reader
*reader
;
795 writer
= reftable_new_writer(&strbuf_add_void
, &noop_flush
, &writer_buf
, &opts
);
796 reftable_writer_set_limits(writer
, 1, 1);
797 for (i
= 0; i
< 100; i
++) {
798 struct reftable_ref_record ref
= {
800 .value_type
= REFTABLE_REF_VAL1
,
805 strbuf_addf(&buf
, "refs/heads/%04d", i
);
806 ref
.refname
= buf
.buf
,
808 err
= reftable_writer_add_ref(writer
, &ref
);
812 for (i
= 0; i
< 100; i
++) {
813 struct reftable_log_record log
= {
815 .value_type
= REFTABLE_LOG_UPDATE
,
823 strbuf_addf(&buf
, "refs/heads/%04d", i
);
824 log
.refname
= buf
.buf
,
826 err
= reftable_writer_add_log(writer
, &log
);
830 reftable_writer_close(writer
);
833 * The written data should be sufficiently large to result in indices
834 * for each of the block types.
836 stats
= reftable_writer_stats(writer
);
837 EXPECT(stats
->ref_stats
.index_offset
> 0);
838 EXPECT(stats
->obj_stats
.index_offset
> 0);
839 EXPECT(stats
->log_stats
.index_offset
> 0);
841 block_source_from_strbuf(&source
, &writer_buf
);
842 err
= reftable_new_reader(&reader
, &source
, "filename");
846 * Seeking the log uses the log index now. In case there is any
847 * confusion regarding indices we would notice here.
849 err
= reftable_reader_seek_log(reader
, &it
, "");
852 reftable_iterator_destroy(&it
);
853 reftable_writer_free(writer
);
854 reftable_reader_free(reader
);
855 strbuf_release(&writer_buf
);
856 strbuf_release(&buf
);
859 static void test_write_multi_level_index(void)
861 struct reftable_write_options opts
= {
864 struct strbuf writer_buf
= STRBUF_INIT
, buf
= STRBUF_INIT
;
865 struct reftable_block_source source
= { 0 };
866 struct reftable_iterator it
= { 0 };
867 const struct reftable_stats
*stats
;
868 struct reftable_writer
*writer
;
869 struct reftable_reader
*reader
;
872 writer
= reftable_new_writer(&strbuf_add_void
, &noop_flush
, &writer_buf
, &opts
);
873 reftable_writer_set_limits(writer
, 1, 1);
874 for (size_t i
= 0; i
< 200; i
++) {
875 struct reftable_ref_record ref
= {
877 .value_type
= REFTABLE_REF_VAL1
,
882 strbuf_addf(&buf
, "refs/heads/%03" PRIuMAX
, (uintmax_t)i
);
883 ref
.refname
= buf
.buf
,
885 err
= reftable_writer_add_ref(writer
, &ref
);
888 reftable_writer_close(writer
);
891 * The written refs should be sufficiently large to result in a
894 stats
= reftable_writer_stats(writer
);
895 EXPECT(stats
->ref_stats
.max_index_level
== 2);
897 block_source_from_strbuf(&source
, &writer_buf
);
898 err
= reftable_new_reader(&reader
, &source
, "filename");
902 * Seeking the last ref should work as expected.
904 err
= reftable_reader_seek_ref(reader
, &it
, "refs/heads/199");
907 reftable_iterator_destroy(&it
);
908 reftable_writer_free(writer
);
909 reftable_reader_free(reader
);
910 strbuf_release(&writer_buf
);
911 strbuf_release(&buf
);
914 static void test_corrupt_table_empty(void)
916 struct strbuf buf
= STRBUF_INIT
;
917 struct reftable_block_source source
= { NULL
};
918 struct reftable_reader rd
= { NULL
};
921 block_source_from_strbuf(&source
, &buf
);
922 err
= init_reader(&rd
, &source
, "file.log");
923 EXPECT(err
== REFTABLE_FORMAT_ERROR
);
926 static void test_corrupt_table(void)
928 uint8_t zeros
[1024] = { 0 };
929 struct strbuf buf
= STRBUF_INIT
;
930 struct reftable_block_source source
= { NULL
};
931 struct reftable_reader rd
= { NULL
};
933 strbuf_add(&buf
, zeros
, sizeof(zeros
));
935 block_source_from_strbuf(&source
, &buf
);
936 err
= init_reader(&rd
, &source
, "file.log");
937 EXPECT(err
== REFTABLE_FORMAT_ERROR
);
938 strbuf_release(&buf
);
941 int readwrite_test_main(int argc
, const char *argv
[])
943 RUN_TEST(test_log_zlib_corruption
);
944 RUN_TEST(test_corrupt_table
);
945 RUN_TEST(test_corrupt_table_empty
);
946 RUN_TEST(test_log_write_read
);
947 RUN_TEST(test_write_key_order
);
948 RUN_TEST(test_table_read_write_seek_linear_sha256
);
949 RUN_TEST(test_log_buffer_size
);
950 RUN_TEST(test_table_write_small_table
);
951 RUN_TEST(test_buffer
);
952 RUN_TEST(test_table_read_api
);
953 RUN_TEST(test_table_read_write_sequential
);
954 RUN_TEST(test_table_read_write_seek_linear
);
955 RUN_TEST(test_table_read_write_seek_index
);
956 RUN_TEST(test_table_refs_for_no_index
);
957 RUN_TEST(test_table_refs_for_obj_index
);
958 RUN_TEST(test_write_empty_key
);
959 RUN_TEST(test_write_empty_table
);
960 RUN_TEST(test_log_overflow
);
961 RUN_TEST(test_write_object_id_length
);
962 RUN_TEST(test_write_object_id_min_length
);
963 RUN_TEST(test_write_multiple_indices
);
964 RUN_TEST(test_write_multi_level_index
);