feat: greatly improve performance and realism of baseline-atomic test. (#30)

We now set a fixed amount of 'big' steps along with one of those chunks
being a range where the step-size is one commit at a time, which
might be the way changes are obtained in the future.

Author: Byron

tests/baseline_atomic.rs

@@ -5,5 +5,5 @@ mod shared;
 #[cfg_attr(debug_assertions, ignore)]
 #[test]
 fn one_per_commit() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    shared::baseline(Step::OnePerCommit)
+    shared::baseline(Step::Realistic { partitions: 40 })
 }

tests/shared/mod.rs

@@ -3,8 +3,13 @@ use crates_index_diff::Change::*;
 
 #[allow(dead_code)]
 pub enum Step {
-    Partitioned { size: usize },
-    OnePerCommit,
+    Partitioned {
+        size: usize,
+    },
+    Realistic {
+        /// Like `Partitioned::size, and used to have big steps until the last partition which is then single-steped entirely.
+        partitions: usize,
+    },
 }
 
 pub fn baseline(mode: Step) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
@@ -37,16 +42,21 @@ pub fn baseline(mode: Step) -> Result<(), Box<dyn std::error::Error + Send + Syn
                     .collect::<Result<Vec<_>, _>>()?;
 
                 // This could be more complex, like jumping to landmarks like 'Delete crate(s)' and so forth.
-                let partitions = match mode {
-                    Step::Partitioned { size } => size,
-                    Step::OnePerCommit => commits.len(),
+                let (partitions, last_partition_is_single_step) = match mode {
+                    Step::Partitioned { size } => (size, false),
+                    Step::Realistic { partitions } => (partitions, true),
                 };
                 let chunk_size = (commits.len() / partitions).max(1);
-                let mut steps = (0..commits.len()).step_by(chunk_size).collect::<Vec<_>>();
+                let mut steps = if last_partition_is_single_step && chunk_size > 1 {
+                    let mut steps: Vec<_> = (0..chunk_size).collect();
+                    steps.extend((chunk_size..commits.len()).step_by(chunk_size));
+                    steps
+                } else {
+                    (0..commits.len()).step_by(chunk_size).collect::<Vec<_>>()
+                };
                 if *steps.last().expect("at least 1") != commits.len() - 1 {
                     steps.push(commits.len() - 1);
                 }
-
                 let mut versions = HashMap::default();
                 let mut previous = None;
                 let num_steps = steps.len();