test(core,kernel): inline format args

Some instances were not caught by `clippy::uninlined_format_args`
because this lint only recognizes a small predefined set of formatting
macros at the moment.

Author: yvt

src/r3_core/src/utils/binary_heap/tests.rs

@@ -46,28 +46,28 @@ fn test_inner<T: BinaryHeap + Default + super::VecLike<Element = usize> + std::f
     let mut subject = T::default();
     let mut reference = Vec::new();
 
-    log::debug!("max_len = {}, bytecode len = {}", max_len, bytecode.len());
+    log::debug!("max_len = {max_len}, bytecode len = {}", bytecode.len());
 
     for cmd in interpret(&bytecode, max_len) {
-        log::trace!("    {:?}", cmd);
+        log::trace!("    {cmd:?}");
         match cmd {
             Cmd::Insert(value) => {
                 let i = subject.heap_push(value, Ctx);
-                log::trace!("     → {}", i);
+                log::trace!("     → {i}");
 
                 let i = reference.binary_search(&value).unwrap_or_else(|x| x);
                 reference.insert(i, value);
             }
             Cmd::Remove(i) => {
                 let out_subject = subject.heap_remove(i, Ctx).unwrap();
-                log::trace!("     → {}", out_subject);
+                log::trace!("     → {out_subject}");
 
                 let i_ref = reference.binary_search(&out_subject).unwrap();
                 reference.remove(i_ref);
             }
         }
-        log::trace!("[sorted: {:?}]", reference);
-        log::trace!("[subject: {:?}]", subject);
+        log::trace!("[sorted: {reference:?}]");
+        log::trace!("[subject: {subject:?}]");
         if subject.len() > 0 {
             assert_eq!(subject[0], reference[0]);
         }
@@ -120,7 +120,7 @@ impl BinaryHeapCtx<El> for TrackingCtx<'_> {
 
     fn on_move(&mut self, e: &mut El, new_index: usize) {
         self.el_position[e.id] = Some(new_index);
-        log::trace!("         on_move{:?}", (e, new_index));
+        log::trace!("         on_move({e:?}, {new_index})");
     }
 }
 
@@ -135,29 +135,29 @@ fn position_tracking(bytecode: Vec<u8>) {
     log::debug!("bytecode len = {}", bytecode.len());
 
     for cmd in interpret(&bytecode, usize::MAX) {
-        log::trace!("    {:?}", cmd);
+        log::trace!("    {cmd:?}");
         match cmd {
             Cmd::Insert(value) => {
                 let id = el_position.len();
                 el_position.push(None);
                 let i = subject.heap_push(El { value, id }, TrackingCtx { el_position });
-                log::trace!("     → {}", i);
+                log::trace!("     → {i}");
 
                 // `on_move` should have reported the position for the
                 // newly-inserted element
                 assert_eq!(el_position[id], Some(i));
             }
             Cmd::Remove(i) => {
                 let out_subject = subject.heap_remove(i, TrackingCtx { el_position }).unwrap();
-                log::trace!("     → {:?}", out_subject);
+                log::trace!("     → {out_subject:?}");
 
                 // For a removed element, we must modify `el_position` manually
                 el_position[out_subject.id] = None;
             }
         }
 
-        log::trace!("[subject: {:?}]", subject);
-        log::trace!("[el_position: {:?}]", el_position);
+        log::trace!("[subject: {subject:?}]");
+        log::trace!("[el_position: {el_position:?}]");
 
         // Check if `el_position` correctly represents
         // the current state of `subject`

src/r3_core/src/utils/binary_search.rs

@@ -45,7 +45,7 @@ mod tests {
     fn lower_bound(mut values: Vec<u32>, arbitrary_value: u32) {
         values.sort();
 
-        log::debug!("values = {:?}", values);
+        log::debug!("values = {values:?}");
 
         for (i, &e) in values.iter().enumerate() {
             let mut expected = i;
@@ -54,12 +54,7 @@ mod tests {
             }
 
             let got = lower_bound!(values.len(), |i| values[i] < e);
-            log::debug!(
-                "  lower_bound(values[{}]) = {} (expected {})",
-                i,
-                got,
-                expected
-            );
+            log::debug!("  lower_bound(values[{i}]) = {got} (expected {expected})");
 
             assert_eq!(got, expected);
         }
@@ -70,29 +65,24 @@ mod tests {
             }
             let mid = win[0] + (win[1] - win[0]) / 2;
             let got = lower_bound!(values.len(), |i| values[i] < mid);
-            log::debug!(
-                "  lower_bound(mean(values[{}] + values[{} + 1])) = {}",
-                i,
-                i,
-                got
-            );
+            log::debug!("  lower_bound(mean(values[{i}] + values[{i} + 1])) = {got}");
             assert_eq!(got, i + 1);
         }
 
         if values.is_empty() {
             let got = lower_bound!(values.len(), |i| values[i] < arbitrary_value);
-            log::debug!("  lower_bound({}) = {}", arbitrary_value, got);
+            log::debug!("  lower_bound({arbitrary_value}) = {got}");
             assert_eq!(got, 0);
         } else {
             if *values.first().unwrap() > 0 {
                 #[allow(unused_comparisons)]
                 let got = lower_bound!(values.len(), |i| values[i] < 0);
-                log::debug!("  lower_bound(0) = {}", got);
+                log::debug!("  lower_bound(0) = {got}");
                 assert_eq!(got, 0);
             }
             if *values.last().unwrap() < u32::MAX {
                 let got = lower_bound!(values.len(), |i| values[i] < u32::MAX);
-                log::debug!("  lower_bound({}) = {}", u32::MAX, got);
+                log::debug!("  lower_bound({}) = {got}", u32::MAX);
                 assert_eq!(got, values.len());
             }
         }