@platformatic/rdkafka 4.0.0

package/deps/librdkafka/tests/0038-performance.c

@@ -0,0 +1,120 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "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 */
+
+
+/**
+ * Basic performance tests.
+ * These tests dont fail but provide a throughput rate indication.
+ *
+ * + Produce N messages to one partition, acks=1, size=100
+ */
+
+
+int main_0038_performance(int argc, char **argv) {
+        const char *topic   = test_mk_topic_name(__FUNCTION__, 1);
+        const int partition = 0;
+        const int msgsize   = 100;
+        uint64_t testid;
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *rk;
+        rd_kafka_topic_t *rkt;
+        test_timing_t t_create, t_produce, t_consume;
+        int totsize = 1024 * 1024 * (test_quick ? 8 : 128);
+        int msgcnt;
+
+        if (!strcmp(test_mode, "valgrind") || !strcmp(test_mode, "helgrind") ||
+            !strcmp(test_mode, "drd"))
+                totsize = 1024 * 1024 * 8; /* 8 meg, valgrind is slow. */
+
+        msgcnt = totsize / msgsize;
+
+        TEST_SAY("Producing %d messages of size %d to %s [%d]\n", msgcnt,
+                 (int)msgsize, topic, partition);
+        testid = test_id_generate();
+        test_conf_init(&conf, NULL, 120);
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+        test_conf_set(conf, "queue.buffering.max.messages", "10000000");
+        test_conf_set(conf, "linger.ms", "100");
+        rk  = test_create_handle(RD_KAFKA_PRODUCER, conf);
+        rkt = test_create_producer_topic(rk, topic, "acks", "1", NULL);
+
+        /* First produce one message to create the topic, etc, this might take
+         * a while and we dont want this to affect the throughput timing. */
+        TIMING_START(&t_create, "CREATE TOPIC");
+        test_produce_msgs(rk, rkt, testid, partition, 0, 1, NULL, msgsize);
+        TIMING_STOP(&t_create);
+
+        TIMING_START(&t_produce, "PRODUCE");
+        test_produce_msgs(rk, rkt, testid, partition, 1, msgcnt - 1, NULL,
+                          msgsize);
+        TIMING_STOP(&t_produce);
+
+        TEST_SAY("Destroying producer\n");
+        rd_kafka_topic_destroy(rkt);
+        rd_kafka_destroy(rk);
+
+        TEST_SAY("Creating consumer\n");
+        test_conf_init(&conf, NULL, 120);
+        rk  = test_create_consumer(NULL, NULL, conf, NULL);
+        rkt = rd_kafka_topic_new(rk, topic, NULL);
+
+        test_consumer_start("CONSUME", rkt, partition,
+                            RD_KAFKA_OFFSET_BEGINNING);
+        TIMING_START(&t_consume, "CONSUME");
+        test_consume_msgs("CONSUME", rkt, testid, partition, TEST_NO_SEEK, 0,
+                          msgcnt, 1);
+        TIMING_STOP(&t_consume);
+        test_consumer_stop("CONSUME", rkt, partition);
+
+        rd_kafka_topic_destroy(rkt);
+        rd_kafka_destroy(rk);
+
+        TEST_REPORT(
+            "{ \"producer\": "
+            " { \"mb_per_sec\": %.2f, \"records_per_sec\": %.2f },"
+            " \"consumer\": "
+            "{ \"mb_per_sec\": %.2f, \"records_per_sec\": %.2f } "
+            "}",
+            (double)(totsize /
+                     ((double)TIMING_DURATION(&t_produce) / 1000000.0f)) /
+                1000000.0f,
+            (float)(msgcnt /
+                    ((double)TIMING_DURATION(&t_produce) / 1000000.0f)),
+            (double)(totsize /
+                     ((double)TIMING_DURATION(&t_consume) / 1000000.0f)) /
+                1000000.0f,
+            (float)(msgcnt /
+                    ((double)TIMING_DURATION(&t_consume) / 1000000.0f)));
+        return 0;
+}

package/deps/librdkafka/tests/0039-event.c

@@ -0,0 +1,284 @@
+/*
+ * 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.
+ */
+
+/**
+ * Tests event API.
+ */
+
+
+#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 */
+
+
+static int msgid_next = 0;
+static int fails      = 0;
+
+/**
+ * Handle delivery reports
+ */
+static void handle_drs(rd_kafka_event_t *rkev) {
+        const rd_kafka_message_t *rkmessage;
+
+        while ((rkmessage = rd_kafka_event_message_next(rkev))) {
+                int32_t broker_id = rd_kafka_message_broker_id(rkmessage);
+                int msgid         = *(int *)rkmessage->_private;
+                free(rkmessage->_private);
+
+                TEST_SAYL(3,
+                          "Got rkmessage %s [%" PRId32 "] @ %" PRId64
+                          ": "
+                          "from broker %" PRId32 ": %s\n",
+                          rd_kafka_topic_name(rkmessage->rkt),
+                          rkmessage->partition, rkmessage->offset, broker_id,
+                          rd_kafka_err2str(rkmessage->err));
+
+
+                if (rkmessage->err != RD_KAFKA_RESP_ERR_NO_ERROR)
+                        TEST_FAIL("Message delivery failed: %s\n",
+                                  rd_kafka_err2str(rkmessage->err));
+
+                if (msgid != msgid_next) {
+                        fails++;
+                        TEST_FAIL("Delivered msg %i, expected %i\n", msgid,
+                                  msgid_next);
+                        return;
+                }
+
+                TEST_ASSERT(broker_id >= 0, "Message %d has no broker id set",
+                            msgid);
+
+                msgid_next = msgid + 1;
+        }
+}
+
+
+/**
+ * @brief Test delivery report events
+ */
+int main_0039_event_dr(int argc, char **argv) {
+        int partition = 0;
+        int r;
+        rd_kafka_t *rk;
+        rd_kafka_topic_t *rkt;
+        rd_kafka_conf_t *conf;
+        rd_kafka_topic_conf_t *topic_conf;
+        char msg[128];
+        int msgcnt = test_quick ? 500 : 50000;
+        int i;
+        test_timing_t t_produce, t_delivery;
+        rd_kafka_queue_t *eventq;
+
+        test_conf_init(&conf, &topic_conf, 10);
+
+        /* Set delivery report callback */
+        rd_kafka_conf_set_dr_msg_cb(conf, test_dr_msg_cb);
+
+        rd_kafka_conf_set_events(conf, RD_KAFKA_EVENT_DR);
+
+        /* Create kafka instance */
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        eventq = rd_kafka_queue_get_main(rk);
+
+        rkt = rd_kafka_topic_new(rk, test_mk_topic_name("0005", 0), topic_conf);
+        if (!rkt)
+                TEST_FAIL("Failed to create topic: %s\n", rd_strerror(errno));
+
+        /* Produce messages */
+        TIMING_START(&t_produce, "PRODUCE");
+        for (i = 0; i < msgcnt; i++) {
+                int *msgidp = malloc(sizeof(*msgidp));
+                *msgidp     = i;
+                rd_snprintf(msg, sizeof(msg), "%s test message #%i", argv[0],
+                            i);
+                r = rd_kafka_produce(rkt, partition, RD_KAFKA_MSG_F_COPY, msg,
+                                     strlen(msg), NULL, 0, msgidp);
+                if (r == -1)
+                        TEST_FAIL("Failed to produce message #%i: %s\n", i,
+                                  rd_strerror(errno));
+        }
+        TIMING_STOP(&t_produce);
+        TEST_SAY("Produced %i messages, waiting for deliveries\n", msgcnt);
+
+        /* Wait for messages to be delivered */
+        TIMING_START(&t_delivery, "DELIVERY");
+        while (rd_kafka_outq_len(rk) > 0) {
+                rd_kafka_event_t *rkev;
+                rkev = rd_kafka_queue_poll(eventq, 1000);
+                switch (rd_kafka_event_type(rkev)) {
+                case RD_KAFKA_EVENT_DR:
+                        TEST_SAYL(3, "%s event with %" PRIusz " messages\n",
+                                  rd_kafka_event_name(rkev),
+                                  rd_kafka_event_message_count(rkev));
+                        handle_drs(rkev);
+                        break;
+                default:
+                        TEST_SAY("Unhandled event: %s\n",
+                                 rd_kafka_event_name(rkev));
+                        break;
+                }
+                rd_kafka_event_destroy(rkev);
+        }
+        TIMING_STOP(&t_delivery);
+
+        if (fails)
+                TEST_FAIL("%i failures, see previous errors", fails);
+
+        if (msgid_next != msgcnt)
+                TEST_FAIL("Still waiting for messages: next %i != end %i\n",
+                          msgid_next, msgcnt);
+
+        rd_kafka_queue_destroy(eventq);
+
+        /* Destroy topic */
+        rd_kafka_topic_destroy(rkt);
+
+        /* Destroy rdkafka instance */
+        TEST_SAY("Destroying kafka instance %s\n", rd_kafka_name(rk));
+        rd_kafka_destroy(rk);
+
+        return 0;
+}
+
+/**
+ * @brief Local test: test log events
+ */
+int main_0039_event_log(int argc, char **argv) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        rd_kafka_queue_t *eventq;
+        int waitevent = 1;
+
+        const char *fac;
+        const char *msg;
+        char ctx[60];
+        int level;
+
+        conf = rd_kafka_conf_new();
+        rd_kafka_conf_set(conf, "bootstrap.servers", "0:65534", NULL, 0);
+        rd_kafka_conf_set(conf, "log.queue", "true", NULL, 0);
+        rd_kafka_conf_set(conf, "debug", "all", NULL, 0);
+
+        /* Create kafka instance */
+        rk     = test_create_handle(RD_KAFKA_PRODUCER, conf);
+        eventq = rd_kafka_queue_get_main(rk);
+        TEST_CALL_ERR__(rd_kafka_set_log_queue(rk, eventq));
+
+        while (waitevent) {
+                /* reset ctx */
+                memset(ctx, '$', sizeof(ctx) - 2);
+                ctx[sizeof(ctx) - 1] = '\0';
+
+                rd_kafka_event_t *rkev;
+                rkev = rd_kafka_queue_poll(eventq, 1000);
+                switch (rd_kafka_event_type(rkev)) {
+                case RD_KAFKA_EVENT_LOG:
+                        rd_kafka_event_log(rkev, &fac, &msg, &level);
+                        rd_kafka_event_debug_contexts(rkev, ctx, sizeof(ctx));
+                        TEST_SAY(
+                            "Got log  event: "
+                            "level: %d ctx: %s fac: %s: msg: %s\n",
+                            level, ctx, fac, msg);
+                        if (strchr(ctx, '$')) {
+                                TEST_FAIL(
+                                    "ctx was not set by "
+                                    "rd_kafka_event_debug_contexts()");
+                        }
+                        waitevent = 0;
+                        break;
+                default:
+                        TEST_SAY("Unhandled event: %s\n",
+                                 rd_kafka_event_name(rkev));
+                        break;
+                }
+                rd_kafka_event_destroy(rkev);
+        }
+
+        /* Destroy rdkafka instance */
+        rd_kafka_queue_destroy(eventq);
+        TEST_SAY("Destroying kafka instance %s\n", rd_kafka_name(rk));
+        rd_kafka_destroy(rk);
+
+        return 0;
+}
+
+/**
+ * @brief Local test: test event generation
+ */
+int main_0039_event(int argc, char **argv) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        rd_kafka_queue_t *eventq;
+        int waitevent = 1;
+
+        /* Set up a config with ERROR events enabled and
+         * configure an invalid broker so that _TRANSPORT or ALL_BROKERS_DOWN
+         * is promptly generated. */
+
+        conf = rd_kafka_conf_new();
+
+        rd_kafka_conf_set_events(conf, RD_KAFKA_EVENT_ERROR);
+        rd_kafka_conf_set(conf, "bootstrap.servers", "0:65534", NULL, 0);
+
+        /* Create kafka instance */
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        eventq = rd_kafka_queue_get_main(rk);
+
+        while (waitevent) {
+                rd_kafka_event_t *rkev;
+                rkev = rd_kafka_queue_poll(eventq, 1000);
+                switch (rd_kafka_event_type(rkev)) {
+                case RD_KAFKA_EVENT_ERROR:
+                        TEST_SAY("Got %s%s event: %s: %s\n",
+                                 rd_kafka_event_error_is_fatal(rkev) ? "FATAL "
+                                                                     : "",
+                                 rd_kafka_event_name(rkev),
+                                 rd_kafka_err2name(rd_kafka_event_error(rkev)),
+                                 rd_kafka_event_error_string(rkev));
+                        waitevent = 0;
+                        break;
+                default:
+                        TEST_SAY("Unhandled event: %s\n",
+                                 rd_kafka_event_name(rkev));
+                        break;
+                }
+                rd_kafka_event_destroy(rkev);
+        }
+
+        rd_kafka_queue_destroy(eventq);
+
+        /* Destroy rdkafka instance */
+        TEST_SAY("Destroying kafka instance %s\n", rd_kafka_name(rk));
+        rd_kafka_destroy(rk);
+
+        return 0;
+}

package/deps/librdkafka/tests/0040-io_event.c

@@ -0,0 +1,251 @@
+/*
+ * 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.
+ */
+
+/**
+ * Tests the queue IO event signalling.
+ */
+
+
+#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 */
+
+#include <fcntl.h>
+#ifdef _WIN32
+#include <io.h>
+#pragma comment(lib, "ws2_32.lib")
+#else
+#include <unistd.h>
+#include <poll.h>
+#endif
+
+
+
+int main_0040_io_event(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        rd_kafka_topic_conf_t *tconf;
+        rd_kafka_t *rk_p, *rk_c;
+        const char *topic;
+        rd_kafka_topic_t *rkt_p;
+        rd_kafka_queue_t *queue;
+        uint64_t testid;
+        int msgcnt = test_quick ? 10 : 100;
+        int recvd  = 0;
+        int fds[2];
+        int wait_multiplier = 1;
+        struct pollfd pfd;
+        int r;
+        rd_kafka_resp_err_t err;
+        enum { _NOPE, _YEP, _REBALANCE } expecting_io = _REBALANCE;
+
+#ifdef _WIN32
+        TEST_SKIP("WSAPoll and pipes are not reliable on Win32 (FIXME)\n");
+        return 0;
+#endif
+        testid = test_id_generate();
+        topic  = test_mk_topic_name(__FUNCTION__, 1);
+
+        rk_p  = test_create_producer();
+        rkt_p = test_create_producer_topic(rk_p, topic, NULL);
+        err   = test_auto_create_topic_rkt(rk_p, rkt_p, tmout_multip(5000));
+        TEST_ASSERT(!err, "Topic auto creation failed: %s",
+                    rd_kafka_err2str(err));
+
+        test_conf_init(&conf, &tconf, 0);
+        rd_kafka_conf_set_events(conf, RD_KAFKA_EVENT_REBALANCE);
+        test_conf_set(conf, "session.timeout.ms", "6000");
+        test_conf_set(conf, "enable.partition.eof", "false");
+        /* Speed up propagation of new topics */
+        test_conf_set(conf, "metadata.max.age.ms", "1000");
+        test_topic_conf_set(tconf, "auto.offset.reset", "earliest");
+        rk_c = test_create_consumer(topic, NULL, conf, tconf);
+
+        queue = rd_kafka_queue_get_consumer(rk_c);
+
+        test_consumer_subscribe(rk_c, topic);
+
+#ifndef _WIN32
+        r = pipe(fds);
+#else
+        r = _pipe(fds, 2, _O_BINARY);
+#endif
+        if (r == -1)
+                TEST_FAIL("pipe() failed: %s\n", strerror(errno));
+
+        rd_kafka_queue_io_event_enable(queue, fds[1], "1", 1);
+
+        pfd.fd      = fds[0];
+        pfd.events  = POLLIN;
+        pfd.revents = 0;
+
+        /**
+         * 1) Wait for rebalance event
+         * 2) Wait 1 interval (1s) expecting no IO (nothing produced).
+         * 3) Produce half the messages
+         * 4) Expect IO
+         * 5) Consume the available messages
+         * 6) Wait 1 interval expecting no IO.
+         * 7) Produce remaing half
+         * 8) Expect IO
+         * 9) Done.
+         */
+        while (recvd < msgcnt) {
+#ifndef _WIN32
+                r = poll(&pfd, 1, 1000 * wait_multiplier);
+#else
+                r = WSAPoll(&pfd, 1, 1000 * wait_multiplier);
+#endif
+                if (r == -1) {
+                        TEST_FAIL("poll() failed: %s", strerror(errno));
+
+                } else if (r == 1) {
+                        rd_kafka_event_t *rkev;
+                        char b;
+                        int eventcnt = 0;
+
+                        if (pfd.events & POLLERR)
+                                TEST_FAIL("Poll error\n");
+                        if (!(pfd.events & POLLIN)) {
+                                TEST_SAY("Stray event 0x%x\n", (int)pfd.events);
+                                continue;
+                        }
+
+                        TEST_SAY("POLLIN\n");
+                        /* Read signaling token to purge socket queue and
+                         * eventually silence POLLIN */
+#ifndef _WIN32
+                        r = read(pfd.fd, &b, 1);
+#else
+                        r = _read((int)pfd.fd, &b, 1);
+#endif
+                        if (r == -1)
+                                TEST_FAIL("read failed: %s\n", strerror(errno));
+
+                        if (!expecting_io)
+                                TEST_WARN(
+                                    "Got unexpected IO after %d/%d msgs\n",
+                                    recvd, msgcnt);
+
+                        while ((rkev = rd_kafka_queue_poll(queue, 0))) {
+                                eventcnt++;
+                                switch (rd_kafka_event_type(rkev)) {
+                                case RD_KAFKA_EVENT_REBALANCE:
+                                        TEST_SAY(
+                                            "Got %s: %s\n",
+                                            rd_kafka_event_name(rkev),
+                                            rd_kafka_err2str(
+                                                rd_kafka_event_error(rkev)));
+                                        if (expecting_io != _REBALANCE)
+                                                TEST_FAIL(
+                                                    "Got Rebalance when "
+                                                    "expecting message\n");
+                                        if (rd_kafka_event_error(rkev) ==
+                                            RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS) {
+                                                rd_kafka_assign(
+                                                    rk_c,
+                                                    rd_kafka_event_topic_partition_list(
+                                                        rkev));
+                                                expecting_io = _NOPE;
+                                        } else
+                                                rd_kafka_assign(rk_c, NULL);
+                                        break;
+
+                                case RD_KAFKA_EVENT_FETCH:
+                                        if (expecting_io != _YEP)
+                                                TEST_FAIL(
+                                                    "Did not expect more "
+                                                    "messages at %d/%d\n",
+                                                    recvd, msgcnt);
+                                        recvd++;
+                                        if (recvd == (msgcnt / 2) ||
+                                            recvd == msgcnt)
+                                                expecting_io = _NOPE;
+                                        break;
+
+                                case RD_KAFKA_EVENT_ERROR:
+                                        TEST_FAIL(
+                                            "Error: %s\n",
+                                            rd_kafka_event_error_string(rkev));
+                                        break;
+
+                                default:
+                                        TEST_SAY("Ignoring event %s\n",
+                                                 rd_kafka_event_name(rkev));
+                                }
+
+                                rd_kafka_event_destroy(rkev);
+                        }
+                        TEST_SAY("%d events, Consumed %d/%d messages\n",
+                                 eventcnt, recvd, msgcnt);
+
+                        wait_multiplier = 1;
+
+                } else {
+                        if (expecting_io == _REBALANCE) {
+                                continue;
+                        } else if (expecting_io == _YEP) {
+                                TEST_FAIL(
+                                    "Did not see expected IO after %d/%d "
+                                    "msgs\n",
+                                    recvd, msgcnt);
+                        }
+
+                        TEST_SAY("IO poll timeout (good)\n");
+
+                        TEST_SAY("Got idle period, producing\n");
+                        test_produce_msgs(rk_p, rkt_p, testid, 0, recvd,
+                                          msgcnt / 2, NULL, 10);
+
+                        expecting_io = _YEP;
+                        /* When running slowly (e.g., valgrind) it might take
+                         * some time before the first message is received
+                         * after producing. */
+                        wait_multiplier = 3;
+                }
+        }
+        TEST_SAY("Done\n");
+
+        rd_kafka_topic_destroy(rkt_p);
+        rd_kafka_destroy(rk_p);
+
+        rd_kafka_queue_destroy(queue);
+        rd_kafka_consumer_close(rk_c);
+        rd_kafka_destroy(rk_c);
+
+#ifndef _WIN32
+        close(fds[0]);
+        close(fds[1]);
+#else
+        _close(fds[0]);
+        _close(fds[1]);
+#endif
+
+        return 0;
+}