bekucera/git
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2025-09-10 22:44:50 +02:00
Code Issues Packages Projects Releases Wiki Activity

t/unit-tests: convert reftable readwrite test to use clar

Browse Source 
Adapt reftable readwrite test file to use clar by using clar assertions
where necessary.

Signed-off-by: Seyi Kuforiji <kuforiji98@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Seyi Kuforiji
2025-07-24 15:28:34 +01:00
committed by Junio C Hamano
parent 18a992b7b7
commit ee0a88dadb
3 changed files with 179 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-basics
CLAR_TEST_SUITES += u-reftable-block CLAR_TEST_SUITES += u-reftable-block
CLAR_TEST_SUITES += u-reftable-merged CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-pq CLAR_TEST_SUITES += u-reftable-pq
CLAR_TEST_SUITES += u-reftable-readwrite
CLAR_TEST_SUITES += u-reftable-table CLAR_TEST_SUITES += u-reftable-table
CLAR_TEST_SUITES += u-reftable-tree CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf CLAR_TEST_SUITES += u-strbuf
@@ -1382,7 +1383,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable-clar.o
UNIT_TEST_PROGRAMS += t-reftable-readwrite
UNIT_TEST_PROGRAMS += t-reftable-record UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack UNIT_TEST_PROGRAMS += t-reftable-stack
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS)) UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))

2
t/meson.build
View File

@@ -12,6 +12,7 @@ clar_test_suites = [
'unit-tests/u-reftable-block.c', 'unit-tests/u-reftable-block.c',
'unit-tests/u-reftable-merged.c', 'unit-tests/u-reftable-merged.c',
'unit-tests/u-reftable-pq.c', 'unit-tests/u-reftable-pq.c',
'unit-tests/u-reftable-readwrite.c',
'unit-tests/u-reftable-table.c', 'unit-tests/u-reftable-table.c',
'unit-tests/u-reftable-tree.c', 'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c', 'unit-tests/u-strbuf.c',
@@ -60,7 +61,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests) test('unit-tests', clar_unit_tests)
unit_test_programs = [ unit_test_programs = [
'unit-tests/t-reftable-readwrite.c',
'unit-tests/t-reftable-record.c', 'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c', 'unit-tests/t-reftable-stack.c',
] ]

405
t/unit-tests/t-reftable-readwrite.c → t/unit-tests/u-reftable-readwrite.c
View File

@@ -8,8 +8,8 @@ https://developers.google.com/open-source/licenses/bsd
#define DISABLE_SIGN_COMPARE_WARNINGS #define DISABLE_SIGN_COMPARE_WARNINGS
#include "test-lib.h" #include "unit-test.h"
#include "lib-reftable.h" #include "lib-reftable-clar.h"
#include "reftable/basics.h" #include "reftable/basics.h"
#include "reftable/blocksource.h" #include "reftable/blocksource.h"
#include "reftable/reftable-error.h" #include "reftable/reftable-error.h"
@@ -19,24 +19,24 @@ https://developers.google.com/open-source/licenses/bsd
static const int update_index = 5; static const int update_index = 5;
static void t_buffer(void) void test_reftable_readwrite__buffer(void)
{ {
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_block_data out = { 0 }; struct reftable_block_data out = { 0 };
int n; int n;
uint8_t in[] = "hello"; uint8_t in[] = "hello";
check(!reftable_buf_add(&buf, in, sizeof(in))); cl_assert_equal_i(reftable_buf_add(&buf, in, sizeof(in)), 0);
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
check_int(block_source_size(&source), ==, 6); cl_assert_equal_i(block_source_size(&source), 6);
n = block_source_read_data(&source, &out, 0, sizeof(in)); n = block_source_read_data(&source, &out, 0, sizeof(in));
check_int(n, ==, sizeof(in)); cl_assert_equal_i(n, sizeof(in));
check(!memcmp(in, out.data, n)); cl_assert(!memcmp(in, out.data, n));
block_source_release_data(&out); block_source_release_data(&out);
n = block_source_read_data(&source, &out, 1, 2); n = block_source_read_data(&source, &out, 1, 2);
check_int(n, ==, 2); cl_assert_equal_i(n, 2);
check(!memcmp(out.data, "el", 2)); cl_assert(!memcmp(out.data, "el", 2));
block_source_release_data(&out); block_source_release_data(&out);
block_source_close(&source); block_source_close(&source);
@@ -55,41 +55,41 @@ static void write_table(char ***names, struct reftable_buf *buf, int N,
int i; int i;
REFTABLE_CALLOC_ARRAY(*names, N + 1); REFTABLE_CALLOC_ARRAY(*names, N + 1);
check(*names != NULL); cl_assert(*names != NULL);
REFTABLE_CALLOC_ARRAY(refs, N); REFTABLE_CALLOC_ARRAY(refs, N);
check(refs != NULL); cl_assert(refs != NULL);
REFTABLE_CALLOC_ARRAY(logs, N); REFTABLE_CALLOC_ARRAY(logs, N);
check(logs != NULL); cl_assert(logs != NULL);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
refs[i].refname = (*names)[i] = xstrfmt("refs/heads/branch%02d", i); refs[i].refname = (*names)[i] = xstrfmt("refs/heads/branch%02d", i);
refs[i].update_index = update_index; refs[i].update_index = update_index;
refs[i].value_type = REFTABLE_REF_VAL1; refs[i].value_type = REFTABLE_REF_VAL1;
t_reftable_set_hash(refs[i].value.val1, i, REFTABLE_HASH_SHA1); cl_reftable_set_hash(refs[i].value.val1, i,
REFTABLE_HASH_SHA1);
} }
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
logs[i].refname = (*names)[i]; logs[i].refname = (*names)[i];
logs[i].update_index = update_index; logs[i].update_index = update_index;
logs[i].value_type = REFTABLE_LOG_UPDATE; logs[i].value_type = REFTABLE_LOG_UPDATE;
t_reftable_set_hash(logs[i].value.update.new_hash, i, cl_reftable_set_hash(logs[i].value.update.new_hash, i,
REFTABLE_HASH_SHA1); REFTABLE_HASH_SHA1);
logs[i].value.update.message = (char *) "message"; logs[i].value.update.message = (char *) "message";
} }
t_reftable_write_to_buf(buf, refs, N, logs, N, &opts); cl_reftable_write_to_buf(buf, refs, N, logs, N, &opts);
reftable_free(refs); reftable_free(refs);
reftable_free(logs); reftable_free(logs);
} }
static void t_log_buffer_size(void) void test_reftable_readwrite__log_buffer_size(void)
{ {
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 4096, .block_size = 4096,
}; };
int err;
int i; int i;
struct reftable_log_record struct reftable_log_record
log = { .refname = (char *) "refs/heads/master", log = { .refname = (char *) "refs/heads/master",
@@ -102,7 +102,8 @@ static void t_log_buffer_size(void)
.time = 0x5e430672, .time = 0x5e430672,
.message = (char *) "commit: 9\n", .message = (char *) "commit: 9\n",
} } }; } } };
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf,
&opts);
/* This tests buffer extension for log compression. Must use a random /* This tests buffer extension for log compression. Must use a random
hash, to ensure that the compressed part is larger than the original. hash, to ensure that the compressed part is larger than the original.
@@ -112,22 +113,19 @@ static void t_log_buffer_size(void)
log.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256); log.value.update.new_hash[i] = (uint8_t)(git_rand(0) % 256);
} }
reftable_writer_set_limits(w, update_index, update_index); reftable_writer_set_limits(w, update_index, update_index);
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
check(!err); cl_assert_equal_i(reftable_writer_close(w), 0);
err = reftable_writer_close(w);
check(!err);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_log_overflow(void) void test_reftable_readwrite__log_overflow(void)
{ {
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
char msg[256] = { 0 }; char msg[256] = { 0 };
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = ARRAY_SIZE(msg), .block_size = ARRAY_SIZE(msg),
}; };
int err;
struct reftable_log_record log = { struct reftable_log_record log = {
.refname = (char *) "refs/heads/master", .refname = (char *) "refs/heads/master",
.update_index = update_index, .update_index = update_index,
@@ -144,21 +142,22 @@ static void t_log_overflow(void)
}, },
}, },
}; };
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf,
&opts);
memset(msg, 'x', sizeof(msg) - 1); memset(msg, 'x', sizeof(msg) - 1);
reftable_writer_set_limits(w, update_index, update_index); reftable_writer_set_limits(w, update_index, update_index);
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_ENTRY_TOO_BIG_ERROR);
check_int(err, ==, REFTABLE_ENTRY_TOO_BIG_ERROR);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_log_write_limits(void) void test_reftable_readwrite__log_write_limits(void)
{ {
struct reftable_write_options opts = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf,
&opts);
struct reftable_log_record log = { struct reftable_log_record log = {
.refname = (char *)"refs/head/master", .refname = (char *)"refs/head/master",
.update_index = 0, .update_index = 0,
@@ -174,29 +173,25 @@ static void t_log_write_limits(void)
}, },
}, },
}; };
int err;
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
/* write with update_index (0) below set limits (1, 1) */ /* write with update_index (0) below set limits (1, 1) */
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
check_int(err, ==, 0);
/* write with update_index (1) in the set limits (1, 1) */ /* write with update_index (1) in the set limits (1, 1) */
log.update_index = 1; log.update_index = 1;
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
check_int(err, ==, 0);
/* write with update_index (3) above set limits (1, 1) */ /* write with update_index (3) above set limits (1, 1) */
log.update_index = 3; log.update_index = 3;
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), REFTABLE_API_ERROR);
check_int(err, ==, REFTABLE_API_ERROR);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_log_write_read(void) void test_reftable_readwrite__log_write_read(void)
{ {
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 256, .block_size = 256,
@@ -207,13 +202,14 @@ static void t_log_write_read(void)
struct reftable_table *table; struct reftable_table *table;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
const struct reftable_stats *stats = NULL; const struct reftable_stats *stats = NULL;
int N = 2, err, i, n; int N = 2, i;
char **names; char **names;
int err;
names = reftable_calloc(N + 1, sizeof(*names)); names = reftable_calloc(N + 1, sizeof(*names));
check(names != NULL); cl_assert(names != NULL);
reftable_writer_set_limits(w, 0, N); reftable_writer_set_limits(w, 0, N);
@@ -225,8 +221,7 @@ static void t_log_write_read(void)
ref.refname = name; ref.refname = name;
ref.update_index = i; ref.update_index = i;
err = reftable_writer_add_ref(w, &ref); cl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);
check(!err);
} }
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@@ -235,60 +230,57 @@ static void t_log_write_read(void)
log.refname = names[i]; log.refname = names[i];
log.update_index = i; log.update_index = i;
log.value_type = REFTABLE_LOG_UPDATE; log.value_type = REFTABLE_LOG_UPDATE;
t_reftable_set_hash(log.value.update.old_hash, i, cl_reftable_set_hash(log.value.update.old_hash, i,
REFTABLE_HASH_SHA1); REFTABLE_HASH_SHA1);
t_reftable_set_hash(log.value.update.new_hash, i + 1, cl_reftable_set_hash(log.value.update.new_hash, i + 1,
REFTABLE_HASH_SHA1); REFTABLE_HASH_SHA1);
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
check(!err);
} }
n = reftable_writer_close(w); cl_assert_equal_i(reftable_writer_close(w), 0);
check_int(n, ==, 0);
stats = reftable_writer_stats(w); stats = reftable_writer_stats(w);
check_int(stats->log_stats.blocks, >, 0); cl_assert(stats->log_stats.blocks > 0);
reftable_writer_free(w); reftable_writer_free(w);
w = NULL; w = NULL;
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log"); err = reftable_table_new(&table, &source, "file.log");
check(!err); cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, names[N - 1]); err = reftable_iterator_seek_ref(&it, names[N - 1]);
check(!err); cl_assert(!err);
err = reftable_iterator_next_ref(&it, &ref); err = reftable_iterator_next_ref(&it, &ref);
check(!err); cl_assert(!err);
/* end of iteration. */ /* end of iteration. */
err = reftable_iterator_next_ref(&it, &ref); cl_assert(reftable_iterator_next_ref(&it, &ref) > 0);
check_int(err, >, 0);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
reftable_ref_record_release(&ref); reftable_ref_record_release(&ref);
err = reftable_table_init_log_iterator(table, &it); err = reftable_table_init_log_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_log(&it, ""); err = reftable_iterator_seek_log(&it, "");
check(!err); cl_assert(!err);
for (i = 0; ; i++) { for (i = 0; ; i++) {
int err = reftable_iterator_next_log(&it, &log); int err = reftable_iterator_next_log(&it, &log);
if (err > 0) if (err > 0)
break; break;
check(!err); cl_assert(!err);
check_str(names[i], log.refname); cl_assert_equal_s(names[i], log.refname);
check_int(i, ==, log.update_index); cl_assert_equal_i(i, log.update_index);
reftable_log_record_release(&log); reftable_log_record_release(&log);
} }
check_int(i, ==, N); cl_assert_equal_i(i, N);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
/* cleanup. */ /* cleanup. */
@@ -297,7 +289,7 @@ static void t_log_write_read(void)
reftable_table_decref(table); reftable_table_decref(table);
} }
static void t_log_zlib_corruption(void) void test_reftable_readwrite__log_zlib_corruption(void)
{ {
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 256, .block_size = 256,
@@ -306,10 +298,12 @@ static void t_log_zlib_corruption(void)
struct reftable_table *table; struct reftable_table *table;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf,
&opts);
const struct reftable_stats *stats = NULL; const struct reftable_stats *stats = NULL;
char message[100] = { 0 }; char message[100] = { 0 };
int err, i, n; int i;
int err;
struct reftable_log_record log = { struct reftable_log_record log = {
.refname = (char *) "refname", .refname = (char *) "refname",
.value_type = REFTABLE_LOG_UPDATE, .value_type = REFTABLE_LOG_UPDATE,
@@ -329,14 +323,11 @@ static void t_log_zlib_corruption(void)
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
err = reftable_writer_add_log(w, &log); cl_assert_equal_i(reftable_writer_add_log(w, &log), 0);
check(!err); cl_assert_equal_i(reftable_writer_close(w), 0);
n = reftable_writer_close(w);
check_int(n, ==, 0);
stats = reftable_writer_stats(w); stats = reftable_writer_stats(w);
check_int(stats->log_stats.blocks, >, 0); cl_assert(stats->log_stats.blocks > 0);
reftable_writer_free(w); reftable_writer_free(w);
w = NULL; w = NULL;
@@ -346,12 +337,12 @@ static void t_log_zlib_corruption(void)
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log"); err = reftable_table_new(&table, &source, "file.log");
check(!err); cl_assert(!err);
err = reftable_table_init_log_iterator(table, &it); err = reftable_table_init_log_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_log(&it, "refname"); err = reftable_iterator_seek_log(&it, "refname");
check_int(err, ==, REFTABLE_ZLIB_ERROR); cl_assert_equal_i(err, REFTABLE_ZLIB_ERROR);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
@@ -360,7 +351,7 @@ static void t_log_zlib_corruption(void)
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_table_read_write_sequential(void) void test_reftable_readwrite__table_read_write_sequential(void)
{ {
char **names; char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
@@ -376,24 +367,24 @@ static void t_table_read_write_sequential(void)
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref"); err = reftable_table_new(&table, &source, "file.ref");
check(!err); cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, ""); err = reftable_iterator_seek_ref(&it, "");
check(!err); cl_assert(!err);
for (j = 0; ; j++) { for (j = 0; ; j++) {
struct reftable_ref_record ref = { 0 }; struct reftable_ref_record ref = { 0 };
int r = reftable_iterator_next_ref(&it, &ref); int r = reftable_iterator_next_ref(&it, &ref);
check_int(r, >=, 0); cl_assert(r >= 0);
if (r > 0) if (r > 0)
break; break;
check_str(names[j], ref.refname); cl_assert_equal_s(names[j], ref.refname);
check_int(update_index, ==, ref.update_index); cl_assert_equal_i(update_index, ref.update_index);
reftable_ref_record_release(&ref); reftable_ref_record_release(&ref);
} }
check_int(j, ==, N); cl_assert_equal_i(j, N);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
reftable_table_decref(table); reftable_table_decref(table);
@@ -401,42 +392,42 @@ static void t_table_read_write_sequential(void)
free_names(names); free_names(names);
} }
static void t_table_write_small_table(void) void test_reftable_readwrite__table_write_small_table(void)
{ {
char **names; char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
int N = 1; int N = 1;
write_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1); write_table(&names, &buf, N, 4096, REFTABLE_HASH_SHA1);
check_int(buf.len, <, 200); cl_assert(buf.len < 200);
reftable_buf_release(&buf); reftable_buf_release(&buf);
free_names(names); free_names(names);
} }
static void t_table_read_api(void) void test_reftable_readwrite__table_read_api(void)
{ {
char **names; char **names;
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
int N = 50; int N = 50;
struct reftable_table *table; struct reftable_table *table;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
int err;
struct reftable_log_record log = { 0 }; struct reftable_log_record log = { 0 };
struct reftable_iterator it = { 0 }; struct reftable_iterator it = { 0 };
int err;
write_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1); write_table(&names, &buf, N, 256, REFTABLE_HASH_SHA1);
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref"); err = reftable_table_new(&table, &source, "file.ref");
check(!err); cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, names[0]); err = reftable_iterator_seek_ref(&it, names[0]);
check(!err); cl_assert(!err);
err = reftable_iterator_next_log(&it, &log); err = reftable_iterator_next_log(&it, &log);
check_int(err, ==, REFTABLE_API_ERROR); cl_assert_equal_i(err, REFTABLE_API_ERROR);
reftable_buf_release(&buf); reftable_buf_release(&buf);
free_names(names); free_names(names);
@@ -464,42 +455,43 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref"); err = reftable_table_new(&table, &source, "file.ref");
check(!err); cl_assert(!err);
check_int(hash_id, ==, reftable_table_hash_id(table)); cl_assert_equal_i(hash_id, reftable_table_hash_id(table));
if (!index) { if (!index) {
table->ref_offsets.index_offset = 0; table->ref_offsets.index_offset = 0;
} else { } else {
check_int(table->ref_offsets.index_offset, >, 0); cl_assert(table->ref_offsets.index_offset > 0);
} }
for (i = 1; i < N; i++) { for (i = 1; i < N; i++) {
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, names[i]); err = reftable_iterator_seek_ref(&it, names[i]);
check(!err); cl_assert(!err);
err = reftable_iterator_next_ref(&it, &ref); err = reftable_iterator_next_ref(&it, &ref);
check(!err); cl_assert(!err);
check_str(names[i], ref.refname); cl_assert_equal_s(names[i], ref.refname);
check_int(REFTABLE_REF_VAL1, ==, ref.value_type); cl_assert_equal_i(REFTABLE_REF_VAL1, ref.value_type);
check_int(i, ==, ref.value.val1[0]); cl_assert_equal_i(i, ref.value.val1[0]);
reftable_ref_record_release(&ref); reftable_ref_record_release(&ref);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
} }
check(!reftable_buf_addstr(&pastLast, names[N - 1])); cl_assert_equal_i(reftable_buf_addstr(&pastLast, names[N - 1]),
check(!reftable_buf_addstr(&pastLast, "/")); 0);
cl_assert_equal_i(reftable_buf_addstr(&pastLast, "/"), 0);
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, pastLast.buf); err = reftable_iterator_seek_ref(&it, pastLast.buf);
if (err == 0) { if (err == 0) {
struct reftable_ref_record ref = { 0 }; struct reftable_ref_record ref = { 0 };
int err = reftable_iterator_next_ref(&it, &ref); int err = reftable_iterator_next_ref(&it, &ref);
check_int(err, >, 0); cl_assert(err > 0);
} else { } else {
check_int(err, >, 0); cl_assert(err > 0);
} }
reftable_buf_release(&pastLast); reftable_buf_release(&pastLast);
@@ -510,17 +502,17 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
reftable_table_decref(table); reftable_table_decref(table);
} }
static void t_table_read_write_seek_linear(void) void test_reftable_readwrite__table_read_write_seek_linear(void)
{ {
t_table_read_write_seek(0, REFTABLE_HASH_SHA1); t_table_read_write_seek(0, REFTABLE_HASH_SHA1);
} }
static void t_table_read_write_seek_linear_sha256(void) void test_reftable_readwrite__table_read_write_seek_linear_sha256(void)
{ {
t_table_read_write_seek(0, REFTABLE_HASH_SHA256); t_table_read_write_seek(0, REFTABLE_HASH_SHA256);
} }
static void t_table_read_write_seek_index(void) void test_reftable_readwrite__table_read_write_seek_index(void)
{ {
t_table_read_write_seek(1, REFTABLE_HASH_SHA1); t_table_read_write_seek(1, REFTABLE_HASH_SHA1);
} }
@@ -538,14 +530,16 @@ static void t_table_refs_for(int indexed)
struct reftable_table *table; struct reftable_table *table;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf,
&opts);
struct reftable_iterator it = { 0 }; struct reftable_iterator it = { 0 };
int N = 50, n, j, err, i; int N = 50, j, i;
int err;
want_names = reftable_calloc(N + 1, sizeof(*want_names)); want_names = reftable_calloc(N + 1, sizeof(*want_names));
check(want_names != NULL); cl_assert(want_names != NULL);
t_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1); cl_reftable_set_hash(want_hash, 4, REFTABLE_HASH_SHA1);
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
uint8_t hash[REFTABLE_HASH_SIZE_SHA1]; uint8_t hash[REFTABLE_HASH_SIZE_SHA1];
@@ -561,24 +555,22 @@ static void t_table_refs_for(int indexed)
ref.refname = name; ref.refname = name;
ref.value_type = REFTABLE_REF_VAL2; ref.value_type = REFTABLE_REF_VAL2;
t_reftable_set_hash(ref.value.val2.value, i / 4, cl_reftable_set_hash(ref.value.val2.value, i / 4,
REFTABLE_HASH_SHA1); REFTABLE_HASH_SHA1);
t_reftable_set_hash(ref.value.val2.target_value, 3 + i / 4, cl_reftable_set_hash(ref.value.val2.target_value,
REFTABLE_HASH_SHA1); 3 + i / 4, REFTABLE_HASH_SHA1);
/* 80 bytes / entry, so 3 entries per block. Yields 17 /* 80 bytes / entry, so 3 entries per block. Yields 17
*/ */
/* blocks. */ /* blocks. */
n = reftable_writer_add_ref(w, &ref); cl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);
check_int(n, ==, 0);
if (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) || if (!memcmp(ref.value.val2.value, want_hash, REFTABLE_HASH_SIZE_SHA1) ||
!memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1)) !memcmp(ref.value.val2.target_value, want_hash, REFTABLE_HASH_SIZE_SHA1))
want_names[want_names_len++] = xstrdup(name); want_names[want_names_len++] = xstrdup(name);
} }
n = reftable_writer_close(w); cl_assert_equal_i(reftable_writer_close(w), 0);
check_int(n, ==, 0);
reftable_writer_free(w); reftable_writer_free(w);
w = NULL; w = NULL;
@@ -586,29 +578,29 @@ static void t_table_refs_for(int indexed)
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.ref"); err = reftable_table_new(&table, &source, "file.ref");
check(!err); cl_assert(!err);
if (!indexed) if (!indexed)
table->obj_offsets.is_present = 0; table->obj_offsets.is_present = 0;
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, ""); err = reftable_iterator_seek_ref(&it, "");
check(!err); cl_assert(!err);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
err = reftable_table_refs_for(table, &it, want_hash); err = reftable_table_refs_for(table, &it, want_hash);
check(!err); cl_assert(!err);
for (j = 0; ; j++) { for (j = 0; ; j++) {
int err = reftable_iterator_next_ref(&it, &ref); int err = reftable_iterator_next_ref(&it, &ref);
check_int(err, >=, 0); cl_assert(err >= 0);
if (err > 0) if (err > 0)
break; break;
check_int(j, <, want_names_len); cl_assert(j < want_names_len);
check_str(ref.refname, want_names[j]); cl_assert_equal_s(ref.refname, want_names[j]);
reftable_ref_record_release(&ref); reftable_ref_record_release(&ref);
} }
check_int(j, ==, want_names_len); cl_assert_equal_i(j, want_names_len);
reftable_buf_release(&buf); reftable_buf_release(&buf);
free_names(want_names); free_names(want_names);
@@ -616,21 +608,21 @@ static void t_table_refs_for(int indexed)
reftable_table_decref(table); reftable_table_decref(table);
} }
static void t_table_refs_for_no_index(void) void test_reftable_readwrite__table_refs_for_no_index(void)
{ {
t_table_refs_for(0); t_table_refs_for(0);
} }
static void t_table_refs_for_obj_index(void) void test_reftable_readwrite__table_refs_for_obj_index(void)
{ {
t_table_refs_for(1); t_table_refs_for(1);
} }
static void t_write_empty_table(void) void test_reftable_readwrite__write_empty_table(void)
{ {
struct reftable_write_options opts = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_table *table = NULL; struct reftable_table *table = NULL;
struct reftable_ref_record rec = { 0 }; struct reftable_ref_record rec = { 0 };
@@ -639,43 +631,41 @@ static void t_write_empty_table(void)
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
err = reftable_writer_close(w); cl_assert_equal_i(reftable_writer_close(w), REFTABLE_EMPTY_TABLE_ERROR);
check_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);
reftable_writer_free(w); reftable_writer_free(w);
check_uint(buf.len, ==, header_size(1) + footer_size(1)); cl_assert_equal_i(buf.len, header_size(1) + footer_size(1));
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "filename"); err = reftable_table_new(&table, &source, "filename");
check(!err); cl_assert(!err);
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, ""); err = reftable_iterator_seek_ref(&it, "");
check(!err); cl_assert(!err);
err = reftable_iterator_next_ref(&it, &rec); err = reftable_iterator_next_ref(&it, &rec);
check_int(err, >, 0); cl_assert(err > 0);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
reftable_table_decref(table); reftable_table_decref(table);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_write_object_id_min_length(void) void test_reftable_readwrite__write_object_id_min_length(void)
{ {
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 75, .block_size = 75,
}; };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record ref = { struct reftable_ref_record ref = {
.update_index = 1, .update_index = 1,
.value_type = REFTABLE_REF_VAL1, .value_type = REFTABLE_REF_VAL1,
.value.val1 = {42}, .value.val1 = {42},
}; };
int err;
int i; int i;
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
@@ -686,30 +676,27 @@ static void t_write_object_id_min_length(void)
char name[256]; char name[256];
snprintf(name, sizeof(name), "ref%05d", i); snprintf(name, sizeof(name), "ref%05d", i);
ref.refname = name; ref.refname = name;
err = reftable_writer_add_ref(w, &ref); cl_assert_equal_i(reftable_writer_add_ref(w, &ref), 0);
check(!err);
} }
err = reftable_writer_close(w); cl_assert_equal_i(reftable_writer_close(w), 0);
check(!err); cl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 2);
check_int(reftable_writer_stats(w)->object_id_len, ==, 2);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_write_object_id_length(void) void test_reftable_readwrite__write_object_id_length(void)
{ {
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 75, .block_size = 75,
}; };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record ref = { struct reftable_ref_record ref = {
.update_index = 1, .update_index = 1,
.value_type = REFTABLE_REF_VAL1, .value_type = REFTABLE_REF_VAL1,
.value.val1 = {42}, .value.val1 = {42},
}; };
int err;
int i; int i;
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
@@ -721,44 +708,39 @@ static void t_write_object_id_length(void)
snprintf(name, sizeof(name), "ref%05d", i); snprintf(name, sizeof(name), "ref%05d", i);
ref.refname = name; ref.refname = name;
ref.value.val1[15] = i; ref.value.val1[15] = i;
err = reftable_writer_add_ref(w, &ref); cl_assert(reftable_writer_add_ref(w, &ref) == 0);
check(!err);
} }
err = reftable_writer_close(w); cl_assert_equal_i(reftable_writer_close(w), 0);
check(!err); cl_assert_equal_i(reftable_writer_stats(w)->object_id_len, 16);
check_int(reftable_writer_stats(w)->object_id_len, ==, 16);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_write_empty_key(void) void test_reftable_readwrite__write_empty_key(void)
{ {
struct reftable_write_options opts = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record ref = { struct reftable_ref_record ref = {
.refname = (char *) "", .refname = (char *) "",
.update_index = 1, .update_index = 1,
.value_type = REFTABLE_REF_DELETION, .value_type = REFTABLE_REF_DELETION,
}; };
int err;
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
err = reftable_writer_add_ref(w, &ref); cl_assert_equal_i(reftable_writer_add_ref(w, &ref), REFTABLE_API_ERROR);
check_int(err, ==, REFTABLE_API_ERROR); cl_assert_equal_i(reftable_writer_close(w),
REFTABLE_EMPTY_TABLE_ERROR);
err = reftable_writer_close(w);
check_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_write_key_order(void) void test_reftable_readwrite__write_key_order(void)
{ {
struct reftable_write_options opts = { 0 }; struct reftable_write_options opts = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts); struct reftable_writer *w = cl_reftable_strbuf_writer(&buf, &opts);
struct reftable_ref_record refs[2] = { struct reftable_ref_record refs[2] = {
{ {
.refname = (char *) "b", .refname = (char *) "b",
@@ -776,24 +758,21 @@ static void t_write_key_order(void)
}, },
} }
}; };
int err;
reftable_writer_set_limits(w, 1, 1); reftable_writer_set_limits(w, 1, 1);
err = reftable_writer_add_ref(w, &refs[0]); cl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), 0);
check(!err); cl_assert_equal_i(reftable_writer_add_ref(w, &refs[1]),
err = reftable_writer_add_ref(w, &refs[1]); REFTABLE_API_ERROR);
check_int(err, ==, REFTABLE_API_ERROR);
refs[0].update_index = 2; refs[0].update_index = 2;
err = reftable_writer_add_ref(w, &refs[0]); cl_assert_equal_i(reftable_writer_add_ref(w, &refs[0]), REFTABLE_API_ERROR);
check_int(err, ==, REFTABLE_API_ERROR);
reftable_writer_close(w); reftable_writer_close(w);
reftable_writer_free(w); reftable_writer_free(w);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_write_multiple_indices(void) void test_reftable_readwrite__write_multiple_indices(void)
{ {
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 100, .block_size = 100,
@@ -805,9 +784,10 @@ static void t_write_multiple_indices(void)
struct reftable_writer *writer; struct reftable_writer *writer;
struct reftable_table *table; struct reftable_table *table;
char buf[128]; char buf[128];
int err, i; int i;
int err;
writer = t_reftable_strbuf_writer(&writer_buf, &opts); writer = cl_reftable_strbuf_writer(&writer_buf, &opts);
reftable_writer_set_limits(writer, 1, 1); reftable_writer_set_limits(writer, 1, 1);
for (i = 0; i < 100; i++) { for (i = 0; i < 100; i++) {
struct reftable_ref_record ref = { struct reftable_ref_record ref = {
@@ -819,8 +799,7 @@ static void t_write_multiple_indices(void)
snprintf(buf, sizeof(buf), "refs/heads/%04d", i); snprintf(buf, sizeof(buf), "refs/heads/%04d", i);
ref.refname = buf; ref.refname = buf;
err = reftable_writer_add_ref(writer, &ref); cl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);
check(!err);
} }
for (i = 0; i < 100; i++) { for (i = 0; i < 100; i++) {
@@ -836,8 +815,7 @@ static void t_write_multiple_indices(void)
snprintf(buf, sizeof(buf), "refs/heads/%04d", i); snprintf(buf, sizeof(buf), "refs/heads/%04d", i);
log.refname = buf; log.refname = buf;
err = reftable_writer_add_log(writer, &log); cl_assert_equal_i(reftable_writer_add_log(writer, &log), 0);
check(!err);
} }
reftable_writer_close(writer); reftable_writer_close(writer);
@@ -847,22 +825,22 @@ static void t_write_multiple_indices(void)
* for each of the block types. * for each of the block types.
*/ */
stats = reftable_writer_stats(writer); stats = reftable_writer_stats(writer);
check_int(stats->ref_stats.index_offset, >, 0); cl_assert(stats->ref_stats.index_offset > 0);
check_int(stats->obj_stats.index_offset, >, 0); cl_assert(stats->obj_stats.index_offset > 0);
check_int(stats->log_stats.index_offset, >, 0); cl_assert(stats->log_stats.index_offset > 0);
block_source_from_buf(&source, &writer_buf); block_source_from_buf(&source, &writer_buf);
err = reftable_table_new(&table, &source, "filename"); err = reftable_table_new(&table, &source, "filename");
check(!err); cl_assert(!err);
/* /*
* Seeking the log uses the log index now. In case there is any * Seeking the log uses the log index now. In case there is any
* confusion regarding indices we would notice here. * confusion regarding indices we would notice here.
*/ */
err = reftable_table_init_log_iterator(table, &it); err = reftable_table_init_log_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_log(&it, ""); err = reftable_iterator_seek_log(&it, "");
check(!err); cl_assert(!err);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
reftable_writer_free(writer); reftable_writer_free(writer);
@@ -870,7 +848,7 @@ static void t_write_multiple_indices(void)
reftable_buf_release(&writer_buf); reftable_buf_release(&writer_buf);
} }
static void t_write_multi_level_index(void) void test_reftable_readwrite__write_multi_level_index(void)
{ {
struct reftable_write_options opts = { struct reftable_write_options opts = {
.block_size = 100, .block_size = 100,
@@ -883,7 +861,7 @@ static void t_write_multi_level_index(void)
struct reftable_table *table; struct reftable_table *table;
int err; int err;
writer = t_reftable_strbuf_writer(&writer_buf, &opts); writer = cl_reftable_strbuf_writer(&writer_buf, &opts);
reftable_writer_set_limits(writer, 1, 1); reftable_writer_set_limits(writer, 1, 1);
for (size_t i = 0; i < 200; i++) { for (size_t i = 0; i < 200; i++) {
struct reftable_ref_record ref = { struct reftable_ref_record ref = {
@@ -896,8 +874,7 @@ static void t_write_multi_level_index(void)
snprintf(buf, sizeof(buf), "refs/heads/%03" PRIuMAX, (uintmax_t)i); snprintf(buf, sizeof(buf), "refs/heads/%03" PRIuMAX, (uintmax_t)i);
ref.refname = buf; ref.refname = buf;
err = reftable_writer_add_ref(writer, &ref); cl_assert_equal_i(reftable_writer_add_ref(writer, &ref), 0);
check(!err);
} }
reftable_writer_close(writer); reftable_writer_close(writer);
@@ -906,19 +883,19 @@ static void t_write_multi_level_index(void)
* multi-level index. * multi-level index.
*/ */
stats = reftable_writer_stats(writer); stats = reftable_writer_stats(writer);
check_int(stats->ref_stats.max_index_level, ==, 2); cl_assert_equal_i(stats->ref_stats.max_index_level, 2);
block_source_from_buf(&source, &writer_buf); block_source_from_buf(&source, &writer_buf);
err = reftable_table_new(&table, &source, "filename"); err = reftable_table_new(&table, &source, "filename");
check(!err); cl_assert(!err);
/* /*
* Seeking the last ref should work as expected. * Seeking the last ref should work as expected.
*/ */
err = reftable_table_init_ref_iterator(table, &it); err = reftable_table_init_ref_iterator(table, &it);
check(!err); cl_assert(!err);
err = reftable_iterator_seek_ref(&it, "refs/heads/199"); err = reftable_iterator_seek_ref(&it, "refs/heads/199");
check(!err); cl_assert(!err);
reftable_iterator_destroy(&it); reftable_iterator_destroy(&it);
reftable_writer_free(writer); reftable_writer_free(writer);
@@ -927,7 +904,7 @@ static void t_write_multi_level_index(void)
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
static void t_corrupt_table_empty(void) void test_reftable_readwrite__corrupt_table_empty(void)
{ {
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
@@ -936,50 +913,22 @@ static void t_corrupt_table_empty(void)
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log"); err = reftable_table_new(&table, &source, "file.log");
check_int(err, ==, REFTABLE_FORMAT_ERROR); cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
} }
static void t_corrupt_table(void) void test_reftable_readwrite__corrupt_table(void)
{ {
uint8_t zeros[1024] = { 0 }; uint8_t zeros[1024] = { 0 };
struct reftable_buf buf = REFTABLE_BUF_INIT; struct reftable_buf buf = REFTABLE_BUF_INIT;
struct reftable_block_source source = { 0 }; struct reftable_block_source source = { 0 };
struct reftable_table *table; struct reftable_table *table;
int err; int err;
check(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
cl_assert(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
block_source_from_buf(&source, &buf); block_source_from_buf(&source, &buf);
err = reftable_table_new(&table, &source, "file.log"); err = reftable_table_new(&table, &source, "file.log");
check_int(err, ==, REFTABLE_FORMAT_ERROR); cl_assert_equal_i(err, REFTABLE_FORMAT_ERROR);
reftable_buf_release(&buf); reftable_buf_release(&buf);
} }
int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
{
TEST(t_buffer(), "strbuf works as blocksource");
TEST(t_corrupt_table(), "read-write on corrupted table");
TEST(t_corrupt_table_empty(), "read-write on an empty table");
TEST(t_log_buffer_size(), "buffer extension for log compression");
TEST(t_log_overflow(), "log overflow returns expected error");
TEST(t_log_write_limits(), "writer limits for writing log records");
TEST(t_log_write_read(), "read-write on log records");
TEST(t_log_zlib_corruption(), "reading corrupted log record returns expected error");
TEST(t_table_read_api(), "read on a table");
TEST(t_table_read_write_seek_index(), "read-write on a table with index");
TEST(t_table_read_write_seek_linear(), "read-write on a table without index (SHA1)");
TEST(t_table_read_write_seek_linear_sha256(), "read-write on a table without index (SHA256)");
TEST(t_table_read_write_sequential(), "sequential read-write on a table");
TEST(t_table_refs_for_no_index(), "refs-only table with no index");
TEST(t_table_refs_for_obj_index(), "refs-only table with index");
TEST(t_table_write_small_table(), "write_table works");
TEST(t_write_empty_key(), "write on refs with empty keys");
TEST(t_write_empty_table(), "read-write on empty tables");
TEST(t_write_key_order(), "refs must be written in increasing order");
TEST(t_write_multi_level_index(), "table with multi-level index");
TEST(t_write_multiple_indices(), "table with indices for multiple block types");
TEST(t_write_object_id_length(), "prefix compression on writing refs");
TEST(t_write_object_id_min_length(), "prefix compression on writing refs");
return test_done();
}