refactor: Rename Queries to Query to align with other enums.

Also return count as uint32_t, not as peer number.

auto_tests/group_general_test.c

@@ -194,13 +194,13 @@ static void group_peer_self_join_handler(const Tox_Event_Group_Self_Join *event,
     ck_assert(tox_group_get_name_size(autotox->tox, groupnumber, nullptr) == GROUP_NAME_LEN);
     ck_assert(tox_group_get_topic_size(autotox->tox, groupnumber, nullptr) == TOPIC_LEN);
 
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
     tox_group_get_name(autotox->tox, groupnumber, group_name, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "%d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "%d", query_err);
     ck_assert(memcmp(group_name, GROUP_NAME, GROUP_NAME_LEN) == 0);
 
     tox_group_get_topic(autotox->tox, groupnumber, topic, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "%d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "%d", query_err);
     ck_assert(memcmp(topic, TOPIC, TOPIC_LEN) == 0);
 
     uint32_t peer_id = tox_group_self_get_peer_id(autotox->tox, groupnumber, nullptr);
@@ -307,10 +307,10 @@ static void group_announce_test(AutoTox *autotoxes)
     ck_assert(tp_err == TOX_ERR_GROUP_TOPIC_SET_OK);
 
     // get the chat id of the new group.
-    Tox_Err_Group_State_Queries err_id;
+    Tox_Err_Group_State_Query err_id;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
     tox_group_get_chat_id(tox0, groupnumber, chat_id, &err_id);
-    ck_assert(err_id == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err_id == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     // tox1 joins it.
     Tox_Err_Group_Join err_join;

auto_tests/group_invite_test.c

@@ -134,11 +134,11 @@ static void group_invite_test(AutoTox *autotoxes)
 
     iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL);
 
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
 
     tox_group_get_chat_id(tox0, groupnumber, chat_id, &id_err);
-    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "%d", id_err);
+    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERY_OK, "%d", id_err);
 
     // peer 1 joins public group with no password
     Tox_Err_Group_Join join_err;

auto_tests/group_moderation_test.c

@@ -382,13 +382,13 @@ static void voice_state_message_test(AutoTox *autotox, Tox_Group_Voice_State voi
 static bool all_peers_got_voice_state_change(AutoTox *autotoxes, uint32_t num_toxes,
         Tox_Group_Voice_State expected_voice_state)
 {
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
 
     for (uint32_t i = 0; i < num_toxes; ++i) {
         const State *state = (State *)autotoxes[i].state;
 
         Tox_Group_Voice_State voice_state = tox_group_get_voice_state(autotoxes[i].tox, state->group_number, &query_err);
-        ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+        ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
         if (voice_state != expected_voice_state) {
             return false;
@@ -472,11 +472,11 @@ static void group_moderation_test(AutoTox *autotoxes)
     ck_assert_msg(err_new == TOX_ERR_GROUP_NEW_OK, "Failed to create group. error: %d\n", err_new);
 
     /* Founder gets chat ID */
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
     tox_group_get_chat_id(tox0, state0->group_number, chat_id, &id_err);
 
-    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get chat ID. error: %d", id_err);
+    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get chat ID. error: %d", id_err);
 
     fprintf(stderr, "Peers attemping to join DHT group via the chat ID\n");
 

auto_tests/group_save_test.c

@@ -58,28 +58,28 @@ static void group_peer_join_handler(const Tox_Event_Group_Peer_Join *event, void
  */
 static int has_correct_group_state(const Tox *tox, uint32_t group_number, const uint8_t *expected_chat_id)
 {
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
 
     Tox_Group_Privacy_State priv_state = tox_group_get_privacy_state(tox, group_number, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     if (priv_state != NEW_PRIV_STATE) {
         return -1;
     }
 
     size_t pass_len = tox_group_get_password_size(tox, group_number, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     uint8_t password[TOX_GROUP_MAX_PASSWORD_SIZE];
     tox_group_get_password(tox, group_number, password, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     if (pass_len != PASS_LEN || memcmp(password, PASSWORD, pass_len) != 0) {
         return -2;
     }
 
     size_t gname_len = tox_group_get_name_size(tox, group_number, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     uint8_t group_name[TOX_GROUP_MAX_GROUP_NAME_LENGTH];
     tox_group_get_name(tox, group_number, group_name, &query_err);
@@ -93,17 +93,17 @@ static int has_correct_group_state(const Tox *tox, uint32_t group_number, const
     }
 
     Tox_Group_Topic_Lock topic_lock = tox_group_get_topic_lock(tox, group_number, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     if (topic_lock != TOX_GROUP_TOPIC_LOCK_DISABLED) {
         return -5;
     }
 
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
     tox_group_get_chat_id(tox, group_number, chat_id, &id_err);
 
-    ck_assert(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(id_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     if (memcmp(chat_id, expected_chat_id, TOX_GROUP_CHAT_ID_SIZE) != 0) {
         return -6;
@@ -174,9 +174,9 @@ static void group_save_test(AutoTox *autotoxes)
 
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
 
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     tox_group_get_chat_id(tox0, group_number, chat_id, &id_err);
-    ck_assert(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(id_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     uint8_t founder_pk[TOX_GROUP_PEER_PUBLIC_KEY_SIZE];
 

auto_tests/group_state_test.c

@@ -69,10 +69,10 @@ static void group_topic_lock_handler(const Tox_Event_Group_Topic_Lock *event,
     const uint32_t groupnumber = tox_event_group_topic_lock_get_group_number(event);
     const Tox_Group_Topic_Lock topic_lock = tox_event_group_topic_lock_get_topic_lock(event);
 
-    Tox_Err_Group_State_Queries err;
+    Tox_Err_Group_State_Query err;
     Tox_Group_Topic_Lock current_topic_lock = tox_group_get_topic_lock(autotox->tox, groupnumber, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(current_topic_lock == topic_lock, "topic locks don't match in callback: %d %d",
                   topic_lock, current_topic_lock);
 }
@@ -86,10 +86,10 @@ static void group_voice_state_handler(const Tox_Event_Group_Voice_State *event,
     const uint32_t groupnumber = tox_event_group_voice_state_get_group_number(event);
     const Tox_Group_Voice_State voice_state = tox_event_group_voice_state_get_voice_state(event);
 
-    Tox_Err_Group_State_Queries err;
+    Tox_Err_Group_State_Query err;
     Tox_Group_Voice_State current_voice_state = tox_group_get_voice_state(autotox->tox, groupnumber, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(current_voice_state == voice_state, "voice states don't match in callback: %d %d",
                   voice_state, current_voice_state);
 }
@@ -103,10 +103,10 @@ static void group_privacy_state_handler(const Tox_Event_Group_Privacy_State *eve
     const uint32_t groupnumber = tox_event_group_privacy_state_get_group_number(event);
     const Tox_Group_Privacy_State privacy_state = tox_event_group_privacy_state_get_privacy_state(event);
 
-    Tox_Err_Group_State_Queries err;
+    Tox_Err_Group_State_Query err;
     Tox_Group_Privacy_State current_pstate = tox_group_get_privacy_state(autotox->tox, groupnumber, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(current_pstate == privacy_state, "privacy states don't match in callback");
 }
 
@@ -118,10 +118,10 @@ static void group_peer_limit_handler(const Tox_Event_Group_Peer_Limit *event, vo
     const uint32_t groupnumber = tox_event_group_peer_limit_get_group_number(event);
     const uint32_t peer_limit = tox_event_group_peer_limit_get_peer_limit(event);
 
-    Tox_Err_Group_State_Queries err;
+    Tox_Err_Group_State_Query err;
     uint32_t current_plimit = tox_group_get_peer_limit(autotox->tox, groupnumber, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(peer_limit == current_plimit,
                   "Peer limits don't match in callback: %u, %u\n", peer_limit, current_plimit);
 }
@@ -136,16 +136,16 @@ static void group_password_handler(const Tox_Event_Group_Password *event,
     const uint8_t *password = tox_event_group_password_get_password(event);
     const size_t length = tox_event_group_password_get_password_length(event);
 
-    Tox_Err_Group_State_Queries err;
+    Tox_Err_Group_State_Query err;
     size_t curr_pwlength = tox_group_get_password_size(autotox->tox, groupnumber, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert(length == curr_pwlength);
 
     uint8_t current_password[TOX_GROUP_MAX_PASSWORD_SIZE];
     tox_group_get_password(autotox->tox, groupnumber, current_password, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(memcmp(current_password, password, length) == 0,
                   "Passwords don't match: %s, %s", password, current_password);
 }
@@ -168,24 +168,24 @@ static int check_group_state(const Tox *tox, uint32_t groupnumber, uint32_t peer
                              Tox_Group_Privacy_State priv_state, Tox_Group_Voice_State voice_state,
                              const uint8_t *password, size_t pass_len, Tox_Group_Topic_Lock topic_lock)
 {
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
 
     Tox_Group_Privacy_State my_priv_state = tox_group_get_privacy_state(tox, groupnumber, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get privacy state: %d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get privacy state: %d", query_err);
 
     if (my_priv_state != priv_state) {
         return -1;
     }
 
     uint32_t my_peer_limit = tox_group_get_peer_limit(tox, groupnumber, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get peer limit: %d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get peer limit: %d", query_err);
 
     if (my_peer_limit != peer_limit) {
         return -2;
     }
 
     size_t my_pass_len = tox_group_get_password_size(tox, groupnumber, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get password size: %d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get password size: %d", query_err);
 
     if (my_pass_len != pass_len) {
         return -5;
@@ -197,7 +197,7 @@ static int check_group_state(const Tox *tox, uint32_t groupnumber, uint32_t peer
         uint8_t my_pass[TOX_GROUP_MAX_PASSWORD_SIZE + 1];
         tox_group_get_password(tox, groupnumber, my_pass, &query_err);
         my_pass[my_pass_len] = 0;
-        ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get password: %d", query_err);
+        ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get password: %d", query_err);
 
         if (memcmp(my_pass, password, my_pass_len) != 0) {
             return -6;
@@ -206,7 +206,7 @@ static int check_group_state(const Tox *tox, uint32_t groupnumber, uint32_t peer
 
     /* Group name should never change */
     size_t my_gname_len = tox_group_get_name_size(tox, groupnumber, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get group name size: %d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get group name size: %d", query_err);
 
     if (my_gname_len != GROUP_NAME_LEN) {
         return -7;
@@ -223,14 +223,14 @@ static int check_group_state(const Tox *tox, uint32_t groupnumber, uint32_t peer
     }
 
     Tox_Group_Topic_Lock current_topic_lock = tox_group_get_topic_lock(tox, groupnumber, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get topic lock: %d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get topic lock: %d", query_err);
 
     if (current_topic_lock != topic_lock) {
         return -9;
     }
 
     Tox_Group_Voice_State current_voice_state = tox_group_get_voice_state(tox, groupnumber, &query_err);
-    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "Failed to get voice state: %d", query_err);
+    ck_assert_msg(query_err == TOX_ERR_GROUP_STATE_QUERY_OK, "Failed to get voice state: %d", query_err);
 
     if (current_voice_state != voice_state) {
         return -10;
@@ -294,11 +294,11 @@ static void group_state_test(AutoTox *autotoxes)
                     (const uint8_t *)PASSWORD, PASS_LEN, TOX_GROUP_TOPIC_LOCK_ENABLED);
 
     /* Founder gets the Chat ID and implicitly shares it publicly */
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
     tox_group_get_chat_id(tox0, groupnum, chat_id, &id_err);
 
-    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "tox_group_get_chat_id failed %d", id_err);
+    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERY_OK, "tox_group_get_chat_id failed %d", id_err);
 
     /* All other peers join the group using the Chat ID and password */
     for (size_t i = 1; i < NUM_GROUP_TOXES; ++i) {

auto_tests/group_sync_test.c

@@ -264,14 +264,14 @@ static bool all_peers_have_same_topic(const AutoTox *autotoxes, uint32_t num_pee
 {
     uint8_t expected_topic[TOX_GROUP_MAX_TOPIC_LENGTH];
 
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
     size_t expected_topic_length = tox_group_get_topic_size(autotoxes[0].tox, groupnumber, &query_err);
 
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     tox_group_get_topic(autotoxes[0].tox, groupnumber, expected_topic, &query_err);
 
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const State *state0 = (const State *)autotoxes[0].state;
 
@@ -286,7 +286,7 @@ static bool all_peers_have_same_topic(const AutoTox *autotoxes, uint32_t num_pee
     for (size_t i = 1; i < num_peers; ++i) {
         size_t topic_length = tox_group_get_topic_size(autotoxes[i].tox, groupnumber, &query_err);
 
-        ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+        ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
         if (topic_length != expected_topic_length) {
             return false;
@@ -295,7 +295,7 @@ static bool all_peers_have_same_topic(const AutoTox *autotoxes, uint32_t num_pee
         uint8_t topic[TOX_GROUP_MAX_TOPIC_LENGTH];
         tox_group_get_topic(autotoxes[i].tox, groupnumber, topic, &query_err);
 
-        ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+        ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
         if (memcmp(expected_topic, (const char *)topic, topic_length) != 0) {
             return false;
@@ -360,11 +360,11 @@ static void group_sync_test(AutoTox *autotoxes)
 
     fprintf(stderr, "tox0 creats new group and invites all his friends");
 
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
 
     tox_group_get_chat_id(tox0, groupnumber, chat_id, &id_err);
-    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "%d", id_err);
+    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERY_OK, "%d", id_err);
 
     for (size_t i = 1; i < NUM_GROUP_TOXES; ++i) {
         Tox_Err_Group_Join join_err;

auto_tests/group_tcp_test.c

@@ -160,11 +160,11 @@ static void group_tcp_test(AutoTox *autotoxes)
 
     iterate_group(autotoxes, NUM_GROUP_TOXES, GROUP_ITERATION_INTERVAL);
 
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
 
     tox_group_get_chat_id(autotoxes[0].tox, groupnumber, chat_id, &id_err);
-    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "%d", id_err);
+    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERY_OK, "%d", id_err);
 
     printf("Tox 0 created new group...\n");
 

auto_tests/group_topic_test.c

@@ -80,13 +80,13 @@ static void group_topic_handler(const Tox_Event_Group_Topic *event, void *user_d
 
     ck_assert(topic_length <= TOX_GROUP_MAX_TOPIC_LENGTH);
 
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
     uint8_t topic2[TOX_GROUP_MAX_TOPIC_LENGTH];
     tox_group_get_topic(autotox->tox, group_number, topic2, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
     size_t topic_length_getter = tox_group_get_topic_size(autotox->tox, group_number, &query_err);
-    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(topic_length_getter == topic_length && memcmp(topic, topic2, topic_length) == 0,
                   "topic differs in callback: %s, %s", topic, topic2);
 }
@@ -99,10 +99,10 @@ static void group_topic_lock_handler(const Tox_Event_Group_Topic_Lock *event, vo
     const uint32_t group_number = tox_event_group_topic_lock_get_group_number(event);
     const Tox_Group_Topic_Lock topic_lock = tox_event_group_topic_lock_get_topic_lock(event);
 
-    Tox_Err_Group_State_Queries err;
+    Tox_Err_Group_State_Query err;
     Tox_Group_Topic_Lock current_lock = tox_group_get_topic_lock(autotox->tox, group_number, &err);
 
-    ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+    ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
     ck_assert_msg(topic_lock == current_lock, "topic locks differ in callback");
 }
 
@@ -123,10 +123,10 @@ static bool set_topic(Tox *tox, uint32_t groupnumber, const char *topic, size_t
  */
 static int check_topic(const Tox *tox, uint32_t groupnumber, const char *expected_topic, size_t expected_length)
 {
-    Tox_Err_Group_State_Queries query_err;
+    Tox_Err_Group_State_Query query_err;
     size_t topic_length = tox_group_get_topic_size(tox, groupnumber, &query_err);
 
-    if (query_err != TOX_ERR_GROUP_STATE_QUERIES_OK) {
+    if (query_err != TOX_ERR_GROUP_STATE_QUERY_OK) {
         return -1;
     }
 
@@ -137,7 +137,7 @@ static int check_topic(const Tox *tox, uint32_t groupnumber, const char *expecte
     uint8_t topic[TOX_GROUP_MAX_TOPIC_LENGTH];
     tox_group_get_topic(tox, groupnumber, topic, &query_err);
 
-    if (query_err != TOX_ERR_GROUP_STATE_QUERIES_OK) {
+    if (query_err != TOX_ERR_GROUP_STATE_QUERY_OK) {
         return -3;
     }
 
@@ -156,9 +156,9 @@ static void wait_topic_lock(AutoTox *autotoxes, uint32_t groupnumber, Tox_Group_
         uint32_t count = 0;
 
         for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) {
-            Tox_Err_Group_State_Queries err;
+            Tox_Err_Group_State_Query err;
             Tox_Group_Topic_Lock topic_lock = tox_group_get_topic_lock(autotoxes[i].tox, groupnumber, &err);
-            ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK);
+            ck_assert(err == TOX_ERR_GROUP_STATE_QUERY_OK);
 
             if (topic_lock == expected_lock) {
                 ++count;
@@ -250,11 +250,11 @@ static void group_topic_test(AutoTox *autotoxes)
     ck_assert_msg(s_ret, "Founder failed to set topic");
 
     /* Founder gets the Chat ID and implicitly shares it publicly */
-    Tox_Err_Group_State_Queries id_err;
+    Tox_Err_Group_State_Query id_err;
     uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE];
     tox_group_get_chat_id(tox0, groupnumber, chat_id, &id_err);
 
-    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERIES_OK, "tox_group_get_chat_id failed %d", id_err);
+    ck_assert_msg(id_err == TOX_ERR_GROUP_STATE_QUERY_OK, "tox_group_get_chat_id failed %d", id_err);
 
     /* All other peers join the group using the Chat ID */
     for (size_t i = 1; i < NUM_GROUP_TOXES; ++i) {

toxcore/tox.c

@@ -3688,7 +3688,7 @@ bool tox_group_set_topic(Tox *tox, uint32_t group_number, const uint8_t *topic,
     return false;
 }
 
-size_t tox_group_get_topic_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error)
+size_t tox_group_get_topic_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3696,12 +3696,12 @@ size_t tox_group_get_topic_size(const Tox *tox, uint32_t group_number, Tox_Err_G
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return -1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const size_t ret = gc_get_topic_size(chat);
     tox_unlock(tox);
@@ -3709,7 +3709,7 @@ size_t tox_group_get_topic_size(const Tox *tox, uint32_t group_number, Tox_Err_G
     return ret;
 }
 
-bool tox_group_get_topic(const Tox *tox, uint32_t group_number, uint8_t *topic, Tox_Err_Group_State_Queries *error)
+bool tox_group_get_topic(const Tox *tox, uint32_t group_number, uint8_t *topic, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3717,7 +3717,7 @@ bool tox_group_get_topic(const Tox *tox, uint32_t group_number, uint8_t *topic,
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return false;
     }
@@ -3725,11 +3725,11 @@ bool tox_group_get_topic(const Tox *tox, uint32_t group_number, uint8_t *topic,
     gc_get_topic(chat, topic);
     tox_unlock(tox);
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
     return true;
 }
 
-size_t tox_group_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error)
+size_t tox_group_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3737,12 +3737,12 @@ size_t tox_group_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Gr
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return -1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const size_t ret = gc_get_group_name_size(chat);
     tox_unlock(tox);
@@ -3750,7 +3750,7 @@ size_t tox_group_get_name_size(const Tox *tox, uint32_t group_number, Tox_Err_Gr
     return ret;
 }
 
-bool tox_group_get_name(const Tox *tox, uint32_t group_number, uint8_t *name, Tox_Err_Group_State_Queries *error)
+bool tox_group_get_name(const Tox *tox, uint32_t group_number, uint8_t *name, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3758,7 +3758,7 @@ bool tox_group_get_name(const Tox *tox, uint32_t group_number, uint8_t *name, To
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return false;
     }
@@ -3766,12 +3766,12 @@ bool tox_group_get_name(const Tox *tox, uint32_t group_number, uint8_t *name, To
     gc_get_group_name(chat, name);
     tox_unlock(tox);
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     return true;
 }
 
-bool tox_group_get_chat_id(const Tox *tox, uint32_t group_number, uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE], Tox_Err_Group_State_Queries *error)
+bool tox_group_get_chat_id(const Tox *tox, uint32_t group_number, uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE], Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3779,12 +3779,12 @@ bool tox_group_get_chat_id(const Tox *tox, uint32_t group_number, uint8_t chat_i
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return false;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
     gc_get_chat_id(chat, chat_id);
     tox_unlock(tox);
 
@@ -3803,7 +3803,7 @@ uint32_t tox_group_get_number_groups(const Tox *tox)
 }
 
 Tox_Group_Privacy_State tox_group_get_privacy_state(const Tox *tox, uint32_t group_number,
-        Tox_Err_Group_State_Queries *error)
+        Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3811,12 +3811,12 @@ Tox_Group_Privacy_State tox_group_get_privacy_state(const Tox *tox, uint32_t gro
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return (Tox_Group_Privacy_State) - 1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const uint8_t state = gc_get_privacy_state(chat);
     tox_unlock(tox);
@@ -3824,7 +3824,7 @@ Tox_Group_Privacy_State tox_group_get_privacy_state(const Tox *tox, uint32_t gro
     return (Tox_Group_Privacy_State)state;
 }
 
-Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error)
+Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3832,12 +3832,12 @@ Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, uint32_t group_num
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return (Tox_Group_Topic_Lock) - 1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const Group_Topic_Lock topic_lock = gc_get_topic_lock_state(chat);
     tox_unlock(tox);
@@ -3846,7 +3846,7 @@ Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, uint32_t group_num
 }
 
 Tox_Group_Voice_State tox_group_get_voice_state(const Tox *tox, uint32_t group_number,
-        Tox_Err_Group_State_Queries *error)
+        Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3854,12 +3854,12 @@ Tox_Group_Voice_State tox_group_get_voice_state(const Tox *tox, uint32_t group_n
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return (Tox_Group_Voice_State) - 1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const Group_Voice_State voice_state = gc_get_voice_state(chat);
     tox_unlock(tox);
@@ -3867,7 +3867,7 @@ Tox_Group_Voice_State tox_group_get_voice_state(const Tox *tox, uint32_t group_n
     return (Tox_Group_Voice_State)voice_state;
 }
 
-uint16_t tox_group_get_peer_limit(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error)
+uint16_t tox_group_get_peer_limit(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3875,12 +3875,12 @@ uint16_t tox_group_get_peer_limit(const Tox *tox, uint32_t group_number, Tox_Err
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return -1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const uint16_t ret = gc_get_max_peers(chat);
     tox_unlock(tox);
@@ -3888,7 +3888,7 @@ uint16_t tox_group_get_peer_limit(const Tox *tox, uint32_t group_number, Tox_Err
     return ret;
 }
 
-size_t tox_group_get_password_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Queries *error)
+size_t tox_group_get_password_size(const Tox *tox, uint32_t group_number, Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3896,12 +3896,12 @@ size_t tox_group_get_password_size(const Tox *tox, uint32_t group_number, Tox_Er
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return -1;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     const size_t ret = gc_get_password_size(chat);
     tox_unlock(tox);
@@ -3910,7 +3910,7 @@ size_t tox_group_get_password_size(const Tox *tox, uint32_t group_number, Tox_Er
 }
 
 bool tox_group_get_password(const Tox *tox, uint32_t group_number, uint8_t *password,
-                            Tox_Err_Group_State_Queries *error)
+                            Tox_Err_Group_State_Query *error)
 {
     assert(tox != nullptr);
 
@@ -3918,12 +3918,12 @@ bool tox_group_get_password(const Tox *tox, uint32_t group_number, uint8_t *pass
     const GC_Chat *chat = gc_get_group(tox->m->group_handler, group_number);
 
     if (chat == nullptr) {
-        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND);
+        SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND);
         tox_unlock(tox);
         return false;
     }
 
-    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERIES_OK);
+    SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_STATE_QUERY_OK);
 
     gc_get_password(chat, password);
     tox_unlock(tox);

toxcore/tox.h

@@ -2458,6 +2458,7 @@ void tox_callback_file_recv_chunk(Tox *tox, tox_file_recv_chunk_cb *callback);
 
 typedef uint32_t Tox_Conference_Number;
 typedef uint32_t Tox_Conference_Peer_Number;
+typedef uint32_t Tox_Conference_Offline_Peer_Number;
 
 /**
  * @brief Conference types for the conference_invite event.
@@ -2682,7 +2683,7 @@ const char *tox_err_conference_peer_query_to_string(Tox_Err_Conference_Peer_Quer
  * peer_number for the functions querying these peers. Return value is
  * unspecified on failure.
  */
-Tox_Conference_Peer_Number tox_conference_peer_count(
+uint32_t tox_conference_peer_count(
     const Tox *tox, Tox_Conference_Number conference_number, Tox_Err_Conference_Peer_Query *error);
 
 /**
@@ -2744,7 +2745,7 @@ uint32_t tox_conference_offline_peer_count(
  */
 size_t tox_conference_offline_peer_get_name_size(
     const Tox *tox, Tox_Conference_Number conference_number,
-    Tox_Conference_Peer_Number offline_peer_number, Tox_Err_Conference_Peer_Query *error);
+    Tox_Conference_Offline_Peer_Number offline_peer_number, Tox_Err_Conference_Peer_Query *error);
 
 /**
  * @brief Copy the name of offline_peer_number who is in conference_number to name.
@@ -2757,7 +2758,7 @@ size_t tox_conference_offline_peer_get_name_size(
  * @return true on success.
  */
 bool tox_conference_offline_peer_get_name(
-    const Tox *tox, Tox_Conference_Number conference_number, Tox_Conference_Peer_Number offline_peer_number,
+    const Tox *tox, Tox_Conference_Number conference_number, Tox_Conference_Offline_Peer_Number offline_peer_number,
     uint8_t name[], Tox_Err_Conference_Peer_Query *error);
 
 /**
@@ -2769,14 +2770,14 @@ bool tox_conference_offline_peer_get_name(
  */
 bool tox_conference_offline_peer_get_public_key(
     const Tox *tox, Tox_Conference_Number conference_number,
-    Tox_Conference_Peer_Number offline_peer_number, uint8_t public_key[TOX_PUBLIC_KEY_SIZE], Tox_Err_Conference_Peer_Query *error);
+    Tox_Conference_Offline_Peer_Number offline_peer_number, uint8_t public_key[TOX_PUBLIC_KEY_SIZE], Tox_Err_Conference_Peer_Query *error);
 
 /**
  * @brief Return a unix-time timestamp of the last time offline_peer_number was seen to be active.
  */
 uint64_t tox_conference_offline_peer_get_last_active(
     const Tox *tox, Tox_Conference_Number conference_number,
-    Tox_Conference_Peer_Number offline_peer_number, Tox_Err_Conference_Peer_Query *error);
+    Tox_Conference_Offline_Peer_Number offline_peer_number, Tox_Err_Conference_Peer_Query *error);
 
 typedef enum Tox_Err_Conference_Set_Max_Offline {
 
@@ -4130,21 +4131,21 @@ void tox_callback_group_peer_status(Tox *tox, tox_group_peer_status_cb *callback
 /**
  * General error codes for group state get and size functions.
  */
-typedef enum Tox_Err_Group_State_Queries {
+typedef enum Tox_Err_Group_State_Query {
 
     /**
      * The function returned successfully.
      */
-    TOX_ERR_GROUP_STATE_QUERIES_OK,
+    TOX_ERR_GROUP_STATE_QUERY_OK,
 
     /**
      * The group number passed did not designate a valid group.
      */
-    TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND,
+    TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND,
 
-} Tox_Err_Group_State_Queries;
+} Tox_Err_Group_State_Query;
 
-const char *tox_err_group_state_queries_to_string(Tox_Err_Group_State_Queries value);
+const char *tox_err_group_state_query_to_string(Tox_Err_Group_State_Query value);
 
 /**
  * Error codes for group topic setting.
@@ -4210,7 +4211,7 @@ bool tox_group_set_topic(
  * The return value is equal to the `length` argument received by the last
  * `group_topic` callback.
  */
-size_t tox_group_get_topic_size(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Queries *error);
+size_t tox_group_get_topic_size(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Query *error);
 
 /**
  * Write the topic designated by the given group number to a byte array.
@@ -4227,7 +4228,7 @@ size_t tox_group_get_topic_size(const Tox *tox, Tox_Group_Number group_number, T
  */
 bool tox_group_get_topic(
     const Tox *tox, Tox_Group_Number group_number,
-    uint8_t topic[], Tox_Err_Group_State_Queries *error);
+    uint8_t topic[], Tox_Err_Group_State_Query *error);
 
 /**
  * @param group_number The group number of the group the topic change is intended for.
@@ -4252,7 +4253,7 @@ void tox_callback_group_topic(Tox *tox, tox_group_topic_cb *callback);
  * Return the length of the group name. If the group number is invalid, the
  * return value is unspecified.
  */
-size_t tox_group_get_name_size(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Queries *error);
+size_t tox_group_get_name_size(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Query *error);
 
 /**
  * Write the name of the group designated by the given group number to a byte array.
@@ -4266,7 +4267,7 @@ size_t tox_group_get_name_size(const Tox *tox, Tox_Group_Number group_number, To
  */
 bool tox_group_get_name(
     const Tox *tox, Tox_Group_Number group_number,
-    uint8_t name[], Tox_Err_Group_State_Queries *error);
+    uint8_t name[], Tox_Err_Group_State_Query *error);
 
 /**
  * Write the Chat ID designated by the given group number to a byte array.
@@ -4280,7 +4281,7 @@ bool tox_group_get_name(
  */
 bool tox_group_get_chat_id(
     const Tox *tox, Tox_Group_Number group_number, uint8_t chat_id[TOX_GROUP_CHAT_ID_SIZE],
-    Tox_Err_Group_State_Queries *error);
+    Tox_Err_Group_State_Query *error);
 
 /**
  * Return the number of groups in the Tox chats array.
@@ -4297,7 +4298,7 @@ uint32_t tox_group_get_number_groups(const Tox *tox);
  * @see the `Group chat founder controls` section for the respective set function.
  */
 Tox_Group_Privacy_State tox_group_get_privacy_state(const Tox *tox, Tox_Group_Number group_number,
-        Tox_Err_Group_State_Queries *error);
+        Tox_Err_Group_State_Query *error);
 
 /**
  * @param group_number The group number of the group the privacy state is intended for.
@@ -4322,7 +4323,7 @@ void tox_callback_group_privacy_state(Tox *tox, tox_group_privacy_state_cb *call
  * @see the `Group chat founder controls` section for the respective set function.
  */
 Tox_Group_Voice_State tox_group_get_voice_state(const Tox *tox, Tox_Group_Number group_number,
-        Tox_Err_Group_State_Queries *error);
+        Tox_Err_Group_State_Query *error);
 
 /**
  * @param group_number The group number of the group the voice state change is intended for.
@@ -4348,7 +4349,7 @@ void tox_callback_group_voice_state(Tox *tox, tox_group_voice_state_cb *callback
  * @see the `Group chat founder contols` section for the respective set function.
  */
 Tox_Group_Topic_Lock tox_group_get_topic_lock(const Tox *tox, Tox_Group_Number group_number,
-        Tox_Err_Group_State_Queries *error);
+        Tox_Err_Group_State_Query *error);
 
 /**
  * @param group_number The group number of the group for which the topic lock has changed.
@@ -4372,7 +4373,7 @@ void tox_callback_group_topic_lock(Tox *tox, tox_group_topic_lock_cb *callback);
  *
  * @see the `Group chat founder controls` section for the respective set function.
  */
-uint16_t tox_group_get_peer_limit(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Queries *error);
+uint16_t tox_group_get_peer_limit(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Query *error);
 
 /**
  * @param group_number The group number of the group for which the peer limit has changed.
@@ -4391,7 +4392,7 @@ void tox_callback_group_peer_limit(Tox *tox, tox_group_peer_limit_cb *callback);
  * Return the length of the group password. If the group number is invalid, the
  * return value is unspecified.
  */
-size_t tox_group_get_password_size(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Queries *error);
+size_t tox_group_get_password_size(const Tox *tox, Tox_Group_Number group_number, Tox_Err_Group_State_Query *error);
 
 /**
  * Write the password for the group designated by the given group number to a byte array.
@@ -4410,7 +4411,7 @@ size_t tox_group_get_password_size(const Tox *tox, Tox_Group_Number group_number
  */
 bool tox_group_get_password(
     const Tox *tox, Tox_Group_Number group_number, uint8_t password[],
-    Tox_Err_Group_State_Queries *error);
+    Tox_Err_Group_State_Query *error);
 
 /**
  * @param group_number The group number of the group for which the password has changed.

toxcore/tox_api.c

@@ -1253,17 +1253,17 @@ const char *tox_err_group_peer_query_to_string(Tox_Err_Group_Peer_Query value)
 
     return "<invalid Tox_Err_Group_Peer_Query>";
 }
-const char *tox_err_group_state_queries_to_string(Tox_Err_Group_State_Queries value)
+const char *tox_err_group_state_query_to_string(Tox_Err_Group_State_Query value)
 {
     switch (value) {
-        case TOX_ERR_GROUP_STATE_QUERIES_OK:
-            return "TOX_ERR_GROUP_STATE_QUERIES_OK";
+        case TOX_ERR_GROUP_STATE_QUERY_OK:
+            return "TOX_ERR_GROUP_STATE_QUERY_OK";
 
-        case TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND:
-            return "TOX_ERR_GROUP_STATE_QUERIES_GROUP_NOT_FOUND";
+        case TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND:
+            return "TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND";
     }
 
-    return "<invalid Tox_Err_Group_State_Queries>";
+    return "<invalid Tox_Err_Group_State_Query>";
 }
 const char *tox_err_group_topic_set_to_string(Tox_Err_Group_Topic_Set value)
 {