| #!/usr/bin/env fuchsia-vendored-python | |
| # Copyright 2026 The Fuchsia Authors. All rights reserved. | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| import tempfile | |
| import unittest | |
| from pathlib import Path | |
| import procfs | |
| from procfs_test_utils import make_fake_process | |
| class ParseStatFileTest(unittest.TestCase): | |
| def test_parse_normal_stat(self) -> None: | |
| content = ( | |
| "123 (ninja) S 456 123 123 0 0 0 0 0 0 0 15 25 0 0 20 0 1 0 100" | |
| ) | |
| stat = procfs.parse_stat_file(content) | |
| self.assertIsNotNone(stat) | |
| assert stat is not None | |
| self.assertEqual(stat.pid, 123) | |
| self.assertEqual(stat.comm, "ninja") | |
| self.assertEqual(stat.state, "S") | |
| self.assertEqual(stat.ppid, 456) | |
| self.assertEqual(stat.pgrp, 123) | |
| self.assertEqual(stat.utime, 15) | |
| self.assertEqual(stat.stime, 25) | |
| def test_parse_stat_comm_with_spaces_and_parens(self) -> None: | |
| content = "999 (worker (sub) proc) R 1 999 999 0 0 0 0 0 0 0 5 10 0 0" | |
| stat = procfs.parse_stat_file(content) | |
| self.assertIsNotNone(stat) | |
| assert stat is not None | |
| self.assertEqual(stat.pid, 999) | |
| self.assertEqual(stat.comm, "worker (sub) proc") | |
| self.assertEqual(stat.state, "R") | |
| self.assertEqual(stat.ppid, 1) | |
| self.assertEqual(stat.pgrp, 999) | |
| self.assertEqual(stat.utime, 5) | |
| self.assertEqual(stat.stime, 10) | |
| def test_parse_stat_malformed(self) -> None: | |
| self.assertIsNone(procfs.parse_stat_file("invalid")) | |
| self.assertIsNone(procfs.parse_stat_file("123 no_parens")) | |
| self.assertIsNone(procfs.parse_stat_file(")reversed( 1 2 3")) | |
| self.assertIsNone(procfs.parse_stat_file("not_int (cmd) S 1 2")) | |
| self.assertIsNone(procfs.parse_stat_file("123 (cmd) S not_int 2")) | |
| class ParseCmdlineFileTest(unittest.TestCase): | |
| def test_parse_normal_cmdline(self) -> None: | |
| raw = b"python3\0-c\0print('hello')\0" | |
| args = procfs.parse_cmdline_file(raw) | |
| self.assertEqual(args, ["python3", "-c", "print('hello')"]) | |
| def test_parse_empty_cmdline_with_fallback(self) -> None: | |
| self.assertEqual( | |
| procfs.parse_cmdline_file(b"", fallback_comm="kthreadd"), | |
| ["[kthreadd]"], | |
| ) | |
| self.assertEqual( | |
| procfs.parse_cmdline_file(b"\0\0", fallback_comm="kworker"), | |
| ["[kworker]"], | |
| ) | |
| def test_parse_empty_cmdline_without_fallback(self) -> None: | |
| self.assertEqual(procfs.parse_cmdline_file(b""), []) | |
| class ReadProcessInfoTest(unittest.TestCase): | |
| def test_read_process_info_complete(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| proc_root = Path(tmpdir) | |
| make_fake_process( | |
| proc_root, | |
| 42, | |
| comm="clang", | |
| ppid=1, | |
| state="R", | |
| utime=100, | |
| stime=200, | |
| cmdline=["clang", "-O2", "foo.c"], | |
| wchan="ep_poll", | |
| ) | |
| info = procfs.read_process_info(42, proc_root=proc_root) | |
| self.assertIsNotNone(info) | |
| assert info is not None | |
| self.assertEqual(info.pid, 42) | |
| self.assertEqual(info.ppid, 1) | |
| self.assertEqual(info.comm, "clang") | |
| self.assertEqual(info.state, "R") | |
| self.assertEqual(info.pgrp, 42) | |
| self.assertEqual(info.cmdline, ["clang", "-O2", "foo.c"]) | |
| self.assertEqual(info.wchan, "ep_poll") | |
| self.assertEqual(info.utime, 100) | |
| self.assertEqual(info.stime, 200) | |
| def test_read_process_info_missing_wchan_and_cmdline(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| proc_root = Path(tmpdir) | |
| make_fake_process(proc_root, 100, comm="kworker", ppid=2) | |
| info = procfs.read_process_info(100, proc_root=proc_root) | |
| self.assertIsNotNone(info) | |
| assert info is not None | |
| self.assertEqual(info.pid, 100) | |
| self.assertEqual(info.comm, "kworker") | |
| self.assertEqual(info.cmdline, ["[kworker]"]) | |
| self.assertIsNone(info.wchan) | |
| def test_read_process_info_nonexistent_pid(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| self.assertIsNone( | |
| procfs.read_process_info(9999, proc_root=Path(tmpdir)) | |
| ) | |
| def test_read_process_comm_cwd_environ(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| root = Path(tmpdir) | |
| proc_root = root / "proc" | |
| cwd = (root / "work").resolve() | |
| cwd.mkdir() | |
| pid_dir = proc_root / "42" | |
| pid_dir.mkdir(parents=True) | |
| (pid_dir / "comm").write_bytes(b"ninja\n") | |
| (pid_dir / "cwd").symlink_to(cwd) | |
| (pid_dir / "environ").write_bytes(b"A=1\0B=two=2\0INVALID\0") | |
| self.assertEqual(procfs.read_process_comm(42, proc_root), "ninja") | |
| self.assertEqual(procfs.read_process_cwd(42, proc_root), cwd) | |
| self.assertEqual( | |
| procfs.read_process_environ(42, proc_root), | |
| {"A": "1", "B": "two=2"}, | |
| ) | |
| self.assertIsNone(procfs.read_process_comm(99, proc_root)) | |
| self.assertIsNone(procfs.read_process_cwd(99, proc_root)) | |
| self.assertIsNone(procfs.read_process_environ(99, proc_root)) | |
| class IterPidsTest(unittest.TestCase): | |
| def test_iter_pids(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| proc_root = Path(tmpdir) | |
| (proc_root / "1").mkdir() | |
| (proc_root / "42").mkdir() | |
| (proc_root / "100").mkdir() | |
| (proc_root / "not_a_pid").mkdir() | |
| (proc_root / "stat").write_text("cpu info", encoding="utf-8") | |
| pids = sorted(procfs.iter_pids(proc_root=proc_root)) | |
| self.assertEqual(pids, [1, 42, 100]) | |
| def test_iter_pids_missing_directory(self) -> None: | |
| self.assertEqual( | |
| list(procfs.iter_pids(proc_root=Path("/nonexistent/path"))), [] | |
| ) | |
| class ReadAllProcessesTest(unittest.TestCase): | |
| def test_read_all_processes(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| proc_root = Path(tmpdir) | |
| for pid in (10, 20): | |
| make_fake_process(proc_root, pid, comm=f"proc{pid}") | |
| all_procs = procfs.read_all_processes(proc_root=proc_root) | |
| self.assertEqual(sorted(all_procs.keys()), [10, 20]) | |
| self.assertEqual(all_procs[10].comm, "proc10") | |
| self.assertEqual(all_procs[20].comm, "proc20") | |
| class ParseLoadAvgTest(unittest.TestCase): | |
| def test_parse_loadavg_valid(self) -> None: | |
| content = "0.50 0.75 1.25 2/450 12345\n" | |
| loads = procfs.parse_loadavg(content) | |
| self.assertEqual(loads, procfs.LoadAvgData(0.50, 0.75, 1.25)) | |
| def test_parse_loadavg_invalid(self) -> None: | |
| self.assertIsNone(procfs.parse_loadavg("invalid")) | |
| self.assertIsNone(procfs.parse_loadavg("0.50")) | |
| class ParseCpuInfoTest(unittest.TestCase): | |
| def test_parse_cpuinfo_valid(self) -> None: | |
| content = ( | |
| "processor\t: 0\n" | |
| "model name\t: Intel(R) Xeon(R) CPU @ 2.20GHz\n" | |
| "cpu cores\t: 2\n" | |
| "\n" | |
| "processor\t: 1\n" | |
| "model name\t: Intel(R) Xeon(R) CPU @ 2.20GHz\n" | |
| "cpu cores\t: 2\n" | |
| ) | |
| info = procfs.parse_cpuinfo(content) | |
| self.assertEqual(info.model_name, "Intel(R) Xeon(R) CPU @ 2.20GHz") | |
| self.assertEqual(info.logical_processors, 2) | |
| self.assertEqual(info.physical_cores, 2) | |
| def test_parse_cpuinfo_fallback_cores(self) -> None: | |
| content = "processor\t: 0\nprocessor\t: 1\n" | |
| info = procfs.parse_cpuinfo(content) | |
| self.assertEqual(info.model_name, "Unknown") | |
| self.assertEqual(info.logical_processors, 2) | |
| self.assertEqual(info.physical_cores, 2) | |
| class ParseMountsTest(unittest.TestCase): | |
| def test_parse_mounts(self) -> None: | |
| content = ( | |
| "/dev/sda1 / ext4 rw,noatime,discard,errors=remount-ro 0 0\n" | |
| "tmpfs /run tmpfs rw,nosuid,nodev 0 0\n" | |
| ) | |
| mounts = list(procfs.parse_mounts(content)) | |
| self.assertEqual(len(mounts), 2) | |
| self.assertEqual(mounts[0].device, "/dev/sda1") | |
| self.assertEqual(mounts[0].mount_point, "/") | |
| self.assertEqual(mounts[0].fstype, "ext4") | |
| self.assertEqual( | |
| mounts[0].options, "rw,noatime,discard,errors=remount-ro" | |
| ) | |
| class ParseMeminfoBytesTest(unittest.TestCase): | |
| def test_parse_meminfo_bytes_valid(self) -> None: | |
| content = "MemTotal: 65873920 kB\nMemFree: 4312690 kB\n" | |
| self.assertEqual( | |
| procfs.parse_meminfo_bytes(content, "MemTotal"), 65873920 * 1024 | |
| ) | |
| self.assertEqual( | |
| procfs.parse_meminfo_bytes(content, "MemFree"), 4312690 * 1024 | |
| ) | |
| def test_parse_meminfo_bytes_missing_key(self) -> None: | |
| self.assertEqual( | |
| procfs.parse_meminfo_bytes("MemFree: 100 kB\n", "MemTotal"), 0 | |
| ) | |
| def test_parse_meminfo_bytes_units(self) -> None: | |
| self.assertEqual( | |
| procfs.parse_meminfo_bytes("MemTotal: 1024 B\n", "MemTotal"), 1024 | |
| ) | |
| self.assertEqual( | |
| procfs.parse_meminfo_bytes("MemTotal: 16 MB\n", "MemTotal"), | |
| 16 * 1024 * 1024, | |
| ) | |
| self.assertEqual( | |
| procfs.parse_meminfo_bytes("MemTotal: 2 GB\n", "MemTotal"), | |
| 2 * 1024 * 1024 * 1024, | |
| ) | |
| class ParseProcStatTest(unittest.TestCase): | |
| def test_parse_proc_stat(self) -> None: | |
| lines = [ | |
| "cpu 100 20 30 500 10 5 2 0 0 0\n", | |
| "intr 1000 1 2 3\n", | |
| "ctxt 5000\n", | |
| "procs_running 2\n", | |
| "procs_blocked 1\n", | |
| ] | |
| data = procfs.parse_proc_stat(lines) | |
| expected = procfs.ProcStatData( | |
| cpu_ticks=[100, 20, 30, 500, 10, 5, 2, 0, 0, 0], | |
| procs_running=2, | |
| procs_blocked=1, | |
| intr=1000, | |
| ctxt=5000, | |
| ) | |
| self.assertEqual(data, expected) | |
| def test_parse_proc_stat_malformed_lines(self) -> None: | |
| lines = [ | |
| "cpu invalid values\n", | |
| "procs_running not_a_number\n", | |
| "intr\n", | |
| ] | |
| data = procfs.parse_proc_stat(lines) | |
| self.assertEqual(data.cpu_ticks, []) | |
| self.assertIsNone(data.procs_running) | |
| self.assertIsNone(data.intr) | |
| class ParseProcMeminfoTest(unittest.TestCase): | |
| def test_parse_proc_meminfo(self) -> None: | |
| lines = [ | |
| "MemFree: 4000000 kB\n", | |
| "Buffers: 50000 kB\n", | |
| "Cached: 1000000 kB\n", | |
| "SReclaimable: 200000 kB\n", | |
| "Shmem: 10000 kB\n", | |
| "SwapTotal: 8000000 kB\n", | |
| "SwapFree: 6000000 kB\n", | |
| "Dirty: 3000 kB\n", | |
| "Writeback: 100 kB\n", | |
| ] | |
| data = procfs.parse_proc_meminfo(lines) | |
| expected = procfs.MemInfoData( | |
| free=4000000 * 1024, | |
| buffers=50000 * 1024, | |
| cached=1190000 * 1024, | |
| swap_used=2000000 * 1024, | |
| dirty=3000 * 1024, | |
| writeback=100 * 1024, | |
| ) | |
| self.assertEqual(data, expected) | |
| class ParseProcVmstatTest(unittest.TestCase): | |
| def test_parse_proc_vmstat(self) -> None: | |
| lines = [ | |
| "pgpgin 100\n", | |
| "pgpgout 200\n", | |
| "pswpin 5\n", | |
| "pswpout 10\n", | |
| ] | |
| data = procfs.parse_proc_vmstat(lines) | |
| expected = procfs.VmStatData( | |
| pgpgin=100 * 1024, | |
| pgpgout=200 * 1024, | |
| pswpin=5 * 4096, | |
| pswpout=10 * 4096, | |
| ) | |
| self.assertEqual(data, expected) | |
| class ParseFileNrTest(unittest.TestCase): | |
| def test_parse_file_nr(self) -> None: | |
| data = procfs.parse_file_nr("2000\t500\t100000\n") | |
| expected = procfs.FileNrData(allocated=2000, free_allocated=500) | |
| self.assertEqual(data, expected) | |
| def test_parse_file_nr_invalid(self) -> None: | |
| self.assertIsNone(procfs.parse_file_nr("")) | |
| self.assertIsNone(procfs.parse_file_nr("2000")) | |
| self.assertIsNone(procfs.parse_file_nr("invalid content")) | |
| class ParsePressureFileTest(unittest.TestCase): | |
| def test_parse_pressure_file(self) -> None: | |
| lines = [ | |
| "some avg10=0.15 avg60=0.10 avg300=0.05 total=1234\n", | |
| "full avg10=0.05 avg60=0.02 avg300=0.01 total=432\n", | |
| ] | |
| data = procfs.parse_pressure_file(lines) | |
| expected = procfs.PressureData( | |
| some=procfs.PressureLine(avg10=0.15, avg60=0.10, avg300=0.05), | |
| full=procfs.PressureLine(avg10=0.05, avg60=0.02, avg300=0.01), | |
| ) | |
| self.assertEqual(data, expected) | |
| class ParseNetDevTest(unittest.TestCase): | |
| def test_parse_net_dev(self) -> None: | |
| lines = [ | |
| "Inter-| Receive | Transmit\n", | |
| " face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed\n", | |
| " eth0: 100000 1000 0 0 0 0 0 0 200000 2000 0 0 0 0 0 0\n", | |
| " lo: 500 5 0 0 0 0 0 0 500 5 0 0 0 0 0 0\n", | |
| " veth123: 500 5 0 0 0 0 0 0 500 5 0 0 0 0 0 0\n", | |
| ] | |
| results = procfs.parse_net_dev(lines) | |
| expected = [ | |
| procfs.InterfaceNetworkData( | |
| ifname="eth0", | |
| rx_bytes=100000, | |
| rx_packets=1000, | |
| tx_bytes=200000, | |
| tx_packets=2000, | |
| ) | |
| ] | |
| self.assertEqual(results, expected) | |
| class FormatCmdlineTest(unittest.TestCase): | |
| def test_format_cmdline_escapes_newlines(self) -> None: | |
| formatted = procfs.format_cmdline( | |
| ["python3", "-c", "import sys\nprint('hello\rworld')"], | |
| fallback_comm="python3", | |
| ) | |
| self.assertEqual( | |
| formatted, r"python3 -c import sys\nprint('hello\rworld')" | |
| ) | |
| def test_format_cmdline_fallback(self) -> None: | |
| self.assertEqual( | |
| procfs.format_cmdline([], fallback_comm="kworker"), "[kworker]" | |
| ) | |
| self.assertEqual(procfs.format_cmdline([]), "") | |
| class CountProcessFdsTest(unittest.TestCase): | |
| def test_count_process_fds(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| proc_root = Path(tmpdir) | |
| make_fake_process(proc_root, 100, fds=3) | |
| self.assertEqual( | |
| procfs.count_process_fds(100, proc_root=proc_root), 3 | |
| ) | |
| self.assertEqual( | |
| procfs.count_process_fds(999, proc_root=proc_root), 0 | |
| ) | |
| class FindDescendantPidsTest(unittest.TestCase): | |
| def test_find_descendant_pids(self) -> None: | |
| ppid_map = { | |
| 1: 0, | |
| 10: 1, | |
| 20: 10, | |
| 21: 20, | |
| 22: 20, | |
| 30: 1, | |
| } | |
| self.assertEqual( | |
| procfs.find_descendant_pids(20, ppid_map=ppid_map), {20, 21, 22} | |
| ) | |
| self.assertEqual( | |
| procfs.find_descendant_pids(10, ppid_map=ppid_map), | |
| {10, 20, 21, 22}, | |
| ) | |
| self.assertEqual( | |
| procfs.find_descendant_pids(30, ppid_map=ppid_map), {30} | |
| ) | |
| self.assertEqual( | |
| procfs.find_descendant_pids(99, ppid_map=ppid_map), {99} | |
| ) | |
| def test_read_ppid_map(self) -> None: | |
| with tempfile.TemporaryDirectory() as tmpdir: | |
| proc_root = Path(tmpdir) | |
| make_fake_process(proc_root, 10, comm="bash", ppid=1) | |
| make_fake_process(proc_root, 20, comm="ninja", ppid=10) | |
| ppid_map = procfs.read_ppid_map(proc_root=proc_root) | |
| self.assertEqual(ppid_map, {10: 1, 20: 10}) | |
| self.assertEqual( | |
| procfs.find_descendant_pids(10, proc_root=proc_root), | |
| {10, 20}, | |
| ) | |
| if __name__ == "__main__": | |
| unittest.main() |