padded_cell 0.1.0

data/ext/padded_cell_native/core/src/discover.rs

@@ -0,0 +1,454 @@
+//! Static Minitest discovery.
+//!
+//! A test class is a class whose superclass constant ends in `Test` or
+//! `TestCase` (`Minitest::Test`, `ActiveSupport::TestCase`, an app's own
+//! `BaseTest`...). Its tests are `def test_*` methods and Rails'
+//! `test "name"` declarations. Nothing is evaluated.
+
+use std::iter::FusedIterator;
+use std::num::NonZeroUsize;
+use std::path::{Path, PathBuf};
+use std::{fs, io, slice, thread};
+
+use ruby_prism::{
+    CallNode, ClassNode, DefNode, Location, ModuleNode, Node, SingletonClassNode, Visit,
+};
+
+#[cfg(test)]
+mod tests;
+
+/// The tests of one source. Each class name is stored once, however many
+/// tests the class has.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Discovery {
+    classes: Vec<String>,
+    tests: Vec<Entry>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct Entry {
+    class: usize,
+    name: String,
+    start_line: usize,
+    end_line: usize,
+}
+
+/// A discovered test, borrowed from its [`Discovery`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TestDef<'a> {
+    /// Full constant name of the class: `Admin::UsersControllerTest`.
+    pub class_name: &'a str,
+    /// Index of the class in [`Discovery::classes`].
+    pub class: usize,
+    /// Method name: `test_index_lists_users` for `test "index lists users"`.
+    pub name: &'a str,
+    /// 1-based line where the definition starts.
+    pub start_line: usize,
+    /// 1-based line where it ends.
+    pub end_line: usize,
+}
+
+impl TestDef<'_> {
+    /// `Class#method`, the id Minitest filters match.
+    #[must_use]
+    pub fn id(&self) -> String {
+        format!("{}#{}", self.class_name, self.name)
+    }
+}
+
+impl Discovery {
+    /// Names of the test classes that have tests, in order of appearance.
+    #[must_use]
+    pub fn classes(&self) -> &[String] {
+        &self.classes
+    }
+
+    /// Number of tests.
+    #[must_use]
+    pub const fn len(&self) -> usize {
+        self.tests.len()
+    }
+
+    /// Whether no test was found.
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.tests.is_empty()
+    }
+
+    /// The tests, in source order.
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_> {
+        Iter { classes: &self.classes, tests: self.tests.iter() }
+    }
+}
+
+impl<'a> IntoIterator for &'a Discovery {
+    type Item = TestDef<'a>;
+    type IntoIter = Iter<'a>;
+
+    fn into_iter(self) -> Iter<'a> {
+        self.iter()
+    }
+}
+
+/// Iterator over the tests of a [`Discovery`].
+#[derive(Debug, Clone)]
+pub struct Iter<'a> {
+    classes: &'a [String],
+    tests: slice::Iter<'a, Entry>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = TestDef<'a>;
+
+    fn next(&mut self) -> Option<TestDef<'a>> {
+        let entry = self.tests.next()?;
+        Some(TestDef {
+            class_name: &self.classes[entry.class],
+            class: entry.class,
+            name: &entry.name,
+            start_line: entry.start_line,
+            end_line: entry.end_line,
+        })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.tests.size_hint()
+    }
+}
+
+impl ExactSizeIterator for Iter<'_> {}
+
+impl FusedIterator for Iter<'_> {}
+
+/// A test file that could not be read.
+#[derive(Debug, thiserror::Error)]
+#[error("{}: {source}", path.display())]
+pub struct FileError {
+    /// The file.
+    pub path: PathBuf,
+    /// Why it could not be read.
+    #[source]
+    pub source: io::Error,
+}
+
+/// The tests defined in `source`, in source order. Syntax errors do not
+/// stop discovery: what Prism recovers is reported.
+#[must_use]
+pub fn discover(source: &[u8]) -> Discovery {
+    let result = ruby_prism::parse(source);
+    let mut visitor = Visitor::new(source);
+    visitor.visit(&result.node());
+    visitor.discovery
+}
+
+/// [`discover`] for every source, spread over the available cores. Results
+/// keep the order of `sources`.
+#[must_use]
+pub fn discover_many<S: AsRef<[u8]> + Sync>(sources: &[S]) -> Vec<Discovery> {
+    let mut found = vec![Discovery::default(); sources.len()];
+    let Ok(()) = fill(sources, &mut found, |source| {
+        Ok::<_, std::convert::Infallible>(discover(source.as_ref()))
+    });
+    found
+}
+
+/// Reads and discovers one file, parsed from the buffer it was read into.
+///
+/// # Errors
+///
+/// [`FileError`] when the file cannot be read.
+pub fn discover_file(path: impl AsRef<Path>) -> Result<Discovery, FileError> {
+    let path = path.as_ref();
+    let source = fs::read(path).map_err(|source| FileError { path: path.to_owned(), source })?;
+    Ok(discover(&source))
+}
+
+/// [`discover_file`] for every path, spread over the available cores.
+/// Results keep the order of `paths`.
+///
+/// # Errors
+///
+/// The [`FileError`] of the first unreadable file, in input order.
+pub fn discover_files<P: AsRef<Path> + Sync>(paths: &[P]) -> Result<Vec<Discovery>, FileError> {
+    let mut found = vec![Discovery::default(); paths.len()];
+    fill(paths, &mut found, |path| discover_file(path))?;
+    Ok(found)
+}
+
+/// Runs `f` over `items` on scoped threads, each writing its own slots of
+/// `out`. Returns the first error in input order.
+///
+/// Scoped threads: none outlives the call, so a process may fork right after
+/// (a pool such as rayon's would leave its threads behind in the parent and
+/// a broken pool in the child).
+fn fill<T, R, E>(items: &[T], out: &mut [R], f: impl Fn(&T) -> Result<R, E> + Sync) -> Result<(), E>
+where
+    T: Sync,
+    R: Send,
+    E: Send,
+{
+    let run = |items: &[T], out: &mut [R]| -> Result<(), E> {
+        for (item, slot) in items.iter().zip(out) {
+            *slot = f(item)?;
+        }
+        Ok(())
+    };
+    let run = &run;
+    let threads = thread::available_parallelism().map_or(1, NonZeroUsize::get).min(items.len());
+    if threads <= 1 {
+        return run(items, out);
+    }
+    let chunk = items.len().div_ceil(threads);
+    thread::scope(|scope| {
+        let workers: Vec<_> = items
+            .chunks(chunk)
+            .zip(out.chunks_mut(chunk))
+            .map(|(items, out)| scope.spawn(move || run(items, out)))
+            .collect();
+        // Chunks are in input order and each stops at its first error.
+        workers.into_iter().try_for_each(|worker| {
+            worker.join().unwrap_or_else(|panic| std::panic::resume_unwind(panic))
+        })
+    })
+}
+
+/// Walks the tree. Names are borrowed from the parse result until a test
+/// class needs its full name.
+struct Visitor<'pr> {
+    lines: Lines<'pr>,
+    /// Constant names of the enclosing namespaces, outermost first.
+    scope: Vec<&'pr str>,
+    /// Where the current namespace starts in `scope`: an absolute path
+    /// (`class ::A`) starts a new one.
+    scope_start: usize,
+    /// Set inside a namespace whose name is not a constant (`class foo::A`):
+    /// nothing below it has a known name.
+    dynamic: bool,
+    test_class: TestClass,
+    discovery: Discovery,
+}
+
+/// Byte offset to 1-based line, without an index: a cursor counts the
+/// newlines between the offsets it is asked for. A pre-order walk asks for
+/// start offsets in increasing order, and an end is counted from its start,
+/// so the source is read about once.
+struct Lines<'s> {
+    source: &'s [u8],
+    offset: usize,
+    line: usize,
+}
+
+impl Lines<'_> {
+    fn at(&mut self, offset: usize) -> usize {
+        let newlines =
+            |bytes: &[u8]| bytes.iter().fold(0, |n, &byte| n + usize::from(byte == b'\n'));
+        // Going back never passes line 1: overflow either way is a bug.
+        self.line = if offset >= self.offset {
+            self.line.strict_add(newlines(&self.source[self.offset..offset]))
+        } else {
+            self.line.strict_sub(newlines(&self.source[offset..self.offset]))
+        };
+        self.offset = offset;
+        self.line
+    }
+}
+
+/// Where the visitor stands: outside a test class, or inside one whose name
+/// is joined and stored when its first test is found (abstract base classes
+/// never are).
+#[derive(Debug, Clone, Copy)]
+enum TestClass {
+    Outside,
+    Pending,
+    Stored(usize),
+}
+
+impl<'pr> Visitor<'pr> {
+    const fn new(source: &'pr [u8]) -> Self {
+        Self {
+            lines: Lines { source, offset: 0, line: 1 },
+            scope: Vec::new(),
+            scope_start: 0,
+            dynamic: false,
+            test_class: TestClass::Outside,
+            discovery: Discovery { classes: Vec::new(), tests: Vec::new() },
+        }
+    }
+
+    fn within(&mut self, path: &Node<'pr>, test: bool, visit: impl FnOnce(&mut Self)) {
+        let (depth, scope_start, dynamic, test_class) =
+            (self.scope.len(), self.scope_start, self.dynamic, self.test_class);
+        let constant = self.push_constant(path).is_some();
+        self.dynamic |= !constant;
+        self.test_class =
+            if test && !self.dynamic { TestClass::Pending } else { TestClass::Outside };
+        visit(self);
+        self.scope.truncate(depth);
+        (self.scope_start, self.dynamic, self.test_class) = (scope_start, dynamic, test_class);
+    }
+
+    /// Pushes the names of a constant path onto the scope, or returns `None`
+    /// when a part of it is not a constant.
+    fn push_constant(&mut self, node: &Node<'pr>) -> Option<()> {
+        let (parent, name) = constant(node)?;
+        match parent {
+            Parent::None => {}
+            Parent::Root => self.scope_start = self.scope.len(),
+            Parent::Path(parent) => self.push_constant(&parent)?,
+        }
+        self.scope.push(name);
+        Some(())
+    }
+
+    /// Stores the current namespace as a class name, joined once.
+    fn add_class(&mut self) -> usize {
+        let names = &self.scope[self.scope_start..];
+        let length =
+            names.iter().map(|name| name.len()).sum::<usize>() + 2 * names.len().saturating_sub(1);
+        let mut class = String::with_capacity(length);
+        for (index, name) in names.iter().enumerate() {
+            if index > 0 {
+                class.push_str("::");
+            }
+            class.push_str(name);
+        }
+        self.discovery.classes.push(class);
+        self.discovery.classes.len() - 1
+    }
+
+    const fn in_test_class(&self) -> bool {
+        !matches!(self.test_class, TestClass::Outside)
+    }
+
+    fn record(&mut self, name: String, location: &Location<'_>) {
+        let class = match self.test_class {
+            TestClass::Outside => return,
+            TestClass::Stored(class) => class,
+            TestClass::Pending => {
+                let class = self.add_class();
+                self.test_class = TestClass::Stored(class);
+                class
+            }
+        };
+        let entry = Entry {
+            class,
+            name,
+            start_line: self.lines.at(location.start_offset()),
+            end_line: self.lines.at(location.end_offset()),
+        };
+        self.discovery.tests.push(entry);
+    }
+}
+
+impl<'pr> Visit<'pr> for Visitor<'pr> {
+    fn visit_module_node(&mut self, node: &ModuleNode<'pr>) {
+        self.within(&node.constant_path(), false, |visitor| {
+            ruby_prism::visit_module_node(visitor, node);
+        });
+    }
+
+    fn visit_class_node(&mut self, node: &ClassNode<'pr>) {
+        let test = node.superclass().is_some_and(|superclass| test_superclass(&superclass));
+        self.within(&node.constant_path(), test, |visitor| {
+            ruby_prism::visit_class_node(visitor, node);
+        });
+    }
+
+    /// `class << self` keeps the namespace, but its methods are not tests.
+    fn visit_singleton_class_node(&mut self, node: &SingletonClassNode<'pr>) {
+        let saved = std::mem::replace(&mut self.test_class, TestClass::Outside);
+        ruby_prism::visit_singleton_class_node(self, node);
+        self.test_class = saved;
+    }
+
+    /// A method body defines nothing on the class: not descended into.
+    fn visit_def_node(&mut self, node: &DefNode<'pr>) {
+        let name = node.name().as_slice();
+        if self.in_test_class()
+            && node.receiver().is_none()
+            && name.starts_with(b"test_")
+            && let Some(name) = utf8(name)
+        {
+            self.record(name.to_owned(), &node.location());
+        }
+    }
+
+    fn visit_call_node(&mut self, node: &CallNode<'pr>) {
+        if self.in_test_class()
+            && node.receiver().is_none()
+            && node.name().as_slice() == b"test"
+            && let Some(name) = declared_name(node)
+        {
+            self.record(name, &node.location());
+        }
+        ruby_prism::visit_call_node(self, node);
+    }
+}
+
+/// Whether a superclass is a constant path ending in `Test` or `TestCase`.
+fn test_superclass(node: &Node<'_>) -> bool {
+    constant_tail(node).is_some_and(|name| name.ends_with("Test") || name.ends_with("TestCase"))
+}
+
+/// The last name of a constant path, when every part of it is a constant.
+fn constant_tail<'pr>(node: &Node<'pr>) -> Option<&'pr str> {
+    let (parent, name) = constant(node)?;
+    if let Parent::Path(parent) = parent {
+        constant_tail(&parent)?;
+    }
+    Some(name)
+}
+
+/// What a constant's name is relative to.
+enum Parent<'pr> {
+    /// `A`: the enclosing namespace.
+    None,
+    /// `::A`: the top level.
+    Root,
+    /// `B::A`: another constant path (or an expression, for `foo::A`).
+    Path(Node<'pr>),
+}
+
+/// A constant node's own name, borrowed from the parse result, and what it
+/// is relative to. `None` for any other node.
+fn constant<'pr>(node: &Node<'pr>) -> Option<(Parent<'pr>, &'pr str)> {
+    if let Some(read) = node.as_constant_read_node() {
+        return Some((Parent::None, utf8(read.name().as_slice())?));
+    }
+    let path = node.as_constant_path_node()?;
+    let parent = path.parent().map_or(Parent::Root, Parent::Path);
+    Some((parent, utf8(path.name()?.as_slice())?))
+}
+
+/// `test_<name>` for `test "name"` with one plain string argument, the way
+/// `ActiveSupport::Testing::Declarative` names it:
+/// `"test_#{name.gsub(/\s+/, '_')}"`, Ruby's `\s` being space, `\t`, `\n`,
+/// `\v`, `\f` and `\r`.
+fn declared_name(node: &CallNode<'_>) -> Option<String> {
+    let arguments = node.arguments()?.arguments();
+    let mut arguments = arguments.iter();
+    let first = arguments.next()?;
+    if arguments.next().is_some() {
+        return None;
+    }
+    let string = first.as_string_node()?;
+    let name = utf8(string.unescaped())?;
+    let mut declared = String::with_capacity("test_".len() + name.len());
+    declared.push_str("test_");
+    let mut in_whitespace = false;
+    for c in name.chars() {
+        let whitespace = matches!(c, ' ' | '\t' | '\n' | '\x0b' | '\x0c' | '\r');
+        if !whitespace {
+            declared.push(c);
+        } else if !in_whitespace {
+            declared.push('_');
+        }
+        in_whitespace = whitespace;
+    }
+    Some(declared)
+}
+
+fn utf8(bytes: &[u8]) -> Option<&str> {
+    std::str::from_utf8(bytes).ok()
+}

data/ext/padded_cell_native/core/src/hash/tests.rs

@@ -0,0 +1,13 @@
+use super::*;
+
+#[test]
+fn matches_the_reference_values() {
+    let cases: &[(&str, u64)] = &[
+        ("", 0xcbf2_9ce4_8422_2325),
+        ("a", 0xaf63_dc4c_8601_ec8c),
+        ("foobar", 0x8594_4171_f739_67e8),
+    ];
+    for (input, expected) in cases {
+        assert_eq!(fnv1a64(input.as_bytes()), *expected, "input: {input:?}");
+    }
+}

data/ext/padded_cell_native/core/src/hash.rs

@@ -0,0 +1,13 @@
+//! FNV-1a 64. Shards split on it: unlike std's randomly seeded hasher, it is
+//! stable across runs, processes and machines, so CI shards agree.
+
+#[cfg(test)]
+mod tests;
+
+/// The FNV-1a 64-bit hash of `bytes`.
+#[must_use]
+pub fn fnv1a64(bytes: &[u8]) -> u64 {
+    bytes.iter().fold(0xcbf2_9ce4_8422_2325, |hash, &byte| {
+        (hash ^ u64::from(byte)).wrapping_mul(0x0000_0100_0000_01b3)
+    })
+}

data/ext/padded_cell_native/core/src/lib.rs

@@ -0,0 +1,30 @@
+//! Static Minitest discovery and deterministic test scheduling: the engine
+//! of the [padded_cell](https://github.com/seuros/padded_cell) test runner.
+//!
+//! ```
+//! let source = b"class UserTest < Minitest::Test\n  def test_valid\n  end\nend\n";
+//! let found = padded_cell::discover(source);
+//! let test = found.iter().next().ok_or("no test")?;
+//! assert_eq!(test.id(), "UserTest#test_valid");
+//! assert_eq!((test.start_line, test.end_line), (2, 3));
+//!
+//! let classes: Vec<&str> = found.iter().map(|test| test.class_name).collect();
+//! assert_eq!(padded_cell::plan(&classes, &[-1.0], 42, 0, 1), [vec![0]]);
+//! # Ok::<(), Box<dyn std::error::Error>>(())
+//! ```
+
+mod discover;
+mod hash;
+mod plan;
+mod rng;
+
+pub use discover::{
+    Discovery, FileError, Iter, TestDef, discover, discover_file, discover_files, discover_many,
+};
+pub use hash::fnv1a64;
+pub use plan::plan;
+pub use rng::SplitMix64;
+
+#[cfg(doctest)]
+#[doc = include_str!("../README.md")]
+struct ReadmeDoctests;

data/ext/padded_cell_native/core/src/plan/tests.rs

@@ -0,0 +1,61 @@
+use super::*;
+
+const UNKNOWN: f64 = -1.0;
+
+fn classes(tests: usize, classes: usize) -> Vec<String> {
+    (0..tests).map(|test| format!("Suite{}Test", test % classes)).collect()
+}
+
+#[test]
+fn every_test_lands_in_exactly_one_shard_with_its_class() {
+    let classes = classes(200, 23);
+    let durations = vec![UNKNOWN; classes.len()];
+    let shards: Vec<Vec<Vec<usize>>> =
+        (0..4).map(|shard| plan(&classes, &durations, 7, shard, 4)).collect();
+    let mut seen: Vec<usize> = shards.iter().flatten().flatten().copied().collect();
+    seen.sort_unstable();
+    assert_eq!(seen, (0..classes.len()).collect::<Vec<_>>());
+    for batch in shards.iter().flatten() {
+        assert!(batch.iter().all(|&test| classes[test] == classes[batch[0]]), "{batch:?}");
+    }
+    assert_eq!(shards.iter().flatten().count(), 23, "one batch per class");
+}
+
+#[test]
+fn the_seed_decides_the_order() {
+    let classes = classes(50, 5);
+    let durations = vec![UNKNOWN; classes.len()];
+    let first = plan(&classes, &durations, 42, 0, 1);
+    assert_eq!(first, plan(&classes, &durations, 42, 0, 1));
+    assert_ne!(first, plan(&classes, &durations, 43, 0, 1));
+}
+
+#[test]
+fn slowest_class_and_test_first_unknown_counts_as_the_median() {
+    // A: 1.0 + 3.0; B: 5.0; C: unknown, the median of 1.0, 3.0, 5.0 = 3.0.
+    let classes = ["A", "A", "B", "C"];
+    let durations = [1.0, 3.0, 5.0, UNKNOWN];
+    assert_eq!(plan(&classes, &durations, 0, 0, 1), [vec![2], vec![1, 0], vec![3]]);
+}
+
+#[test]
+fn pinned_order() {
+    // Same input, same expected batches in test/plan_test.rb: the engines
+    // agree even without the native extension.
+    let classes = ["A", "B", "A", "C", "B", "A", "D", "C"];
+    let durations = [0.5, UNKNOWN, 0.5, 2.0, UNKNOWN, 0.1, UNKNOWN, 0.5];
+    assert_eq!(
+        plan(&classes, &durations, 1234, 0, 1),
+        [vec![3, 7], vec![2, 0, 5], vec![1, 4], vec![6]]
+    );
+    let unknown = [UNKNOWN; 8];
+    assert_eq!(plan(&classes, &unknown, 1234, 0, 3), [vec![6], vec![0, 5, 2], vec![1, 4]]);
+    assert_eq!(plan(&classes, &unknown, 1234, 1, 3), Vec::<Vec<usize>>::new());
+    assert_eq!(plan(&classes, &unknown, 1234, 2, 3), [vec![3, 7]]);
+}
+
+#[test]
+fn nothing_to_plan() {
+    let classes: [&str; 0] = [];
+    assert_eq!(plan(&classes, &[], 0, 0, 1), Vec::<Vec<usize>>::new());
+}

data/ext/padded_cell_native/core/src/plan.rs

@@ -0,0 +1,109 @@
+//! Run order. Tests stay grouped by class, as Minitest and Rails run them:
+//! per-class setup such as fixtures loads once.
+//!
+//! 1. group tests by class, in order of first appearance;
+//! 2. keep the classes whose FNV-1a 64 hash modulo `shard_count` is
+//!    `shard_index`;
+//! 3. Fisher-Yates shuffle the classes, then each class's tests, with one
+//!    [`SplitMix64`] seeded by `seed`;
+//! 4. within a class, slowest test first; classes, slowest total first. Sorts
+//!    are stable, so ties keep the shuffled order. A negative duration means
+//!    unknown and counts as the median of the known ones (0.0 when none are
+//!    known).
+
+use std::cmp::Ordering;
+use std::collections::HashMap;
+
+use crate::hash::fnv1a64;
+use crate::rng::SplitMix64;
+
+#[cfg(test)]
+mod tests;
+
+/// Batches of test indices, one per class, in run order, for one shard.
+///
+/// `classes[i]` is the class of test `i` and `durations[i]` its last known run
+/// time in seconds, or any negative number when unknown.
+///
+/// # Panics
+///
+/// When `shard_count` is 0, or `durations` is shorter than `classes`.
+#[must_use]
+pub fn plan<S: AsRef<[u8]>>(
+    classes: &[S],
+    durations: &[f64],
+    seed: u64,
+    shard_index: u64,
+    shard_count: u64,
+) -> Vec<Vec<usize>> {
+    let mut batches = group(classes, shard_index, shard_count);
+    let mut rng = SplitMix64::new(seed);
+    shuffle(&mut batches, &mut rng);
+    for batch in &mut batches {
+        shuffle(batch, &mut rng);
+    }
+
+    let mut known = Vec::with_capacity(classes.len());
+    known.extend(batches.iter().flatten().map(|&test| durations[test]).filter(|d| *d >= 0.0));
+    let fallback = median(known);
+    let estimate = |test: usize| {
+        let duration = durations[test];
+        if duration < 0.0 { fallback } else { duration }
+    };
+    let total = |batch: &[usize]| batch.iter().fold(0.0, |sum, &test| sum + estimate(test));
+
+    // Stable sorts: ties keep the shuffled order.
+    for batch in &mut batches {
+        batch.sort_by(|&a, &b| descending(estimate(a), estimate(b)));
+    }
+    batches.sort_by(|a, b| descending(total(a), total(b)));
+    batches
+}
+
+/// The tests of each class in this shard, classes in order of first
+/// appearance. Each class is hashed once.
+fn group<S: AsRef<[u8]>>(classes: &[S], shard_index: u64, shard_count: u64) -> Vec<Vec<usize>> {
+    let mut slots: HashMap<&[u8], Option<usize>> = HashMap::new();
+    let mut batches: Vec<Vec<usize>> = Vec::new();
+    for (test, class) in classes.iter().enumerate() {
+        let class = class.as_ref();
+        let slot = *slots.entry(class).or_insert_with(|| {
+            (fnv1a64(class) % shard_count == shard_index).then(|| {
+                batches.push(Vec::new());
+                batches.len() - 1
+            })
+        });
+        if let Some(batch) = slot {
+            batches[batch].push(test);
+        }
+    }
+    batches
+}
+
+fn descending(a: f64, b: f64) -> Ordering {
+    b.total_cmp(&a)
+}
+
+fn shuffle<T>(items: &mut [T], rng: &mut SplitMix64) {
+    for i in (1..items.len()).rev() {
+        let bound = u64::try_from(i + 1).unwrap_or(u64::MAX);
+        // Below i + 1, so it fits.
+        let j = usize::try_from(rng.next_u64() % bound).unwrap_or(i);
+        items.swap(i, j);
+    }
+}
+
+/// The median of the known durations, 0.0 without any. Selection, not a
+/// full sort: the value is the same.
+fn median(mut known: Vec<f64>) -> f64 {
+    let len = known.len();
+    if len == 0 {
+        return 0.0;
+    }
+    let (lower, &mut upper, _) = known.select_nth_unstable_by(len / 2, f64::total_cmp);
+    if !len.is_multiple_of(2) {
+        return upper;
+    }
+    let below = lower.iter().copied().max_by(f64::total_cmp).unwrap_or(upper);
+    below.midpoint(upper)
+}