@platformatic/rdkafka 4.0.1 → 4.1.0-alpha.1

package/deps/librdkafka/src/rdkafka_mock_cgrp.c

@@ -37,19 +37,21 @@
 #include "rdkafka_mock_int.h"
 
 
-static const char *rd_kafka_mock_cgrp_state_names[] = {
+static const char *rd_kafka_mock_cgrp_classic_state_names[] = {
     "Empty", "Joining", "Syncing", "Rebalancing", "Up"};
 
 
-static void rd_kafka_mock_cgrp_rebalance(rd_kafka_mock_cgrp_t *mcgrp,
-                                         const char *reason);
 static void
-rd_kafka_mock_cgrp_member_destroy(rd_kafka_mock_cgrp_t *mcgrp,
-                                  rd_kafka_mock_cgrp_member_t *member);
+rd_kafka_mock_cgrp_classic_rebalance(rd_kafka_mock_cgrp_classic_t *mcgrp,
+                                     const char *reason);
+static void rd_kafka_mock_cgrp_classic_member_destroy(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member);
 
-static void rd_kafka_mock_cgrp_set_state(rd_kafka_mock_cgrp_t *mcgrp,
-                                         unsigned int new_state,
-                                         const char *reason) {
+static void
+rd_kafka_mock_cgrp_classic_set_state(rd_kafka_mock_cgrp_classic_t *mcgrp,
+                                     unsigned int new_state,
+                                     const char *reason) {
         if (mcgrp->state == new_state)
                 return;
 
@@ -57,8 +59,8 @@ static void rd_kafka_mock_cgrp_set_state(rd_kafka_mock_cgrp_t *mcgrp,
                      "Mock consumer group %s with %d member(s) "
                      "changing state %s -> %s: %s",
                      mcgrp->id, mcgrp->member_cnt,
-                     rd_kafka_mock_cgrp_state_names[mcgrp->state],
-                     rd_kafka_mock_cgrp_state_names[new_state], reason);
+                     rd_kafka_mock_cgrp_classic_state_names[mcgrp->state],
+                     rd_kafka_mock_cgrp_classic_state_names[new_state], reason);
 
         mcgrp->state = new_state;
 }
@@ -67,8 +69,9 @@ static void rd_kafka_mock_cgrp_set_state(rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Mark member as active (restart session timer)
  */
-void rd_kafka_mock_cgrp_member_active(rd_kafka_mock_cgrp_t *mcgrp,
-                                      rd_kafka_mock_cgrp_member_t *member) {
+void rd_kafka_mock_cgrp_classic_member_active(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member) {
         rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
                      "Marking mock consumer group member %s as active",
                      member->id);
@@ -81,11 +84,11 @@ void rd_kafka_mock_cgrp_member_active(rd_kafka_mock_cgrp_t *mcgrp,
  *
  * @param member may be NULL.
  */
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_check_state(rd_kafka_mock_cgrp_t *mcgrp,
-                               rd_kafka_mock_cgrp_member_t *member,
-                               const rd_kafka_buf_t *request,
-                               int32_t generation_id) {
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_check_state(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member,
+    const rd_kafka_buf_t *request,
+    int32_t generation_id) {
         int16_t ApiKey              = request->rkbuf_reqhdr.ApiKey;
         rd_bool_t has_generation_id = ApiKey == RD_KAFKAP_SyncGroup ||
                                       ApiKey == RD_KAFKAP_Heartbeat ||
@@ -142,9 +145,9 @@ rd_kafka_mock_cgrp_check_state(rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Set a member's assignment (from leader's SyncGroupRequest)
  */
-void rd_kafka_mock_cgrp_member_assignment_set(
-    rd_kafka_mock_cgrp_t *mcgrp,
-    rd_kafka_mock_cgrp_member_t *member,
+void rd_kafka_mock_cgrp_classic_member_assignment_set(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member,
     const rd_kafkap_bytes_t *Metadata) {
         if (member->assignment) {
                 rd_assert(mcgrp->assignment_cnt > 0);
@@ -163,9 +166,10 @@ void rd_kafka_mock_cgrp_member_assignment_set(
 /**
  * @brief Sync done (successfully) or failed, send responses back to members.
  */
-static void rd_kafka_mock_cgrp_sync_done(rd_kafka_mock_cgrp_t *mcgrp,
-                                         rd_kafka_resp_err_t err) {
-        rd_kafka_mock_cgrp_member_t *member;
+static void
+rd_kafka_mock_cgrp_classic_sync_done(rd_kafka_mock_cgrp_classic_t *mcgrp,
+                                     rd_kafka_resp_err_t err) {
+        rd_kafka_mock_cgrp_classic_member_t *member;
 
         TAILQ_FOREACH(member, &mcgrp->members, link) {
                 rd_kafka_buf_t *resp;
@@ -181,7 +185,8 @@ static void rd_kafka_mock_cgrp_sync_done(rd_kafka_mock_cgrp_t *mcgrp,
                             resp, !err ? member->assignment : NULL);
                 }
 
-                rd_kafka_mock_cgrp_member_assignment_set(mcgrp, member, NULL);
+                rd_kafka_mock_cgrp_classic_member_assignment_set(mcgrp, member,
+                                                                 NULL);
 
                 if (member->conn) {
                         rd_kafka_mock_connection_set_blocking(member->conn,
@@ -201,20 +206,21 @@ static void rd_kafka_mock_cgrp_sync_done(rd_kafka_mock_cgrp_t *mcgrp,
  * @brief Check if all members have sent SyncGroupRequests, if so, propagate
  *        assignment to members.
  */
-static void rd_kafka_mock_cgrp_sync_check(rd_kafka_mock_cgrp_t *mcgrp) {
+static void
+rd_kafka_mock_cgrp_classic_sync_check(rd_kafka_mock_cgrp_classic_t *mcgrp) {
 
         rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
                      "Mock consumer group %s: awaiting %d/%d syncing members "
                      "in state %s",
                      mcgrp->id, mcgrp->assignment_cnt, mcgrp->member_cnt,
-                     rd_kafka_mock_cgrp_state_names[mcgrp->state]);
+                     rd_kafka_mock_cgrp_classic_state_names[mcgrp->state]);
 
         if (mcgrp->assignment_cnt < mcgrp->member_cnt)
                 return;
 
-        rd_kafka_mock_cgrp_sync_done(mcgrp, RD_KAFKA_RESP_ERR_NO_ERROR);
-        rd_kafka_mock_cgrp_set_state(mcgrp, RD_KAFKA_MOCK_CGRP_STATE_UP,
-                                     "all members synced");
+        rd_kafka_mock_cgrp_classic_sync_done(mcgrp, RD_KAFKA_RESP_ERR_NO_ERROR);
+        rd_kafka_mock_cgrp_classic_set_state(mcgrp, RD_KAFKA_MOCK_CGRP_STATE_UP,
+                                             "all members synced");
 }
 
 
@@ -223,16 +229,16 @@ static void rd_kafka_mock_cgrp_sync_check(rd_kafka_mock_cgrp_t *mcgrp) {
  *        which will be sent when the all group member SyncGroupRequest are
  *        received.
  */
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_member_sync_set(rd_kafka_mock_cgrp_t *mcgrp,
-                                   rd_kafka_mock_cgrp_member_t *member,
-                                   rd_kafka_mock_connection_t *mconn,
-                                   rd_kafka_buf_t *resp) {
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_member_sync_set(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member,
+    rd_kafka_mock_connection_t *mconn,
+    rd_kafka_buf_t *resp) {
 
         if (mcgrp->state != RD_KAFKA_MOCK_CGRP_STATE_SYNCING)
                 return RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS; /* FIXME */
 
-        rd_kafka_mock_cgrp_member_active(mcgrp, member);
+        rd_kafka_mock_cgrp_classic_member_active(mcgrp, member);
 
         rd_assert(!member->resp);
 
@@ -241,7 +247,7 @@ rd_kafka_mock_cgrp_member_sync_set(rd_kafka_mock_cgrp_t *mcgrp,
         rd_kafka_mock_connection_set_blocking(member->conn, rd_true);
 
         /* Check if all members now have an assignment, if so, send responses */
-        rd_kafka_mock_cgrp_sync_check(mcgrp);
+        rd_kafka_mock_cgrp_classic_sync_check(mcgrp);
 
         return RD_KAFKA_RESP_ERR_NO_ERROR;
 }
@@ -250,16 +256,16 @@ rd_kafka_mock_cgrp_member_sync_set(rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Member is explicitly leaving the group (through LeaveGroupRequest)
  */
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_member_leave(rd_kafka_mock_cgrp_t *mcgrp,
-                                rd_kafka_mock_cgrp_member_t *member) {
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_member_leave(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member) {
 
         rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
                      "Member %s is leaving group %s", member->id, mcgrp->id);
 
-        rd_kafka_mock_cgrp_member_destroy(mcgrp, member);
+        rd_kafka_mock_cgrp_classic_member_destroy(mcgrp, member);
 
-        rd_kafka_mock_cgrp_rebalance(mcgrp, "explicit member leave");
+        rd_kafka_mock_cgrp_classic_rebalance(mcgrp, "explicit member leave");
 
         return RD_KAFKA_RESP_ERR_NO_ERROR;
 }
@@ -267,8 +273,9 @@ rd_kafka_mock_cgrp_member_leave(rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Destroys/frees an array of protocols, including the array itself.
  */
-void rd_kafka_mock_cgrp_protos_destroy(rd_kafka_mock_cgrp_proto_t *protos,
-                                       int proto_cnt) {
+void rd_kafka_mock_cgrp_classic_protos_destroy(
+    rd_kafka_mock_cgrp_classic_proto_t *protos,
+    int proto_cnt) {
         int i;
 
         for (i = 0; i < proto_cnt; i++) {
@@ -280,15 +287,16 @@ void rd_kafka_mock_cgrp_protos_destroy(rd_kafka_mock_cgrp_proto_t *protos,
         rd_free(protos);
 }
 
-static void
-rd_kafka_mock_cgrp_rebalance_timer_restart(rd_kafka_mock_cgrp_t *mcgrp,
-                                           int timeout_ms);
+static void rd_kafka_mock_cgrp_classic_rebalance_timer_restart(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    int timeout_ms);
 
 /**
  * @brief Elect consumer group leader and send JoinGroup responses
  */
-static void rd_kafka_mock_cgrp_elect_leader(rd_kafka_mock_cgrp_t *mcgrp) {
-        rd_kafka_mock_cgrp_member_t *member;
+static void
+rd_kafka_mock_cgrp_classic_elect_leader(rd_kafka_mock_cgrp_classic_t *mcgrp) {
+        rd_kafka_mock_cgrp_classic_member_t *member;
 
         rd_assert(mcgrp->state == RD_KAFKA_MOCK_CGRP_STATE_JOINING);
         rd_assert(!TAILQ_EMPTY(&mcgrp->members));
@@ -331,7 +339,7 @@ static void rd_kafka_mock_cgrp_elect_leader(rd_kafka_mock_cgrp_t *mcgrp) {
                 rd_bool_t is_leader = member == mcgrp->leader;
                 int member_cnt      = is_leader ? mcgrp->member_cnt : 0;
                 rd_kafka_buf_t *resp;
-                rd_kafka_mock_cgrp_member_t *member2;
+                rd_kafka_mock_cgrp_classic_member_t *member2;
                 rd_kafka_mock_connection_t *mconn;
 
                 /* Member connection has been closed, it will eventually
@@ -373,7 +381,7 @@ static void rd_kafka_mock_cgrp_elect_leader(rd_kafka_mock_cgrp_t *mcgrp) {
                 /* Mark each member as active to avoid them timing out
                  * at the same time as a JoinGroup handler that blocks
                  * session.timeout.ms to elect a leader. */
-                rd_kafka_mock_cgrp_member_active(mcgrp, member);
+                rd_kafka_mock_cgrp_classic_member_active(mcgrp, member);
 
                 rd_kafka_mock_connection_set_blocking(mconn, rd_false);
                 rd_kafka_mock_connection_send_response(mconn, resp);
@@ -381,20 +389,22 @@ static void rd_kafka_mock_cgrp_elect_leader(rd_kafka_mock_cgrp_t *mcgrp) {
 
         mcgrp->last_member_cnt = mcgrp->member_cnt;
 
-        rd_kafka_mock_cgrp_set_state(mcgrp, RD_KAFKA_MOCK_CGRP_STATE_SYNCING,
-                                     "leader elected, waiting for all "
-                                     "members to sync");
+        rd_kafka_mock_cgrp_classic_set_state(mcgrp,
+                                             RD_KAFKA_MOCK_CGRP_STATE_SYNCING,
+                                             "leader elected, waiting for all "
+                                             "members to sync");
 
-        rd_kafka_mock_cgrp_rebalance_timer_restart(mcgrp,
-                                                   mcgrp->session_timeout_ms);
+        rd_kafka_mock_cgrp_classic_rebalance_timer_restart(
+            mcgrp, mcgrp->session_timeout_ms);
 }
 
 
 /**
  * @brief Trigger group rebalance.
  */
-static void rd_kafka_mock_cgrp_rebalance(rd_kafka_mock_cgrp_t *mcgrp,
-                                         const char *reason) {
+static void
+rd_kafka_mock_cgrp_classic_rebalance(rd_kafka_mock_cgrp_classic_t *mcgrp,
+                                     const char *reason) {
         int timeout_ms;
 
         if (mcgrp->state == RD_KAFKA_MOCK_CGRP_STATE_JOINING)
@@ -418,21 +428,23 @@ static void rd_kafka_mock_cgrp_rebalance(rd_kafka_mock_cgrp_t *mcgrp,
 
         if (mcgrp->state == RD_KAFKA_MOCK_CGRP_STATE_SYNCING)
                 /* Abort current Syncing state */
-                rd_kafka_mock_cgrp_sync_done(
+                rd_kafka_mock_cgrp_classic_sync_done(
                     mcgrp, RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS);
 
-        rd_kafka_mock_cgrp_set_state(mcgrp, RD_KAFKA_MOCK_CGRP_STATE_JOINING,
-                                     reason);
-        rd_kafka_mock_cgrp_rebalance_timer_restart(mcgrp, timeout_ms);
+        rd_kafka_mock_cgrp_classic_set_state(
+            mcgrp, RD_KAFKA_MOCK_CGRP_STATE_JOINING, reason);
+        rd_kafka_mock_cgrp_classic_rebalance_timer_restart(mcgrp, timeout_ms);
 }
 
 /**
  * @brief Consumer group state machine triggered by timer events.
  */
-static void rd_kafka_mock_cgrp_fsm_timeout(rd_kafka_mock_cgrp_t *mcgrp) {
+static void
+rd_kafka_mock_cgrp_classic_fsm_timeout(rd_kafka_mock_cgrp_classic_t *mcgrp) {
         rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
                      "Mock consumer group %s FSM timeout in state %s",
-                     mcgrp->id, rd_kafka_mock_cgrp_state_names[mcgrp->state]);
+                     mcgrp->id,
+                     rd_kafka_mock_cgrp_classic_state_names[mcgrp->state]);
 
         switch (mcgrp->state) {
         case RD_KAFKA_MOCK_CGRP_STATE_EMPTY:
@@ -441,9 +453,9 @@ static void rd_kafka_mock_cgrp_fsm_timeout(rd_kafka_mock_cgrp_t *mcgrp) {
         case RD_KAFKA_MOCK_CGRP_STATE_JOINING:
                 /* Timed out waiting for more members, elect a leader */
                 if (mcgrp->member_cnt > 0)
-                        rd_kafka_mock_cgrp_elect_leader(mcgrp);
+                        rd_kafka_mock_cgrp_classic_elect_leader(mcgrp);
                 else
-                        rd_kafka_mock_cgrp_set_state(
+                        rd_kafka_mock_cgrp_classic_set_state(
                             mcgrp, RD_KAFKA_MOCK_CGRP_STATE_EMPTY,
                             "no members joined");
                 break;
@@ -452,20 +464,20 @@ static void rd_kafka_mock_cgrp_fsm_timeout(rd_kafka_mock_cgrp_t *mcgrp) {
                 /* Timed out waiting for all members to sync */
 
                 /* Send error response to all waiting members */
-                rd_kafka_mock_cgrp_sync_done(
+                rd_kafka_mock_cgrp_classic_sync_done(
                     mcgrp, RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS /* FIXME */);
 
-                rd_kafka_mock_cgrp_set_state(
+                rd_kafka_mock_cgrp_classic_set_state(
                     mcgrp, RD_KAFKA_MOCK_CGRP_STATE_REBALANCING,
                     "timed out waiting for all members to synchronize");
                 break;
 
         case RD_KAFKA_MOCK_CGRP_STATE_REBALANCING:
                 /* Timed out waiting for all members to Leave or re-Join */
-                rd_kafka_mock_cgrp_set_state(mcgrp,
-                                             RD_KAFKA_MOCK_CGRP_STATE_JOINING,
-                                             "timed out waiting for all "
-                                             "members to re-Join or Leave");
+                rd_kafka_mock_cgrp_classic_set_state(
+                    mcgrp, RD_KAFKA_MOCK_CGRP_STATE_JOINING,
+                    "timed out waiting for all "
+                    "members to re-Join or Leave");
                 break;
 
         case RD_KAFKA_MOCK_CGRP_STATE_UP:
@@ -477,27 +489,27 @@ static void rd_kafka_mock_cgrp_fsm_timeout(rd_kafka_mock_cgrp_t *mcgrp) {
 
 static void rd_kafka_mcgrp_rebalance_timer_cb(rd_kafka_timers_t *rkts,
                                               void *arg) {
-        rd_kafka_mock_cgrp_t *mcgrp = arg;
+        rd_kafka_mock_cgrp_classic_t *mcgrp = arg;
 
-        rd_kafka_mock_cgrp_fsm_timeout(mcgrp);
+        rd_kafka_mock_cgrp_classic_fsm_timeout(mcgrp);
 }
 
 
 /**
  * @brief Restart the rebalance timer, postponing leader election.
  */
-static void
-rd_kafka_mock_cgrp_rebalance_timer_restart(rd_kafka_mock_cgrp_t *mcgrp,
-                                           int timeout_ms) {
+static void rd_kafka_mock_cgrp_classic_rebalance_timer_restart(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    int timeout_ms) {
         rd_kafka_timer_start_oneshot(
             &mcgrp->cluster->timers, &mcgrp->rebalance_tmr, rd_true,
             timeout_ms * 1000, rd_kafka_mcgrp_rebalance_timer_cb, mcgrp);
 }
 
 
-static void
-rd_kafka_mock_cgrp_member_destroy(rd_kafka_mock_cgrp_t *mcgrp,
-                                  rd_kafka_mock_cgrp_member_t *member) {
+static void rd_kafka_mock_cgrp_classic_member_destroy(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_cgrp_classic_member_t *member) {
         rd_assert(mcgrp->member_cnt > 0);
         TAILQ_REMOVE(&mcgrp->members, member, link);
         mcgrp->member_cnt--;
@@ -510,9 +522,10 @@ rd_kafka_mock_cgrp_member_destroy(rd_kafka_mock_cgrp_t *mcgrp,
         if (member->group_instance_id)
                 rd_free(member->group_instance_id);
 
-        rd_kafka_mock_cgrp_member_assignment_set(mcgrp, member, NULL);
+        rd_kafka_mock_cgrp_classic_member_assignment_set(mcgrp, member, NULL);
 
-        rd_kafka_mock_cgrp_protos_destroy(member->protos, member->proto_cnt);
+        rd_kafka_mock_cgrp_classic_protos_destroy(member->protos,
+                                                  member->proto_cnt);
 
         rd_free(member);
 }
@@ -521,13 +534,13 @@ rd_kafka_mock_cgrp_member_destroy(rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Find member in group.
  */
-rd_kafka_mock_cgrp_member_t *
-rd_kafka_mock_cgrp_member_find(const rd_kafka_mock_cgrp_t *mcgrp,
-                               const rd_kafkap_str_t *MemberId) {
-        const rd_kafka_mock_cgrp_member_t *member;
+rd_kafka_mock_cgrp_classic_member_t *rd_kafka_mock_cgrp_classic_member_find(
+    const rd_kafka_mock_cgrp_classic_t *mcgrp,
+    const rd_kafkap_str_t *MemberId) {
+        const rd_kafka_mock_cgrp_classic_member_t *member;
         TAILQ_FOREACH(member, &mcgrp->members, link) {
                 if (!rd_kafkap_str_cmp_str(MemberId, member->id))
-                        return (rd_kafka_mock_cgrp_member_t *)member;
+                        return (rd_kafka_mock_cgrp_classic_member_t *)member;
         }
 
         return NULL;
@@ -537,25 +550,25 @@ rd_kafka_mock_cgrp_member_find(const rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Update or add member to consumer group
  */
-rd_kafka_resp_err_t
-rd_kafka_mock_cgrp_member_add(rd_kafka_mock_cgrp_t *mcgrp,
-                              rd_kafka_mock_connection_t *mconn,
-                              rd_kafka_buf_t *resp,
-                              const rd_kafkap_str_t *MemberId,
-                              const rd_kafkap_str_t *ProtocolType,
-                              const rd_kafkap_str_t *GroupInstanceId,
-                              rd_kafka_mock_cgrp_proto_t *protos,
-                              int proto_cnt,
-                              int session_timeout_ms) {
-        rd_kafka_mock_cgrp_member_t *member;
+rd_kafka_resp_err_t rd_kafka_mock_cgrp_classic_member_add(
+    rd_kafka_mock_cgrp_classic_t *mcgrp,
+    rd_kafka_mock_connection_t *mconn,
+    rd_kafka_buf_t *resp,
+    const rd_kafkap_str_t *MemberId,
+    const rd_kafkap_str_t *ProtocolType,
+    const rd_kafkap_str_t *GroupInstanceId,
+    rd_kafka_mock_cgrp_classic_proto_t *protos,
+    int proto_cnt,
+    int session_timeout_ms) {
+        rd_kafka_mock_cgrp_classic_member_t *member;
         rd_kafka_resp_err_t err;
 
-        err = rd_kafka_mock_cgrp_check_state(mcgrp, NULL, resp, -1);
+        err = rd_kafka_mock_cgrp_classic_check_state(mcgrp, NULL, resp, -1);
         if (err)
                 return err;
 
         /* Find member */
-        member = rd_kafka_mock_cgrp_member_find(mcgrp, MemberId);
+        member = rd_kafka_mock_cgrp_classic_member_find(mcgrp, MemberId);
         if (!member) {
                 /* Not found, add member */
                 member = rd_calloc(1, sizeof(*member));
@@ -577,20 +590,20 @@ rd_kafka_mock_cgrp_member_add(rd_kafka_mock_cgrp_t *mcgrp,
         }
 
         if (mcgrp->state != RD_KAFKA_MOCK_CGRP_STATE_JOINING)
-                rd_kafka_mock_cgrp_rebalance(mcgrp, "member join");
+                rd_kafka_mock_cgrp_classic_rebalance(mcgrp, "member join");
 
         mcgrp->session_timeout_ms = session_timeout_ms;
 
         if (member->protos)
-                rd_kafka_mock_cgrp_protos_destroy(member->protos,
-                                                  member->proto_cnt);
+                rd_kafka_mock_cgrp_classic_protos_destroy(member->protos,
+                                                          member->proto_cnt);
         member->protos    = protos;
         member->proto_cnt = proto_cnt;
 
         rd_assert(!member->resp);
         member->resp = resp;
         member->conn = mconn;
-        rd_kafka_mock_cgrp_member_active(mcgrp, member);
+        rd_kafka_mock_cgrp_classic_member_active(mcgrp, member);
 
         return RD_KAFKA_RESP_ERR_NO_ERROR;
 }
@@ -598,10 +611,10 @@ rd_kafka_mock_cgrp_member_add(rd_kafka_mock_cgrp_t *mcgrp,
 /**
  * @brief Check if any members have exceeded the session timeout.
  */
-static void rd_kafka_mock_cgrp_session_tmr_cb(rd_kafka_timers_t *rkts,
-                                              void *arg) {
-        rd_kafka_mock_cgrp_t *mcgrp = arg;
-        rd_kafka_mock_cgrp_member_t *member, *tmp;
+static void rd_kafka_mock_cgrp_classic_session_tmr_cb(rd_kafka_timers_t *rkts,
+                                                      void *arg) {
+        rd_kafka_mock_cgrp_classic_t *mcgrp = arg;
+        rd_kafka_mock_cgrp_classic_member_t *member, *tmp;
         rd_ts_t now     = rd_clock();
         int timeout_cnt = 0;
 
@@ -615,19 +628,19 @@ static void rd_kafka_mock_cgrp_session_tmr_cb(rd_kafka_timers_t *rkts,
                              "Member %s session timed out for group %s",
                              member->id, mcgrp->id);
 
-                rd_kafka_mock_cgrp_member_destroy(mcgrp, member);
+                rd_kafka_mock_cgrp_classic_member_destroy(mcgrp, member);
                 timeout_cnt++;
         }
 
         if (timeout_cnt)
-                rd_kafka_mock_cgrp_rebalance(mcgrp, "member timeout");
+                rd_kafka_mock_cgrp_classic_rebalance(mcgrp, "member timeout");
 }
 
 
-void rd_kafka_mock_cgrp_destroy(rd_kafka_mock_cgrp_t *mcgrp) {
-        rd_kafka_mock_cgrp_member_t *member;
+void rd_kafka_mock_cgrp_classic_destroy(rd_kafka_mock_cgrp_classic_t *mcgrp) {
+        rd_kafka_mock_cgrp_classic_member_t *member;
 
-        TAILQ_REMOVE(&mcgrp->cluster->cgrps, mcgrp, link);
+        TAILQ_REMOVE(&mcgrp->cluster->cgrps_classic, mcgrp, link);
 
         rd_kafka_timer_stop(&mcgrp->cluster->timers, &mcgrp->rebalance_tmr,
                             rd_true);
@@ -638,15 +651,16 @@ void rd_kafka_mock_cgrp_destroy(rd_kafka_mock_cgrp_t *mcgrp) {
         if (mcgrp->protocol_name)
                 rd_free(mcgrp->protocol_name);
         while ((member = TAILQ_FIRST(&mcgrp->members)))
-                rd_kafka_mock_cgrp_member_destroy(mcgrp, member);
+                rd_kafka_mock_cgrp_classic_member_destroy(mcgrp, member);
         rd_free(mcgrp);
 }
 
 
-rd_kafka_mock_cgrp_t *rd_kafka_mock_cgrp_find(rd_kafka_mock_cluster_t *mcluster,
-                                              const rd_kafkap_str_t *GroupId) {
-        rd_kafka_mock_cgrp_t *mcgrp;
-        TAILQ_FOREACH(mcgrp, &mcluster->cgrps, link) {
+rd_kafka_mock_cgrp_classic_t *
+rd_kafka_mock_cgrp_classic_find(rd_kafka_mock_cluster_t *mcluster,
+                                const rd_kafkap_str_t *GroupId) {
+        rd_kafka_mock_cgrp_classic_t *mcgrp;
+        TAILQ_FOREACH(mcgrp, &mcluster->cgrps_classic, link) {
                 if (!rd_kafkap_str_cmp_str(GroupId, mcgrp->id))
                         return mcgrp;
         }
@@ -656,15 +670,15 @@ rd_kafka_mock_cgrp_t *rd_kafka_mock_cgrp_find(rd_kafka_mock_cluster_t *mcluster,
 
 
 /**
- * @brief Find or create a consumer group
+ * @brief Find or create a classic consumer group
  */
-rd_kafka_mock_cgrp_t *
-rd_kafka_mock_cgrp_get(rd_kafka_mock_cluster_t *mcluster,
-                       const rd_kafkap_str_t *GroupId,
-                       const rd_kafkap_str_t *ProtocolType) {
-        rd_kafka_mock_cgrp_t *mcgrp;
+rd_kafka_mock_cgrp_classic_t *
+rd_kafka_mock_cgrp_classic_get(rd_kafka_mock_cluster_t *mcluster,
+                               const rd_kafkap_str_t *GroupId,
+                               const rd_kafkap_str_t *ProtocolType) {
+        rd_kafka_mock_cgrp_classic_t *mcgrp;
 
-        mcgrp = rd_kafka_mock_cgrp_find(mcluster, GroupId);
+        mcgrp = rd_kafka_mock_cgrp_classic_find(mcluster, GroupId);
         if (mcgrp)
                 return mcgrp;
 
@@ -679,24 +693,25 @@ rd_kafka_mock_cgrp_get(rd_kafka_mock_cluster_t *mcluster,
         TAILQ_INIT(&mcgrp->members);
         rd_kafka_timer_start(&mcluster->timers, &mcgrp->session_tmr,
                              1000 * 1000 /*1s*/,
-                             rd_kafka_mock_cgrp_session_tmr_cb, mcgrp);
+                             rd_kafka_mock_cgrp_classic_session_tmr_cb, mcgrp);
 
-        TAILQ_INSERT_TAIL(&mcluster->cgrps, mcgrp, link);
+        TAILQ_INSERT_TAIL(&mcluster->cgrps_classic, mcgrp, link);
 
         return mcgrp;
 }
 
 
 /**
- * @brief A client connection closed, check if any cgrp has any state
+ * @brief A client connection closed, check if any classic cgrp has any state
  *        for this connection that needs to be cleared.
  */
-void rd_kafka_mock_cgrps_connection_closed(rd_kafka_mock_cluster_t *mcluster,
-                                           rd_kafka_mock_connection_t *mconn) {
-        rd_kafka_mock_cgrp_t *mcgrp;
+void rd_kafka_mock_cgrps_classic_connection_closed(
+    rd_kafka_mock_cluster_t *mcluster,
+    rd_kafka_mock_connection_t *mconn) {
+        rd_kafka_mock_cgrp_classic_t *mcgrp;
 
-        TAILQ_FOREACH(mcgrp, &mcluster->cgrps, link) {
-                rd_kafka_mock_cgrp_member_t *member, *tmp;
+        TAILQ_FOREACH(mcgrp, &mcluster->cgrps_classic, link) {
+                rd_kafka_mock_cgrp_classic_member_t *member, *tmp;
                 TAILQ_FOREACH_SAFE(member, &mcgrp->members, link, tmp) {
                         if (member->conn == mconn) {
                                 member->conn = NULL;
@@ -708,3 +723,1154 @@ void rd_kafka_mock_cgrps_connection_closed(rd_kafka_mock_cluster_t *mcluster,
                 }
         }
 }
+
+/**
+ * @struct Target assignment for a consumer group.
+ *         `member_ids` and `assignment` are in the same order
+ *         and have the same count.
+ */
+typedef struct rd_kafka_mock_cgrp_consumer_target_assignment_s {
+        rd_list_t *member_ids; /**< Member id list (char *). */
+        rd_list_t *assignment; /**< Assingment list
+                                  (rd_kafka_topic_partition_list_t *). */
+} rd_kafka_mock_cgrp_consumer_target_assignment_t;
+
+static rd_kafka_mock_cgrp_consumer_target_assignment_t *
+rd_kafka_mock_cgrp_consumer_target_assignment_new0(rd_list_t *member_ids,
+                                                   rd_list_t *assignment) {
+        rd_assert(member_ids->rl_cnt == assignment->rl_cnt);
+        rd_kafka_mock_cgrp_consumer_target_assignment_t *target_assignment =
+            rd_calloc(1, sizeof(*target_assignment));
+        target_assignment->member_ids =
+            rd_list_copy(member_ids, rd_list_string_copy, NULL);
+        target_assignment->assignment = rd_list_copy(
+            assignment, rd_kafka_topic_partition_list_copy_opaque, NULL);
+        return target_assignment;
+}
+
+rd_kafka_mock_cgrp_consumer_target_assignment_t *
+rd_kafka_mock_cgrp_consumer_target_assignment_new(
+    char **member_ids,
+    int member_cnt,
+    rd_kafka_topic_partition_list_t **assignment) {
+        int i;
+        rd_list_t *member_id_list, *assignment_list;
+        rd_kafka_mock_cgrp_consumer_target_assignment_t *ret;
+
+        member_id_list = rd_list_new(member_cnt, rd_free);
+        assignment_list =
+            rd_list_new(member_cnt, rd_kafka_topic_partition_list_destroy_free);
+        for (i = 0; i < member_cnt; i++) {
+                rd_list_add(member_id_list, rd_strdup(member_ids[i]));
+                rd_list_add(assignment_list,
+                            rd_kafka_topic_partition_list_copy(assignment[i]));
+        }
+
+        ret = rd_kafka_mock_cgrp_consumer_target_assignment_new0(
+            member_id_list, assignment_list);
+        rd_list_destroy(member_id_list);
+        rd_list_destroy(assignment_list);
+        return ret;
+}
+
+void rd_kafka_mock_cgrp_consumer_target_assignment_destroy(
+    rd_kafka_mock_cgrp_consumer_target_assignment_t *target_assignment) {
+        rd_list_destroy(target_assignment->member_ids);
+        rd_list_destroy(target_assignment->assignment);
+        rd_free(target_assignment);
+}
+
+/**
+ * @brief Sets next target assignment and member epoch for \p member
+ *        to a copy of partition list \p rktparlist,
+ *        filling its topic ids if not provided, using \p cgrp cluster topics.
+ *
+ * @param mcgrp The consumer group containing the member.
+ * @param member A consumer group member.
+ * @param target_member_epoch New member epoch.
+ * @param rktparlist Next target assignment.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_member_target_assignment_set(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    int target_member_epoch,
+    const rd_kafka_topic_partition_list_t *rktparlist) {
+        rd_kafka_topic_partition_t *rktpar;
+        if (member->target_assignment) {
+                rd_kafka_topic_partition_list_destroy(
+                    member->target_assignment);
+        }
+        member->target_member_epoch = target_member_epoch;
+        member->target_assignment =
+            rd_kafka_topic_partition_list_copy(rktparlist);
+
+        /* If not present, fill topic ids using names */
+        RD_KAFKA_TPLIST_FOREACH(rktpar, member->target_assignment) {
+                rd_kafka_Uuid_t topic_id =
+                    rd_kafka_topic_partition_get_topic_id(rktpar);
+                if (!rd_kafka_Uuid_cmp(topic_id, RD_KAFKA_UUID_ZERO)) {
+                        rd_kafka_mock_topic_t *mtopic =
+                            rd_kafka_mock_topic_find(mcgrp->cluster,
+                                                     rktpar->topic);
+                        if (mtopic)
+                                rd_kafka_topic_partition_set_topic_id(
+                                    rktpar, mtopic->id);
+                }
+        }
+}
+
+/**
+ * @brief Sets next target assignment for group \p mcgrp
+ *        to a copy of \p target_assignment partition lists.
+ *
+ * @param mcgrp The consumer group.
+ * @param target_assignment Target assignment for all members.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_target_assignment_set(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_target_assignment_t *target_assignment) {
+        int i = 0;
+        int32_t new_target_member_epoch;
+        const char *member_id;
+        rd_kafka_mock_cgrp_consumer_member_t *member;
+
+        mcgrp->group_epoch++;
+        new_target_member_epoch = mcgrp->group_epoch;
+        RD_LIST_FOREACH(member_id, target_assignment->member_ids, i) {
+                rd_kafkap_str_t *member_id_str =
+                    rd_kafkap_str_new(member_id, strlen(member_id));
+                rd_kafka_topic_partition_list_t *member_assignment =
+                    rd_list_elem(target_assignment->assignment, i);
+                member = rd_kafka_mock_cgrp_consumer_member_find(mcgrp,
+                                                                 member_id_str);
+                rd_kafkap_str_destroy(member_id_str);
+
+                if (!member)
+                        continue;
+
+                rd_kafka_mock_cgrp_consumer_member_target_assignment_set(
+                    mcgrp, member, new_target_member_epoch, member_assignment);
+        }
+}
+
+typedef RD_MAP_TYPE(const char *, rd_list_t *) map_str_list;
+typedef RD_MAP_TYPE(const char *, int *) map_str_int;
+
+/**
+ * @brief Calculate a simple range target assignment for the consumer group \p
+ * mcgrp. This isn't replicating any given broker assignor but is used
+ * when the test doesn't need a specific type of assignment.
+ *
+ * If the test needs it, instead of replicating same conditions with all the
+ * members, one can mock the assignment directly with
+ * `rd_kafka_mock_cgrp_consumer_target_assignment`.
+ */
+static rd_kafka_mock_cgrp_consumer_target_assignment_t *
+rd_kafka_mock_cgrp_consumer_target_assignment_calculate_range(
+    const rd_kafka_mock_cgrp_consumer_t *mcgrp) {
+        int i, *i_pointer;
+        const char *topic;
+        rd_list_t *members;
+        rd_kafka_mock_cgrp_consumer_member_t *member;
+        rd_kafka_mock_cluster_t *mcluster = mcgrp->cluster;
+        /* List of member ids (char *) */
+        rd_list_t *member_ids = rd_list_new(mcgrp->member_cnt, rd_free);
+        /* List of member assignment (rd_kafka_topic_partition_list_t *) */
+        rd_list_t *assignment = rd_list_new(
+            mcgrp->member_cnt, rd_kafka_topic_partition_list_destroy_free);
+        /* Map from topic name to list of members */
+        map_str_list topic_members =
+            RD_MAP_INITIALIZER(mcgrp->member_cnt, rd_map_str_cmp,
+                               rd_map_str_hash, NULL, rd_list_destroy_free);
+        /* Map from member id to index in the members and assignment lists. */
+        map_str_int member_idx = RD_MAP_INITIALIZER(
+            mcgrp->member_cnt, rd_map_str_cmp, rd_map_str_hash, NULL, rd_free);
+
+        i = 0;
+
+        /* First create a map with topics associated to the list of members
+         * and save the member idx in the `member_idx` map. */
+        TAILQ_FOREACH(member, &mcgrp->members, link) {
+                int j;
+                rd_list_add(member_ids, rd_strdup(member->id));
+                rd_list_add(assignment, rd_kafka_topic_partition_list_new(0));
+
+                RD_LIST_FOREACH(topic, member->subscribed_topics, j) {
+                        if (!RD_MAP_GET(&topic_members, topic)) {
+                                members = rd_list_new(0, NULL);
+                                RD_MAP_SET(&topic_members, topic, members);
+                        } else
+                                members = RD_MAP_GET(&topic_members, topic);
+                        rd_list_add(members, member);
+                }
+                i_pointer  = rd_calloc(1, sizeof(*i_pointer));
+                *i_pointer = i;
+                RD_MAP_SET(&member_idx, member->id, i_pointer);
+                i++;
+        }
+
+        /* For each topic to a range assignment and add the
+         * corresponding partitions to the assignment for that member.
+         * Finds the list index using the `member_idx` map. */
+        RD_MAP_FOREACH(topic, members, &topic_members) {
+                rd_kafka_Uuid_t topic_id;
+                rd_kafka_topic_partition_list_t *member_assignment;
+                int members_cnt = rd_list_cnt(members);
+                int common, one_more, assigned = 0;
+                rd_kafkap_str_t Topic = {.str = topic, .len = strlen(topic)};
+                rd_kafka_mock_topic_t *mock_topic =
+                    rd_kafka_mock_topic_find_by_kstr(mcluster, &Topic);
+                if (!mock_topic)
+                        continue;
+
+                topic_id = mock_topic->id;
+
+                /* Assign one partition more
+                 * to the first mock_topic->partition_cnt % members_cnt
+                 * members. */
+                common   = mock_topic->partition_cnt / members_cnt;
+                one_more = mock_topic->partition_cnt % members_cnt;
+
+                RD_LIST_FOREACH(member, members, i) {
+                        int j, num_partitions = common;
+                        int idx = *RD_MAP_GET(&member_idx, member->id);
+                        member_assignment = rd_list_elem(assignment, idx);
+                        if (idx < one_more)
+                                num_partitions++;
+                        for (j = 0; j < num_partitions; j++) {
+                                rd_kafka_topic_partition_t *rktpar =
+                                    rd_kafka_topic_partition_list_add(
+                                        member_assignment, topic, assigned + j);
+                                rd_kafka_topic_partition_set_topic_id(rktpar,
+                                                                      topic_id);
+                        }
+                        assigned += num_partitions;
+                }
+        }
+
+        rd_kafka_mock_cgrp_consumer_target_assignment_t *ret =
+            rd_kafka_mock_cgrp_consumer_target_assignment_new0(member_ids,
+                                                               assignment);
+
+        RD_MAP_DESTROY(&topic_members);
+        RD_MAP_DESTROY(&member_idx);
+
+        rd_list_destroy(member_ids);
+        rd_list_destroy(assignment);
+
+        return ret;
+}
+
+/**
+ * @brief Recalculate and set a target assignment for \p mcgrp
+ *        only if `mcgrp->manual_assignment` isn't set.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_target_assignment_recalculate(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp) {
+        if (mcgrp->manual_assignment)
+                return;
+
+        rd_kafka_mock_cgrp_consumer_target_assignment_t *target_assignment =
+            rd_kafka_mock_cgrp_consumer_target_assignment_calculate_range(
+                mcgrp);
+        rd_kafka_mock_cgrp_consumer_target_assignment_set(mcgrp,
+                                                          target_assignment);
+        rd_kafka_mock_cgrp_consumer_target_assignment_destroy(
+            target_assignment);
+}
+
+/**
+ * @brief Set manual target assignment \p target_assignment
+ *        to the consumer group \p mcgrp .
+ *
+ * @param mcgrp Consumer group
+ * @param target_assignment Target assignment to set.
+ *                          Pass NULL to return to automatic assignment.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_target_assignment_set_manual(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_target_assignment_t *target_assignment) {
+        if (!target_assignment) {
+                mcgrp->manual_assignment = rd_false;
+                rd_kafka_mock_cgrp_consumer_target_assignment_recalculate(
+                    mcgrp);
+                return;
+        }
+
+        mcgrp->manual_assignment = rd_true;
+
+        rd_kafka_mock_cgrp_consumer_target_assignment_set(mcgrp,
+                                                          target_assignment);
+}
+
+/**
+ * @brief Sets \p member current assignment to a copy of
+ *        \p current_assignment.
+ *
+ * @param member A consumer group member.
+ * @param current_assignment Current assignment to set.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_member_current_assignment_set(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    const rd_kafka_topic_partition_list_t *current_assignment) {
+        if (member->current_assignment) {
+                rd_kafka_topic_partition_list_destroy(
+                    member->current_assignment);
+        }
+
+        member->current_assignment =
+            current_assignment
+                ? rd_kafka_topic_partition_list_copy(current_assignment)
+                : NULL;
+}
+
+/**
+ * @brief Sets \p member returned assignment to a
+ *        copy of \p returned_assignment.
+ *
+ * @param member A consumer group member.
+ * @param returned_assignment Returned assignment to set.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_member_returned_assignment_set(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    const rd_kafka_topic_partition_list_t *returned_assignment) {
+        if (member->returned_assignment) {
+                rd_kafka_topic_partition_list_destroy(
+                    member->returned_assignment);
+        }
+        member->returned_assignment =
+            returned_assignment
+                ? rd_kafka_topic_partition_list_copy(returned_assignment)
+                : NULL;
+}
+
+/**
+ * @brief Returns a copy of \p member target assignment containing only
+ * partitions that can be assignment, whose topic id is non-zero.
+ *
+ * @param member The group member.
+ *
+ * @remark The returned pointer ownership is transferred to the caller.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static rd_kafka_topic_partition_list_t *
+rd_kafka_mock_cgrp_consumer_member_target_assignment_assignable(
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+        rd_kafka_topic_partition_list_t *assignment = member->target_assignment;
+        rd_kafka_topic_partition_t *rktpar;
+        rd_kafka_topic_partition_list_t *ret =
+            rd_kafka_topic_partition_list_new(assignment->cnt);
+
+        RD_KAFKA_TPLIST_FOREACH(rktpar, assignment) {
+                rd_kafka_Uuid_t topic_id =
+                    rd_kafka_topic_partition_get_topic_id(rktpar);
+                if (rd_kafka_Uuid_cmp(topic_id, RD_KAFKA_UUID_ZERO)) {
+                        rd_kafka_topic_partition_list_add_copy(ret, rktpar);
+                }
+        }
+
+        return ret;
+}
+
+/**
+ * Returns true iff \p new_assignment doesn't have any intersection with any
+ * other member current assignment.
+ *
+ * If there's an intersection, it means we cannot bump the epoch at the moment,
+ * because some of these partitions are held by a different member. They have
+ * to be revoked from that member before it's possible to increase the epoch
+ * and assign additional partitions to this member.
+ */
+rd_bool_t rd_kafka_mock_cgrp_consumer_member_next_assignment_can_bump_epoch(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    rd_kafka_topic_partition_list_t *new_assignment) {
+        rd_kafka_topic_partition_list_t *double_assignment,
+            *assigned_partitions = rd_kafka_topic_partition_list_new(0);
+        rd_kafka_mock_cgrp_consumer_member_t *other_member;
+        rd_kafka_mock_cgrp_consumer_t *mcgrp = member->mcgrp;
+        rd_bool_t ret;
+
+        TAILQ_FOREACH(other_member, &mcgrp->members, link) {
+                int other_current_assignment_cnt  = 0,
+                    other_returned_assignment_cnt = 0;
+                if (member == other_member)
+                        continue;
+                if (other_member->current_assignment)
+                        other_current_assignment_cnt =
+                            other_member->current_assignment->cnt;
+                if (other_member->returned_assignment)
+                        other_returned_assignment_cnt =
+                            other_member->returned_assignment->cnt;
+
+                if (other_current_assignment_cnt > 0 &&
+                    other_current_assignment_cnt >
+                        other_returned_assignment_cnt) {
+                        /* This is the case where we're revoking
+                         * some partitions.
+                         * returned_assignment < current_assignment. */
+                        rd_kafka_topic_partition_list_add_list(
+                            assigned_partitions,
+                            other_member->current_assignment);
+                } else if (other_returned_assignment_cnt > 0) {
+                        /* This is the case where we're assigning
+                         * some partitions.
+                         * returned_assignment >= current_assignment. */
+                        rd_kafka_topic_partition_list_add_list(
+                            assigned_partitions,
+                            other_member->returned_assignment);
+                }
+        }
+        double_assignment = rd_kafka_topic_partition_list_intersection_by_id(
+            new_assignment, assigned_partitions);
+        ret = double_assignment->cnt == 0;
+
+        rd_kafka_topic_partition_list_destroy(assigned_partitions);
+        rd_kafka_topic_partition_list_destroy(double_assignment);
+        return ret;
+}
+
+/**
+ * @brief Calculates if \p member,
+ *        needs a revocation, that is if its current assignment
+ *        isn't a subset of its target assignment.
+ *        In case it needs a revocation, it returns
+ *        the intersection between the two assignments,
+ *        that is the remaining partitions after revocation
+ *        of those not included in target assignment.
+ *
+ * @param member The group member.
+ *
+ * @return The remaining set of partitions, or NULL in case no revocation
+ *         is needed.
+ *
+ * @remark The returned pointer ownership is transferred to the caller.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static rd_kafka_topic_partition_list_t *
+rd_kafka_mock_cgrp_consumer_member_needs_revocation(
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+        rd_kafka_topic_partition_list_t *intersection;
+        rd_bool_t needs_revocation;
+
+        if (member->current_assignment)
+                /* If we have a current assignment we
+                 * calculate the intersection with
+                 * target assignment. */
+                intersection = rd_kafka_topic_partition_list_intersection_by_id(
+                    member->current_assignment, member->target_assignment);
+        else
+                /* Otherwise intersection is empty. */
+                intersection = rd_kafka_topic_partition_list_new(0);
+
+        needs_revocation = member->current_assignment &&
+                           intersection->cnt < member->current_assignment->cnt;
+        if (needs_revocation) {
+                return intersection;
+        }
+
+        rd_kafka_topic_partition_list_destroy(intersection);
+        return NULL;
+}
+
+/**
+ * @brief Calculates if \p member,
+ *        can receive new partitions, given revocation is completed.
+ *        In case new partitions aren't held by other members it
+ *        returns the assignable target assignment and bumps current
+ *        member epoch, otherwise it returns NULL and
+ *        doesn't change current member epoch.
+ *
+ * @param member The group member.
+ *
+ * @return The assignable set of partitions, or NULL in case new partitions
+ *         cannot be assigned yet.
+ *
+ * @remark The returned pointer ownership is transferred to the caller.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static rd_kafka_topic_partition_list_t *
+rd_kafka_mock_cgrp_consumer_member_needs_assignment(
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+        rd_kafka_topic_partition_list_t *returned_assignment =
+            rd_kafka_mock_cgrp_consumer_member_target_assignment_assignable(
+                member);
+
+        if (!rd_kafka_mock_cgrp_consumer_member_next_assignment_can_bump_epoch(
+                member, returned_assignment)) {
+                /* We can't bump the epoch still,
+                 * there are some partitions held by other members.
+                 * We have to return NULL. */
+                rd_kafka_topic_partition_list_destroy(returned_assignment);
+                return NULL;
+        }
+
+        /* No partitions to remove, return
+         * target assignment and reconcile the
+         * epochs */
+        member->current_member_epoch = member->target_member_epoch;
+        return returned_assignment;
+}
+
+/**
+ * @brief Calculates next assignment and member epoch for a \p member,
+ *        given \p current_assignment.
+ *
+ * @param member The group member.
+ * @param current_assignment The assignment sent by the member, or NULL if it
+ *                           didn't change. Must be NULL if *member_epoch is 0.
+ * @param member_epoch Pointer to client reported member epoch. Can be updated.
+ *
+ * @return The new assignment to return to the member.
+ *
+ * @remark The returned pointer ownership is transferred to the caller.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+rd_kafka_topic_partition_list_t *
+rd_kafka_mock_cgrp_consumer_member_next_assignment(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    rd_kafka_topic_partition_list_t *current_assignment,
+    int *member_epoch) {
+        rd_kafka_topic_partition_list_t *assignment_to_return = NULL;
+
+        if (current_assignment) {
+                /* Update current assignment to reflect what is provided
+                 * by the client. */
+                rd_kafka_mock_cgrp_consumer_member_current_assignment_set(
+                    member, current_assignment);
+        }
+
+        if (*member_epoch > 0 &&
+            member->current_member_epoch != *member_epoch) {
+                /* Member epoch is different from the one we expect,
+                 * that means we have to fence the member. */
+                *member_epoch = -1; /* FENCED_MEMBER_EPOCH */
+                return NULL;
+        }
+
+        if (member->target_assignment) {
+                /* We have a target assignment,
+                 * let's check if we can assign it. */
+
+                if (*member_epoch != member->current_member_epoch ||
+                    member->current_member_epoch !=
+                        member->target_member_epoch) {
+                        /* Epochs are different, that means we have to bump the
+                         * epoch immediately or do some revocations
+                         * before that. */
+
+                        assignment_to_return =
+                            rd_kafka_mock_cgrp_consumer_member_needs_revocation(
+                                member);
+                        if (!assignment_to_return) {
+                                /* After revocation we only have to
+                                 * add new partitions.
+                                 * In case these new partitions are held
+                                 * by other members we still cannot do it. */
+                                assignment_to_return =
+                                    rd_kafka_mock_cgrp_consumer_member_needs_assignment(
+                                        member);
+                        }
+                } else if (!member->returned_assignment) {
+                        /* If all the epochs are the same, the only case
+                         * where we have to return the assignment is
+                         * after a disconnection, when returned_assignment has
+                         * been reset to NULL. */
+                        assignment_to_return =
+                            rd_kafka_mock_cgrp_consumer_member_target_assignment_assignable(
+                                member);
+                }
+        }
+
+        *member_epoch = member->current_member_epoch;
+        if (assignment_to_return) {
+                /* Compare assignment_to_return with last returned_assignment.
+                 * If equal, return NULL, otherwise return assignment_to_return
+                 * and update last returned_assignment. */
+                rd_bool_t same_returned_assignment =
+                    member->returned_assignment &&
+                    !rd_kafka_topic_partition_list_cmp(
+                        member->returned_assignment, assignment_to_return,
+                        rd_kafka_topic_partition_by_id_cmp);
+
+                if (same_returned_assignment) {
+                        /* Returned assignment is the same as previous
+                         * one, we return NULL instead to show no change. */
+                        rd_kafka_topic_partition_list_destroy(
+                            assignment_to_return);
+                        assignment_to_return = NULL;
+                } else {
+                        /* We store returned assignment
+                         * for later comparison. */
+                        rd_kafka_mock_cgrp_consumer_member_returned_assignment_set(
+                            member, assignment_to_return);
+                }
+        }
+        return assignment_to_return;
+}
+
+/**
+ * @brief Mark member as active (restart session timer).
+ *
+ * @param mcgrp Member's consumer group.
+ * @param member Member to set as active.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+void rd_kafka_mock_cgrp_consumer_member_active(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+        rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
+                     "Marking mock consumer group member %s as active",
+                     member->id);
+        member->ts_last_activity = rd_clock();
+}
+
+/**
+ * @brief Finds a member in consumer group \p mcgrp by \p MemberId.
+ *
+ * @param mcgrp Consumer group to search.
+ * @param MemberId Member id to look for.
+ * @return Found member or NULL.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+rd_kafka_mock_cgrp_consumer_member_t *rd_kafka_mock_cgrp_consumer_member_find(
+    const rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    const rd_kafkap_str_t *MemberId) {
+        const rd_kafka_mock_cgrp_consumer_member_t *member;
+        TAILQ_FOREACH(member, &mcgrp->members, link) {
+                if (!rd_kafkap_str_cmp_str(MemberId, member->id))
+                        return (rd_kafka_mock_cgrp_consumer_member_t *)member;
+        }
+
+        return NULL;
+}
+
+/**
+ * @brief Finds a member in consumer group \p mcgrp by \p InstanceId.
+ *
+ * @param mcgrp Consumer group to search.
+ * @param InstanceId Instance id to look for.
+ * @return Found member or NULL.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+rd_kafka_mock_cgrp_consumer_member_t *
+rd_kafka_mock_cgrp_consumer_member_find_by_instance_id(
+    const rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    const rd_kafkap_str_t *InstanceId) {
+        if (RD_KAFKAP_STR_IS_NULL(InstanceId))
+                return NULL;
+
+        const rd_kafka_mock_cgrp_consumer_member_t *member;
+        TAILQ_FOREACH(member, &mcgrp->members, link) {
+                if (!member->instance_id)
+                        continue;
+
+                if (!rd_kafkap_str_cmp_str(InstanceId, member->instance_id))
+                        return (rd_kafka_mock_cgrp_consumer_member_t *)member;
+        }
+
+        return NULL;
+}
+
+static void validate_subscription(const rd_kafkap_str_t *SubscribedTopicNames,
+                                  int32_t SubscribedTopicNamesCnt,
+                                  const rd_kafkap_str_t *SubscribedTopicRegex) {
+        /* Either they are both NULL
+         * or both non-NULL. */
+        rd_assert((SubscribedTopicNames == NULL) ==
+                  RD_KAFKAP_STR_IS_NULL(SubscribedTopicRegex));
+        /* If they're not NULL at least one should be non-empty */
+        rd_assert(SubscribedTopicNames == NULL || SubscribedTopicNamesCnt > 0 ||
+                  RD_KAFKAP_STR_LEN(SubscribedTopicRegex) > 0);
+}
+
+/**
+ * @brief Set the subscribed topics for the member \p member based on \p
+ * SubscribedTopicNames and \p SubscribedTopicRegex. Deduplicates the list after
+ * sorting it.
+ * @return `rd_true` if the subscription was changed, that happens
+ *         if it's set and different from previous one.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static rd_bool_t rd_kafka_mock_cgrp_consumer_member_subscribed_topic_names_set(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    rd_kafkap_str_t *SubscribedTopicNames,
+    int32_t SubscribedTopicNamesCnt,
+    const rd_kafkap_str_t *SubscribedTopicRegex) {
+        rd_bool_t changed = rd_false;
+        rd_list_t *new_subscription;
+        int32_t i;
+
+        validate_subscription(SubscribedTopicNames, SubscribedTopicNamesCnt,
+                              SubscribedTopicRegex);
+
+        if (!SubscribedTopicNames &&
+            RD_KAFKAP_STR_IS_NULL(SubscribedTopicRegex) &&
+            !member->subscribed_topic_regex) {
+                /* When client is sending NULL for SubscribedTopicNames and
+                 * SubscribedTopicRegex, its subscription didn't change. If we
+                 * already had a regex, we need to compute the regex again. */
+                return changed;
+        }
+
+        if (SubscribedTopicNames) {
+                RD_IF_FREE(member->subscribed_topic_names, rd_list_destroy);
+                member->subscribed_topic_names =
+                    rd_list_new(SubscribedTopicNamesCnt, rd_free);
+                for (i = 0; i < SubscribedTopicNamesCnt; i++) {
+                        rd_list_add(
+                            member->subscribed_topic_names,
+                            RD_KAFKAP_STR_DUP(&SubscribedTopicNames[i]));
+                }
+        }
+
+        if (!RD_KAFKAP_STR_IS_NULL(SubscribedTopicRegex)) {
+                RD_IF_FREE(member->subscribed_topic_regex, rd_free);
+                member->subscribed_topic_regex =
+                    RD_KAFKAP_STR_DUP(SubscribedTopicRegex);
+        }
+
+        new_subscription =
+            rd_list_new(rd_list_cnt(member->subscribed_topic_names), rd_free);
+
+        rd_list_copy_to(new_subscription, member->subscribed_topic_names,
+                        rd_list_string_copy, NULL);
+
+        if (member->subscribed_topic_regex[0]) {
+                rd_kafka_mock_cluster_t *mcluster = member->mcgrp->cluster;
+                rd_kafka_mock_topic_t *mtopic;
+                char errstr[1];
+                rd_regex_t *re = rd_regex_comp(member->subscribed_topic_regex,
+                                               errstr, sizeof(errstr));
+
+                TAILQ_FOREACH(mtopic, &mcluster->topics, link) {
+                        if (rd_regex_exec(re, mtopic->name))
+                                rd_list_add(new_subscription,
+                                            rd_strdup(mtopic->name));
+                }
+
+                rd_regex_destroy(re);
+        }
+
+        rd_list_deduplicate(&new_subscription, rd_strcmp2);
+
+        if (!member->subscribed_topics ||
+            rd_list_cmp(new_subscription, member->subscribed_topics,
+                        rd_list_cmp_str)) {
+                if (member->subscribed_topics)
+                        rd_list_destroy(member->subscribed_topics);
+                member->subscribed_topics =
+                    rd_list_copy(new_subscription, rd_list_string_copy, NULL);
+                changed = rd_true;
+        }
+        rd_list_destroy(new_subscription);
+        return changed;
+}
+
+static void rd_kafka_mock_cgrp_consumer_member_topic_id_set(
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    const rd_kafkap_str_t *MemberId) {
+        /* KIP 1082: MemberId is generated by the client */
+        rd_assert(RD_KAFKAP_STR_LEN(MemberId) > 0);
+        RD_IF_FREE(member->id, rd_free);
+        member->id = RD_KAFKAP_STR_DUP(MemberId);
+}
+
+/**
+ * @brief Adds a member to consumer group \p mcgrp. If member with same
+ *        \p MemberId is already present, only updates the connection and
+ *        sets it as active.
+ *
+ * @param mcgrp Consumer group to add the member to.
+ * @param conn Member connection.
+ * @param MemberId Member id.
+ * @param InstanceId Group instance id (optional).
+ * @param session_timeout_ms Session timeout to use.
+ * @param SubscribedTopicNames Array of subscribed topics.
+ *                             Mandatory if the member is a new one.
+ * @param SubscribedTopicNamesCnt Number of elements in \p SubscribedTopicNames.
+ * @param SubscribedTopicRegex Subscribed topic regex.
+ *
+ * @return New or existing member, NULL if the member cannot be added.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+rd_kafka_mock_cgrp_consumer_member_t *rd_kafka_mock_cgrp_consumer_member_add(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    struct rd_kafka_mock_connection_s *conn,
+    const rd_kafkap_str_t *MemberId,
+    const rd_kafkap_str_t *InstanceId,
+    rd_kafkap_str_t *SubscribedTopicNames,
+    int32_t SubscribedTopicNamesCnt,
+    const rd_kafkap_str_t *SubscribedTopicRegex) {
+        rd_kafka_mock_cgrp_consumer_member_t *member = NULL;
+        rd_bool_t changed                            = rd_false;
+
+        /* Find member */
+        member = rd_kafka_mock_cgrp_consumer_member_find(mcgrp, MemberId);
+        if (!member) {
+                member = rd_kafka_mock_cgrp_consumer_member_find_by_instance_id(
+                    mcgrp, InstanceId);
+
+                if (member) {
+                        if (!member->left_static_membership) {
+                                /* Old member still active,
+                                 * fence this one */
+                                return NULL;
+                        }
+
+                        if (rd_kafkap_str_cmp_str(MemberId, member->id) != 0) {
+                                /* Member is a new instance and is rejoining
+                                 * with a new MemberId. */
+                                rd_kafka_mock_cgrp_consumer_member_topic_id_set(
+                                    member, MemberId);
+                        }
+                        member->left_static_membership = rd_false;
+                }
+        } else {
+                member->left_static_membership = rd_false;
+        }
+
+        if (!member) {
+                validate_subscription(SubscribedTopicNames,
+                                      SubscribedTopicNamesCnt,
+                                      SubscribedTopicRegex);
+
+                /* In case of session timeout
+                 * where the member isn't aware it's been fenced. */
+                if (SubscribedTopicNames == NULL)
+                        return NULL;
+
+                /* Not found, add member */
+                member        = rd_calloc(1, sizeof(*member));
+                member->mcgrp = mcgrp;
+
+                rd_kafka_mock_cgrp_consumer_member_topic_id_set(member,
+                                                                MemberId);
+
+                if (!RD_KAFKAP_STR_IS_NULL(InstanceId))
+                        member->instance_id = RD_KAFKAP_STR_DUP(InstanceId);
+
+                TAILQ_INSERT_TAIL(&mcgrp->members, member, link);
+                mcgrp->member_cnt++;
+                changed                     = rd_true;
+                member->target_member_epoch = mcgrp->group_epoch;
+        }
+
+        changed |=
+            rd_kafka_mock_cgrp_consumer_member_subscribed_topic_names_set(
+                member, SubscribedTopicNames, SubscribedTopicNamesCnt,
+                SubscribedTopicRegex);
+
+        mcgrp->session_timeout_ms =
+            mcgrp->cluster->defaults.group_consumer_session_timeout_ms;
+        mcgrp->heartbeat_interval_ms =
+            mcgrp->cluster->defaults.group_consumer_heartbeat_interval_ms;
+
+        member->conn = conn;
+
+        rd_kafka_mock_cgrp_consumer_member_active(mcgrp, member);
+
+        if (changed)
+                rd_kafka_mock_cgrp_consumer_target_assignment_recalculate(
+                    mcgrp);
+
+        return member;
+}
+
+/**
+ * @brief Destroys a consumer group member, removing from its consumer group.
+ *
+ * @param mcgrp Member consumer group.
+ * @param member Member to destroy.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+static void rd_kafka_mock_cgrp_consumer_member_destroy(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+        rd_assert(mcgrp->member_cnt > 0);
+        TAILQ_REMOVE(&mcgrp->members, member, link);
+        mcgrp->member_cnt--;
+
+        rd_kafka_mock_cgrp_consumer_target_assignment_recalculate(mcgrp);
+
+        rd_free(member->id);
+
+        if (member->instance_id)
+                rd_free(member->instance_id);
+
+        RD_IF_FREE(member->target_assignment,
+                   rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(member->current_assignment,
+                   rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(member->returned_assignment,
+                   rd_kafka_topic_partition_list_destroy);
+        RD_IF_FREE(member->subscribed_topics, rd_list_destroy_free);
+
+        RD_IF_FREE(member->subscribed_topic_names, rd_list_destroy_free);
+
+        RD_IF_FREE(member->subscribed_topic_regex, rd_free);
+
+        rd_free(member);
+}
+
+static void rd_kafka_mock_cgrp_consumer_member_leave_static(
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+        member->left_static_membership = rd_true;
+        rd_kafka_mock_cgrp_consumer_member_returned_assignment_set(member,
+                                                                   NULL);
+}
+
+
+/**
+ * @brief Called when a member must leave a consumer group.
+ *
+ * @param mcgrp Consumer group to leave.
+ * @param member Member that leaves.
+ * @param leave_static If true, the member is leaving with static group
+ * membership.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+void rd_kafka_mock_cgrp_consumer_member_leave(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member,
+    rd_bool_t leave_static) {
+        rd_bool_t is_static = member->instance_id != NULL;
+
+        rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
+                     "Member %s is leaving group %s, is static: %s, "
+                     "static leave: %s",
+                     member->id, mcgrp->id, RD_STR_ToF(is_static),
+                     RD_STR_ToF(leave_static));
+        if (!is_static || !leave_static)
+                rd_kafka_mock_cgrp_consumer_member_destroy(mcgrp, member);
+        else
+                rd_kafka_mock_cgrp_consumer_member_leave_static(member);
+}
+
+/**
+ * @brief Called when a member is fenced from a consumer group.
+ *
+ * @param mcgrp Consumer group.
+ * @param member Member to fence.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+void rd_kafka_mock_cgrp_consumer_member_fenced(
+    rd_kafka_mock_cgrp_consumer_t *mcgrp,
+    rd_kafka_mock_cgrp_consumer_member_t *member) {
+
+        rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
+                     "Member %s is fenced from group %s", member->id,
+                     mcgrp->id);
+
+        rd_kafka_mock_cgrp_consumer_member_destroy(mcgrp, member);
+}
+
+/**
+ * @brief Find a consumer group in cluster \p mcluster by \p GroupId.
+ *
+ * @param mcluster Cluster to search in.
+ * @param GroupId Group id to search.
+ * @return Found group or NULL.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+rd_kafka_mock_cgrp_consumer_t *
+rd_kafka_mock_cgrp_consumer_find(const rd_kafka_mock_cluster_t *mcluster,
+                                 const rd_kafkap_str_t *GroupId) {
+        rd_kafka_mock_cgrp_consumer_t *mcgrp;
+        TAILQ_FOREACH(mcgrp, &mcluster->cgrps_consumer, link) {
+                if (!rd_kafkap_str_cmp_str(GroupId, mcgrp->id))
+                        return mcgrp;
+        }
+
+        return NULL;
+}
+
+/**
+ * @brief Check if any members have exceeded the session timeout.
+ *
+ * @param rkts Timers.
+ * @param arg Consumer group.
+ *
+ * @locks mcluster->lock is acquired and released.
+ */
+static void rd_kafka_mock_cgrp_consumer_session_tmr_cb(rd_kafka_timers_t *rkts,
+                                                       void *arg) {
+        rd_kafka_mock_cgrp_consumer_t *mcgrp = arg;
+        rd_kafka_mock_cgrp_consumer_member_t *member, *tmp;
+        rd_ts_t now                       = rd_clock();
+        rd_kafka_mock_cluster_t *mcluster = mcgrp->cluster;
+
+        mtx_unlock(&mcluster->lock);
+        TAILQ_FOREACH_SAFE(member, &mcgrp->members, link, tmp) {
+                if (member->ts_last_activity +
+                        (mcgrp->session_timeout_ms * 1000) >
+                    now)
+                        continue;
+
+                rd_kafka_dbg(mcgrp->cluster->rk, MOCK, "MOCK",
+                             "Member %s session timed out for group %s",
+                             member->id, mcgrp->id);
+
+                rd_kafka_mock_cgrp_consumer_member_fenced(mcgrp, member);
+        }
+        mtx_unlock(&mcluster->lock);
+}
+
+
+/**
+ * @brief Find or create a "consumer" consumer group.
+ *
+ * @param mcluster Cluster to search in.
+ * @param GroupId Group id to look for.
+ * @return Found or new consumer group.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+rd_kafka_mock_cgrp_consumer_t *
+rd_kafka_mock_cgrp_consumer_get(rd_kafka_mock_cluster_t *mcluster,
+                                const rd_kafkap_str_t *GroupId) {
+        rd_kafka_mock_cgrp_consumer_t *mcgrp;
+
+        mcgrp = rd_kafka_mock_cgrp_consumer_find(mcluster, GroupId);
+        if (mcgrp)
+                return mcgrp;
+
+        mcgrp              = rd_calloc(1, sizeof(*mcgrp));
+        mcgrp->cluster     = mcluster;
+        mcgrp->id          = RD_KAFKAP_STR_DUP(GroupId);
+        mcgrp->group_epoch = 1;
+        TAILQ_INIT(&mcgrp->members);
+        rd_kafka_timer_start(&mcluster->timers, &mcgrp->session_tmr,
+                             1000 * 1000 /*1s*/,
+                             rd_kafka_mock_cgrp_consumer_session_tmr_cb, mcgrp);
+
+        TAILQ_INSERT_TAIL(&mcluster->cgrps_consumer, mcgrp, link);
+
+        return mcgrp;
+}
+
+
+void rd_kafka_mock_cgrp_consumer_target_assignment(
+    rd_kafka_mock_cluster_t *mcluster,
+    const char *group_id,
+    rd_kafka_mock_cgrp_consumer_target_assignment_t *target_assignment) {
+        rd_kafka_mock_cgrp_consumer_t *mcgrp;
+        rd_kafkap_str_t *group_id_str =
+            rd_kafkap_str_new(group_id, strlen(group_id));
+
+        mtx_lock(&mcluster->lock);
+
+        mcgrp = rd_kafka_mock_cgrp_consumer_find(mcluster, group_id_str);
+        if (!mcgrp)
+                goto destroy;
+
+        rd_kafka_mock_cgrp_consumer_target_assignment_set_manual(
+            mcgrp, target_assignment);
+
+destroy:
+        rd_kafkap_str_destroy(group_id_str);
+        mtx_unlock(&mcluster->lock);
+}
+
+void rd_kafka_mock_set_group_consumer_session_timeout_ms(
+    rd_kafka_mock_cluster_t *mcluster,
+    int group_consumer_session_timeout_ms) {
+        mtx_lock(&mcluster->lock);
+        mcluster->defaults.group_consumer_session_timeout_ms =
+            group_consumer_session_timeout_ms;
+        mtx_unlock(&mcluster->lock);
+}
+
+void rd_kafka_mock_set_group_consumer_heartbeat_interval_ms(
+    rd_kafka_mock_cluster_t *mcluster,
+    int group_consumer_heartbeat_interval_ms) {
+        mtx_lock(&mcluster->lock);
+        mcluster->defaults.group_consumer_heartbeat_interval_ms =
+            group_consumer_heartbeat_interval_ms;
+        mtx_unlock(&mcluster->lock);
+}
+
+/**
+ * @brief A client connection closed, check if any consumer cgrp has any state
+ *        for this connection that needs to be cleared.
+ *
+ * @param mcluster Cluster to search in.
+ * @param mconn Connection that was closed.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+void rd_kafka_mock_cgrps_consumer_connection_closed(
+    rd_kafka_mock_cluster_t *mcluster,
+    rd_kafka_mock_connection_t *mconn) {
+        rd_kafka_mock_cgrp_consumer_t *mcgrp;
+
+        TAILQ_FOREACH(mcgrp, &mcluster->cgrps_consumer, link) {
+                rd_kafka_mock_cgrp_consumer_member_t *member, *tmp;
+                TAILQ_FOREACH_SAFE(member, &mcgrp->members, link, tmp) {
+                        if (member->conn == mconn) {
+                                member->conn = NULL;
+                                rd_kafka_mock_cgrp_consumer_member_returned_assignment_set(
+                                    member, NULL);
+                                rd_kafka_mock_cgrp_consumer_member_current_assignment_set(
+                                    member, NULL);
+                        }
+                }
+        }
+}
+
+/**
+ * @brief Destroys consumer group \p mcgrp and all of its members.
+ *
+ * @param mcgrp Consumer group to destroy.
+ *
+ * @locks mcluster->lock MUST be held.
+ */
+void rd_kafka_mock_cgrp_consumer_destroy(rd_kafka_mock_cgrp_consumer_t *mcgrp) {
+        rd_kafka_mock_cgrp_consumer_member_t *member;
+
+        TAILQ_REMOVE(&mcgrp->cluster->cgrps_consumer, mcgrp, link);
+
+        rd_kafka_timer_stop(&mcgrp->cluster->timers, &mcgrp->session_tmr,
+                            rd_true);
+        rd_free(mcgrp->id);
+        while ((member = TAILQ_FIRST(&mcgrp->members)))
+                rd_kafka_mock_cgrp_consumer_member_destroy(mcgrp, member);
+        rd_free(mcgrp);
+}
+
+/**
+ * @brief A client connection closed, check if any cgrp has any state
+ *        for this connection that needs to be cleared.
+ *
+ * @param mcluster Mock cluster.
+ * @param mconn Connection that was closed.
+ */
+void rd_kafka_mock_cgrps_connection_closed(rd_kafka_mock_cluster_t *mcluster,
+                                           rd_kafka_mock_connection_t *mconn) {
+        rd_kafka_mock_cgrps_classic_connection_closed(mcluster, mconn);
+        rd_kafka_mock_cgrps_consumer_connection_closed(mcluster, mconn);
+}