tomato/auto_tests/scenarios/scenario_group_message_test.c

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

#define PEER0_NICK "Thomas"
#define PEER0_NICK_LEN (sizeof(PEER0_NICK) - 1)
#define PEER1_NICK "Winslow"
#define PEER1_NICK_LEN (sizeof(PEER1_NICK) - 1)
#define TEST_GROUP_NAME "Utah Data Center"
#define TEST_GROUP_NAME_LEN (sizeof(TEST_GROUP_NAME) - 1)
#define TEST_MESSAGE "Where is it I've read that someone condemned to death says or thinks..."
#define TEST_MESSAGE_LEN (sizeof(TEST_MESSAGE) - 1)
#define TEST_PRIVATE_MESSAGE "Don't spill yer beans"
#define TEST_PRIVATE_MESSAGE_LEN (sizeof(TEST_PRIVATE_MESSAGE) - 1)
#define TEST_CUSTOM_PACKET "Why'd ya spill yer beans?"
#define TEST_CUSTOM_PACKET_LEN (sizeof(TEST_CUSTOM_PACKET) - 1)
#define TEST_CUSTOM_PRIVATE_PACKET "This is a custom private packet. Enjoy."
#define TEST_CUSTOM_PRIVATE_PACKET_LEN (sizeof(TEST_CUSTOM_PRIVATE_PACKET) - 1)
#define MAX_NUM_MESSAGES_LOSSLESS_TEST 100

typedef struct {
    uint32_t group_number;
    uint32_t peer_id;
    bool peer_joined;
    bool message_received;
    bool private_message_received;
    size_t custom_packets_received;
    size_t custom_private_packets_received;
    int32_t last_msg_recv;
    bool lossless_done;
} GroupState;

static uint16_t get_message_checksum(const uint8_t *message, uint16_t length)
{
    uint16_t sum = 0;
    for (size_t i = 0; i < length; ++i) {
        sum += message[i];
    }
    return sum;
}

static void on_group_invite(const Tox_Event_Group_Invite *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    GroupState *state = (GroupState *)tox_node_get_script_ctx(self);
    Tox_Err_Group_Invite_Accept err;
    state->group_number = tox_group_invite_accept(tox_node_get_tox(self),
                          tox_event_group_invite_get_friend_number(event),
                          tox_event_group_invite_get_invite_data(event),
                          tox_event_group_invite_get_invite_data_length(event),
                          (const uint8_t *)PEER1_NICK, PEER1_NICK_LEN, nullptr, 0, &err);
    tox_node_log(self, "Accepted group invite, group %u", state->group_number);
}

static void on_group_peer_join(const Tox_Event_Group_Peer_Join *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    GroupState *state = (GroupState *)tox_node_get_script_ctx(self);
    state->peer_joined = true;
    state->peer_id = tox_event_group_peer_join_get_peer_id(event);
    tox_node_log(self, "Peer %u joined group", state->peer_id);
}

static void on_group_message(const Tox_Event_Group_Message *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    GroupState *state = (GroupState *)tox_node_get_script_ctx(self);
    const uint8_t *msg = tox_event_group_message_get_message(event);
    size_t len = tox_event_group_message_get_message_length(event);

    if (len == TEST_MESSAGE_LEN && memcmp(msg, TEST_MESSAGE, len) == 0) {
        state->message_received = true;
        tox_node_log(self, "Received group message");
    } else if (len >= 4) {
        uint16_t start, checksum;
        memcpy(&start, msg, 2);
        memcpy(&checksum, msg + 2, 2);
        if (checksum == get_message_checksum(msg + 4, len - 4)) {
            state->last_msg_recv = start;
            if (start == MAX_NUM_MESSAGES_LOSSLESS_TEST) {
                state->lossless_done = true;
            }
        }
    }
}

static void on_group_private_message(const Tox_Event_Group_Private_Message *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    GroupState *state = (GroupState *)tox_node_get_script_ctx(self);
    const uint8_t *msg = tox_event_group_private_message_get_message(event);
    size_t len = tox_event_group_private_message_get_message_length(event);

    if (len == TEST_PRIVATE_MESSAGE_LEN && memcmp(msg, TEST_PRIVATE_MESSAGE, len) == 0) {
        state->private_message_received = true;
        tox_node_log(self, "Received private group message");
    }
}

static void on_group_custom_packet(const Tox_Event_Group_Custom_Packet *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    GroupState *state = (GroupState *)tox_node_get_script_ctx(self);
    state->custom_packets_received++;
    tox_node_log(self, "Received custom packet %zu", state->custom_packets_received);
}

static void on_group_custom_private_packet(const Tox_Event_Group_Custom_Private_Packet *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    GroupState *state = (GroupState *)tox_node_get_script_ctx(self);
    state->custom_private_packets_received++;
    tox_node_log(self, "Received custom private packet %zu", state->custom_private_packets_received);
}

static void peer0_script(ToxNode *self, void *ctx)
{
    GroupState *state = (GroupState *)ctx;
    Tox *tox = tox_node_get_tox(self);
    Tox_Dispatch *dispatch = tox_node_get_dispatch(self);

    tox_events_callback_group_peer_join(dispatch, on_group_peer_join);
    tox_events_callback_group_message(dispatch, on_group_message);
    tox_events_callback_group_private_message(dispatch, on_group_private_message);
    tox_events_callback_group_custom_packet(dispatch, on_group_custom_packet);
    tox_events_callback_group_custom_private_packet(dispatch, on_group_custom_private_packet);

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

    state->group_number = tox_group_new(tox, TOX_GROUP_PRIVACY_STATE_PRIVATE, (const uint8_t *)TEST_GROUP_NAME, TEST_GROUP_NAME_LEN, (const uint8_t *)PEER0_NICK, PEER0_NICK_LEN, nullptr);
    tox_group_invite_friend(tox, state->group_number, 0, nullptr);
    tox_node_log(self, "Created group and invited friend");

    WAIT_UNTIL(state->peer_joined);
    WAIT_UNTIL(state->message_received);
    WAIT_UNTIL(state->private_message_received);
    WAIT_UNTIL(state->custom_packets_received >= 2);
    WAIT_UNTIL(state->custom_private_packets_received >= 2);

    // Lossless test
    uint8_t m[TOX_GROUP_MAX_MESSAGE_LENGTH];
    for (uint16_t i = 0; i <= MAX_NUM_MESSAGES_LOSSLESS_TEST; ++i) {
        uint32_t size = 4 + (rand() % 100);
        memcpy(m, &i, 2);
        for (size_t j = 4; j < size; ++j) {
            uint32_t val = rand() % 256;
            m[j] = (uint8_t)val;
        }
        uint16_t checksum = get_message_checksum(m + 4, (uint16_t)(size - 4));
        memcpy(m + 2, &checksum, 2);
        tox_group_send_message(tox, state->group_number, TOX_MESSAGE_TYPE_NORMAL, m, size, nullptr);
        if (i % 10 == 0) {
            tox_scenario_yield(self);
        }
    }

    tox_node_log(self, "Done");
}

static void peer1_script(ToxNode *self, void *ctx)
{
    const GroupState *state = (const GroupState *)ctx;
    const Tox *tox = tox_node_get_tox(self);
    Tox_Dispatch *dispatch = tox_node_get_dispatch(self);

    tox_events_callback_group_invite(dispatch, on_group_invite);
    tox_events_callback_group_peer_join(dispatch, on_group_peer_join);
    tox_events_callback_group_message(dispatch, on_group_message);

    WAIT_UNTIL(tox_node_is_self_connected(self));
    WAIT_UNTIL(state->peer_joined);

    tox_group_send_message(tox, state->group_number, TOX_MESSAGE_TYPE_NORMAL, (const uint8_t *)TEST_MESSAGE, TEST_MESSAGE_LEN, nullptr);
    tox_group_send_private_message(tox, state->group_number, state->peer_id, TOX_MESSAGE_TYPE_ACTION, (const uint8_t *)TEST_PRIVATE_MESSAGE, TEST_PRIVATE_MESSAGE_LEN, nullptr);

    tox_group_send_custom_packet(tox, state->group_number, true, (const uint8_t *)TEST_CUSTOM_PACKET, TEST_CUSTOM_PACKET_LEN, nullptr);
    tox_group_send_custom_packet(tox, state->group_number, false, (const uint8_t *)TEST_CUSTOM_PACKET, TEST_CUSTOM_PACKET_LEN, nullptr);

    tox_group_send_custom_private_packet(tox, state->group_number, state->peer_id, true, (const uint8_t *)TEST_CUSTOM_PRIVATE_PACKET, TEST_CUSTOM_PRIVATE_PACKET_LEN, nullptr);
    tox_group_send_custom_private_packet(tox, state->group_number, state->peer_id, false, (const uint8_t *)TEST_CUSTOM_PRIVATE_PACKET, TEST_CUSTOM_PRIVATE_PACKET_LEN, nullptr);

    WAIT_UNTIL(state->lossless_done);
    tox_node_log(self, "Done");
}

int main(int argc, char *argv[])
{
    ToxScenario *s = tox_scenario_new(argc, argv, 300000);
    GroupState s0 = { .last_msg_recv = -1 }, s1 = { .last_msg_recv = -1 };

    ToxNode *n0 = tox_scenario_add_node(s, "Peer0", peer0_script, &s0, sizeof(GroupState));
    ToxNode *n1 = tox_scenario_add_node(s, "Peer1", peer1_script, &s1, sizeof(GroupState));

    tox_node_friend_add(n0, n1);
    tox_node_friend_add(n1, n0);
    tox_node_bootstrap(n0, n1);
    tox_node_bootstrap(n1, n0);

    ToxScenarioStatus res = tox_scenario_run(s);
    if (res != TOX_SCENARIO_DONE) {
        tox_scenario_log(s, "Test failed with status %u", res);
        return 1;
    }

    tox_scenario_free(s);
    return 0;
}

#undef PEER0_NICK
#undef PEER0_NICK_LEN
#undef PEER1_NICK
#undef PEER1_NICK_LEN