@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/0153-memberid.c

@@ -0,0 +1,128 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2025, 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"
+typedef struct consumer_s {
+        const char *group_id;
+        char *memberid;
+} consumer_t;
+
+static int
+is_fatal_cb(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason) {
+        if (err == RD_KAFKA_RESP_ERR__TIMED_OUT)
+                return 0;
+        return 1;
+}
+
+static int consumer_thread(void *arg) {
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *consumer;
+        consumer_t *consumer_args = arg;
+
+        test_curr->is_fatal_cb = is_fatal_cb;
+
+        test_conf_init(&conf, NULL, 60);
+
+        consumer =
+            test_create_consumer(consumer_args->group_id, NULL, conf, NULL);
+
+        consumer_args->memberid = rd_kafka_memberid(consumer);
+
+        test_consumer_close(consumer);
+        rd_kafka_destroy(consumer);
+        test_curr->is_fatal_cb = NULL;
+        return 0;
+}
+
+void do_test_unique_memberid() {
+        int i;
+        int j;
+        int have_only_unique_memberids = 1;
+        const char *group_id           = test_mk_topic_name("0153-memberid", 1);
+
+#define CONSUMER_CNT 500
+        thrd_t thread_id[CONSUMER_CNT];
+        consumer_t consumer_args[CONSUMER_CNT];
+
+        SUB_TEST_QUICK();
+
+        for (i = 0; i < CONSUMER_CNT; i++) {
+                consumer_args[i].group_id = group_id;
+                consumer_args[i].memberid = NULL;
+                thrd_create(&thread_id[i], consumer_thread, &consumer_args[i]);
+        }
+
+        for (i = 0; i < CONSUMER_CNT; i++) {
+                thrd_join(thread_id[i], NULL);
+        }
+
+        for (i = 0; i < CONSUMER_CNT; i++) {
+                if (have_only_unique_memberids) {
+                        for (j = i + 1; j < CONSUMER_CNT; j++) {
+                                if (strcmp(consumer_args[i].memberid,
+                                           consumer_args[j].memberid) == 0) {
+                                        TEST_SAY(
+                                            "Consumer %d has the same member "
+                                            "ID as consumer %d: %s\n",
+                                            i, j, consumer_args[i].memberid);
+                                        have_only_unique_memberids = 0;
+                                        break;
+                                }
+                        }
+                }
+                rd_free(consumer_args[i].memberid);
+        }
+
+        if (have_only_unique_memberids) {
+                TEST_SAY("All %d consumers have unique member IDs\n",
+                         CONSUMER_CNT);
+        } else {
+                TEST_FAIL("Not all consumers have unique member IDs\n");
+        }
+
+        SUB_TEST_PASS();
+}
+
+int main_0153_memberid(int argc, char **argv) {
+
+        if (test_consumer_group_protocol_classic()) {
+                TEST_SKIP(
+                    "Member ID is not generated on the client side in classic "
+                    "protocol, skipping test");
+                return 0;
+        }
+
+        if (!strcmp(test_mode, "valgrind")) {
+                TEST_SKIP("Test is too heavy for valgrind, skipping it");
+                return 0;
+        }
+
+        do_test_unique_memberid();
+
+        return 0;
+}

package/deps/librdkafka/tests/1000-unktopic.c

@@ -0,0 +1,164 @@
+/*
+ * 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 that producing to unknown topic fails.
+ * Issue #39
+ *
+ * NOTE! This test requires auto.create.topics.enable=false to be
+ *       configured on the broker!
+ */
+
+#define _GNU_SOURCE
+#include <sys/time.h>
+#include <time.h>
+
+#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 msgs_wait = 0; /* bitmask */
+
+/**
+ * Delivery report callback.
+ * Called for each message once to signal its delivery status.
+ */
+static void dr_cb(rd_kafka_t *rk,
+                  void *payload,
+                  size_t len,
+                  rd_kafka_resp_err_t err,
+                  void *opaque,
+                  void *msg_opaque) {
+        int msgid = *(int *)msg_opaque;
+
+        free(msg_opaque);
+
+        if (!(msgs_wait & (1 << msgid)))
+                TEST_FAIL(
+                    "Unwanted delivery report for message #%i "
+                    "(waiting for 0x%x)\n",
+                    msgid, msgs_wait);
+
+        TEST_SAY("Delivery report for message #%i: %s\n", msgid,
+                 rd_kafka_err2str(err));
+
+        msgs_wait &= ~(1 << msgid);
+
+        if (err != RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC)
+                TEST_FAIL("Message #%i failed with unexpected error %s\n",
+                          msgid, rd_kafka_err2str(err));
+}
+
+
+int main(int argc, char **argv) {
+        char topic[64];
+        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 errstr[512];
+        char msg[128];
+        int msgcnt = 10;
+        int i;
+
+        /* Generate unique topic name */
+        test_conf_init(&conf, &topic_conf, 10);
+
+        rd_snprintf(topic, sizeof(topic), "rdkafkatest1_unk_%x%x", rand(),
+                    rand());
+
+        TEST_SAY(
+            "\033[33mNOTE! This test requires "
+            "auto.create.topics.enable=false to be configured on "
+            "the broker!\033[0m\n");
+
+        /* Set delivery report callback */
+        rd_kafka_conf_set_dr_cb(conf, dr_cb);
+
+        /* Create kafka instance */
+        rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
+
+        rkt = rd_kafka_topic_new(rk, topic, topic_conf);
+        if (!rkt)
+                TEST_FAIL("Failed to create topic: %s\n", strerror(errno));
+
+        /* Produce a message */
+        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) {
+                        if (errno == ENOENT)
+                                TEST_SAY(
+                                    "Failed to produce message #%i: "
+                                    "unknown topic: good!\n",
+                                    i);
+                        else
+                                TEST_FAIL("Failed to produce message #%i: %s\n",
+                                          i, strerror(errno));
+                } else {
+                        if (i > 5)
+                                TEST_FAIL(
+                                    "Message #%i produced: "
+                                    "should've failed\n",
+                                    i);
+                        msgs_wait |= (1 << i);
+                }
+
+                /* After half the messages: sleep to allow the metadata
+                 * to be fetched from broker and update the actual partition
+                 * count: this will make subsequent produce() calls fail
+                 * immediately. */
+                if (i == 5)
+                        sleep(2);
+        }
+
+        /* Wait for messages to time out */
+        while (rd_kafka_outq_len(rk) > 0)
+                rd_kafka_poll(rk, 50);
+
+        if (msgs_wait != 0)
+                TEST_FAIL("Still waiting for messages: 0x%x\n", msgs_wait);
+
+        /* 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;
+}

package/deps/librdkafka/tests/8000-idle.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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 "testcpp.h"
+#include <cstring>
+
+/**
+ * Manual test: idle producer
+ */
+
+
+static void do_test_idle_producer() {
+  RdKafka::Conf *conf;
+  Test::conf_init(&conf, NULL, 0);
+
+  std::string errstr;
+  RdKafka::Producer *p = RdKafka::Producer::create(conf, errstr);
+  if (!p)
+    Test::Fail("Failed to create Producer: " + errstr);
+  delete conf;
+
+  while (true)
+    p->poll(1000);
+
+  delete p;
+}
+
+
+extern "C" {
+int main_8000_idle(int argc, char **argv) {
+  do_test_idle_producer();
+  return 0;
+}
+}

package/deps/librdkafka/tests/8001-fetch_from_follower_mock_manual.c

@@ -0,0 +1,113 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 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"
+
+#include "../src/rdkafka_proto.h"
+
+/**
+ * @brief Test that the #4195 segfault doesn't happen when preferred replica
+ *        lease expires and the rktp is in fetch state
+ *        RD_KAFKA_TOPPAR_FETCH_OFFSET_WAIT.
+ */
+static void do_test_fetch_from_follower_offset_retry(void) {
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *c;
+        const char *topic = "test";
+        rd_kafka_topic_partition_t *rktpar;
+        rd_kafka_topic_partition_list_t *seek;
+        int i;
+
+        SUB_TEST_QUICK();
+        test_timeout_set(600);
+
+        mcluster = test_mock_cluster_new(3, &bootstraps);
+        /* Set partition leader to broker 1. */
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+        rd_kafka_mock_partition_set_follower(mcluster, topic, 0, 2);
+
+        test_conf_init(&conf, NULL, 0);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "client.rack", "myrack");
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "fetch.error.backoff.ms", "1000");
+        test_conf_set(conf, "fetch.message.max.bytes", "10");
+        test_conf_set(conf, "session.timeout.ms", "600000");
+        test_conf_set(conf, "topic.metadata.refresh.interval.ms", "600000");
+
+        c = test_create_consumer("mygroup", NULL, conf, NULL);
+
+        test_consumer_assign_partition(
+            "do_test_fetch_from_follower_offset_retry", c, topic, 0,
+            RD_KAFKA_OFFSET_INVALID);
+
+        /* Since there are no messages, this poll only waits for metadata, and
+         * then sets the preferred replica after the first fetch request.
+         * Subsequent polls are for waiting up to 5 minutes. */
+        for (i = 0; i < 7; i++) {
+                test_consumer_poll_no_msgs(
+                    "initial metadata and preferred replica set", c, 0, 40000);
+        }
+
+
+        /* Seek to end to trigger ListOffsets */
+        seek           = rd_kafka_topic_partition_list_new(1);
+        rktpar         = rd_kafka_topic_partition_list_add(seek, topic, 0);
+        rktpar->offset = RD_KAFKA_OFFSET_END;
+
+        /* Increase RTT for this ListOffsets */
+        rd_kafka_mock_broker_push_request_error_rtts(
+            mcluster, 2, RD_KAFKAP_ListOffsets, 1, RD_KAFKA_RESP_ERR_NO_ERROR,
+            40 * 1000);
+
+        rd_kafka_seek_partitions(c, seek, -1);
+        rd_kafka_topic_partition_list_destroy(seek);
+
+        /* Wait lease expiry */
+        rd_sleep(50);
+
+        test_consumer_close(c);
+
+        rd_kafka_destroy(c);
+
+        test_mock_cluster_destroy(mcluster);
+
+        SUB_TEST_PASS();
+}
+
+
+int main_8001_fetch_from_follower_mock_manual(int argc, char **argv) {
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        do_test_fetch_from_follower_offset_retry();
+
+        return 0;
+}

package/deps/librdkafka/tests/CMakeLists.txt

@@ -0,0 +1,170 @@
+set(
+    sources
+    0000-unittests.c
+    0001-multiobj.c
+    0002-unkpart.c
+    0003-msgmaxsize.c
+    0004-conf.c
+    0005-order.c
+    0006-symbols.c
+    0007-autotopic.c
+    0008-reqacks.c
+    0009-mock_cluster.c
+    0011-produce_batch.c
+    0012-produce_consume.c
+    0013-null-msgs.c
+    0014-reconsume-191.c
+    0015-offset_seeks.c
+    0016-client_swname.c
+    0017-compression.c
+    0018-cgrp_term.c
+    0019-list_groups.c
+    0020-destroy_hang.c
+    0021-rkt_destroy.c
+    0022-consume_batch.c
+    0025-timers.c
+    0026-consume_pause.c
+    0028-long_topicnames.c
+    0029-assign_offset.c
+    0030-offset_commit.c
+    0031-get_offsets.c
+    0033-regex_subscribe.c
+    0034-offset_reset.c
+    0035-api_version.c
+    0036-partial_fetch.c
+    0037-destroy_hang_local.c
+    0038-performance.c
+    0039-event.c
+    0040-io_event.c
+    0041-fetch_max_bytes.c
+    0042-many_topics.c
+    0043-no_connection.c
+    0044-partition_cnt.c
+    0045-subscribe_update.c
+    0046-rkt_cache.c
+    0047-partial_buf_tmout.c
+    0048-partitioner.c
+    0049-consume_conn_close.c
+    0050-subscribe_adds.c
+    0051-assign_adds.c
+    0052-msg_timestamps.c
+    0053-stats_cb.cpp
+    0054-offset_time.cpp
+    0055-producer_latency.c
+    0056-balanced_group_mt.c
+    0057-invalid_topic.cpp
+    0058-log.cpp
+    0059-bsearch.cpp
+    0060-op_prio.cpp
+    0061-consumer_lag.cpp
+    0062-stats_event.c
+    0063-clusterid.cpp
+    0064-interceptors.c
+    0065-yield.cpp
+    0066-plugins.cpp
+    0067-empty_topic.cpp
+    0068-produce_timeout.c
+    0069-consumer_add_parts.c
+    0070-null_empty.cpp
+    0072-headers_ut.c
+    0073-headers.c
+    0074-producev.c
+    0075-retry.c
+    0076-produce_retry.c
+    0077-compaction.c
+    0078-c_from_cpp.cpp
+    0079-fork.c
+    0080-admin_ut.c
+    0081-admin.c
+    0082-fetch_max_bytes.cpp
+    0083-cb_event.c
+    0084-destroy_flags.c
+    0085-headers.cpp
+    0086-purge.c
+    0088-produce_metadata_timeout.c
+    0089-max_poll_interval.c
+    0090-idempotence.c
+    0091-max_poll_interval_timeout.c
+    0092-mixed_msgver.c
+    0093-holb.c
+    0094-idempotence_msg_timeout.c
+    0095-all_brokers_down.cpp
+    0097-ssl_verify.cpp
+    0098-consumer-txn.cpp
+    0099-commit_metadata.c
+    0100-thread_interceptors.cpp
+    0101-fetch-from-follower.cpp
+    0102-static_group_rebalance.c
+    0103-transactions.c
+    0104-fetch_from_follower_mock.c
+    0105-transactions_mock.c
+    0106-cgrp_sess_timeout.c
+    0107-topic_recreate.c
+    0109-auto_create_topics.cpp
+    0110-batch_size.cpp
+    0111-delay_create_topics.cpp
+    0112-assign_unknown_part.c
+    0113-cooperative_rebalance.cpp
+    0114-sticky_partitioning.cpp
+    0115-producer_auth.cpp
+    0116-kafkaconsumer_close.cpp
+    0117-mock_errors.c
+    0118-commit_rebalance.c
+    0119-consumer_auth.cpp
+    0120-asymmetric_subscription.c
+    0121-clusterid.c
+    0122-buffer_cleaning_after_rebalance.c
+    0123-connections_max_idle.c
+    0124-openssl_invalid_engine.c
+    0125-immediate_flush.c
+    0126-oauthbearer_oidc.c
+    0127-fetch_queue_backoff.cpp
+    0128-sasl_callback_queue.cpp
+    0129-fetch_aborted_msgs.c
+    0130-store_offsets.c
+    0131-connect_timeout.c
+    0132-strategy_ordering.c
+    0133-ssl_keys.c
+    0134-ssl_provider.c
+    0135-sasl_credentials.cpp
+    0136-resolve_cb.c
+    0137-barrier_batch_consume.c
+    0138-admin_mock.c
+    0139-offset_validation_mock.c
+    0140-commit_metadata.cpp
+    0142-reauthentication.c
+    0143-exponential_backoff_mock.c
+    0144-idempotence_mock.c
+    0145-pause_resume_mock.c
+    0146-metadata_mock.c
+    0147-consumer_group_consumer_mock.c
+    0148-offset_fetch_commit_error_mock.c
+    0149-broker-same-host-port.c
+    0150-telemetry_mock.c
+    0151-purge-brokers.c
+    0152-rebootstrap.c
+    0153-memberid.c
+    8000-idle.cpp
+    8001-fetch_from_follower_mock_manual.c
+    test.c
+    testcpp.cpp
+    rusage.c
+)
+
+if(NOT WIN32)
+    list(APPEND sources sockem.c sockem_ctrl.c)
+else()
+    list(APPEND sources ../src/tinycthread.c ../src/tinycthread_extra.c)
+endif()
+
+add_executable(test-runner ${sources})
+target_link_libraries(test-runner PUBLIC rdkafka++)
+
+add_test(NAME RdKafkaTestInParallel COMMAND test-runner -p5)
+add_test(NAME RdKafkaTestSequentially COMMAND test-runner -p1)
+add_test(NAME RdKafkaTestBrokerLess COMMAND test-runner -p5 -l)
+
+if(NOT WIN32 AND NOT APPLE)
+  set(tests_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+  add_subdirectory(interceptor_test)
+endif()