tomato-testing/auto_tests/scenarios/scenario_toxav_basic_test.c

#include "framework/framework.h"
#include "../../toxav/toxav.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct {
    bool incoming;
    uint32_t state;
} CallState;

#define WAIT_UNTIL_AV(av, cond) do { \
    while(!(cond) && tox_scenario_is_running(self)) { \
        toxav_iterate(av); \
        tox_scenario_yield(self); \
    } \
} while(0)

static void on_call(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    CallState *state = (CallState *)tox_node_get_script_ctx(self);
    tox_node_log(self, "Received call from friend %u", friend_number);
    state->incoming = true;
}

static void on_call_state(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    CallState *cs = (CallState *)tox_node_get_script_ctx(self);
    tox_node_log(self, "Call state changed to %u", state);
    cs->state = state;
}

static void on_audio_receive(ToxAV *av, uint32_t friend_number, int16_t const *pcm, size_t sample_count,
                             uint8_t channels, uint32_t sampling_rate, void *user_data)
{
    (void)av;
    (void)friend_number;
    (void)pcm;
    (void)sample_count;
    (void)channels;
    (void)sampling_rate;
    (void)user_data;
}

static void on_video_receive(ToxAV *av, uint32_t friend_number, uint16_t width, uint16_t height,
                             uint8_t const *y, uint8_t const *u, uint8_t const *v,
                             int32_t ystride, int32_t ustride, int32_t vstride, void *user_data)
{
    (void)av;
    (void)friend_number;
    (void)width;
    (void)height;
    (void)y;
    (void)u;
    (void)v;
    (void)ystride;
    (void)ustride;
    (void)vstride;
    (void)user_data;
}

static void alice_script(ToxNode *self, void *ctx)
{
    CallState *state = (CallState *)ctx;
    Tox *tox = tox_node_get_tox(self);
    Toxav_Err_New av_err;
    ToxAV *av = toxav_new(tox, &av_err);
    ck_assert(av_err == TOXAV_ERR_NEW_OK);

    toxav_callback_call(av, on_call, self);
    toxav_callback_call_state(av, on_call_state, self);
    toxav_callback_audio_receive_frame(av, on_audio_receive, self);
    toxav_callback_video_receive_frame(av, on_video_receive, self);

    WAIT_UNTIL(tox_node_is_self_connected(self));
    WAIT_UNTIL(tox_node_is_friend_connected(self, 0));

    // 1. Regular AV call - Alice calls, Bob answers, Bob hangs up
    tox_node_log(self, "--- Starting Regular AV Call ---");
    state->state = 0;
    Toxav_Err_Call call_err;
    toxav_call(av, 0, 48, 4000, &call_err);
    ck_assert(call_err == TOXAV_ERR_CALL_OK);

    WAIT_UNTIL_AV(av, state->state & TOXAV_FRIEND_CALL_STATE_FINISHED);
    tox_node_log(self, "Regular AV Call finished (state=%u)", state->state);

    tox_scenario_barrier_wait(self);

    // 2. Reject flow - Alice calls, Bob rejects
    tox_node_log(self, "--- Starting Reject Flow ---");
    state->state = 0;
    toxav_call(av, 0, 48, 0, &call_err);
    ck_assert(call_err == TOXAV_ERR_CALL_OK);

    WAIT_UNTIL_AV(av, state->state & TOXAV_FRIEND_CALL_STATE_FINISHED);
    tox_node_log(self, "Reject Flow finished");

    tox_scenario_barrier_wait(self);

    // 3. Cancel flow - Alice calls, Alice cancels
    tox_node_log(self, "--- Starting Cancel Flow ---");
    state->state = 0;
    toxav_call(av, 0, 48, 0, &call_err);
    ck_assert(call_err == TOXAV_ERR_CALL_OK);

    // Wait for Bob to see it ringing
    tox_scenario_barrier_wait(self);

    tox_node_log(self, "Alice: Canceling call...");
    Toxav_Err_Call_Control cc_err;
    toxav_call_control(av, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
    ck_assert(cc_err == TOXAV_ERR_CALL_CONTROL_OK);

    // Alice doesn't receive FINISHED state when SHE cancels
    tox_node_log(self, "Alice: Cancel Flow finished");

    tox_scenario_barrier_wait(self);

    toxav_kill(av);
}

static void bob_script(ToxNode *self, void *ctx)
{
    CallState *state = (CallState *)ctx;
    Tox *tox = tox_node_get_tox(self);
    Toxav_Err_New av_err;
    ToxAV *av = toxav_new(tox, &av_err);
    ck_assert(av_err == TOXAV_ERR_NEW_OK);

    toxav_callback_call(av, on_call, self);
    toxav_callback_call_state(av, on_call_state, self);
    toxav_callback_audio_receive_frame(av, on_audio_receive, self);
    toxav_callback_video_receive_frame(av, on_video_receive, self);

    WAIT_UNTIL(tox_node_is_self_connected(self));
    WAIT_UNTIL(tox_node_is_friend_connected(self, 0));

    // 1. Regular AV call - Bob answers, then hangs up
    WAIT_UNTIL_AV(av, state->incoming);
    state->incoming = false;
    Toxav_Err_Answer answer_err;
    toxav_answer(av, 0, 48, 4000, &answer_err);
    ck_assert(answer_err == TOXAV_ERR_ANSWER_OK);

    // Wait a bit and hang up
    for (int i = 0; i < 10; i++) {
        toxav_iterate(av);
        tox_scenario_yield(self);
    }
    tox_node_log(self, "Bob: Hanging up...");
    Toxav_Err_Call_Control cc_err;
    toxav_call_control(av, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
    ck_assert(cc_err == TOXAV_ERR_CALL_CONTROL_OK);

    tox_scenario_barrier_wait(self);

    // 2. Reject flow - Bob rejects
    WAIT_UNTIL_AV(av, state->incoming);
    state->incoming = false;
    tox_node_log(self, "Bob: Rejecting call...");
    toxav_call_control(av, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
    ck_assert(cc_err == TOXAV_ERR_CALL_CONTROL_OK);

    tox_scenario_barrier_wait(self);

    // 3. Cancel flow - Alice cancels
    WAIT_UNTIL_AV(av, state->incoming);
    state->incoming = false;
    tox_scenario_barrier_wait(self); // Alice will now cancel

    WAIT_UNTIL_AV(av, state->state & TOXAV_FRIEND_CALL_STATE_FINISHED);
    tox_node_log(self, "Bob: Cancel Flow finished (Alice canceled)");

    tox_scenario_barrier_wait(self);

    toxav_kill(av);
}

int main(int argc, char *argv[])
{
    ToxScenario *s = tox_scenario_new(argc, argv, 60000);

    CallState alice_state = {0};
    CallState bob_state = {0};

    Tox_Options *opts = tox_options_new(nullptr);
    tox_options_set_ipv6_enabled(opts, false);
    tox_options_set_local_discovery_enabled(opts, false);

    ToxNode *alice = tox_scenario_add_node_ex(s, "Alice", alice_script, &alice_state, sizeof(CallState), opts);
    ToxNode *bob = tox_scenario_add_node_ex(s, "Bob", bob_script, &bob_state, sizeof(CallState), opts);

    tox_options_free(opts);

    tox_node_bootstrap(bob, alice);
    tox_node_friend_add(alice, bob);
    tox_node_friend_add(bob, alice);

    ToxScenarioStatus res = tox_scenario_run(s);
    tox_scenario_free(s);
    return (res == TOX_SCENARIO_DONE) ? 0 : 1;
}