OSDK check and clippy with cfg(ktest)

Makefile

@@ -210,7 +210,7 @@ format:
 	@make --no-print-directory -C test format
 
 .PHONY: check
-check: $(CARGO_OSDK)
+check: initramfs $(CARGO_OSDK)
 	@./tools/format_all.sh --check   	# Check Rust format issues
 	@# Check if STD_CRATES and NOSTD_CRATES combined is the same as all workspace members
 	@sed -n '/^\[workspace\]/,/^\[.*\]/{/members = \[/,/\]/p}' Cargo.toml | \

kernel/aster-nix/src/fs/exfat/mod.rs

@@ -484,7 +484,7 @@ mod test {
         let mut read = vec![0u8; BUF_SIZE];
         let read_after_rename = a_inode_new.read_bytes_at(0, &mut read);
         assert!(
-            read_after_rename.is_ok() && read_after_rename.clone().unwrap() == BUF_SIZE,
+            read_after_rename.is_ok() && read_after_rename.unwrap() == BUF_SIZE,
             "Fail to read after rename: {:?}",
             read_after_rename.unwrap_err()
         );
@@ -495,8 +495,7 @@ mod test {
         let new_buf = vec![7u8; NEW_BUF_SIZE];
         let new_write_after_rename = a_inode_new.write_bytes_at(0, &new_buf);
         assert!(
-            new_write_after_rename.is_ok()
-                && new_write_after_rename.clone().unwrap() == NEW_BUF_SIZE,
+            new_write_after_rename.is_ok() && new_write_after_rename.unwrap() == NEW_BUF_SIZE,
             "Fail to write file after rename: {:?}",
             new_write_after_rename.unwrap_err()
         );
@@ -984,7 +983,7 @@ mod test {
         let mut file_names: Vec<String> = (0..file_num).map(|x| x.to_string()).collect();
         file_names.sort();
         let mut file_inodes: Vec<Arc<dyn Inode>> = Vec::new();
-        for (_file_id, file_name) in file_names.iter().enumerate() {
+        for file_name in file_names.iter() {
             let inode = create_file(root.clone(), file_name);
             file_inodes.push(inode);
         }

kernel/aster-nix/src/fs/exfat/utils.rs

@@ -60,7 +60,6 @@ impl DosTimestamp {
         #[cfg(not(ktest))]
         {
             use crate::time::clocks::RealTimeClock;
-
             DosTimestamp::from_duration(RealTimeClock::get().read_time())
         }
 
@@ -68,9 +67,9 @@ impl DosTimestamp {
         #[cfg(ktest)]
         {
             use crate::time::SystemTime;
-            return DosTimestamp::from_duration(
+            DosTimestamp::from_duration(
                 SystemTime::UNIX_EPOCH.duration_since(&SystemTime::UNIX_EPOCH)?,
-            );
+            )
         }
     }
 

kernel/aster-nix/src/fs/pipe.rs

@@ -331,7 +331,7 @@ mod test {
     #[ktest]
     fn test_read_closed() {
         test_blocking(
-            |writer| drop(writer),
+            drop,
             |reader| {
                 let mut buf = [0; 1];
                 assert_eq!(reader.read(&mut writer_from(&mut buf)).unwrap(), 0);
@@ -350,7 +350,7 @@ mod test {
                     Errno::EPIPE
                 );
             },
-            |reader| drop(reader),
+            drop,
             Ordering::WriteThenRead,
         );
     }

kernel/aster-nix/src/process/sync/condvar.rs

@@ -291,7 +291,7 @@ mod test {
             while !*started {
                 started = cvar.wait(started).unwrap_or_else(|err| err.into_guard());
             }
-            assert_eq!(*started, true);
+            assert!(*started);
         }
     }
 
@@ -316,7 +316,7 @@ mod test {
                     .wait_timeout(started, Duration::from_secs(1))
                     .unwrap_or_else(|err| err.into_guard());
             }
-            assert_eq!(*started, true);
+            assert!(*started);
         }
     }
 
@@ -338,7 +338,7 @@ mod test {
             let started = cvar
                 .wait_while(lock.lock(), |started| *started)
                 .unwrap_or_else(|err| err.into_guard());
-            assert_eq!(*started, false);
+            assert!(!*started);
         }
     }
 
@@ -360,7 +360,7 @@ mod test {
             let (started, _) = cvar
                 .wait_timeout_while(lock.lock(), Duration::from_secs(1), |started| *started)
                 .unwrap_or_else(|err| err.into_guard());
-            assert_eq!(*started, false);
+            assert!(!*started);
         }
     }
 }

kernel/aster-nix/src/taskless.rs

@@ -216,7 +216,7 @@ mod test {
         let mut counter = 0;
 
         // Schedule this taskless for `SCHEDULE_TIMES`.
-        while taskless.is_scheduled.load(Ordering::Acquire) == false {
+        while !taskless.is_scheduled.load(Ordering::Acquire) {
             taskless.schedule();
             counter += 1;
             if counter == SCHEDULE_TIMES {
@@ -227,7 +227,9 @@ mod test {
         // Wait for all taskless having finished.
         while taskless.is_running.load(Ordering::Acquire)
             || taskless.is_scheduled.load(Ordering::Acquire)
-        {}
+        {
+            core::hint::spin_loop()
+        }
 
         assert_eq!(counter, COUNTER.load(Ordering::Relaxed));
     }

kernel/aster-nix/src/vm/vmar/options.rs

@@ -136,7 +136,7 @@ impl<R> VmarChildOptions<R> {
 #[cfg(ktest)]
 mod test {
     use aster_rights::Full;
-    use ostd::{mm::VmIo, prelude::*};
+    use ostd::prelude::*;
 
     use super::*;
     use crate::vm::{

kernel/libs/aster-util/src/coeff.rs

@@ -134,8 +134,8 @@ mod test {
     #[ktest]
     fn calculation() {
         let coeff = Coeff::new(23456, 56789, 1_000_000_000);
-        assert!(coeff * 0 as u64 == 0);
-        assert!(coeff * 100 as u64 == 100 * 23456 / 56789);
-        assert!(coeff * 1_000_000_000 as u64 == 1_000_000_000 * 23456 / 56789);
+        assert!(coeff * 0_u64 == 0);
+        assert!(coeff * 100_u64 == 100 * 23456 / 56789);
+        assert!(coeff * 1_000_000_000_u64 == 1_000_000_000 * 23456 / 56789);
     }
 }

osdk/src/cli.rs

@@ -49,9 +49,9 @@ pub fn main() {
         OsdkSubcommand::Test(test_args) => {
             execute_test_command(&load_config(&test_args.common_args), test_args);
         }
-        OsdkSubcommand::Check(args) => execute_forwarded_command("check", &args.args),
-        OsdkSubcommand::Clippy(args) => execute_forwarded_command("clippy", &args.args),
-        OsdkSubcommand::Doc(args) => execute_forwarded_command("doc", &args.args),
+        OsdkSubcommand::Check(args) => execute_forwarded_command("check", &args.args, true),
+        OsdkSubcommand::Clippy(args) => execute_forwarded_command("clippy", &args.args, true),
+        OsdkSubcommand::Doc(args) => execute_forwarded_command("doc", &args.args, false),
     }
 }
 

osdk/src/commands/mod.rs

@@ -16,8 +16,10 @@ pub use self::{
 
 use crate::arch::get_default_arch;
 
-/// Execute the forwarded cargo command with args containing the subcommand and its arguments.
-pub fn execute_forwarded_command(subcommand: &str, args: &Vec<String>) -> ! {
+/// Execute the forwarded cargo command with arguments.
+///
+/// The `cfg_ktest` parameter controls whether `cfg(ktest)` is enabled.
+pub fn execute_forwarded_command(subcommand: &str, args: &Vec<String>, cfg_ktest: bool) -> ! {
     let mut cargo = util::cargo();
     cargo.arg(subcommand).args(util::COMMON_CARGO_ARGS);
     if !args.contains(&"--target".to_owned()) {
@@ -27,6 +29,11 @@ pub fn execute_forwarded_command(subcommand: &str, args: &Vec<String>) -> ! {
 
     let env_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
     let rustflags = env_rustflags + " --check-cfg cfg(ktest)";
+    let rustflags = if cfg_ktest {
+        rustflags + " --cfg ktest"
+    } else {
+        rustflags
+    };
 
     cargo.env("RUSTFLAGS", rustflags);
 

osdk/test-kernel/src/tree.rs

@@ -221,9 +221,7 @@ mod tests {
 
     macro_rules! gen_test_case {
         () => {{
-            fn dummy_fn() {
-                ()
-            }
+            fn dummy_fn() {}
             let mut tree = KtestTree::new();
             let new = |m: &'static str, f: &'static str, p: &'static str| {
                 KtestItem::new(
@@ -295,7 +293,7 @@ mod tests {
             for mov in crate_.iter() {
                 let module = mov;
                 for test in module.iter() {
-                    collection.push(&test);
+                    collection.push(test);
                 }
             }
         }

ostd/src/lib.rs

@@ -119,6 +119,7 @@ mod test {
     use crate::prelude::*;
 
     #[ktest]
+    #[allow(clippy::eq_op)]
     fn trivial_assertion() {
         assert_eq!(0, 0);
     }

ostd/src/mm/dma/dma_stream.rs

@@ -334,9 +334,10 @@ mod test {
             .alloc_contiguous()
             .unwrap();
         let vm_segment_child = vm_segment_parent.range(0..1);
-        let _dma_stream_parent =
+        let dma_stream_parent =
             DmaStream::map(vm_segment_parent, DmaDirection::Bidirectional, false);
         let dma_stream_child = DmaStream::map(vm_segment_child, DmaDirection::Bidirectional, false);
+        assert!(dma_stream_parent.is_ok());
         assert!(dma_stream_child.is_err());
     }
 

ostd/src/sync/atomic_bits.rs

@@ -313,24 +313,24 @@ mod test {
     fn set_get() {
         let bits = AtomicBits::new_zeroes(128);
         for i in 0..bits.len() {
-            assert!(bits.get(i) == false);
+            assert!(!bits.get(i));
 
             bits.set(i, true);
-            assert!(bits.get(i) == true);
+            assert!(bits.get(i));
 
             bits.set(i, false);
-            assert!(bits.get(i) == false);
+            assert!(!bits.get(i));
         }
 
         let bits = AtomicBits::new_ones(128);
         for i in 0..bits.len() {
-            assert!(bits.get(i) == true);
+            assert!(bits.get(i));
 
             bits.set(i, false);
-            assert!(bits.get(i) == false);
+            assert!(!bits.get(i));
 
             bits.set(i, true);
-            assert!(bits.get(i) == true);
+            assert!(bits.get(i));
         }
     }
 
@@ -389,9 +389,9 @@ mod test {
     #[ktest]
     fn iter() {
         let bits = AtomicBits::new_zeroes(7);
-        assert!(bits.iter().all(|bit| bit == false));
+        assert!(bits.iter().all(|bit| !bit));
 
         let bits = AtomicBits::new_ones(128);
-        assert!(bits.iter().all(|bit| bit == true));
+        assert!(bits.iter().all(|bit| bit));
     }
 }

ostd/src/sync/wait.rs

@@ -293,7 +293,7 @@ mod test {
             Task::yield_now();
 
             cond_cloned.store(true, Ordering::Relaxed);
-            wake(&*queue_cloned);
+            wake(&queue_cloned);
         })
         .data(())
         .spawn()

ostd/src/task/task/mod.rs

@@ -383,6 +383,7 @@ mod test {
 
     #[ktest]
     fn create_task() {
+        #[allow(clippy::eq_op)]
         let task = || {
             assert_eq!(1, 1);
         };
@@ -395,6 +396,7 @@ mod test {
 
     #[ktest]
     fn spawn_task() {
+        #[allow(clippy::eq_op)]
         let task = || {
             assert_eq!(1, 1);
         };