From e07248debbb7769f2c710c6e6ec542a7decf1056 Mon Sep 17 00:00:00 2001 From: Green Sky Date: Sat, 13 Jan 2024 23:32:37 +0100 Subject: [PATCH] refactor: Migrate auto_tests to new events API. Co-authored-by: Green Sky --- auto_tests/BUILD.bazel | 2 + auto_tests/auto_test_support.c | 28 ++++- auto_tests/auto_test_support.h | 4 + auto_tests/conference_av_test.c | 34 ++++-- auto_tests/conference_double_invite_test.c | 12 ++- auto_tests/conference_invite_merge_test.c | 13 ++- auto_tests/conference_peer_nick_test.c | 19 ++-- auto_tests/conference_simple_test.c | 118 +++++++++++---------- auto_tests/conference_test.c | 1 + auto_tests/dht_getnodes_api_test.c | 8 +- auto_tests/file_transfer_test.c | 109 +++++++++++++------ auto_tests/friend_request_spam_test.c | 8 +- auto_tests/friend_request_test.c | 42 ++++++-- auto_tests/group_general_test.c | 52 +++++---- auto_tests/group_invite_test.c | 14 +-- auto_tests/group_message_test.c | 91 ++++++++++------ auto_tests/group_moderation_test.c | 21 ++-- auto_tests/group_save_test.c | 15 +-- auto_tests/group_state_test.c | 40 ++++--- auto_tests/group_sync_test.c | 22 ++-- auto_tests/group_tcp_test.c | 32 ++++-- auto_tests/group_topic_test.c | 35 +++--- auto_tests/lossless_packet_test.c | 10 +- auto_tests/lossy_packet_test.c | 10 +- auto_tests/overflow_recvq_test.c | 10 +- auto_tests/reconnect_test.c | 7 +- auto_tests/save_friend_test.c | 42 ++++++-- auto_tests/save_load_test.c | 60 +++++++++-- auto_tests/send_message_test.c | 9 +- auto_tests/set_name_test.c | 46 ++++++-- auto_tests/set_status_message_test.c | 40 +++++-- auto_tests/tox_dispatch_test.c | 13 --- auto_tests/tox_many_tcp_test.c | 36 +++++-- auto_tests/tox_many_test.c | 22 +++- auto_tests/typing_test.c | 8 +- 35 files changed, 719 insertions(+), 314 deletions(-) diff --git a/auto_tests/BUILD.bazel b/auto_tests/BUILD.bazel index 2a205250..17606caf 100644 --- a/auto_tests/BUILD.bazel +++ b/auto_tests/BUILD.bazel @@ -17,6 +17,8 @@ cc_library( "//c-toxcore/toxcore:Messenger", "//c-toxcore/toxcore:mono_time", "//c-toxcore/toxcore:tox", + "//c-toxcore/toxcore:tox_dispatch", + "//c-toxcore/toxcore:tox_events", ], ) diff --git a/auto_tests/auto_test_support.c b/auto_tests/auto_test_support.c index 21346e58..fcae32ba 100644 --- a/auto_tests/auto_test_support.c +++ b/auto_tests/auto_test_support.c @@ -5,6 +5,8 @@ #include "../testing/misc_tools.h" #include "../toxcore/Messenger.h" #include "../toxcore/mono_time.h" +#include "../toxcore/tox_dispatch.h" +#include "../toxcore/tox_events.h" #include "../toxcore/tox_struct.h" #include "auto_test_support.h" @@ -23,6 +25,7 @@ Run_Auto_Options default_run_auto_options(void) .graph = GRAPH_COMPLETE, .init_autotox = nullptr, .tcp_port = 33188, + .events = true, }; } @@ -131,7 +134,15 @@ void iterate_all_wait(AutoTox *autotoxes, uint32_t tox_count, uint32_t wait) for (uint32_t i = 0; i < tox_count; ++i) { if (autotoxes[i].alive) { - tox_iterate(autotoxes[i].tox, &autotoxes[i]); + if (autotoxes[i].events) { + Tox_Err_Events_Iterate err; + Tox_Events *events = tox_events_iterate(autotoxes[i].tox, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(autotoxes[i].dispatch, events, autotoxes[i].tox, &autotoxes[i]); + tox_events_free(events); + } else { + tox_iterate(autotoxes[i].tox, &autotoxes[i]); + } autotoxes[i].clock += wait; } } @@ -181,6 +192,7 @@ void kill_autotox(AutoTox *autotox) ck_assert(autotox->alive); fprintf(stderr, "Killing #%u\n", autotox->index); autotox->alive = false; + tox_dispatch_free(autotox->dispatch); tox_kill(autotox->tox); } @@ -202,6 +214,11 @@ void reload(AutoTox *autotox) tox_options_set_savedata_data(options, autotox->save_state, autotox->save_size); autotox->tox = tox_new_log(options, nullptr, &autotox->index); ck_assert(autotox->tox != nullptr); + autotox->dispatch = tox_dispatch_new(nullptr); + ck_assert(autotox->dispatch != nullptr); + if (autotox->events) { + tox_events_init(autotox->tox); + } tox_options_free(options); set_mono_time_callback(autotox); @@ -212,6 +229,7 @@ static void initialise_autotox(struct Tox_Options *options, AutoTox *autotox, ui Run_Auto_Options *autotest_opts) { autotox->index = index; + autotox->events = autotest_opts->events; Tox_Err_New err = TOX_ERR_NEW_OK; @@ -259,6 +277,12 @@ static void initialise_autotox(struct Tox_Options *options, AutoTox *autotox, ui set_mono_time_callback(autotox); + autotox->dispatch = tox_dispatch_new(nullptr); + ck_assert(autotox->dispatch != nullptr); + if (autotox->events) { + tox_events_init(autotox->tox); + } + autotox->alive = true; autotox->save_state = nullptr; @@ -371,6 +395,7 @@ void run_auto_test(struct Tox_Options *options, uint32_t tox_count, void test(Au test(autotoxes); for (uint32_t i = 0; i < tox_count; ++i) { + tox_dispatch_free(autotoxes[i].dispatch); tox_kill(autotoxes[i].tox); free(autotoxes[i].state); free(autotoxes[i].save_state); @@ -455,4 +480,3 @@ Tox *tox_new_log(struct Tox_Options *options, Tox_Err_New *err, void *log_user_d { return tox_new_log_lan(options, err, log_user_data, false); } - diff --git a/auto_tests/auto_test_support.h b/auto_tests/auto_test_support.h index eab121aa..f506d9b2 100644 --- a/auto_tests/auto_test_support.h +++ b/auto_tests/auto_test_support.h @@ -7,9 +7,11 @@ #include "../testing/misc_tools.h" #include "../toxcore/Messenger.h" #include "../toxcore/mono_time.h" +#include "../toxcore/tox_dispatch.h" typedef struct AutoTox { Tox *tox; + Tox_Dispatch *dispatch; uint32_t index; uint64_t clock; @@ -17,6 +19,7 @@ typedef struct AutoTox { size_t save_size; uint8_t *save_state; bool alive; + bool events; void *state; } AutoTox; @@ -42,6 +45,7 @@ typedef struct Run_Auto_Options { Graph_Type graph; void (*init_autotox)(AutoTox *autotox, uint32_t n); uint16_t tcp_port; + bool events; } Run_Auto_Options; Run_Auto_Options default_run_auto_options(void); diff --git a/auto_tests/conference_av_test.c b/auto_tests/conference_av_test.c index c366be42..9477cc0f 100644 --- a/auto_tests/conference_av_test.c +++ b/auto_tests/conference_av_test.c @@ -23,10 +23,11 @@ typedef struct State { } State; static void handle_self_connection_status( - Tox *tox, Tox_Connection connection_status, void *user_data) + Tox *tox, const Tox_Event_Self_Connection_Status *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; + const Tox_Connection connection_status = tox_event_self_connection_status_get_connection_status(event); if (connection_status != TOX_CONNECTION_NONE) { printf("tox #%u: is now connected\n", autotox->index); } else { @@ -35,10 +36,13 @@ static void handle_self_connection_status( } static void handle_friend_connection_status( - Tox *tox, uint32_t friendnumber, Tox_Connection connection_status, void *user_data) + Tox *tox, const Tox_Event_Friend_Connection_Status *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; + const uint32_t friendnumber = tox_event_friend_connection_status_get_friend_number(event); + const Tox_Connection connection_status = tox_event_friend_connection_status_get_connection_status(event); + if (connection_status != TOX_CONNECTION_NONE) { printf("tox #%u: is now connected to friend %u\n", autotox->index, friendnumber); } else { @@ -70,18 +74,23 @@ static void audio_callback(void *tox, uint32_t groupnumber, uint32_t peernumber, } static void handle_conference_invite( - Tox *tox, uint32_t friendnumber, Tox_Conference_Type type, - const uint8_t *data, size_t length, void *user_data) + Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; + + const uint32_t friend_number = tox_event_conference_invite_get_friend_number(event); + const Tox_Conference_Type type = tox_event_conference_invite_get_type(event); + const uint8_t *cookie = tox_event_conference_invite_get_cookie(event); + const size_t length = tox_event_conference_invite_get_cookie_length(event); + ck_assert_msg(type == TOX_CONFERENCE_TYPE_AV, "tox #%u: wrong conference type: %d", autotox->index, type); - ck_assert_msg(toxav_join_av_groupchat(tox, friendnumber, data, length, audio_callback, user_data) == 0, + ck_assert_msg(toxav_join_av_groupchat(tox, friend_number, cookie, length, audio_callback, user_data) == 0, "tox #%u: failed to join group", autotox->index); } static void handle_conference_connected( - Tox *tox, uint32_t conference_number, void *user_data) + Tox *tox, const Tox_Event_Conference_Connected *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; @@ -138,7 +147,10 @@ static void disconnect_toxes(uint32_t tox_count, AutoTox *autotoxes, do { for (uint32_t i = 0; i < tox_count; ++i) { if (!disconnect_now[i]) { - tox_iterate(autotoxes[i].tox, &autotoxes[i]); + Tox_Err_Events_Iterate err; + Tox_Events *events = tox_events_iterate(autotoxes[i].tox, true, &err); + tox_dispatch_invoke(autotoxes[i].dispatch, events, autotoxes[i].tox, &autotoxes[i]); + tox_events_free(events); autotoxes[i].clock += 1000; } } @@ -402,10 +414,10 @@ static void test_groupav(AutoTox *autotoxes) const time_t test_start_time = time(nullptr); for (uint32_t i = 0; i < NUM_AV_GROUP_TOX; ++i) { - tox_callback_self_connection_status(autotoxes[i].tox, &handle_self_connection_status); - tox_callback_friend_connection_status(autotoxes[i].tox, &handle_friend_connection_status); - tox_callback_conference_invite(autotoxes[i].tox, &handle_conference_invite); - tox_callback_conference_connected(autotoxes[i].tox, &handle_conference_connected); + tox_events_callback_self_connection_status(autotoxes[i].dispatch, handle_self_connection_status); + tox_events_callback_friend_connection_status(autotoxes[i].dispatch, handle_friend_connection_status); + tox_events_callback_conference_invite(autotoxes[i].dispatch, handle_conference_invite); + tox_events_callback_conference_connected(autotoxes[i].dispatch, handle_conference_connected); } ck_assert_msg(toxav_add_av_groupchat(autotoxes[0].tox, audio_callback, &autotoxes[0]) != UINT32_MAX, diff --git a/auto_tests/conference_double_invite_test.c b/auto_tests/conference_double_invite_test.c index 201dd8f5..bda1c74e 100644 --- a/auto_tests/conference_double_invite_test.c +++ b/auto_tests/conference_double_invite_test.c @@ -12,12 +12,16 @@ typedef struct State { #include "auto_test_support.h" static void handle_conference_invite( - Tox *tox, uint32_t friend_number, Tox_Conference_Type type, - const uint8_t *cookie, size_t length, void *user_data) + Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; + const uint32_t friend_number = tox_event_conference_invite_get_friend_number(event); + const Tox_Conference_Type type = tox_event_conference_invite_get_type(event); + const uint8_t *cookie = tox_event_conference_invite_get_cookie(event); + const size_t length = tox_event_conference_invite_get_cookie_length(event); + fprintf(stderr, "handle_conference_invite(#%u, %u, %d, uint8_t[%u], _)\n", autotox->index, friend_number, type, (unsigned)length); fprintf(stderr, "tox%u joining conference\n", autotox->index); @@ -37,8 +41,8 @@ static void handle_conference_invite( static void conference_double_invite_test(AutoTox *autotoxes) { // Conference callbacks. - tox_callback_conference_invite(autotoxes[0].tox, handle_conference_invite); - tox_callback_conference_invite(autotoxes[1].tox, handle_conference_invite); + tox_events_callback_conference_invite(autotoxes[0].dispatch, handle_conference_invite); + tox_events_callback_conference_invite(autotoxes[1].dispatch, handle_conference_invite); State *state[2]; state[0] = (State *)autotoxes[0].state; diff --git a/auto_tests/conference_invite_merge_test.c b/auto_tests/conference_invite_merge_test.c index c02c59b4..4c980905 100644 --- a/auto_tests/conference_invite_merge_test.c +++ b/auto_tests/conference_invite_merge_test.c @@ -12,12 +12,15 @@ typedef struct State { #include "auto_test_support.h" static void handle_conference_invite( - Tox *tox, uint32_t friend_number, Tox_Conference_Type type, - const uint8_t *cookie, size_t length, void *user_data) + Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; + const uint32_t friend_number = tox_event_conference_invite_get_friend_number(event); + const uint8_t *cookie = tox_event_conference_invite_get_cookie(event); + const size_t length = tox_event_conference_invite_get_cookie_length(event); + if (friend_number != -1) { Tox_Err_Conference_Join err; state->conference = tox_conference_join(tox, friend_number, cookie, length, &err); @@ -28,7 +31,7 @@ static void handle_conference_invite( } static void handle_conference_connected( - Tox *tox, uint32_t conference_number, void *user_data) + Tox *tox, const Tox_Event_Conference_Connected *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; @@ -95,8 +98,8 @@ static void conference_invite_merge_test(AutoTox *autotoxes) // components will cause a split group to merge for (int i = 0; i < NUM_INVITE_MERGE_TOX; i++) { - tox_callback_conference_invite(autotoxes[i].tox, &handle_conference_invite); - tox_callback_conference_connected(autotoxes[i].tox, &handle_conference_connected); + tox_events_callback_conference_invite(autotoxes[i].dispatch, handle_conference_invite); + tox_events_callback_conference_connected(autotoxes[i].dispatch, handle_conference_connected); } State *state2 = (State *)autotoxes[2].state; diff --git a/auto_tests/conference_peer_nick_test.c b/auto_tests/conference_peer_nick_test.c index d1d12979..1414ebe9 100644 --- a/auto_tests/conference_peer_nick_test.c +++ b/auto_tests/conference_peer_nick_test.c @@ -13,12 +13,16 @@ typedef struct State { #include "auto_test_support.h" static void handle_conference_invite( - Tox *tox, uint32_t friend_number, Tox_Conference_Type type, - const uint8_t *cookie, size_t length, void *user_data) + Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; + const uint32_t friend_number = tox_event_conference_invite_get_friend_number(event); + const Tox_Conference_Type type = tox_event_conference_invite_get_type(event); + const uint8_t *cookie = tox_event_conference_invite_get_cookie(event); + const size_t length = tox_event_conference_invite_get_cookie_length(event); + fprintf(stderr, "handle_conference_invite(#%u, %u, %d, uint8_t[%u], _)\n", autotox->index, friend_number, type, (unsigned)length); fprintf(stderr, "tox%u joining conference\n", autotox->index); @@ -31,11 +35,12 @@ static void handle_conference_invite( state->joined = true; } -static void handle_peer_list_changed(Tox *tox, uint32_t conference_number, void *user_data) +static void handle_peer_list_changed(Tox *tox, const Tox_Event_Conference_Peer_List_Changed *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; + const uint32_t conference_number = tox_event_conference_peer_list_changed_get_conference_number(event); fprintf(stderr, "handle_peer_list_changed(#%u, %u, _)\n", autotox->index, conference_number); @@ -75,10 +80,10 @@ static void rebuild_peer_list(Tox *tox) static void conference_peer_nick_test(AutoTox *autotoxes) { // Conference callbacks. - tox_callback_conference_invite(autotoxes[0].tox, handle_conference_invite); - tox_callback_conference_invite(autotoxes[1].tox, handle_conference_invite); - tox_callback_conference_peer_list_changed(autotoxes[0].tox, handle_peer_list_changed); - tox_callback_conference_peer_list_changed(autotoxes[1].tox, handle_peer_list_changed); + tox_events_callback_conference_invite(autotoxes[0].dispatch, handle_conference_invite); + tox_events_callback_conference_invite(autotoxes[1].dispatch, handle_conference_invite); + tox_events_callback_conference_peer_list_changed(autotoxes[0].dispatch, handle_peer_list_changed); + tox_events_callback_conference_peer_list_changed(autotoxes[1].dispatch, handle_peer_list_changed); // Set the names of the toxes. tox_self_set_name(autotoxes[0].tox, (const uint8_t *)"test-tox-0", 10, nullptr); diff --git a/auto_tests/conference_simple_test.c b/auto_tests/conference_simple_test.c index 2c445d4b..189ab35c 100644 --- a/auto_tests/conference_simple_test.c +++ b/auto_tests/conference_simple_test.c @@ -3,6 +3,8 @@ #include "../testing/misc_tools.h" #include "../toxcore/tox.h" +#include "../toxcore/tox_dispatch.h" +#include "../toxcore/tox_events.h" #include "auto_test_support.h" #include "check_compat.h" @@ -20,28 +22,34 @@ typedef struct State { uint32_t peers; } State; -static void handle_self_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data) +static void handle_self_connection_status(Tox *tox, const Tox_Event_Self_Connection_Status *event, void *user_data) { State *state = (State *)user_data; + const Tox_Connection connection_status = tox_event_self_connection_status_get_connection_status(event); fprintf(stderr, "self_connection_status(#%u, %d, _)\n", state->id, connection_status); state->self_online = connection_status != TOX_CONNECTION_NONE; } -static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, Tox_Connection connection_status, +static void handle_friend_connection_status(Tox *tox, const Tox_Event_Friend_Connection_Status *event, void *user_data) { State *state = (State *)user_data; + const uint32_t friend_number = tox_event_friend_connection_status_get_friend_number(event); + const Tox_Connection connection_status = tox_event_friend_connection_status_get_connection_status(event); fprintf(stderr, "handle_friend_connection_status(#%u, %u, %d, _)\n", state->id, friend_number, connection_status); state->friend_online = connection_status != TOX_CONNECTION_NONE; } -static void handle_conference_invite(Tox *tox, uint32_t friend_number, Tox_Conference_Type type, const uint8_t *cookie, - size_t length, void *user_data) +static void handle_conference_invite(Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data) { State *state = (State *)user_data; + const uint32_t friend_number = tox_event_conference_invite_get_friend_number(event); + const Tox_Conference_Type type = tox_event_conference_invite_get_type(event); + const uint8_t *cookie = tox_event_conference_invite_get_cookie(event); + const size_t length = tox_event_conference_invite_get_cookie_length(event); fprintf(stderr, "handle_conference_invite(#%u, %u, %d, uint8_t[%u], _)\n", state->id, friend_number, type, (unsigned)length); fprintf(stderr, "tox%u joining conference\n", state->id); @@ -55,11 +63,16 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, Tox_Confe } } -static void handle_conference_message(Tox *tox, uint32_t conference_number, uint32_t peer_number, - Tox_Message_Type type, const uint8_t *message, size_t length, void *user_data) +static void handle_conference_message(Tox *tox, const Tox_Event_Conference_Message *event, void *user_data) { State *state = (State *)user_data; + const uint32_t conference_number = tox_event_conference_message_get_conference_number(event); + const uint32_t peer_number = tox_event_conference_message_get_peer_number(event); + const Tox_Message_Type type = tox_event_conference_message_get_type(event); + const uint8_t *message = tox_event_conference_message_get_message(event); + const size_t length = tox_event_conference_message_get_message_length(event); + fprintf(stderr, "handle_conference_message(#%u, %u, %u, %d, uint8_t[%u], _)\n", state->id, conference_number, peer_number, type, (unsigned)length); @@ -67,10 +80,11 @@ static void handle_conference_message(Tox *tox, uint32_t conference_number, uint state->received = true; } -static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_number, void *user_data) +static void handle_conference_peer_list_changed(Tox *tox, const Tox_Event_Conference_Peer_List_Changed *event, void *user_data) { State *state = (State *)user_data; + const uint32_t conference_number = tox_event_conference_peer_list_changed_get_conference_number(event); fprintf(stderr, "handle_conference_peer_list_changed(#%u, %u, _)\n", state->id, conference_number); @@ -86,7 +100,7 @@ static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_nu state->peers = count; } -static void handle_conference_connected(Tox *tox, uint32_t conference_number, void *user_data) +static void handle_conference_connected(Tox *tox, const Tox_Event_Conference_Connected *event, void *user_data) { State *state = (State *)user_data; @@ -101,6 +115,29 @@ static void handle_conference_connected(Tox *tox, uint32_t conference_number, vo } } +static void iterate_one( + Tox *tox, State *state, Tox_Dispatch *dispatch) +{ + Tox_Err_Events_Iterate err; + Tox_Events *events = tox_events_iterate(tox, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, tox, state); + tox_events_free(events); +} + +static void iterate3_wait( + Tox *tox1, State *state1, + Tox *tox2, State *state2, + Tox *tox3, State *state3, + Tox_Dispatch *dispatch, int interval) +{ + iterate_one(tox1, state1, dispatch); + iterate_one(tox2, state2, dispatch); + iterate_one(tox3, state3, dispatch); + + c_sleep(interval); +} + int main(void) { setvbuf(stdout, nullptr, _IONBF, 0); @@ -114,6 +151,10 @@ int main(void) Tox *tox2 = tox_new_log(nullptr, nullptr, &state2.id); Tox *tox3 = tox_new_log(nullptr, nullptr, &state3.id); + tox_events_init(tox1); + tox_events_init(tox2); + tox_events_init(tox3); + // tox1 <-> tox2, tox2 <-> tox3 uint8_t key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_public_key(tox2, key); @@ -133,41 +174,24 @@ int main(void) tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr); tox_bootstrap(tox3, "localhost", dht_port, dht_key, nullptr); - // Connection callbacks. - tox_callback_self_connection_status(tox1, handle_self_connection_status); - tox_callback_self_connection_status(tox2, handle_self_connection_status); - tox_callback_self_connection_status(tox3, handle_self_connection_status); + Tox_Dispatch *dispatch = tox_dispatch_new(nullptr); + ck_assert(dispatch != nullptr); - tox_callback_friend_connection_status(tox1, handle_friend_connection_status); - tox_callback_friend_connection_status(tox2, handle_friend_connection_status); - tox_callback_friend_connection_status(tox3, handle_friend_connection_status); + // Connection callbacks. + tox_events_callback_self_connection_status(dispatch, handle_self_connection_status); + tox_events_callback_friend_connection_status(dispatch, handle_friend_connection_status); // Conference callbacks. - tox_callback_conference_invite(tox1, handle_conference_invite); - tox_callback_conference_invite(tox2, handle_conference_invite); - tox_callback_conference_invite(tox3, handle_conference_invite); - - tox_callback_conference_connected(tox1, handle_conference_connected); - tox_callback_conference_connected(tox2, handle_conference_connected); - tox_callback_conference_connected(tox3, handle_conference_connected); - - tox_callback_conference_message(tox1, handle_conference_message); - tox_callback_conference_message(tox2, handle_conference_message); - tox_callback_conference_message(tox3, handle_conference_message); - - tox_callback_conference_peer_list_changed(tox1, handle_conference_peer_list_changed); - tox_callback_conference_peer_list_changed(tox2, handle_conference_peer_list_changed); - tox_callback_conference_peer_list_changed(tox3, handle_conference_peer_list_changed); + tox_events_callback_conference_invite(dispatch, handle_conference_invite); + tox_events_callback_conference_connected(dispatch, handle_conference_connected); + tox_events_callback_conference_message(dispatch, handle_conference_message); + tox_events_callback_conference_peer_list_changed(dispatch, handle_conference_peer_list_changed); // Wait for self connection. fprintf(stderr, "Waiting for toxes to come online\n"); do { - tox_iterate(tox1, &state1); - tox_iterate(tox2, &state2); - tox_iterate(tox3, &state3); - - c_sleep(100); + iterate3_wait(tox1, &state1, tox2, &state2, tox3, &state3, dispatch, 100); } while (!state1.self_online || !state2.self_online || !state3.self_online); fprintf(stderr, "Toxes are online\n"); @@ -176,11 +200,7 @@ int main(void) fprintf(stderr, "Waiting for friends to connect\n"); do { - tox_iterate(tox1, &state1); - tox_iterate(tox2, &state2); - tox_iterate(tox3, &state3); - - c_sleep(100); + iterate3_wait(tox1, &state1, tox2, &state2, tox3, &state3, dispatch, 100); } while (!state1.friend_online || !state2.friend_online || !state3.friend_online); fprintf(stderr, "Friends are connected\n"); @@ -206,11 +226,7 @@ int main(void) fprintf(stderr, "Waiting for invitation to arrive\n"); do { - tox_iterate(tox1, &state1); - tox_iterate(tox2, &state2); - tox_iterate(tox3, &state3); - - c_sleep(100); + iterate3_wait(tox1, &state1, tox2, &state2, tox3, &state3, dispatch, 100); } while (!state1.joined || !state2.joined || !state3.joined); fprintf(stderr, "Invitations accepted\n"); @@ -218,11 +234,7 @@ int main(void) fprintf(stderr, "Waiting for peers to come online\n"); do { - tox_iterate(tox1, &state1); - tox_iterate(tox2, &state2); - tox_iterate(tox3, &state3); - - c_sleep(100); + iterate3_wait(tox1, &state1, tox2, &state2, tox3, &state3, dispatch, 100); } while (state1.peers == 0 || state2.peers == 0 || state3.peers == 0); fprintf(stderr, "All peers are online\n"); @@ -242,15 +254,13 @@ int main(void) fprintf(stderr, "Waiting for messages to arrive\n"); do { - tox_iterate(tox1, &state1); - tox_iterate(tox2, &state2); - tox_iterate(tox3, &state3); - + iterate3_wait(tox1, &state1, tox2, &state2, tox3, &state3, dispatch, 100); c_sleep(100); } while (!state2.received || !state3.received); fprintf(stderr, "Messages received. Test complete.\n"); + tox_dispatch_free(dispatch); tox_kill(tox3); tox_kill(tox2); tox_kill(tox1); diff --git a/auto_tests/conference_test.c b/auto_tests/conference_test.c index 66edddd8..01b072b0 100644 --- a/auto_tests/conference_test.c +++ b/auto_tests/conference_test.c @@ -435,6 +435,7 @@ int main(void) Run_Auto_Options options = default_run_auto_options(); options.graph = GRAPH_LINEAR; + options.events = false; run_auto_test(nullptr, NUM_GROUP_TOX, test_many_group, sizeof(State), &options); return 0; diff --git a/auto_tests/dht_getnodes_api_test.c b/auto_tests/dht_getnodes_api_test.c index 3b54f1cc..04057500 100644 --- a/auto_tests/dht_getnodes_api_test.c +++ b/auto_tests/dht_getnodes_api_test.c @@ -72,13 +72,17 @@ static bool all_nodes_crawled(const AutoTox *autotoxes, uint32_t num_toxes, uint return true; } -static void getnodes_response_cb(Tox *tox, const uint8_t *public_key, const char *ip, uint16_t port, void *user_data) +static void getnodes_response_cb(Tox *tox, const Tox_Event_Dht_Get_Nodes_Response *event, void *user_data) { ck_assert(user_data != nullptr); AutoTox *autotoxes = (AutoTox *)user_data; State *state = (State *)autotoxes->state; + const uint8_t *public_key = tox_event_dht_get_nodes_response_get_public_key(event); + const char *ip = (const char *)tox_event_dht_get_nodes_response_get_ip(event); + const uint16_t port = tox_event_dht_get_nodes_response_get_port(event); + if (node_crawled(state->nodes, state->num_nodes, public_key)) { return; } @@ -121,7 +125,7 @@ static void test_dht_getnodes(AutoTox *autotoxes) ck_assert(public_key_list[i] != nullptr); tox_self_get_dht_id(autotoxes[i].tox, public_key_list[i]); - tox_callback_dht_get_nodes_response(autotoxes[i].tox, getnodes_response_cb); + tox_events_callback_dht_get_nodes_response(autotoxes[i].dispatch, getnodes_response_cb); printf("Peer %zu dht closenode count total/announce-capable: %d/%d\n", i, diff --git a/auto_tests/file_transfer_test.c b/auto_tests/file_transfer_test.c index 522717fa..c1247738 100644 --- a/auto_tests/file_transfer_test.c +++ b/auto_tests/file_transfer_test.c @@ -26,8 +26,12 @@ #define TOX_LOCALHOST "127.0.0.1" #endif -static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) +static void accept_friend_request(Tox *m, const Tox_Event_Friend_Request *event, void *userdata) { + const uint8_t *public_key = tox_event_friend_request_get_public_key(event); + const uint8_t *data = tox_event_friend_request_get_message(event); + const size_t length = tox_event_friend_request_get_message_length(event); + if (length == 7 && memcmp("Gentoo", data, 7) == 0) { tox_friend_add_norequest(m, public_key, nullptr); } @@ -39,9 +43,15 @@ static uint64_t sending_pos; static uint8_t file_cmp_id[TOX_FILE_ID_LENGTH]; static uint32_t file_accepted; static uint64_t file_size; -static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_number, uint32_t kind, uint64_t filesize, - const uint8_t *filename, size_t filename_length, void *userdata) +static void tox_file_receive(Tox *tox, const Tox_Event_File_Recv *event, void *userdata) { + const uint32_t friend_number = tox_event_file_recv_get_friend_number(event); + const uint32_t file_number = tox_event_file_recv_get_file_number(event); + const uint32_t kind = tox_event_file_recv_get_kind(event); + const uint64_t filesize = tox_event_file_recv_get_file_size(event); + const uint8_t *filename = tox_event_file_recv_get_filename(event); + const size_t filename_length = tox_event_file_recv_get_filename_length(event); + ck_assert_msg(kind == TOX_FILE_KIND_DATA, "bad kind"); ck_assert_msg(filename_length == sizeof("Gentoo.exe") @@ -86,9 +96,12 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num } static uint32_t sendf_ok; -static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, Tox_File_Control control, +static void file_print_control(Tox *tox, const Tox_Event_File_Recv_Control *event, void *userdata) { + const uint32_t file_number = tox_event_file_recv_control_get_file_number(event); + const Tox_File_Control control = tox_event_file_recv_control_get_control(event); + /* First send file num is 0.*/ if (file_number == 0 && control == TOX_FILE_CONTROL_RESUME) { sendf_ok = 1; @@ -99,12 +112,16 @@ static uint64_t max_sending; static bool m_send_reached; static uint8_t sending_num; static bool file_sending_done; -static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position, - size_t length, void *user_data) +static void tox_file_chunk_request(Tox *tox, const Tox_Event_File_Chunk_Request *event, void *user_data) { + const uint32_t friend_number = tox_event_file_chunk_request_get_friend_number(event); + const uint32_t file_number = tox_event_file_chunk_request_get_file_number(event); + const uint64_t position = tox_event_file_chunk_request_get_position(event); + size_t length = tox_event_file_chunk_request_get_length(event); + ck_assert_msg(sendf_ok, "didn't get resume control"); - ck_assert_msg(sending_pos == position, "bad position %lu", (unsigned long)position); + ck_assert_msg(sending_pos == position, "bad position %lu (should be %lu)", (unsigned long)position, (unsigned long)sending_pos); if (length == 0) { ck_assert_msg(!file_sending_done, "file sending already done"); @@ -126,7 +143,6 @@ static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t fi Tox_Err_File_Send_Chunk error; tox_file_send_chunk(tox, friend_number, file_number, position, f_data, length, &error); - ck_assert_msg(error == TOX_ERR_FILE_SEND_CHUNK_OK, "could not send chunk, error num=%d pos=%d len=%d", (int)error, (int)position, (int)length); @@ -137,9 +153,12 @@ static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t fi static uint8_t num; static bool file_recv; -static void write_file(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data, - size_t length, void *user_data) +static void write_file(Tox *tox, const Tox_Event_File_Recv_Chunk *event, void *user_data) { + const uint64_t position = tox_event_file_recv_chunk_get_position(event); + const uint8_t *data = tox_event_file_recv_chunk_get_data(event); + const size_t length = tox_event_file_recv_chunk_get_data_length(event); + ck_assert_msg(size_recv == position, "bad position"); if (length == 0) { @@ -156,6 +175,17 @@ static void write_file(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uin size_recv += length; } +static void iterate_and_dispatch(Tox_Dispatch *dispatch, Tox *tox) +{ + Tox_Err_Events_Iterate err; + Tox_Events *events; + + events = tox_events_iterate(tox, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, tox, nullptr); + tox_events_free(events); +} + static void file_transfer_test(void) { printf("Starting test: few_clients\n"); @@ -171,7 +201,19 @@ static void file_transfer_test(void) ck_assert_msg(tox1 && tox2 && tox3, "Failed to create 3 tox instances"); - tox_callback_friend_request(tox2, accept_friend_request); + tox_events_init(tox1); + tox_events_init(tox2); + tox_events_init(tox3); + + Tox_Dispatch *dispatch1 = tox_dispatch_new(nullptr); + ck_assert(dispatch1 != nullptr); + Tox_Dispatch *dispatch2 = tox_dispatch_new(nullptr); + ck_assert(dispatch2 != nullptr); + Tox_Dispatch *dispatch3 = tox_dispatch_new(nullptr); + ck_assert(dispatch3 != nullptr); + + tox_events_callback_friend_request(dispatch2, accept_friend_request); + uint8_t address[TOX_ADDRESS_SIZE]; tox_self_get_address(tox2, address); uint32_t test = tox_friend_add(tox3, address, (const uint8_t *)"Gentoo", 7, nullptr); @@ -187,9 +229,9 @@ static void file_transfer_test(void) printf("Waiting for toxes to come online\n"); do { - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); - tox_iterate(tox3, nullptr); + iterate_and_dispatch(dispatch1, tox1); + iterate_and_dispatch(dispatch2, tox2); + iterate_and_dispatch(dispatch3, tox3); printf("Connections: self (%d, %d, %d), friends (%d, %d)\n", tox_self_get_connection_status(tox1), @@ -210,11 +252,11 @@ static void file_transfer_test(void) file_recv = 0; max_sending = UINT64_MAX; uint64_t f_time = time(nullptr); - tox_callback_file_recv_chunk(tox3, write_file); - tox_callback_file_recv_control(tox2, file_print_control); - tox_callback_file_chunk_request(tox2, tox_file_chunk_request); - tox_callback_file_recv_control(tox3, file_print_control); - tox_callback_file_recv(tox3, tox_file_receive); + tox_events_callback_file_recv_chunk(dispatch3, write_file); + tox_events_callback_file_recv_control(dispatch2, file_print_control); + tox_events_callback_file_chunk_request(dispatch2, tox_file_chunk_request); + tox_events_callback_file_recv_control(dispatch3, file_print_control); + tox_events_callback_file_recv(dispatch3, tox_file_receive); uint64_t totalf_size = 100 * 1024 * 1024; uint32_t fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr, (const uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"), nullptr); @@ -231,9 +273,9 @@ static void file_transfer_test(void) const size_t max_iterations = INT16_MAX; for (size_t i = 0; i < max_iterations; i++) { - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); - tox_iterate(tox3, nullptr); + iterate_and_dispatch(dispatch1, tox1); + iterate_and_dispatch(dispatch2, tox2); + iterate_and_dispatch(dispatch3, tox3); if (file_sending_done) { ck_assert_msg(sendf_ok && file_recv && totalf_size == file_size && size_recv == file_size && sending_pos == size_recv @@ -274,11 +316,11 @@ static void file_transfer_test(void) sendf_ok = 0; size_recv = 0; file_recv = 0; - tox_callback_file_recv_chunk(tox3, write_file); - tox_callback_file_recv_control(tox2, file_print_control); - tox_callback_file_chunk_request(tox2, tox_file_chunk_request); - tox_callback_file_recv_control(tox3, file_print_control); - tox_callback_file_recv(tox3, tox_file_receive); + tox_events_callback_file_recv_chunk(dispatch3, write_file); + tox_events_callback_file_recv_control(dispatch2, file_print_control); + tox_events_callback_file_chunk_request(dispatch2, tox_file_chunk_request); + tox_events_callback_file_recv_control(dispatch3, file_print_control); + tox_events_callback_file_recv(dispatch3, tox_file_receive); totalf_size = 0; fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr, (const uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"), nullptr); @@ -298,9 +340,9 @@ static void file_transfer_test(void) c_sleep(min_u32(tox1_interval, min_u32(tox2_interval, tox3_interval))); - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); - tox_iterate(tox3, nullptr); + iterate_and_dispatch(dispatch1, tox1); + iterate_and_dispatch(dispatch2, tox2); + iterate_and_dispatch(dispatch3, tox3); } while (!file_sending_done); ck_assert_msg(sendf_ok && file_recv && totalf_size == file_size && size_recv == file_size @@ -312,9 +354,12 @@ static void file_transfer_test(void) printf("file_transfer_test succeeded, took %llu seconds\n", time(nullptr) - cur_time); - tox_kill(tox1); - tox_kill(tox2); + tox_dispatch_free(dispatch3); + tox_dispatch_free(dispatch2); + tox_dispatch_free(dispatch1); tox_kill(tox3); + tox_kill(tox2); + tox_kill(tox1); } int main(void) diff --git a/auto_tests/friend_request_spam_test.c b/auto_tests/friend_request_spam_test.c index 8916f250..c90c3ec1 100644 --- a/auto_tests/friend_request_spam_test.c +++ b/auto_tests/friend_request_spam_test.c @@ -22,9 +22,13 @@ typedef struct State { bool unused; } State; -static void accept_friend_request(Tox *tox, const uint8_t *public_key, const uint8_t *data, size_t length, +static void accept_friend_request(Tox *tox, const Tox_Event_Friend_Request *event, void *userdata) { + const uint8_t *public_key = tox_event_friend_request_get_public_key(event); + const uint8_t *data = tox_event_friend_request_get_message(event); + const size_t length = tox_event_friend_request_get_message_length(event); + ck_assert_msg(length == sizeof(FR_MESSAGE) && memcmp(FR_MESSAGE, data, sizeof(FR_MESSAGE)) == 0, "unexpected friend request message"); tox_friend_add_norequest(tox, public_key, nullptr); @@ -35,7 +39,7 @@ static void test_friend_request(AutoTox *autotoxes) const time_t con_time = time(nullptr); printf("All toxes add tox1 as friend.\n"); - tox_callback_friend_request(autotoxes[0].tox, accept_friend_request); + tox_events_callback_friend_request(autotoxes[0].dispatch, accept_friend_request); uint8_t address[TOX_ADDRESS_SIZE]; tox_self_get_address(autotoxes[0].tox, address); diff --git a/auto_tests/friend_request_test.c b/auto_tests/friend_request_test.c index 8fe8f292..78d950f8 100644 --- a/auto_tests/friend_request_test.c +++ b/auto_tests/friend_request_test.c @@ -15,14 +15,35 @@ #define FR_MESSAGE "Gentoo" -static void accept_friend_request(Tox *tox, const uint8_t *public_key, const uint8_t *data, size_t length, +static void accept_friend_request(Tox *tox, const Tox_Event_Friend_Request *event, void *userdata) { + const uint8_t *public_key = tox_event_friend_request_get_public_key(event); + const uint8_t *data = tox_event_friend_request_get_message(event); + const size_t length = tox_event_friend_request_get_message_length(event); ck_assert_msg(length == sizeof(FR_MESSAGE) && memcmp(FR_MESSAGE, data, sizeof(FR_MESSAGE)) == 0, "unexpected friend request message"); tox_friend_add_norequest(tox, public_key, nullptr); } +static void iterate2_wait(Tox_Dispatch *dispatch, Tox *tox1, Tox *tox2) +{ + Tox_Err_Events_Iterate err; + Tox_Events *events; + + events = tox_events_iterate(tox1, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, tox1, nullptr); + tox_events_free(events); + + events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, tox2, nullptr); + tox_events_free(events); + + c_sleep(ITERATION_INTERVAL); +} + static void test_friend_request(void) { printf("Initialising 2 toxes.\n"); @@ -33,6 +54,9 @@ static void test_friend_request(void) ck_assert_msg(tox1 && tox2, "failed to create 2 tox instances"); + tox_events_init(tox1); + tox_events_init(tox2); + printf("Bootstrapping tox2 off tox1.\n"); uint8_t dht_key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_dht_id(tox1, dht_key); @@ -40,11 +64,11 @@ static void test_friend_request(void) tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr); - do { - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + Tox_Dispatch *dispatch = tox_dispatch_new(nullptr); + ck_assert(dispatch != nullptr); - c_sleep(ITERATION_INTERVAL); + do { + iterate2_wait(dispatch, tox1, tox2); } while (tox_self_get_connection_status(tox1) == TOX_CONNECTION_NONE || tox_self_get_connection_status(tox2) == TOX_CONNECTION_NONE); @@ -52,7 +76,7 @@ static void test_friend_request(void) const time_t con_time = time(nullptr); printf("Tox1 adds tox2 as friend, tox2 accepts.\n"); - tox_callback_friend_request(tox2, accept_friend_request); + tox_events_callback_friend_request(dispatch, accept_friend_request); uint8_t address[TOX_ADDRESS_SIZE]; tox_self_get_address(tox2, address); @@ -61,16 +85,14 @@ static void test_friend_request(void) ck_assert_msg(test == 0, "failed to add friend error code: %u", test); do { - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); - - c_sleep(ITERATION_INTERVAL); + iterate2_wait(dispatch, tox1, tox2); } while (tox_friend_get_connection_status(tox1, 0, nullptr) != TOX_CONNECTION_UDP || tox_friend_get_connection_status(tox2, 0, nullptr) != TOX_CONNECTION_UDP); printf("Tox clients connected took %lu seconds.\n", (unsigned long)(time(nullptr) - con_time)); printf("friend_request_test succeeded, took %lu seconds.\n", (unsigned long)(time(nullptr) - cur_time)); + tox_dispatch_free(dispatch); tox_kill(tox1); tox_kill(tox2); } diff --git a/auto_tests/group_general_test.c b/auto_tests/group_general_test.c index 06663041..38c0d003 100644 --- a/auto_tests/group_general_test.c +++ b/auto_tests/group_general_test.c @@ -62,7 +62,7 @@ static void print_ip(Tox *tox, uint32_t groupnumber, uint32_t peer_id) static bool all_group_peers_connected(AutoTox *autotoxes, uint32_t tox_count, uint32_t groupnumber, size_t name_length) { for (size_t i = 0; i < tox_count; ++i) { - // make sure we got an invite response + // make sure we got an F response if (tox_group_get_name_size(autotoxes[i].tox, groupnumber, nullptr) != name_length) { return false; } @@ -81,16 +81,19 @@ static bool all_group_peers_connected(AutoTox *autotoxes, uint32_t tox_count, ui return true; } -static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t groupnumber = tox_event_group_peer_join_get_group_number(event); + const uint32_t peer_id = tox_event_group_peer_join_get_peer_id(event); + // we do a connection test here for fun Tox_Err_Group_Peer_Query pq_err; - TOX_CONNECTION connection_status = tox_group_peer_get_connection_status(tox, groupnumber, peer_id, &pq_err); + Tox_Connection connection_status = tox_group_peer_get_connection_status(tox, groupnumber, peer_id, &pq_err); ck_assert(pq_err == TOX_ERR_GROUP_PEER_QUERY_OK); ck_assert(connection_status != TOX_CONNECTION_NONE); @@ -143,13 +146,15 @@ static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t pee ++state->peer_joined_count; } -static void group_peer_self_join_handler(Tox *tox, uint32_t groupnumber, void *user_data) +static void group_peer_self_join_handler(Tox *tox, const Tox_Event_Group_Self_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t groupnumber = tox_event_group_self_join_get_group_number(event); + // make sure we see our own correct peer state on join callback Tox_Err_Group_Self_Query sq_err; @@ -162,7 +167,7 @@ static void group_peer_self_join_handler(Tox *tox, uint32_t groupnumber, void *u ck_assert(sq_err == TOX_ERR_GROUP_SELF_QUERY_OK); - TOX_USER_STATUS self_status = tox_group_self_get_status(tox, groupnumber, &sq_err); + Tox_User_Status self_status = tox_group_self_get_status(tox, groupnumber, &sq_err); ck_assert(sq_err == TOX_ERR_GROUP_SELF_QUERY_OK); Tox_Group_Role self_role = tox_group_self_get_role(tox, groupnumber, &sq_err); @@ -206,15 +211,16 @@ static void group_peer_self_join_handler(Tox *tox, uint32_t groupnumber, void *u ++state->self_joined_count; } -static void group_peer_exit_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, Tox_Group_Exit_Type exit_type, - const uint8_t *name, size_t name_length, const uint8_t *part_message, - size_t length, void *user_data) +static void group_peer_exit_handler(Tox *tox, const Tox_Event_Group_Peer_Exit *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint8_t *part_message = tox_event_group_peer_exit_get_part_message(event); + const size_t length = tox_event_group_peer_exit_get_part_message_length(event); + ++state->peer_exit_count; // first exit is a disconnect. second is a real exit with a part message @@ -224,14 +230,16 @@ static void group_peer_exit_handler(Tox *tox, uint32_t groupnumber, uint32_t pee } } -static void group_peer_name_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *name, - size_t length, void *user_data) +static void group_peer_name_handler(Tox *tox, const Tox_Event_Group_Peer_Name *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint8_t *name = tox_event_group_peer_name_get_name(event); + const size_t length = tox_event_group_peer_name_get_name_length(event); + // note: we already test the name_get api call elsewhere ck_assert(length == PEER0_NICK2_LEN); @@ -240,7 +248,7 @@ static void group_peer_name_handler(Tox *tox, uint32_t groupnumber, uint32_t pee state->peer_nick = true; } -static void group_peer_status_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_USER_STATUS status, +static void group_peer_status_handler(Tox *tox, const Tox_Event_Group_Peer_Status *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; @@ -248,8 +256,12 @@ static void group_peer_status_handler(Tox *tox, uint32_t groupnumber, uint32_t p State *state = (State *)autotox->state; + const uint32_t groupnumber = tox_event_group_peer_status_get_group_number(event); + const uint32_t peer_id = tox_event_group_peer_status_get_peer_id(event); + const Tox_User_Status status = tox_event_group_peer_status_get_status(event); + Tox_Err_Group_Peer_Query err; - TOX_USER_STATUS cur_status = tox_group_peer_get_status(tox, groupnumber, peer_id, &err); + Tox_User_Status cur_status = tox_group_peer_get_status(tox, groupnumber, peer_id, &err); ck_assert_msg(cur_status == status, "%d, %d", cur_status, status); ck_assert(status == TOX_USER_STATUS_BUSY); @@ -266,13 +278,13 @@ static void group_announce_test(AutoTox *autotoxes) State *state0 = (State *)autotoxes[0].state; State *state1 = (State *)autotoxes[1].state; - tox_callback_group_peer_join(tox0, group_peer_join_handler); - tox_callback_group_peer_join(tox1, group_peer_join_handler); - tox_callback_group_self_join(tox0, group_peer_self_join_handler); - tox_callback_group_self_join(tox1, group_peer_self_join_handler); - tox_callback_group_peer_name(tox1, group_peer_name_handler); - tox_callback_group_peer_status(tox1, group_peer_status_handler); - tox_callback_group_peer_exit(tox1, group_peer_exit_handler); + tox_events_callback_group_peer_join(autotoxes[0].dispatch, group_peer_join_handler); + tox_events_callback_group_peer_join(autotoxes[1].dispatch, group_peer_join_handler); + tox_events_callback_group_self_join(autotoxes[0].dispatch, group_peer_self_join_handler); + tox_events_callback_group_self_join(autotoxes[1].dispatch, group_peer_self_join_handler); + tox_events_callback_group_peer_name(autotoxes[1].dispatch, group_peer_name_handler); + tox_events_callback_group_peer_status(autotoxes[1].dispatch, group_peer_status_handler); + tox_events_callback_group_peer_exit(autotoxes[1].dispatch, group_peer_exit_handler); // tox0 makes new group. Tox_Err_Group_New err_new; @@ -343,7 +355,7 @@ static void group_announce_test(AutoTox *autotoxes) iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL); - TOX_USER_STATUS self_status = tox_group_self_get_status(tox0, groupnumber, &sq_err); + Tox_User_Status self_status = tox_group_self_get_status(tox0, groupnumber, &sq_err); ck_assert(sq_err == TOX_ERR_GROUP_SELF_QUERY_OK); ck_assert(self_status == TOX_USER_STATUS_BUSY); diff --git a/auto_tests/group_invite_test.c b/auto_tests/group_invite_test.c index b83bed5e..11674f74 100644 --- a/auto_tests/group_invite_test.c +++ b/auto_tests/group_invite_test.c @@ -51,13 +51,15 @@ static bool group_has_full_graph(const AutoTox *autotoxes, uint32_t group_number return true; } -static void group_join_fail_handler(Tox *tox, uint32_t group_number, Tox_Group_Join_Fail fail_type, void *user_data) +static void group_join_fail_handler(Tox *tox, const Tox_Event_Group_Join_Fail *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const Tox_Group_Join_Fail fail_type = tox_event_group_join_fail_get_fail_type(event); + switch (fail_type) { case TOX_GROUP_JOIN_FAIL_PEER_LIMIT: { state->peer_limit_fail = true; @@ -79,7 +81,7 @@ static void group_join_fail_handler(Tox *tox, uint32_t group_number, Tox_Group_J } } -static void group_self_join_handler(Tox *tox, uint32_t group_number, void *user_data) +static void group_self_join_handler(Tox *tox, const Tox_Event_Group_Self_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -89,7 +91,7 @@ static void group_self_join_handler(Tox *tox, uint32_t group_number, void *user_ state->connected = true; } -static void group_peer_join_handler(Tox *tox, uint32_t group_number, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -105,9 +107,9 @@ static void group_invite_test(AutoTox *autotoxes) ck_assert_msg(NUM_GROUP_TOXES > 7, "NUM_GROUP_TOXES is too small: %d", NUM_GROUP_TOXES); for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) { - tox_callback_group_peer_join(autotoxes[i].tox, group_peer_join_handler); - tox_callback_group_join_fail(autotoxes[i].tox, group_join_fail_handler); - tox_callback_group_self_join(autotoxes[i].tox, group_self_join_handler); + tox_events_callback_group_peer_join(autotoxes[i].dispatch, group_peer_join_handler); + tox_events_callback_group_join_fail(autotoxes[i].dispatch, group_join_fail_handler); + tox_events_callback_group_self_join(autotoxes[i].dispatch, group_self_join_handler); } Tox *tox0 = autotoxes[0].tox; diff --git a/auto_tests/group_message_test.c b/auto_tests/group_message_test.c index a8e20f99..d78e86d0 100644 --- a/auto_tests/group_message_test.c +++ b/auto_tests/group_message_test.c @@ -71,9 +71,12 @@ static uint16_t get_message_checksum(const uint8_t *message, uint16_t length) return sum; } -static void group_invite_handler(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, - const uint8_t *group_name, size_t group_name_length, void *user_data) +static void group_invite_handler(Tox *tox, const Tox_Event_Group_Invite *event, void *user_data) { + const uint32_t friend_number = tox_event_group_invite_get_friend_number(event); + const uint8_t *invite_data = tox_event_group_invite_get_invite_data(event); + const size_t length = tox_event_group_invite_get_invite_data_length(event); + printf("invite arrived; accepting\n"); Tox_Err_Group_Invite_Accept err_accept; tox_group_invite_accept(tox, friend_number, invite_data, length, (const uint8_t *)PEER0_NICK, PEER0_NICK_LEN, @@ -81,18 +84,21 @@ static void group_invite_handler(Tox *tox, uint32_t friend_number, const uint8_t ck_assert(err_accept == TOX_ERR_GROUP_INVITE_ACCEPT_OK); } -static void group_join_fail_handler(Tox *tox, uint32_t groupnumber, Tox_Group_Join_Fail fail_type, void *user_data) +static void group_join_fail_handler(Tox *tox, const Tox_Event_Group_Join_Fail *event, void *user_data) { + const Tox_Group_Join_Fail fail_type = tox_event_group_join_fail_get_fail_type(event); printf("join failed: %d\n", fail_type); } -static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t peer_id = tox_event_group_peer_join_get_peer_id(event); + ck_assert_msg(state->peer_joined == false, "Peer timedout"); printf("peer %u joined, sending message\n", peer_id); @@ -100,9 +106,13 @@ static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t pee state->peer_id = peer_id; } -static void group_custom_private_packet_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *data, - size_t length, void *user_data) +static void group_custom_private_packet_handler(Tox *tox, const Tox_Event_Group_Custom_Private_Packet *event, void *user_data) { + const uint32_t groupnumber = tox_event_group_custom_private_packet_get_group_number(event); + const uint32_t peer_id = tox_event_group_custom_private_packet_get_peer_id(event); + const uint8_t *data = tox_event_group_custom_private_packet_get_data(event); + const size_t length = tox_event_group_custom_private_packet_get_data_length(event); + ck_assert_msg(length == TEST_CUSTOM_PRIVATE_PACKET_LEN, "Failed to receive custom private packet. Invalid length: %zu\n", length); @@ -146,9 +156,13 @@ static void group_custom_private_packet_handler(Tox *tox, uint32_t groupnumber, ++state->custom_private_packets_received; } -static void group_custom_packet_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *data, - size_t length, void *user_data) +static void group_custom_packet_handler(Tox *tox, const Tox_Event_Group_Custom_Packet *event, void *user_data) { + const uint32_t groupnumber = tox_event_group_custom_packet_get_group_number(event); + const uint32_t peer_id = tox_event_group_custom_packet_get_peer_id(event); + const uint8_t *data = tox_event_group_custom_packet_get_data(event); + const size_t length = tox_event_group_custom_packet_get_data_length(event); + ck_assert_msg(length == TEST_CUSTOM_PACKET_LEN, "Failed to receive custom packet. Invalid length: %zu\n", length); char message_buf[TOX_MAX_CUSTOM_PACKET_SIZE + 1]; @@ -191,9 +205,11 @@ static void group_custom_packet_handler(Tox *tox, uint32_t groupnumber, uint32_t ++state->custom_packets_received; } -static void group_custom_packet_large_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *data, - size_t length, void *user_data) +static void group_custom_packet_large_handler(Tox *tox, const Tox_Event_Group_Custom_Packet *event, void *user_data) { + const uint8_t *data = tox_event_group_custom_packet_get_data(event); + const size_t length = tox_event_group_custom_packet_get_data_length(event); + ck_assert_msg(length == TEST_CUSTOM_PACKET_LARGE_LEN, "Failed to receive large custom packet. Invalid length: %zu\n", length); ck_assert(memcmp(data, TEST_CUSTOM_PACKET_LARGE, length) == 0); @@ -206,9 +222,14 @@ static void group_custom_packet_large_handler(Tox *tox, uint32_t groupnumber, ui ++state->custom_packets_received; } -static void group_message_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_MESSAGE_TYPE type, - const uint8_t *message, size_t length, uint32_t pseudo_msg_id, void *user_data) +static void group_message_handler(Tox *tox, const Tox_Event_Group_Message *event, void *user_data) { + const uint32_t groupnumber = tox_event_group_message_get_group_number(event); + const uint32_t peer_id = tox_event_group_message_get_peer_id(event); + const uint8_t *message = tox_event_group_message_get_message(event); + const size_t length = tox_event_group_message_get_message_length(event); + const uint32_t pseudo_msg_id = tox_event_group_message_get_message_id(event); + ck_assert(!(length == IGNORE_MESSAGE_LEN && memcmp(message, IGNORE_MESSAGE, length) == 0)); ck_assert_msg(length == TEST_MESSAGE_LEN, "Failed to receive message. Invalid length: %zu\n", length); @@ -254,9 +275,14 @@ static void group_message_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_ state->pseudo_msg_id = pseudo_msg_id; } -static void group_private_message_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_MESSAGE_TYPE type, - const uint8_t *message, size_t length, void *user_data) +static void group_private_message_handler(Tox *tox, const Tox_Event_Group_Private_Message *event, void *user_data) { + const uint32_t groupnumber = tox_event_group_private_message_get_group_number(event); + const uint32_t peer_id = tox_event_group_private_message_get_peer_id(event); + const Tox_Message_Type type = tox_event_group_private_message_get_type(event); + const uint8_t *message = tox_event_group_private_message_get_message(event); + const size_t length = tox_event_group_private_message_get_message_length(event); + ck_assert_msg(length == TEST_PRIVATE_MESSAGE_LEN, "Failed to receive message. Invalid length: %zu\n", length); char message_buf[TOX_GROUP_MAX_MESSAGE_LENGTH + 1]; @@ -301,9 +327,11 @@ static void group_private_message_handler(Tox *tox, uint32_t groupnumber, uint32 state->private_message_received = true; } -static void group_message_handler_lossless_test(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_MESSAGE_TYPE type, - const uint8_t *message, size_t length, uint32_t pseudo_msg_id, void *user_data) +static void group_message_handler_lossless_test(Tox *tox, const Tox_Event_Group_Message *event, void *user_data) { + const uint8_t *message = tox_event_group_message_get_message(event); + const size_t length = tox_event_group_message_get_message_length(event); + AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -325,10 +353,11 @@ static void group_message_handler_lossless_test(Tox *tox, uint32_t groupnumber, state->lossless_check = true; } } -static void group_message_handler_wraparound_test(Tox *tox, uint32_t groupnumber, uint32_t peer_id, - TOX_MESSAGE_TYPE type, - const uint8_t *message, size_t length, uint32_t pseudo_msg_id, void *user_data) +static void group_message_handler_wraparound_test(Tox *tox, const Tox_Event_Group_Message *event, void *user_data) { + const uint8_t *message = tox_event_group_message_get_message(event); + const size_t length = tox_event_group_message_get_message_length(event); + AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -365,15 +394,15 @@ static void group_message_test(AutoTox *autotoxes) state0->pseudo_msg_id = 0; state1->pseudo_msg_id = 1; - tox_callback_group_invite(tox1, group_invite_handler); - tox_callback_group_join_fail(tox1, group_join_fail_handler); - tox_callback_group_peer_join(tox1, group_peer_join_handler); - tox_callback_group_join_fail(tox0, group_join_fail_handler); - tox_callback_group_peer_join(tox0, group_peer_join_handler); - tox_callback_group_message(tox0, group_message_handler); - tox_callback_group_custom_packet(tox0, group_custom_packet_handler); - tox_callback_group_custom_private_packet(tox0, group_custom_private_packet_handler); - tox_callback_group_private_message(tox0, group_private_message_handler); + tox_events_callback_group_invite(autotoxes[1].dispatch, group_invite_handler); + tox_events_callback_group_join_fail(autotoxes[1].dispatch, group_join_fail_handler); + tox_events_callback_group_peer_join(autotoxes[1].dispatch, group_peer_join_handler); + tox_events_callback_group_join_fail(autotoxes[0].dispatch, group_join_fail_handler); + tox_events_callback_group_peer_join(autotoxes[0].dispatch, group_peer_join_handler); + tox_events_callback_group_message(autotoxes[0].dispatch, group_message_handler); + tox_events_callback_group_custom_packet(autotoxes[0].dispatch, group_custom_packet_handler); + tox_events_callback_group_custom_private_packet(autotoxes[0].dispatch, group_custom_private_packet_handler); + tox_events_callback_group_private_message(autotoxes[0].dispatch, group_private_message_handler); Tox_Err_Group_Send_Message err_send; @@ -472,7 +501,7 @@ static void group_message_test(AutoTox *autotoxes) // tox0 sends a large max sized lossy custom packet // overwrite callback for larger packet - tox_callback_group_custom_packet(tox0, group_custom_packet_large_handler); + tox_events_callback_group_custom_packet(autotoxes[0].dispatch, group_custom_packet_large_handler); tox_group_send_custom_packet(tox1, group_number, false, (const uint8_t *)TEST_CUSTOM_PACKET_LARGE, TEST_CUSTOM_PACKET_LARGE_LEN, &c_err); @@ -486,7 +515,7 @@ static void group_message_test(AutoTox *autotoxes) fprintf(stderr, "Doing lossless packet test...\n"); - tox_callback_group_message(tox1, group_message_handler_lossless_test); + tox_events_callback_group_message(autotoxes[1].dispatch, group_message_handler_lossless_test); state1->last_msg_recv = -1; // lossless and packet splitting/reassembly test @@ -517,7 +546,7 @@ static void group_message_test(AutoTox *autotoxes) } state1->last_msg_recv = -1; - tox_callback_group_message(tox1, group_message_handler_wraparound_test); + tox_events_callback_group_message(autotoxes[1].dispatch, group_message_handler_wraparound_test); fprintf(stderr, "Doing wraparound test...\n"); diff --git a/auto_tests/group_moderation_test.c b/auto_tests/group_moderation_test.c index d87491ee..a0d75d6b 100644 --- a/auto_tests/group_moderation_test.c +++ b/auto_tests/group_moderation_test.c @@ -156,18 +156,22 @@ static size_t get_state_index_by_nick(const AutoTox *autotoxes, size_t num_peers ck_assert_msg(0, "Failed to find index"); } -static void group_join_fail_handler(Tox *tox, uint32_t group_number, Tox_Group_Join_Fail fail_type, void *user_data) +static void group_join_fail_handler(Tox *tox, const Tox_Event_Group_Join_Fail *event, void *user_data) { + const Tox_Group_Join_Fail fail_type = tox_event_group_join_fail_get_fail_type(event); fprintf(stderr, "Failed to join group: %d", fail_type); } -static void group_peer_join_handler(Tox *tox, uint32_t group_number, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t group_number = tox_event_group_peer_join_get_group_number(event); + const uint32_t peer_id = tox_event_group_peer_join_get_peer_id(event); + ck_assert(state->group_number == group_number); char peer_name[TOX_MAX_NAME_LENGTH + 1]; @@ -243,14 +247,17 @@ static void handle_user(State *state, const char *peer_name, size_t peer_name_le state->user_check = true; } -static void group_mod_event_handler(Tox *tox, uint32_t group_number, uint32_t source_peer_id, uint32_t target_peer_id, - Tox_Group_Mod_Event mod_type, void *user_data) +static void group_mod_event_handler(Tox *tox, const Tox_Event_Group_Moderation *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t group_number = tox_event_group_moderation_get_group_number(event); + const uint32_t target_peer_id = tox_event_group_moderation_get_target_peer_id(event); + const Tox_Group_Mod_Event mod_type = tox_event_group_moderation_get_mod_type(event); + ck_assert(state->group_number == group_number); char peer_name[TOX_MAX_NAME_LENGTH + 1]; @@ -445,9 +452,9 @@ static void group_moderation_test(AutoTox *autotoxes) snprintf(state->self_name, sizeof(state->self_name), "peer_%zu", i); state->self_name[name_length] = 0; - tox_callback_group_join_fail(autotoxes[i].tox, group_join_fail_handler); - tox_callback_group_peer_join(autotoxes[i].tox, group_peer_join_handler); - tox_callback_group_moderation(autotoxes[i].tox, group_mod_event_handler); + tox_events_callback_group_join_fail(autotoxes[i].dispatch, group_join_fail_handler); + tox_events_callback_group_peer_join(autotoxes[i].dispatch, group_peer_join_handler); + tox_events_callback_group_moderation(autotoxes[i].dispatch, group_mod_event_handler); } iterate_all_wait(autotoxes, NUM_GROUP_TOXES, ITERATION_INTERVAL); diff --git a/auto_tests/group_save_test.c b/auto_tests/group_save_test.c index aea898dc..e5456d96 100644 --- a/auto_tests/group_save_test.c +++ b/auto_tests/group_save_test.c @@ -26,9 +26,12 @@ typedef struct State { #define PEER0_NICK_LEN (sizeof(PEER0_NICK) -1) #define NEW_USER_STATUS TOX_USER_STATUS_BUSY -static void group_invite_handler(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, - const uint8_t *group_name, size_t group_name_length, void *user_data) +static void group_invite_handler(Tox *tox, const Tox_Event_Group_Invite *event, void *user_data) { + const uint32_t friend_number = tox_event_group_invite_get_friend_number(event); + const uint8_t *invite_data = tox_event_group_invite_get_invite_data(event); + const size_t length = tox_event_group_invite_get_invite_data_length(event); + Tox_Err_Group_Invite_Accept err_accept; tox_group_invite_accept(tox, friend_number, invite_data, length, (const uint8_t *)"test2", 5, nullptr, 0, &err_accept); @@ -36,7 +39,7 @@ static void group_invite_handler(Tox *tox, uint32_t friend_number, const uint8_t } -static void group_peer_join_handler(Tox *tox, uint32_t group_number, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -120,7 +123,7 @@ static int has_correct_self_state(const Tox *tox, uint32_t group_number, const u return -1; } - TOX_USER_STATUS self_status = tox_group_self_get_status(tox, group_number, &sq_err); + Tox_User_Status self_status = tox_group_self_get_status(tox, group_number, &sq_err); ck_assert(sq_err == TOX_ERR_GROUP_SELF_QUERY_OK); if (self_status != NEW_USER_STATUS) { @@ -151,8 +154,8 @@ static void group_save_test(AutoTox *autotoxes) ck_assert_msg(NUM_GROUP_TOXES > 1, "NUM_GROUP_TOXES is too small: %d", NUM_GROUP_TOXES); for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) { - tox_callback_group_invite(autotoxes[i].tox, group_invite_handler); - tox_callback_group_peer_join(autotoxes[i].tox, group_peer_join_handler); + tox_events_callback_group_invite(autotoxes[i].dispatch, group_invite_handler); + tox_events_callback_group_peer_join(autotoxes[i].dispatch, group_peer_join_handler); } Tox *tox0 = autotoxes[0].tox; diff --git a/auto_tests/group_state_test.c b/auto_tests/group_state_test.c index c506f802..ca953238 100644 --- a/auto_tests/group_state_test.c +++ b/auto_tests/group_state_test.c @@ -60,9 +60,12 @@ static bool all_group_peers_connected(const AutoTox *autotoxes, uint32_t tox_cou return true; } -static void group_topic_lock_handler(Tox *tox, uint32_t groupnumber, Tox_Group_Topic_Lock topic_lock, +static void group_topic_lock_handler(Tox *tox, const Tox_Event_Group_Topic_Lock *event, void *user_data) { + 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_Group_Topic_Lock current_topic_lock = tox_group_get_topic_lock(tox, groupnumber, &err); @@ -71,9 +74,12 @@ static void group_topic_lock_handler(Tox *tox, uint32_t groupnumber, Tox_Group_T topic_lock, current_topic_lock); } -static void group_voice_state_handler(Tox *tox, uint32_t groupnumber, Tox_Group_Voice_State voice_state, +static void group_voice_state_handler(Tox *tox, const Tox_Event_Group_Voice_State *event, void *user_data) { + 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_Group_Voice_State current_voice_state = tox_group_get_voice_state(tox, groupnumber, &err); @@ -82,9 +88,12 @@ static void group_voice_state_handler(Tox *tox, uint32_t groupnumber, Tox_Group_ voice_state, current_voice_state); } -static void group_privacy_state_handler(Tox *tox, uint32_t groupnumber, Tox_Group_Privacy_State privacy_state, +static void group_privacy_state_handler(Tox *tox, const Tox_Event_Group_Privacy_State *event, void *user_data) { + 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_Group_Privacy_State current_pstate = tox_group_get_privacy_state(tox, groupnumber, &err); @@ -92,8 +101,11 @@ static void group_privacy_state_handler(Tox *tox, uint32_t groupnumber, Tox_Grou ck_assert_msg(current_pstate == privacy_state, "privacy states don't match in callback"); } -static void group_peer_limit_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_limit, void *user_data) +static void group_peer_limit_handler(Tox *tox, const Tox_Event_Group_Peer_Limit *event, void *user_data) { + 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; uint32_t current_plimit = tox_group_get_peer_limit(tox, groupnumber, &err); @@ -102,9 +114,13 @@ static void group_peer_limit_handler(Tox *tox, uint32_t groupnumber, uint32_t pe "Peer limits don't match in callback: %u, %u\n", peer_limit, current_plimit); } -static void group_password_handler(Tox *tox, uint32_t groupnumber, const uint8_t *password, size_t length, +static void group_password_handler(Tox *tox, const Tox_Event_Group_Password *event, void *user_data) { + const uint32_t groupnumber = tox_event_group_password_get_group_number(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; size_t curr_pwlength = tox_group_get_password_size(tox, groupnumber, &err); @@ -119,7 +135,7 @@ static void group_password_handler(Tox *tox, uint32_t groupnumber, const uint8_t "Passwords don't match: %s, %s", password, current_password); } -static void group_peer_join_handler(Tox *tox, uint32_t group_number, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -241,12 +257,12 @@ static void group_state_test(AutoTox *autotoxes) ck_assert_msg(NUM_GROUP_TOXES >= 3, "NUM_GROUP_TOXES is too small: %d", NUM_GROUP_TOXES); for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) { - tox_callback_group_privacy_state(autotoxes[i].tox, group_privacy_state_handler); - tox_callback_group_peer_limit(autotoxes[i].tox, group_peer_limit_handler); - tox_callback_group_password(autotoxes[i].tox, group_password_handler); - tox_callback_group_peer_join(autotoxes[i].tox, group_peer_join_handler); - tox_callback_group_voice_state(autotoxes[i].tox, group_voice_state_handler); - tox_callback_group_topic_lock(autotoxes[i].tox, group_topic_lock_handler); + tox_events_callback_group_privacy_state(autotoxes[i].dispatch, group_privacy_state_handler); + tox_events_callback_group_peer_limit(autotoxes[i].dispatch, group_peer_limit_handler); + tox_events_callback_group_password(autotoxes[i].dispatch, group_password_handler); + tox_events_callback_group_peer_join(autotoxes[i].dispatch, group_peer_join_handler); + tox_events_callback_group_voice_state(autotoxes[i].dispatch, group_voice_state_handler); + tox_events_callback_group_topic_lock(autotoxes[i].dispatch, group_topic_lock_handler); } Tox *tox0 = autotoxes[0].tox; diff --git a/auto_tests/group_sync_test.c b/auto_tests/group_sync_test.c index d635f76f..745752e1 100644 --- a/auto_tests/group_sync_test.c +++ b/auto_tests/group_sync_test.c @@ -96,38 +96,42 @@ static void peers_cleanup(Peers *peers) free(peers); } -static void group_peer_join_handler(Tox *tox, uint32_t group_number, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t peer_id = tox_event_group_peer_join_get_peer_id(event); + ck_assert(add_peer(state->peers, peer_id) == 0); } -static void group_peer_exit_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, Tox_Group_Exit_Type exit_type, - const uint8_t *name, size_t name_length, const uint8_t *part_message, - size_t length, void *user_data) +static void group_peer_exit_handler(Tox *tox, const Tox_Event_Group_Peer_Exit *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint32_t peer_id = tox_event_group_peer_exit_get_peer_id(event); + ck_assert(del_peer(state->peers, peer_id) == 0); } -static void group_topic_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *topic, - size_t length, void *user_data) +static void group_topic_handler(Tox *tox, const Tox_Event_Group_Topic *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + const uint8_t *topic = tox_event_group_topic_get_topic(event); + const size_t length = tox_event_group_topic_get_topic_length(event); + ck_assert(length <= TOX_GROUP_MAX_TOPIC_LENGTH); memcpy(state->callback_topic, (const char *)topic, length); @@ -335,9 +339,9 @@ static void group_sync_test(AutoTox *autotoxes) ck_assert(rng != nullptr); for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) { - tox_callback_group_peer_join(autotoxes[i].tox, group_peer_join_handler); - tox_callback_group_topic(autotoxes[i].tox, group_topic_handler); - tox_callback_group_peer_exit(autotoxes[i].tox, group_peer_exit_handler); + tox_events_callback_group_peer_join(autotoxes[i].dispatch, group_peer_join_handler); + tox_events_callback_group_topic(autotoxes[i].dispatch, group_topic_handler); + tox_events_callback_group_peer_exit(autotoxes[i].dispatch, group_peer_exit_handler); State *state = (State *)autotoxes[i].state; state->peers = (Peers *)calloc(1, sizeof(Peers)); diff --git a/auto_tests/group_tcp_test.c b/auto_tests/group_tcp_test.c index 78a339d8..66b435b1 100644 --- a/auto_tests/group_tcp_test.c +++ b/auto_tests/group_tcp_test.c @@ -19,9 +19,12 @@ typedef struct State { uint32_t peer_id[NUM_GROUP_TOXES - 1]; } State; -static void group_invite_handler(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, - const uint8_t *group_name, size_t group_name_length, void *user_data) +static void group_invite_handler(Tox *tox, const Tox_Event_Group_Invite *event, void *user_data) { + const uint32_t friend_number = tox_event_group_invite_get_friend_number(event); + const uint8_t *invite_data = tox_event_group_invite_get_invite_data(event); + const size_t length = tox_event_group_invite_get_invite_data_length(event); + printf("Accepting friend invite\n"); Tox_Err_Group_Invite_Accept err_accept; @@ -30,21 +33,26 @@ static void group_invite_handler(Tox *tox, uint32_t friend_number, const uint8_t ck_assert(err_accept == TOX_ERR_GROUP_INVITE_ACCEPT_OK); } -static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); State *state = (State *)autotox->state; + + const uint32_t peer_id = tox_event_group_peer_join_get_peer_id(event); + fprintf(stderr, "joined: %zu, %u\n", state->num_peers, peer_id); ck_assert_msg(state->num_peers < NUM_GROUP_TOXES - 1, "%zu", state->num_peers); state->peer_id[state->num_peers++] = peer_id; } -static void group_private_message_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_MESSAGE_TYPE type, - const uint8_t *message, size_t length, void *user_data) +static void group_private_message_handler(Tox *tox, const Tox_Event_Group_Private_Message *event, void *user_data) { + const uint8_t *message = tox_event_group_private_message_get_message(event); + const size_t length = tox_event_group_private_message_get_message_length(event); + AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -58,9 +66,11 @@ static void group_private_message_handler(Tox *tox, uint32_t groupnumber, uint32 state->got_code = true; } -static void group_message_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, TOX_MESSAGE_TYPE type, - const uint8_t *message, size_t length, uint32_t message_id, void *user_data) +static void group_message_handler(Tox *tox, const Tox_Event_Group_Message *event, void *user_data) { + const uint8_t *message = tox_event_group_message_get_message(event); + const size_t length = tox_event_group_message_get_message_length(event); + AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -133,12 +143,12 @@ static void group_tcp_test(AutoTox *autotoxes) State *state1 = (State *)autotoxes[1].state; for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) { - tox_callback_group_peer_join(autotoxes[i].tox, group_peer_join_handler); - tox_callback_group_private_message(autotoxes[i].tox, group_private_message_handler); + tox_events_callback_group_peer_join(autotoxes[i].dispatch, group_peer_join_handler); + tox_events_callback_group_private_message(autotoxes[i].dispatch, group_private_message_handler); } - tox_callback_group_message(autotoxes[1].tox, group_message_handler); - tox_callback_group_invite(autotoxes[1].tox, group_invite_handler); + tox_events_callback_group_message(autotoxes[1].dispatch, group_message_handler); + tox_events_callback_group_invite(autotoxes[1].dispatch, group_invite_handler); Tox_Err_Group_New new_err; uint32_t groupnumber = tox_group_new(autotoxes[0].tox, TOX_GROUP_PRIVACY_STATE_PUBLIC, (const uint8_t *)"test", 4, diff --git a/auto_tests/group_topic_test.c b/auto_tests/group_topic_test.c index 60f78acf..6ca5fb0b 100644 --- a/auto_tests/group_topic_test.c +++ b/auto_tests/group_topic_test.c @@ -55,8 +55,11 @@ static bool all_group_peers_connected(const AutoTox *autotoxes, uint32_t tox_cou return true; } -static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, void *user_data) +static void group_peer_join_handler(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data) { + //const uint32_t group_number = tox_event_group_peer_join_get_group_number(event); + const uint32_t peer_id = tox_event_group_peer_join_get_peer_id(event); + AutoTox *autotox = (AutoTox *)user_data; ck_assert(autotox != nullptr); @@ -65,26 +68,33 @@ static void group_peer_join_handler(Tox *tox, uint32_t groupnumber, uint32_t pee state->peer_id = peer_id; } -static void group_topic_handler(Tox *tox, uint32_t groupnumber, uint32_t peer_id, const uint8_t *topic, - size_t length, void *user_data) +static void group_topic_handler(Tox *tox, const Tox_Event_Group_Topic *event, void *user_data) { - ck_assert(length <= TOX_GROUP_MAX_TOPIC_LENGTH); + const uint32_t group_number = tox_event_group_topic_get_group_number(event); + //const uint32_t peer_id = tox_event_group_topic_get_peer_id(event); + const uint8_t *topic = tox_event_group_topic_get_topic(event); + const uint32_t topic_length = tox_event_group_topic_get_topic_length(event); + + ck_assert(topic_length <= TOX_GROUP_MAX_TOPIC_LENGTH); Tox_Err_Group_State_Queries query_err; uint8_t topic2[TOX_GROUP_MAX_TOPIC_LENGTH]; - tox_group_get_topic(tox, groupnumber, topic2, &query_err); + tox_group_get_topic(tox, group_number, topic2, &query_err); ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK); - size_t topic_length = tox_group_get_topic_size(tox, groupnumber, &query_err); + size_t topic_length_getter = tox_group_get_topic_size(tox, group_number, &query_err); ck_assert(query_err == TOX_ERR_GROUP_STATE_QUERIES_OK); - ck_assert_msg(topic_length == length && memcmp(topic, topic2, length) == 0, + ck_assert_msg(topic_length_getter == topic_length && memcmp(topic, topic2, topic_length) == 0, "topic differs in callback: %s, %s", topic, topic2); } -static void group_topic_lock_handler(Tox *tox, uint32_t groupnumber, Tox_Group_Topic_Lock topic_lock, void *user_data) +static void group_topic_lock_handler(Tox *tox, const Tox_Event_Group_Topic_Lock *event, void *user_data) { + 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_Group_Topic_Lock current_lock = tox_group_get_topic_lock(tox, groupnumber, &err); + Tox_Group_Topic_Lock current_lock = tox_group_get_topic_lock(tox, group_number, &err); ck_assert(err == TOX_ERR_GROUP_STATE_QUERIES_OK); ck_assert_msg(topic_lock == current_lock, "topic locks differ in callback"); @@ -209,13 +219,14 @@ static void group_topic_test(AutoTox *autotoxes) ck_assert(rng != nullptr); Tox *tox0 = autotoxes[0].tox; + Tox_Dispatch *dispatch0 = autotoxes[0].dispatch; const State *state0 = (const State *)autotoxes[0].state; - tox_callback_group_peer_join(tox0, group_peer_join_handler); + tox_events_callback_group_peer_join(dispatch0, group_peer_join_handler); for (size_t i = 0; i < NUM_GROUP_TOXES; ++i) { - tox_callback_group_topic(autotoxes[i].tox, group_topic_handler); - tox_callback_group_topic_lock(autotoxes[i].tox, group_topic_lock_handler); + tox_events_callback_group_topic(autotoxes[i].dispatch, group_topic_handler); + tox_events_callback_group_topic_lock(autotoxes[i].dispatch, group_topic_lock_handler); } /* Tox1 creates a group and is the founder of a newly created group */ diff --git a/auto_tests/lossless_packet_test.c b/auto_tests/lossless_packet_test.c index 9d3f824c..5fc0525f 100644 --- a/auto_tests/lossless_packet_test.c +++ b/auto_tests/lossless_packet_test.c @@ -18,13 +18,17 @@ typedef struct State { #define LOSSLESS_PACKET_FILLER 160 -static void handle_lossless_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length, void *user_data) +static void handle_lossless_packet(Tox *tox, const Tox_Event_Friend_Lossless_Packet *event, void *user_data) { + //const uint32_t friend_number = tox_event_friend_lossless_packet_get_friend_number(event); + const uint8_t *data = tox_event_friend_lossless_packet_get_data(event); + const uint32_t data_length = tox_event_friend_lossless_packet_get_data_length(event); + uint8_t *cmp_packet = (uint8_t *)malloc(tox_max_custom_packet_size()); ck_assert(cmp_packet != nullptr); memset(cmp_packet, LOSSLESS_PACKET_FILLER, tox_max_custom_packet_size()); - if (length == tox_max_custom_packet_size() && memcmp(data, cmp_packet, tox_max_custom_packet_size()) == 0) { + if (data_length == tox_max_custom_packet_size() && memcmp(data, cmp_packet, tox_max_custom_packet_size()) == 0) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; state->custom_packet_received = true; @@ -35,7 +39,7 @@ static void handle_lossless_packet(Tox *tox, uint32_t friend_number, const uint8 static void test_lossless_packet(AutoTox *autotoxes) { - tox_callback_friend_lossless_packet(autotoxes[1].tox, &handle_lossless_packet); + tox_events_callback_friend_lossless_packet(autotoxes[1].dispatch, &handle_lossless_packet); const size_t packet_size = tox_max_custom_packet_size() + 1; uint8_t *packet = (uint8_t *)malloc(packet_size); ck_assert(packet != nullptr); diff --git a/auto_tests/lossy_packet_test.c b/auto_tests/lossy_packet_test.c index 30745410..8221d02c 100644 --- a/auto_tests/lossy_packet_test.c +++ b/auto_tests/lossy_packet_test.c @@ -18,13 +18,17 @@ typedef struct State { #define LOSSY_PACKET_FILLER 200 -static void handle_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length, void *user_data) +static void handle_lossy_packet(Tox *tox, const Tox_Event_Friend_Lossy_Packet *event, void *user_data) { + //const uint32_t friend_number = tox_event_friend_lossy_packet_get_friend_number(event); + const uint8_t *data = tox_event_friend_lossy_packet_get_data(event); + const uint32_t data_length = tox_event_friend_lossy_packet_get_data_length(event); + uint8_t *cmp_packet = (uint8_t *)malloc(tox_max_custom_packet_size()); ck_assert(cmp_packet != nullptr); memset(cmp_packet, LOSSY_PACKET_FILLER, tox_max_custom_packet_size()); - if (length == tox_max_custom_packet_size() && memcmp(data, cmp_packet, tox_max_custom_packet_size()) == 0) { + if (data_length == tox_max_custom_packet_size() && memcmp(data, cmp_packet, tox_max_custom_packet_size()) == 0) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; state->custom_packet_received = true; @@ -35,7 +39,7 @@ static void handle_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_t static void test_lossy_packet(AutoTox *autotoxes) { - tox_callback_friend_lossy_packet(autotoxes[1].tox, &handle_lossy_packet); + tox_events_callback_friend_lossy_packet(autotoxes[1].dispatch, &handle_lossy_packet); const size_t packet_size = tox_max_custom_packet_size() + 1; uint8_t *packet = (uint8_t *)malloc(packet_size); ck_assert(packet != nullptr); diff --git a/auto_tests/overflow_recvq_test.c b/auto_tests/overflow_recvq_test.c index 8855f70f..04191485 100644 --- a/auto_tests/overflow_recvq_test.c +++ b/auto_tests/overflow_recvq_test.c @@ -11,9 +11,13 @@ typedef struct State { #define NUM_MSGS 40000 -static void handle_friend_message(Tox *tox, uint32_t friend_number, Tox_Message_Type type, - const uint8_t *message, size_t length, void *user_data) +static void handle_friend_message(Tox *tox, const Tox_Event_Friend_Message *event, void *user_data) { + //const uint32_t friend_number = tox_event_friend_message_get_friend_number(event); + //const Tox_Message_Type type = tox_event_friend_message_get_type(event); + //const uint8_t *message = tox_event_friend_message_get_message(event); + //const uint32_t message_length = tox_event_friend_message_get_message_length(event); + const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; state->recv_count++; @@ -21,7 +25,7 @@ static void handle_friend_message(Tox *tox, uint32_t friend_number, Tox_Message_ static void net_crypto_overflow_test(AutoTox *autotoxes) { - tox_callback_friend_message(autotoxes[0].tox, handle_friend_message); + tox_events_callback_friend_message(autotoxes[0].dispatch, handle_friend_message); printf("sending many messages to tox0\n"); diff --git a/auto_tests/reconnect_test.c b/auto_tests/reconnect_test.c index 253f66b0..beb3f519 100644 --- a/auto_tests/reconnect_test.c +++ b/auto_tests/reconnect_test.c @@ -67,7 +67,12 @@ static void test_reconnect(AutoTox *autotoxes) do { for (uint16_t i = 0; i < TOX_COUNT; ++i) { if (i != disconnect) { - tox_iterate(autotoxes[i].tox, &autotoxes[i]); + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(autotoxes[i].tox, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(autotoxes[i].dispatch, events, autotoxes[i].tox, &autotoxes[i]); + tox_events_free(events); + autotoxes[i].clock += 1000; } } diff --git a/auto_tests/save_friend_test.c b/auto_tests/save_friend_test.c index 80a6ed03..0d999998 100644 --- a/auto_tests/save_friend_test.c +++ b/auto_tests/save_friend_test.c @@ -44,18 +44,25 @@ static void set_string(uint8_t **to, const uint8_t *from, size_t length) memcpy(*to, from, length); } -static void namechange_callback(Tox *tox, uint32_t friend_number, const uint8_t *name, size_t length, void *user_data) +static void namechange_callback(Tox *tox, const Tox_Event_Friend_Name *event, void *user_data) { + //const uint32_t friend_number = tox_event_friend_name_get_friend_number(event); + const uint8_t *name = tox_event_friend_name_get_name(event); + const uint32_t name_length = tox_event_friend_name_get_name_length(event); + struct test_data *to_compare = (struct test_data *)user_data; - set_string(&to_compare->name, name, length); + set_string(&to_compare->name, name, name_length); to_compare->received_name = true; } -static void statuschange_callback(Tox *tox, uint32_t friend_number, const uint8_t *message, size_t length, - void *user_data) +static void statuschange_callback(Tox *tox, const Tox_Event_Friend_Status_Message *event, void *user_data) { + //const uint32_t friend_number = tox_event_friend_status_message_get_friend_number(event); + const uint8_t *message = tox_event_friend_status_message_get_message(event); + const uint32_t message_length = tox_event_friend_status_message_get_message_length(event); + struct test_data *to_compare = (struct test_data *)user_data; - set_string(&to_compare->status_message, message, length); + set_string(&to_compare->status_message, message, message_length); to_compare->received_status_message = true; } @@ -65,6 +72,12 @@ int main(void) Tox *const tox1 = tox_new_log(nullptr, nullptr, nullptr); Tox *const tox2 = tox_new_log(nullptr, nullptr, nullptr); + ck_assert(tox1 != nullptr); + ck_assert(tox2 != nullptr); + + tox_events_init(tox1); + Tox_Dispatch* dispatch1 = tox_dispatch_new(nullptr); + ck_assert(dispatch1 != nullptr); printf("bootstrapping tox2 off tox1\n"); uint8_t dht_key[TOX_PUBLIC_KEY_SIZE]; @@ -96,8 +109,8 @@ int main(void) tox_self_get_name(tox2, reference_name); tox_self_get_status_message(tox2, reference_status); - tox_callback_friend_name(tox1, namechange_callback); - tox_callback_friend_status_message(tox1, statuschange_callback); + tox_events_callback_friend_name(dispatch1, namechange_callback); + tox_events_callback_friend_status_message(dispatch1, statuschange_callback); while (true) { if (tox_self_get_connection_status(tox1) && @@ -107,7 +120,12 @@ int main(void) break; } - tox_iterate(tox1, &to_compare); + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox1, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch1, events, tox1, &to_compare); + tox_events_free(events); + tox_iterate(tox2, nullptr); c_sleep(tox_iteration_interval(tox1)); @@ -119,7 +137,12 @@ int main(void) break; } - tox_iterate(tox1, &to_compare); + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox1, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch1, events, tox1, &to_compare); + tox_events_free(events); + tox_iterate(tox2, nullptr); c_sleep(tox_iteration_interval(tox1)); @@ -146,6 +169,7 @@ int main(void) "incorrect status message: should be all zeroes"); tox_options_free(options); + tox_dispatch_free(dispatch1); tox_kill(tox1); tox_kill(tox2); tox_kill(tox_to_compare); diff --git a/auto_tests/save_load_test.c b/auto_tests/save_load_test.c index 20baed5b..96901ddc 100644 --- a/auto_tests/save_load_test.c +++ b/auto_tests/save_load_test.c @@ -32,16 +32,22 @@ #endif #define TCP_RELAY_PORT 33431 -static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) +static void accept_friend_request(Tox *m, const Tox_Event_Friend_Request *event, void *userdata) { - if (length == 7 && memcmp("Gentoo", data, 7) == 0) { + const uint8_t *public_key = tox_event_friend_request_get_public_key(event); + const uint8_t *message = tox_event_friend_request_get_message(event); + uint32_t message_length = tox_event_friend_request_get_message_length(event); + + if (message_length == 7 && memcmp("Gentoo", message, 7) == 0) { tox_friend_add_norequest(m, public_key, nullptr); } } static unsigned int connected_t1; -static void tox_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data) +static void tox_connection_status(Tox *tox, const Tox_Event_Self_Connection_Status *event, void *user_data) { + const Tox_Connection connection_status = tox_event_self_connection_status_get_connection_status(event); + if (connected_t1 && !connection_status) { ck_abort_msg("Tox went offline"); } @@ -147,6 +153,9 @@ static void test_few_clients(void) Tox *tox1 = tox_new_log(opts1, &t_n_error, &index[0]); ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "Failed to create tox instance: %d", t_n_error); tox_options_free(opts1); + tox_events_init(tox1); + Tox_Dispatch* dispatch1 = tox_dispatch_new(nullptr); + ck_assert(dispatch1 != nullptr); struct Tox_Options *opts2 = tox_options_new(nullptr); tox_options_set_ipv6_enabled(opts2, USE_IPV6); @@ -154,6 +163,9 @@ static void test_few_clients(void) tox_options_set_local_discovery_enabled(opts2, false); Tox *tox2 = tox_new_log(opts2, &t_n_error, &index[1]); ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "Failed to create tox instance: %d", t_n_error); + tox_events_init(tox2); + Tox_Dispatch* dispatch2 = tox_dispatch_new(nullptr); + ck_assert(dispatch2 != nullptr); struct Tox_Options *opts3 = tox_options_new(nullptr); tox_options_set_ipv6_enabled(opts3, USE_IPV6); @@ -183,8 +195,8 @@ static void test_few_clients(void) tox_bootstrap(tox3, "localhost", dht_port, dht_key, nullptr); connected_t1 = 0; - tox_callback_self_connection_status(tox1, tox_connection_status); - tox_callback_friend_request(tox2, accept_friend_request); + tox_events_callback_self_connection_status(dispatch1, tox_connection_status); + tox_events_callback_friend_request(dispatch2, accept_friend_request); uint8_t address[TOX_ADDRESS_SIZE]; tox_self_get_address(tox2, address); uint32_t test = tox_friend_add(tox3, address, (const uint8_t *)"Gentoo", 7, nullptr); @@ -193,8 +205,20 @@ static void test_few_clients(void) uint8_t off = 1; while (true) { - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + { + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox1, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch1, events, tox1, nullptr); + tox_events_free(events); + } + { + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch2, events, tox2, nullptr); + tox_events_free(events); + } tox_iterate(tox3, nullptr); if (tox_self_get_connection_status(tox1) && tox_self_get_connection_status(tox2) @@ -220,9 +244,10 @@ static void test_few_clients(void) // We're done with this callback, so unset it to ensure we don't fail the // test if tox1 goes offline while tox2 and 3 are reloaded. - tox_callback_self_connection_status(tox1, nullptr); + tox_events_callback_self_connection_status(dispatch1, nullptr); reload_tox(&tox2, opts2, &index[1]); + tox_events_init(tox2); reload_tox(&tox3, opts3, &index[2]); @@ -231,8 +256,20 @@ static void test_few_clients(void) off = 1; while (true) { - tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + { + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox1, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch1, events, tox1, nullptr); + tox_events_free(events); + } + { + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch2, events, tox2, nullptr); + tox_events_free(events); + } tox_iterate(tox3, nullptr); if (tox_self_get_connection_status(tox1) && tox_self_get_connection_status(tox2) @@ -257,6 +294,9 @@ static void test_few_clients(void) printf("test_few_clients succeeded, took %lu seconds\n", (unsigned long)(time(nullptr) - cur_time)); + tox_dispatch_free(dispatch1); + tox_dispatch_free(dispatch2); + tox_kill(tox1); tox_kill(tox2); tox_kill(tox3); diff --git a/auto_tests/send_message_test.c b/auto_tests/send_message_test.c index 92079cb8..5051a82e 100644 --- a/auto_tests/send_message_test.c +++ b/auto_tests/send_message_test.c @@ -14,12 +14,15 @@ typedef struct State { #define MESSAGE_FILLER 'G' static void message_callback( - Tox *m, uint32_t friendnumber, Tox_Message_Type type, - const uint8_t *string, size_t length, void *user_data) + Tox *m, const Tox_Event_Friend_Message *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; + const Tox_Message_Type type = tox_event_friend_message_get_type(event); + const uint8_t *string = tox_event_friend_message_get_message(event); + const uint32_t length = tox_event_friend_message_get_message_length(event); + if (type != TOX_MESSAGE_TYPE_NORMAL) { ck_abort_msg("Bad type"); } @@ -38,7 +41,7 @@ static void message_callback( static void send_message_test(AutoTox *autotoxes) { - tox_callback_friend_message(autotoxes[1].tox, &message_callback); + tox_events_callback_friend_message(autotoxes[1].dispatch, &message_callback); const size_t msgs_len = tox_max_message_length() + 1; uint8_t *msgs = (uint8_t *)malloc(msgs_len); diff --git a/auto_tests/set_name_test.c b/auto_tests/set_name_test.c index 9ad7946c..e1802278 100644 --- a/auto_tests/set_name_test.c +++ b/auto_tests/set_name_test.c @@ -15,12 +15,16 @@ #define NICKNAME "Gentoo" -static void nickchange_callback(Tox *tox, uint32_t friendnumber, const uint8_t *string, size_t length, void *userdata) +static void nickchange_callback(Tox *tox, const Tox_Event_Friend_Name *event, void *user_data) { - ck_assert_msg(length == sizeof(NICKNAME), "Name length not correct: %d != %d", (uint16_t)length, + //const uint32_t friend_number = tox_event_friend_name_get_friend_number(event); + const uint8_t* name = tox_event_friend_name_get_name(event); + const uint32_t name_length = tox_event_friend_name_get_name_length(event); + + ck_assert_msg(name_length == sizeof(NICKNAME), "Name length not correct: %d != %d", (uint16_t)name_length, (uint16_t)sizeof(NICKNAME)); - ck_assert_msg(memcmp(string, NICKNAME, sizeof(NICKNAME)) == 0, "Name not correct: %s", (const char *)string); - bool *nickname_updated = (bool *)userdata; + ck_assert_msg(memcmp(name, NICKNAME, sizeof(NICKNAME)) == 0, "Name not correct: %s", (const char *)name); + bool *nickname_updated = (bool *)user_data; *nickname_updated = true; } @@ -34,6 +38,12 @@ static void test_set_name(void) ck_assert_msg(tox1 && tox2, "failed to create 2 tox instances"); + // we only run events on tox2 in this test case + tox_events_init(tox2); + + Tox_Dispatch *dispatch2 = tox_dispatch_new(nullptr); + ck_assert(dispatch2 != nullptr); + printf("tox1 adds tox2 as friend, tox2 adds tox1\n"); uint8_t public_key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_public_key(tox2, public_key); @@ -50,7 +60,13 @@ static void test_set_name(void) do { tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + //tox_dispatch_invoke(dispatch2, events, tox2, nullptr); + tox_events_free(events); + c_sleep(ITERATION_INTERVAL); } while (tox_self_get_connection_status(tox1) == TOX_CONNECTION_NONE || tox_self_get_connection_status(tox2) == TOX_CONNECTION_NONE); @@ -60,14 +76,20 @@ static void test_set_name(void) do { tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + //tox_dispatch_invoke(dispatch2, events, tox2, nullptr); + tox_events_free(events); + c_sleep(ITERATION_INTERVAL); } while (tox_friend_get_connection_status(tox1, 0, nullptr) != TOX_CONNECTION_UDP || tox_friend_get_connection_status(tox2, 0, nullptr) != TOX_CONNECTION_UDP); printf("tox clients connected took %lu seconds\n", (unsigned long)(time(nullptr) - con_time)); - tox_callback_friend_name(tox2, nickchange_callback); + tox_events_callback_friend_name(dispatch2, nickchange_callback); Tox_Err_Set_Info err_n; bool ret = tox_self_set_name(tox1, (const uint8_t *)NICKNAME, sizeof(NICKNAME), &err_n); ck_assert_msg(ret && err_n == TOX_ERR_SET_INFO_OK, "tox_self_set_name failed because %d\n", err_n); @@ -76,7 +98,13 @@ static void test_set_name(void) do { tox_iterate(tox1, nullptr); - tox_iterate(tox2, &nickname_updated); + + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch2, events, tox2, &nickname_updated); + tox_events_free(events); + c_sleep(ITERATION_INTERVAL); } while (!nickname_updated); @@ -87,6 +115,8 @@ static void test_set_name(void) printf("test_set_name succeeded, took %lu seconds\n", (unsigned long)(time(nullptr) - cur_time)); + tox_dispatch_free(dispatch2); + tox_kill(tox1); tox_kill(tox2); } diff --git a/auto_tests/set_status_message_test.c b/auto_tests/set_status_message_test.c index 435d2239..d63f773d 100644 --- a/auto_tests/set_status_message_test.c +++ b/auto_tests/set_status_message_test.c @@ -15,9 +15,13 @@ #define STATUS_MESSAGE "Installing Gentoo" -static void status_callback(Tox *tox, uint32_t friend_number, const uint8_t *message, size_t length, void *user_data) +static void status_callback(Tox *tox, const Tox_Event_Friend_Status_Message *event, void *user_data) { - ck_assert_msg(length == sizeof(STATUS_MESSAGE) && + //uint32_t friend_number = tox_event_friend_status_message_get_friend_number(event); + const uint8_t *message = tox_event_friend_status_message_get_message(event); + uint32_t message_length = tox_event_friend_status_message_get_message_length(event); + + ck_assert_msg(message_length == sizeof(STATUS_MESSAGE) && memcmp(message, STATUS_MESSAGE, sizeof(STATUS_MESSAGE)) == 0, "incorrect data in status callback"); bool *status_updated = (bool *)user_data; @@ -34,6 +38,12 @@ static void test_set_status_message(void) ck_assert_msg(tox1 && tox2, "failed to create 2 tox instances"); + // we only run events on tox2 in this test case + tox_events_init(tox2); + + Tox_Dispatch *dispatch2 = tox_dispatch_new(nullptr); + ck_assert(dispatch2 != nullptr); + printf("tox1 adds tox2 as friend, tox2 adds tox1\n"); uint8_t public_key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_public_key(tox2, public_key); @@ -50,7 +60,12 @@ static void test_set_status_message(void) do { tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + //tox_dispatch_invoke(dispatch2, events, tox2, nullptr); + tox_events_free(events); c_sleep(ITERATION_INTERVAL); } while (tox_self_get_connection_status(tox1) == TOX_CONNECTION_NONE || @@ -61,7 +76,12 @@ static void test_set_status_message(void) do { tox_iterate(tox1, nullptr); - tox_iterate(tox2, nullptr); + + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + //tox_dispatch_invoke(dispatch2, events, tox2, nullptr); + tox_events_free(events); c_sleep(ITERATION_INTERVAL); } while (tox_friend_get_connection_status(tox1, 0, nullptr) != TOX_CONNECTION_UDP || @@ -69,8 +89,8 @@ static void test_set_status_message(void) printf("tox clients connected took %lu seconds\n", (unsigned long)(time(nullptr) - con_time)); + tox_events_callback_friend_status_message(dispatch2, status_callback); Tox_Err_Set_Info err_n; - tox_callback_friend_status_message(tox2, status_callback); bool ret = tox_self_set_status_message(tox1, (const uint8_t *)STATUS_MESSAGE, sizeof(STATUS_MESSAGE), &err_n); ck_assert_msg(ret && err_n == TOX_ERR_SET_INFO_OK, "tox_self_set_status_message failed because %d\n", err_n); @@ -79,7 +99,13 @@ static void test_set_status_message(void) do { tox_iterate(tox1, nullptr); - tox_iterate(tox2, &status_updated); + + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(tox2, true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch2, events, tox2, &status_updated); + tox_events_free(events); + c_sleep(ITERATION_INTERVAL); } while (!status_updated); @@ -92,6 +118,8 @@ static void test_set_status_message(void) printf("test_set_status_message succeeded, took %lu seconds\n", (unsigned long)(time(nullptr) - cur_time)); + tox_dispatch_free(dispatch2); + tox_kill(tox1); tox_kill(tox2); } diff --git a/auto_tests/tox_dispatch_test.c b/auto_tests/tox_dispatch_test.c index 01294589..1cc2f7e0 100644 --- a/auto_tests/tox_dispatch_test.c +++ b/auto_tests/tox_dispatch_test.c @@ -169,22 +169,9 @@ static void test_tox_events(void) } } -static void fake_test_unpack(void) -{ - // TODO(Green-Sky): add proper unpack tests and/or implement ngc events - (void)tox_group_privacy_state_unpack; - (void)tox_group_privacy_state_unpack; - (void)tox_group_voice_state_unpack; - (void)tox_group_topic_lock_unpack; - (void)tox_group_join_fail_unpack; - (void)tox_group_mod_event_unpack; - (void)tox_group_exit_type_unpack; -} - int main(void) { setvbuf(stdout, nullptr, _IONBF, 0); test_tox_events(); - fake_test_unpack(); return 0; } diff --git a/auto_tests/tox_many_tcp_test.c b/auto_tests/tox_many_tcp_test.c index b6e34d79..56acc4bd 100644 --- a/auto_tests/tox_many_tcp_test.c +++ b/auto_tests/tox_many_tcp_test.c @@ -28,13 +28,17 @@ static bool enable_broken_tests = false; -static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) +static void accept_friend_request(Tox *m, const Tox_Event_Friend_Request *event, void *userdata) { + const uint8_t *public_key = tox_event_friend_request_get_public_key(event); + const uint8_t *message = tox_event_friend_request_get_message(event); + const uint32_t message_length = tox_event_friend_request_get_message_length(event); + if (*((uint32_t *)userdata) != 974536) { return; } - if (length == 7 && memcmp("Gentoo", data, 7) == 0) { + if (message_length == 7 && memcmp("Gentoo", message, 7) == 0) { tox_friend_add_norequest(m, public_key, nullptr); } } @@ -73,7 +77,7 @@ static void test_many_clients_tcp(void) continue; } ck_assert_msg(toxes[i] != nullptr, "Failed to create tox instances %u", i); - tox_callback_friend_request(toxes[i], accept_friend_request); + tox_events_init(toxes[i]); uint8_t dpk[TOX_PUBLIC_KEY_SIZE]; tox_self_get_dht_id(toxes[0], dpk); Tox_Err_Bootstrap error; @@ -85,6 +89,11 @@ static void test_many_clients_tcp(void) tox_options_free(opts); } + Tox_Dispatch *dispatch = tox_dispatch_new(nullptr); + ck_assert(dispatch != nullptr); + + tox_events_callback_friend_request(dispatch, accept_friend_request); + struct { uint16_t tox1; uint16_t tox2; @@ -131,12 +140,17 @@ loop_top: } for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) { - tox_iterate(toxes[i], &to_comp); + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(toxes[i], true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, toxes[i], &to_comp); + tox_events_free(events); } c_sleep(50); } + tox_dispatch_free(dispatch); for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) { tox_kill(toxes[i]); } @@ -167,7 +181,7 @@ static void test_many_clients_tcp_b(void) index[i] = i + 1; toxes[i] = tox_new_log(opts, nullptr, &index[i]); ck_assert_msg(toxes[i] != nullptr, "Failed to create tox instances %u", i); - tox_callback_friend_request(toxes[i], accept_friend_request); + tox_events_init(toxes[i]); uint8_t dpk[TOX_PUBLIC_KEY_SIZE]; tox_self_get_dht_id(toxes[(i % NUM_TCP_RELAYS)], dpk); ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, tcp_relay_port + (i % NUM_TCP_RELAYS), dpk, nullptr), @@ -179,6 +193,11 @@ static void test_many_clients_tcp_b(void) tox_options_free(opts); } + Tox_Dispatch *dispatch = tox_dispatch_new(nullptr); + ck_assert(dispatch != nullptr); + + tox_events_callback_friend_request(dispatch, accept_friend_request); + struct { uint16_t tox1; uint16_t tox2; @@ -232,12 +251,17 @@ loop_top: } for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) { - tox_iterate(toxes[i], &to_comp); + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(toxes[i], true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, toxes[i], &to_comp); + tox_events_free(events); } c_sleep(30); } + tox_dispatch_free(dispatch); for (uint32_t i = 0; i < NUM_TOXES_TCP; ++i) { tox_kill(toxes[i]); } diff --git a/auto_tests/tox_many_test.c b/auto_tests/tox_many_test.c index 8501b5c1..246f460c 100644 --- a/auto_tests/tox_many_test.c +++ b/auto_tests/tox_many_test.c @@ -13,9 +13,13 @@ #include "auto_test_support.h" #include "check_compat.h" -static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata) +static void accept_friend_request(Tox *m, const Tox_Event_Friend_Request *event, void *userdata) { - if (length == 7 && memcmp("Gentoo", data, 7) == 0) { + const uint8_t *public_key = tox_event_friend_request_get_public_key(event); + const uint8_t *message = tox_event_friend_request_get_message(event); + const uint32_t message_length = tox_event_friend_request_get_message_length(event); + + if (message_length == 7 && memcmp("Gentoo", message, 7) == 0) { tox_friend_add_norequest(m, public_key, nullptr); } } @@ -36,9 +40,14 @@ static void test_many_clients(void) index[i] = i + 1; toxes[i] = tox_new_log(nullptr, nullptr, &index[i]); ck_assert_msg(toxes[i] != nullptr, "failed to create tox instances %u", i); - tox_callback_friend_request(toxes[i], accept_friend_request); + tox_events_init(toxes[i]); } + Tox_Dispatch *dispatch = tox_dispatch_new(nullptr); + ck_assert(dispatch != nullptr); + + tox_events_callback_friend_request(dispatch, accept_friend_request); + struct { uint16_t tox1; uint16_t tox2; @@ -112,12 +121,17 @@ loop_top: } for (uint32_t i = 0; i < TCP_TEST_NUM_TOXES; ++i) { - tox_iterate(toxes[i], nullptr); + Tox_Err_Events_Iterate err = TOX_ERR_EVENTS_ITERATE_OK; + Tox_Events *events = tox_events_iterate(toxes[i], true, &err); + ck_assert(err == TOX_ERR_EVENTS_ITERATE_OK); + tox_dispatch_invoke(dispatch, events, toxes[i], nullptr); + tox_events_free(events); } c_sleep(50); } + tox_dispatch_free(dispatch); for (uint32_t i = 0; i < TCP_TEST_NUM_TOXES; ++i) { tox_kill(toxes[i]); } diff --git a/auto_tests/typing_test.c b/auto_tests/typing_test.c index 5c015987..5cf40219 100644 --- a/auto_tests/typing_test.c +++ b/auto_tests/typing_test.c @@ -17,10 +17,14 @@ typedef struct State { #include "auto_test_support.h" -static void typing_callback(Tox *m, uint32_t friendnumber, bool typing, void *user_data) +static void typing_callback(Tox *m, const Tox_Event_Friend_Typing *event, void *user_data) { const AutoTox *autotox = (AutoTox *)user_data; State *state = (State *)autotox->state; + + //const uint32_t friend_number = tox_event_friend_typing_get_friend_number(event); + const bool typing = tox_event_friend_typing_get_typing(event); + state->friend_is_typing = typing; } @@ -28,7 +32,7 @@ static void test_typing(AutoTox *autotoxes) { time_t cur_time = time(nullptr); - tox_callback_friend_typing(autotoxes[1].tox, &typing_callback); + tox_events_callback_friend_typing(autotoxes[1].dispatch, &typing_callback); tox_self_set_typing(autotoxes[0].tox, 0, true, nullptr); do {