Inside Bitcoin

251    // protect 2 localhost and 2 onions, plus 4 other peers, sorted by longest uptime.
252    BOOST_CHECK(IsProtected(
253        16, [](NodeEvictionCandidate& c) {
254            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
255            c.m_is_local = (c.id == 6 || c.id == 9 || c.id == 11 || c.id == 12);
256            c.m_network = (c.id == 8 || c.id == 10) ? NET_ONION : NET_IPV6;
257        },
258        /*protected_peer_ids=*/{0, 1, 2, 3, 6, 8, 9, 10},
259        /*unprotected_peer_ids=*/{4, 5, 7, 11, 12, 13, 14, 15},
260        random_context));
261
262    // Combined test: expect having 5 localhost and 1 onion peer out of 16 to
263    // protect 3 localhost (recovering the unused onion slot), 1 onion, and 4
264    // others, sorted by longest uptime.
265    BOOST_CHECK(IsProtected(
266        16, [](NodeEvictionCandidate& c) {
267            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
268            c.m_is_local = (c.id > 10);
269            c.m_network = (c.id == 10) ? NET_ONION : NET_IPV4;
270        },
271        /*protected_peer_ids=*/{0, 1, 2, 3, 10, 11, 12, 13},
272        /*unprotected_peer_ids=*/{4, 5, 6, 7, 8, 9, 14, 15},
273        random_context));
274
275    // Combined test: expect having 1 localhost and 4 onion peers out of 16 to
276    // protect 1 localhost and 3 onions (recovering the unused localhost slot),
277    // plus 4 others, sorted by longest uptime.
278    BOOST_CHECK(IsProtected(
279        16, [](NodeEvictionCandidate& c) {
280            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
281            c.m_is_local = (c.id == 15);
282            c.m_network = (c.id > 6 && c.id < 11) ? NET_ONION : NET_IPV6;
283        },
284        /*protected_peer_ids=*/{0, 1, 2, 3, 7, 8, 9, 15},
285        /*unprotected_peer_ids=*/{5, 6, 10, 11, 12, 13, 14},
286        random_context));
287
288    // Combined test: expect having 2 onion and 4 I2P out of 12 peers to protect
289    // 2 onion (prioritized for having fewer candidates) and 1 I2P, plus 3
290    // others, sorted by longest uptime.
291    BOOST_CHECK(IsProtected(
292        num_peers, [](NodeEvictionCandidate& c) {
293            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
294            c.m_is_local = false;
295            if (c.id == 8 || c.id == 10) {
296                c.m_network = NET_ONION;
297            } else if (c.id == 6 || c.id == 9 || c.id == 11 || c.id == 12) {
298                c.m_network = NET_I2P;
299            } else {
300                c.m_network = NET_IPV4;
301            }
302        },
303        /*protected_peer_ids=*/{0, 1, 2, 6, 8, 10},
304        /*unprotected_peer_ids=*/{3, 4, 5, 7, 9, 11},
305        random_context));
306
307    // Tests with 3 networks...
308
309    // Combined test: expect having 1 localhost, 1 I2P and 1 onion peer out of 4
310    // to protect 1 I2P, 0 localhost, 0 onion and 1 other peer (2 total), sorted
311    // by longest uptime; stable sort breaks tie with array order of I2P first.
312    BOOST_CHECK(IsProtected(
313        4, [](NodeEvictionCandidate& c) {
314            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
315            c.m_is_local = (c.id == 2);
316            if (c.id == 3) {
317                c.m_network = NET_I2P;
318            } else if (c.id == 1) {
319                c.m_network = NET_ONION;
320            } else {
321                c.m_network = NET_IPV6;
322            }
323        },
324        /*protected_peer_ids=*/{0, 3},
325        /*unprotected_peer_ids=*/{1, 2},
326        random_context));
327
328    // Combined test: expect having 1 localhost, 1 I2P and 1 onion peer out of 7
329    // to protect 1 I2P, 0 localhost, 0 onion and 2 other peers (3 total) sorted
330    // by longest uptime; stable sort breaks tie with array order of I2P first.
331    BOOST_CHECK(IsProtected(
332        7, [](NodeEvictionCandidate& c) {
333            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
334            c.m_is_local = (c.id == 4);
335            if (c.id == 6) {
336                c.m_network = NET_I2P;
337            } else if (c.id == 5) {
338                c.m_network = NET_ONION;
339            } else {
340                c.m_network = NET_IPV6;
341            }
342        },
343        /*protected_peer_ids=*/{0, 1, 6},
344        /*unprotected_peer_ids=*/{2, 3, 4, 5},
345        random_context));
346
347    // Combined test: expect having 1 localhost, 1 I2P and 1 onion peer out of 8
348    // to protect 1 I2P, 1 localhost, 0 onion and 2 other peers (4 total) sorted
349    // by uptime; stable sort breaks tie with array order of I2P then localhost.
350    BOOST_CHECK(IsProtected(
351        8, [](NodeEvictionCandidate& c) {
352            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
353            c.m_is_local = (c.id == 6);
354            if (c.id == 5) {
355                c.m_network = NET_I2P;
356            } else if (c.id == 4) {
357                c.m_network = NET_ONION;
358            } else {
359                c.m_network = NET_IPV6;
360            }
361        },
362        /*protected_peer_ids=*/{0, 1, 5, 6},
363        /*unprotected_peer_ids=*/{2, 3, 4, 7},
364        random_context));
365
366    // Combined test: expect having 4 localhost, 2 I2P, and 2 onion peers out of
367    // 16 to protect 1 localhost, 2 I2P, and 1 onion (4/16 total), plus 4 others
368    // for 8 total, sorted by longest uptime.
369    BOOST_CHECK(IsProtected(
370        16, [](NodeEvictionCandidate& c) {
371            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
372            c.m_is_local = (c.id == 6 || c.id > 11);
373            if (c.id == 7 || c.id == 11) {
374                c.m_network = NET_I2P;
375            } else if (c.id == 9 || c.id == 10) {
376                c.m_network = NET_ONION;
377            } else {
378                c.m_network = NET_IPV4;
379            }
380        },
381        /*protected_peer_ids=*/{0, 1, 2, 3, 6, 7, 9, 11},
382        /*unprotected_peer_ids=*/{4, 5, 8, 10, 12, 13, 14, 15},
383        random_context));
384
385    // Combined test: expect having 1 localhost, 8 I2P and 1 onion peer out of
386    // 24 to protect 1, 4, and 1 (6 total), plus 6 others for 12/24 total,
387    // sorted by longest uptime.
388    BOOST_CHECK(IsProtected(
389        24, [](NodeEvictionCandidate& c) {
390            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
391            c.m_is_local = (c.id == 12);
392            if (c.id > 14 && c.id < 23) { // 4 protected instead of usual 2
393                c.m_network = NET_I2P;
394            } else if (c.id == 23) {
395                c.m_network = NET_ONION;
396            } else {
397                c.m_network = NET_IPV6;
398            }
399        },
400        /*protected_peer_ids=*/{0, 1, 2, 3, 4, 5, 12, 15, 16, 17, 18, 23},
401        /*unprotected_peer_ids=*/{6, 7, 8, 9, 10, 11, 13, 14, 19, 20, 21, 22},
402        random_context));
403
404    // Combined test: expect having 1 localhost, 3 I2P and 6 onion peers out of
405    // 24 to protect 1, 3, and 2 (6 total, I2P has fewer candidates and so gets the
406    // unused localhost slot), plus 6 others for 12/24 total, sorted by longest uptime.
407    BOOST_CHECK(IsProtected(
408        24, [](NodeEvictionCandidate& c) {
409            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
410            c.m_is_local = (c.id == 15);
411            if (c.id == 12 || c.id == 14 || c.id == 17) {
412                c.m_network = NET_I2P;
413            } else if (c.id > 17) { // 4 protected instead of usual 2
414                c.m_network = NET_ONION;
415            } else {
416                c.m_network = NET_IPV4;
417            }
418        },
419        /*protected_peer_ids=*/{0, 1, 2, 3, 4, 5, 12, 14, 15, 17, 18, 19},
420        /*unprotected_peer_ids=*/{6, 7, 8, 9, 10, 11, 13, 16, 20, 21, 22, 23},
421        random_context));
422
423    // Combined test: expect having 1 localhost, 7 I2P and 4 onion peers out of
424    // 24 to protect 1 localhost, 2 I2P, and 3 onions (6 total), plus 6 others
425    // for 12/24 total, sorted by longest uptime.
426    BOOST_CHECK(IsProtected(
427        24, [](NodeEvictionCandidate& c) {
428            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
429            c.m_is_local = (c.id == 13);
430            if (c.id > 16) {
431                c.m_network = NET_I2P;
432            } else if (c.id == 12 || c.id == 14 || c.id == 15 || c.id == 16) {
433                c.m_network = NET_ONION;
434            } else {
435                c.m_network = NET_IPV6;
436            }
437        },
438        /*protected_peer_ids=*/{0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 17, 18},
439        /*unprotected_peer_ids=*/{6, 7, 8, 9, 10, 11, 16, 19, 20, 21, 22, 23},
440        random_context));
441
442    // Combined test: expect having 8 localhost, 4 CJDNS, and 3 onion peers out
443    // of 24 to protect 2 of each (6 total), plus 6 others for 12/24 total,
444    // sorted by longest uptime.
445    BOOST_CHECK(IsProtected(
446        24, [](NodeEvictionCandidate& c) {
447            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
448            c.m_is_local = (c.id > 15);
449            if (c.id > 10 && c.id < 15) {
450                c.m_network = NET_CJDNS;
451            } else if (c.id > 6 && c.id < 10) {
452                c.m_network = NET_ONION;
453            } else {
454                c.m_network = NET_IPV4;
455            }
456        },
457        /*protected_peer_ids=*/{0, 1, 2, 3, 4, 5, 7, 8, 11, 12, 16, 17},
458        /*unprotected_peer_ids=*/{6, 9, 10, 13, 14, 15, 18, 19, 20, 21, 22, 23},
459        random_context));
460
461    // Tests with 4 networks...
462
463    // Combined test: expect having 1 CJDNS, 1 I2P, 1 localhost and 1 onion peer
464    // out of 5 to protect 1 CJDNS, 0 I2P, 0 localhost, 0 onion and 1 other peer
465    // (2 total), sorted by longest uptime; stable sort breaks tie with array
466    // order of CJDNS first.
467    BOOST_CHECK(IsProtected(
468        5, [](NodeEvictionCandidate& c) {
469            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
470            c.m_is_local = (c.id == 3);
471            if (c.id == 4) {
472                c.m_network = NET_CJDNS;
473            } else if (c.id == 1) {
474                c.m_network = NET_I2P;
475            } else if (c.id == 2) {
476                c.m_network = NET_ONION;
477            } else {
478                c.m_network = NET_IPV6;
479            }
480        },
481        /*protected_peer_ids=*/{0, 4},
482        /*unprotected_peer_ids=*/{1, 2, 3},
483        random_context));
484
485    // Combined test: expect having 1 CJDNS, 1 I2P, 1 localhost and 1 onion peer
486    // out of 7 to protect 1 CJDNS, 0, I2P, 0 localhost, 0 onion and 2 other
487    // peers (3 total) sorted by longest uptime; stable sort breaks tie with
488    // array order of CJDNS first.
489    BOOST_CHECK(IsProtected(
490        7, [](NodeEvictionCandidate& c) {
491            c.m_connected = NodeSeconds{std::chrono::seconds{c.id}};
492            c.m_is_local = (c.id == 4);
493            if (c.id == 6) {
494                c.m_network = NET_CJDNS;
495            } else if (c.id == 5) {
496                c.m_network = NET_I2P;
497            } else if (c.id == 3) {
498                c.m_network = NET_ONION;
499            } else {
500                c.m_network = NET_IPV4;