mirror of
https://github.com/irungentoo/toxcore.git
synced 2024-03-22 13:30:51 +08:00
refactor: Migrate auto_tests to new events API.
Co-authored-by: Green Sky <green@g-s.xyz>
This commit is contained in:
parent
bdd42b5452
commit
e07248debb
|
@ -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",
|
||||
],
|
||||
)
|
||||
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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");
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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 */
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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");
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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]);
|
||||
}
|
||||
|
|
|
@ -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]);
|
||||
}
|
||||
|
|
|
@ -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 {
|
||||
|
|
Loading…
Reference in New Issue
Block a user