@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0120-asymmetric_subscription.c

@@ -0,0 +1,185 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-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 "test.h"
+
+
+#define _PART_CNT 4
+
+
+/**
+ * @brief Verify proper assignment for asymmetrical subscriptions.
+ */
+static void do_test_asymmetric(const char *assignor, const char *bootstraps) {
+        rd_kafka_conf_t *conf;
+#define _C_CNT 3
+        rd_kafka_t *c[_C_CNT];
+#define _S_CNT 2 /* max subscription count per consumer */
+        const char *topics[_C_CNT][_S_CNT] = {
+            /* c0 */ {"t1", "t2"},
+            /* c1 */ {"t2", "t3"},
+            /* c2 */ {"t4"},
+        };
+        struct {
+                const char *topic;
+                const int cnt;
+                int seen;
+        } expect[_C_CNT][_S_CNT] = {
+            /* c0 */
+            {
+                {"t1", _PART_CNT},
+                {"t2", _PART_CNT / 2},
+            },
+            /* c1 */
+            {
+                {"t2", _PART_CNT / 2},
+                {"t3", _PART_CNT},
+            },
+            /* c2 */
+            {
+                {"t4", _PART_CNT},
+            },
+        };
+        const char *groupid = assignor;
+        int i;
+
+        SUB_TEST_QUICK("%s assignor", assignor);
+
+        test_conf_init(&conf, NULL, 30);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "partition.assignment.strategy", assignor);
+
+        for (i = 0; i < _C_CNT; i++) {
+                char name[16];
+                rd_kafka_topic_partition_list_t *tlist =
+                    rd_kafka_topic_partition_list_new(2);
+                int j;
+
+                rd_snprintf(name, sizeof(name), "c%d", i);
+                test_conf_set(conf, "client.id", name);
+
+                for (j = 0; j < _S_CNT && topics[i][j]; j++)
+                        rd_kafka_topic_partition_list_add(
+                            tlist, topics[i][j], RD_KAFKA_PARTITION_UA);
+
+                c[i] = test_create_consumer(groupid, NULL,
+                                            rd_kafka_conf_dup(conf), NULL);
+
+                TEST_CALL_ERR__(rd_kafka_subscribe(c[i], tlist));
+
+                rd_kafka_topic_partition_list_destroy(tlist);
+        }
+
+        rd_kafka_conf_destroy(conf);
+
+
+        /* Await assignments for all consumers */
+        for (i = 0; i < _C_CNT; i++)
+                test_consumer_wait_assignment(c[i], rd_true);
+
+        /* All have assignments, grab them. */
+        for (i = 0; i < _C_CNT; i++) {
+                int j;
+                int p;
+                rd_kafka_topic_partition_list_t *assignment;
+
+                TEST_CALL_ERR__(rd_kafka_assignment(c[i], &assignment));
+
+                TEST_ASSERT(assignment, "No assignment for %s",
+                            rd_kafka_name(c[i]));
+
+                for (p = 0; p < assignment->cnt; p++) {
+                        const rd_kafka_topic_partition_t *part =
+                            &assignment->elems[p];
+                        rd_bool_t found = rd_false;
+
+                        for (j = 0; j < _S_CNT && expect[i][j].topic; j++) {
+                                if (!strcmp(part->topic, expect[i][j].topic)) {
+                                        expect[i][j].seen++;
+                                        found = rd_true;
+                                        break;
+                                }
+                        }
+
+                        TEST_ASSERT(found,
+                                    "%s was assigned unexpected topic %s",
+                                    rd_kafka_name(c[i]), part->topic);
+                }
+
+                for (j = 0; j < _S_CNT && expect[i][j].topic; j++) {
+                        TEST_ASSERT(expect[i][j].seen == expect[i][j].cnt,
+                                    "%s expected %d assigned partitions "
+                                    "for %s, not %d",
+                                    rd_kafka_name(c[i]), expect[i][j].cnt,
+                                    expect[i][j].topic, expect[i][j].seen);
+                }
+
+                rd_kafka_topic_partition_list_destroy(assignment);
+        }
+
+
+        for (i = 0; i < _C_CNT; i++) {
+                if (strcmp(assignor, "range") && (i & 1) == 0)
+                        test_consumer_close(c[i]);
+                rd_kafka_destroy(c[i]);
+        }
+
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0120_asymmetric_subscription(int argc, char **argv) {
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        mcluster = test_mock_cluster_new(3, &bootstraps);
+
+
+        /* Create topics */
+        rd_kafka_mock_topic_create(mcluster, "t1", _PART_CNT, 1);
+        rd_kafka_mock_topic_create(mcluster, "t2", _PART_CNT, 1);
+        rd_kafka_mock_topic_create(mcluster, "t3", _PART_CNT, 1);
+        rd_kafka_mock_topic_create(mcluster, "t4", _PART_CNT, 1);
+
+        do_test_asymmetric("range", bootstraps);
+
+        /* These tests would be duplicate with KIP 848 protocol,
+         * given we're not testing the assignment here,
+         * as it's mocked. */
+        if (test_consumer_group_protocol_classic()) {
+                do_test_asymmetric("roundrobin", bootstraps);
+                do_test_asymmetric("cooperative-sticky", bootstraps);
+        }
+
+        test_mock_cluster_destroy(mcluster);
+
+        return 0;
+}

package/deps/librdkafka/tests/0121-clusterid.c

@@ -0,0 +1,115 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-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 "test.h"
+
+#include "rdkafka.h"
+
+#include "../src/rdkafka_proto.h"
+#include "../src/rdunittest.h"
+
+#include <stdarg.h>
+
+
+/**
+ * @name Connecting to two different clusters should emit warning.
+ *
+ */
+
+static void
+log_cb(const rd_kafka_t *rk, int level, const char *fac, const char *buf) {
+        rd_atomic32_t *log_cntp = rd_kafka_opaque(rk);
+        rd_bool_t matched       = !strcmp(fac, "CLUSTERID") &&
+                            strstr(buf, "reports different ClusterId");
+
+        TEST_SAY("%sLog: %s level %d fac %s: %s\n", matched ? _C_GRN : "",
+                 rd_kafka_name(rk), level, fac, buf);
+
+        if (matched)
+                rd_atomic32_add(log_cntp, 1);
+}
+
+
+int main_0121_clusterid(int argc, char **argv) {
+        rd_kafka_mock_cluster_t *cluster_a, *cluster_b;
+        const char *bootstraps_a, *bootstraps_b;
+        size_t bs_size;
+        char *bootstraps;
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        rd_atomic32_t log_cnt;
+        int cnt = 0;
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        /* Create two clusters */
+        cluster_a = test_mock_cluster_new(1, &bootstraps_a);
+        cluster_b = test_mock_cluster_new(1, &bootstraps_b);
+        rd_kafka_mock_broker_set_down(cluster_b, 1);
+
+        test_conf_init(&conf, NULL, 10);
+
+        /* Combine bootstraps from both clusters */
+        bs_size    = strlen(bootstraps_a) + strlen(bootstraps_b) + 2;
+        bootstraps = malloc(bs_size);
+        rd_snprintf(bootstraps, bs_size, "%s,%s", bootstraps_a, bootstraps_b);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        free(bootstraps);
+
+        rd_atomic32_init(&log_cnt, 0);
+        rd_kafka_conf_set_log_cb(conf, log_cb);
+        rd_kafka_conf_set_opaque(conf, &log_cnt);
+
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+
+        while (rd_atomic32_get(&log_cnt) == 0) {
+                const rd_kafka_metadata_t *md;
+
+                /* After 3 seconds bring down cluster a and bring up
+                 * cluster b, this is to force the client to connect to
+                 * the other cluster. */
+                if (cnt == 3) {
+                        rd_kafka_mock_broker_set_down(cluster_a, 1);
+                        rd_kafka_mock_broker_set_up(cluster_b, 1);
+                }
+
+                if (!rd_kafka_metadata(rk, 1, NULL, &md, 1000))
+                        rd_kafka_metadata_destroy(md);
+                rd_sleep(1);
+
+                cnt++;
+        }
+
+
+        rd_kafka_destroy(rk);
+        test_mock_cluster_destroy(cluster_a);
+        test_mock_cluster_destroy(cluster_b);
+
+        return 0;
+}

package/deps/librdkafka/tests/0122-buffer_cleaning_after_rebalance.c

@@ -0,0 +1,227 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2021-2022, Magnus Edenhill
+ *               2023, 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.
+ */
+
+#include "test.h"
+/* Typical include path would be <librdkafka/rdkafka.h>, but this program
+ * is built from within the librdkafka source tree and thus differs. */
+#include "rdkafka.h" /* for Kafka driver */
+
+typedef struct consumer_s {
+        const char *what;
+        rd_kafka_queue_t *rkq;
+        int timeout_ms;
+        int consume_msg_cnt;
+        int expected_msg_cnt;
+        rd_kafka_t *rk;
+        uint64_t testid;
+        test_msgver_t *mv;
+        struct test *test;
+} consumer_t;
+
+static int consumer_batch_queue(void *arg) {
+        consumer_t *arguments = arg;
+        int msg_cnt           = 0;
+        int i;
+        test_timing_t t_cons;
+
+        rd_kafka_queue_t *rkq     = arguments->rkq;
+        int timeout_ms            = arguments->timeout_ms;
+        const int consume_msg_cnt = arguments->consume_msg_cnt;
+        rd_kafka_t *rk            = arguments->rk;
+        uint64_t testid           = arguments->testid;
+        rd_kafka_message_t **rkmessage =
+            malloc(consume_msg_cnt * sizeof(*rkmessage));
+
+        if (arguments->test)
+                test_curr = arguments->test;
+
+        TEST_SAY(
+            "%s calling consume_batch_queue(timeout=%d, msgs=%d) "
+            "and expecting %d messages back\n",
+            rd_kafka_name(rk), timeout_ms, consume_msg_cnt,
+            arguments->expected_msg_cnt);
+
+        TIMING_START(&t_cons, "CONSUME");
+        msg_cnt = (int)rd_kafka_consume_batch_queue(rkq, timeout_ms, rkmessage,
+                                                    consume_msg_cnt);
+        TIMING_STOP(&t_cons);
+
+        TEST_SAY("%s consumed %d/%d/%d message(s)\n", rd_kafka_name(rk),
+                 msg_cnt, arguments->consume_msg_cnt,
+                 arguments->expected_msg_cnt);
+        TEST_ASSERT(msg_cnt == arguments->expected_msg_cnt,
+                    "consumed %d messages, expected %d", msg_cnt,
+                    arguments->expected_msg_cnt);
+
+        for (i = 0; i < msg_cnt; i++) {
+                if (test_msgver_add_msg(rk, arguments->mv, rkmessage[i]) == 0)
+                        TEST_FAIL(
+                            "The message is not from testid "
+                            "%" PRId64 " \n",
+                            testid);
+                rd_kafka_message_destroy(rkmessage[i]);
+        }
+
+        free(rkmessage);
+
+        return 0;
+}
+
+
+/**
+ * @brief Produce 400 messages and consume 500 messages totally by 2 consumers
+ *        using batch queue method, verify if there isn't any missed or
+ *        duplicate messages received by the two consumers.
+ *        The reasons for setting the consume messages number is higher than
+ *        or equal to the produce messages number are:
+ *        1) Make sure each consumer can at most receive half of the produced
+ *           messages even though the consumers expect more.
+ *        2) If the consume messages number is smaller than the produce
+ *           messages number, it's hard to verify that the messages returned
+ *           are added to the batch queue before or after the rebalancing.
+ *           But if the consume messages number is larger than the produce
+ *           messages number, and we still received half of the produced
+ *           messages by each consumer, we can make sure that the buffer
+ *           cleaning is happened during the batch queue process to guarantee
+ *           only received messages added to the batch queue after the
+ *           rebalance.
+ *
+ *        1. Produce 100 messages to each of the 4 partitions
+ *        2. First consumer subscribes to the topic, wait for it's assignment
+ *        3. The first consumer consumes 500 messages using the batch queue
+ *           method
+ *        4. Second consumer subscribes to the topic, wait for it's assignment
+ *        5. Rebalance happenes
+ *        6. The second consumer consumes 500 messages using the batch queue
+ *           method
+ *        7. Each consumer receives 200 messages finally
+ *        8. Combine all the messages received by the 2 consumers and
+ *           verify if there isn't any missed or duplicate messages
+ *
+ */
+static void do_test_consume_batch(const char *strategy) {
+        const int partition_cnt = 4;
+        rd_kafka_queue_t *rkq1, *rkq2;
+        const char *topic;
+        rd_kafka_t *c1;
+        rd_kafka_t *c2;
+        int p;
+        const int timeout_ms = 12000; /* Must be > rebalance time */
+        uint64_t testid;
+        const int consume_msg_cnt = 500;
+        const int produce_msg_cnt = 400;
+        rd_kafka_conf_t *conf;
+        consumer_t c1_args = RD_ZERO_INIT;
+        consumer_t c2_args = RD_ZERO_INIT;
+        test_msgver_t mv;
+        thrd_t thread_id;
+
+        SUB_TEST("partition.assignment.strategy = %s", strategy);
+
+        test_conf_init(&conf, NULL, 60);
+        test_conf_set(conf, "enable.auto.commit", "false");
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "partition.assignment.strategy", strategy);
+
+        testid = test_id_generate();
+        test_msgver_init(&mv, testid);
+
+        /* Produce messages */
+        topic = test_mk_topic_name("0122-buffer_cleaning", 1);
+
+        for (p = 0; p < partition_cnt; p++)
+                test_produce_msgs_easy(topic, testid, p,
+                                       produce_msg_cnt / partition_cnt);
+
+        /* Create consumers */
+        c1 = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
+        c2 = test_create_consumer(topic, NULL, conf, NULL);
+
+        test_consumer_subscribe(c1, topic);
+        test_consumer_wait_assignment(c1, rd_false);
+
+        /* Create generic consume queue */
+        rkq1 = rd_kafka_queue_get_consumer(c1);
+
+        c1_args.what             = "C1.PRE";
+        c1_args.rkq              = rkq1;
+        c1_args.timeout_ms       = timeout_ms;
+        c1_args.consume_msg_cnt  = consume_msg_cnt;
+        c1_args.expected_msg_cnt = produce_msg_cnt / 2;
+        c1_args.rk               = c1;
+        c1_args.testid           = testid;
+        c1_args.mv               = &mv;
+        c1_args.test             = test_curr;
+        if (thrd_create(&thread_id, consumer_batch_queue, &c1_args) !=
+            thrd_success)
+                TEST_FAIL("Failed to create thread for %s", "C1.PRE");
+
+        test_consumer_subscribe(c2, topic);
+        test_consumer_wait_assignment(c2, rd_false);
+
+        thrd_join(thread_id, NULL);
+
+        /* Create generic consume queue */
+        rkq2 = rd_kafka_queue_get_consumer(c2);
+
+        c2_args.what = "C2.PRE";
+        c2_args.rkq  = rkq2;
+        /* Second consumer should be able to consume all messages right away */
+        c2_args.timeout_ms       = 5000;
+        c2_args.consume_msg_cnt  = consume_msg_cnt;
+        c2_args.expected_msg_cnt = produce_msg_cnt / 2;
+        c2_args.rk               = c2;
+        c2_args.testid           = testid;
+        c2_args.mv               = &mv;
+
+        consumer_batch_queue(&c2_args);
+
+        test_msgver_verify("C1.PRE + C2.PRE", &mv,
+                           TEST_MSGVER_ORDER | TEST_MSGVER_DUP, 0,
+                           produce_msg_cnt);
+        test_msgver_clear(&mv);
+
+        rd_kafka_queue_destroy(rkq1);
+        rd_kafka_queue_destroy(rkq2);
+
+        test_consumer_close(c1);
+        test_consumer_close(c2);
+
+        rd_kafka_destroy(c1);
+        rd_kafka_destroy(c2);
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0122_buffer_cleaning_after_rebalance(int argc, char **argv) {
+        do_test_consume_batch("range");
+        do_test_consume_batch("cooperative-sticky");
+        return 0;
+}

package/deps/librdkafka/tests/0123-connections_max_idle.c

@@ -0,0 +1,98 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2021-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 "test.h"
+
+#include "rdkafka.h"
+
+#include "../src/rdkafka_proto.h"
+#include "../src/rdunittest.h"
+
+#include <stdarg.h>
+
+
+/**
+ * @name Verify connections.max.idle.ms
+ *
+ */
+
+static void
+log_cb(const rd_kafka_t *rk, int level, const char *fac, const char *buf) {
+        rd_atomic32_t *log_cntp = rd_kafka_opaque(rk);
+
+        if (!strstr(buf, "Connection max idle time exceeded"))
+                return;
+
+        TEST_SAY("Log: %s level %d fac %s: %s\n", rd_kafka_name(rk), level, fac,
+                 buf);
+
+        rd_atomic32_add(log_cntp, 1);
+}
+
+static void do_test_idle(rd_bool_t set_idle) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        rd_atomic32_t log_cnt;
+
+        SUB_TEST_QUICK("set_idle = %s", set_idle ? "yes" : "no");
+
+        test_conf_init(&conf, NULL, 10);
+        test_conf_set(conf, "debug", "broker");
+        test_conf_set(conf, "connections.max.idle.ms", set_idle ? "5000" : "0");
+        rd_atomic32_init(&log_cnt, 0);
+        rd_kafka_conf_set_log_cb(conf, log_cb);
+        rd_kafka_conf_set_opaque(conf, &log_cnt);
+
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        rd_sleep(3);
+        TEST_ASSERT(rd_atomic32_get(&log_cnt) == 0,
+                    "Should not have seen an idle disconnect this soon");
+
+        rd_sleep(5);
+        if (set_idle)
+                TEST_ASSERT(rd_atomic32_get(&log_cnt) > 0,
+                            "Should have seen at least one idle "
+                            "disconnect by now");
+        else
+                TEST_ASSERT(rd_atomic32_get(&log_cnt) == 0,
+                            "Should not have seen an idle disconnect");
+
+        rd_kafka_destroy(rk);
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0123_connections_max_idle(int argc, char **argv) {
+
+        do_test_idle(rd_true);
+        do_test_idle(rd_false);
+
+        return 0;
+}

package/deps/librdkafka/tests/0124-openssl_invalid_engine.c

@@ -0,0 +1,69 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2021-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 "test.h"
+
+int main_0124_openssl_invalid_engine(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *rk;
+        char errstr[512];
+        rd_kafka_conf_res_t res;
+
+        test_conf_init(&conf, NULL, 30);
+        res = rd_kafka_conf_set(conf, "ssl.engine.location", "invalid_path",
+                                errstr, sizeof(errstr));
+
+        if (res == RD_KAFKA_CONF_INVALID) {
+                rd_kafka_conf_destroy(conf);
+                TEST_SKIP("%s\n", errstr);
+                return 0;
+        }
+
+        if (res != RD_KAFKA_CONF_OK)
+                TEST_FAIL("%s", errstr);
+
+        if (rd_kafka_conf_set(conf, "security.protocol", "ssl", errstr,
+                              sizeof(errstr)) != RD_KAFKA_CONF_OK)
+                TEST_FAIL("%s", errstr);
+
+        rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr));
+        TEST_ASSERT(!rk,
+                    "kafka_new() should not succeed with invalid engine"
+                    " path, error: %s",
+                    errstr);
+        TEST_SAY("rd_kafka_new() failed (as expected): %s\n", errstr);
+
+        TEST_ASSERT(strstr(errstr, "engine initialization failed in"),
+                    "engine"
+                    " initialization failure expected because of invalid engine"
+                    " path, error: %s",
+                    errstr);
+
+        rd_kafka_conf_destroy(conf);
+        return 0;
+}