@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0046-rkt_cache.c

@@ -0,0 +1,65 @@
+/*
+ * 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"
+#include "rdkafka.h"
+
+#include <stdarg.h>
+
+/**
+ * Issue #345, #821
+ * Test that topic_new() + topic_destroy() can be used as a topic-lookup cache,
+ * i.e., as long as the app topic refcount stays above 1 the app can call
+ * new() and destroy() any number of times (symetrically).
+ */
+
+
+int main_0046_rkt_cache(int argc, char **argv) {
+        rd_kafka_t *rk;
+        rd_kafka_topic_t *rkt;
+        const char *topic = test_mk_topic_name(__FUNCTION__, 0);
+        int i;
+
+        rk = test_create_producer();
+
+        rkt = test_create_producer_topic(rk, topic, NULL);
+
+        for (i = 0; i < 100; i++) {
+                rd_kafka_topic_t *rkt2;
+
+                rkt2 = rd_kafka_topic_new(rk, topic, NULL);
+                TEST_ASSERT(rkt2 != NULL);
+
+                rd_kafka_topic_destroy(rkt2);
+        }
+
+        rd_kafka_topic_destroy(rkt);
+        rd_kafka_destroy(rk);
+
+        return 0;
+}

package/deps/librdkafka/tests/0047-partial_buf_tmout.c

@@ -0,0 +1,98 @@
+/*
+ * 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"
+#include "rdkafka.h"
+
+#include <stdarg.h>
+
+/**
+ * Issue #756
+ *
+ * Partially sent buffers that timeout would cause the next request sent
+ * to appear inside the partially sent buffer, eventually leading to an
+ * InvalidReceiveException exception on the broker.
+ *
+ * This is easily triggered by:
+ *  - decrease socket buffers
+ *  - decrease message timeout
+ *  - produce a bunch of large messages that will need to be partially sent
+ *  - requests should timeout which should cause the connection to be closed
+ *    by librdkafka.
+ *
+ * How do we monitor for correctness?
+ *  - the broker shall not close the connection (but we might)
+ */
+
+static int got_timeout_err = 0;
+
+static void
+my_error_cb(rd_kafka_t *rk, int err, const char *reason, void *opaque) {
+        got_timeout_err += (err == RD_KAFKA_RESP_ERR__TIMED_OUT);
+
+        if (err == RD_KAFKA_RESP_ERR__TIMED_OUT ||
+            err == RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN)
+                TEST_SAY("Expected error: %s: %s\n", rd_kafka_err2str(err),
+                         reason);
+        else
+                TEST_FAIL("Unexpected error: %s: %s", rd_kafka_err2str(err),
+                          reason);
+}
+
+int main_0047_partial_buf_tmout(int argc, char **argv) {
+        rd_kafka_t *rk;
+        rd_kafka_topic_t *rkt;
+        const char *topic = test_mk_topic_name(__FUNCTION__, 0);
+        rd_kafka_conf_t *conf;
+        const size_t msg_size = 10000;
+        int msgcounter        = 0;
+
+        test_conf_init(&conf, NULL, 30);
+        test_conf_set(conf, "socket.send.buffer.bytes", "1000");
+        test_conf_set(conf, "batch.num.messages", "100");
+        test_conf_set(conf, "queue.buffering.max.messages", "10000000");
+        rd_kafka_conf_set_error_cb(conf, my_error_cb);
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        rkt = test_create_producer_topic(rk, topic, "message.timeout.ms", "300",
+                                         NULL);
+        test_wait_topic_exists(rk, topic, 5000);
+
+        while (got_timeout_err == 0) {
+                test_produce_msgs_nowait(rk, rkt, 0, RD_KAFKA_PARTITION_UA, 0,
+                                         10000, NULL, msg_size, 0, &msgcounter);
+                rd_kafka_flush(rk, 100);
+        }
+
+        TEST_ASSERT(got_timeout_err > 0);
+
+        rd_kafka_topic_destroy(rkt);
+        rd_kafka_destroy(rk);
+
+        return 0;
+}

package/deps/librdkafka/tests/0048-partitioner.c

@@ -0,0 +1,283 @@
+/*
+ * 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"
+#include "rdkafka.h"
+
+#include <stdarg.h>
+
+/**
+ * Various partitioner tests
+ *
+ * - Issue #797 - deadlock on failed partitioning
+ * - Verify that partitioning works across partitioners.
+ */
+
+int32_t my_invalid_partitioner(const rd_kafka_topic_t *rkt,
+                               const void *keydata,
+                               size_t keylen,
+                               int32_t partition_cnt,
+                               void *rkt_opaque,
+                               void *msg_opaque) {
+        int32_t partition = partition_cnt + 10;
+        TEST_SAYL(4, "partition \"%.*s\" to %" PRId32 "\n", (int)keylen,
+                  (const char *)keydata, partition);
+        return partition;
+}
+
+
+/* FIXME: This doesn't seem to trigger the bug in #797.
+ *        Still a useful test though. */
+static void do_test_failed_partitioning(void) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        rd_kafka_topic_t *rkt;
+        rd_kafka_topic_conf_t *tconf;
+        const char *topic = test_mk_topic_name(__FUNCTION__, 1);
+        int i;
+        int msgcnt = test_quick ? 100 : 10000;
+
+        test_conf_init(&conf, &tconf, 0);
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+        test_conf_set(conf, "sticky.partitioning.linger.ms", "0");
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        rd_kafka_topic_conf_set_partitioner_cb(tconf, my_invalid_partitioner);
+        test_topic_conf_set(tconf, "message.timeout.ms",
+                            tsprintf("%d", tmout_multip(10000)));
+        rkt = rd_kafka_topic_new(rk, topic, tconf);
+        TEST_ASSERT(rkt != NULL, "%s", rd_kafka_err2str(rd_kafka_last_error()));
+
+        /* Produce some messages (to p 0) to create topic */
+        test_produce_msgs(rk, rkt, 0, 0, 0, 2, NULL, 0);
+
+        /* Now use partitioner */
+        for (i = 0; i < msgcnt; i++) {
+                rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
+                if (rd_kafka_produce(rkt, RD_KAFKA_PARTITION_UA, 0, NULL, 0,
+                                     NULL, 0, NULL) == -1)
+                        err = rd_kafka_last_error();
+                if (err != RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION)
+                        TEST_FAIL(
+                            "produce(): "
+                            "Expected UNKNOWN_PARTITION, got %s\n",
+                            rd_kafka_err2str(err));
+        }
+        test_flush(rk, 5000);
+
+        rd_kafka_topic_destroy(rkt);
+        rd_kafka_destroy(rk);
+}
+
+
+static void part_dr_msg_cb(rd_kafka_t *rk,
+                           const rd_kafka_message_t *rkmessage,
+                           void *opaque) {
+        int32_t *partp = rkmessage->_private;
+        int *remainsp  = opaque;
+
+        if (rkmessage->err) {
+                /* Will fail later */
+                TEST_WARN("Delivery failed: %s\n",
+                          rd_kafka_err2str(rkmessage->err));
+                *partp = -1;
+        } else {
+                *partp = rkmessage->partition;
+        }
+
+        (*remainsp)--;
+}
+
+/**
+ * @brief Test single \p partitioner
+ */
+static void do_test_partitioner(const char *topic,
+                                const char *partitioner,
+                                int msgcnt,
+                                const char **keys,
+                                const int32_t *exp_part) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        int i;
+        int32_t *parts;
+        int remains = msgcnt;
+        int randcnt = 0;
+        int fails   = 0;
+
+        TEST_SAY(_C_MAG "Test partitioner \"%s\"\n", partitioner);
+
+        test_conf_init(&conf, NULL, 30);
+        rd_kafka_conf_set_opaque(conf, &remains);
+        rd_kafka_conf_set_dr_msg_cb(conf, part_dr_msg_cb);
+        test_conf_set(conf, "partitioner", partitioner);
+        test_conf_set(conf, "sticky.partitioning.linger.ms", "0");
+
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        parts = malloc(msgcnt * sizeof(*parts));
+        for (i = 0; i < msgcnt; i++)
+                parts[i] = -1;
+
+        /*
+         * Produce messages
+         */
+        for (i = 0; i < msgcnt; i++) {
+                rd_kafka_resp_err_t err;
+
+                err = rd_kafka_producev(
+                    rk, RD_KAFKA_V_TOPIC(topic),
+                    RD_KAFKA_V_KEY(keys[i], keys[i] ? strlen(keys[i]) : 0),
+                    RD_KAFKA_V_OPAQUE(&parts[i]), RD_KAFKA_V_END);
+                TEST_ASSERT(!err, "producev() failed: %s",
+                            rd_kafka_err2str(err));
+
+                randcnt += exp_part[i] == -1;
+        }
+
+        rd_kafka_flush(rk, tmout_multip(10000));
+
+        TEST_ASSERT(remains == 0, "Expected remains=%d, not %d for %d messages",
+                    0, remains, msgcnt);
+
+        /*
+         * Verify produced partitions to expected partitions.
+         */
+
+        /* First look for produce failures */
+        for (i = 0; i < msgcnt; i++) {
+                if (parts[i] == -1) {
+                        TEST_WARN("Message #%d (exp part %" PRId32
+                                  ") "
+                                  "was not successfully produced\n",
+                                  i, exp_part[i]);
+                        fails++;
+                }
+        }
+
+        TEST_ASSERT(!fails, "See %d previous failure(s)", fails);
+
+
+        if (randcnt == msgcnt) {
+                /* If all expected partitions are random make sure
+                 * the produced partitions have some form of
+                 * random distribution */
+                int32_t last_part = parts[0];
+                int samecnt       = 0;
+
+                for (i = 0; i < msgcnt; i++) {
+                        samecnt += parts[i] == last_part;
+                        last_part = parts[i];
+                }
+
+                TEST_ASSERT(samecnt < msgcnt,
+                            "No random distribution, all on partition %" PRId32,
+                            last_part);
+        } else {
+                for (i = 0; i < msgcnt; i++) {
+                        if (exp_part[i] != -1 && parts[i] != exp_part[i]) {
+                                TEST_WARN(
+                                    "Message #%d expected partition "
+                                    "%" PRId32 " but got %" PRId32 ": %s\n",
+                                    i, exp_part[i], parts[i], keys[i]);
+                                fails++;
+                        }
+                }
+
+
+                TEST_ASSERT(!fails, "See %d previous failure(s)", fails);
+        }
+
+        free(parts);
+
+        rd_kafka_destroy(rk);
+
+        TEST_SAY(_C_GRN "Test partitioner \"%s\": PASS\n", partitioner);
+}
+
+extern uint32_t rd_crc32(const char *, size_t);
+
+/**
+ * @brief Test all builtin partitioners
+ */
+static void do_test_partitioners(void) {
+        int part_cnt = test_quick ? 7 : 17;
+#define _MSG_CNT 5
+        const char *unaligned = "123456";
+        /* Message keys */
+        const char *keys[_MSG_CNT] = {
+            NULL,
+            "",  // empty
+            unaligned + 1,
+            "this is another string with more length to it perhaps", "hejsan"};
+        struct {
+                const char *partitioner;
+                /* Expected partition per message (see keys above) */
+                int32_t exp_part[_MSG_CNT];
+        } ptest[] = {{"random", {-1, -1, -1, -1, -1}},
+                     {"consistent",
+                      {/* These constants were acquired using
+                        * the 'crc32' command on OSX */
+                       0x0 % part_cnt, 0x0 % part_cnt, 0xb1b451d7 % part_cnt,
+                       0xb0150df7 % part_cnt, 0xd077037e % part_cnt}},
+                     {"consistent_random",
+                      {-1, -1, 0xb1b451d7 % part_cnt, 0xb0150df7 % part_cnt,
+                       0xd077037e % part_cnt}},
+                     {"murmur2",
+                      {/* .. using tests/java/Murmur2Cli */
+                       0x106e08d9 % part_cnt, 0x106e08d9 % part_cnt,
+                       0x058d780f % part_cnt, 0x4f7703da % part_cnt,
+                       0x5ec19395 % part_cnt}},
+                     {"murmur2_random",
+                      {-1, 0x106e08d9 % part_cnt, 0x058d780f % part_cnt,
+                       0x4f7703da % part_cnt, 0x5ec19395 % part_cnt}},
+                     {"fnv1a",
+                      {/* .. using https://play.golang.org/p/hRkA4xtYyJ6 */
+                       0x7ee3623b % part_cnt, 0x7ee3623b % part_cnt,
+                       0x27e6f469 % part_cnt, 0x155e3e5f % part_cnt,
+                       0x17b1e27a % part_cnt}},
+                     {"fnv1a_random",
+                      {-1, 0x7ee3623b % part_cnt, 0x27e6f469 % part_cnt,
+                       0x155e3e5f % part_cnt, 0x17b1e27a % part_cnt}},
+                     {NULL}};
+        int pi;
+        const char *topic = test_mk_topic_name(__FUNCTION__, 1);
+
+        test_create_topic_wait_exists(NULL, topic, part_cnt, 1, 5000);
+
+        for (pi = 0; ptest[pi].partitioner; pi++) {
+                do_test_partitioner(topic, ptest[pi].partitioner, _MSG_CNT,
+                                    keys, ptest[pi].exp_part);
+        }
+}
+
+int main_0048_partitioner(int argc, char **argv) {
+        if (test_can_create_topics(0))
+                do_test_partitioners();
+        do_test_failed_partitioning();
+        return 0;
+}

package/deps/librdkafka/tests/0049-consume_conn_close.c

@@ -0,0 +1,162 @@
+/*
+ * 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"
+
+#if WITH_SOCKEM
+#include "rdkafka.h"
+
+#include <stdarg.h>
+
+/**
+ * Verify that consumtion continues after broker connectivity failure.
+ */
+
+static int simulate_network_down = 0;
+
+/**
+ * @brief Sockem connect, called from **internal librdkafka thread** through
+ *        librdkafka's connect_cb
+ */
+static int connect_cb(struct test *test, sockem_t *skm, const char *id) {
+        int r;
+
+        TEST_LOCK();
+        r = simulate_network_down;
+        TEST_UNLOCK();
+
+        if (r) {
+                sockem_close(skm);
+                return ECONNREFUSED;
+        } else {
+                /* Let it go real slow so we dont consume all
+                 * the messages right away. */
+                sockem_set(skm, "rx.thruput", 100000, NULL);
+        }
+        return 0;
+}
+
+static int
+is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
+        /* Ignore connectivity errors since we'll be bringing down
+         * .. connectivity.
+         * SASL auther will think a connection-down even in the auth
+         * state means the broker doesn't support SASL PLAIN. */
+        if (err == RD_KAFKA_RESP_ERR__TRANSPORT ||
+            err == RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN ||
+            err == RD_KAFKA_RESP_ERR__AUTHENTICATION)
+                return 0;
+        return 1;
+}
+
+
+int main_0049_consume_conn_close(int argc, char **argv) {
+        rd_kafka_t *rk;
+        const char *topic = test_mk_topic_name("0049_consume_conn_close", 1);
+        uint64_t testid;
+        int msgcnt = test_quick ? 100 : 10000;
+        test_msgver_t mv;
+        rd_kafka_conf_t *conf;
+        rd_kafka_topic_conf_t *tconf;
+        rd_kafka_topic_partition_list_t *assignment;
+        rd_kafka_resp_err_t err;
+
+        if (!test_conf_match(NULL, "sasl.mechanisms", "GSSAPI")) {
+                TEST_SKIP(
+                    "KNOWN ISSUE: ApiVersionRequest+SaslHandshake "
+                    "will not play well with sudden disconnects\n");
+                return 0;
+        }
+
+        test_conf_init(&conf, &tconf, 60);
+        /* Want an even number so it is divisable by two without surprises */
+        msgcnt = (msgcnt / (int)test_timeout_multiplier) & ~1;
+
+        testid = test_id_generate();
+        test_produce_msgs_easy(topic, testid, RD_KAFKA_PARTITION_UA, msgcnt);
+
+
+        test_socket_enable(conf);
+        test_curr->connect_cb  = connect_cb;
+        test_curr->is_fatal_cb = is_fatal_cb;
+
+        test_topic_conf_set(tconf, "auto.offset.reset", "smallest");
+
+        rk = test_create_consumer(topic, NULL, conf, tconf);
+
+        test_consumer_subscribe(rk, topic);
+
+        test_msgver_init(&mv, testid);
+
+        test_consumer_poll("consume.up", rk, testid, -1, 0, msgcnt / 2, &mv);
+
+        err = rd_kafka_assignment(rk, &assignment);
+        TEST_ASSERT(!err, "assignment() failed: %s", rd_kafka_err2str(err));
+        TEST_ASSERT(assignment->cnt > 0, "empty assignment");
+
+        TEST_SAY("Bringing down the network\n");
+
+        TEST_LOCK();
+        simulate_network_down = 1;
+        TEST_UNLOCK();
+        test_socket_close_all(test_curr, 1 /*reinit*/);
+
+        TEST_SAY("Waiting for session timeout to expire (6s), and then some\n");
+
+        /* Commit an offset, which should fail, to trigger the offset commit
+         * callback fallback (CONSUMER_ERR) */
+        assignment->elems[0].offset = 123456789;
+        TEST_SAY("Committing offsets while down, should fail eventually\n");
+        err = rd_kafka_commit(rk, assignment, 1 /*async*/);
+        TEST_ASSERT(!err, "async commit failed: %s", rd_kafka_err2str(err));
+        rd_kafka_topic_partition_list_destroy(assignment);
+
+        rd_sleep(10);
+
+        TEST_SAY("Bringing network back up\n");
+        TEST_LOCK();
+        simulate_network_down = 0;
+        TEST_UNLOCK();
+
+        TEST_SAY("Continuing to consume..\n");
+        test_consumer_poll("consume.up2", rk, testid, -1, msgcnt / 2,
+                           msgcnt / 2, &mv);
+
+        test_msgver_verify("consume", &mv, TEST_MSGVER_ORDER | TEST_MSGVER_DUP,
+                           0, msgcnt);
+
+        test_msgver_clear(&mv);
+
+        test_consumer_close(rk);
+        rd_kafka_destroy(rk);
+
+        return 0;
+}
+
+
+#endif