@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0127-fetch_queue_backoff.cpp

@@ -0,0 +1,165 @@
+/*
+ * 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 <iostream>
+#include <map>
+#include <cstring>
+#include <cstdlib>
+#include "testcpp.h"
+extern "C" {
+#include "test.h"
+}
+
+/**
+ * Test consumer fetch.queue.backoff.ms behaviour.
+ *
+ * @param backoff_ms Backoff ms to configure, -1 to rely on default one.
+ *
+ * 1. Produce N messages, 1 message per batch.
+ * 2. Configure consumer with queued.min.messages=1 and
+ *    fetch.queue.backoff.ms=<backoff_ms>
+ * 3. Verify that the consume() latency is <= fetch.queue.backoff.ms.
+ */
+
+
+static void do_test_queue_backoff(const std::string &topic, int backoff_ms) {
+  SUB_TEST("backoff_ms = %d", backoff_ms);
+
+  /* Create consumer */
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 60);
+  Test::conf_set(conf, "group.id", topic);
+  Test::conf_set(conf, "enable.auto.commit", "false");
+  Test::conf_set(conf, "auto.offset.reset", "beginning");
+  Test::conf_set(conf, "queued.min.messages", "1");
+  if (backoff_ms >= 0) {
+    Test::conf_set(conf, "fetch.queue.backoff.ms", tostr() << backoff_ms);
+  }
+  /* Make sure to include only one message in each fetch.
+   * Message size is 10000. */
+  Test::conf_set(conf, "fetch.message.max.bytes", "12000");
+
+  if (backoff_ms < 0)
+    /* default */
+    backoff_ms = 1000;
+
+  std::string errstr;
+
+  RdKafka::KafkaConsumer *c = RdKafka::KafkaConsumer::create(conf, errstr);
+  if (!c)
+    Test::Fail("Failed to create KafkaConsumer: " + errstr);
+  delete conf;
+
+  RdKafka::TopicPartition *rktpar = RdKafka::TopicPartition::create(topic, 0);
+  std::vector<RdKafka::TopicPartition *> parts;
+  parts.push_back(rktpar);
+
+  RdKafka::ErrorCode err;
+  if ((err = c->assign(parts)))
+    Test::Fail("assigned failed: " + RdKafka::err2str(err));
+  RdKafka::TopicPartition::destroy(parts);
+
+  int received       = 0;
+  int in_profile_cnt = 0;
+  int dmax           = backoff_ms + test_timeout_multiplier * 30;
+
+  int64_t ts_consume = test_clock();
+
+  while (received < 5) {
+    /* Wait more than dmax to count out of profile messages.
+     * Different for first message, that is skipped. */
+    int consume_timeout = received == 0 ? 1500 * test_timeout_multiplier : dmax;
+    RdKafka::Message *msg = c->consume(consume_timeout);
+    if (msg->err() == RdKafka::ERR__TIMED_OUT) {
+      delete msg;
+      continue;
+    }
+
+    rd_ts_t now     = test_clock();
+    int latency     = (now - ts_consume) / 1000;
+    ts_consume      = now;
+    bool in_profile = latency <= dmax;
+
+    if (!msg)
+      Test::Fail(tostr() << "No message for " << consume_timeout << "ms");
+    if (msg->err())
+      Test::Fail("Unexpected consumer error: " + msg->errstr());
+
+    Test::Say(tostr() << "Message #" << received << " consumed in " << latency
+                      << "ms (expecting <= " << dmax << "ms)"
+                      << (received == 0 ? ": skipping first" : "")
+                      << (in_profile ? ": in profile" : ": OUT OF PROFILE")
+                      << "\n");
+
+    if (received++ > 0 && in_profile)
+      in_profile_cnt++;
+
+    delete msg;
+  }
+
+  Test::Say(tostr() << in_profile_cnt << "/" << received << " messages were "
+                    << "in profile (<= " << dmax
+                    << ") for backoff_ms=" << backoff_ms << "\n");
+
+  /* first message isn't counted*/
+  const int expected_in_profile = received - 1;
+  TEST_ASSERT(expected_in_profile - in_profile_cnt == 0,
+              "Only %d/%d messages were in profile", in_profile_cnt,
+              expected_in_profile);
+
+  delete c;
+
+  SUB_TEST_PASS();
+}
+
+
+extern "C" {
+int main_0127_fetch_queue_backoff(int argc, char **argv) {
+  std::string topic = Test::mk_topic_name("0127_fetch_queue_backoff", 1);
+
+  /* Prime the topic with messages. */
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 10);
+  Test::conf_set(conf, "batch.num.messages", "1");
+  std::string errstr;
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail(tostr() << __FUNCTION__
+                       << ": Failed to create producer: " << errstr);
+  delete conf;
+
+  Test::produce_msgs(p, topic, 0, 100, 10000, true /*flush*/);
+  delete p;
+
+  do_test_queue_backoff(topic, -1);
+  do_test_queue_backoff(topic, 500);
+  do_test_queue_backoff(topic, 10);
+  do_test_queue_backoff(topic, 0);
+  return 0;
+}
+}

package/deps/librdkafka/tests/0128-sasl_callback_queue.cpp

@@ -0,0 +1,125 @@
+/*
+ * 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.
+ */
+
+
+/**
+ * Verify that background SASL callback queues work by calling
+ * a non-polling API after client creation.
+ */
+#include "testcpp.h"
+#include "rdatomic.h"
+
+namespace {
+/* Provide our own token refresh callback */
+class MyCb : public RdKafka::OAuthBearerTokenRefreshCb {
+ public:
+  MyCb() {
+    rd_atomic32_init(&called_, 0);
+  }
+
+  bool called() {
+    return rd_atomic32_get(&called_) > 0;
+  }
+
+  void oauthbearer_token_refresh_cb(RdKafka::Handle *handle,
+                                    const std::string &oauthbearer_config) {
+    handle->oauthbearer_set_token_failure(
+        "Not implemented by this test, "
+        "but that's okay");
+    rd_atomic32_add(&called_, 1);
+    Test::Say("Callback called!\n");
+  }
+
+  rd_atomic32_t called_;
+};
+};  // namespace
+
+
+static void do_test(bool use_background_queue) {
+  SUB_TEST("Use background queue = %s", use_background_queue ? "yes" : "no");
+
+  bool expect_called = use_background_queue;
+
+  RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
+
+  Test::conf_set(conf, "security.protocol", "SASL_PLAINTEXT");
+  Test::conf_set(conf, "sasl.mechanism", "OAUTHBEARER");
+
+  std::string errstr;
+
+  MyCb mycb;
+  if (conf->set("oauthbearer_token_refresh_cb", &mycb, errstr))
+    Test::Fail("Failed to set refresh callback: " + errstr);
+
+  if (use_background_queue)
+    if (conf->enable_sasl_queue(true, errstr))
+      Test::Fail("Failed to enable SASL queue: " + errstr);
+
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create Producer: " + errstr);
+  delete conf;
+
+  if (use_background_queue) {
+    RdKafka::Error *error = p->sasl_background_callbacks_enable();
+    if (error)
+      Test::Fail("sasl_background_callbacks_enable() failed: " + error->str());
+  }
+
+  /* This call should fail since the refresh callback fails,
+   * and there are no brokers configured anyway. */
+  const std::string clusterid = p->clusterid(5 * 1000);
+
+  TEST_ASSERT(clusterid.empty(),
+              "Expected clusterid() to fail since the token was not set");
+
+  if (expect_called)
+    TEST_ASSERT(mycb.called(),
+                "Expected refresh callback to have been called by now");
+  else
+    TEST_ASSERT(!mycb.called(),
+                "Did not expect refresh callback to have been called");
+
+  delete p;
+
+  SUB_TEST_PASS();
+}
+
+extern "C" {
+int main_0128_sasl_callback_queue(int argc, char **argv) {
+  if (!test_check_builtin("sasl_oauthbearer")) {
+    Test::Skip("Test requires OAUTHBEARER support\n");
+    return 0;
+  }
+
+  do_test(true);
+  do_test(false);
+
+  return 0;
+}
+}

package/deps/librdkafka/tests/0129-fetch_aborted_msgs.c

@@ -0,0 +1,79 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-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"
+
+
+/**
+ * @brief Verify that a FetchResponse containing only aborted messages does not
+ *        raise a ERR_MSG_SIZE_TOO_LARGE error. #2993.
+ *
+ * 1. Create topic with a small message.max.bytes to make sure that
+ *    there's at least one full fetch response without any control messages,
+ *    just aborted messages.
+ * 2. Transactionally produce 10x the message.max.bytes.
+ * 3. Abort the transaction.
+ * 4. Consume from start, verify that no error is received, wait for EOF.
+ *
+ */
+int main_0129_fetch_aborted_msgs(int argc, char **argv) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        const char *topic    = test_mk_topic_name("0129_fetch_aborted_msgs", 1);
+        const int msgcnt     = 1000;
+        const size_t msgsize = 1000;
+
+        test_conf_init(&conf, NULL, 30);
+
+        test_conf_set(conf, "linger.ms", "10000");
+        test_conf_set(conf, "transactional.id", topic);
+        test_conf_set(conf, "message.max.bytes", "10000");
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        test_admin_create_topic(rk, topic, 1, 1,
+                                (const char *[]) {"max.message.bytes", "10000",
+                                                  "segment.bytes", "20000",
+                                                  NULL});
+        test_wait_topic_exists(rk, topic, 5000);
+
+        TEST_CALL_ERROR__(rd_kafka_init_transactions(rk, -1));
+        TEST_CALL_ERROR__(rd_kafka_begin_transaction(rk));
+
+        /* Produce half set of messages without waiting for delivery. */
+        test_produce_msgs2(rk, topic, 0, 0, 0, msgcnt, NULL, msgsize);
+
+        TEST_CALL_ERROR__(rd_kafka_abort_transaction(rk, -1));
+
+        rd_kafka_destroy(rk);
+
+        /* Verify messages were actually produced by consuming them back. */
+        test_consume_msgs_easy(topic, topic, 0, 1, 0, NULL);
+
+        return 0;
+}

package/deps/librdkafka/tests/0130-store_offsets.c

@@ -0,0 +1,178 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-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"
+
+
+/**
+ * Verify that offsets_store() commits the right offsets and metadata,
+ * and is not allowed for unassigned partitions.
+ */
+static void do_test_store_unassigned(void) {
+        const char *topic = test_mk_topic_name("0130_store_unassigned", 1);
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *c;
+        rd_kafka_topic_partition_list_t *parts;
+        rd_kafka_resp_err_t err;
+        rd_kafka_message_t *rkmessage;
+        char metadata[]             = "metadata";
+        const int64_t proper_offset = 900, bad_offset = 300;
+
+        SUB_TEST_QUICK();
+
+        test_produce_msgs_easy(topic, 0, 0, 1000);
+
+        test_conf_init(&conf, NULL, 30);
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "enable.auto.offset.store", "false");
+        test_conf_set(conf, "enable.partition.eof", "true");
+
+        c = test_create_consumer(topic, NULL, conf, NULL);
+
+        parts = rd_kafka_topic_partition_list_new(1);
+        rd_kafka_topic_partition_list_add(parts, topic, 0);
+        TEST_CALL_ERR__(rd_kafka_assign(c, parts));
+
+        TEST_SAY("Consume one message\n");
+        test_consumer_poll_once(c, NULL, tmout_multip(3000));
+
+        parts->elems[0].offset        = proper_offset;
+        parts->elems[0].metadata_size = sizeof metadata;
+        parts->elems[0].metadata      = malloc(parts->elems[0].metadata_size);
+        memcpy(parts->elems[0].metadata, metadata,
+               parts->elems[0].metadata_size);
+        TEST_SAY("Storing offset %" PRId64
+                 " with metadata while assigned: should succeed\n",
+                 parts->elems[0].offset);
+        TEST_CALL_ERR__(rd_kafka_offsets_store(c, parts));
+
+        TEST_SAY("Committing\n");
+        TEST_CALL_ERR__(rd_kafka_commit(c, NULL, rd_false /*sync*/));
+
+        TEST_SAY("Unassigning partitions and trying to store again\n");
+        TEST_CALL_ERR__(rd_kafka_assign(c, NULL));
+
+        parts->elems[0].offset        = bad_offset;
+        parts->elems[0].metadata_size = 0;
+        rd_free(parts->elems[0].metadata);
+        parts->elems[0].metadata = NULL;
+        TEST_SAY("Storing offset %" PRId64 " while unassigned: should fail\n",
+                 parts->elems[0].offset);
+        err = rd_kafka_offsets_store(c, parts);
+        TEST_ASSERT_LATER(err != RD_KAFKA_RESP_ERR_NO_ERROR,
+                          "Expected offsets_store() to fail");
+        TEST_ASSERT(parts->cnt == 1);
+
+        TEST_ASSERT(parts->elems[0].err == RD_KAFKA_RESP_ERR__STATE,
+                    "Expected %s [%" PRId32
+                    "] to fail with "
+                    "_STATE, not %s",
+                    parts->elems[0].topic, parts->elems[0].partition,
+                    rd_kafka_err2name(parts->elems[0].err));
+
+        TEST_SAY("Committing: should fail\n");
+        err = rd_kafka_commit(c, NULL, rd_false /*sync*/);
+        TEST_ASSERT(err == RD_KAFKA_RESP_ERR__NO_OFFSET,
+                    "Expected commit() to fail with NO_OFFSET, not %s",
+                    rd_kafka_err2name(err));
+
+        TEST_SAY("Assigning partition again\n");
+        parts->elems[0].offset = RD_KAFKA_OFFSET_INVALID; /* Use committed */
+        TEST_CALL_ERR__(rd_kafka_assign(c, parts));
+
+        TEST_SAY("Consuming message to verify committed offset\n");
+        rkmessage = rd_kafka_consumer_poll(c, tmout_multip(3000));
+        TEST_ASSERT(rkmessage != NULL, "Expected message");
+        TEST_SAY("Consumed message with offset %" PRId64 "\n",
+                 rkmessage->offset);
+        TEST_ASSERT(!rkmessage->err, "Expected proper message, not error %s",
+                    rd_kafka_message_errstr(rkmessage));
+        TEST_ASSERT(rkmessage->offset == proper_offset,
+                    "Expected first message to be properly stored "
+                    "offset %" PRId64 ", not %" PRId64,
+                    proper_offset, rkmessage->offset);
+
+        TEST_SAY(
+            "Retrieving committed offsets to verify committed offset "
+            "metadata\n");
+        rd_kafka_topic_partition_list_t *committed_toppar;
+        committed_toppar = rd_kafka_topic_partition_list_new(1);
+        rd_kafka_topic_partition_list_add(committed_toppar, topic, 0);
+        TEST_CALL_ERR__(
+            rd_kafka_committed(c, committed_toppar, tmout_multip(3000)));
+        TEST_ASSERT(committed_toppar->elems[0].offset == proper_offset,
+                    "Expected committed offset to be %" PRId64 ", not %" PRId64,
+                    proper_offset, committed_toppar->elems[0].offset);
+        TEST_ASSERT(committed_toppar->elems[0].metadata != NULL,
+                    "Expected metadata to not be NULL");
+        TEST_ASSERT(strcmp(committed_toppar->elems[0].metadata, metadata) == 0,
+                    "Expected metadata to be %s, not %s", metadata,
+                    (char *)committed_toppar->elems[0].metadata);
+
+        TEST_SAY("Storing next offset without metadata\n");
+        parts->elems[0].offset = proper_offset + 1;
+        TEST_CALL_ERR__(rd_kafka_offsets_store(c, parts));
+
+        TEST_SAY("Committing\n");
+        TEST_CALL_ERR__(rd_kafka_commit(c, NULL, rd_false /*sync*/));
+
+        TEST_SAY(
+            "Retrieving committed offset to verify empty committed offset "
+            "metadata\n");
+        rd_kafka_topic_partition_list_t *committed_toppar_empty;
+        committed_toppar_empty = rd_kafka_topic_partition_list_new(1);
+        rd_kafka_topic_partition_list_add(committed_toppar_empty, topic, 0);
+        TEST_CALL_ERR__(
+            rd_kafka_committed(c, committed_toppar_empty, tmout_multip(3000)));
+        TEST_ASSERT(committed_toppar_empty->elems[0].offset ==
+                        proper_offset + 1,
+                    "Expected committed offset to be %" PRId64 ", not %" PRId64,
+                    proper_offset, committed_toppar_empty->elems[0].offset);
+        TEST_ASSERT(committed_toppar_empty->elems[0].metadata == NULL,
+                    "Expected metadata to be NULL");
+
+        rd_kafka_message_destroy(rkmessage);
+
+        rd_kafka_topic_partition_list_destroy(parts);
+        rd_kafka_topic_partition_list_destroy(committed_toppar);
+        rd_kafka_topic_partition_list_destroy(committed_toppar_empty);
+
+        rd_kafka_consumer_close(c);
+        rd_kafka_destroy(c);
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0130_store_offsets(int argc, char **argv) {
+
+        do_test_store_unassigned();
+
+        return 0;
+}

package/deps/librdkafka/tests/0131-connect_timeout.c

@@ -0,0 +1,81 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 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"
+
+
+/**
+ * @name Verify socket.connection.setup.timeout.ms by using
+ *       a mock cluster with an rtt > timeout.
+ */
+
+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 setup timed out"))
+                return;
+
+        TEST_SAY("Log: %s level %d fac %s: %s\n", rd_kafka_name(rk), level, fac,
+                 buf);
+
+        rd_atomic32_add(log_cntp, 1);
+}
+
+int main_0131_connect_timeout(int argc, char **argv) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        rd_atomic32_t log_cnt;
+
+        test_conf_init(NULL, NULL, 20);
+        conf = rd_kafka_conf_new();
+        test_conf_set(conf, "test.mock.num.brokers", "2");
+        test_conf_set(conf, "test.mock.broker.rtt", "10000");
+        test_conf_set(conf, "socket.connection.setup.timeout.ms", "6000");
+        test_conf_set(conf, "debug", "broker");
+        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 a disconnect this soon");
+
+        rd_sleep(5);
+        TEST_ASSERT(rd_atomic32_get(&log_cnt) > 0,
+                    "Should have seen at least one "
+                    "disconnect by now");
+
+        rd_kafka_destroy(rk);
+
+        return 0;
+}