bisector 1.0.0

Flexible bisect implementatation which allows the use the bisection method on arbitrary data types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use super::super::*;

#[derive(Debug)]
struct FailOutput {
    message: String,
    value: u64,
    exit_code: i32,
}

fn run_external_command(version: &semver::Version) -> ConvergeTo<u64, FailOutput> {
    // Requires https://github.com/foresterre/exit-with-code to be installed and available on the PATH
    let command = std::process::Command::new("ewc")
        .arg(&format!("{}", version.minor))
        .stderr(std::process::Stdio::piped())
        .spawn()
        .unwrap();
    let status = command.wait_with_output().unwrap();

    if status.status.success() {
        ConvergeTo::Left(version.minor)
    } else {
        ConvergeTo::Right(FailOutput {
            message: String::from_utf8(status.stderr).unwrap(),
            value: version.minor,
            exit_code: status.status.code().unwrap(),
        })
    }
}

#[test]
fn bisect_with_command() {
    let versions = [
        semver::Version::new(2, 100, 0),
        semver::Version::new(1, 50, 0),
        semver::Version::new(1, 50, 0),
        semver::Version::new(1, 10, 0),
        semver::Version::new(1, 9, 0),
        semver::Version::new(1, 8, 0),
        semver::Version::new(0, 0, 0), // will succeed with ewc 0
    ];

    let bisect = Bisector::new(&versions);

    let mut failures = vec![];

    let mut i = Indices::from_bisector(&bisect);
    while let Step {
        indices,
        result: Some(t),
    } = bisect.bisect(|v| run_external_command(v), i)
    {
        i = indices;

        if let ConvergeTo::Right(f) = t {
            failures.push(f);
        }
    }

    assert_eq!(failures.len(), 2);

    assert_eq!(failures[0].exit_code, 10);
    assert!(failures[0].message.is_empty());
    assert_eq!(failures[0].value, 10);

    assert_eq!(failures[1].exit_code, 8);
    assert!(failures[1].message.is_empty());
    assert_eq!(failures[1].value, 8);
}