refactor least_satisfying to eliminate duplicated start date checks

This occurred during nighty testing when a start date is defined on the command line

Author: chrissimpkins

src/least_satisfying.rs

@@ -8,7 +8,7 @@
 use std::collections::BTreeMap;
 use std::fmt;
 
-pub fn least_satisfying<T, P>(slice: &[T], mut predicate: P) -> usize
+pub fn least_satisfying<T, P>(slice: &[T], start_check: bool, mut predicate: P) -> usize
 where
     T: fmt::Display + fmt::Debug,
     P: FnMut(&T) -> Satisfies,
@@ -18,12 +18,14 @@ where
     let mut unknown_ranges: Vec<(usize, usize)> = Vec::new();
     let mut rm_no = 0; // presume that the slice starts with a no
 
-    eprintln!("verifying the start of the range does not reproduce the regression");
-    match predicate(rm_no) {
-        Satisfies::No => {
-            eprintln!("confirmed the start of the range does not reproduce the regression")
+    if start_check {
+        eprintln!("verifying the start of the range does not reproduce the regression");
+        match predicate(rm_no) {
+            Satisfies::No => {
+                eprintln!("confirmed the start of the range does not reproduce the regression")
+            }
+            _ => panic!("the start of the range to test must not reproduce the regression"),
         }
-        _ => panic!("the start of the range to test must not reproduce the regression"),
     }
 
     let mut lm_yes = slice.len() - 1; // presume that the slice ends with a yes
@@ -103,59 +105,111 @@ mod tests {
             }
         }
 
-        let res = least_satisfying(&satisfies_v, |i| *i);
+        let res = least_satisfying(&satisfies_v, true, |i| *i);
         let exp = first_yes.unwrap();
         TestResult::from_bool(res == exp)
     }
 
     #[test]
     fn least_satisfying_1() {
         assert_eq!(
-            least_satisfying(&[No, Unknown, Unknown, No, Yes], |i| *i),
+            least_satisfying(&[No, Unknown, Unknown, No, Yes], true,|i| *i),
+            4
+        );
+    }
+
+    #[test]
+    fn least_satisfying_1f() {
+        assert_eq!(
+            least_satisfying(&[No, Unknown, Unknown, No, Yes], false,|i| *i),
             4
         );
     }
 
     #[test]
     fn least_satisfying_2() {
         assert_eq!(
-            least_satisfying(&[No, Unknown, Yes, Unknown, Yes], |i| *i),
+            least_satisfying(&[No, Unknown, Yes, Unknown, Yes], true, |i| *i),
+            2
+        );
+    }
+
+    #[test]
+    fn least_satisfying_2f() {
+        assert_eq!(
+            least_satisfying(&[No, Unknown, Yes, Unknown, Yes], false, |i| *i),
             2
         );
     }
 
     #[test]
     fn least_satisfying_3() {
-        assert_eq!(least_satisfying(&[No, No, No, No, Yes], |i| *i), 4);
+        assert_eq!(least_satisfying(&[No, No, No, No, Yes], true, |i| *i), 4);
+    }
+
+    #[test]
+    fn least_satisfying_3f() {
+        assert_eq!(least_satisfying(&[No, No, No, No, Yes], false, |i| *i), 4);
     }
 
     #[test]
     fn least_satisfying_4() {
-        assert_eq!(least_satisfying(&[No, No, Yes, Yes, Yes], |i| *i), 2);
+        assert_eq!(least_satisfying(&[No, No, Yes, Yes, Yes], true, |i| *i), 2);
+    }
+
+    #[test]
+    fn least_satisfying_4f() {
+        assert_eq!(least_satisfying(&[No, No, Yes, Yes, Yes], false, |i| *i), 2);
     }
 
     #[test]
     fn least_satisfying_5() {
-        assert_eq!(least_satisfying(&[No, Yes, Yes, Yes, Yes], |i| *i), 1);
+        assert_eq!(least_satisfying(&[No, Yes, Yes, Yes, Yes], true, |i| *i), 1);
+    }
+
+    #[test]
+    fn least_satisfying_5f() {
+        assert_eq!(least_satisfying(&[No, Yes, Yes, Yes, Yes], false, |i| *i), 1);
     }
 
     #[test]
     fn least_satisfying_6() {
         assert_eq!(
-            least_satisfying(&[No, Yes, Yes, Unknown, Unknown, Yes, Unknown, Yes], |i| *i),
+            least_satisfying(&[No, Yes, Yes, Unknown, Unknown, Yes, Unknown, Yes], true, |i| *i),
+            1
+        );
+    }
+
+    #[test]
+    fn least_satisfying_6f() {
+        assert_eq!(
+            least_satisfying(&[No, Yes, Yes, Unknown, Unknown, Yes, Unknown, Yes], false, |i| *i),
             1
         );
     }
 
     #[test]
     fn least_satisfying_7() {
-        assert_eq!(least_satisfying(&[No, Yes, Unknown, Yes], |i| *i), 1);
+        assert_eq!(least_satisfying(&[No, Yes, Unknown, Yes], true, |i| *i), 1);
+    }
+
+    #[test]
+    fn least_satisfying_7f() {
+        assert_eq!(least_satisfying(&[No, Yes, Unknown, Yes], false, |i| *i), 1);
     }
 
     #[test]
     fn least_satisfying_8() {
         assert_eq!(
-            least_satisfying(&[No, Unknown, No, No, Unknown, Yes, Yes], |i| *i),
+            least_satisfying(&[No, Unknown, No, No, Unknown, Yes, Yes], true,|i| *i),
+            5
+        );
+    }
+
+    #[test]
+    fn least_satisfying_8f() {
+        assert_eq!(
+            least_satisfying(&[No, Unknown, No, No, Unknown, Yes, Yes], false,|i| *i),
             5
         );
     }

src/main.rs

@@ -1298,17 +1298,19 @@ fn bisect_nightlies(cfg: &Config, client: &Client) -> Result<BisectionResult, Er
         }
         match t.install(client, &dl_spec) {
             Ok(()) => {
+                eprintln!("verifying the start of the range does not reproduce the regression");
                 let outcome = t.test(&cfg);
 
                 if !cfg.args.preserve {
                     let _ = t.remove(&dl_spec);
                 }
 
                 if let TestOutcome::Baseline = outcome {
+                    eprintln!("confirmed {} does not reproduce the regression", t);
                     first_success = Some(nightly_date);
                     break;
                 } else if has_start {
-                    return Err(format_err!("the --start nightly has the regression"))?;
+                    return Err(format_err!("the start of the range to test must not reproduce the regression"))?;
                 } else {
                     last_failure = nightly_date;
                 }
@@ -1322,7 +1324,7 @@ fn bisect_nightlies(cfg: &Config, client: &Client) -> Result<BisectionResult, Er
                     let _ = t.remove(&dl_spec);
                 }
                 if has_start {
-                    return Err(format_err!("could not find the --start nightly"))?;
+                    return Err(format_err!("could not find {}", t))?;
                 }
             }
             Err(e) => {
@@ -1344,7 +1346,11 @@ fn bisect_nightlies(cfg: &Config, client: &Client) -> Result<BisectionResult, Er
         ToolchainSpec::Nightly { date: last_failure },
     );
 
-    let found = least_satisfying(&toolchains, |t| {
+    // First success check has been performed above so it is not necessary
+    // to repeat it within the least_satisfying function in the call here.
+    // Set `start_check` to false to prevent a repeat check on the same
+    // nightly in `least_satisfying`
+    let found = least_satisfying(&toolchains, false, |t| {
         match t.install(&client, &dl_spec) {
             Ok(()) => {
                 let outcome = t.test(&cfg);
@@ -1488,7 +1494,7 @@ fn bisect_ci_in_commits(
         .collect::<Vec<_>>();
 
     eprintln!("testing commits");
-    let found = least_satisfying(&toolchains, |t| {
+    let found = least_satisfying(&toolchains, true,|t| {
         eprintln!("installing {}", t);
         match t.install(&client, &dl_spec) {
             Ok(()) => {