[Tarantool-patches] [PATCH luajit] test: add tests for the leb128 encode/decode
Sergey Kaplun
skaplun at tarantool.org
Wed Jul 22 17:00:36 MSK 2026
This patch is a follow-up to the commit
7058e9215f8a50d00701302ecbb510503d21148d ("utils: introduce leb128
reader and writer").
The leb128 encoding is used inside our profilers (memprof/sysprof). But
there are no tests for this module, so its coverage is low, since only
`lj_utils_write_uleb128()` is used. Also, there is no correctness check
for this implementation.
This patch adapts the LuaVela tests [1] to cover this module. Since the
initial version of the module wasn't adapted as is, the guarded version
of the reader functions has different behaviour for zero-sized requested
reads. Hence, this case is removed for now. The readers with a requested
size are unused in our code, so this is not crucial at the moment.
Also, this patch fixes the UBSan warning in the
`lj_utils_write_leb128()` on checking the remaining value to be written
by fixing the cast to uint64_t.
[1]: https://github.com/luavela/luavela/blob/288e8a95218ed47dad93016259533406e30b109b/tests/impl/uJIT-tests-C/suite/test_leb128.c
---
The main idea of the patch is to increase coverage for the
lj_utils_leb128.c. The UBSan "bug" (not really, since this part is
unused, anyway) is fixed as a side effect. You may compare the coverage
between master [1] and this branch [2] with coveralls.
Branch: https://github.com/tarantool/luajit/tree/skaplun/gh-noticket-leb128-testsing
[1]: https://coveralls.io/builds/80394140/source?filename=src%2Flj_utils_leb128.c
[2]: https://coveralls.io/builds/80728053/source?filename=src%2Flj_utils_leb128.c
src/lj_utils_leb128.c | 2 +-
test/tarantool-c-tests/unit-leb128.test.c | 366 ++++++++++++++++++++++
2 files changed, 367 insertions(+), 1 deletion(-)
create mode 100644 test/tarantool-c-tests/unit-leb128.test.c
diff --git a/src/lj_utils_leb128.c b/src/lj_utils_leb128.c
index d66961da..5ad2bd3c 100644
--- a/src/lj_utils_leb128.c
+++ b/src/lj_utils_leb128.c
@@ -105,7 +105,7 @@ size_t LJ_FASTCALL lj_utils_write_leb128(uint8_t *buffer, int64_t value)
size_t i = 0;
/* LEB_SIGN_BIT propagation to check the remaining value. */
- while ((uint64_t)(value + LEB_SIGN_BIT) >= MIN_TWOBYTE_VALUE) {
+ while ((uint64_t)value + LEB_SIGN_BIT >= MIN_TWOBYTE_VALUE) {
buffer[i++] = (uint8_t)((value & PAYLOAD_MASK) | LINK_BIT);
value >>= SHIFT_STEP;
}
diff --git a/test/tarantool-c-tests/unit-leb128.test.c b/test/tarantool-c-tests/unit-leb128.test.c
new file mode 100644
index 00000000..142476fb
--- /dev/null
+++ b/test/tarantool-c-tests/unit-leb128.test.c
@@ -0,0 +1,366 @@
+/*
+** Testing of LEB128/ULEB128 encoding.
+**
+** Major portions taken verbatim or adapted from the LuaVela.
+** Copyright (C) 2020-2026 LuaVela Authors.
+** Copyright (C) 2015-2020 IPONWEB Ltd.
+*/
+
+#include <stdint.h>
+#include <string.h>
+
+#include "test.h"
+
+#include "lj_utils.h"
+
+#define BUFFER_SIZE 16
+
+static int test_write_uleb128(void *state)
+{
+ size_t bytes_written = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x0);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 64);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x40);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 128);
+ assert_true(bytes_written == 2);
+ assert_true(buffer[0] == 0x80 && buffer[1] == 0x01);
+
+ bytes_written = lj_utils_write_uleb128(buffer, UINT64_MAX);
+ assert_true(bytes_written == 10);
+ assert_true(buffer[0] == 0xff && buffer[1] == 0xff &&
+ buffer[2] == 0xff && buffer[3] == 0xff &&
+ buffer[4] == 0xff && buffer[5] == 0xff &&
+ buffer[6] == 0xff && buffer[7] == 0xff &&
+ buffer[8] == 0xff && buffer[9] == 0x01);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+static int test_write_leb128(void *state)
+{
+ size_t bytes_written = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ bytes_written = lj_utils_write_leb128(buffer, 0);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x0);
+
+ bytes_written = lj_utils_write_leb128(buffer, -624485);
+ assert_true(bytes_written == 3);
+ assert_true(buffer[0] == 0x9b && buffer[1] == 0xf1 &&
+ buffer[2] == 0x59);
+
+ bytes_written = lj_utils_write_leb128(buffer, INT64_MIN);
+ assert_true(bytes_written == 10);
+ assert_true(buffer[0] == 0x80 && buffer[1] == 0x80 &&
+ buffer[2] == 0x80 && buffer[3] == 0x80 &&
+ buffer[4] == 0x80 && buffer[5] == 0x80 &&
+ buffer[6] == 0x80 && buffer[7] == 0x80 &&
+ buffer[8] == 0x80 && buffer[9] == 0x7f);
+
+ bytes_written = lj_utils_write_leb128(buffer, INT64_MAX);
+ assert_true(bytes_written == 10);
+ assert_true(buffer[0] == 0xff && buffer[1] == 0xff &&
+ buffer[2] == 0xff && buffer[3] == 0xff &&
+ buffer[4] == 0xff && buffer[5] == 0xff &&
+ buffer[6] == 0xff && buffer[7] == 0xff &&
+ buffer[8] == 0xff && buffer[9] == 0x00);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+/* Test miscellaneous writes, both signed and unsigned. */
+static int test_misc_writes(void *state)
+{
+ size_t bytes_written = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ bytes_written = lj_utils_write_leb128(buffer, 0x10);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x10);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0x10);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x10);
+
+ bytes_written = lj_utils_write_leb128(buffer, -0x3b);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x45);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0x45);
+ assert_true(bytes_written == 1);
+ assert_true(buffer[0] == 0x45);
+
+ bytes_written = lj_utils_write_leb128(buffer, 0x190e);
+ assert_true(bytes_written == 2);
+ assert_true(buffer[0] == 0x8e && buffer[1] == 0x32);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0x190e);
+ assert_true(bytes_written == 2);
+ assert_true(buffer[0] == 0x8e && buffer[1] == 0x32);
+
+ bytes_written = lj_utils_write_leb128(buffer, -0x143f);
+ assert_true(bytes_written == 2);
+ assert_true(buffer[0] == 0xc1 && buffer[1] == 0x57);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0x2bc1);
+ assert_true(bytes_written == 2);
+ assert_true(buffer[0] == 0xc1 && buffer[1] == 0x57);
+
+ bytes_written = lj_utils_write_leb128(buffer, 0x7e00000);
+ assert_true(bytes_written == 4);
+ assert_true(buffer[0] == 0x80 && buffer[1] == 0x80 &&
+ buffer[2] == 0x80 && buffer[3] == 0x3f);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0x7e00000);
+ assert_true(bytes_written == 4);
+ assert_true(buffer[0] == 0x80 && buffer[1] == 0x80 &&
+ buffer[2] == 0x80 && buffer[3] == 0x3f);
+
+ bytes_written = lj_utils_write_leb128(buffer, -0x6200000);
+ assert_true(bytes_written == 4);
+ assert_true(buffer[0] == 0x80 && buffer[1] == 0x80 &&
+ buffer[2] == 0x80 && buffer[3] == 0x4f);
+
+ bytes_written = lj_utils_write_uleb128(buffer, 0x9e00000);
+ assert_true(bytes_written == 4);
+ assert_true(buffer[0] == 0x80 && buffer[1] == 0x80 &&
+ buffer[2] == 0x80 && buffer[3] == 0x4f);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+static int test_read_uleb128(void *state)
+{
+ uint64_t value = 0;
+ size_t bytes_read = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ bytes_read = lj_utils_read_uleb128(&value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(value == 0);
+
+ buffer[0] = 0x40;
+ bytes_read = lj_utils_read_uleb128(&value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(value == 64);
+
+ buffer[0] = 0x80;
+ buffer[1] = 0x01;
+ bytes_read = lj_utils_read_uleb128(&value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(value == 128);
+
+ memset(buffer, 0xff, 9);
+ buffer[9] = 0x01;
+ bytes_read = lj_utils_read_uleb128(&value, buffer);
+ assert_true(bytes_read == 10);
+ assert_true(value == UINT64_MAX);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+static int test_read_leb128(void *state)
+{
+ int64_t value = 0;
+ size_t bytes_read = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ bytes_read = lj_utils_read_leb128(&value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(value == 0);
+
+ buffer[0] = 0x9b;
+ buffer[1] = 0xf1;
+ buffer[2] = 0x59;
+ bytes_read = lj_utils_read_leb128(&value, buffer);
+ assert_true(bytes_read == 3);
+ assert_true(value == (int64_t)-624485);
+
+ memset(buffer, 0x80, 9);
+ buffer[9] = 0x7f;
+ bytes_read = lj_utils_read_leb128(&value, buffer);
+ assert_true(bytes_read == 10);
+ assert_true(value == INT64_MIN);
+
+ memset(buffer, 0xff, 9);
+ buffer[9] = 0x00;
+ bytes_read = lj_utils_read_leb128(&value, buffer);
+ assert_true(bytes_read == 10);
+ assert_true(value == INT64_MAX);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+/* Test miscellaneous reads, both signed and unsigned. */
+static int test_misc_reads(void *state)
+{
+ int64_t i_value = 0;
+ uint64_t u_value = 0;
+
+ size_t bytes_read = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ buffer[0] = 0x10;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(i_value == (int64_t)0x10);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(u_value == (uint64_t)0x10);
+
+ buffer[0] = 0x45;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(i_value == (int64_t)-0x3b);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 1);
+ assert_true(u_value == (uint64_t)0x45);
+
+ buffer[0] = 0x8e;
+ buffer[1] = 0x32;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(i_value == (int64_t)0x190e);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(u_value == (uint64_t)0x190e);
+
+ buffer[0] = 0xc1;
+ buffer[1] = 0x57;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(i_value == (int64_t)-0x143f);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(u_value == (uint64_t)0x2bc1);
+
+ buffer[0] = 0xc1;
+ buffer[1] = 0x57;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(i_value == (int64_t)-0x143f);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 2);
+ assert_true(u_value == (uint64_t)0x2bc1);
+
+ buffer[0] = 0x80;
+ buffer[1] = 0x80;
+ buffer[2] = 0x80;
+ buffer[3] = 0x3f;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 4);
+ assert_true(i_value == (int64_t)0x7e00000);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 4);
+ assert_true(u_value == (uint64_t)0x7e00000);
+
+ buffer[0] = 0x80;
+ buffer[1] = 0x80;
+ buffer[2] = 0x80;
+ buffer[3] = 0x4f;
+
+ bytes_read = lj_utils_read_leb128(&i_value, buffer);
+ assert_true(bytes_read == 4);
+ assert_true(i_value == (int64_t)-0x6200000);
+
+ bytes_read = lj_utils_read_uleb128(&u_value, buffer);
+ assert_true(bytes_read == 4);
+ assert_true(u_value == (uint64_t)0x9e00000);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+static int test_read_n(void *state)
+{
+ int64_t i_value = 0;
+ uint64_t u_value = 0;
+
+ size_t bytes_read = 0;
+ uint8_t buffer[BUFFER_SIZE] = {0};
+
+ UNUSED(state);
+
+ bytes_read = lj_utils_read_leb128_n(&i_value, buffer, 1);
+ assert_true(bytes_read == 1);
+ assert_true(i_value == 0);
+
+ bytes_read = lj_utils_read_uleb128_n(&u_value, buffer, 1);
+ assert_true(bytes_read == 1);
+ assert_true(u_value == 0);
+
+ buffer[0] = 0x80;
+ buffer[1] = 0x80;
+ buffer[2] = 0x80;
+ buffer[3] = 0x3f;
+
+ assert_true(lj_utils_read_leb128_n(&i_value, buffer, 3) == 0);
+ assert_true(lj_utils_read_uleb128_n(&u_value, buffer, 3) == 0);
+ /* Values are untouched in case of failure. */
+ assert_true(i_value == 0);
+ assert_true(u_value == 0);
+
+ bytes_read = lj_utils_read_leb128_n(&i_value, buffer, 4);
+ assert_true(bytes_read == 4);
+ assert_true(i_value == (int64_t)0x7e00000);
+
+ bytes_read = lj_utils_read_uleb128_n(&u_value, buffer, 4);
+ assert_true(bytes_read == 4);
+ assert_true(u_value == (uint64_t)0x7e00000);
+
+ bytes_read = lj_utils_read_leb128_n(&i_value, buffer, 5);
+ assert_true(bytes_read == 4);
+ assert_true(i_value == (int64_t)0x7e00000);
+
+ bytes_read = lj_utils_read_uleb128_n(&u_value, buffer, 5);
+ assert_true(bytes_read == 4);
+ assert_true(u_value == (uint64_t)0x7e00000);
+
+ return TEST_EXIT_SUCCESS;
+}
+
+int main(void)
+{
+ const struct test_unit tgroup[] = {
+ test_unit_def(test_write_uleb128),
+ test_unit_def(test_write_leb128),
+ test_unit_def(test_misc_writes),
+ test_unit_def(test_read_uleb128),
+ test_unit_def(test_read_leb128),
+ test_unit_def(test_misc_reads),
+ test_unit_def(test_read_n),
+ };
+ const int test_result = test_run_group(tgroup, NULL);
+ return test_result;
+}
--
2.55.0
More information about the Tarantool-patches
mailing list