Adapt reftable record test file to use clar by using clar assertions
where necessary.
Signed-off-by: Seyi Kuforiji <kuforiji98@xxxxxxxxx>
---
Makefile | 2 +-
t/meson.build | 2 +-
t/unit-tests/t-reftable-record.c | 585 -------------------------------
t/unit-tests/u-reftable-record.c | 565 +++++++++++++++++++++++++++++
4 files changed, 567 insertions(+), 587 deletions(-)
delete mode 100644 t/unit-tests/t-reftable-record.c
create mode 100644 t/unit-tests/u-reftable-record.c
diff --git a/Makefile b/Makefile
index 7511959baf..1af0eb8aa2 100644
--- a/Makefile
+++ b/Makefile
@@ -1368,6 +1368,7 @@ CLAR_TEST_SUITES += u-reftable-merged
CLAR_TEST_SUITES += u-reftable-pq
CLAR_TEST_SUITES += u-reftable-reader
CLAR_TEST_SUITES += u-reftable-readwrite
+CLAR_TEST_SUITES += u-reftable-record
CLAR_TEST_SUITES += u-reftable-tree
CLAR_TEST_SUITES += u-strbuf
CLAR_TEST_SUITES += u-strcmp-offset
@@ -1381,7 +1382,6 @@ CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-oid.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/lib-reftable.o
CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o
-UNIT_TEST_PROGRAMS += t-reftable-record
UNIT_TEST_PROGRAMS += t-reftable-stack
UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
UNIT_TEST_OBJS += $(UNIT_TEST_DIR)/test-lib.o
diff --git a/t/meson.build b/t/meson.build
index b9e9648f7c..bd0292f0c7 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -14,6 +14,7 @@ clar_test_suites = [
'unit-tests/u-reftable-pq.c',
'unit-tests/u-reftable-reader.c',
'unit-tests/u-reftable-readwrite.c',
+ 'unit-tests/u-reftable-record.c',
'unit-tests/u-reftable-tree.c',
'unit-tests/u-strbuf.c',
'unit-tests/u-strcmp-offset.c',
@@ -61,7 +62,6 @@ clar_unit_tests = executable('unit-tests',
test('unit-tests', clar_unit_tests)
unit_test_programs = [
- 'unit-tests/t-reftable-record.c',
'unit-tests/t-reftable-stack.c',
]
diff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/t-reftable-record.c
deleted file mode 100644
index 5954966373..0000000000
--- a/t/unit-tests/t-reftable-record.c
+++ /dev/null
@@ -1,585 +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 "test-lib.h"
-#include "reftable/basics.h"
-#include "reftable/constants.h"
-#include "reftable/record.h"
-
-static void t_copy(struct reftable_record *rec)
-{
- struct reftable_record copy;
- uint8_t typ;
-
- typ = reftable_record_type(rec);
- check(!reftable_record_init(©, typ));
- reftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);
- /* do it twice to catch memory leaks */
- reftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);
- check(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1));
-
- reftable_record_release(©);
-}
-
-static void t_varint_roundtrip(void)
-{
- uint64_t inputs[] = { 0,
- 1,
- 27,
- 127,
- 128,
- 257,
- 4096,
- ((uint64_t)1 << 63),
- ((uint64_t)1 << 63) + ((uint64_t)1 << 63) - 1 };
-
- for (size_t i = 0; i < ARRAY_SIZE(inputs); i++) {
- uint8_t dest[10];
-
- struct string_view out = {
- .buf = dest,
- .len = sizeof(dest),
- };
- uint64_t in = inputs[i];
- int n = put_var_int(&out, in);
- uint64_t got = 0;
-
- check_int(n, >, 0);
- out.len = n;
- n = get_var_int(&got, &out);
- check_int(n, >, 0);
-
- check_int(got, ==, in);
- }
-}
-
-static void t_varint_overflow(void)
-{
- unsigned char buf[] = {
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0x00,
- };
- struct string_view view = {
- .buf = buf,
- .len = sizeof(buf),
- };
- uint64_t value;
- int err = get_var_int(&value, &view);
- check_int(err, ==, -1);
-}
-
-static void set_hash(uint8_t *h, int j)
-{
- for (size_t i = 0; i < hash_size(REFTABLE_HASH_SHA1); i++)
- h[i] = (j >> i) & 0xff;
-}
-
-static void t_reftable_ref_record_comparison(void)
-{
- struct reftable_record in[3] = {
- {
- .type = BLOCK_TYPE_REF,
- .u.ref.refname = (char *) "refs/heads/master",
- .u.ref.value_type = REFTABLE_REF_VAL1,
- },
- {
- .type = BLOCK_TYPE_REF,
- .u.ref.refname = (char *) "refs/heads/master",
- .u.ref.value_type = REFTABLE_REF_DELETION,
- },
- {
- .type = BLOCK_TYPE_REF,
- .u.ref.refname = (char *) "HEAD",
- .u.ref.value_type = REFTABLE_REF_SYMREF,
- .u.ref.value.symref = (char *) "refs/heads/master",
- },
- };
- int cmp;
-
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
-
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
-
- in[1].u.ref.value_type = in[0].u.ref.value_type;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
-}
-
-static void t_reftable_ref_record_compare_name(void)
-{
- struct reftable_ref_record recs[3] = {
- {
- .refname = (char *) "refs/heads/a"
- },
- {
- .refname = (char *) "refs/heads/b"
- },
- {
- .refname = (char *) "refs/heads/a"
- },
- };
-
- check_int(reftable_ref_record_compare_name(&recs[0], &recs[1]), <, 0);
- check_int(reftable_ref_record_compare_name(&recs[1], &recs[0]), >, 0);
- check_int(reftable_ref_record_compare_name(&recs[0], &recs[2]), ==, 0);
-}
-
-static void t_reftable_ref_record_roundtrip(void)
-{
- struct reftable_buf scratch = REFTABLE_BUF_INIT;
-
- for (int i = REFTABLE_REF_DELETION; i < REFTABLE_NR_REF_VALUETYPES; i++) {
- struct reftable_record in = {
- .type = BLOCK_TYPE_REF,
- .u.ref.value_type = i,
- };
- struct reftable_record out = { .type = BLOCK_TYPE_REF };
- struct reftable_buf key = REFTABLE_BUF_INIT;
- uint8_t buffer[1024] = { 0 };
- struct string_view dest = {
- .buf = buffer,
- .len = sizeof(buffer),
- };
- int n, m;
-
- in.u.ref.value_type = i;
- switch (i) {
- case REFTABLE_REF_DELETION:
- break;
- case REFTABLE_REF_VAL1:
- set_hash(in.u.ref.value.val1, 1);
- break;
- case REFTABLE_REF_VAL2:
- set_hash(in.u.ref.value.val2.value, 1);
- set_hash(in.u.ref.value.val2.target_value, 2);
- break;
- case REFTABLE_REF_SYMREF:
- in.u.ref.value.symref = xstrdup("target");
- break;
- }
- in.u.ref.refname = xstrdup("refs/heads/master");
-
- t_copy(&in);
-
- check_int(reftable_record_val_type(&in), ==, i);
- check_int(reftable_record_is_deletion(&in), ==, i == REFTABLE_REF_DELETION);
-
- reftable_record_key(&in, &key);
- n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >, 0);
-
- /* decode into a non-zero reftable_record to test for leaks. */
- m = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);
- check_int(n, ==, m);
-
- check(reftable_ref_record_equal(&in.u.ref, &out.u.ref,
- REFTABLE_HASH_SIZE_SHA1));
- reftable_record_release(&in);
-
- reftable_buf_release(&key);
- reftable_record_release(&out);
- }
-
- reftable_buf_release(&scratch);
-}
-
-static void t_reftable_log_record_comparison(void)
-{
- struct reftable_record in[3] = {
- {
- .type = BLOCK_TYPE_LOG,
- .u.log.refname = (char *) "refs/heads/master",
- .u.log.update_index = 42,
- },
- {
- .type = BLOCK_TYPE_LOG,
- .u.log.refname = (char *) "refs/heads/master",
- .u.log.update_index = 22,
- },
- {
- .type = BLOCK_TYPE_LOG,
- .u.log.refname = (char *) "refs/heads/main",
- .u.log.update_index = 22,
- },
- };
- int cmp;
-
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
- /* comparison should be reversed for equal keys, because
- * comparison is now performed on the basis of update indices */
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check_int(cmp, <, 0);
-
- in[1].u.log.update_index = in[0].u.log.update_index;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
-}
-
-static void t_reftable_log_record_compare_key(void)
-{
- struct reftable_log_record logs[3] = {
- {
- .refname = (char *) "refs/heads/a",
- .update_index = 1,
- },
- {
- .refname = (char *) "refs/heads/b",
- .update_index = 2,
- },
- {
- .refname = (char *) "refs/heads/a",
- .update_index = 3,
- },
- };
-
- check_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);
- check_int(reftable_log_record_compare_key(&logs[1], &logs[0]), >, 0);
-
- logs[1].update_index = logs[0].update_index;
- check_int(reftable_log_record_compare_key(&logs[0], &logs[1]), <, 0);
-
- check_int(reftable_log_record_compare_key(&logs[0], &logs[2]), >, 0);
- check_int(reftable_log_record_compare_key(&logs[2], &logs[0]), <, 0);
- logs[2].update_index = logs[0].update_index;
- check_int(reftable_log_record_compare_key(&logs[0], &logs[2]), ==, 0);
-}
-
-static void t_reftable_log_record_roundtrip(void)
-{
- struct reftable_log_record in[] = {
- {
- .refname = xstrdup("refs/heads/master"),
- .update_index = 42,
- .value_type = REFTABLE_LOG_UPDATE,
- .value = {
- .update = {
- .name = xstrdup("han-wen"),
- .email = xstrdup("hanwen@xxxxxxxxxx"),
- .message = xstrdup("test"),
- .time = 1577123507,
- .tz_offset = 100,
- },
- }
- },
- {
- .refname = xstrdup("refs/heads/master"),
- .update_index = 22,
- .value_type = REFTABLE_LOG_DELETION,
- },
- {
- .refname = xstrdup("branch"),
- .update_index = 33,
- .value_type = REFTABLE_LOG_UPDATE,
- }
- };
- struct reftable_buf scratch = REFTABLE_BUF_INIT;
- set_hash(in[0].value.update.new_hash, 1);
- set_hash(in[0].value.update.old_hash, 2);
- set_hash(in[2].value.update.new_hash, 3);
- set_hash(in[2].value.update.old_hash, 4);
-
- check(!reftable_log_record_is_deletion(&in[0]));
- check(reftable_log_record_is_deletion(&in[1]));
- check(!reftable_log_record_is_deletion(&in[2]));
-
- for (size_t i = 0; i < ARRAY_SIZE(in); i++) {
- struct reftable_record rec = { .type = BLOCK_TYPE_LOG };
- struct reftable_buf key = REFTABLE_BUF_INIT;
- uint8_t buffer[1024] = { 0 };
- struct string_view dest = {
- .buf = buffer,
- .len = sizeof(buffer),
- };
- /* populate out, to check for leaks. */
- struct reftable_record out = {
- .type = BLOCK_TYPE_LOG,
- .u.log = {
- .refname = xstrdup("old name"),
- .value_type = REFTABLE_LOG_UPDATE,
- .value = {
- .update = {
- .name = xstrdup("old name"),
- .email = xstrdup("old@email"),
- .message = xstrdup("old message"),
- },
- },
- },
- };
- int n, m, valtype;
-
- rec.u.log = in[i];
-
- t_copy(&rec);
-
- reftable_record_key(&rec, &key);
-
- n = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >=, 0);
- valtype = reftable_record_val_type(&rec);
- m = reftable_record_decode(&out, key, valtype, dest,
- REFTABLE_HASH_SIZE_SHA1, &scratch);
- check_int(n, ==, m);
-
- check(reftable_log_record_equal(&in[i], &out.u.log,
- REFTABLE_HASH_SIZE_SHA1));
- reftable_log_record_release(&in[i]);
- reftable_buf_release(&key);
- reftable_record_release(&out);
- }
-
- reftable_buf_release(&scratch);
-}
-
-static void t_key_roundtrip(void)
-{
- uint8_t buffer[1024] = { 0 };
- struct string_view dest = {
- .buf = buffer,
- .len = sizeof(buffer),
- };
- struct reftable_buf last_key = REFTABLE_BUF_INIT;
- struct reftable_buf key = REFTABLE_BUF_INIT;
- struct reftable_buf roundtrip = REFTABLE_BUF_INIT;
- int restart;
- uint8_t extra;
- int n, m;
- uint8_t rt_extra;
-
- check(!reftable_buf_addstr(&last_key, "refs/heads/master"));
- check(!reftable_buf_addstr(&key, "refs/tags/bla"));
- extra = 6;
- n = reftable_encode_key(&restart, dest, last_key, key, extra);
- check(!restart);
- check_int(n, >, 0);
-
- check(!reftable_buf_addstr(&roundtrip, "refs/heads/master"));
- m = reftable_decode_key(&roundtrip, &rt_extra, dest);
- check_int(n, ==, m);
- check(!reftable_buf_cmp(&key, &roundtrip));
- check_int(rt_extra, ==, extra);
-
- reftable_buf_release(&last_key);
- reftable_buf_release(&key);
- reftable_buf_release(&roundtrip);
-}
-
-static void t_reftable_obj_record_comparison(void)
-{
-
- uint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };
- uint64_t offsets[] = { 0, 16, 32, 48, 64, 80, 96, 112};
- struct reftable_record in[3] = {
- {
- .type = BLOCK_TYPE_OBJ,
- .u.obj.hash_prefix = id_bytes,
- .u.obj.hash_prefix_len = 7,
- .u.obj.offsets = offsets,
- .u.obj.offset_len = 8,
- },
- {
- .type = BLOCK_TYPE_OBJ,
- .u.obj.hash_prefix = id_bytes,
- .u.obj.hash_prefix_len = 7,
- .u.obj.offsets = offsets,
- .u.obj.offset_len = 5,
- },
- {
- .type = BLOCK_TYPE_OBJ,
- .u.obj.hash_prefix = id_bytes,
- .u.obj.hash_prefix_len = 5,
- },
- };
- int cmp;
-
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
-
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
-
- in[1].u.obj.offset_len = in[0].u.obj.offset_len;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
-}
-
-static void t_reftable_obj_record_roundtrip(void)
-{
- uint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };
- uint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };
- struct reftable_obj_record recs[3] = {
- {
- .hash_prefix = testHash1,
- .hash_prefix_len = 5,
- .offsets = till9,
- .offset_len = 3,
- },
- {
- .hash_prefix = testHash1,
- .hash_prefix_len = 5,
- .offsets = till9,
- .offset_len = 9,
- },
- {
- .hash_prefix = testHash1,
- .hash_prefix_len = 5,
- },
- };
- struct reftable_buf scratch = REFTABLE_BUF_INIT;
-
- for (size_t i = 0; i < ARRAY_SIZE(recs); i++) {
- uint8_t buffer[1024] = { 0 };
- struct string_view dest = {
- .buf = buffer,
- .len = sizeof(buffer),
- };
- struct reftable_record in = {
- .type = BLOCK_TYPE_OBJ,
- .u = {
- .obj = recs[i],
- },
- };
- struct reftable_buf key = REFTABLE_BUF_INIT;
- struct reftable_record out = { .type = BLOCK_TYPE_OBJ };
- int n, m;
- uint8_t extra;
-
- check(!reftable_record_is_deletion(&in));
- t_copy(&in);
- reftable_record_key(&in, &key);
- n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >, 0);
- extra = reftable_record_val_type(&in);
- m = reftable_record_decode(&out, key, extra, dest,
- REFTABLE_HASH_SIZE_SHA1, &scratch);
- check_int(n, ==, m);
-
- check(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));
- reftable_buf_release(&key);
- reftable_record_release(&out);
- }
-
- reftable_buf_release(&scratch);
-}
-
-static void t_reftable_index_record_comparison(void)
-{
- struct reftable_record in[3] = {
- {
- .type = BLOCK_TYPE_INDEX,
- .u.idx.offset = 22,
- .u.idx.last_key = REFTABLE_BUF_INIT,
- },
- {
- .type = BLOCK_TYPE_INDEX,
- .u.idx.offset = 32,
- .u.idx.last_key = REFTABLE_BUF_INIT,
- },
- {
- .type = BLOCK_TYPE_INDEX,
- .u.idx.offset = 32,
- .u.idx.last_key = REFTABLE_BUF_INIT,
- },
- };
- int cmp;
-
- check(!reftable_buf_addstr(&in[0].u.idx.last_key, "refs/heads/master"));
- check(!reftable_buf_addstr(&in[1].u.idx.last_key, "refs/heads/master"));
- check(!reftable_buf_addstr(&in[2].u.idx.last_key, "refs/heads/branch"));
-
- check(!reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
-
- check(!reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[1], &in[2], &cmp));
- check_int(cmp, >, 0);
-
- in[1].u.idx.offset = in[0].u.idx.offset;
- check(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1));
- check(!reftable_record_cmp(&in[0], &in[1], &cmp));
- check(!cmp);
-
- for (size_t i = 0; i < ARRAY_SIZE(in); i++)
- reftable_record_release(&in[i]);
-}
-
-static void t_reftable_index_record_roundtrip(void)
-{
- struct reftable_record in = {
- .type = BLOCK_TYPE_INDEX,
- .u.idx = {
- .offset = 42,
- .last_key = REFTABLE_BUF_INIT,
- },
- };
- uint8_t buffer[1024] = { 0 };
- struct string_view dest = {
- .buf = buffer,
- .len = sizeof(buffer),
- };
- struct reftable_buf scratch = REFTABLE_BUF_INIT;
- struct reftable_buf key = REFTABLE_BUF_INIT;
- struct reftable_record out = {
- .type = BLOCK_TYPE_INDEX,
- .u.idx = { .last_key = REFTABLE_BUF_INIT },
- };
- int n, m;
- uint8_t extra;
-
- check(!reftable_buf_addstr(&in.u.idx.last_key, "refs/heads/master"));
- reftable_record_key(&in, &key);
- t_copy(&in);
-
- check(!reftable_record_is_deletion(&in));
- check(!reftable_buf_cmp(&key, &in.u.idx.last_key));
- n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
- check_int(n, >, 0);
-
- extra = reftable_record_val_type(&in);
- m = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,
- &scratch);
- check_int(m, ==, n);
-
- check(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1));
-
- reftable_record_release(&out);
- reftable_buf_release(&key);
- reftable_buf_release(&scratch);
- reftable_buf_release(&in.u.idx.last_key);
-}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
- TEST(t_reftable_ref_record_comparison(), "comparison operations work on ref record");
- TEST(t_reftable_log_record_comparison(), "comparison operations work on log record");
- TEST(t_reftable_index_record_comparison(), "comparison operations work on index record");
- TEST(t_reftable_obj_record_comparison(), "comparison operations work on obj record");
- TEST(t_reftable_ref_record_compare_name(), "reftable_ref_record_compare_name works");
- TEST(t_reftable_log_record_compare_key(), "reftable_log_record_compare_key works");
- TEST(t_reftable_log_record_roundtrip(), "record operations work on log record");
- TEST(t_reftable_ref_record_roundtrip(), "record operations work on ref record");
- TEST(t_varint_roundtrip(), "put_var_int and get_var_int work");
- TEST(t_varint_overflow(), "get_var_int notices an integer overflow");
- TEST(t_key_roundtrip(), "reftable_encode_key and reftable_decode_key work");
- TEST(t_reftable_obj_record_roundtrip(), "record operations work on obj record");
- TEST(t_reftable_index_record_roundtrip(), "record operations work on index record");
-
- return test_done();
-}
diff --git a/t/unit-tests/u-reftable-record.c b/t/unit-tests/u-reftable-record.c
new file mode 100644
index 0000000000..ac2e33584c
--- /dev/null
+++ b/t/unit-tests/u-reftable-record.c
@@ -0,0 +1,565 @@
+/*
+ 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 "unit-test.h"
+#include "reftable/basics.h"
+#include "reftable/constants.h"
+#include "reftable/record.h"
+
+static void t_copy(struct reftable_record *rec)
+{
+ struct reftable_record copy;
+ uint8_t typ;
+
+ typ = reftable_record_type(rec);
+ cl_assert(reftable_record_init(©, typ) == 0);
+ reftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);
+ /* do it twice to catch memory leaks */
+ reftable_record_copy_from(©, rec, REFTABLE_HASH_SIZE_SHA1);
+ cl_assert(reftable_record_equal(rec, ©, REFTABLE_HASH_SIZE_SHA1) != 0);
+
+ reftable_record_release(©);
+}
+
+void test_reftable_record__varint_roundtrip(void)
+{
+ uint64_t inputs[] = { 0,
+ 1,
+ 27,
+ 127,
+ 128,
+ 257,
+ 4096,
+ ((uint64_t)1 << 63),
+ ((uint64_t)1 << 63) + ((uint64_t)1 << 63) - 1 };
+
+ for (size_t i = 0; i < ARRAY_SIZE(inputs); i++) {
+ uint8_t dest[10];
+
+ struct string_view out = {
+ .buf = dest,
+ .len = sizeof(dest),
+ };
+ uint64_t in = inputs[i];
+ int n = put_var_int(&out, in);
+ uint64_t got = 0;
+
+ cl_assert(n > 0);
+ out.len = n;
+ n = get_var_int(&got, &out);
+ cl_assert(n > 0);
+
+ cl_assert_equal_i(got, in);
+ }
+}
+
+void test_reftable_record__varint_overflow(void)
+{
+ unsigned char buf[] = {
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x00,
+ };
+ struct string_view view = {
+ .buf = buf,
+ .len = sizeof(buf),
+ };
+ uint64_t value;
+ cl_assert_equal_i(get_var_int(&value, &view), -1);
+}
+
+static void set_hash(uint8_t *h, int j)
+{
+ for (size_t i = 0; i < hash_size(REFTABLE_HASH_SHA1); i++)
+ h[i] = (j >> i) & 0xff;
+}
+
+void test_reftable_record__ref_record_comparison(void)
+{
+ struct reftable_record in[3] = {
+ {
+ .type = BLOCK_TYPE_REF,
+ .u.ref.refname = (char *) "refs/heads/master",
+ .u.ref.value_type = REFTABLE_REF_VAL1,
+ },
+ {
+ .type = BLOCK_TYPE_REF,
+ .u.ref.refname = (char *) "refs/heads/master",
+ .u.ref.value_type = REFTABLE_REF_DELETION,
+ },
+ {
+ .type = BLOCK_TYPE_REF,
+ .u.ref.refname = (char *) "HEAD",
+ .u.ref.value_type = REFTABLE_REF_SYMREF,
+ .u.ref.value.symref = (char *) "refs/heads/master",
+ },
+ };
+ int cmp;
+
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
+
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
+
+ in[1].u.ref.value_type = in[0].u.ref.value_type;
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
+}
+
+void test_reftable_record__ref_record_compare_name(void)
+{
+ struct reftable_ref_record recs[3] = {
+ {
+ .refname = (char *) "refs/heads/a"
+ },
+ {
+ .refname = (char *) "refs/heads/b"
+ },
+ {
+ .refname = (char *) "refs/heads/a"
+ },
+ };
+
+ cl_assert(reftable_ref_record_compare_name(&recs[0], &recs[1]) < 0);
+ cl_assert(reftable_ref_record_compare_name(&recs[1], &recs[0]) > 0);
+ cl_assert_equal_i(reftable_ref_record_compare_name(&recs[0], &recs[2]), 0);
+}
+
+void test_reftable_record__ref_record_roundtrip(void)
+{
+ struct reftable_buf scratch = REFTABLE_BUF_INIT;
+
+ for (int i = REFTABLE_REF_DELETION; i < REFTABLE_NR_REF_VALUETYPES; i++) {
+ struct reftable_record in = {
+ .type = BLOCK_TYPE_REF,
+ .u.ref.value_type = i,
+ };
+ struct reftable_record out = { .type = BLOCK_TYPE_REF };
+ struct reftable_buf key = REFTABLE_BUF_INIT;
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
+ .buf = buffer,
+ .len = sizeof(buffer),
+ };
+ int n, m;
+
+ in.u.ref.value_type = i;
+ switch (i) {
+ case REFTABLE_REF_DELETION:
+ break;
+ case REFTABLE_REF_VAL1:
+ set_hash(in.u.ref.value.val1, 1);
+ break;
+ case REFTABLE_REF_VAL2:
+ set_hash(in.u.ref.value.val2.value, 1);
+ set_hash(in.u.ref.value.val2.target_value, 2);
+ break;
+ case REFTABLE_REF_SYMREF:
+ in.u.ref.value.symref = xstrdup("target");
+ break;
+ }
+ in.u.ref.refname = xstrdup("refs/heads/master");
+
+ t_copy(&in);
+
+ cl_assert_equal_i(reftable_record_val_type(&in), i);
+ cl_assert_equal_i(reftable_record_is_deletion(&in), i == REFTABLE_REF_DELETION);
+
+ reftable_record_key(&in, &key);
+ n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
+ cl_assert(n > 0);
+
+ /* decode into a non-zero reftable_record to test for leaks. */
+ m = reftable_record_decode(&out, key, i, dest, REFTABLE_HASH_SIZE_SHA1, &scratch);
+ cl_assert_equal_i(n, m);
+
+ cl_assert(reftable_ref_record_equal(&in.u.ref, &out.u.ref,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
+ reftable_record_release(&in);
+
+ reftable_buf_release(&key);
+ reftable_record_release(&out);
+ }
+
+ reftable_buf_release(&scratch);
+}
+
+void test_reftable_record__log_record_comparison(void)
+{
+ struct reftable_record in[3] = {
+ {
+ .type = BLOCK_TYPE_LOG,
+ .u.log.refname = (char *) "refs/heads/master",
+ .u.log.update_index = 42,
+ },
+ {
+ .type = BLOCK_TYPE_LOG,
+ .u.log.refname = (char *) "refs/heads/master",
+ .u.log.update_index = 22,
+ },
+ {
+ .type = BLOCK_TYPE_LOG,
+ .u.log.refname = (char *) "refs/heads/main",
+ .u.log.update_index = 22,
+ },
+ };
+ int cmp;
+
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
+ /* comparison should be reversed for equal keys, because
+ * comparison is now performed on the basis of update indices */
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp < 0);
+
+ in[1].u.log.update_index = in[0].u.log.update_index;
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+}
+
+void test_reftable_record__log_record_compare_key(void)
+{
+ struct reftable_log_record logs[3] = {
+ {
+ .refname = (char *) "refs/heads/a",
+ .update_index = 1,
+ },
+ {
+ .refname = (char *) "refs/heads/b",
+ .update_index = 2,
+ },
+ {
+ .refname = (char *) "refs/heads/a",
+ .update_index = 3,
+ },
+ };
+
+ cl_assert(reftable_log_record_compare_key(&logs[0], &logs[1]) < 0);
+ cl_assert(reftable_log_record_compare_key(&logs[1], &logs[0]) > 0);
+
+ logs[1].update_index = logs[0].update_index;
+ cl_assert(reftable_log_record_compare_key(&logs[0], &logs[1]) < 0);
+
+ cl_assert(reftable_log_record_compare_key(&logs[0], &logs[2]) > 0);
+ cl_assert(reftable_log_record_compare_key(&logs[2], &logs[0]) < 0);
+ logs[2].update_index = logs[0].update_index;
+ cl_assert_equal_i(reftable_log_record_compare_key(&logs[0], &logs[2]), 0);
+}
+
+void test_reftable_record__log_record_roundtrip(void)
+{
+ struct reftable_log_record in[] = {
+ {
+ .refname = xstrdup("refs/heads/master"),
+ .update_index = 42,
+ .value_type = REFTABLE_LOG_UPDATE,
+ .value = {
+ .update = {
+ .name = xstrdup("han-wen"),
+ .email = xstrdup("hanwen@xxxxxxxxxx"),
+ .message = xstrdup("test"),
+ .time = 1577123507,
+ .tz_offset = 100,
+ },
+ }
+ },
+ {
+ .refname = xstrdup("refs/heads/master"),
+ .update_index = 22,
+ .value_type = REFTABLE_LOG_DELETION,
+ },
+ {
+ .refname = xstrdup("branch"),
+ .update_index = 33,
+ .value_type = REFTABLE_LOG_UPDATE,
+ }
+ };
+ struct reftable_buf scratch = REFTABLE_BUF_INIT;
+ set_hash(in[0].value.update.new_hash, 1);
+ set_hash(in[0].value.update.old_hash, 2);
+ set_hash(in[2].value.update.new_hash, 3);
+ set_hash(in[2].value.update.old_hash, 4);
+
+ cl_assert(reftable_log_record_is_deletion(&in[0]) == 0);
+ cl_assert(reftable_log_record_is_deletion(&in[1]) != 0);
+ cl_assert(reftable_log_record_is_deletion(&in[2]) == 0);
+
+ for (size_t i = 0; i < ARRAY_SIZE(in); i++) {
+ struct reftable_record rec = { .type = BLOCK_TYPE_LOG };
+ struct reftable_buf key = REFTABLE_BUF_INIT;
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
+ .buf = buffer,
+ .len = sizeof(buffer),
+ };
+ /* populate out, to check for leaks. */
+ struct reftable_record out = {
+ .type = BLOCK_TYPE_LOG,
+ .u.log = {
+ .refname = xstrdup("old name"),
+ .value_type = REFTABLE_LOG_UPDATE,
+ .value = {
+ .update = {
+ .name = xstrdup("old name"),
+ .email = xstrdup("old@email"),
+ .message = xstrdup("old message"),
+ },
+ },
+ },
+ };
+ int n, m, valtype;
+
+ rec.u.log = in[i];
+
+ t_copy(&rec);
+
+ reftable_record_key(&rec, &key);
+
+ n = reftable_record_encode(&rec, dest, REFTABLE_HASH_SIZE_SHA1);
+ cl_assert(n >= 0);
+ valtype = reftable_record_val_type(&rec);
+ m = reftable_record_decode(&out, key, valtype, dest,
+ REFTABLE_HASH_SIZE_SHA1, &scratch);
+ cl_assert_equal_i(n, m);
+
+ cl_assert(reftable_log_record_equal(&in[i], &out.u.log,
+ REFTABLE_HASH_SIZE_SHA1) != 0);
+ reftable_log_record_release(&in[i]);
+ reftable_buf_release(&key);
+ reftable_record_release(&out);
+ }
+
+ reftable_buf_release(&scratch);
+}
+
+void test_reftable_record__key_roundtrip(void)
+{
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
+ .buf = buffer,
+ .len = sizeof(buffer),
+ };
+ struct reftable_buf last_key = REFTABLE_BUF_INIT;
+ struct reftable_buf key = REFTABLE_BUF_INIT;
+ struct reftable_buf roundtrip = REFTABLE_BUF_INIT;
+ int restart;
+ uint8_t extra;
+ int n, m;
+ uint8_t rt_extra;
+
+ cl_assert(reftable_buf_addstr(&last_key, "refs/heads/master") == 0);
+ cl_assert(reftable_buf_addstr(&key, "refs/tags/bla") == 0);
+ extra = 6;
+ n = reftable_encode_key(&restart, dest, last_key, key, extra);
+ cl_assert(restart == 0);
+ cl_assert(n > 0);
+
+ cl_assert(reftable_buf_addstr(&roundtrip, "refs/heads/master") == 0);
+ m = reftable_decode_key(&roundtrip, &rt_extra, dest);
+ cl_assert_equal_i(n, m);
+ cl_assert(reftable_buf_cmp(&key, &roundtrip) == 0);
+ cl_assert_equal_i(rt_extra, extra);
+
+ reftable_buf_release(&last_key);
+ reftable_buf_release(&key);
+ reftable_buf_release(&roundtrip);
+}
+
+void test_reftable_record__obj_record_comparison(void)
+{
+
+ uint8_t id_bytes[] = { 0, 1, 2, 3, 4, 5, 6 };
+ uint64_t offsets[] = { 0, 16, 32, 48, 64, 80, 96, 112};
+ struct reftable_record in[3] = {
+ {
+ .type = BLOCK_TYPE_OBJ,
+ .u.obj.hash_prefix = id_bytes,
+ .u.obj.hash_prefix_len = 7,
+ .u.obj.offsets = offsets,
+ .u.obj.offset_len = 8,
+ },
+ {
+ .type = BLOCK_TYPE_OBJ,
+ .u.obj.hash_prefix = id_bytes,
+ .u.obj.hash_prefix_len = 7,
+ .u.obj.offsets = offsets,
+ .u.obj.offset_len = 5,
+ },
+ {
+ .type = BLOCK_TYPE_OBJ,
+ .u.obj.hash_prefix = id_bytes,
+ .u.obj.hash_prefix_len = 5,
+ },
+ };
+ int cmp;
+
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
+
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
+
+ in[1].u.obj.offset_len = in[0].u.obj.offset_len;
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
+}
+
+void test_reftable_record__obj_record_roundtrip(void)
+{
+ uint8_t testHash1[REFTABLE_HASH_SIZE_SHA1] = { 1, 2, 3, 4, 0 };
+ uint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };
+ struct reftable_obj_record recs[3] = {
+ {
+ .hash_prefix = testHash1,
+ .hash_prefix_len = 5,
+ .offsets = till9,
+ .offset_len = 3,
+ },
+ {
+ .hash_prefix = testHash1,
+ .hash_prefix_len = 5,
+ .offsets = till9,
+ .offset_len = 9,
+ },
+ {
+ .hash_prefix = testHash1,
+ .hash_prefix_len = 5,
+ },
+ };
+ struct reftable_buf scratch = REFTABLE_BUF_INIT;
+
+ for (size_t i = 0; i < ARRAY_SIZE(recs); i++) {
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
+ .buf = buffer,
+ .len = sizeof(buffer),
+ };
+ struct reftable_record in = {
+ .type = BLOCK_TYPE_OBJ,
+ .u = {
+ .obj = recs[i],
+ },
+ };
+ struct reftable_buf key = REFTABLE_BUF_INIT;
+ struct reftable_record out = { .type = BLOCK_TYPE_OBJ };
+ int n, m;
+ uint8_t extra;
+
+ cl_assert(reftable_record_is_deletion(&in) == 0);
+ t_copy(&in);
+ reftable_record_key(&in, &key);
+ n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
+ cl_assert(n > 0);
+ extra = reftable_record_val_type(&in);
+ m = reftable_record_decode(&out, key, extra, dest,
+ REFTABLE_HASH_SIZE_SHA1, &scratch);
+ cl_assert_equal_i(n, m);
+
+ cl_assert(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1) != 0);
+ reftable_buf_release(&key);
+ reftable_record_release(&out);
+ }
+
+ reftable_buf_release(&scratch);
+}
+
+void test_reftable_record__index_record_comparison(void)
+{
+ struct reftable_record in[3] = {
+ {
+ .type = BLOCK_TYPE_INDEX,
+ .u.idx.offset = 22,
+ .u.idx.last_key = REFTABLE_BUF_INIT,
+ },
+ {
+ .type = BLOCK_TYPE_INDEX,
+ .u.idx.offset = 32,
+ .u.idx.last_key = REFTABLE_BUF_INIT,
+ },
+ {
+ .type = BLOCK_TYPE_INDEX,
+ .u.idx.offset = 32,
+ .u.idx.last_key = REFTABLE_BUF_INIT,
+ },
+ };
+ int cmp;
+
+ cl_assert(reftable_buf_addstr(&in[0].u.idx.last_key, "refs/heads/master") == 0);
+ cl_assert(reftable_buf_addstr(&in[1].u.idx.last_key, "refs/heads/master") == 0);
+ cl_assert(reftable_buf_addstr(&in[2].u.idx.last_key, "refs/heads/branch") == 0);
+
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
+
+ cl_assert(reftable_record_equal(&in[1], &in[2], REFTABLE_HASH_SIZE_SHA1) == 0);
+ cl_assert(reftable_record_cmp(&in[1], &in[2], &cmp) == 0);
+ cl_assert(cmp > 0);
+
+ in[1].u.idx.offset = in[0].u.idx.offset;
+ cl_assert(reftable_record_equal(&in[0], &in[1], REFTABLE_HASH_SIZE_SHA1) != 0);
+ cl_assert(reftable_record_cmp(&in[0], &in[1], &cmp) == 0);
+ cl_assert(cmp == 0);
+
+ for (size_t i = 0; i < ARRAY_SIZE(in); i++)
+ reftable_record_release(&in[i]);
+}
+
+void test_reftable_record__index_record_roundtrip(void)
+{
+ struct reftable_record in = {
+ .type = BLOCK_TYPE_INDEX,
+ .u.idx = {
+ .offset = 42,
+ .last_key = REFTABLE_BUF_INIT,
+ },
+ };
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
+ .buf = buffer,
+ .len = sizeof(buffer),
+ };
+ struct reftable_buf scratch = REFTABLE_BUF_INIT;
+ struct reftable_buf key = REFTABLE_BUF_INIT;
+ struct reftable_record out = {
+ .type = BLOCK_TYPE_INDEX,
+ .u.idx = { .last_key = REFTABLE_BUF_INIT },
+ };
+ int n, m;
+ uint8_t extra;
+
+ cl_assert(reftable_buf_addstr(&in.u.idx.last_key, "refs/heads/master") == 0);
+ reftable_record_key(&in, &key);
+ t_copy(&in);
+
+ cl_assert(reftable_record_is_deletion(&in) == 0);
+ cl_assert(reftable_buf_cmp(&key, &in.u.idx.last_key) == 0);
+ n = reftable_record_encode(&in, dest, REFTABLE_HASH_SIZE_SHA1);
+ cl_assert(n > 0);
+
+ extra = reftable_record_val_type(&in);
+ m = reftable_record_decode(&out, key, extra, dest, REFTABLE_HASH_SIZE_SHA1,
+ &scratch);
+ cl_assert_equal_i(m, n);
+
+ cl_assert(reftable_record_equal(&in, &out, REFTABLE_HASH_SIZE_SHA1) != 0);
+
+ reftable_record_release(&out);
+ reftable_buf_release(&key);
+ reftable_buf_release(&scratch);
+ reftable_buf_release(&in.u.idx.last_key);
+}
--
2.43.0
