2 files changed, 61 insertions, 0 deletions

diff --git a/tests/integration/test_config.py b/tests/integration/test_config.py
new file mode 100644
index 0000000..1a84fa7
--- /dev/null
+++ b/tests/integration/test_config.py
@@ -0,0 +1,29 @@
+"""Settings the tracker has to accept, and still work with.
+
+An unrecognised key makes opentracker refuse to start, so a test that it
+comes up at all is a test that the key was understood.
+"""
+
+import unittest
+
+from harness import Tracker, TrackerTestCase, free_port
+
+
+class TcpWorkers(TrackerTestCase):
+    config = "listen.tcp.workers 2\n"
+
+    def test_the_tracker_serves_with_tcp_workers_asked_for(self):
+        self.assertEqual(self.tracker.announce(self.hash_for("tcpworkers"))[b"complete"], 1)
+
+
+class WorkersOnAListenStatement(unittest.TestCase):
+    def test_a_listen_statement_may_carry_a_worker_count(self):
+        """The option is read off the statement rather than inherited."""
+        second = free_port()
+        tracker = Tracker("listen.tcp 127.0.0.1:%d workers=2\n" % second)
+        try:
+            self.assertEqual(tracker.announce(b"listenopts\0\0\0\0\0\0\0\0\0\0")[b"complete"], 1)
+            complaints = tracker.stop()
+            self.assertEqual(complaints, [], "the tracker reported:\n" + "\n".join(complaints))
+        finally:
+            tracker._cleanup()
diff --git a/tests/t_event.c b/tests/t_event.c
index ad3948f..1908dc9 100644
--- a/tests/t_event.c
+++ b/tests/t_event.c
@@ -241,9 +241,40 @@ static void case_close_takes_it_out(void) {
   pair_close();
 }
 
+/* A descriptor can be taken on before anybody waits for anything on it: the
+   full scrape parks a connection while a worker thread builds the reply. The
+   mechanisms disagree about what registering nothing means, so what is
+   checked is that asking for a filter afterwards still works. */
+static void case_add_nothing_then_ask(void) {
+  test_case("a descriptor added with no interest can be given some later");
+  pair_open();
+  CHECK(sv[0] != -1);
+  CHECK_INT(event_add(sv[0], 0, 7), 0);
+  CHECK_INT((int)write(sv[1], "x", 1), 1);
+  CHECK_INT(wait_for(sv[0], EVENT_IN, 200, NULL), 0);
+
+  CHECK_INT(event_modify(sv[0], EVENT_IN, 7), 0);
+  {
+    uint32_t generation = 0;
+    CHECK_INT(wait_for(sv[0], EVENT_IN, 500, &generation), 1);
+    CHECK_INT((int)generation, 7);
+  }
+  event_del(sv[0]);
+  pair_close();
+}
+
+/* Whether a worker thread may register a descriptor while this one waits
+   depends on who keeps the set. Tying the answer to the mechanism's name
+   here means a backend added later cannot quietly forget to say. */
+static void case_sharing_matches_the_mechanism(void) {
+  test_case("only a set the kernel keeps may be changed from another thread");
+  CHECK_INT(event_can_share(), strcmp(event_mechanism(), "poll") ? 1 : 0);
+}
+
 void test_event(void) {
   CHECK_INT(event_init(), 0);
   CHECK(event_mechanism() != NULL);
+  case_sharing_matches_the_mechanism();
 
   case_readable();
   case_writable();
@@ -254,6 +285,7 @@ void test_event(void) {
   case_timeout();
   case_unknown_descriptor();
   case_close_takes_it_out();
+  case_add_nothing_then_ask();
 
   event_deinit();
 }