@platformatic/rdkafka 4.0.0

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

@@ -0,0 +1,78 @@
+/*
+ * 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_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;
+}

package/deps/librdkafka/tests/0132-strategy_ordering.c

@@ -0,0 +1,171 @@
+/*
+ * 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"
+
+
+#define _PART_CNT 4
+
+static void verify_roundrobin_assignment(rd_kafka_t *c[]) {
+        rd_kafka_topic_partition_list_t *assignment1;
+        rd_kafka_topic_partition_list_t *assignment2;
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[0], &assignment1));
+
+        TEST_ASSERT(assignment1->cnt == _PART_CNT / 2,
+                    "Roundrobin: Assignment partitions for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[0]), assignment1->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment1->elems[0].partition == 0,
+                    "Roundrobin: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[0].partition, 0);
+        TEST_ASSERT(assignment1->elems[1].partition == 2,
+                    "Roundrobin: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[1].partition, 2);
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[1], &assignment2));
+        TEST_ASSERT(assignment2->cnt == _PART_CNT / 2,
+                    "Roundrobin: Assignment partitions for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[1]), assignment2->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment2->elems[0].partition == 1,
+                    "Roundrobin: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[0].partition, 1);
+        TEST_ASSERT(assignment2->elems[1].partition == 3,
+                    "Roundrobin: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[1].partition, 3);
+
+        rd_kafka_topic_partition_list_destroy(assignment1);
+        rd_kafka_topic_partition_list_destroy(assignment2);
+}
+
+static void verify_range_assignment(rd_kafka_t *c[]) {
+        rd_kafka_topic_partition_list_t *assignment1;
+        rd_kafka_topic_partition_list_t *assignment2;
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[0], &assignment1));
+
+        TEST_ASSERT(assignment1->cnt == _PART_CNT / 2,
+                    "Range: Assignment partition for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[0]), assignment1->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment1->elems[0].partition == 0,
+                    "Range: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[0].partition, 0);
+        TEST_ASSERT(assignment1->elems[1].partition == 1,
+                    "Range: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[0]), assignment1->elems[1].partition, 1);
+
+        TEST_CALL_ERR__(rd_kafka_assignment(c[1], &assignment2));
+        TEST_ASSERT(assignment2->cnt == _PART_CNT / 2,
+                    "Range: Assignment partition for %s"
+                    "is %d, but the expected is %d\n",
+                    rd_kafka_name(c[1]), assignment2->cnt, _PART_CNT / 2);
+
+        TEST_ASSERT(assignment2->elems[0].partition == 2,
+                    "Range: First assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[0].partition, 2);
+        TEST_ASSERT(assignment2->elems[1].partition == 3,
+                    "Range: Second assignment partition for %s"
+                    "is %d, but the expectation is %d\n",
+                    rd_kafka_name(c[1]), assignment2->elems[1].partition, 3);
+
+        rd_kafka_topic_partition_list_destroy(assignment1);
+        rd_kafka_topic_partition_list_destroy(assignment2);
+}
+
+static void do_test_stragety_ordering(const char *assignor,
+                                      const char *expected_assignor) {
+        rd_kafka_conf_t *conf;
+#define _C_CNT 2
+        rd_kafka_t *c[_C_CNT];
+
+        const char *topic;
+        const int msgcnt = 100;
+        int i;
+        uint64_t testid;
+
+        SUB_TEST("partition.assignment.strategy = %s", assignor);
+
+        testid = test_id_generate();
+
+        topic = test_mk_topic_name("0132-strategy_ordering", 1);
+        test_create_topic(NULL, topic, _PART_CNT, 1);
+        test_produce_msgs_easy(topic, testid, RD_KAFKA_PARTITION_UA, msgcnt);
+
+        test_conf_init(&conf, NULL, 30);
+        test_conf_set(conf, "partition.assignment.strategy", assignor);
+
+        for (i = 0; i < _C_CNT; i++) {
+                char name[16];
+
+                rd_snprintf(name, sizeof(name), "c%d", i);
+                test_conf_set(conf, "client.id", name);
+
+                c[i] = test_create_consumer(assignor, NULL,
+                                            rd_kafka_conf_dup(conf), NULL);
+
+                test_consumer_subscribe(c[i], topic);
+        }
+
+        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);
+        }
+
+        if (!strcmp(expected_assignor, "range"))
+                verify_range_assignment(c);
+        else
+                verify_roundrobin_assignment(c);
+
+        for (i = 0; i < _C_CNT; i++) {
+                test_consumer_close(c[i]);
+                rd_kafka_destroy(c[i]);
+        }
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0132_strategy_ordering(int argc, char **argv) {
+        do_test_stragety_ordering("roundrobin,range", "roundrobin");
+        do_test_stragety_ordering("range,roundrobin", "range");
+        return 0;
+}

package/deps/librdkafka/tests/0133-ssl_keys.c

@@ -0,0 +1,128 @@
+/*
+ * 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 "rdstring.h"
+
+/**
+ * @brief Tests reading SSL PKCS#12 keystore or PEM certificate and key from
+ * file. Decoding it with the correct password or not.
+ *
+ * Ensures it's read correctly on Windows too.
+ * See https://github.com/confluentinc/librdkafka/issues/3992
+ */
+static void do_test_ssl_keys(const char *type, rd_bool_t correct_password) {
+#define TEST_FIXTURES_FOLDER            "./fixtures"
+#define TEST_FIXTURES_SSL_FOLDER        TEST_FIXTURES_FOLDER "/ssl/"
+#define TEST_FIXTURES_KEYSTORE_PASSWORD "use_strong_password_keystore_client"
+#define TEST_FIXTURES_KEY_PASSWORD      "use_strong_password_keystore_client2"
+#define TEST_KEYSTORE_LOCATION          TEST_FIXTURES_SSL_FOLDER "client.keystore.p12"
+#define TEST_CERTIFICATE_LOCATION                                              \
+        TEST_FIXTURES_SSL_FOLDER "client2.certificate.pem"
+#define TEST_KEY_LOCATION TEST_FIXTURES_SSL_FOLDER "client2.key"
+
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *rk;
+        char errstr[256];
+
+        SUB_TEST_QUICK("keystore type = %s, correct password = %s", type,
+                       RD_STR_ToF(correct_password));
+
+        test_conf_init(&conf, NULL, 30);
+        test_conf_set(conf, "security.protocol", "SSL");
+
+        if (!strcmp(type, "PKCS12")) {
+                test_conf_set(conf, "ssl.keystore.location",
+                              TEST_KEYSTORE_LOCATION);
+                if (correct_password)
+                        test_conf_set(conf, "ssl.keystore.password",
+                                      TEST_FIXTURES_KEYSTORE_PASSWORD);
+                else
+                        test_conf_set(conf, "ssl.keystore.password",
+                                      TEST_FIXTURES_KEYSTORE_PASSWORD
+                                      " and more");
+        } else if (!strcmp(type, "PEM")) {
+                test_conf_set(conf, "ssl.certificate.location",
+                              TEST_CERTIFICATE_LOCATION);
+                test_conf_set(conf, "ssl.key.location", TEST_KEY_LOCATION);
+                if (correct_password)
+                        test_conf_set(conf, "ssl.key.password",
+                                      TEST_FIXTURES_KEY_PASSWORD);
+                else
+                        test_conf_set(conf, "ssl.keystore.password",
+                                      TEST_FIXTURES_KEYSTORE_PASSWORD
+                                      " and more");
+        } else {
+                TEST_FAIL("Unexpected key type\n");
+        }
+
+        rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr));
+        if ((rk != NULL) != correct_password) {
+                TEST_FAIL("Expected rd_kafka creation to %s\n",
+                          correct_password ? "succeed" : "fail");
+        }
+
+        if (rk)
+                rd_kafka_destroy(rk);
+        else
+                rd_kafka_conf_destroy(conf);
+
+        SUB_TEST_PASS();
+
+#undef TEST_FIXTURES_KEYSTORE_PASSWORD
+#undef TEST_FIXTURES_KEY_PASSWORD
+#undef TEST_KEYSTORE_LOCATION
+#undef TEST_CERTIFICATE_LOCATION
+#undef TEST_KEY_LOCATION
+#undef TEST_FIXTURES_FOLDER
+#undef TEST_FIXTURES_SSL_FOLDER
+}
+
+
+int main_0133_ssl_keys(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        char errstr[512];
+        rd_kafka_conf_res_t res;
+
+        test_conf_init(&conf, NULL, 10);
+
+        /* Check that we're linked/built with OpenSSL 3.x */
+        res = rd_kafka_conf_set(conf, "ssl.providers", "a,b", errstr,
+                                sizeof(errstr));
+        rd_kafka_conf_destroy(conf);
+        if (res == RD_KAFKA_CONF_INVALID) {
+                TEST_SKIP("%s\n", errstr);
+                return 0;
+        }
+
+        do_test_ssl_keys("PKCS12", rd_true);
+        do_test_ssl_keys("PKCS12", rd_false);
+        do_test_ssl_keys("PEM", rd_true);
+        do_test_ssl_keys("PEM", rd_false);
+        return 0;
+}