aboutsummaryrefslogtreecommitdiffstats
path: root/reftable/readwrite_test.c
diff options
context:
space:
mode:
Diffstat (limited to 'reftable/readwrite_test.c')
-rw-r--r--reftable/readwrite_test.c979
1 files changed, 0 insertions, 979 deletions
diff --git a/reftable/readwrite_test.c b/reftable/readwrite_test.c
deleted file mode 100644
index f411abfe9c..0000000000
--- a/reftable/readwrite_test.c
+++ /dev/null
@@ -1,979 +0,0 @@
-/*
-Copyright 2020 Google LLC
-
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file or at
-https://developers.google.com/open-source/licenses/bsd
-*/
-
-#include "system.h"
-
-#include "basics.h"
-#include "block.h"
-#include "blocksource.h"
-#include "reader.h"
-#include "record.h"
-#include "test_framework.h"
-#include "reftable-tests.h"
-#include "reftable-writer.h"
-
-static const int update_index = 5;
-
-static void test_buffer(void)
-{
- struct strbuf buf = STRBUF_INIT;
- struct reftable_block_source source = { NULL };
- struct reftable_block out = { NULL };
- int n;
- uint8_t in[] = "hello";
- strbuf_add(&buf, in, sizeof(in));
- block_source_from_strbuf(&source, &buf);
- EXPECT(block_source_size(&source) == 6);
- n = block_source_read_block(&source, &out, 0, sizeof(in));
- EXPECT(n == sizeof(in));
- EXPECT(!memcmp(in, out.data, n));
- reftable_block_done(&out);
-
- n = block_source_read_block(&source, &out, 1, 2);
- EXPECT(n == 2);
- EXPECT(!memcmp(out.data, "el", 2));
-
- reftable_block_done(&out);
- block_source_close(&source);
- strbuf_release(&buf);
-}
-
-static void write_table(char ***names, struct strbuf *buf, int N,
- int block_size, uint32_t hash_id)
-{
- struct reftable_write_options opts = {
- .block_size = block_size,
- .hash_id = hash_id,
- };
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, buf, &opts);
- struct reftable_ref_record ref = { NULL };
- int i = 0, n;
- struct reftable_log_record log = { NULL };
- const struct reftable_stats *stats = NULL;
-
- REFTABLE_CALLOC_ARRAY(*names, N + 1);
-
- reftable_writer_set_limits(w, update_index, update_index);
- for (i = 0; i < N; i++) {
- char name[100];
- int n;
-
- snprintf(name, sizeof(name), "refs/heads/branch%02d", i);
-
- ref.refname = name;
- ref.update_index = update_index;
- ref.value_type = REFTABLE_REF_VAL1;
- set_test_hash(ref.value.val1, i);
- (*names)[i] = xstrdup(name);
-
- n = reftable_writer_add_ref(w, &ref);
- EXPECT(n == 0);
- }
-
- for (i = 0; i < N; i++) {
- char name[100];
- int n;
-
- snprintf(name, sizeof(name), "refs/heads/branch%02d", i);
-
- log.refname = name;
- log.update_index = update_index;
- log.value_type = REFTABLE_LOG_UPDATE;
- set_test_hash(log.value.update.new_hash, i);
- log.value.update.message = (char *) "message";
-
- n = reftable_writer_add_log(w, &log);
- EXPECT(n == 0);
- }
-
- n = reftable_writer_close(w);
- EXPECT(n == 0);
-
- stats = reftable_writer_stats(w);
- for (i = 0; i < stats->ref_stats.blocks; i++) {
- int off = i * opts.block_size;
- if (off == 0) {
- off = header_size(
- (hash_id == GIT_SHA256_FORMAT_ID) ? 2 : 1);
- }
- EXPECT(buf->buf[off] == 'r');
- }
-
- EXPECT(stats->log_stats.blocks > 0);
- reftable_writer_free(w);
-}
-
-static void test_log_buffer_size(void)
-{
- struct strbuf buf = STRBUF_INIT;
- struct reftable_write_options opts = {
- .block_size = 4096,
- };
- int err;
- int i;
- struct reftable_log_record
- log = { .refname = (char *) "refs/heads/master",
- .update_index = 0xa,
- .value_type = REFTABLE_LOG_UPDATE,
- .value = { .update = {
- .name = (char *) "Han-Wen Nienhuys",
- .email = (char *) "hanwen@google.com",
- .tz_offset = 100,
- .time = 0x5e430672,
- .message = (char *) "commit: 9\n",
- } } };
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
-
- /* This tests buffer extension for log compression. Must use a random
- hash, to ensure that the compressed part is larger than the original.
- */
- for (i = 0; i < GIT_SHA1_RAWSZ; i++) {
- log.value.update.old_hash[i] = (uint8_t)(git_rand() % 256);
- log.value.update.new_hash[i] = (uint8_t)(git_rand() % 256);
- }
- reftable_writer_set_limits(w, update_index, update_index);
- err = reftable_writer_add_log(w, &log);
- EXPECT_ERR(err);
- err = reftable_writer_close(w);
- EXPECT_ERR(err);
- reftable_writer_free(w);
- strbuf_release(&buf);
-}
-
-static void test_log_overflow(void)
-{
- struct strbuf buf = STRBUF_INIT;
- char msg[256] = { 0 };
- struct reftable_write_options opts = {
- .block_size = ARRAY_SIZE(msg),
- };
- int err;
- struct reftable_log_record log = {
- .refname = (char *) "refs/heads/master",
- .update_index = 0xa,
- .value_type = REFTABLE_LOG_UPDATE,
- .value = {
- .update = {
- .old_hash = { 1 },
- .new_hash = { 2 },
- .name = (char *) "Han-Wen Nienhuys",
- .email = (char *) "hanwen@google.com",
- .tz_offset = 100,
- .time = 0x5e430672,
- .message = msg,
- },
- },
- };
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
-
- memset(msg, 'x', sizeof(msg) - 1);
- reftable_writer_set_limits(w, update_index, update_index);
- err = reftable_writer_add_log(w, &log);
- EXPECT(err == REFTABLE_ENTRY_TOO_BIG_ERROR);
- reftable_writer_free(w);
- strbuf_release(&buf);
-}
-
-static void test_log_write_read(void)
-{
- int N = 2;
- char **names = reftable_calloc(N + 1, sizeof(*names));
- int err;
- struct reftable_write_options opts = {
- .block_size = 256,
- };
- struct reftable_ref_record ref = { NULL };
- int i = 0;
- struct reftable_log_record log = { NULL };
- int n;
- struct reftable_iterator it = { NULL };
- struct reftable_reader rd = { NULL };
- struct reftable_block_source source = { NULL };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- const struct reftable_stats *stats = NULL;
- reftable_writer_set_limits(w, 0, N);
- for (i = 0; i < N; i++) {
- char name[256];
- struct reftable_ref_record ref = { NULL };
- snprintf(name, sizeof(name), "b%02d%0*d", i, 130, 7);
- names[i] = xstrdup(name);
- ref.refname = name;
- ref.update_index = i;
-
- err = reftable_writer_add_ref(w, &ref);
- EXPECT_ERR(err);
- }
- for (i = 0; i < N; i++) {
- struct reftable_log_record log = { NULL };
-
- log.refname = names[i];
- log.update_index = i;
- log.value_type = REFTABLE_LOG_UPDATE;
- set_test_hash(log.value.update.old_hash, i);
- set_test_hash(log.value.update.new_hash, i + 1);
-
- err = reftable_writer_add_log(w, &log);
- EXPECT_ERR(err);
- }
-
- n = reftable_writer_close(w);
- EXPECT(n == 0);
-
- stats = reftable_writer_stats(w);
- EXPECT(stats->log_stats.blocks > 0);
- reftable_writer_free(w);
- w = NULL;
-
- block_source_from_strbuf(&source, &buf);
-
- err = init_reader(&rd, &source, "file.log");
- EXPECT_ERR(err);
-
- reftable_reader_init_ref_iterator(&rd, &it);
-
- err = reftable_iterator_seek_ref(&it, names[N - 1]);
- EXPECT_ERR(err);
-
- err = reftable_iterator_next_ref(&it, &ref);
- EXPECT_ERR(err);
-
- /* end of iteration. */
- err = reftable_iterator_next_ref(&it, &ref);
- EXPECT(0 < err);
-
- reftable_iterator_destroy(&it);
- reftable_ref_record_release(&ref);
-
- reftable_reader_init_log_iterator(&rd, &it);
-
- err = reftable_iterator_seek_log(&it, "");
- EXPECT_ERR(err);
-
- i = 0;
- while (1) {
- int err = reftable_iterator_next_log(&it, &log);
- if (err > 0) {
- break;
- }
-
- EXPECT_ERR(err);
- EXPECT_STREQ(names[i], log.refname);
- EXPECT(i == log.update_index);
- i++;
- reftable_log_record_release(&log);
- }
-
- EXPECT(i == N);
- reftable_iterator_destroy(&it);
-
- /* cleanup. */
- strbuf_release(&buf);
- free_names(names);
- reader_close(&rd);
-}
-
-static void test_log_zlib_corruption(void)
-{
- struct reftable_write_options opts = {
- .block_size = 256,
- };
- struct reftable_iterator it = { 0 };
- struct reftable_reader rd = { 0 };
- struct reftable_block_source source = { 0 };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- const struct reftable_stats *stats = NULL;
- char message[100] = { 0 };
- int err, i, n;
- struct reftable_log_record log = {
- .refname = (char *) "refname",
- .value_type = REFTABLE_LOG_UPDATE,
- .value = {
- .update = {
- .new_hash = { 1 },
- .old_hash = { 2 },
- .name = (char *) "My Name",
- .email = (char *) "myname@invalid",
- .message = message,
- },
- },
- };
-
- for (i = 0; i < sizeof(message) - 1; i++)
- message[i] = (uint8_t)(git_rand() % 64 + ' ');
-
- reftable_writer_set_limits(w, 1, 1);
-
- err = reftable_writer_add_log(w, &log);
- EXPECT_ERR(err);
-
- n = reftable_writer_close(w);
- EXPECT(n == 0);
-
- stats = reftable_writer_stats(w);
- EXPECT(stats->log_stats.blocks > 0);
- reftable_writer_free(w);
- w = NULL;
-
- /* corrupt the data. */
- buf.buf[50] ^= 0x99;
-
- block_source_from_strbuf(&source, &buf);
-
- err = init_reader(&rd, &source, "file.log");
- EXPECT_ERR(err);
-
- reftable_reader_init_log_iterator(&rd, &it);
- err = reftable_iterator_seek_log(&it, "refname");
- EXPECT(err == REFTABLE_ZLIB_ERROR);
-
- reftable_iterator_destroy(&it);
-
- /* cleanup. */
- strbuf_release(&buf);
- reader_close(&rd);
-}
-
-static void test_table_read_write_sequential(void)
-{
- char **names;
- struct strbuf buf = STRBUF_INIT;
- int N = 50;
- struct reftable_iterator it = { NULL };
- struct reftable_block_source source = { NULL };
- struct reftable_reader rd = { NULL };
- int err = 0;
- int j = 0;
-
- write_table(&names, &buf, N, 256, GIT_SHA1_FORMAT_ID);
-
- block_source_from_strbuf(&source, &buf);
-
- err = init_reader(&rd, &source, "file.ref");
- EXPECT_ERR(err);
-
- reftable_reader_init_ref_iterator(&rd, &it);
- err = reftable_iterator_seek_ref(&it, "");
- EXPECT_ERR(err);
-
- while (1) {
- struct reftable_ref_record ref = { NULL };
- int r = reftable_iterator_next_ref(&it, &ref);
- EXPECT(r >= 0);
- if (r > 0) {
- break;
- }
- EXPECT(0 == strcmp(names[j], ref.refname));
- EXPECT(update_index == ref.update_index);
-
- j++;
- reftable_ref_record_release(&ref);
- }
- EXPECT(j == N);
- reftable_iterator_destroy(&it);
- strbuf_release(&buf);
- free_names(names);
-
- reader_close(&rd);
-}
-
-static void test_table_write_small_table(void)
-{
- char **names;
- struct strbuf buf = STRBUF_INIT;
- int N = 1;
- write_table(&names, &buf, N, 4096, GIT_SHA1_FORMAT_ID);
- EXPECT(buf.len < 200);
- strbuf_release(&buf);
- free_names(names);
-}
-
-static void test_table_read_api(void)
-{
- char **names;
- struct strbuf buf = STRBUF_INIT;
- int N = 50;
- struct reftable_reader rd = { NULL };
- struct reftable_block_source source = { NULL };
- int err;
- int i;
- struct reftable_log_record log = { NULL };
- struct reftable_iterator it = { NULL };
-
- write_table(&names, &buf, N, 256, GIT_SHA1_FORMAT_ID);
-
- block_source_from_strbuf(&source, &buf);
-
- err = init_reader(&rd, &source, "file.ref");
- EXPECT_ERR(err);
-
- reftable_reader_init_ref_iterator(&rd, &it);
- err = reftable_iterator_seek_ref(&it, names[0]);
- EXPECT_ERR(err);
-
- err = reftable_iterator_next_log(&it, &log);
- EXPECT(err == REFTABLE_API_ERROR);
-
- strbuf_release(&buf);
- for (i = 0; i < N; i++) {
- reftable_free(names[i]);
- }
- reftable_iterator_destroy(&it);
- reftable_free(names);
- reader_close(&rd);
- strbuf_release(&buf);
-}
-
-static void test_table_read_write_seek(int index, int hash_id)
-{
- char **names;
- struct strbuf buf = STRBUF_INIT;
- int N = 50;
- struct reftable_reader rd = { NULL };
- struct reftable_block_source source = { NULL };
- int err;
- int i = 0;
-
- struct reftable_iterator it = { NULL };
- struct strbuf pastLast = STRBUF_INIT;
- struct reftable_ref_record ref = { NULL };
-
- write_table(&names, &buf, N, 256, hash_id);
-
- block_source_from_strbuf(&source, &buf);
-
- err = init_reader(&rd, &source, "file.ref");
- EXPECT_ERR(err);
- EXPECT(hash_id == reftable_reader_hash_id(&rd));
-
- if (!index) {
- rd.ref_offsets.index_offset = 0;
- } else {
- EXPECT(rd.ref_offsets.index_offset > 0);
- }
-
- for (i = 1; i < N; i++) {
- reftable_reader_init_ref_iterator(&rd, &it);
- err = reftable_iterator_seek_ref(&it, names[i]);
- EXPECT_ERR(err);
- err = reftable_iterator_next_ref(&it, &ref);
- EXPECT_ERR(err);
- EXPECT(0 == strcmp(names[i], ref.refname));
- EXPECT(REFTABLE_REF_VAL1 == ref.value_type);
- EXPECT(i == ref.value.val1[0]);
-
- reftable_ref_record_release(&ref);
- reftable_iterator_destroy(&it);
- }
-
- strbuf_addstr(&pastLast, names[N - 1]);
- strbuf_addstr(&pastLast, "/");
-
- reftable_reader_init_ref_iterator(&rd, &it);
- err = reftable_iterator_seek_ref(&it, pastLast.buf);
- if (err == 0) {
- struct reftable_ref_record ref = { NULL };
- int err = reftable_iterator_next_ref(&it, &ref);
- EXPECT(err > 0);
- } else {
- EXPECT(err > 0);
- }
-
- strbuf_release(&pastLast);
- reftable_iterator_destroy(&it);
-
- strbuf_release(&buf);
- for (i = 0; i < N; i++) {
- reftable_free(names[i]);
- }
- reftable_free(names);
- reader_close(&rd);
-}
-
-static void test_table_read_write_seek_linear(void)
-{
- test_table_read_write_seek(0, GIT_SHA1_FORMAT_ID);
-}
-
-static void test_table_read_write_seek_linear_sha256(void)
-{
- test_table_read_write_seek(0, GIT_SHA256_FORMAT_ID);
-}
-
-static void test_table_read_write_seek_index(void)
-{
- test_table_read_write_seek(1, GIT_SHA1_FORMAT_ID);
-}
-
-static void test_table_refs_for(int indexed)
-{
- int N = 50;
- char **want_names = reftable_calloc(N + 1, sizeof(*want_names));
- int want_names_len = 0;
- uint8_t want_hash[GIT_SHA1_RAWSZ];
-
- struct reftable_write_options opts = {
- .block_size = 256,
- };
- struct reftable_ref_record ref = { NULL };
- int i = 0;
- int n;
- int err;
- struct reftable_reader rd;
- struct reftable_block_source source = { NULL };
-
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
-
- struct reftable_iterator it = { NULL };
- int j;
-
- set_test_hash(want_hash, 4);
-
- for (i = 0; i < N; i++) {
- uint8_t hash[GIT_SHA1_RAWSZ];
- char fill[51] = { 0 };
- char name[100];
- struct reftable_ref_record ref = { NULL };
-
- memset(hash, i, sizeof(hash));
- memset(fill, 'x', 50);
- /* Put the variable part in the start */
- snprintf(name, sizeof(name), "br%02d%s", i, fill);
- name[40] = 0;
- ref.refname = name;
-
- ref.value_type = REFTABLE_REF_VAL2;
- set_test_hash(ref.value.val2.value, i / 4);
- set_test_hash(ref.value.val2.target_value, 3 + i / 4);
-
- /* 80 bytes / entry, so 3 entries per block. Yields 17
- */
- /* blocks. */
- n = reftable_writer_add_ref(w, &ref);
- EXPECT(n == 0);
-
- if (!memcmp(ref.value.val2.value, want_hash, GIT_SHA1_RAWSZ) ||
- !memcmp(ref.value.val2.target_value, want_hash, GIT_SHA1_RAWSZ)) {
- want_names[want_names_len++] = xstrdup(name);
- }
- }
-
- n = reftable_writer_close(w);
- EXPECT(n == 0);
-
- reftable_writer_free(w);
- w = NULL;
-
- block_source_from_strbuf(&source, &buf);
-
- err = init_reader(&rd, &source, "file.ref");
- EXPECT_ERR(err);
- if (!indexed) {
- rd.obj_offsets.is_present = 0;
- }
-
- reftable_reader_init_ref_iterator(&rd, &it);
- err = reftable_iterator_seek_ref(&it, "");
- EXPECT_ERR(err);
- reftable_iterator_destroy(&it);
-
- err = reftable_reader_refs_for(&rd, &it, want_hash);
- EXPECT_ERR(err);
-
- j = 0;
- while (1) {
- int err = reftable_iterator_next_ref(&it, &ref);
- EXPECT(err >= 0);
- if (err > 0) {
- break;
- }
-
- EXPECT(j < want_names_len);
- EXPECT(0 == strcmp(ref.refname, want_names[j]));
- j++;
- reftable_ref_record_release(&ref);
- }
- EXPECT(j == want_names_len);
-
- strbuf_release(&buf);
- free_names(want_names);
- reftable_iterator_destroy(&it);
- reader_close(&rd);
-}
-
-static void test_table_refs_for_no_index(void)
-{
- test_table_refs_for(0);
-}
-
-static void test_table_refs_for_obj_index(void)
-{
- test_table_refs_for(1);
-}
-
-static void test_write_empty_table(void)
-{
- struct reftable_write_options opts = { 0 };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- struct reftable_block_source source = { NULL };
- struct reftable_reader *rd = NULL;
- struct reftable_ref_record rec = { NULL };
- struct reftable_iterator it = { NULL };
- int err;
-
- reftable_writer_set_limits(w, 1, 1);
-
- err = reftable_writer_close(w);
- EXPECT(err == REFTABLE_EMPTY_TABLE_ERROR);
- reftable_writer_free(w);
-
- EXPECT(buf.len == header_size(1) + footer_size(1));
-
- block_source_from_strbuf(&source, &buf);
-
- err = reftable_new_reader(&rd, &source, "filename");
- EXPECT_ERR(err);
-
- reftable_reader_init_ref_iterator(rd, &it);
- err = reftable_iterator_seek_ref(&it, "");
- EXPECT_ERR(err);
-
- err = reftable_iterator_next_ref(&it, &rec);
- EXPECT(err > 0);
-
- reftable_iterator_destroy(&it);
- reftable_reader_free(rd);
- strbuf_release(&buf);
-}
-
-static void test_write_object_id_min_length(void)
-{
- struct reftable_write_options opts = {
- .block_size = 75,
- };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- struct reftable_ref_record ref = {
- .update_index = 1,
- .value_type = REFTABLE_REF_VAL1,
- .value.val1 = {42},
- };
- int err;
- int i;
-
- reftable_writer_set_limits(w, 1, 1);
-
- /* Write the same hash in many refs. If there is only 1 hash, the
- * disambiguating prefix is length 0 */
- for (i = 0; i < 256; i++) {
- char name[256];
- snprintf(name, sizeof(name), "ref%05d", i);
- ref.refname = name;
- err = reftable_writer_add_ref(w, &ref);
- EXPECT_ERR(err);
- }
-
- err = reftable_writer_close(w);
- EXPECT_ERR(err);
- EXPECT(reftable_writer_stats(w)->object_id_len == 2);
- reftable_writer_free(w);
- strbuf_release(&buf);
-}
-
-static void test_write_object_id_length(void)
-{
- struct reftable_write_options opts = {
- .block_size = 75,
- };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- struct reftable_ref_record ref = {
- .update_index = 1,
- .value_type = REFTABLE_REF_VAL1,
- .value.val1 = {42},
- };
- int err;
- int i;
-
- reftable_writer_set_limits(w, 1, 1);
-
- /* Write the same hash in many refs. If there is only 1 hash, the
- * disambiguating prefix is length 0 */
- for (i = 0; i < 256; i++) {
- char name[256];
- snprintf(name, sizeof(name), "ref%05d", i);
- ref.refname = name;
- ref.value.val1[15] = i;
- err = reftable_writer_add_ref(w, &ref);
- EXPECT_ERR(err);
- }
-
- err = reftable_writer_close(w);
- EXPECT_ERR(err);
- EXPECT(reftable_writer_stats(w)->object_id_len == 16);
- reftable_writer_free(w);
- strbuf_release(&buf);
-}
-
-static void test_write_empty_key(void)
-{
- struct reftable_write_options opts = { 0 };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- struct reftable_ref_record ref = {
- .refname = (char *) "",
- .update_index = 1,
- .value_type = REFTABLE_REF_DELETION,
- };
- int err;
-
- reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_add_ref(w, &ref);
- EXPECT(err == REFTABLE_API_ERROR);
-
- err = reftable_writer_close(w);
- EXPECT(err == REFTABLE_EMPTY_TABLE_ERROR);
- reftable_writer_free(w);
- strbuf_release(&buf);
-}
-
-static void test_write_key_order(void)
-{
- struct reftable_write_options opts = { 0 };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_writer *w =
- reftable_new_writer(&strbuf_add_void, &noop_flush, &buf, &opts);
- struct reftable_ref_record refs[2] = {
- {
- .refname = (char *) "b",
- .update_index = 1,
- .value_type = REFTABLE_REF_SYMREF,
- .value = {
- .symref = (char *) "target",
- },
- }, {
- .refname = (char *) "a",
- .update_index = 1,
- .value_type = REFTABLE_REF_SYMREF,
- .value = {
- .symref = (char *) "target",
- },
- }
- };
- int err;
-
- reftable_writer_set_limits(w, 1, 1);
- err = reftable_writer_add_ref(w, &refs[0]);
- EXPECT_ERR(err);
- err = reftable_writer_add_ref(w, &refs[1]);
- EXPECT(err == REFTABLE_API_ERROR);
- reftable_writer_close(w);
- reftable_writer_free(w);
- strbuf_release(&buf);
-}
-
-static void test_write_multiple_indices(void)
-{
- struct reftable_write_options opts = {
- .block_size = 100,
- };
- struct strbuf writer_buf = STRBUF_INIT, buf = STRBUF_INIT;
- struct reftable_block_source source = { 0 };
- struct reftable_iterator it = { 0 };
- const struct reftable_stats *stats;
- struct reftable_writer *writer;
- struct reftable_reader *reader;
- int err, i;
-
- writer = reftable_new_writer(&strbuf_add_void, &noop_flush, &writer_buf, &opts);
- reftable_writer_set_limits(writer, 1, 1);
- for (i = 0; i < 100; i++) {
- struct reftable_ref_record ref = {
- .update_index = 1,
- .value_type = REFTABLE_REF_VAL1,
- .value.val1 = {i},
- };
-
- strbuf_reset(&buf);
- strbuf_addf(&buf, "refs/heads/%04d", i);
- ref.refname = buf.buf,
-
- err = reftable_writer_add_ref(writer, &ref);
- EXPECT_ERR(err);
- }
-
- for (i = 0; i < 100; i++) {
- struct reftable_log_record log = {
- .update_index = 1,
- .value_type = REFTABLE_LOG_UPDATE,
- .value.update = {
- .old_hash = { i },
- .new_hash = { i },
- },
- };
-
- strbuf_reset(&buf);
- strbuf_addf(&buf, "refs/heads/%04d", i);
- log.refname = buf.buf,
-
- err = reftable_writer_add_log(writer, &log);
- EXPECT_ERR(err);
- }
-
- reftable_writer_close(writer);
-
- /*
- * The written data should be sufficiently large to result in indices
- * for each of the block types.
- */
- stats = reftable_writer_stats(writer);
- EXPECT(stats->ref_stats.index_offset > 0);
- EXPECT(stats->obj_stats.index_offset > 0);
- EXPECT(stats->log_stats.index_offset > 0);
-
- block_source_from_strbuf(&source, &writer_buf);
- err = reftable_new_reader(&reader, &source, "filename");
- EXPECT_ERR(err);
-
- /*
- * Seeking the log uses the log index now. In case there is any
- * confusion regarding indices we would notice here.
- */
- reftable_reader_init_log_iterator(reader, &it);
- err = reftable_iterator_seek_log(&it, "");
- EXPECT_ERR(err);
-
- reftable_iterator_destroy(&it);
- reftable_writer_free(writer);
- reftable_reader_free(reader);
- strbuf_release(&writer_buf);
- strbuf_release(&buf);
-}
-
-static void test_write_multi_level_index(void)
-{
- struct reftable_write_options opts = {
- .block_size = 100,
- };
- struct strbuf writer_buf = STRBUF_INIT, buf = STRBUF_INIT;
- struct reftable_block_source source = { 0 };
- struct reftable_iterator it = { 0 };
- const struct reftable_stats *stats;
- struct reftable_writer *writer;
- struct reftable_reader *reader;
- int err;
-
- writer = reftable_new_writer(&strbuf_add_void, &noop_flush, &writer_buf, &opts);
- reftable_writer_set_limits(writer, 1, 1);
- for (size_t i = 0; i < 200; i++) {
- struct reftable_ref_record ref = {
- .update_index = 1,
- .value_type = REFTABLE_REF_VAL1,
- .value.val1 = {i},
- };
-
- strbuf_reset(&buf);
- strbuf_addf(&buf, "refs/heads/%03" PRIuMAX, (uintmax_t)i);
- ref.refname = buf.buf,
-
- err = reftable_writer_add_ref(writer, &ref);
- EXPECT_ERR(err);
- }
- reftable_writer_close(writer);
-
- /*
- * The written refs should be sufficiently large to result in a
- * multi-level index.
- */
- stats = reftable_writer_stats(writer);
- EXPECT(stats->ref_stats.max_index_level == 2);
-
- block_source_from_strbuf(&source, &writer_buf);
- err = reftable_new_reader(&reader, &source, "filename");
- EXPECT_ERR(err);
-
- /*
- * Seeking the last ref should work as expected.
- */
- reftable_reader_init_ref_iterator(reader, &it);
- err = reftable_iterator_seek_ref(&it, "refs/heads/199");
- EXPECT_ERR(err);
-
- reftable_iterator_destroy(&it);
- reftable_writer_free(writer);
- reftable_reader_free(reader);
- strbuf_release(&writer_buf);
- strbuf_release(&buf);
-}
-
-static void test_corrupt_table_empty(void)
-{
- struct strbuf buf = STRBUF_INIT;
- struct reftable_block_source source = { NULL };
- struct reftable_reader rd = { NULL };
- int err;
-
- block_source_from_strbuf(&source, &buf);
- err = init_reader(&rd, &source, "file.log");
- EXPECT(err == REFTABLE_FORMAT_ERROR);
-}
-
-static void test_corrupt_table(void)
-{
- uint8_t zeros[1024] = { 0 };
- struct strbuf buf = STRBUF_INIT;
- struct reftable_block_source source = { NULL };
- struct reftable_reader rd = { NULL };
- int err;
- strbuf_add(&buf, zeros, sizeof(zeros));
-
- block_source_from_strbuf(&source, &buf);
- err = init_reader(&rd, &source, "file.log");
- EXPECT(err == REFTABLE_FORMAT_ERROR);
- strbuf_release(&buf);
-}
-
-int readwrite_test_main(int argc, const char *argv[])
-{
- RUN_TEST(test_log_zlib_corruption);
- RUN_TEST(test_corrupt_table);
- RUN_TEST(test_corrupt_table_empty);
- RUN_TEST(test_log_write_read);
- RUN_TEST(test_write_key_order);
- RUN_TEST(test_table_read_write_seek_linear_sha256);
- RUN_TEST(test_log_buffer_size);
- RUN_TEST(test_table_write_small_table);
- RUN_TEST(test_buffer);
- RUN_TEST(test_table_read_api);
- RUN_TEST(test_table_read_write_sequential);
- RUN_TEST(test_table_read_write_seek_linear);
- RUN_TEST(test_table_read_write_seek_index);
- RUN_TEST(test_table_refs_for_no_index);
- RUN_TEST(test_table_refs_for_obj_index);
- RUN_TEST(test_write_empty_key);
- RUN_TEST(test_write_empty_table);
- RUN_TEST(test_log_overflow);
- RUN_TEST(test_write_object_id_length);
- RUN_TEST(test_write_object_id_min_length);
- RUN_TEST(test_write_multiple_indices);
- RUN_TEST(test_write_multi_level_index);
- return 0;
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-13 13:26:26 +0000