@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/src/rdunittest.h

@@ -0,0 +1,232 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2017-2022, Magnus Edenhill
+ *               2025, Confluent Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _RD_UNITTEST_H
+#define _RD_UNITTEST_H
+
+#include <stdio.h>
+
+
+extern rd_bool_t rd_unittest_assert_on_failure;
+extern rd_bool_t rd_unittest_on_ci;
+extern rd_bool_t rd_unittest_with_valgrind;
+extern rd_bool_t rd_unittest_slow;
+
+#define ENABLE_CODECOV ENABLE_DEVEL
+
+
+/**
+ * @brief Begin single unit-test function (optional).
+ *        Currently only used for logging.
+ */
+#define RD_UT_BEGIN()                                                          \
+        fprintf(stderr, "\033[34mRDUT: INFO: %s:%d: %s: BEGIN: \033[0m\n",     \
+                __FILE__, __LINE__, __FUNCTION__)
+
+
+/**
+ * @brief Fail the current unit-test function.
+ */
+#define RD_UT_FAIL(...)                                                        \
+        do {                                                                   \
+                fprintf(stderr, "\033[31mRDUT: FAIL: %s:%d: %s: ", __FILE__,   \
+                        __LINE__, __FUNCTION__);                               \
+                fprintf(stderr, __VA_ARGS__);                                  \
+                fprintf(stderr, "\033[0m\n");                                  \
+                if (rd_unittest_assert_on_failure)                             \
+                        rd_assert(!*"unittest failure");                       \
+                return 1;                                                      \
+        } while (0)
+
+/**
+ * @brief Pass the current unit-test function
+ */
+#define RD_UT_PASS()                                                           \
+        do {                                                                   \
+                fprintf(stderr, "\033[32mRDUT: PASS: %s:%d: %s\033[0m\n",      \
+                        __FILE__, __LINE__, __FUNCTION__);                     \
+                return 0;                                                      \
+        } while (0)
+
+/**
+ * @brief Skip the current unit-test function
+ */
+#define RD_UT_SKIP(...)                                                        \
+        do {                                                                   \
+                fprintf(stderr, "\033[33mRDUT: SKIP: %s:%d: %s: ", __FILE__,   \
+                        __LINE__, __FUNCTION__);                               \
+                fprintf(stderr, __VA_ARGS__);                                  \
+                fprintf(stderr, "\033[0m\n");                                  \
+                return 0;                                                      \
+        } while (0)
+
+
+/**
+ * @brief Fail unit-test if \p expr is false
+ */
+#define RD_UT_ASSERT(expr, ...)                                                \
+        do {                                                                   \
+                if (!(expr)) {                                                 \
+                        fprintf(stderr,                                        \
+                                "\033[31mRDUT: FAIL: %s:%d: %s: "              \
+                                "assert failed: " #expr ": ",                  \
+                                __FILE__, __LINE__, __FUNCTION__);             \
+                        fprintf(stderr, __VA_ARGS__);                          \
+                        fprintf(stderr, "\033[0m\n");                          \
+                        if (rd_unittest_assert_on_failure)                     \
+                                rd_assert(expr);                               \
+                        return 1;                                              \
+                }                                                              \
+        } while (0)
+
+
+/**
+ * @brief Check that value \p V is within inclusive range \p VMIN .. \p VMAX,
+ *        else asserts.
+ *
+ * @param VFMT is the printf formatter for \p V's type
+ */
+#define RD_UT_ASSERT_RANGE(V, VMIN, VMAX, VFMT)                                \
+        RD_UT_ASSERT((VMIN) <= (V) && (VMAX) >= (V),                           \
+                     VFMT " out of range " VFMT " .. " VFMT, (V), (VMIN),      \
+                     (VMAX))
+
+
+/**
+ * @brief Log something from a unit-test
+ */
+#define RD_UT_SAY(...)                                                         \
+        do {                                                                   \
+                fprintf(stderr, "RDUT: INFO: %s:%d: %s: ", __FILE__, __LINE__, \
+                        __FUNCTION__);                                         \
+                fprintf(stderr, __VA_ARGS__);                                  \
+                fprintf(stderr, "\n");                                         \
+        } while (0)
+
+
+/**
+ * @brief Warn about something from a unit-test
+ */
+#define RD_UT_WARN(...)                                                        \
+        do {                                                                   \
+                fprintf(stderr, "\033[33mRDUT: WARN: %s:%d: %s: ", __FILE__,   \
+                        __LINE__, __FUNCTION__);                               \
+                fprintf(stderr, __VA_ARGS__);                                  \
+                fprintf(stderr, "\033[0m\n");                                  \
+        } while (0)
+
+
+
+int rd_unittest(void);
+
+
+
+/**
+ * @name Manual code coverage
+ *
+ * The RD_UT_COVERAGE*() set of macros are used to perform manual
+ * code coverage testing.
+ * This provides an alternative to object and state inspection by
+ * instead verifying that certain code paths (typically error paths)
+ * are executed, allowing functional black-box testing on the one part
+ * combined with precise knowledge of code flow on the other part.
+ *
+ * How to use:
+ *
+ * 1. First identify a code path that you want to make sure is executed, such
+ *    as a corner error case, increase RD_UT_COVNR_MAX (below) and use the
+ *    new max number as the coverage number (COVNR).
+ *
+ * 2. In the code path add RD_UT_COVERAGE(your_covnr).
+ *
+ * 3. Write a unittest case that is supposed to trigger the code path.
+ *
+ * 4. In the unittest, add a call to RD_UT_COVERAGE_CHECK(your_covnr) at the
+ *    point where you expect the code path to have executed.
+ *
+ * 5. RD_UT_COVERAGE_CHECK(your_covnr) will fail the current test, but not
+ *    return from your test function, so you need to `return 1;` if
+ *    RD_UT_COVERAGE_CHECK(your_covnr) returns 0, e.g:
+ *
+ *         if (!RD_UT_COVERAGE_CHECK(your_covnr))
+ *              return 1; -- failure
+ *
+ * 6. Run the unit tests with `make unit` in tests/.
+ *
+ * 7. If the code path was not executed your test will fail, otherwise pass.
+ *
+ *
+ * Code coverage checks require --enable-devel.
+ *
+ * There is a script in packaging/tools/rdutcoverage.sh that checks that
+ * code coverage numbers are not reused.
+ *
+ * @{
+ */
+
+#if ENABLE_CODECOV
+
+/* @define When adding new code coverages, use the next value and increment
+ *         this maximum accordingly. */
+#define RD_UT_COVNR_MAX 1
+
+/**
+ * @brief Register code as covered/executed.
+ */
+#define RD_UT_COVERAGE(COVNR)                                                  \
+        rd_ut_coverage(__FILE__, __FUNCTION__, __LINE__, COVNR)
+
+/**
+ * @returns how many times the code was executed.
+ *          will fail the unit test (but not return) if code has not
+ *          been executed.
+ */
+#define RD_UT_COVERAGE_CHECK(COVNR)                                            \
+        rd_ut_coverage_check(__FILE__, __FUNCTION__, __LINE__, COVNR)
+
+
+void rd_ut_coverage(const char *file, const char *func, int line, int covnr);
+int64_t
+rd_ut_coverage_check(const char *file, const char *func, int line, int covnr);
+
+#else
+
+/* Does nothing if ENABLE_CODECOV is not set */
+#define RD_UT_COVERAGE(COVNR)                                                  \
+        do {                                                                   \
+        } while (0)
+#define RD_UT_COVERAGE_CHECK(COVNR) 1
+
+#endif /* ENABLE_CODECOV */
+
+
+/**@}*/
+
+
+#endif /* _RD_UNITTEST_H */

package/deps/librdkafka/src/rdvarint.c

@@ -0,0 +1,134 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include "rdvarint.h"
+#include "rdunittest.h"
+
+
+static int do_test_rd_uvarint_enc_i64(const char *file,
+                                      int line,
+                                      int64_t num,
+                                      const char *exp,
+                                      size_t exp_size) {
+        char buf[16] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+        size_t sz    = rd_uvarint_enc_i64(buf, sizeof(buf), num);
+        size_t r;
+        int ir;
+        rd_buf_t b;
+        rd_slice_t slice, bad_slice;
+        int64_t ret_num;
+
+        if (sz != exp_size || memcmp(buf, exp, exp_size))
+                RD_UT_FAIL("i64 encode of %" PRId64
+                           ": "
+                           "expected size %" PRIusz " (got %" PRIusz ")\n",
+                           num, exp_size, sz);
+
+        /* Verify with standard decoder */
+        r = rd_varint_dec_i64(buf, sz, &ret_num);
+        RD_UT_ASSERT(!RD_UVARINT_DEC_FAILED(r),
+                     "varint decode failed: %" PRIusz, r);
+        RD_UT_ASSERT(ret_num == num,
+                     "varint decode returned wrong number: "
+                     "%" PRId64 " != %" PRId64,
+                     ret_num, num);
+
+        /* Verify with slice decoder */
+        rd_buf_init(&b, 1, 0);
+        rd_buf_push(&b, buf, sizeof(buf), NULL); /* including trailing 0xff
+                                                  * garbage which should be
+                                                  * ignored by decoder */
+        rd_slice_init_full(&slice, &b);
+
+        /* Should fail for incomplete reads */
+        ir = rd_slice_narrow_copy(&slice, &bad_slice, sz - 1);
+        RD_UT_ASSERT(ir, "narrow_copy failed");
+        ret_num = -1;
+        r       = rd_slice_read_varint(&bad_slice, &ret_num);
+        RD_UT_ASSERT(RD_UVARINT_DEC_FAILED(r),
+                     "varint decode failed should have failed, "
+                     "returned %" PRIusz,
+                     r);
+        r = rd_slice_offset(&bad_slice);
+        RD_UT_ASSERT(r == 0,
+                     "expected slice position to not change, but got %" PRIusz,
+                     r);
+
+        /* Verify proper slice */
+        ret_num = -1;
+        r       = rd_slice_read_varint(&slice, &ret_num);
+        RD_UT_ASSERT(!RD_UVARINT_DEC_FAILED(r),
+                     "varint decode failed: %" PRIusz, r);
+        RD_UT_ASSERT(ret_num == num,
+                     "varint decode returned wrong number: "
+                     "%" PRId64 " != %" PRId64,
+                     ret_num, num);
+        RD_UT_ASSERT(r == sz,
+                     "expected varint decoder to read %" PRIusz
+                     " bytes, "
+                     "not %" PRIusz,
+                     sz, r);
+        r = rd_slice_offset(&slice);
+        RD_UT_ASSERT(r == sz,
+                     "expected slice position to change to %" PRIusz
+                     ", but got %" PRIusz,
+                     sz, r);
+
+
+        rd_buf_destroy(&b);
+
+        RD_UT_PASS();
+}
+
+
+int unittest_rdvarint(void) {
+        int fails = 0;
+
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 0,
+                                            (const char[]) {0}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 1,
+                                            (const char[]) {0x2}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, -1,
+                                            (const char[]) {0x1}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 23,
+                                            (const char[]) {0x2e}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, -23,
+                                            (const char[]) {0x2d}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 253,
+                                            (const char[]) {0xfa, 3}, 2);
+        fails += do_test_rd_uvarint_enc_i64(
+            __FILE__, __LINE__, 1234567890101112,
+            (const char[]) {0xf0, 0x8d, 0xd3, 0xc8, 0xa7, 0xb5, 0xb1, 0x04}, 8);
+        fails += do_test_rd_uvarint_enc_i64(
+            __FILE__, __LINE__, -1234567890101112,
+            (const char[]) {0xef, 0x8d, 0xd3, 0xc8, 0xa7, 0xb5, 0xb1, 0x04}, 8);
+
+        return fails;
+}

package/deps/librdkafka/src/rdvarint.h

@@ -0,0 +1,165 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef _RDVARINT_H
+#define _RDVARINT_H
+
+#include "rd.h"
+#include "rdbuf.h"
+
+/**
+ * @name signed varint zig-zag encoder/decoder
+ * @{
+ *
+ */
+
+/**
+ * @brief unsigned-varint encodes unsigned integer \p num into buffer
+ *        at \p dst of size \p dstsize.
+ * @returns the number of bytes written to \p dst, or 0 if not enough space.
+ */
+
+static RD_INLINE RD_UNUSED size_t rd_uvarint_enc_u64(char *dst,
+                                                     size_t dstsize,
+                                                     uint64_t num) {
+        size_t of = 0;
+
+        do {
+                if (unlikely(of >= dstsize))
+                        return 0; /* Not enough space */
+
+                dst[of++] = (num & 0x7f) | (num > 0x7f ? 0x80 : 0);
+                num >>= 7;
+        } while (num);
+
+        return of;
+}
+
+/**
+ * @brief encodes a signed integer using zig-zag encoding.
+ * @sa rd_uvarint_enc_u64
+ */
+static RD_INLINE RD_UNUSED size_t rd_uvarint_enc_i64(char *dst,
+                                                     size_t dstsize,
+                                                     int64_t num) {
+        return rd_uvarint_enc_u64(dst, dstsize, (num << 1) ^ (num >> 63));
+}
+
+
+static RD_INLINE RD_UNUSED size_t rd_uvarint_enc_i32(char *dst,
+                                                     size_t dstsize,
+                                                     int32_t num) {
+        return rd_uvarint_enc_i64(dst, dstsize, num);
+}
+
+
+
+/**
+ * @brief Use on return value from rd_uvarint_dec() to check if
+ *        decoded varint fit the size_t.
+ *
+ * @returns 1 on overflow, else 0.
+ */
+#define RD_UVARINT_OVERFLOW(DEC_RETVAL) (DEC_RETVAL > SIZE_MAX)
+
+/**
+ * @returns 1 if there were not enough bytes to decode the varint, else 0.
+ */
+#define RD_UVARINT_UNDERFLOW(DEC_RETVAL) (DEC_RETVAL == 0)
+
+
+/**
+ * @param DEC_RETVAL the return value from \c rd_uvarint_dec()
+ * @returns 1 if varint decoding failed, else 0.
+ * @warning \p DEC_RETVAL will be evaluated twice.
+ */
+#define RD_UVARINT_DEC_FAILED(DEC_RETVAL)                                      \
+        (RD_UVARINT_UNDERFLOW(DEC_RETVAL) || RD_UVARINT_OVERFLOW(DEC_RETVAL))
+
+
+/**
+ * @brief Decodes the unsigned-varint in buffer \p src of size \p srcsize
+ *        and stores the decoded unsigned integer in \p nump.
+ *
+ * @remark Use RD_UVARINT_OVERFLOW(returnvalue) to check if the varint
+ *         could not fit \p nump, and RD_UVARINT_UNDERFLOW(returnvalue) to
+ *         check if there were not enough bytes available in \p src to
+ *         decode the full varint.
+ *
+ * @returns the number of bytes read from \p src.
+ */
+static RD_INLINE RD_UNUSED size_t rd_uvarint_dec(const char *src,
+                                                 size_t srcsize,
+                                                 uint64_t *nump) {
+        size_t of    = 0;
+        uint64_t num = 0;
+        int shift    = 0;
+
+        do {
+                if (unlikely(srcsize-- == 0))
+                        return 0; /* Underflow */
+                num |= (uint64_t)(src[(int)of] & 0x7f) << shift;
+                shift += 7;
+        } while (src[(int)of++] & 0x80);
+
+        *nump = num;
+        return of;
+}
+
+static RD_INLINE RD_UNUSED size_t rd_varint_dec_i64(const char *src,
+                                                    size_t srcsize,
+                                                    int64_t *nump) {
+        uint64_t n;
+        size_t r;
+
+        r = rd_uvarint_dec(src, srcsize, &n);
+        if (likely(!RD_UVARINT_DEC_FAILED(r)))
+                *nump = (int64_t)(n >> 1) ^ -(int64_t)(n & 1);
+
+        return r;
+}
+
+
+/**
+ * @returns the maximum encoded size for a type
+ */
+#define RD_UVARINT_ENC_SIZEOF(TYPE) (sizeof(TYPE) + 1 + (sizeof(TYPE) / 7))
+
+/**
+ * @returns the encoding size of the value 0
+ */
+#define RD_UVARINT_ENC_SIZE_0() ((size_t)1)
+
+
+int unittest_rdvarint(void);
+
+/**@}*/
+
+
+#endif /* _RDVARINT_H */