#![cfg(target_os = "linux")]
#[cfg(test)]
mod tests {
use procfs2::proc::{
ConsoleFlags, DeviceKind, Process, buddyinfo, consoles, cpu_pressure, cpuinfo, crypto,
devices, diskstats, filesystems, interrupts, io_pressure, iomem, ioports, irq_pressure,
loadavg, locks, meminfo, memory_pressure, misc, modules, mounts, pagetypeinfo, partitions,
softirqs, stat, swaps, uptime, version, vmstat, zoneinfo,
};
use procfs2::sys;
fn pagetypeinfo_or_skip() -> Option<procfs2::proc::PageTypeInfo> {
match pagetypeinfo() {
Ok(info) => Some(info),
Err(procfs2::Error::Io { error: e, .. })
if e.kind() == std::io::ErrorKind::PermissionDenied =>
{
None
}
Err(e) => panic!("Failed to read /proc/pagetypeinfo: {e}"),
}
}
fn kptr_hides_us() -> bool {
std::fs::read_to_string("/proc/sys/kernel/kptr_restrict")
.expect("kptr_restrict should be readable")
.trim()
.parse::<u32>()
.expect("invalid kptr_restrict")
>= 2
}
fn blocked_child_wchan(child: &Process) -> Option<procfs2::proc::process::Wchan> {
use procfs2::proc::process::Wchan;
if kptr_hides_us() {
return None;
}
for _ in 0..100 {
let wchan = child.wchan().expect("Failed to read child wchan");
if wchan != Wchan::RunningOrUnavailable {
return Some(wchan);
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
None
}
#[test]
fn test_live_meminfo() {
let info = meminfo().expect("Failed to read /proc/meminfo");
assert!(info.total.0 > 0, "Total memory should be > 0");
}
#[test]
fn test_live_uptime() {
let up = uptime().expect("Failed to read /proc/uptime");
assert!(up.total.as_secs() > 0, "Uptime should be > 0");
}
#[test]
fn test_live_loadavg() {
let load = loadavg().expect("Failed to read /proc/loadavg");
assert!(load.one >= 0.0);
}
#[test]
fn test_live_stat() {
let st = stat().expect("Failed to read /proc/stat");
assert!(!st.per_cpu.is_empty());
}
#[test]
fn test_live_version() {
let ver = version().expect("Failed to read /proc/version");
assert!(ver.major > 0);
}
#[test]
fn test_live_cpuinfo() {
let cpus = cpuinfo().expect("Failed to read /proc/cpuinfo");
assert!(!cpus.is_empty());
}
#[test]
fn test_live_cpuinfo_fields() {
let cpus = cpuinfo().expect("Failed to read /proc/cpuinfo");
for cpu in &cpus {
assert!(cpu.cpu_mhz > 0.0, "cpu MHz should be a positive value");
assert!(cpu.cpu_family > 0, "cpu family should be a positive value");
assert!(!cpu.model_name.is_empty(), "model name should not be empty");
}
}
#[test]
fn test_live_cpuinfo_dedup() {
let cpus = cpuinfo().expect("Failed to read /proc/cpuinfo");
let mut processors: Vec<u32> = cpus.iter().map(|c| c.processor).collect();
processors.sort_unstable();
processors.dedup();
assert_eq!(
processors.len(),
cpus.len(),
"processor numbers should be unique"
);
}
#[test]
fn test_live_current_process() {
let process = Process::current().expect("Failed to get current process");
assert!(process.pid > 0, "PID should be > 0");
}
#[test]
fn test_live_process_status() {
let process = Process::current().expect("Failed to get current process");
let status = process.status().expect("Failed to read process status");
assert!(!status.name.is_empty());
}
#[test]
fn test_live_process_maps() {
let process = Process::current().expect("Failed to get current process");
let maps = process.maps().expect("Failed to read process maps");
assert!(!maps.is_empty());
}
#[test]
fn test_process_iteration() {
let mut count = 0;
for result in Process::all() {
if result.is_ok() {
count += 1;
}
}
assert!(count >= 1);
}
#[test]
fn test_process_new() {
let me = Process::current().expect("Failed to get current process");
assert!(Process::new(me.pid).is_ok());
match Process::new(0) {
Err(procfs2::Error::ProcessGone(0)) => {}
other => panic!("expected ProcessGone for pid 0, got {:?}", other),
}
}
#[test]
fn test_live_process_cmdline() {
let me = Process::current().expect("Failed to get current process");
let cmdline = me.cmdline().expect("Failed to read process cmdline");
assert!(!cmdline.is_empty(), "cmdline should not be empty");
}
#[test]
fn test_live_process_environ() {
let me = Process::current().expect("Failed to get current process");
let environ = me.environ().expect("Failed to read process environ");
assert!(!environ.is_empty(), "environ should not be empty");
}
#[test]
fn test_live_process_exe() {
let me = Process::current().expect("Failed to get current process");
let exe = me.exe().expect("Failed to read process exe");
assert!(exe.is_absolute(), "exe path should be absolute");
assert!(exe.exists(), "exe path should exist");
}
#[test]
fn test_live_process_cwd() {
let me = Process::current().expect("Failed to get current process");
let cwd = me.cwd().expect("Failed to read process cwd");
assert!(cwd.is_absolute(), "cwd should be absolute");
assert!(cwd.is_dir(), "cwd should be a directory");
}
#[test]
fn test_live_process_smaps() {
let me = Process::current().expect("Failed to get current process");
let smaps = me.smaps().expect("Failed to read process smaps");
assert!(!smaps.is_empty(), "smaps should not be empty");
}
#[test]
fn test_live_process_smaps_rollup() {
let me = Process::current().expect("Failed to get current process");
let rollup = me.smaps_rollup().expect("Failed to read smaps_rollup");
assert!(rollup.rss_kb > 0, "rss should be > 0");
}
#[test]
fn test_live_process_fds() {
let me = Process::current().expect("Failed to get current process");
let mut fds = None;
for _ in 0..5 {
if let Ok(v) = me.fds() {
fds = Some(v);
break;
}
}
let fds = fds.expect("Failed to read process fds");
assert!(!fds.is_empty(), "should have at least one open fd");
}
#[test]
fn test_live_process_limits() {
let me = Process::current().expect("Failed to get current process");
let limits = me.limits().expect("Failed to read process limits");
assert!(
limits.max_open_files.soft.is_some(),
"open files soft limit should be set"
);
}
#[test]
fn test_live_process_cgroup() {
let me = Process::current().expect("Failed to get current process");
let cgroups = me.cgroup().expect("Failed to read process cgroup");
assert!(
!cgroups.is_empty(),
"process should be in at least one cgroup"
);
}
#[test]
fn test_live_process_namespaces() {
let me = Process::current().expect("Failed to get current process");
let ns = me.namespaces().expect("Failed to read process namespaces");
assert!(ns.mnt.is_some(), "mnt namespace should be present");
assert!(ns.pid.is_some(), "pid namespace should be present");
assert!(ns.net.is_some(), "net namespace should be present");
}
#[test]
fn test_live_process_threads() {
let me = Process::current().expect("Failed to get current process");
let count = me.threads().filter(|r| r.is_ok()).count();
assert!(count >= 1, "process should have at least one thread");
}
#[test]
fn test_live_process_syscall() {
let me = Process::current().expect("Failed to get current process");
let syscall = me.syscall().expect("Failed to read process syscall");
match syscall.state {
procfs2::proc::process::SyscallState::Running => {
}
procfs2::proc::process::SyscallState::BlockedNotInSyscall => {
assert_eq!(syscall.nr, Some(-1));
}
procfs2::proc::process::SyscallState::InSyscall => {
assert!(syscall.nr.is_some_and(|n| n >= 0));
for arg in syscall.args {
assert!(arg.is_some(), "InSyscall should have all 6 args");
}
}
}
}
#[test]
fn test_live_process_syscall_sp_ip() {
let me = Process::current().expect("Failed to get current process");
let syscall = me.syscall().expect("Failed to read process syscall");
if syscall.state != procfs2::proc::process::SyscallState::Running {
assert!(
syscall.sp > 0,
"stack pointer should be non-zero when not running"
);
assert!(
syscall.ip > 0,
"instruction pointer should be non-zero when not running"
);
}
}
#[test]
fn test_live_process_statm() {
let me = Process::current().expect("Failed to get current process");
let statm = me.statm().expect("Failed to read process statm");
assert!(
statm.size >= statm.resident,
"size should cover the resident set"
);
assert!(statm.resident > 0, "process should have resident pages");
assert!(
statm.text + statm.data <= statm.size,
"text and data should fit within size"
);
}
#[test]
fn test_live_process_statm_obsolete_fields() {
let me = Process::current().expect("Failed to get current process");
let statm = me.statm().expect("Failed to read process statm");
assert_eq!(statm.lib, 0, "lib should be zero");
assert_eq!(statm.dt, 0, "dt should be zero");
}
#[test]
fn test_live_process_statm_matches_stat() {
let me = Process::current().expect("Failed to get current process");
let statm = me.statm().expect("Failed to read process statm");
let stat = me.stat().expect("Failed to read process stat");
let rss = stat.rss.max(0);
let diff = (statm.resident as i64 - rss).unsigned_abs();
assert!(
diff < 1000,
"statm resident ({}) should track stat rss ({rss})",
statm.resident
);
}
#[test]
fn test_live_process_auxv() {
let me = Process::current().expect("Failed to get current process");
let auxv = me.auxv().expect("Failed to read process auxv");
assert!(!auxv.entries.is_empty(), "auxv should not be empty");
assert!(
auxv.get(procfs2::proc::process::auxv_type::AT_PAGESZ)
.is_some(),
"auxv should contain AT_PAGESZ"
);
}
#[test]
fn test_live_process_auxv_page_size() {
let me = Process::current().expect("Failed to get current process");
let auxv = me.auxv().expect("Failed to read process auxv");
let raw = auxv
.get(procfs2::proc::process::auxv_type::AT_PAGESZ)
.expect("AT_PAGESZ should be present");
assert!(raw.is_power_of_two(), "page size should be a power of two");
assert_eq!(auxv.page_size(), raw, "page_size should match AT_PAGESZ");
}
#[test]
fn test_live_process_auxv_known_entries() {
let me = Process::current().expect("Failed to get current process");
let auxv = me.auxv().expect("Failed to read process auxv");
use procfs2::proc::process::auxv_type;
assert!(auxv.get(auxv_type::AT_CLKTCK).is_some_and(|v| v > 0));
assert!(auxv.get(auxv_type::AT_ENTRY).is_some_and(|v| v != 0));
assert_eq!(auxv.get(u64::MAX), None);
}
#[test]
fn test_live_process_pagemap_count() {
let me = Process::current().expect("Failed to get current process");
let maps = me.maps().expect("Failed to read process maps");
let first = maps.first().expect("process should have at least one map");
let entries = me
.pagemap(first.address.start, first.address.end)
.expect("Failed to read process pagemap");
let page_size = me.auxv().expect("Failed to read auxv").page_size();
let expected = first.address.end.div_ceil(page_size) - first.address.start / page_size;
assert_eq!(entries.len() as u64, expected, "one entry per page");
}
#[test]
fn test_live_process_pagemap_resident() {
let me = Process::current().expect("Failed to get current process");
let maps = me.maps().expect("Failed to read process maps");
let mut resident = 0;
for map in &maps {
let entries = me
.pagemap(map.address.start, map.address.end)
.expect("Failed to read process pagemap");
resident += entries.iter().filter(|e| e.is_mapped()).count();
}
assert!(resident > 0, "process should have resident pages");
}
#[test]
fn test_live_process_pagemap_empty_range() {
let me = Process::current().expect("Failed to get current process");
let entries = me
.pagemap(0x1000, 0x1000)
.expect("Failed to read process pagemap");
assert!(entries.is_empty(), "empty range should yield no entries");
}
#[test]
fn test_live_process_loginuid() {
let me = Process::current().expect("Failed to get current process");
let Some(a) = me.loginuid().expect("Failed to read process loginuid") else {
return;
};
let b = me
.loginuid()
.expect("Failed to read process loginuid")
.expect("loginuid vanished between reads");
assert_eq!(a, b, "loginuid should be immutable for a process");
}
#[test]
fn test_live_process_loginuid_matches_file() {
let me = Process::current().expect("Failed to get current process");
let Some(parsed) = me.loginuid().expect("Failed to read process loginuid") else {
return;
};
let raw = std::fs::read_to_string("/proc/self/loginuid")
.expect("loginuid file should exist on this kernel");
let expected: u32 = raw.trim().parse().expect("invalid loginuid in file");
assert_eq!(parsed, expected, "parse should match raw file contents");
}
#[test]
fn test_live_process_loginuid_inherited() {
let me = Process::current().expect("Failed to get current process");
let Some(parent) = me.loginuid().expect("Failed to read process loginuid") else {
return;
};
let mut child = std::process::Command::new("/bin/sleep")
.arg("1")
.spawn()
.expect("Failed to spawn child process");
let child_proc = Process::new(child.id()).expect("Failed to get child process");
let child_loginuid = child_proc
.loginuid()
.expect("Failed to read child loginuid");
child.wait().expect("Failed to wait on child");
let Some(child_loginuid) = child_loginuid else {
return;
};
assert_eq!(
child_loginuid, parent,
"child should inherit parent's loginuid"
);
}
#[test]
fn test_live_process_sessionid() {
let me = Process::current().expect("Failed to get current process");
let Some(a) = me.sessionid().expect("Failed to read process sessionid") else {
return;
};
let b = me
.sessionid()
.expect("Failed to read process sessionid")
.expect("sessionid vanished between reads");
assert_eq!(a, b, "sessionid should be immutable for a process");
}
#[test]
fn test_live_process_sessionid_matches_file() {
let me = Process::current().expect("Failed to get current process");
let Some(parsed) = me.sessionid().expect("Failed to read process sessionid") else {
return;
};
let raw = std::fs::read_to_string("/proc/self/sessionid")
.expect("sessionid file should exist on this kernel");
let expected: u32 = raw.trim().parse().expect("invalid sessionid in file");
assert_eq!(parsed, expected, "parse should match raw file contents");
}
#[test]
fn test_live_process_sessionid_inherited() {
let me = Process::current().expect("Failed to get current process");
let Some(parent) = me.sessionid().expect("Failed to read process sessionid") else {
return;
};
let mut child = std::process::Command::new("/bin/sleep")
.arg("1")
.spawn()
.expect("Failed to spawn child process");
let child_proc = Process::new(child.id()).expect("Failed to get child process");
let child_sessionid = child_proc
.sessionid()
.expect("Failed to read child sessionid");
child.wait().expect("Failed to wait on child");
let Some(child_sessionid) = child_sessionid else {
return;
};
assert_eq!(
child_sessionid, parent,
"child should inherit parent's sessionid"
);
}
#[test]
fn test_live_process_coredump_filter() {
let me = Process::current().expect("Failed to get current process");
let Some(filter) = me
.coredump_filter()
.expect("Failed to read process coredump_filter")
else {
return;
};
let again = me
.coredump_filter()
.expect("Failed to read process coredump_filter")
.expect("coredump_filter vanished between reads");
assert_eq!(
filter, again,
"coredump_filter should be stable for a process"
);
}
#[test]
fn test_live_process_coredump_filter_matches_file() {
let me = Process::current().expect("Failed to get current process");
let Some(parsed) = me
.coredump_filter()
.expect("Failed to read process coredump_filter")
else {
return;
};
let raw = std::fs::read_to_string("/proc/self/coredump_filter")
.expect("coredump_filter file should exist on this kernel");
let expected =
u32::from_str_radix(raw.trim(), 16).expect("invalid coredump_filter in file");
assert_eq!(
parsed.bits(),
expected,
"parse should match raw file contents"
);
}
#[test]
fn test_live_process_coredump_filter_inherited() {
let me = Process::current().expect("Failed to get current process");
let Some(parent) = me
.coredump_filter()
.expect("Failed to read process coredump_filter")
else {
return;
};
let mut child = std::process::Command::new("/bin/sleep")
.arg("1")
.spawn()
.expect("Failed to spawn child process");
let child_proc = Process::new(child.id()).expect("Failed to get child process");
let child_filter = child_proc
.coredump_filter()
.expect("Failed to read child coredump_filter");
child.wait().expect("Failed to wait on child");
let Some(child_filter) = child_filter else {
return;
};
assert_eq!(
child_filter, parent,
"child should inherit parent's coredump_filter"
);
}
#[test]
fn test_live_process_oom_score() {
let me = Process::current().expect("Failed to get current process");
let a = me.oom_score().expect("Failed to read process oom_score");
let b = me.oom_score().expect("Failed to read process oom_score");
assert_eq!(a, b, "oom_score should be stable between reads");
}
#[test]
fn test_live_process_oom_score_matches_file() {
let me = Process::current().expect("Failed to get current process");
let raw = std::fs::read_to_string("/proc/self/oom_score")
.expect("oom_score file should exist on this kernel");
let expected: u16 = raw.trim().parse().expect("invalid oom_score in file");
let parsed = me.oom_score().expect("Failed to read process oom_score");
assert_eq!(parsed, expected, "parse should match raw file contents");
}
#[test]
fn test_live_process_oom_score_range() {
let me = Process::current().expect("Failed to get current process");
let score = me.oom_score().expect("Failed to read process oom_score");
assert!(
score <= 2000,
"oom_score {score} outside the documented range"
);
}
#[test]
fn test_live_process_oom_score_adj() {
let me = Process::current().expect("Failed to get current process");
let a = me
.oom_score_adj()
.expect("Failed to read process oom_score_adj");
let b = me
.oom_score_adj()
.expect("Failed to read process oom_score_adj");
assert_eq!(a, b, "oom_score_adj should be stable between reads");
}
#[test]
fn test_live_process_oom_score_adj_matches_file() {
let me = Process::current().expect("Failed to get current process");
let raw = std::fs::read_to_string("/proc/self/oom_score_adj")
.expect("oom_score_adj file should exist on this kernel");
let expected: i16 = raw.trim().parse().expect("invalid oom_score_adj in file");
let parsed = me
.oom_score_adj()
.expect("Failed to read process oom_score_adj");
assert_eq!(parsed, expected, "parse should match raw file contents");
}
#[test]
fn test_live_process_oom_score_adj_range() {
let me = Process::current().expect("Failed to get current process");
let adj = me
.oom_score_adj()
.expect("Failed to read process oom_score_adj");
assert!(
(-1000..=1000).contains(&adj),
"oom_score_adj {adj} outside the documented range"
);
}
#[test]
fn test_live_process_wchan() {
use procfs2::proc::process::Wchan;
let me = Process::current().expect("Failed to get current process");
let wchan = me.wchan().expect("Failed to read process wchan");
match wchan {
Wchan::RunningOrUnavailable => {}
Wchan::Symbol(name) => assert!(
!name.is_empty() && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_'),
"symbol {name:?} should be a bare kernel identifier"
),
Wchan::Address(addr) => assert_ne!(addr, 0, "address should not be zero"),
}
}
#[test]
fn test_live_process_wchan_blocked() {
let mut child = std::process::Command::new("/bin/sleep")
.arg("2")
.spawn()
.expect("Failed to spawn child process");
let child_proc = Process::new(child.id()).expect("Failed to get child process");
let blocked = blocked_child_wchan(&child_proc);
let again = child_proc.wchan().expect("Failed to re-read child wchan");
child.wait().expect("Failed to wait on child");
assert!(
blocked.is_some() || kptr_hides_us(),
"a sleeping process should report where it is blocked"
);
if let Some(blocked) = blocked {
assert_eq!(blocked, again, "wchan should be stable while blocked");
}
}
#[test]
fn test_live_process_wchan_matches_file() {
use procfs2::proc::process::Wchan;
let mut child = std::process::Command::new("/bin/sleep")
.arg("2")
.spawn()
.expect("Failed to spawn child process");
let child_proc = Process::new(child.id()).expect("Failed to get child process");
let parsed = blocked_child_wchan(&child_proc).unwrap_or(Wchan::RunningOrUnavailable);
let raw = std::fs::read_to_string(format!("/proc/{}/wchan", child.id()))
.expect("wchan file should exist on this kernel");
child.wait().expect("Failed to wait on child");
let field = raw.trim();
if field == "0" {
assert_eq!(parsed, Wchan::RunningOrUnavailable);
} else if let Ok(addr) = u64::from_str_radix(field, 16) {
assert_eq!(parsed, Wchan::Address(addr), "parse should match raw file");
} else {
assert_eq!(
parsed,
Wchan::Symbol(field.to_string()),
"parse should match raw file contents"
);
}
}
#[test]
fn test_live_devices() {
let devices = devices().expect("Failed to read /proc/devices");
assert!(!devices.is_empty(), "Should have at least one device");
assert!(
devices.iter().any(|d| d.major > 0),
"Device major numbers should be > 0"
);
}
#[test]
fn test_live_devices_both_kinds() {
let devices = devices().expect("Failed to read /proc/devices");
assert!(
devices.iter().any(|d| d.kind == DeviceKind::Character),
"Should have at least one character device"
);
assert!(
devices.iter().any(|d| d.kind == DeviceKind::Block),
"Should have at least one block device"
);
}
#[test]
fn test_live_devices_names() {
let devices = devices().expect("Failed to read /proc/devices");
for d in &devices {
assert!(!d.name.is_empty(), "Device name should not be empty");
assert!(
!d.name.contains(' '),
"Device name should not contain spaces"
);
}
}
#[test]
fn test_live_filesystems() {
let fs_list = filesystems().expect("Failed to read /proc/filesystems");
assert!(!fs_list.is_empty(), "Should have at least one filesystem");
assert!(
fs_list.iter().any(|f| f.name.as_ref() == "proc"),
"proc filesystem should be listed"
);
assert!(
fs_list.iter().any(|f| f.name.as_ref() == "tmpfs"),
"tmpfs filesystem should be listed"
);
}
#[test]
fn test_live_filesystems_both_kinds() {
let fs_list = filesystems().expect("Failed to read /proc/filesystems");
assert!(
fs_list.iter().any(|f| !f.dev),
"Should have at least one nodev filesystem"
);
assert!(
fs_list.iter().any(|f| f.dev),
"Should have at least one device-backed filesystem"
);
}
#[test]
fn test_live_filesystems_names() {
let fs_list = filesystems().expect("Failed to read /proc/filesystems");
for f in &fs_list {
assert!(!f.name.is_empty(), "Filesystem name should not be empty");
assert!(
!f.name.contains('\t'),
"Filesystem name should not contain tabs"
);
}
}
#[test]
fn test_live_mounts() {
let mounts = mounts().expect("Failed to read /proc/mounts");
assert!(!mounts.is_empty(), "Should have at least one mount");
}
#[test]
fn test_live_mounts_root() {
let mounts = mounts().expect("Failed to read /proc/mounts");
let root = mounts
.iter()
.find(|m| m.file.as_ref() == "/")
.expect("root mount should exist");
assert!(!root.vfstype.is_empty(), "Root vfstype should not be empty");
let _ = root.spec;
let _ = root.mntops;
let _ = root.freq;
let _ = root.passno;
}
#[test]
fn test_live_mounts_fields() {
let mounts = mounts().expect("Failed to read /proc/mounts");
for m in &mounts {
assert!(!m.vfstype.is_empty(), "vfstype should not be empty");
assert!(!m.file.is_empty(), "Mount point should not be empty");
let _ = m.spec;
let _ = m.mntops;
let _ = m.freq;
let _ = m.passno;
}
}
#[test]
fn test_live_swaps() {
let swaps = swaps().expect("Failed to read /proc/swaps");
for s in &swaps {
assert!(!s.filename.is_empty(), "Filename should not be empty");
assert!(s.size.0 > 0, "Swap size should be > 0");
assert!(s.used.0 <= s.size.0, "Used should not exceed size");
}
}
#[test]
fn test_live_swaps_fields() {
let swaps = swaps().expect("Failed to read /proc/swaps");
for s in &swaps {
match s.kind {
procfs2::proc::SwapType::Partition | procfs2::proc::SwapType::File => {}
}
let _ = s.priority;
}
}
#[test]
fn test_live_partitions() {
let partitions = partitions().expect("Failed to read /proc/partitions");
assert!(!partitions.is_empty(), "Should have at least one partition");
for p in &partitions {
assert!(!p.name.is_empty(), "Partition name should not be empty");
assert!(p.blocks.0 > 0, "Partition blocks should be > 0");
}
}
#[test]
fn test_live_partitions_fields() {
let partitions = partitions().expect("Failed to read /proc/partitions");
for p in &partitions {
assert!(p.major > 0, "Major number should be > 0");
assert!(
!p.name.contains(' '),
"Partition name should not contain spaces"
);
let _ = p.minor;
}
}
#[test]
fn test_live_diskstats() {
let stats = diskstats().expect("Failed to read /proc/diskstats");
assert!(!stats.is_empty(), "Should have at least one disk entry");
for s in &stats {
assert!(!s.name.is_empty(), "Device name should not be empty");
assert!(
!s.name.contains(' '),
"Device name should not contain spaces"
);
assert!(s.major > 0, "Major number should be > 0");
let _ = s.minor;
}
}
#[test]
fn test_live_diskstats_io() {
let stats = diskstats().expect("Failed to read /proc/diskstats");
for s in &stats {
let _ = s.reads_completed;
let _ = s.writes_completed;
let _ = s.sectors_read;
let _ = s.sectors_written;
}
assert!(
stats
.iter()
.any(|s| s.reads_completed > 0 || s.writes_completed > 0),
"Should have at least one device with I/O stats"
);
}
#[test]
fn test_live_diskstats_flush_fields() {
let stats = diskstats().expect("Failed to read /proc/diskstats");
for s in &stats {
let _ = s.flush_completed;
let _ = s.time_flushing;
let _ = s.io_in_progress;
}
}
#[test]
fn test_live_vmstat() {
let vmstat = vmstat().expect("Failed to read /proc/vmstat");
assert!(vmstat.len() > 50, "Should have many vmstat counters");
for key in ["nr_free_pages", "nr_dirty", "pgpgin", "pgfault", "oom_kill"] {
assert!(vmstat.contains_key(key), "vmstat should contain {key}");
}
}
#[test]
fn test_live_vmstat_values() {
let vmstat = vmstat().expect("Failed to read /proc/vmstat");
for (key, &value) in &vmstat {
assert!(!key.is_empty(), "Key should not be empty");
assert!(
!key.contains(char::is_whitespace),
"Key should not contain whitespace"
);
let _ = value;
}
assert!(
vmstat.get("nr_free_pages").is_some_and(|&v| v > 0),
"nr_free_pages should be > 0"
);
}
#[test]
fn test_live_zoneinfo() {
let zones = zoneinfo().expect("Failed to read /proc/zoneinfo");
assert!(!zones.is_empty(), "Should have at least one zone");
let normal = zones
.iter()
.find(|z| z.name.as_ref() == "Normal")
.expect("Should have a Normal zone");
assert!(normal.pages.present > 0, "Normal zone should be populated");
assert!(
!normal.protection.is_empty(),
"Normal zone should have protection values"
);
assert!(
normal.stats.contains_key("nr_free_pages"),
"Normal zone should have nr_free_pages"
);
}
#[test]
fn test_live_zoneinfo_fields() {
let zones = zoneinfo().expect("Failed to read /proc/zoneinfo");
for z in &zones {
assert!(!z.name.is_empty(), "Zone name should not be empty");
if z.pages.managed > 0 {
assert_eq!(
z.pages.free,
z.stats.get("nr_free_pages").copied().unwrap_or(0),
"free pages should match nr_free_pages for {}",
z.name
);
}
}
}
#[test]
fn test_live_zoneinfo_pagesets() {
let zones = zoneinfo().expect("Failed to read /proc/zoneinfo");
for z in zones.iter().filter(|z| z.pages.managed > 0) {
assert!(!z.pagesets.is_empty(), "{} should have pagesets", z.name);
for (i, pcp) in z.pagesets.iter().enumerate() {
assert_eq!(pcp.cpu, i as u32, "{} pageset CPU ids", z.name);
}
}
}
#[test]
fn test_live_buddyinfo() {
let buddy = buddyinfo().expect("Failed to read /proc/buddyinfo");
assert!(!buddy.is_empty(), "Should have at least one zone");
let normal = buddy
.iter()
.find(|b| b.zone.as_ref() == "Normal")
.expect("Should have a Normal zone");
assert!(
!normal.free_lists.is_empty(),
"Normal zone should have free lists"
);
}
#[test]
fn test_live_buddyinfo_fields() {
let buddy = buddyinfo().expect("Failed to read /proc/buddyinfo");
for b in &buddy {
assert!(!b.zone.is_empty(), "Zone name should not be empty");
assert!(
!b.zone.contains(char::is_whitespace),
"Zone name should not contain whitespace"
);
assert!(
!b.free_lists.is_empty(),
"{} should have at least one free list",
b.zone
);
let _ = b.node;
}
}
#[test]
fn test_live_buddyinfo_orders() {
let buddy = buddyinfo().expect("Failed to read /proc/buddyinfo");
let orders = buddy[0].free_lists.len();
assert!(orders > 0, "Should have at least one order");
for b in &buddy {
assert_eq!(
b.free_lists.len(),
orders,
"{} free-list length should match",
b.zone
);
}
}
#[test]
fn test_live_pagetypeinfo() {
let Some(info) = pagetypeinfo_or_skip() else {
return;
};
assert!(info.page_block_order > 0, "Page block order should be > 0");
assert!(info.pages_per_block > 0, "Pages per block should be > 0");
assert!(!info.free.is_empty(), "Should have free-list rows");
assert!(!info.blocks.is_empty(), "Should have block-count rows");
assert_eq!(
info.pages_per_block,
1u64 << info.page_block_order,
"pages_per_block should equal 1 << page_block_order"
);
}
#[test]
fn test_live_pagetypeinfo_free() {
let Some(info) = pagetypeinfo_or_skip() else {
return;
};
let orders = info.free[0].orders.len();
assert!(orders > 0, "Should have at least one order");
for f in &info.free {
assert!(!f.zone.is_empty(), "Zone name should not be empty");
assert!(
!f.migrate_type.is_empty(),
"Migrate type should not be empty"
);
assert_eq!(
f.orders.len(),
orders,
"{} {} free-list length should match",
f.zone,
f.migrate_type
);
assert!(
info.blocks.iter().any(|b| b.zone == f.zone),
"{} should appear in block counts",
f.zone
);
}
}
#[test]
fn test_live_pagetypeinfo_blocks() {
let Some(info) = pagetypeinfo_or_skip() else {
return;
};
let types = info.blocks[0].types.len();
assert!(types > 0, "Should have at least one migrate type");
for b in &info.blocks {
assert!(!b.zone.is_empty(), "Zone name should not be empty");
assert_eq!(
b.types.len(),
types,
"{} block-count length should match",
b.zone
);
}
}
#[test]
fn test_live_softirqs() {
let si = softirqs().expect("Failed to read /proc/softirqs");
assert!(!si.cpus.is_empty(), "Should have at least one CPU");
assert!(!si.rows.is_empty(), "Should have at least one softirq");
for key in ["HI", "TIMER", "NET_TX", "NET_RX", "BLOCK", "SCHED", "RCU"] {
assert!(
si.rows.iter().any(|r| r.name.as_ref() == key),
"softirqs should contain {key}"
);
}
}
#[test]
fn test_live_softirqs_fields() {
let si = softirqs().expect("Failed to read /proc/softirqs");
for r in &si.rows {
assert!(!r.name.is_empty(), "Softirq name should not be empty");
assert!(
!r.name.contains(':') && !r.name.contains(char::is_whitespace),
"Softirq name should be a bare token"
);
assert_eq!(
r.per_cpu.len(),
si.cpus.len(),
"{} should have one count per CPU",
r.name
);
}
for pair in si.cpus.windows(2) {
assert!(pair[0] < pair[1], "CPU ids should ascend");
}
let timer = si
.rows
.iter()
.find(|r| r.name.as_ref() == "TIMER")
.expect("TIMER softirq should exist");
assert!(
timer.per_cpu.iter().sum::<u64>() > 0,
"TIMER counts should be > 0"
);
}
#[test]
fn test_live_softirqs_monotonic() {
let first = softirqs().expect("Failed to read /proc/softirqs");
let second = softirqs().expect("Failed to re-read /proc/softirqs");
assert_eq!(
first.rows.len(),
second.rows.len(),
"row count should match"
);
for (a, b) in first.rows.iter().zip(&second.rows) {
assert_eq!(a.name, b.name, "row order should be stable");
for (&x, &y) in a.per_cpu.iter().zip(&b.per_cpu) {
assert!(y >= x, "{} counter went backwards: {} -> {}", a.name, x, y);
}
}
}
#[test]
fn test_live_interrupts() {
let irq = interrupts().expect("Failed to read /proc/interrupts");
assert!(!irq.cpus.is_empty(), "Should have at least one CPU");
assert!(!irq.rows.is_empty(), "Should have at least one IRQ row");
assert!(
!irq.counts.is_empty(),
"Should have at least one aggregate counter"
);
for key in ["NMI", "LOC", "RES", "CAL", "TLB"] {
assert!(
irq.counts.iter().any(|c| c.name.as_ref() == key),
"interrupts should contain aggregate {key}"
);
}
}
#[test]
fn test_live_interrupts_fields() {
let irq = interrupts().expect("Failed to read /proc/interrupts");
for r in &irq.rows {
assert_eq!(
r.per_cpu.len(),
irq.cpus.len(),
"IRQ {} should have one count per CPU",
r.irq
);
assert!(!r.info.is_empty(), "IRQ {} should have info", r.irq);
}
for c in &irq.counts {
assert!(!c.name.is_empty(), "Aggregate name should not be empty");
assert!(
!c.name.contains(':'),
"Aggregate name should not contain ':'"
);
assert!(
c.values.len() == 1 || c.values.len() == irq.cpus.len(),
"{} should have per-cpu or single total values",
c.name
);
}
}
#[test]
fn test_live_interrupts_monotonic() {
let first = interrupts().expect("Failed to read /proc/interrupts");
let second = interrupts().expect("Failed to re-read /proc/interrupts");
assert_eq!(
first.rows.len(),
second.rows.len(),
"IRQ row count should match"
);
for (a, b) in first.rows.iter().zip(&second.rows) {
assert_eq!(a.irq, b.irq, "IRQ numbers should be stable");
for (&x, &y) in a.per_cpu.iter().zip(&b.per_cpu) {
assert!(
y >= x,
"IRQ {} counter went backwards: {} -> {}",
a.irq,
x,
y
);
}
}
for (a, b) in first.counts.iter().zip(&second.counts) {
assert_eq!(a.name, b.name, "Aggregate names should be stable");
for (&x, &y) in a.values.iter().zip(&b.values) {
assert!(y >= x, "{} counter went backwards: {} -> {}", a.name, x, y);
}
}
}
#[test]
fn test_live_iomem() {
let regions = iomem().expect("Failed to read /proc/iomem");
assert!(
!regions.is_empty(),
"Should have at least one memory region"
);
}
#[test]
fn test_live_iomem_fields() {
let regions = iomem().expect("Failed to read /proc/iomem");
for r in ®ions {
assert!(
r.start <= r.end,
"Start address {:x} should be <= end address {:x}",
r.start,
r.end,
);
assert!(!r.name.is_empty(), "Region name should not be empty");
}
}
#[test]
fn test_live_iomem_system_ram() {
let regions = iomem().expect("Failed to read /proc/iomem");
assert!(
regions.iter().any(|r| r.name.as_ref() == "System RAM"),
"Should have at least one System RAM region"
);
assert!(
regions.iter().any(|r| r.depth == 0),
"Should have at least one root-level entry"
);
}
#[test]
fn test_live_ioports() {
let regions = ioports().expect("Failed to read /proc/ioports");
assert!(
!regions.is_empty(),
"Should have at least one I/O port region"
);
}
#[test]
fn test_live_ioports_fields() {
let regions = ioports().expect("Failed to read /proc/ioports");
for r in ®ions {
assert!(
r.start <= r.end,
"Port start {} should be <= end {}",
r.start,
r.end,
);
assert!(!r.name.is_empty(), "Port region name should not be empty");
}
}
#[test]
fn test_live_ioports_depth() {
let regions = ioports().expect("Failed to read /proc/ioports");
assert!(
regions.iter().any(|r| r.depth == 0),
"Should have at least one root-level entry"
);
assert!(
regions.iter().any(|r| r.name.as_ref() == "dma1"),
"Should have a dma1 entry"
);
assert!(
regions.iter().any(|r| r.name.as_ref() == "pic1"),
"Should have a pic1 entry"
);
}
#[test]
fn test_live_misc() {
let devices = misc().expect("Failed to read /proc/misc");
assert!(!devices.is_empty(), "Should have at least one misc device");
}
#[test]
fn test_live_misc_fields() {
let devices = misc().expect("Failed to read /proc/misc");
for d in &devices {
assert!(!d.name.is_empty(), "Misc device name should not be empty");
let _ = d.minor;
}
}
#[test]
fn test_live_misc_known() {
let devices = misc().expect("Failed to read /proc/misc");
assert!(
devices.iter().any(|d| d.name.as_ref() == "fuse"),
"Should have a fuse misc device"
);
}
#[test]
fn test_live_modules() {
let mods = modules().expect("Failed to read /proc/modules");
assert!(!mods.is_empty(), "Should have at least one loaded module");
}
#[test]
fn test_live_modules_fields() {
let mods = modules().expect("Failed to read /proc/modules");
for m in &mods {
assert!(!m.name.is_empty(), "Module name should not be empty");
assert!(m.size > 0, "Module size should be > 0");
assert!(
m.state.as_ref() == "Live"
|| m.state.as_ref() == "Loading"
|| m.state.as_ref() == "Unloading",
"Module state should be Live, Loading, or Unloading"
);
let _ = m.ref_count;
let _ = m.address;
}
}
#[test]
fn test_live_modules_live() {
let mods = modules().expect("Failed to read /proc/modules");
assert!(
mods.iter().any(|m| m.state.as_ref() == "Live"),
"Should have at least one live module"
);
assert!(
mods.iter().any(|m| m.deps.as_ref() != "-"),
"Should have at least one module with dependencies"
);
}
#[test]
fn test_live_crypto() {
let entries = crypto().expect("Failed to read /proc/crypto");
assert!(!entries.is_empty(), "Should have at least one crypto entry");
}
#[test]
fn test_live_crypto_fields() {
let entries = crypto().expect("Failed to read /proc/crypto");
for entry in &entries {
assert!(!entry.name.is_empty(), "Crypto name should not be empty");
assert!(
!entry.driver.is_empty(),
"Crypto driver should not be empty"
);
assert!(
!entry.crypto_type.is_empty(),
"Crypto type should not be empty"
);
let _ = entry.priority;
let _ = entry.ref_count;
}
}
#[test]
fn test_live_crypto_self_tests() {
let entries = crypto().expect("Failed to read /proc/crypto");
assert!(
entries
.iter()
.any(|entry| entry.self_test.as_ref() == "passed"),
"Should have at least one passed crypto self-test"
);
}
#[test]
fn test_live_consoles() {
let cons = consoles().expect("Failed to read /proc/consoles");
assert!(!cons.is_empty(), "Should have at least one console");
}
#[test]
fn test_live_consoles_fields() {
let cons = consoles().expect("Failed to read /proc/consoles");
for c in &cons {
assert!(!c.name.is_empty(), "Console name should not be empty");
match (c.major, c.minor) {
(Some(major), Some(minor)) => {
assert!(major > 0, "Console major should be > 0");
let _ = minor;
}
(None, None) => {}
_ => panic!("Console major/minor should both be set or both absent"),
}
}
}
#[test]
fn test_live_consoles_flags() {
let cons = consoles().expect("Failed to read /proc/consoles");
for c in &cons {
let unknown = c.flags.bits() & !ConsoleFlags::all().bits();
assert!(
unknown == 0,
"Console flags contain unknown bits: {unknown:#b}"
);
}
}
#[test]
fn test_live_locks() {
let lock_list = locks().expect("Failed to read /proc/locks");
for l in &lock_list {
assert!(l.pid != 0, "Lock PID should not be 0");
assert!(l.inode > 0, "Lock inode should be > 0");
}
}
#[test]
fn test_live_locks_fields() {
let lock_list = locks().expect("Failed to read /proc/locks");
for l in &lock_list {
match l.lock_type {
procfs2::proc::LockType::Flock
| procfs2::proc::LockType::Ofdlck
| procfs2::proc::LockType::Posix => {}
}
match l.class {
procfs2::proc::LockClass::Advisory | procfs2::proc::LockClass::Mandatory => {}
}
match l.access {
procfs2::proc::LockAccess::Read | procfs2::proc::LockAccess::Write => {}
}
let _ = l.start;
let _ = l.end;
}
}
#[test]
fn test_live_locks_no_zero_pid() {
let lock_list = locks().expect("Failed to read /proc/locks");
for l in &lock_list {
assert!(
l.pid != 0,
"Lock PID should be non-zero (got 0 for {:?})",
l.lock_type,
);
}
}
#[test]
fn test_live_cpu_pressure() {
let psi = cpu_pressure().expect("Failed to read /proc/pressure/cpu");
assert!(psi.some.avg10 >= 0.0, "avg10 should be >= 0");
assert!(psi.full.avg10 >= 0.0, "full avg10 should be >= 0");
let _ = psi.some.total;
}
#[test]
fn test_live_memory_and_io_pressure() {
let mem = memory_pressure().expect("Failed to read /proc/pressure/memory");
let io = io_pressure().expect("Failed to read /proc/pressure/io");
assert!(mem.some.avg10 >= 0.0);
assert!(mem.full.avg10 >= 0.0);
assert!(io.some.avg10 >= 0.0);
assert!(io.full.avg10 >= 0.0);
}
#[test]
fn test_live_irq_pressure() {
let Some(psi) = irq_pressure().expect("Failed to read /proc/pressure/irq (when supported)")
else {
return;
};
assert!(psi.full.avg10 >= 0.0, "avg10 should be >= 0");
assert!(psi.full.avg60 >= 0.0, "avg60 should be >= 0");
assert!(psi.full.avg300 >= 0.0, "avg300 should be >= 0");
let _ = psi.full.total;
}
#[test]
fn test_live_net_snmp() {
let stats = procfs2::proc::net::snmp().expect("Failed to read /proc/net/snmp");
assert!(stats.ip.default_ttl > 0, "IP default TTL should be > 0");
assert!(stats.tcp.rto_min > 0, "TCP minimum RTO should be > 0");
}
#[test]
fn test_live_net_snmp_counters() {
let stats = procfs2::proc::net::snmp().expect("Failed to read /proc/net/snmp");
assert!(stats.ip.in_receives >= stats.ip.in_delivers);
assert!(stats.tcp.in_segs > 0, "TCP input segments should be > 0");
assert!(
stats.udp.out_datagrams > 0,
"UDP output datagrams should be > 0"
);
}
#[test]
fn test_live_net_snmp_consistent() {
let first = procfs2::proc::net::snmp().expect("Failed to read /proc/net/snmp");
let second = procfs2::proc::net::snmp().expect("Failed to reread /proc/net/snmp");
assert!(second.ip.in_receives >= first.ip.in_receives);
assert!(second.tcp.in_segs >= first.tcp.in_segs);
assert!(second.udp.in_datagrams >= first.udp.in_datagrams);
}
#[test]
fn test_live_net_snmp6() {
let stats = procfs2::proc::net::snmp6().expect("Failed to read /proc/net/snmp6");
assert!(stats.ip.in_delivers <= stats.ip.in_receives);
}
#[test]
fn test_live_net_snmp6_counters() {
let stats = procfs2::proc::net::snmp6().expect("Failed to read /proc/net/snmp6");
assert!(
stats.ip.out_requests
<= stats.ip.out_transmits + stats.ip.out_discards + stats.ip.out_no_routes,
"out_requests should be accounted for by transmits or drops"
);
let _ = stats.udp.out_datagrams;
}
#[test]
fn test_live_net_snmp6_consistent() {
let first = procfs2::proc::net::snmp6().expect("Failed to read /proc/net/snmp6");
let second = procfs2::proc::net::snmp6().expect("Failed to reread /proc/net/snmp6");
assert!(second.ip.in_receives >= first.ip.in_receives);
assert!(second.icmp.in_msgs >= first.icmp.in_msgs);
assert!(second.udp.out_datagrams >= first.udp.out_datagrams);
}
#[test]
fn test_live_net_route() {
let routes: Vec<_> = procfs2::proc::net::route().filter_map(|r| r.ok()).collect();
assert!(!routes.is_empty(), "Should have at least one route");
}
#[test]
fn test_live_net_route_fields() {
let routes: Vec<_> = procfs2::proc::net::route().filter_map(|r| r.ok()).collect();
for r in &routes {
assert!(!r.iface.is_empty(), "Route iface should not be empty");
let _ = r.destination;
let _ = r.gateway;
let _ = r.mask;
let _ = r.flags;
let _ = r.refcnt;
let _ = r.use_;
let _ = r.metric;
let _ = r.mtu;
let _ = r.window;
let _ = r.irtt;
}
}
#[test]
fn test_live_net_route_default() {
let routes: Vec<_> = procfs2::proc::net::route().filter_map(|r| r.ok()).collect();
for r in &routes {
if r.destination.is_unspecified() && r.mask.is_unspecified() {
let _ = r.gateway;
let _ = r.metric;
}
}
}
#[test]
fn test_live_net_dev() {
let devices: Vec<_> = procfs2::proc::net::dev().filter_map(|r| r.ok()).collect();
assert!(!devices.is_empty(), "Should have at least one interface");
assert!(
devices.iter().any(|d| d.name.as_ref() == "lo"),
"Should have a loopback interface"
);
}
#[test]
fn test_live_net_dev_fields() {
let devices: Vec<_> = procfs2::proc::net::dev().filter_map(|r| r.ok()).collect();
for d in &devices {
assert!(!d.name.is_empty(), "Interface name should not be empty");
let _ = d.rx_bytes;
let _ = d.rx_packets;
let _ = d.rx_errors;
let _ = d.rx_drop;
let _ = d.rx_fifo_errors;
let _ = d.rx_frame_errors;
let _ = d.rx_compressed;
let _ = d.rx_multicast;
let _ = d.tx_bytes;
let _ = d.tx_packets;
let _ = d.tx_errors;
let _ = d.tx_drop;
let _ = d.tx_fifo_errors;
let _ = d.tx_collisions;
let _ = d.tx_carrier_errors;
let _ = d.tx_compressed;
}
}
#[test]
fn test_live_net_dev_loopback_activity() {
let devices: Vec<_> = procfs2::proc::net::dev().filter_map(|r| r.ok()).collect();
let lo = devices
.iter()
.find(|d| d.name.as_ref() == "lo")
.expect("loopback interface should exist");
assert!(lo.rx_packets > 0, "loopback should have received packets");
assert!(
lo.tx_packets > 0,
"loopback should have transmitted packets"
);
}
#[test]
fn test_live_net_arp() {
let entries: Vec<_> = procfs2::proc::net::arp().filter_map(|r| r.ok()).collect();
assert!(
procfs2::proc::net::arp().all(|r| r.is_ok()),
"ARP entries should parse"
);
let _ = entries;
}
#[test]
fn test_live_net_arp_fields() {
let entries: Vec<_> = procfs2::proc::net::arp().filter_map(|r| r.ok()).collect();
for e in &entries {
let _ = e.ip;
let _ = e.hw_type;
let _ = e.flags;
let _ = e.mac;
assert!(!e.device.is_empty(), "ARP device should not be empty");
}
}
#[test]
fn test_live_net_arp_consistency() {
let first: Vec<_> = procfs2::proc::net::arp().filter_map(|r| r.ok()).collect();
let second: Vec<_> = procfs2::proc::net::arp().filter_map(|r| r.ok()).collect();
if first.len() == second.len() {
for (a, b) in first.iter().zip(&second) {
assert_eq!(a.ip, b.ip, "ARP entry should keep its IP");
}
}
}
#[test]
fn test_live_net_tcp() {
let entries: Vec<_> = procfs2::proc::net::tcp().collect();
assert!(
entries.iter().all(|r| r.is_ok()),
"TCP entries should parse"
);
}
#[test]
fn test_live_net_tcp_loopback() {
let entries: Vec<_> = procfs2::proc::net::tcp().filter_map(|r| r.ok()).collect();
for e in &entries {
let _ = e.local;
let _ = e.remote;
let _ = e.state;
let _ = e.inode;
let _ = e.uid;
let _ = e.rx_queue;
let _ = e.tx_queue;
}
}
#[test]
fn test_live_net_tcp_states() {
let entries: Vec<_> = procfs2::proc::net::tcp().collect();
for r in entries {
let e = r.expect("TCP entry should parse");
match e.state {
procfs2::proc::net::TcpState::Established
| procfs2::proc::net::TcpState::SynSent
| procfs2::proc::net::TcpState::SynRecv
| procfs2::proc::net::TcpState::FinWait1
| procfs2::proc::net::TcpState::FinWait2
| procfs2::proc::net::TcpState::TimeWait
| procfs2::proc::net::TcpState::Close
| procfs2::proc::net::TcpState::CloseWait
| procfs2::proc::net::TcpState::LastAck
| procfs2::proc::net::TcpState::Listen
| procfs2::proc::net::TcpState::Closing
| procfs2::proc::net::TcpState::NewSynRecv => {}
}
}
}
#[test]
fn test_live_net_tcp6() {
let _ = procfs2::proc::net::tcp6().count();
}
#[test]
fn test_live_net_tcp6_mapped() {
for entry in procfs2::proc::net::tcp6().flatten() {
assert!(
entry.local.ip().is_loopback() || !entry.local.ip().is_unspecified(),
"mapped entry should invert to the original IPv4"
);
let _ = entry.remote;
let _ = entry.state;
}
}
#[test]
fn test_live_net_tcp6_fallback() {
for entry in procfs2::proc::net::tcp::parse_tcp6_entries().flatten() {
let _ = entry.local;
let _ = entry.remote;
let _ = entry.inode;
}
}
#[test]
fn test_live_net_udp() {
let entries: Vec<_> = procfs2::proc::net::udp().collect();
assert!(
entries.iter().all(|r| r.is_ok()),
"UDP entries should parse"
);
}
#[test]
fn test_live_net_udp_loopback() {
let entries: Vec<_> = procfs2::proc::net::udp().filter_map(|r| r.ok()).collect();
for e in &entries {
let _ = e.local;
let _ = e.remote;
let _ = e.state;
let _ = e.uid;
let _ = e.inode;
let _ = e.rx_queue;
let _ = e.tx_queue;
}
}
#[test]
fn test_live_net_udp_states() {
let entries: Vec<_> = procfs2::proc::net::udp().collect();
for r in entries {
let e = r.expect("UDP entry should parse");
assert!(
e.state == 0x07 || e.state == 0x01,
"UDP state {:#x} should be 0x01 or 0x07",
e.state
);
}
}
#[test]
fn test_live_net_udp6() {
let entries: Vec<_> = procfs2::proc::net::udp6().collect();
assert!(
entries.iter().all(|r| r.is_ok()),
"UDP6 entries should parse"
);
}
#[test]
fn test_live_net_udp6_fields() {
let entries: Vec<_> = procfs2::proc::net::udp6().filter_map(|r| r.ok()).collect();
for e in &entries {
let _ = e.local;
let _ = e.remote;
let _ = e.state;
let _ = e.uid;
let _ = e.inode;
}
}
#[test]
fn test_live_net_udp6_ipv4_mixed() {
let _count: usize = procfs2::proc::net::udp6().filter_map(|r| r.ok()).count();
}
#[test]
fn test_live_net_unix() {
let entries: Vec<_> = procfs2::proc::net::unix().collect();
assert!(
entries.iter().all(|r| r.is_ok()),
"Unix socket entries should parse"
);
}
#[test]
fn test_live_net_unix_path() {
let entries: Vec<_> = procfs2::proc::net::unix().filter_map(|r| r.ok()).collect();
let has_path = entries.iter().any(|e| e.path.is_some());
let _ = has_path;
for e in &entries {
let _ = e.ino;
let _ = e.ref_count;
let _ = e.protocol;
let _ = e.type_;
let _ = e.state;
let _ = e.inode;
}
}
#[test]
fn test_live_net_unix_state() {
let entries: Vec<_> = procfs2::proc::net::unix().collect();
for r in entries {
let e = r.expect("Unix socket entry should parse");
assert!(
e.state <= 12,
"Unix socket state {} should be a valid TCP state code",
e.state
);
}
}
#[test]
fn test_live_sys_block() {
let devices: Vec<_> = sys::BlockDevice::all().filter_map(|r| r.ok()).collect();
assert!(!devices.is_empty(), "Should have at least one block device");
let dev = devices
.iter()
.find(|dev| dev.size().map(|s| s.0 > 0).unwrap_or(false))
.expect("Should have a block device with a nonzero size");
let stat = dev.stat().expect("Failed to read block device stat");
assert!(dev.size().expect("Failed to read device size").0 > 0);
assert!(stat.reads_completed > 0 || stat.writes_completed > 0);
}
#[test]
fn test_live_sys_cpu() {
let count = sys::cpu_count().expect("Failed to read cpu count");
assert!(count > 0, "CPU count should be > 0");
let cpus = sys::online_cpus().expect("Failed to read online cpus");
assert!(!cpus.is_empty(), "Should have at least one online CPU");
}
#[test]
fn test_live_sys_net() {
let ifaces: Vec<_> = sys::NetInterface::all().filter_map(|r| r.ok()).collect();
assert!(!ifaces.is_empty(), "Should have at least one interface");
if let Some(iface) = ifaces.first() {
let stats = iface.stats().expect("Failed to read interface stats");
assert!(
iface.mtu().expect("Failed to read mtu") > 0,
"MTU should be > 0"
);
assert!(
iface
.flags()
.expect("Failed to read flags")
.contains(sys::NetIfFlags::UP),
"interface should be up"
);
let _ = stats.rx_bytes.0;
}
}
#[test]
fn test_live_sys_power() {
let supplies: Vec<_> = sys::PowerSupply::all().filter_map(|r| r.ok()).collect();
for ps in &supplies {
assert!(ps.kind().is_ok(), "Power supply kind should parse");
}
}
}