#include "tracker.h"

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

static void put32(uint8_t *p, uint32_t v)
{
    p[0] = (uint8_t)(v >> 24);
    p[1] = (uint8_t)(v >> 16);
    p[2] = (uint8_t)(v >> 8);
    p[3] = (uint8_t)v;
}

static void put64(uint8_t *p, uint64_t v)
{
    put32(p, (uint32_t)(v >> 32));
    put32(p + 4, (uint32_t)v);
}

static uint32_t get32(const uint8_t *p)
{
    return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
           ((uint32_t)p[2] << 8) | p[3];
}

static void fill_announce(tracker_announce_request *req, const char *hash,
                          const char *peer_id, uint16_t port, uint64_t left,
                          tracker_event event)
{
    memset(req, 0, sizeof(*req));
    memcpy(req->info_hash, hash, 20);
    memcpy(req->peer_id, peer_id, 20);
    req->port = port;
    req->left = left;
    req->numwant = -1;
    req->event = event;
    req->compact = 1;
    req->has_key = 1;
    req->key = (uint32_t)port;
}

static tracker_peer ipv4_source(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
{
    tracker_peer peer;
    memset(&peer, 0, sizeof(peer));
    peer.family = TRACKER_ADDR_IPV4;
    peer.addr[0] = a;
    peer.addr[1] = b;
    peer.addr[2] = c;
    peer.addr[3] = d;
    return peer;
}

static void test_dht_queries(void)
{
    uint8_t buf[512];
    size_t written = 0;
    dht_message msg;
    uint8_t tx[] = {'a', 'a'};
    uint8_t id[20] = "abcdefghij0123456789";
    uint8_t target[20] = "mnopqrstuvwxyz123456";
    uint8_t token[] = "tok";

    assert(dht_write_ping_query(tx, sizeof(tx), id, buf, sizeof(buf),
                                &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.type == DHT_MSG_QUERY);
    assert(msg.query == DHT_QUERY_PING);
    assert(msg.transaction_len == 2);
    assert(memcmp(msg.transaction, tx, 2) == 0);
    assert(memcmp(msg.id, id, 20) == 0);

    assert(dht_write_find_node_query(tx, sizeof(tx), id, target, 1, 1,
                                     buf, sizeof(buf),
                                     &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.query == DHT_QUERY_FIND_NODE);
    assert(memcmp(msg.target, target, 20) == 0);
    assert(msg.want_ipv4 == 1);
    assert(msg.want_ipv6 == 1);

    assert(dht_write_get_peers_query(tx, sizeof(tx), id, target, 0, 1,
                                     buf, sizeof(buf),
                                     &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.query == DHT_QUERY_GET_PEERS);
    assert(memcmp(msg.info_hash, target, 20) == 0);
    assert(msg.want_ipv4 == 0);
    assert(msg.want_ipv6 == 1);

    assert(dht_write_announce_peer_query(tx, sizeof(tx), id, target, 6881,
                                         token, sizeof(token) - 1, 1,
                                         buf, sizeof(buf),
                                         &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.query == DHT_QUERY_ANNOUNCE_PEER);
    assert(memcmp(msg.info_hash, target, 20) == 0);
    assert(msg.port == 6881);
    assert(msg.implied_port == 1);
    assert(msg.token_len == sizeof(token) - 1);
    assert(memcmp(msg.token, token, sizeof(token) - 1) == 0);
}

static void test_dht_responses(void)
{
    uint8_t buf[1024];
    size_t written = 0;
    dht_message msg;
    uint8_t tx[] = {'b', 'b'};
    uint8_t id[20] = "abcdefghij0123456789";
    uint8_t node_id[20] = "mnopqrstuvwxyz123456";
    uint8_t token[] = "aoeusnth";
    dht_node nodes[2];
    tracker_peer peers[2];

    assert(dht_write_ping_response(tx, sizeof(tx), id, buf, sizeof(buf),
                                   &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.type == DHT_MSG_RESPONSE);
    assert(memcmp(msg.id, id, 20) == 0);

    memset(nodes, 0, sizeof(nodes));
    memcpy(nodes[0].id, node_id, 20);
    nodes[0].family = TRACKER_ADDR_IPV4;
    nodes[0].addr[0] = 1;
    nodes[0].addr[1] = 2;
    nodes[0].addr[2] = 3;
    nodes[0].addr[3] = 4;
    nodes[0].port = 6881;
    memcpy(nodes[1].id, id, 20);
    nodes[1].family = TRACKER_ADDR_IPV6;
    nodes[1].addr[15] = 1;
    nodes[1].port = 6882;
    assert(dht_write_nodes_response(tx, sizeof(tx), id, token,
                                    sizeof(token) - 1, nodes, 2,
                                    buf, sizeof(buf),
                                    &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.type == DHT_MSG_RESPONSE);
    assert(msg.node_count == 2);
    assert(msg.nodes[0].family == TRACKER_ADDR_IPV4);
    assert(msg.nodes[0].port == 6881);
    assert(msg.nodes[1].family == TRACKER_ADDR_IPV6);
    assert(msg.nodes[1].port == 6882);
    assert(msg.token_len == sizeof(token) - 1);
    assert(memcmp(msg.token, token, sizeof(token) - 1) == 0);

    memset(peers, 0, sizeof(peers));
    peers[0].family = TRACKER_ADDR_IPV4;
    peers[0].addr[0] = 8;
    peers[0].addr[1] = 8;
    peers[0].addr[2] = 8;
    peers[0].addr[3] = 8;
    peers[0].port = 51413;
    peers[1].family = TRACKER_ADDR_IPV6;
    peers[1].addr[15] = 2;
    peers[1].port = 51414;
    assert(dht_write_peers_response(tx, sizeof(tx), id, token,
                                    sizeof(token) - 1, peers, 2,
                                    buf, sizeof(buf),
                                    &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.peer_count == 2);
    assert(msg.peers[0].family == TRACKER_ADDR_IPV4);
    assert(msg.peers[0].port == 51413);
    assert(msg.peers[1].family == TRACKER_ADDR_IPV6);
    assert(msg.peers[1].port == 51414);
}

static void test_dht_error(void)
{
    uint8_t buf[256];
    size_t written = 0;
    dht_message msg;
    uint8_t tx[] = {'e', 'r'};
    assert(dht_write_error(tx, sizeof(tx), DHT_ERR_PROTOCOL, "bad token",
                           buf, sizeof(buf), &written) == TRACKER_OK);
    assert(dht_parse_message(buf, written, &msg) == TRACKER_OK);
    assert(msg.type == DHT_MSG_ERROR);
    assert(msg.error_code == DHT_ERR_PROTOCOL);
    assert(strcmp(msg.error_message, "bad token") == 0);
}

static void test_http_announce_parse(void)
{
    tracker_announce_request req;
    const char *q =
        "/announce?info_hash=%00%01%02%03%04%05%06%07%08%09%0a%0b%0c%0d%0e%0f%10%11%12%13"
        "&peer_id=-TT0001-abcdefghijkl"
        "&port=6881&uploaded=10&downloaded=20&left=30&compact=1"
        "&event=started&numwant=50&key=12345&trackerid=session";
    int rc = tracker_http_parse_announce_query(q, &req);
    assert(rc == TRACKER_OK);
    assert(req.info_hash[0] == 0);
    assert(req.info_hash[19] == 0x13);
    assert(memcmp(req.peer_id, "-TT0001-abcdefghijkl", 20) == 0);
    assert(req.port == 6881);
    assert(req.uploaded == 10);
    assert(req.downloaded == 20);
    assert(req.left == 30);
    assert(req.compact == 1);
    assert(req.event == TRACKER_EVENT_STARTED);
    assert(req.numwant == 50);
    assert(req.has_key == 1 && req.key == 12345);
    assert(strcmp(req.tracker_id, "session") == 0);

    assert(tracker_http_parse_announce_query(
               "/announce?info_hash=++++++++++++++++++++"
               "&peer_id=--------------------&port=1&uploaded=0"
               "&downloaded=0&left=0",
               &req) == TRACKER_OK);
    assert(req.info_hash[0] == '+');
    assert(req.info_hash[19] == '+');
}

static void test_http_compact_response(void)
{
    uint8_t buf[512];
    size_t written = 0;
    tracker_peer peers[2];
    tracker_announce_response resp;

    memset(peers, 0, sizeof(peers));
    peers[0].family = TRACKER_ADDR_IPV4;
    peers[0].addr[0] = 127;
    peers[0].addr[1] = 0;
    peers[0].addr[2] = 0;
    peers[0].addr[3] = 1;
    peers[0].port = 6881;
    peers[1].family = TRACKER_ADDR_IPV6;
    peers[1].addr[15] = 1;
    peers[1].port = 51413;

    memset(&resp, 0, sizeof(resp));
    resp.interval = 1800;
    resp.complete = 7;
    resp.incomplete = 3;
    resp.peers = peers;
    resp.peer_count = 2;
    resp.compact = 1;

    assert(tracker_http_write_announce_response(&resp, buf, sizeof(buf),
                                                &written) == TRACKER_OK);
    assert(written > 0);
    assert(memmem(buf, written, "5:peers6:", 9) != NULL);
    assert(memmem(buf, written, "6:peers618:", 10) != NULL);
}

static void test_http_scrape(void)
{
    uint8_t hashes[2][20];
    size_t count = 0;
    tracker_scrape_file files[1];
    tracker_scrape_response resp;
    uint8_t buf[256];
    size_t written = 0;
    int rc = tracker_http_parse_scrape_query(
        "/scrape?info_hash=aaaaaaaaaaaaaaaaaaaa&info_hash=bbbbbbbbbbbbbbbbbbbb",
        hashes, 2, &count);
    assert(rc == TRACKER_OK);
    assert(count == 2);
    assert(memcmp(hashes[0], "aaaaaaaaaaaaaaaaaaaa", 20) == 0);
    assert(memcmp(hashes[1], "bbbbbbbbbbbbbbbbbbbb", 20) == 0);

    memset(files, 0, sizeof(files));
    memcpy(files[0].info_hash, hashes[0], 20);
    files[0].complete = 11;
    files[0].downloaded = 22;
    files[0].incomplete = 33;
    resp.files = files;
    resp.file_count = 1;
    assert(tracker_http_write_scrape_response(&resp, buf, sizeof(buf),
                                              &written) == TRACKER_OK);
    assert(memmem(buf, written, "5:filesd20:aaaaaaaaaaaaaaaaaaaa", 31) != NULL);
    assert(memmem(buf, written, "8:completei11e", 14) != NULL);
}

static void test_http_client_helpers(void)
{
    tracker_announce_request req;
    tracker_announce_request parsed;
    tracker_announce_response resp;
    tracker_announce_response parsed_resp;
    tracker_scrape_response scrape;
    tracker_scrape_response parsed_scrape;
    tracker_scrape_file files[1];
    tracker_scrape_file parsed_files[2];
    tracker_peer peers[2];
    tracker_peer parsed_peers[4];
    uint8_t buf[512];
    char query[512];
    size_t written = 0;
    uint8_t hashes[2][20];
    size_t hash_count = 0;

    fill_announce(&req, "abcdefghijklmnopqrst", "-TC0001-abcdefghijkl", 6881,
                  12345, TRACKER_EVENT_STARTED);
    req.uploaded = 10;
    req.downloaded = 20;
    req.numwant = 25;
    assert(tracker_http_write_announce_query(&req, query, sizeof(query),
                                             &written) == TRACKER_OK);
    assert(written > 0);
    assert(tracker_http_parse_announce_query(query, &parsed) == TRACKER_OK);
    assert(memcmp(parsed.info_hash, req.info_hash, 20) == 0);
    assert(memcmp(parsed.peer_id, req.peer_id, 20) == 0);
    assert(parsed.port == 6881);
    assert(parsed.left == 12345);
    assert(parsed.event == TRACKER_EVENT_STARTED);
    assert(parsed.numwant == 25);

    memset(peers, 0, sizeof(peers));
    peers[0].family = TRACKER_ADDR_IPV4;
    peers[0].addr[0] = 1;
    peers[0].addr[1] = 2;
    peers[0].addr[2] = 3;
    peers[0].addr[3] = 4;
    peers[0].port = 6000;
    peers[1].family = TRACKER_ADDR_IPV6;
    peers[1].addr[15] = 1;
    peers[1].port = 6001;
    memset(&resp, 0, sizeof(resp));
    resp.interval = 1800;
    resp.min_interval = 60;
    resp.complete = 3;
    resp.incomplete = 4;
    resp.peers = peers;
    resp.peer_count = 2;
    resp.compact = 1;
    assert(tracker_http_write_announce_response(&resp, buf, sizeof(buf),
                                                &written) == TRACKER_OK);
    assert(tracker_http_parse_announce_response(buf, written, parsed_peers, 4,
                                                &parsed_resp) == TRACKER_OK);
    assert(parsed_resp.interval == 1800);
    assert(parsed_resp.min_interval == 60);
    assert(parsed_resp.complete == 3);
    assert(parsed_resp.incomplete == 4);
    assert(parsed_resp.peer_count == 2);
    assert(parsed_peers[0].family == TRACKER_ADDR_IPV4);
    assert(parsed_peers[0].port == 6000);
    assert(parsed_peers[1].family == TRACKER_ADDR_IPV6);
    assert(parsed_peers[1].port == 6001);

    memcpy(hashes[0], "aaaaaaaaaaaaaaaaaaaa", 20);
    memcpy(hashes[1], "bbbbbbbbbbbbbbbbbbbb", 20);
    assert(tracker_http_write_scrape_query(hashes, 2, query, sizeof(query),
                                           &written) == TRACKER_OK);
    assert(tracker_http_parse_scrape_query(query, hashes, 2,
                                           &hash_count) == TRACKER_OK);
    assert(hash_count == 2);

    memset(files, 0, sizeof(files));
    memcpy(files[0].info_hash, "aaaaaaaaaaaaaaaaaaaa", 20);
    files[0].complete = 9;
    files[0].downloaded = 8;
    files[0].incomplete = 7;
    scrape.files = files;
    scrape.file_count = 1;
    assert(tracker_http_write_scrape_response(&scrape, buf, sizeof(buf),
                                              &written) == TRACKER_OK);
    assert(tracker_http_parse_scrape_response(buf, written, parsed_files, 2,
                                              &parsed_scrape) == TRACKER_OK);
    assert(parsed_scrape.file_count == 1);
    assert(memcmp(parsed_files[0].info_hash, files[0].info_hash, 20) == 0);
    assert(parsed_files[0].complete == 9);
    assert(parsed_files[0].downloaded == 8);
    assert(parsed_files[0].incomplete == 7);
}

static void test_udp_announce_parse(void)
{
    uint8_t pkt[128];
    tracker_udp_request req;
    memset(pkt, 0, sizeof(pkt));
    put64(pkt, 0x0102030405060708ULL);
    put32(pkt + 8, TRACKER_UDP_ANNOUNCE);
    put32(pkt + 12, 0x11223344);
    memcpy(pkt + 16, "aaaaaaaaaaaaaaaaaaaa", 20);
    memcpy(pkt + 36, "bbbbbbbbbbbbbbbbbbbb", 20);
    put64(pkt + 56, 100);
    put64(pkt + 64, 200);
    put64(pkt + 72, 300);
    put32(pkt + 80, TRACKER_EVENT_COMPLETED);
    put32(pkt + 88, 0xaabbccdd);
    put32(pkt + 92, 25);
    pkt[96] = 0x1a;
    pkt[97] = 0xe1;
    pkt[98] = 0x02;
    pkt[99] = 12;
    memcpy(pkt + 100, "/dir?a=b&c=d", 12);
    pkt[112] = 0x00;

    assert(tracker_udp_parse_request(pkt, 113, TRACKER_ADDR_IPV4,
                                     &req) == TRACKER_OK);
    assert(req.action == TRACKER_UDP_ANNOUNCE);
    assert(req.transaction_id == 0x11223344);
    assert(req.connection_id == 0x0102030405060708ULL);
    assert(memcmp(req.announce.info_hash, "aaaaaaaaaaaaaaaaaaaa", 20) == 0);
    assert(memcmp(req.announce.peer_id, "bbbbbbbbbbbbbbbbbbbb", 20) == 0);
    assert(req.announce.downloaded == 100);
    assert(req.announce.left == 200);
    assert(req.announce.uploaded == 300);
    assert(req.announce.event == TRACKER_EVENT_COMPLETED);
    assert(req.announce.key == 0xaabbccdd);
    assert(req.announce.numwant == 25);
    assert(req.announce.port == 6881);
    assert(strcmp(req.announce.url_data, "/dir?a=b&c=d") == 0);
}

static void test_udp_responses(void)
{
    uint8_t buf[256];
    size_t written = 0;
    tracker_peer peer;
    tracker_announce_response announce;
    tracker_scrape_file file;
    tracker_scrape_response scrape;

    assert(tracker_udp_write_connect_response(0x1234, 0x0102030405060708ULL,
                                              buf, sizeof(buf),
                                              &written) == TRACKER_OK);
    assert(written == 16);
    assert(get32(buf) == TRACKER_UDP_CONNECT);
    assert(get32(buf + 4) == 0x1234);

    memset(&peer, 0, sizeof(peer));
    peer.family = TRACKER_ADDR_IPV4;
    peer.addr[0] = 10;
    peer.addr[3] = 5;
    peer.port = 6000;
    memset(&announce, 0, sizeof(announce));
    announce.interval = 900;
    announce.complete = 2;
    announce.incomplete = 4;
    announce.peers = &peer;
    announce.peer_count = 1;
    assert(tracker_udp_write_announce_response(0x99, TRACKER_ADDR_IPV4,
                                               &announce, buf, sizeof(buf),
                                               &written) == TRACKER_OK);
    assert(written == 26);
    assert(get32(buf) == TRACKER_UDP_ANNOUNCE);
    assert(get32(buf + 8) == 900);
    assert(get32(buf + 12) == 4);
    assert(get32(buf + 16) == 2);
    assert(buf[20] == 10 && buf[23] == 5);

    memset(&file, 0, sizeof(file));
    file.complete = 8;
    file.downloaded = 9;
    file.incomplete = 10;
    scrape.files = &file;
    scrape.file_count = 1;
    assert(tracker_udp_write_scrape_response(0x77, &scrape, buf, sizeof(buf),
                                             &written) == TRACKER_OK);
    assert(written == 20);
    assert(get32(buf) == TRACKER_UDP_SCRAPE);
    assert(get32(buf + 8) == 8);
    assert(get32(buf + 12) == 9);
    assert(get32(buf + 16) == 10);
}

static void test_udp_client_helpers(void)
{
    uint8_t buf[512];
    uint8_t response_buf[512];
    size_t written = 0;
    size_t response_written = 0;
    tracker_udp_request parsed_req;
    tracker_announce_request req;
    tracker_announce_response resp;
    tracker_announce_response parsed_resp;
    tracker_scrape_response scrape;
    tracker_scrape_response parsed_scrape;
    tracker_scrape_file file;
    tracker_scrape_file parsed_files[2];
    tracker_peer peer;
    tracker_peer parsed_peers[2];
    uint8_t hashes[1][20];
    uint64_t connection_id = 0;

    assert(tracker_udp_write_connect_request(0x5555, buf, sizeof(buf),
                                             &written) == TRACKER_OK);
    assert(tracker_udp_parse_request(buf, written, TRACKER_ADDR_IPV4,
                                     &parsed_req) == TRACKER_OK);
    assert(parsed_req.action == TRACKER_UDP_CONNECT);
    assert(parsed_req.transaction_id == 0x5555);
    assert(tracker_udp_write_connect_response(0x5555, 0x0102030405060708ULL,
                                              response_buf, sizeof(response_buf),
                                              &response_written) == TRACKER_OK);
    assert(tracker_udp_parse_connect_response(response_buf, response_written,
                                              0x5555,
                                              &connection_id) == TRACKER_OK);
    assert(connection_id == 0x0102030405060708ULL);

    fill_announce(&req, "abcdefghijklmnopqrst", "-UC0001-abcdefghijkl", 7000,
                  42, TRACKER_EVENT_STARTED);
    req.downloaded = 5;
    req.uploaded = 6;
    req.numwant = 10;
    strcpy(req.url_data, "/announce?token=abc");
    assert(tracker_udp_write_announce_request(connection_id, 0x6666, &req,
                                              buf, sizeof(buf),
                                              &written) == TRACKER_OK);
    assert(tracker_udp_parse_request(buf, written, TRACKER_ADDR_IPV4,
                                     &parsed_req) == TRACKER_OK);
    assert(parsed_req.action == TRACKER_UDP_ANNOUNCE);
    assert(parsed_req.transaction_id == 0x6666);
    assert(parsed_req.connection_id == connection_id);
    assert(parsed_req.announce.port == 7000);
    assert(parsed_req.announce.left == 42);
    assert(strcmp(parsed_req.announce.url_data, "/announce?token=abc") == 0);

    memset(&peer, 0, sizeof(peer));
    peer.family = TRACKER_ADDR_IPV4;
    peer.addr[0] = 8;
    peer.addr[1] = 8;
    peer.addr[2] = 4;
    peer.addr[3] = 4;
    peer.port = 51413;
    memset(&resp, 0, sizeof(resp));
    resp.interval = 900;
    resp.complete = 11;
    resp.incomplete = 12;
    resp.peers = &peer;
    resp.peer_count = 1;
    assert(tracker_udp_write_announce_response(0x6666, TRACKER_ADDR_IPV4,
                                               &resp, response_buf,
                                               sizeof(response_buf),
                                               &response_written) == TRACKER_OK);
    assert(tracker_udp_parse_announce_response(response_buf, response_written,
                                               0x6666, TRACKER_ADDR_IPV4,
                                               parsed_peers, 2,
                                               &parsed_resp) == TRACKER_OK);
    assert(parsed_resp.interval == 900);
    assert(parsed_resp.complete == 11);
    assert(parsed_resp.incomplete == 12);
    assert(parsed_resp.peer_count == 1);
    assert(parsed_peers[0].addr[0] == 8);
    assert(parsed_peers[0].port == 51413);

    memcpy(hashes[0], "aaaaaaaaaaaaaaaaaaaa", 20);
    assert(tracker_udp_write_scrape_request(connection_id, 0x7777, hashes, 1,
                                            buf, sizeof(buf),
                                            &written) == TRACKER_OK);
    assert(tracker_udp_parse_request(buf, written, TRACKER_ADDR_IPV4,
                                     &parsed_req) == TRACKER_OK);
    assert(parsed_req.action == TRACKER_UDP_SCRAPE);
    assert(parsed_req.scrape_count == 1);
    assert(memcmp(parsed_req.scrape_hashes[0], hashes[0], 20) == 0);

    memset(&file, 0, sizeof(file));
    file.complete = 1;
    file.downloaded = 2;
    file.incomplete = 3;
    scrape.files = &file;
    scrape.file_count = 1;
    assert(tracker_udp_write_scrape_response(0x7777, &scrape, response_buf,
                                             sizeof(response_buf),
                                             &response_written) == TRACKER_OK);
    assert(tracker_udp_parse_scrape_response(response_buf, response_written,
                                             0x7777, parsed_files, 2,
                                             &parsed_scrape) == TRACKER_OK);
    assert(parsed_scrape.file_count == 1);
    assert(parsed_files[0].complete == 1);
    assert(parsed_files[0].downloaded == 2);
    assert(parsed_files[0].incomplete == 3);
}

static void test_store_announce_scrape_stop_and_prune(void)
{
    tracker_store_config cfg;
    tracker_store *store;
    tracker_announce_request req1;
    tracker_announce_request req2;
    tracker_announce_response resp;
    tracker_scrape_response scrape;
    tracker_scrape_file files[1];
    tracker_peer source1 = ipv4_source(10, 0, 0, 1);
    tracker_peer source2 = ipv4_source(10, 0, 0, 2);
    tracker_peer out[8];
    uint8_t hashes[1][20];

    memset(&cfg, 0, sizeof(cfg));
    cfg.interval = 1200;
    cfg.min_interval = 60;
    cfg.peer_timeout = 10;
    cfg.default_numwant = 50;
    cfg.max_numwant = 50;
    cfg.random_seed = 1;
    store = tracker_store_create(&cfg);
    assert(store != NULL);

    fill_announce(&req1, "aaaaaaaaaaaaaaaaaaaa", "peer-000000000000001", 6001,
                  100, TRACKER_EVENT_STARTED);
    assert(tracker_store_announce(store, &req1, &source1, 100, out, 8,
                                  &resp) == TRACKER_OK);
    assert(resp.interval == 1200);
    assert(resp.min_interval == 60);
    assert(resp.complete == 0);
    assert(resp.incomplete == 1);
    assert(resp.peer_count == 0);
    assert(tracker_store_peer_count(store) == 1);

    fill_announce(&req2, "aaaaaaaaaaaaaaaaaaaa", "peer-000000000000002", 6002,
                  0, TRACKER_EVENT_STARTED);
    assert(tracker_store_announce(store, &req2, &source2, 101, out, 8,
                                  &resp) == TRACKER_OK);
    assert(resp.complete == 1);
    assert(resp.incomplete == 1);
    assert(resp.peer_count == 1);
    assert(out[0].port == 6001);
    assert(out[0].addr[3] == 1);

    req1.left = 0;
    req1.event = TRACKER_EVENT_COMPLETED;
    assert(tracker_store_announce(store, &req1, &source1, 102, out, 8,
                                  &resp) == TRACKER_OK);
    assert(resp.complete == 2);
    assert(resp.incomplete == 0);
    assert(resp.peer_count == 1);
    assert(out[0].port == 6002);

    memcpy(hashes[0], "aaaaaaaaaaaaaaaaaaaa", 20);
    assert(tracker_store_scrape(store, hashes, 1, files, 1,
                                &scrape) == TRACKER_OK);
    assert(scrape.file_count == 1);
    assert(files[0].complete == 2);
    assert(files[0].incomplete == 0);
    assert(files[0].downloaded == 1);

    req2.event = TRACKER_EVENT_STOPPED;
    assert(tracker_store_announce(store, &req2, &source2, 103, out, 8,
                                  &resp) == TRACKER_OK);
    assert(resp.complete == 1);
    assert(resp.incomplete == 0);
    assert(resp.peer_count == 0);
    assert(tracker_store_peer_count(store) == 1);

    assert(tracker_store_prune(store, 200) == 1);
    assert(tracker_store_peer_count(store) == 0);
    assert(tracker_store_scrape(store, hashes, 1, files, 1,
                                &scrape) == TRACKER_OK);
    assert(files[0].complete == 0);
    assert(files[0].incomplete == 0);
    assert(files[0].downloaded == 1);

    tracker_store_destroy(store);
}

int main(void)
{
    test_http_announce_parse();
    test_http_compact_response();
    test_http_scrape();
    test_http_client_helpers();
    test_dht_queries();
    test_dht_responses();
    test_dht_error();
    test_udp_announce_parse();
    test_udp_responses();
    test_udp_client_helpers();
    test_store_announce_scrape_stop_and_prune();
    puts("tracker protocol tests passed");
    return 0;
}