// test_socks_client.c — SOCKS5-клиент: dial через mock-прокси (no-auth, auth, reject)
#include "socks_client.h"
#include "../lib/u_async.h"
#include "../lib/debug_config.h"
#include "../lib/mem.h"
#include "../lib/socket_compat.h"
#include "../lib/platform_compat.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

static int test_failed = 0;
#define TASSERT(cond) do { \
    if (!(cond)) { DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "  FAIL: %s", #cond); test_failed = 1; return test_failed; } \
} while(0)

#define MOCK_PORT 24771

enum { MOCK_NOAUTH = 0, MOCK_AUTH = 1, MOCK_REJECT = 2 };

struct mock {
    struct UASYNC *ua;
    socket_t listen_sock;
    void *listen_id;
    socket_t conn_sock;
    void *conn_id;
    uint8_t mode;
    uint8_t state;          // 0=greeting, 1=auth, 2=request, 3=relay
    uint8_t buf[512];
    size_t  buf_len;
    int     got_connect;
};

static void mock_send(struct mock *m, const uint8_t *d, size_t n) {
    ssize_t s = send(m->conn_sock, d, n, 0);
    (void)s;
}

static void mock_process(struct mock *m) {
    for (;;) {
        if (m->state == 0) {                       // greeting
            if (m->buf_len < 3) return;
            uint8_t nm = m->buf[1];
            if (m->buf_len < (size_t)(2 + nm)) return;
            if (m->mode == MOCK_AUTH) { uint8_t r[] = {0x05, 0x02}; mock_send(m, r, 2); m->state = 1; }
            else { uint8_t r[] = {0x05, 0x00}; mock_send(m, r, 2); m->state = 2; }
            size_t c = 2 + nm; memmove(m->buf, m->buf + c, m->buf_len - c); m->buf_len -= c;
            continue;
        }
        if (m->state == 1) {                       // auth (RFC1929)
            if (m->buf_len < 2) return;
            size_t ulen = m->buf[1];
            if (m->buf_len < 2 + ulen + 1) return;
            size_t plen = m->buf[2 + ulen];
            size_t total = 2 + ulen + 1 + plen;
            if (m->buf_len < total) return;
            uint8_t r[] = {0x01, 0x00}; mock_send(m, r, 2); m->state = 2;
            memmove(m->buf, m->buf + total, m->buf_len - total); m->buf_len -= total;
            continue;
        }
        if (m->state == 2) {                       // CONNECT request
            if (m->buf_len < 4) return;
            uint8_t atyp = m->buf[3];
            size_t need = 4;
            if (atyp == 0x01) need += 6;
            else if (atyp == 0x03) { if (m->buf_len < 5) return; need += 1 + (size_t)m->buf[4] + 2; }
            else if (atyp == 0x04) need += 18;
            else return;
            if (m->buf_len < need) return;
            if (m->mode == MOCK_REJECT) { uint8_t r[] = {0x05, 0x05, 0x00, 0x01, 0,0,0,0, 0,0}; mock_send(m, r, 10); }
            else { uint8_t r[] = {0x05, 0x00, 0x00, 0x01, 0,0,0,0, 0,0}; mock_send(m, r, 10); m->got_connect = 1; }
            m->state = 3;
            memmove(m->buf, m->buf + need, m->buf_len - need); m->buf_len -= need;
            continue;
        }
        while (m->buf_len > 0) {                   // relay: echo
            mock_send(m, m->buf, 1);
            memmove(m->buf, m->buf + 1, m->buf_len - 1); m->buf_len -= 1;
        }
        return;
    }
}

static void mock_read_cb(socket_t sock, void *arg) {
    struct mock *m = (struct mock *)arg;
    (void)sock;
    uint8_t tmp[512];
    ssize_t n = recv(m->conn_sock, tmp, sizeof(tmp), 0);
    if (n <= 0) return;
    memcpy(m->buf + m->buf_len, tmp, (size_t)n);
    m->buf_len += (size_t)n;
    mock_process(m);
}

static void mock_accept_cb(socket_t sock, void *arg) {
    struct mock *m = (struct mock *)arg;
    struct sockaddr_storage sa; socklen_t sl = sizeof(sa);
    m->conn_sock = accept(sock, (struct sockaddr *)&sa, &sl);
    if (m->conn_sock == SOCKET_INVALID) return;
    socket_set_nonblocking(m->conn_sock);
    m->conn_id = uasync_add_socket_t(m->ua, m->conn_sock, mock_read_cb, NULL, NULL, "mock_conn", m);
}

static int mock_start(struct mock *m, struct UASYNC *ua, int port, uint8_t mode) {
    memset(m, 0, sizeof(*m));
    m->ua = ua; m->mode = mode; m->conn_sock = SOCKET_INVALID;
    m->listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (m->listen_sock == SOCKET_INVALID) return -1;
    socket_set_reuseaddr(m->listen_sock, 1);
    socket_set_nonblocking(m->listen_sock);
    struct sockaddr_in a; memset(&a, 0, sizeof(a));
    a.sin_family = AF_INET; a.sin_addr.s_addr = htonl(INADDR_LOOPBACK); a.sin_port = htons((uint16_t)port);
    if (bind(m->listen_sock, (struct sockaddr *)&a, sizeof(a)) < 0) return -1;
    if (listen(m->listen_sock, 8) < 0) return -1;
    m->listen_id = uasync_add_socket_t(ua, m->listen_sock, mock_accept_cb, NULL, NULL, "mock_listen", m);
    return m->listen_id ? 0 : -1;
}

static void mock_stop(struct mock *m) {
    if (m->conn_id) uasync_remove_socket_t(m->ua, m->conn_sock);
    if (m->conn_sock != SOCKET_INVALID) socket_close_wrapper(m->conn_sock);
    if (m->listen_id) uasync_remove_socket_t(m->ua, m->listen_sock);
    socket_close_wrapper(m->listen_sock);
}

// ── Mock SOCKS5 UDP ASSOCIATE: TCP-control (greeting+associate) + UDP-релей с эхом ──

struct udp_mock {
    struct UASYNC *ua;
    socket_t listen_sock;      // TCP-control listener
    void *listen_id;
    socket_t ctrl_sock;        // принятый control-коннект
    void *ctrl_id;
    uint8_t cbuf[512];
    size_t cblen;
    uint8_t cstate;            // 0=greeting, 1=associate
    socket_t udp_sock;         // UDP-релей
    void *udp_id;
    uint16_t udp_port;
    int got_associate;
    int echo_count;
    uint8_t last_payload[256];
    size_t last_payload_len;
    struct sockaddr_storage last_peer;
};

static void umock_ctrl_process(struct udp_mock *m) {
    for (;;) {
        if (m->cstate == 0) {   // greeting
            if (m->cblen < 3) return;
            uint8_t nm = m->cbuf[1];
            if (m->cblen < (size_t)(2 + nm)) return;
            uint8_t r[] = {0x05, 0x00};   // no-auth
            send(m->ctrl_sock, r, 2, 0);
            m->cstate = 1;
            size_t c = 2 + nm; memmove(m->cbuf, m->cbuf + c, m->cblen - c); m->cblen -= c;
            continue;
        }
        if (m->cstate == 1) {   // UDP ASSOCIATE request
            if (m->cblen < 4) return;
            uint8_t atyp = m->cbuf[3];
            size_t need = 4;
            if (atyp == 0x01) need += 6;
            else if (atyp == 0x04) need += 18;
            else return;
            if (m->cblen < need) return;
            uint8_t r[10];
            r[0] = 0x05; r[1] = 0x00; r[2] = 0x00; r[3] = 0x01;
            uint32_t ip = htonl(INADDR_LOOPBACK);
            memcpy(r + 4, &ip, 4);
            uint16_t port = htons(m->udp_port);
            memcpy(r + 8, &port, 2);
            send(m->ctrl_sock, r, 10, 0);
            m->got_associate++;
            m->cstate = 2;
            memmove(m->cbuf, m->cbuf + need, m->cblen - need); m->cblen -= need;
            continue;
        }
        m->cblen = 0;   // idle
        return;
    }
}

static void umock_ctrl_read_cb(socket_t sock, void *arg) {
    struct udp_mock *m = (struct udp_mock *)arg;
    (void)sock;
    uint8_t tmp[512];
    ssize_t n = recv(m->ctrl_sock, tmp, sizeof(tmp), 0);
    if (n <= 0) return;
    memcpy(m->cbuf + m->cblen, tmp, (size_t)n); m->cblen += (size_t)n;
    umock_ctrl_process(m);
}

static void umock_accept_cb(socket_t sock, void *arg) {
    struct udp_mock *m = (struct udp_mock *)arg;
    struct sockaddr_storage sa; socklen_t sl = sizeof(sa);
    socket_t cs = accept(sock, (struct sockaddr *)&sa, &sl);
    if (cs == SOCKET_INVALID) return;
    socket_set_nonblocking(cs);
    m->ctrl_sock = cs;
    m->cstate = 0;
    m->cblen = 0;
    m->ctrl_id = uasync_add_socket_t(m->ua, cs, umock_ctrl_read_cb, NULL, NULL, "umock_ctrl", m);
}

// Релей: принять обёрнутую датаграмму, сохранить dst (peer) + payload, отправить эхо с SRC=peer.
static void umock_udp_read_cb(socket_t sock, void *arg) {
    struct udp_mock *m = (struct udp_mock *)arg;
    (void)sock;
    uint8_t raw[2048];
    struct sockaddr_storage from; socklen_t fl = sizeof(from);
    ssize_t n = recvfrom(m->udp_sock, raw, sizeof(raw), 0, (struct sockaddr *)&from, &fl);
    if (n < 10 || raw[0] || raw[1] || raw[2]) return;
    uint8_t atyp = raw[3];
    size_t hlen;
    if (atyp == 0x01) hlen = 10;
    else if (atyp == 0x04) hlen = 22;
    else return;
    if ((size_t)n < hlen) return;

    memset(&m->last_peer, 0, sizeof(m->last_peer));
    if (atyp == 0x01) {
        struct sockaddr_in *sa = (struct sockaddr_in *)&m->last_peer;
        sa->sin_family = AF_INET;
        memcpy(&sa->sin_addr.s_addr, raw + 4, 4);
        memcpy(&sa->sin_port, raw + 8, 2);
    } else {
        struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&m->last_peer;
        sa6->sin6_family = AF_INET6;
        memcpy(&sa6->sin6_addr, raw + 4, 16);
        memcpy(&sa6->sin6_port, raw + 20, 2);
    }
    size_t plen = (size_t)n - hlen;
    memcpy(m->last_payload, raw + hlen, plen);
    m->last_payload_len = plen;
    m->echo_count++;

    uint8_t out[2048];
    size_t o = 0;
    out[o++] = 0; out[o++] = 0; out[o++] = 0;
    if (m->last_peer.ss_family == AF_INET) {
        struct sockaddr_in *sa = (struct sockaddr_in *)&m->last_peer;
        out[o++] = 0x01;
        memcpy(out + o, &sa->sin_addr.s_addr, 4); o += 4;
        memcpy(out + o, &sa->sin_port, 2); o += 2;
    } else {
        struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&m->last_peer;
        out[o++] = 0x04;
        memcpy(out + o, &sa6->sin6_addr, 16); o += 16;
        memcpy(out + o, &sa6->sin6_port, 2); o += 2;
    }
    memcpy(out + o, m->last_payload, plen); o += plen;
    sendto(m->udp_sock, out, o, 0, (struct sockaddr *)&from, fl);
}

static int umock_start(struct udp_mock *m, struct UASYNC *ua, int listen_port) {
    memset(m, 0, sizeof(*m));
    m->ua = ua;
    m->ctrl_sock = SOCKET_INVALID;
    m->listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (m->listen_sock == SOCKET_INVALID) return -1;
    socket_set_reuseaddr(m->listen_sock, 1);
    socket_set_nonblocking(m->listen_sock);
    struct sockaddr_in a; memset(&a, 0, sizeof(a));
    a.sin_family = AF_INET; a.sin_addr.s_addr = htonl(INADDR_LOOPBACK); a.sin_port = htons((uint16_t)listen_port);
    if (bind(m->listen_sock, (struct sockaddr *)&a, sizeof(a)) < 0) return -1;
    if (listen(m->listen_sock, 8) < 0) return -1;
    m->listen_id = uasync_add_socket_t(ua, m->listen_sock, umock_accept_cb, NULL, NULL, "umock_listen", m);

    m->udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (m->udp_sock == SOCKET_INVALID) return -1;
    socket_set_nonblocking(m->udp_sock);
    struct sockaddr_in ua_addr; memset(&ua_addr, 0, sizeof(ua_addr));
    ua_addr.sin_family = AF_INET; ua_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    if (bind(m->udp_sock, (struct sockaddr *)&ua_addr, sizeof(ua_addr)) < 0) return -1;
    struct sockaddr_in got; socklen_t gl = sizeof(got);
    getsockname(m->udp_sock, (struct sockaddr *)&got, &gl);
    m->udp_port = ntohs(got.sin_port);
    m->udp_id = uasync_add_socket_t(ua, m->udp_sock, umock_udp_read_cb, NULL, NULL, "umock_udp", m);
    return (m->listen_id && m->udp_id) ? 0 : -1;
}

static void umock_stop(struct udp_mock *m) {
    if (m->ctrl_id) uasync_remove_socket_t(m->ua, m->ctrl_sock);
    if (m->ctrl_sock != SOCKET_INVALID) socket_close_wrapper(m->ctrl_sock);
    if (m->listen_id) uasync_remove_socket_t(m->ua, m->listen_sock);
    socket_close_wrapper(m->listen_sock);
    if (m->udp_id) uasync_remove_socket_t(m->ua, m->udp_sock);
    socket_close_wrapper(m->udp_sock);
}

static int g_su_ready = 0, g_su_err = 0;
static void su_ready_cb(struct socks_udp *s, int err, void *arg) {
    (void)s; (void)arg;
    g_su_ready++;
    g_su_err = err;
}

static socket_t g_sock = SOCKET_INVALID;
static int g_err = 0;
static int g_done = 0;
static void dial_cb(socket_t sock, int err, void *arg) {
    (void)arg;
    g_sock = sock; g_err = err; g_done = 1;
}
static void read_echo_cb(socket_t sock, void *arg) {
    int *got = (int *)arg;
    uint8_t b;
    if (recv(sock, &b, 1, 0) == 1) *got = b;
}

// Запустить dial, дождаться результата, вернуть 0 (успех) или err.
static int run_dial(struct UASYNC *ua, struct socks_cfg *cfg, const char *target, uint16_t tport) {
    g_done = 0; g_sock = SOCKET_INVALID; g_err = 0;
    void *h = socks_dial(ua, cfg, target, tport, dial_cb, NULL, 0);
    if (!h) return -1;
    int ticks = 0;
    while (!g_done && ticks < 20000) { uasync_poll(ua, 10); ticks++; }
    if (!g_done) return -1;
    return g_err;
}

static int test1_noauth_v4(void) {
    struct UASYNC *ua = uasync_create(); TASSERT(ua);
    struct mock m;
    TASSERT(mock_start(&m, ua, MOCK_PORT, MOCK_NOAUTH) == 0);
    struct socks_cfg cfg; memset(&cfg, 0, sizeof(cfg));
    strcpy(cfg.host, "127.0.0.1"); cfg.port = MOCK_PORT;

    TASSERT(run_dial(ua, &cfg, "127.0.0.1", 12345) == 0);
    TASSERT(g_sock != SOCKET_INVALID);
    TASSERT(m.got_connect == 1);

    int got = 0;
    void *sid = uasync_add_socket_t(ua, g_sock, read_echo_cb, NULL, NULL, "echo", &got);
    TASSERT(sid != NULL);
    uint8_t x = 'A';
    send(g_sock, &x, 1, 0);
    int ticks = 0;
    while (got == 0 && ticks < 5000) { uasync_poll(ua, 10); ticks++; }
    TASSERT(got == 'A');

    uasync_remove_socket_t(ua, g_sock);
    socket_close_wrapper(g_sock);
    mock_stop(&m);
    uasync_destroy(ua, 1);
    return 0;
}

static int test2_auth_domain(void) {
    struct UASYNC *ua = uasync_create(); TASSERT(ua);
    struct mock m;
    TASSERT(mock_start(&m, ua, MOCK_PORT, MOCK_AUTH) == 0);
    struct socks_cfg cfg; memset(&cfg, 0, sizeof(cfg));
    strcpy(cfg.host, "127.0.0.1"); cfg.port = MOCK_PORT;
    strcpy(cfg.user, "alice"); strcpy(cfg.pass, "secret");

    TASSERT(run_dial(ua, &cfg, "example.com", 443) == 0);
    TASSERT(g_sock != SOCKET_INVALID);
    TASSERT(m.got_connect == 1);

    socket_close_wrapper(g_sock);
    mock_stop(&m);
    uasync_destroy(ua, 1);
    return 0;
}

static int test3_reject(void) {
    struct UASYNC *ua = uasync_create(); TASSERT(ua);
    struct mock m;
    TASSERT(mock_start(&m, ua, MOCK_PORT, MOCK_REJECT) == 0);
    struct socks_cfg cfg; memset(&cfg, 0, sizeof(cfg));
    strcpy(cfg.host, "127.0.0.1"); cfg.port = MOCK_PORT;

    int err = run_dial(ua, &cfg, "127.0.0.1", 12345);
    TASSERT(err != 0);
    TASSERT(g_sock == SOCKET_INVALID);

    mock_stop(&m);
    uasync_destroy(ua, 1);
    return 0;
}

static int test4_udp_associate(void) {
    struct UASYNC *ua = uasync_create(); TASSERT(ua);
    struct udp_mock m;
    TASSERT(umock_start(&m, ua, MOCK_PORT) == 0);

    socket_t lfd = socket(AF_INET, SOCK_DGRAM, 0);
    TASSERT(lfd != SOCKET_INVALID);
    socket_set_nonblocking(lfd);
    struct sockaddr_in lb; memset(&lb, 0, sizeof(lb));
    lb.sin_family = AF_INET; lb.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    TASSERT(bind(lfd, (struct sockaddr *)&lb, sizeof(lb)) == 0);

    struct socks_cfg cfg; memset(&cfg, 0, sizeof(cfg));
    strcpy(cfg.host, "127.0.0.1"); cfg.port = MOCK_PORT;

    g_su_ready = 0; g_su_err = 0;
    struct socks_udp *su = socks_udp_associate(ua, &cfg, lfd, su_ready_cb, NULL);
    TASSERT(su != NULL);

    int ticks = 0;
    while (g_su_ready == 0 && ticks < 20000) { uasync_poll(ua, 10); ticks++; }
    TASSERT(g_su_ready == 1);
    TASSERT(g_su_err == 0);
    TASSERT(m.got_associate == 1);

    struct sockaddr_storage peer; memset(&peer, 0, sizeof(peer));
    struct sockaddr_in *p = (struct sockaddr_in *)&peer;
    p->sin_family = AF_INET; p->sin_addr.s_addr = htonl(INADDR_LOOPBACK); p->sin_port = htons(9999);

    ssize_t snd = socks_udp_sendto(su, (const uint8_t *)"hello", 5, &peer);
    TASSERT(snd > 0);

    uint8_t raw[2048];
    struct sockaddr_storage from; socklen_t fl = sizeof(from);
    ssize_t got = -1;
    ticks = 0;
    while (ticks < 5000) {
        got = recvfrom(lfd, raw, sizeof(raw), 0, (struct sockaddr *)&from, &fl);
        if (got > 0) break;
        uasync_poll(ua, 10); ticks++;
    }
    TASSERT(got > 0);

    uint8_t payload[256];
    struct sockaddr_storage src;
    ssize_t plen = socks_udp_unwrap(su, raw, (size_t)got, payload, sizeof(payload), &src);
    TASSERT(plen == 5);
    TASSERT(memcmp(payload, "hello", 5) == 0);
    TASSERT(src.ss_family == AF_INET);
    TASSERT(((struct sockaddr_in *)&src)->sin_port == p->sin_port);

    socks_udp_destroy(su);
    socket_close_wrapper(lfd);
    umock_stop(&m);
    uasync_destroy(ua, 1);
    return 0;
}

static int test5_udp_reassociate(void) {
    struct UASYNC *ua = uasync_create(); TASSERT(ua);
    struct udp_mock m;
    TASSERT(umock_start(&m, ua, MOCK_PORT) == 0);

    socket_t lfd = socket(AF_INET, SOCK_DGRAM, 0);
    TASSERT(lfd != SOCKET_INVALID);
    socket_set_nonblocking(lfd);
    struct sockaddr_in lb; memset(&lb, 0, sizeof(lb));
    lb.sin_family = AF_INET; lb.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    TASSERT(bind(lfd, (struct sockaddr *)&lb, sizeof(lb)) == 0);

    struct socks_cfg cfg; memset(&cfg, 0, sizeof(cfg));
    strcpy(cfg.host, "127.0.0.1"); cfg.port = MOCK_PORT;

    g_su_ready = 0; g_su_err = 0;
    struct socks_udp *su = socks_udp_associate(ua, &cfg, lfd, su_ready_cb, NULL);
    TASSERT(su != NULL);

    int ticks = 0;
    while (g_su_ready == 0 && ticks < 20000) { uasync_poll(ua, 10); ticks++; }
    TASSERT(g_su_ready == 1);
    TASSERT(m.got_associate == 1);

    // Обрыв control-канала: закрываем серверную сторону → клиент должен пересоздать ассоциацию.
    if (m.ctrl_id) { uasync_remove_socket_t(m.ua, m.ctrl_sock); m.ctrl_id = NULL; }
    if (m.ctrl_sock != SOCKET_INVALID) { socket_close_wrapper(m.ctrl_sock); m.ctrl_sock = SOCKET_INVALID; }

    int ready_before = g_su_ready;
    ticks = 0;
    while (g_su_ready == ready_before && ticks < 50000) { uasync_poll(ua, 10); ticks++; }  // backoff ~1с
    TASSERT(g_su_ready > ready_before);
    TASSERT(m.got_associate >= 2);

    // После re-associate канал снова работает.
    struct sockaddr_storage peer; memset(&peer, 0, sizeof(peer));
    struct sockaddr_in *p = (struct sockaddr_in *)&peer;
    p->sin_family = AF_INET; p->sin_addr.s_addr = htonl(INADDR_LOOPBACK); p->sin_port = htons(7777);

    TASSERT(socks_udp_sendto(su, (const uint8_t *)"ping", 4, &peer) > 0);
    uint8_t raw[2048];
    struct sockaddr_storage from; socklen_t fl = sizeof(from);
    ssize_t got = -1;
    ticks = 0;
    while (ticks < 5000) {
        got = recvfrom(lfd, raw, sizeof(raw), 0, (struct sockaddr *)&from, &fl);
        if (got > 0) break;
        uasync_poll(ua, 10); ticks++;
    }
    TASSERT(got > 0);
    uint8_t payload[256];
    struct sockaddr_storage src;
    ssize_t plen = socks_udp_unwrap(su, raw, (size_t)got, payload, sizeof(payload), &src);
    TASSERT(plen == 4);
    TASSERT(memcmp(payload, "ping", 4) == 0);

    socks_udp_destroy(su);
    socket_close_wrapper(lfd);
    umock_stop(&m);
    uasync_destroy(ua, 1);
    return 0;
}

int main(void) {
    debug_set_level(DEBUG_LEVEL_ERROR);
    socket_platform_init();

    struct { const char *name; int (*fn)(void); } tests[] = {
        {"test1_noauth_v4", test1_noauth_v4},
        {"test2_auth_domain", test2_auth_domain},
        {"test3_reject", test3_reject},
        {"test4_udp_associate", test4_udp_associate},
        {"test5_udp_reassociate", test5_udp_reassociate},
    };
    int n = (int)(sizeof(tests) / sizeof(tests[0]));
    int passed = 0;
    for (int i = 0; i < n; i++) {
        test_failed = 0;
        int r = tests[i].fn();
        if (r == 0) { passed++; DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "PASS: %s", tests[i].name); }
        else        { DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "FAIL: %s", tests[i].name); }
    }
    socket_platform_cleanup();
    DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "Results: %d/%d passed", passed, n);
    return passed == n ? 0 : 1;
}