assertions WRT allocation and panics

Signed-off-by: Pierre Fenoll <pierrefenoll@gmail.com>

Author: fenollp

Cargo.lock

@@ -8,14 +8,22 @@ keywords = ["xargs", "buildkit", "docker", "visualization"]
 license = "MIT"
 repository = "https://github.com/fenollp/buildxargs"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
+assert_no_alloc = "1"
 clap = { version = "4", features = ["derive", "color"] }
+no-panic = "0.1"
 shlex = "1"
 tempfile = "3"
 
 [dev-dependencies]
 assert_cmd = "2"
 assert_fs = "1"
 predicates = "3"
+
+[profile.dev]
+lto = "thin"  # no_panic
+opt-level = 1 # no_panic
+
+[profile.test]
+lto = "thin"  # no_panic
+opt-level = 1 # no_panic

Cargo.toml

@@ -0,0 +1,58 @@
+use assert_no_alloc::assert_no_alloc;
+use no_panic::no_panic;
+
+// no_panic
+
+// Our business logic says there's no way this panics,
+// so let's ensure/enforce/document it!
+
+// cf https://github.com/dtolnay/no-panic/issues/8 for inlining
+// Also, push for proc-macro on expressions!
+
+#[inline(never)]
+#[no_panic]
+fn f(x: u32) -> Option<u32> {
+    Some(x)
+}
+
+#[inline(never)]
+#[no_panic]
+#[test]
+fn do_not_panic_with_unwrap() {
+    assert_eq!(20, f(20).unwrap());
+}
+
+#[inline(never)]
+#[no_panic]
+#[test]
+fn do_not_panic_with_expect() {
+    assert_eq!(21, f(21).expect("unreachable"));
+}
+
+#[inline(never)]
+#[no_panic]
+#[test]
+fn do_not_panic_with_unwrap_unchecked() {
+    assert_eq!(1, unsafe { f(1).unwrap_unchecked() });
+}
+
+// no_alloc
+
+//https://github.com/Windfisch/rust-assert-no-alloc/issues/11
+
+#[test]
+#[should_panic]
+fn does_actually_alloc() {
+    assert_no_alloc(|| {
+        let xs: Vec<i64> = Vec::with_capacity(42);
+        assert_eq!(42, xs.capacity());
+    });
+}
+
+#[test]
+fn does_not_alloc() {
+    assert_no_alloc(|| {
+        let xs: Vec<i64> = Vec::with_capacity(0);
+        assert_eq!(0, xs.capacity());
+    });
+}

src/contracts.rs

@@ -1,5 +1,8 @@
-use std::collections::{hash_map::Entry::Vacant, HashMap};
+use std::collections::{hash_map::Entry, HashMap};
 
+use assert_no_alloc::assert_no_alloc;
+
+// TODO: #[no_panic]
 // try_quick executes f on values slice and subslices when an error is returned
 // until maxdepth amounts of slicing happened.
 // It returns the indices of values that kept returning errors.
@@ -21,38 +24,50 @@ where
     let mut ixs: Vec<usize> = (0..values.len()).collect();
     let mut passed: Vec<usize> = Vec::with_capacity(values.len());
     let mut failed: HashMap<usize, String> = HashMap::with_capacity(values.len());
-    for _ in 1..=maxdepth {
-        let ixsn = ixs.len();
-        if ixsn == 0 {
-            return Ok(HashMap::new());
-        }
-        if ixsn / 2 == 0 {
-            break;
-        }
-        for indices in ixs.chunks(ixsn / 2) {
-            xs.clear();
-            for i in indices {
-                xs.push(values[*i].clone());
+    assert_no_alloc(|| {
+        for _ in 1..=maxdepth {
+            let ixsn = ixs.len();
+            if ixsn == 0 {
+                return Ok(HashMap::new());
             }
+            if ixsn / 2 == 0 {
+                break;
+            }
+            for indices in ixs.chunks(ixsn / 2) {
+                xs.clear();
+                for i in indices {
+                    xs.push(values[*i].clone());
+                }
 
-            match f(&xs) {
-                Ok(()) => passed.extend(indices.iter()),
-                Err(e) => {
-                    for &ix in indices {
-                        if let Vacant(entry) = failed.entry(ix) {
-                            let _ = entry.insert(format!("{e}")); // TODO: e.clone()
+                match f(&xs) {
+                    Ok(()) => passed.extend(indices.iter()),
+                    Err(e) => {
+                        for &ix in indices {
+                            if let Entry::Vacant(entry) = failed.entry(ix) {
+                                let _ = entry.insert(format!("{e}")); // TODO: e.clone()
+                            }
                         }
                     }
                 }
             }
-        }
-        for &index in &passed {
-            let _ = failed.remove(&index);
-            if let Some(ix) = ixs.iter().position(|&ix| ix == index) {
-                let _ = ixs.swap_remove(ix);
+            for &index in &passed {
+                let _ = failed.remove(&index);
+                if let Some(ix) = ixs.iter().position(|&ix| ix == index) {
+                    let _ = ixs.swap_remove(ix);
+                }
             }
         }
-    }
 
-    Ok(failed)
+        Ok(failed)
+    })
+}
+
+#[test]
+fn single_bad_job() {
+    let xs = vec![0];
+    let err = format!("{}", "NaN".parse::<u32>().unwrap_err());
+    for d in 0..=9 {
+        let ixs_failed = try_quick(&xs, d, |_subxs| Err(err.clone()));
+        assert_eq!(ixs_failed, Err(err.clone()));
+    }
 }