8 files changed, 602 insertions, 73 deletions

diff --git a/tests/integration/test_dynamic_accesslist.py b/tests/integration/test_dynamic_accesslist.py
new file mode 100644
index 0000000..7fa5fde
--- /dev/null
+++ b/tests/integration/test_dynamic_accesslist.py
@@ -0,0 +1,50 @@
+"""Hashes added to and removed from the blacklist while the tracker runs.
+
+The two FIFOs are read by threads of their own, which is also what makes
+this the test that drives those threads through a shutdown.
+"""
+
+import os
+import time
+import unittest
+
+from harness import TrackerTestCase
+
+BLOCKED = bytes(range(1, 21))
+
+
+def as_hex(info_hash):
+    return "".join("%02x" % b for b in info_hash)
+
+
+class DynamicAccesslist(TrackerTestCase):
+    config = ("access.blacklist {dir}/blacklist\n"
+              "access.fifo_add {dir}/add.fifo\n"
+              "access.fifo_delete {dir}/delete.fifo\n")
+    files = {"blacklist": b""}
+
+    def feed(self, name, info_hash):
+        """Writing to the FIFO blocks until the reader has it, so this also
+           tells us the thread is alive."""
+        with open(os.path.join(self.tracker.dir, name), "w") as fifo:
+            fifo.write("%s added by a test\n" % as_hex(info_hash))
+
+    def wait_for(self, info_hash, blocked, patience=5.0):
+        """The reader thread picks the hash up on its own schedule, so this
+           waits for the answer to change rather than assuming it already has."""
+        deadline = time.time() + patience
+        while time.time() < deadline:
+            answer = self.tracker.announce(info_hash)
+            if (b"failure reason" in answer) == blocked:
+                return True
+            time.sleep(0.05)
+        return False
+
+    def test_a_hash_can_be_blocked_and_released_while_running(self):
+        self.assertNotIn(b"failure reason", self.tracker.announce(BLOCKED))
+
+        self.feed("add.fifo", BLOCKED)
+        self.assertTrue(self.wait_for(BLOCKED, blocked=True), "the hash was never blocked")
+
+        self.feed("delete.fifo", BLOCKED)
+        self.assertTrue(self.wait_for(BLOCKED, blocked=False), "the hash was never released")
diff --git a/tests/integration/test_tcpworkers.py b/tests/integration/test_tcpworkers.py
new file mode 100644
index 0000000..e43612a
--- /dev/null
+++ b/tests/integration/test_tcpworkers.py
@@ -0,0 +1,67 @@
+"""The tracker with its tcp side handed to worker threads.
+
+With workers configured, a connection is accepted and answered on a worker's
+own stack. Anything it cannot finish there is copied to the heap and handed
+to the event loop, which is the one place where a worker and the main thread
+touch the same structures, so these drive all three outcomes: answered
+inline, held open, and parked waiting for another thread entirely.
+"""
+
+import threading
+import unittest
+import urllib.parse
+
+from harness import TrackerTestCase, bdecode
+
+WORKERS = 4
+
+
+class TcpWorkers(TrackerTestCase):
+    config = "listen.tcp.workers %d\n" % WORKERS
+
+    def announce_path(self, name, port=6881):
+        return "/announce?info_hash=%s&peer_id=%s&port=%d&left=0" % (
+            urllib.parse.quote_from_bytes(self.hash_for(name), safe=""),
+            "x" * 20,
+            port,
+        )
+
+    def test_many_at_once_are_all_answered(self):
+        """Every worker gets something to do, and the swarm adds up."""
+        info_hash = self.hash_for("workers-swarm")
+        errors = []
+
+        def announce(index):
+            try:
+                self.tracker.announce(info_hash, peer_id=b"-OT0001-%012d" % index, port=7000 + index, left=0)
+            except Exception as problem:  # noqa: BLE001 - reported, not swallowed
+                errors.append("%d: %r" % (index, problem))
+
+        threads = [threading.Thread(target=announce, args=(i,)) for i in range(32)]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        self.assertEqual(errors, [], "\n".join(errors))
+        self.assertEqual(self.tracker.scrape(info_hash)[b"files"][info_hash][b"complete"], 32)
+
+    def test_a_kept_connection_outlives_the_worker_that_took_it(self):
+        """Keep-alive is the plain case of a connection a worker hands on."""
+        connection = self.tracker.connect()
+        try:
+            for i in range(4):
+                connection.send(self.announce_path("workers-kept"))
+                status, _, body = connection.reply()
+                self.assertIn(b"200", status)
+                self.assertIn(b"complete", bdecode(body))
+        finally:
+            connection.close()
+
+    def test_a_full_scrape_asked_for_by_a_worker_still_arrives(self):
+        """The reply is built by another thread, so the worker parks the
+           connection waiting for nothing at all before handing it over."""
+        for i in range(20):
+            self.tracker.announce(bytes([i]) + b"\0" * 19, port=7100 + i, left=0)
+        body = self.tracker.get("/scrape")
+        self.assertEqual(len(bdecode(body)[b"files"]), 20)
diff --git a/tests/runner.c b/tests/runner.c
index 71a5e2a..97c6d51 100644
--- a/tests/runner.c
+++ b/tests/runner.c
@@ -28,6 +28,8 @@ static const struct module modules[] = {{"ot_urlencoded", test_urlencoded},
                                         {"ot_ip", test_ip},
                                         {"ot_socket", test_socket},
                                         {"ot_mutex", test_mutex},
+                                        {"trackerlogic", test_trackerlogic},
+                                        {"ot_workqueue", test_workqueue},
                                         {"ot_batch", test_batch},
                                         {"ot_fdstate", test_fdstate},
                                         {"ot_event", test_event},
diff --git a/tests/stubs.c b/tests/stubs.c
index a8e6962..5999e2d 100644
--- a/tests/stubs.c
+++ b/tests/stubs.c
@@ -8,11 +8,9 @@
    behaviour should be supplied here rather than the test weakened. */
 
 /* Opentracker */
+#include "ot_stats.h"
 #include "trackerlogic.h"
 
-/* ot_vector.c calls this from vector_clean_list, which no test drives yet. */
-void free_peerlist(ot_peerlist *peer_list) { (void)peer_list; }
-
 /* ot_accesslist.c is built with WANT_ACCESSLIST_BLACK so that the hash parser
    is reachable. These two belong to accesslist_readfile and the reload worker,
    neither of which any test drives. */
@@ -26,3 +24,32 @@ long io_trywrite(long d, const char *buf, long len) {
   (void)buf;
   return len;
 }
+
+/* trackerlogic.c is under test, and starting it up starts every module it
+   leans on. None of them is driven by these tests, so they are answered here
+   rather than linked in and left to run threads of their own. */
+void clean_init(void) {}
+void clean_deinit(void) {}
+int  clean_single_torrent(ot_torrent *torrent) {
+  (void)torrent;
+  return 0;
+}
+void fullscrape_init(void) {}
+void fullscrape_deinit(void) {}
+void livesync_init(void) {}
+void livesync_deinit(void) {}
+void livesync_tell(struct ot_workstruct *ws) { (void)ws; }
+void stats_init(void) {}
+void stats_deinit(void) {}
+void stats_issue_event(struct ot_workstruct *ws, ot_status_event event, PROTO_FLAG proto, uintptr_t event_data) {
+  (void)ws;
+  (void)event;
+  (void)proto;
+  (void)event_data;
+}
+void stats_counters_register(struct ot_workstruct *ws) { (void)ws; }
+void stats_counters_retire(struct ot_workstruct *ws) { (void)ws; }
+
+const char *g_stats_path;
+ssize_t     g_stats_path_len;
+uint32_t    g_tracker_id;
diff --git a/tests/t_mutex.c b/tests/t_mutex.c
index 3307d70..7c1463b 100644
--- a/tests/t_mutex.c
+++ b/tests/t_mutex.c
@@ -4,104 +4,135 @@
    $id$ */
 
 /* System */
-#include <stdlib.h>
+#include <pthread.h>
+#include <stdatomic.h>
 #include <string.h>
+#include <unistd.h>
 
 /* Opentracker */
 #include "ot_mutex.h"
 #include "test.h"
 
-/* A worker asks for a class of task and blocks until one turns up, so a task
-   whose class matches no worker is never claimed and whoever is waiting for
-   its answer waits forever. These cases pin the matching. */
+/* Every announce passes through here, and what it has to get right is which
+   bucket a hash belongs to and that two threads never hold one bucket at
+   once. Both are checked against real mutexes rather than a stand-in. */
 
-static void case_task_goes_to_its_own_class(void) {
-  ot_tasktype asked;
-  ot_taskid   taskid;
+/* A hash that lands in a chosen bucket: the bucket is the top
+   OT_BUCKET_COUNT_BITS of the first four bytes, read in network order */
+static void hash_for_bucket(ot_hash hash, int bucket) {
+  memset(hash, 0, sizeof(ot_hash));
+  hash[0] = (uint8_t)(bucket >> (OT_BUCKET_COUNT_BITS - 8));
+  hash[1] = (uint8_t)((bucket << (16 - OT_BUCKET_COUNT_BITS)) & 0xff);
+}
+
+static void case_a_hash_names_its_bucket(void) {
+  static const int buckets[] = {0, 1, 2, 17, 511, 512, OT_BUCKET_COUNT - 1};
+  size_t           i;
+
+  test_case("a hash is served by the bucket its leading bits name");
+  for (i = 0; i < sizeof(buckets) / sizeof(buckets[0]); ++i) {
+    ot_hash    hash;
+    ot_vector *by_hash, *by_number;
+
+    hash_for_bucket(hash, buckets[i]);
+    by_hash = mutex_bucket_lock_by_hash(hash);
+    mutex_bucket_unlock_by_hash(hash, 0);
 
-  test_case("a worker is handed the task of the class it asked for");
-  CHECK_INT(mutex_workqueue_pushtask(41, TASK_FULLSCRAPE_TPB_ASCII), 0);
-  asked  = TASK_FULLSCRAPE;
-  taskid = mutex_workqueue_poptask(&asked);
-  CHECK(taskid != 0);
+    by_number = mutex_bucket_lock(buckets[i]);
+    mutex_bucket_unlock(buckets[i], 0);
 
-  test_case("and the full task type, not just its class");
-  CHECK_INT(asked, TASK_FULLSCRAPE_TPB_ASCII);
-  mutex_workqueue_canceltask(41);
+    CHECK(by_hash == by_number);
+  }
 }
 
-static void case_flags_survive_the_queue(void) {
-  ot_tasktype asked;
+static void case_every_bucket_is_its_own(void) {
+  ot_vector *first, *last, *middle;
 
-  test_case("flags outside the class mask are carried through");
-  CHECK_INT(mutex_workqueue_pushtask(42, TASK_FULLSCRAPE_TPB_URLENCODED | TASK_FLAG_GZIP), 0);
-  asked = TASK_FULLSCRAPE;
-  CHECK(mutex_workqueue_poptask(&asked) != 0);
-  CHECK_INT(asked, TASK_FULLSCRAPE_TPB_URLENCODED | TASK_FLAG_GZIP);
-  mutex_workqueue_canceltask(42);
+  test_case("no two buckets are the same one");
+  first  = mutex_bucket_lock(0);
+  mutex_bucket_unlock(0, 0);
+  middle = mutex_bucket_lock(OT_BUCKET_COUNT / 2);
+  mutex_bucket_unlock(OT_BUCKET_COUNT / 2, 0);
+  last   = mutex_bucket_lock(OT_BUCKET_COUNT - 1);
+  mutex_bucket_unlock(OT_BUCKET_COUNT - 1, 0);
+
+  CHECK(first != middle);
+  CHECK(middle != last);
+  CHECK(first != last);
 }
 
-static void case_classes_do_not_cross(void) {
-  ot_tasktype asked;
-  ot_taskid   taskid;
+static void case_the_count_follows_what_unlock_is_told(void) {
+  size_t before = mutex_get_torrent_count();
+
+  test_case("the torrent count moves by what unlocking reports, and not otherwise");
+  mutex_bucket_lock(3);
+  mutex_bucket_unlock(3, 0);
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 0);
 
-  test_case("a stats worker passes over a fullscrape task");
-  CHECK_INT(mutex_workqueue_pushtask(43, TASK_FULLSCRAPE_TPB_BINARY), 0);
-  CHECK_INT(mutex_workqueue_pushtask(44, TASK_STATS_PEERS), 0);
+  mutex_bucket_lock(3);
+  mutex_bucket_unlock(3, 5);
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 5);
 
-  asked  = TASK_STATS;
-  taskid = mutex_workqueue_poptask(&asked);
-  CHECK(taskid != 0);
-  CHECK_INT(asked, TASK_STATS_PEERS);
+  mutex_bucket_lock(3);
+  mutex_bucket_unlock(3, -2);
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 3);
+}
 
-  test_case("and leaves it for the one that wants it");
-  asked  = TASK_FULLSCRAPE;
-  taskid = mutex_workqueue_poptask(&asked);
-  CHECK(taskid != 0);
-  CHECK_INT(asked, TASK_FULLSCRAPE_TPB_BINARY);
+static _Atomic int g_other_got_in;
 
-  mutex_workqueue_canceltask(43);
-  mutex_workqueue_canceltask(44);
+static void *take_a_bucket(void *args) {
+  int bucket = (int)(intptr_t)args;
+
+  mutex_bucket_lock(bucket);
+  atomic_store(&g_other_got_in, 1);
+  mutex_bucket_unlock(bucket, 0);
+  return NULL;
+}
+
+static int waited_for_entry(int patience_ms) {
+  int waited;
+
+  for (waited = 0; waited < patience_ms && !atomic_load(&g_other_got_in); ++waited)
+    usleep(1000);
+  return atomic_load(&g_other_got_in);
 }
 
-static void case_every_task_gets_its_own_id(void) {
-  ot_tasktype asked;
-  ot_taskid   first, second;
+static void case_a_held_bucket_keeps_others_out(void) {
+  pthread_t other;
 
-  test_case("two queued tasks are handed out under different ids");
-  CHECK_INT(mutex_workqueue_pushtask(45, TASK_FULLSCRAPE), 0);
-  CHECK_INT(mutex_workqueue_pushtask(46, TASK_FULLSCRAPE), 0);
+  test_case("a second thread waits for the bucket this one holds");
+  atomic_store(&g_other_got_in, 0);
+  mutex_bucket_lock(9);
+  CHECK_INT(pthread_create(&other, NULL, take_a_bucket, (void *)(intptr_t)9), 0);
 
-  asked  = TASK_FULLSCRAPE;
-  first  = mutex_workqueue_poptask(&asked);
-  asked  = TASK_FULLSCRAPE;
-  second = mutex_workqueue_poptask(&asked);
-  CHECK(first != 0);
-  CHECK(second != 0);
-  CHECK(first != second);
+  CHECK_INT(waited_for_entry(200), 0);
 
-  mutex_workqueue_canceltask(45);
-  mutex_workqueue_canceltask(46);
+  mutex_bucket_unlock(9, 0);
+  CHECK_INT(waited_for_entry(2000), 1);
+  pthread_join(other, NULL);
 }
 
-static void case_cancelled_task_is_not_handed_out(void) {
-  ot_tasktype asked;
+static void case_another_bucket_is_free_meanwhile(void) {
+  pthread_t other;
 
-  test_case("a cancelled task is gone before any worker sees it");
-  CHECK_INT(mutex_workqueue_pushtask(47, TASK_FULLSCRAPE_TPB_ASCII_PLUS), 0);
-  CHECK_INT(mutex_workqueue_pushtask(48, TASK_FULLSCRAPE), 0);
-  mutex_workqueue_canceltask(47);
+  test_case("and a different bucket is not held up by it");
+  atomic_store(&g_other_got_in, 0);
+  mutex_bucket_lock(9);
+  CHECK_INT(pthread_create(&other, NULL, take_a_bucket, (void *)(intptr_t)10), 0);
 
-  asked = TASK_FULLSCRAPE;
-  CHECK(mutex_workqueue_poptask(&asked) != 0);
-  CHECK_INT(asked, TASK_FULLSCRAPE);
-  mutex_workqueue_canceltask(48);
+  CHECK_INT(waited_for_entry(2000), 1);
+  pthread_join(other, NULL);
+  mutex_bucket_unlock(9, 0);
 }
 
 void test_mutex(void) {
-  case_task_goes_to_its_own_class();
-  case_flags_survive_the_queue();
-  case_classes_do_not_cross();
-  case_every_task_gets_its_own_id();
-  case_cancelled_task_is_not_handed_out();
+  mutex_init();
+
+  case_a_hash_names_its_bucket();
+  case_every_bucket_is_its_own();
+  case_the_count_follows_what_unlock_is_told();
+  case_a_held_bucket_keeps_others_out();
+  case_another_bucket_is_free_meanwhile();
+
+  mutex_deinit();
 }
diff --git a/tests/t_trackerlogic.c b/tests/t_trackerlogic.c
new file mode 100644
index 0000000..d3d8755
--- /dev/null
+++ b/tests/t_trackerlogic.c
@@ -0,0 +1,243 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+   It is considered beerware. Prost. Skol. Cheers or whatever.
+
+   $id$ */
+
+/* System */
+#include <arpa/inet.h>
+#include <signal.h>
+#include <pthread.h>
+#include <string.h>
+
+/* Opentracker */
+#include "ot_mutex.h"
+#include "trackerlogic.h"
+#include "test.h"
+
+/* The swarm itself: what an announce does to a torrent, and what a scrape
+   says about it afterwards. The counts are read back through the udp scrape
+   because that is the one reply the tracker builds as plain numbers. */
+
+static struct ot_workstruct ws;
+
+static void                 hash_named(ot_hash hash, const char *name) {
+  memset(hash, 0, sizeof(ot_hash));
+  memcpy(hash, name, strlen(name) < sizeof(ot_hash) ? strlen(name) : sizeof(ot_hash));
+}
+
+/* An IPv4 peer arrives as the v4 mapped form the tracker stores */
+static void peer_v4(ot_peer6 peer, uint8_t last, uint16_t port) {
+  ot_ip6   ip = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 10, 0, 0, 0};
+  uint16_t net_port = htons(port);
+
+  ip[15] = last;
+  memset(peer, 0, sizeof(ot_peer6));
+  OT_SETIP(peer, ip);
+  OT_SETPORT(peer, &net_port);
+  OT_PEERFLAG(peer) = 0;
+}
+
+static void peer_v6(ot_peer6 peer, uint8_t last, uint16_t port) {
+  ot_ip6   ip = {0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  uint16_t net_port = htons(port);
+
+  ip[15] = last;
+  memset(peer, 0, sizeof(ot_peer6));
+  OT_SETIP(peer, ip);
+  OT_SETPORT(peer, &net_port);
+  OT_PEERFLAG(peer) = 0;
+}
+
+static void announce(ot_hash *hash, ot_peer6 peer) {
+  ws.hash = hash;
+  memcpy(ws.peer, peer, sizeof(ot_peer6));
+  ws.reply = ws.outbuf;
+  add_peer_to_torrent_and_return_peers(FLAG_TCP, &ws, 50);
+}
+
+/* seeders, downloads completed, leechers */
+static void scrape(ot_hash hash, uint32_t counts[3]) {
+  char reply[12];
+
+  return_udp_scrape_for_torrent(hash, reply);
+  counts[0] = ntohl(((uint32_t *)reply)[0]);
+  counts[1] = ntohl(((uint32_t *)reply)[1]);
+  counts[2] = ntohl(((uint32_t *)reply)[2]);
+}
+
+static void case_an_announce_makes_a_torrent(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+  size_t   before = mutex_get_torrent_count();
+
+  test_case("the first announce for a hash creates its torrent");
+  hash_named(hash, "first-announce");
+  peer_v4(peer, 1, 6881);
+  announce(&hash, peer);
+
+  CHECK_INT((int)(mutex_get_torrent_count() - before), 1);
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 1); /* one leecher */
+  CHECK_INT((int)counts[0], 0);
+}
+
+static void case_the_same_peer_twice_is_one_peer(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("announcing twice renews a peer rather than adding another");
+  hash_named(hash, "renewing");
+  peer_v4(peer, 2, 6881);
+  announce(&hash, peer);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 1);
+}
+
+static void case_a_port_makes_a_different_peer(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("the same address on another port is another peer");
+  hash_named(hash, "two-ports");
+  peer_v4(peer, 3, 6881);
+  announce(&hash, peer);
+  peer_v4(peer, 3, 6882);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 2);
+}
+
+static void case_seeding_is_counted_apart(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a seeder counts as complete, a leecher as incomplete");
+  hash_named(hash, "seed-and-leech");
+  peer_v4(peer, 4, 6881);
+  OT_PEERFLAG(peer) |= PEER_FLAG_SEEDING;
+  announce(&hash, peer);
+  peer_v4(peer, 5, 6881);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[0], 1);
+  CHECK_INT((int)counts[2], 1);
+}
+
+static void case_completion_without_seeding_is_not_believed(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a peer that claims to have completed but is still leeching is not counted");
+  hash_named(hash, "claiming");
+  peer_v4(peer, 6, 6881);
+  OT_PEERFLAG(peer) |= PEER_FLAG_COMPLETED;
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[1], 0);
+  CHECK_INT((int)counts[2], 1); /* still a leecher */
+}
+
+static void case_completing_is_counted_once(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a seeder reporting completion is counted once, however often it says so");
+  hash_named(hash, "completing");
+  peer_v4(peer, 7, 6881);
+  OT_PEERFLAG(peer) |= PEER_FLAG_COMPLETED | PEER_FLAG_SEEDING;
+  announce(&hash, peer);
+  announce(&hash, peer);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[1], 1);
+  CHECK_INT((int)counts[0], 1);
+}
+
+static void case_a_peer_can_leave(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a peer that stops is gone from the swarm");
+  hash_named(hash, "leaving");
+  peer_v4(peer, 7, 6881);
+  announce(&hash, peer);
+  peer_v4(peer, 8, 6881);
+  announce(&hash, peer);
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 2);
+
+  ws.hash = &hash;
+  memcpy(ws.peer, peer, sizeof(ot_peer6));
+  remove_peer_from_torrent(FLAG_TCP, &ws);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 1);
+}
+
+static void case_the_families_are_kept_apart(void) {
+  ot_hash  hash;
+  ot_peer6 peer;
+  uint32_t counts[3];
+
+  test_case("a v4 and a v6 peer of one swarm are both counted");
+  hash_named(hash, "dual-stack");
+  peer_v4(peer, 9, 6881);
+  announce(&hash, peer);
+  peer_v6(peer, 9, 6881);
+  announce(&hash, peer);
+
+  scrape(hash, counts);
+  CHECK_INT((int)counts[2], 2);
+}
+
+static void case_a_hash_nobody_announced(void) {
+  ot_hash  hash;
+  uint32_t counts[3];
+
+  test_case("a hash nobody has announced scrapes as nothing at all");
+  hash_named(hash, "never-seen");
+  scrape(hash, counts);
+  CHECK_INT((int)counts[0], 0);
+  CHECK_INT((int)counts[1], 0);
+  CHECK_INT((int)counts[2], 0);
+}
+
+void test_trackerlogic(void) {
+  sigset_t signal_mask;
+
+  /* accesslist_init starts a thread that waits for SIGHUP and is stopped by
+     being sent one, so the signal has to be blocked here as the tracker
+     blocks it, or stopping the tracker logic ends this process instead */
+  sigemptyset(&signal_mask);
+  sigaddset(&signal_mask, SIGHUP);
+  pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
+
+  trackerlogic_init();
+  CHECK_INT(workstruct_init(&ws), 0);
+
+  case_an_announce_makes_a_torrent();
+  case_the_same_peer_twice_is_one_peer();
+  case_a_port_makes_a_different_peer();
+  case_seeding_is_counted_apart();
+  case_completion_without_seeding_is_not_believed();
+  case_completing_is_counted_once();
+  case_a_peer_can_leave();
+  case_the_families_are_kept_apart();
+  case_a_hash_nobody_announced();
+
+  workstruct_deinit(&ws);
+  trackerlogic_deinit();
+}
diff --git a/tests/t_workqueue.c b/tests/t_workqueue.c
new file mode 100644
index 0000000..13e0b2e
--- /dev/null
+++ b/tests/t_workqueue.c
@@ -0,0 +1,107 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+   It is considered beerware. Prost. Skol. Cheers or whatever.
+
+   $id$ */
+
+/* System */
+#include <stdlib.h>
+#include <string.h>
+
+/* Opentracker */
+#include "ot_workqueue.h"
+#include "test.h"
+
+/* A worker asks for a class of task and blocks until one turns up, so a task
+   whose class matches no worker is never claimed and whoever is waiting for
+   its answer waits forever. These cases pin the matching. */
+
+static void case_task_goes_to_its_own_class(void) {
+  ot_tasktype asked;
+  ot_taskid   taskid;
+
+  test_case("a worker is handed the task of the class it asked for");
+  CHECK_INT(workqueue_pushtask(41, TASK_FULLSCRAPE_TPB_ASCII), 0);
+  asked  = TASK_FULLSCRAPE;
+  taskid = workqueue_poptask(&asked);
+  CHECK(taskid != 0);
+
+  test_case("and the full task type, not just its class");
+  CHECK_INT(asked, TASK_FULLSCRAPE_TPB_ASCII);
+  workqueue_canceltask(41);
+}
+
+static void case_flags_survive_the_queue(void) {
+  ot_tasktype asked;
+
+  test_case("flags outside the class mask are carried through");
+  CHECK_INT(workqueue_pushtask(42, TASK_FULLSCRAPE_TPB_URLENCODED | TASK_FLAG_GZIP), 0);
+  asked = TASK_FULLSCRAPE;
+  CHECK(workqueue_poptask(&asked) != 0);
+  CHECK_INT(asked, TASK_FULLSCRAPE_TPB_URLENCODED | TASK_FLAG_GZIP);
+  workqueue_canceltask(42);
+}
+
+static void case_classes_do_not_cross(void) {
+  ot_tasktype asked;
+  ot_taskid   taskid;
+
+  test_case("a stats worker passes over a fullscrape task");
+  CHECK_INT(workqueue_pushtask(43, TASK_FULLSCRAPE_TPB_BINARY), 0);
+  CHECK_INT(workqueue_pushtask(44, TASK_STATS_PEERS), 0);
+
+  asked  = TASK_STATS;
+  taskid = workqueue_poptask(&asked);
+  CHECK(taskid != 0);
+  CHECK_INT(asked, TASK_STATS_PEERS);
+
+  test_case("and leaves it for the one that wants it");
+  asked  = TASK_FULLSCRAPE;
+  taskid = workqueue_poptask(&asked);
+  CHECK(taskid != 0);
+  CHECK_INT(asked, TASK_FULLSCRAPE_TPB_BINARY);
+
+  workqueue_canceltask(43);
+  workqueue_canceltask(44);
+}
+
+static void case_every_task_gets_its_own_id(void) {
+  ot_tasktype asked;
+  ot_taskid   first, second;
+
+  test_case("two queued tasks are handed out under different ids");
+  CHECK_INT(workqueue_pushtask(45, TASK_FULLSCRAPE), 0);
+  CHECK_INT(workqueue_pushtask(46, TASK_FULLSCRAPE), 0);
+
+  asked  = TASK_FULLSCRAPE;
+  first  = workqueue_poptask(&asked);
+  asked  = TASK_FULLSCRAPE;
+  second = workqueue_poptask(&asked);
+  CHECK(first != 0);
+  CHECK(second != 0);
+  CHECK(first != second);
+
+  workqueue_canceltask(45);
+  workqueue_canceltask(46);
+}
+
+static void case_cancelled_task_is_not_handed_out(void) {
+  ot_tasktype asked;
+
+  test_case("a cancelled task is gone before any worker sees it");
+  CHECK_INT(workqueue_pushtask(47, TASK_FULLSCRAPE_TPB_ASCII_PLUS), 0);
+  CHECK_INT(workqueue_pushtask(48, TASK_FULLSCRAPE), 0);
+  workqueue_canceltask(47);
+
+  asked = TASK_FULLSCRAPE;
+  CHECK(workqueue_poptask(&asked) != 0);
+  CHECK_INT(asked, TASK_FULLSCRAPE);
+  workqueue_canceltask(48);
+}
+
+void test_workqueue(void) {
+  case_task_goes_to_its_own_class();
+  case_flags_survive_the_queue();
+  case_classes_do_not_cross();
+  case_every_task_gets_its_own_id();
+  case_cancelled_task_is_not_handed_out();
+}
diff --git a/tests/test.h b/tests/test.h
index 0eddc82..d7296cc 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -87,6 +87,8 @@ void test_buf(void);
 void test_ip(void);
 void test_socket(void);
 void test_mutex(void);
+void test_trackerlogic(void);
+void test_workqueue(void);
 void test_batch(void);
 void test_fdstate(void);
 void test_event(void);