1 files changed, 87 insertions, 5 deletions

diff --git a/tests/t_clean.c b/tests/t_clean.c
index 7eca9aa..ce17bc3 100644
--- a/tests/t_clean.c
+++ b/tests/t_clean.c
@@ -11,7 +11,7 @@
 #include "trackerlogic.h"
 #include "test.h"
 
-/* A clock stepped backwards used to leave peer_list->base in the future, so
+/* A clock stepped backwards used to leave the torrent's base in the future, so
    the span the cleaner works from came out negative. It was then added to a
    peer's age and stored in the single byte that age lives in, where -1 reads
    as 255 and the next pass threw the whole swarm away. */
@@ -33,6 +33,20 @@ static void announce(struct ot_workstruct *ws, ot_hash *hash, uint8_t last_octet
   add_peer_to_torrent_and_return_peers(FLAG_TCP, ws, 0);
 }
 
+/* A distinct v4 peer addressed by two octets, to build swarms past 256 */
+static size_t announce_wide(struct ot_workstruct *ws, ot_hash *hash, unsigned int which, size_t amount) {
+  static const uint8_t v4mapped[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff};
+
+  ws->reply = ws->outbuf;
+  memset(&ws->peer, 0, sizeof(ws->peer));
+  memcpy(&ws->peer, v4mapped, sizeof(v4mapped));
+  ((uint8_t *)&ws->peer)[14] = (uint8_t)(which >> 8);
+  ((uint8_t *)&ws->peer)[15] = (uint8_t)which;
+  OT_SETPORT(&ws->peer, &(uint16_t){6881});
+  ws->hash = hash;
+  return add_peer_to_torrent_and_return_peers(FLAG_TCP, ws, amount);
+}
+
 static size_t peers_in(ot_hash *hash) {
   char   reply[1024];
   size_t len = return_udp_scrape_for_torrent(*hash, reply);
@@ -60,14 +74,12 @@ static ot_torrent *torrent_of(ot_hash *hash) {
 
 /* What a clock stepped back by `minutes` leaves behind */
 static void step_clock_back(ot_torrent *torrent, int minutes) {
-  torrent->peer_list6->base += minutes;
-  torrent->peer_list4->base += minutes;
+  torrent->base += minutes;
 }
 
 /* What the next minute of a well behaved clock looks like */
 static void age_by_a_minute(ot_torrent *torrent) {
-  torrent->peer_list6->base -= 1;
-  torrent->peer_list4->base -= 1;
+  torrent->base -= 1;
 }
 
 static void case_a_clock_that_went_back_keeps_the_swarm(void) {
@@ -124,6 +136,74 @@ static void case_an_idle_swarm_still_ages_out(void) {
   workstruct_deinit(&ws);
 }
 
+static void case_empty_torrent_timeout_bounds_a_counter_only_torrent(void) {
+  struct ot_workstruct ws;
+  ot_hash              hash;
+  ot_torrent          *torrent;
+  ot_time              saved = g_empty_torrent_timeout;
+
+  test_case("the empty torrent timeout bounds a counter-only torrent's life");
+  memset(hash, 0x33, sizeof(hash));
+  CHECK_INT(workstruct_init(&ws, G_INBUF_SIZE), 0);
+
+  announce(&ws, &hash, 7, 1);
+  torrent = torrent_of(&hash);
+  CHECK(torrent != NULL);
+  torrent->down_count = 1; /* one completed download to remember it by */
+
+  /* Age the only peer out: the torrent falls empty but keeps its count */
+  step_clock_back(torrent, -OT_PEER_TIMEOUT);
+  CHECK_INT(clean_single_torrent(torrent), 0);
+  CHECK_INT(peers_in(&hash), 0);
+
+  /* Carry it a little past a short empty-torrent timeout */
+  step_clock_back(torrent, -10);
+
+  /* The default, matching the torrent timeout, still holds it for the count */
+  g_empty_torrent_timeout = OT_TORRENT_TIMEOUT;
+  CHECK_INT(clean_single_torrent(torrent), 0);
+
+  /* A timeout it has now exceeded lets the next sweep drop it */
+  g_empty_torrent_timeout = OT_PEER_TIMEOUT + 5;
+  CHECK_INT(clean_single_torrent(torrent), 1);
+
+  g_empty_torrent_timeout = saved;
+  workstruct_deinit(&ws);
+}
+
+static void case_a_bucketed_swarm_survives_clean_and_serves(void) {
+  struct ot_workstruct ws;
+  ot_hash              hash;
+  ot_torrent          *torrent;
+  unsigned int         i;
+  const unsigned int   n = 600; /* past OT_PEER_BUCKET_MINCOUNT (512) */
+
+  test_case("a swarm large enough to be bucketed cleans, splits and serves without loss");
+  memset(hash, 0x34, sizeof(hash));
+  CHECK_INT(workstruct_init(&ws, G_INBUF_SIZE), 0);
+
+  for (i = 0; i < n; ++i)
+    announce_wide(&ws, &hash, i, 0);
+  CHECK_INT(peers_in(&hash), n);
+
+  torrent = torrent_of(&hash);
+  CHECK(torrent != NULL);
+  CHECK(torrent->peer_list != NULL);
+
+  /* A clean with a minute elapsed splits the flat vector into buckets */
+  step_clock_back(torrent, -1);
+  CHECK_INT(clean_single_torrent(torrent), 0);
+  CHECK(torrent->peer_list != NULL);
+  CHECK_INT(OT_VECTOR_HASBUCKETS(&torrent->peer_list->peers4), 1);
+  CHECK_INT(peers_in(&hash), n);
+
+  /* Serve a selection back, which walks the bucket list */
+  CHECK(announce_wide(&ws, &hash, 1, 200) > 0);
+  CHECK_INT(peers_in(&hash), n);
+
+  workstruct_deinit(&ws);
+}
+
 void test_clean(void) {
   sigset_t hup;
 
@@ -136,5 +216,7 @@ void test_clean(void) {
   trackerlogic_init();
   case_a_clock_that_went_back_keeps_the_swarm();
   case_an_idle_swarm_still_ages_out();
+  case_empty_torrent_timeout_bounds_a_counter_only_torrent();
+  case_a_bucketed_swarm_survives_clean_and_serves();
   trackerlogic_deinit();
 }