@platformatic/rdkafka 4.0.0

package/deps/librdkafka/tests/0016-client_swname.c

@@ -0,0 +1,166 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test.h"
+
+#include "rdkafka.h"
+
+/**
+ * @name Verify KIP-511, client.software.name and client.software.version
+ *
+ */
+static char jmx_cmd[512];
+
+/**
+ * @brief Verify that the expected software name and version is reported
+ *        in JMX metrics.
+ */
+static void jmx_verify(const char *exp_swname, const char *exp_swversion) {
+#if _WIN32
+        return;
+#else
+        int r;
+        char cmd[512 + 256];
+
+        if (!*jmx_cmd)
+                return;
+
+        rd_snprintf(cmd, sizeof(cmd),
+                    "%s | "
+                    "grep -F 'clientSoftwareName=%s,clientSoftwareVersion=%s'",
+                    jmx_cmd, exp_swname, exp_swversion ? exp_swversion : "");
+        r = system(cmd);
+        if (WEXITSTATUS(r) == 1)
+                TEST_FAIL(
+                    "Expected software name and version not found in "
+                    "JMX metrics with command \"%s\"",
+                    cmd);
+        else if (r == -1 || WIFSIGNALED(r) || WEXITSTATUS(r))
+                TEST_FAIL(
+                    "Failed to execute JmxTool command \"%s\": "
+                    "exit code %d",
+                    cmd, r);
+
+        TEST_SAY(
+            "Expected software name \"%s\" and version \"%s\" "
+            "found in JMX metrics\n",
+            exp_swname, exp_swversion);
+#endif /* !_WIN32 */
+}
+
+
+static void do_test_swname(const char *broker,
+                           const char *swname,
+                           const char *swversion,
+                           const char *exp_swname,
+                           const char *exp_swversion) {
+        rd_kafka_t *rk;
+        rd_kafka_conf_t *conf;
+        const rd_kafka_metadata_t *md;
+        rd_kafka_resp_err_t err;
+
+        TEST_SAY(_C_MAG
+                 "[ Test client.software.name=%s, "
+                 "client.software.version=%s ]\n",
+                 swname ? swname : "NULL", swversion ? swversion : "NULL");
+
+        test_conf_init(&conf, NULL, 30 /* jmxtool is severely slow */);
+        if (broker)
+                test_conf_set(conf, "bootstrap.servers", broker);
+        if (swname)
+                test_conf_set(conf, "client.software.name", swname);
+        if (swversion)
+                test_conf_set(conf, "client.software.version", swversion);
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        /* Trigger a metadata request so we know we're connected. */
+        err = rd_kafka_metadata(rk, 0, NULL, &md, tmout_multip(5000));
+        TEST_ASSERT(!err, "metadata() failed: %s", rd_kafka_err2str(err));
+        rd_kafka_metadata_destroy(md);
+
+        /* Verify JMX metrics, if possible */
+        jmx_verify(exp_swname, exp_swversion);
+
+        rd_kafka_destroy(rk);
+
+        TEST_SAY(_C_GRN
+                 "[ Test client.software.name=%s, "
+                 "client.software.version=%s: PASS ]\n",
+                 swname ? swname : "NULL", swversion ? swversion : "NULL");
+}
+
+int main_0016_client_swname(int argc, char **argv) {
+        const char *broker;
+        const char *kafka_path;
+        const char *jmx_port;
+        const char *reason = NULL;
+
+        /* If available, use the Kafka JmxTool to query software name
+         * in broker JMX metrics */
+        if (!(broker = test_getenv("BROKER_ADDRESS_2", NULL)))
+                reason =
+                    "Env var BROKER_ADDRESS_2 missing "
+                    "(not running in trivup or trivup too old?)";
+        else if (test_broker_version < TEST_BRKVER(2, 5, 0, 0))
+                reason =
+                    "Client software JMX metrics not exposed prior to "
+                    "Apache Kafka 2.5.0.0";
+        else if (!(kafka_path = test_getenv("KAFKA_PATH", NULL)))
+                reason = "Env var KAFKA_PATH missing (not running in trivup?)";
+        else if (!(jmx_port = test_getenv("BROKER_JMX_PORT_2", NULL)))
+                reason =
+                    "Env var BROKER_JMX_PORT_2 missing "
+                    "(not running in trivup or trivup too old?)";
+        else
+                rd_snprintf(jmx_cmd, sizeof(jmx_cmd),
+                            "%s/bin/kafka-run-class.sh kafka.tools.JmxTool "
+                            "--jmx-url "
+                            "service:jmx:rmi:///jndi/rmi://:%s/jmxrmi "
+                            " --one-time true | "
+                            "grep clientSoftware",
+                            kafka_path, jmx_port);
+
+        if (reason)
+                TEST_WARN("Will not be able to verify JMX metrics: %s\n",
+                          reason);
+
+        /* Default values, the version is not checked since the
+         * built librdkafka may not use the same string, and additionally we
+         * don't want to perform the string mangling here to make the string
+         * protocol safe. */
+        do_test_swname(broker, NULL, NULL, "librdkafka", NULL);
+        /* Properly formatted */
+        do_test_swname(broker, "my-little-version", "1.2.3.4",
+                       "my-little-version", "1.2.3.4");
+        /* Containing invalid characters, verify that safing the strings works
+         */
+        do_test_swname(broker, "?1?this needs! ESCAPING?", "--v99.11 ~b~",
+                       "1-this-needs--ESCAPING", "v99.11--b");
+
+        return 0;
+}

package/deps/librdkafka/tests/0017-compression.c

@@ -0,0 +1,142 @@
+/*
+ * 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"
+
+/* 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 compression tests, with rather lacking verification.
+ */
+
+
+int main_0017_compression(int argc, char **argv) {
+        rd_kafka_t *rk_p, *rk_c;
+        const int msg_cnt = 1000;
+        int msg_base      = 0;
+        uint64_t testid;
+#define CODEC_CNT 5
+        const char *codecs[CODEC_CNT + 1] = {
+                "none",
+#if WITH_ZLIB
+                "gzip",
+#endif
+#if WITH_SNAPPY
+                "snappy",
+#endif
+#if WITH_ZSTD
+                "zstd",
+#endif
+                "lz4",
+                NULL
+        };
+        char *topics[CODEC_CNT];
+        const int32_t partition = 0;
+        int i;
+        int crc;
+
+        testid = test_id_generate();
+
+        /* Produce messages */
+        rk_p = test_create_producer();
+        for (i = 0; codecs[i] != NULL; i++) {
+                rd_kafka_topic_t *rkt_p;
+
+                topics[i] = rd_strdup(test_mk_topic_name(codecs[i], 1));
+                TEST_SAY(
+                    "Produce %d messages with %s compression to "
+                    "topic %s\n",
+                    msg_cnt, codecs[i], topics[i]);
+                rkt_p = test_create_producer_topic(
+                    rk_p, topics[i], "compression.codec", codecs[i], NULL);
+
+                /* Produce small message that will not decrease with
+                 * compression (issue #781) */
+                test_produce_msgs(rk_p, rkt_p, testid, partition,
+                                  msg_base + (partition * msg_cnt), 1, NULL, 5);
+
+                /* Produce standard sized messages */
+                test_produce_msgs(rk_p, rkt_p, testid, partition,
+                                  msg_base + (partition * msg_cnt) + 1,
+                                  msg_cnt - 1, NULL, 512);
+                rd_kafka_topic_destroy(rkt_p);
+        }
+
+        rd_kafka_destroy(rk_p);
+
+
+        /* restart timeout (mainly for helgrind use since it is very slow) */
+        test_timeout_set(30);
+
+        /* Consume messages: Without and with CRC checking */
+        for (crc = 0; crc < 2; crc++) {
+                const char *crc_tof = crc ? "true" : "false";
+                rd_kafka_conf_t *conf;
+
+                test_conf_init(&conf, NULL, 0);
+                test_conf_set(conf, "check.crcs", crc_tof);
+
+                rk_c = test_create_consumer(NULL, NULL, conf, NULL);
+
+                for (i = 0; codecs[i] != NULL; i++) {
+                        rd_kafka_topic_t *rkt_c =
+                            rd_kafka_topic_new(rk_c, topics[i], NULL);
+
+                        TEST_SAY("Consume %d messages from topic %s (crc=%s)\n",
+                                 msg_cnt, topics[i], crc_tof);
+                        /* Start consuming */
+                        test_consumer_start(codecs[i], rkt_c, partition,
+                                            RD_KAFKA_OFFSET_BEGINNING);
+
+                        /* Consume messages */
+                        test_consume_msgs(
+                            codecs[i], rkt_c, testid, partition,
+                            /* Use offset 0 here, which is wrong, should
+                             * be TEST_NO_SEEK, but it exposed a bug
+                             * where the Offset query was postponed
+                             * till after the seek, causing messages
+                             * to be replayed. */
+                            0, msg_base, msg_cnt, 1 /* parse format */);
+
+                        test_consumer_stop(codecs[i], rkt_c, partition);
+
+                        rd_kafka_topic_destroy(rkt_c);
+                }
+
+                rd_kafka_destroy(rk_c);
+        }
+
+        for (i = 0; codecs[i] != NULL; i++)
+                rd_free(topics[i]);
+
+
+        return 0;
+}

package/deps/librdkafka/tests/0018-cgrp_term.c

@@ -0,0 +1,333 @@
+/*
+ * 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 "rdstring.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 */
+
+
+/**
+ * KafkaConsumer balanced group testing: termination
+ *
+ * Runs two consumers subscribing to the same topics, waits for both to
+ * get an assignment and then closes one of them.
+ */
+
+
+static int assign_cnt       = 0;
+static int consumed_msg_cnt = 0;
+
+
+static void rebalance_cb(rd_kafka_t *rk,
+                         rd_kafka_resp_err_t err,
+                         rd_kafka_topic_partition_list_t *partitions,
+                         void *opaque) {
+        char *memberid = rd_kafka_memberid(rk);
+
+        TEST_SAY("%s: MemberId \"%s\": Consumer group rebalanced: %s\n",
+                 rd_kafka_name(rk), memberid, rd_kafka_err2str(err));
+
+        if (memberid)
+                free(memberid);
+
+        test_print_partition_list(partitions);
+
+        switch (err) {
+        case RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS:
+                assign_cnt++;
+                rd_kafka_assign(rk, partitions);
+                break;
+
+        case RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS:
+                if (assign_cnt == 0)
+                        TEST_FAIL("asymetric rebalance_cb\n");
+                assign_cnt--;
+                rd_kafka_assign(rk, NULL);
+                break;
+
+        default:
+                TEST_FAIL("rebalance failed: %s\n", rd_kafka_err2str(err));
+                break;
+        }
+}
+
+
+static void consume_all(rd_kafka_t **rk_c,
+                        int rk_cnt,
+                        int exp_msg_cnt,
+                        int max_time /*ms*/) {
+        int64_t ts_start = test_clock();
+        int i;
+
+        max_time *= 1000;
+        while (ts_start + max_time > test_clock()) {
+                for (i = 0; i < rk_cnt; i++) {
+                        rd_kafka_message_t *rkmsg;
+
+                        if (!rk_c[i])
+                                continue;
+
+                        rkmsg = rd_kafka_consumer_poll(rk_c[i], 500);
+
+                        if (!rkmsg)
+                                continue;
+                        else if (rkmsg->err)
+                                TEST_SAY(
+                                    "Message error "
+                                    "(at offset %" PRId64
+                                    " after "
+                                    "%d/%d messages and %dms): %s\n",
+                                    rkmsg->offset, consumed_msg_cnt,
+                                    exp_msg_cnt,
+                                    (int)(test_clock() - ts_start) / 1000,
+                                    rd_kafka_message_errstr(rkmsg));
+                        else
+                                consumed_msg_cnt++;
+
+                        rd_kafka_message_destroy(rkmsg);
+
+                        if (consumed_msg_cnt >= exp_msg_cnt) {
+                                static int once = 0;
+                                if (!once++)
+                                        TEST_SAY("All messages consumed\n");
+                                return;
+                        }
+                }
+        }
+}
+
+struct args {
+        rd_kafka_t *c;
+        rd_kafka_queue_t *queue;
+};
+
+static int poller_thread_main(void *p) {
+        struct args *args = (struct args *)p;
+
+        while (!rd_kafka_consumer_closed(args->c)) {
+                rd_kafka_message_t *rkm;
+
+                /* Using a long timeout (1 minute) to verify that the
+                 * queue is woken when close is done. */
+                rkm = rd_kafka_consume_queue(args->queue, 60 * 1000);
+                if (rkm)
+                        rd_kafka_message_destroy(rkm);
+        }
+
+        return 0;
+}
+
+/**
+ * @brief Close consumer using async queue.
+ */
+static void consumer_close_queue(rd_kafka_t *c) {
+        /* Use the standard consumer queue rather than a temporary queue,
+         * the latter is covered by test 0116. */
+        rd_kafka_queue_t *queue = rd_kafka_queue_get_consumer(c);
+        struct args args        = {c, queue};
+        thrd_t thrd;
+        int ret;
+
+        /* Spin up poller thread */
+        if (thrd_create(&thrd, poller_thread_main, (void *)&args) !=
+            thrd_success)
+                TEST_FAIL("Failed to create thread");
+
+        TEST_SAY("Closing consumer %s using queue\n", rd_kafka_name(c));
+        TEST_CALL_ERROR__(rd_kafka_consumer_close_queue(c, queue));
+
+        if (thrd_join(thrd, &ret) != thrd_success)
+                TEST_FAIL("thrd_join failed");
+
+        rd_kafka_queue_destroy(queue);
+}
+
+
+static void do_test(rd_bool_t with_queue) {
+        const char *topic = test_mk_topic_name(__FUNCTION__, 1);
+#define _CONS_CNT 2
+        rd_kafka_t *rk_p, *rk_c[_CONS_CNT];
+        rd_kafka_topic_t *rkt_p;
+        int msg_cnt       = test_quick ? 100 : 1000;
+        int msg_base      = 0;
+        int partition_cnt = 2;
+        int partition;
+        uint64_t testid;
+        rd_kafka_topic_conf_t *default_topic_conf;
+        rd_kafka_topic_partition_list_t *topics;
+        rd_kafka_resp_err_t err;
+        test_timing_t t_assign, t_consume;
+        char errstr[512];
+        int i;
+
+        SUB_TEST("with_queue=%s", RD_STR_ToF(with_queue));
+
+        testid = test_id_generate();
+
+        /* Produce messages */
+        rk_p  = test_create_producer();
+        rkt_p = test_create_producer_topic(rk_p, topic, NULL);
+
+        for (partition = 0; partition < partition_cnt; partition++) {
+                test_produce_msgs(rk_p, rkt_p, testid, partition,
+                                  msg_base + (partition * msg_cnt), msg_cnt,
+                                  NULL, 0);
+        }
+
+        rd_kafka_topic_destroy(rkt_p);
+        rd_kafka_destroy(rk_p);
+
+
+        test_conf_init(NULL, &default_topic_conf,
+                       5 + ((test_session_timeout_ms * 3 * 2) / 1000));
+        if (rd_kafka_topic_conf_set(default_topic_conf, "auto.offset.reset",
+                                    "smallest", errstr,
+                                    sizeof(errstr)) != RD_KAFKA_CONF_OK)
+                TEST_FAIL("%s\n", errstr);
+
+        /* Fill in topic subscription set */
+        topics = rd_kafka_topic_partition_list_new(1);
+        rd_kafka_topic_partition_list_add(topics, topic, -1);
+
+        /* Create consumers and start subscription */
+        for (i = 0; i < _CONS_CNT; i++) {
+                rk_c[i] = test_create_consumer(
+                    topic /*group_id*/, rebalance_cb, NULL,
+                    rd_kafka_topic_conf_dup(default_topic_conf));
+
+                err = rd_kafka_poll_set_consumer(rk_c[i]);
+                if (err)
+                        TEST_FAIL("poll_set_consumer: %s\n",
+                                  rd_kafka_err2str(err));
+
+                err = rd_kafka_subscribe(rk_c[i], topics);
+                if (err)
+                        TEST_FAIL("subscribe: %s\n", rd_kafka_err2str(err));
+        }
+
+        rd_kafka_topic_conf_destroy(default_topic_conf);
+
+        rd_kafka_topic_partition_list_destroy(topics);
+
+
+        /* Wait for both consumers to get an assignment */
+        TEST_SAY("Awaiting assignments for %d consumer(s)\n", _CONS_CNT);
+        TIMING_START(&t_assign, "WAIT.ASSIGN");
+        while (assign_cnt < _CONS_CNT)
+                consume_all(rk_c, _CONS_CNT, msg_cnt,
+                            test_session_timeout_ms + 3000);
+        TIMING_STOP(&t_assign);
+
+        /* Now close one of the consumers, this will cause a rebalance. */
+        TEST_SAY("Closing down 1/%d consumer(s): %s\n", _CONS_CNT,
+                 rd_kafka_name(rk_c[0]));
+        if (with_queue)
+                consumer_close_queue(rk_c[0]);
+        else
+                TEST_CALL_ERR__(rd_kafka_consumer_close(rk_c[0]));
+
+        rd_kafka_destroy(rk_c[0]);
+        rk_c[0] = NULL;
+
+        /* Let remaining consumers run for a while to take over the now
+         * lost partitions. */
+
+        if (test_consumer_group_protocol_generic() &&
+            assign_cnt != _CONS_CNT - 1)
+                TEST_FAIL("assign_cnt %d, should be %d\n", assign_cnt,
+                          _CONS_CNT - 1);
+
+        TIMING_START(&t_consume, "CONSUME.WAIT");
+        consume_all(rk_c, _CONS_CNT, msg_cnt, test_session_timeout_ms + 3000);
+        TIMING_STOP(&t_consume);
+
+        TEST_SAY("Closing remaining consumers\n");
+        for (i = 0; i < _CONS_CNT; i++) {
+                test_timing_t t_close;
+                rd_kafka_topic_partition_list_t *sub;
+                int j;
+
+                if (!rk_c[i])
+                        continue;
+
+                /* Query subscription */
+                err = rd_kafka_subscription(rk_c[i], &sub);
+                if (err)
+                        TEST_FAIL("%s: subscription() failed: %s\n",
+                                  rd_kafka_name(rk_c[i]),
+                                  rd_kafka_err2str(err));
+                TEST_SAY("%s: subscription (%d):\n", rd_kafka_name(rk_c[i]),
+                         sub->cnt);
+                for (j = 0; j < sub->cnt; j++)
+                        TEST_SAY(" %s\n", sub->elems[j].topic);
+                rd_kafka_topic_partition_list_destroy(sub);
+
+                /* Run an explicit unsubscribe() (async) prior to close()
+                 * to trigger race condition issues on termination. */
+                TEST_SAY("Unsubscribing instance %s\n", rd_kafka_name(rk_c[i]));
+                err = rd_kafka_unsubscribe(rk_c[i]);
+                if (err)
+                        TEST_FAIL("%s: unsubscribe failed: %s\n",
+                                  rd_kafka_name(rk_c[i]),
+                                  rd_kafka_err2str(err));
+
+                TEST_SAY("Closing %s\n", rd_kafka_name(rk_c[i]));
+                TIMING_START(&t_close, "CONSUMER.CLOSE");
+                if (with_queue)
+                        consumer_close_queue(rk_c[i]);
+                else
+                        TEST_CALL_ERR__(rd_kafka_consumer_close(rk_c[i]));
+                TIMING_STOP(&t_close);
+
+                rd_kafka_destroy(rk_c[i]);
+                rk_c[i] = NULL;
+        }
+
+        TEST_SAY("%d/%d messages consumed\n", consumed_msg_cnt, msg_cnt);
+        if (consumed_msg_cnt < msg_cnt)
+                TEST_FAIL("Only %d/%d messages were consumed\n",
+                          consumed_msg_cnt, msg_cnt);
+        else if (consumed_msg_cnt > msg_cnt)
+                TEST_SAY(
+                    "At least %d/%d messages were consumed "
+                    "multiple times\n",
+                    consumed_msg_cnt - msg_cnt, msg_cnt);
+
+        SUB_TEST_PASS();
+}
+
+
+int main_0018_cgrp_term(int argc, char **argv) {
+        do_test(rd_false /* rd_kafka_consumer_close() */);
+        do_test(rd_true /*  rd_kafka_consumer_close_queue() */);
+
+        return 0;
+}