py2docfx 0.1.20rc2196756__py3-none-any.whl → 0.1.21.dev2246704__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_bsd.py

@@ -26,10 +26,9 @@ from psutil.tests import PsutilTestCase
 from psutil.tests import pytest
 from psutil.tests import retry_on_failure
 from psutil.tests import sh
-from psutil.tests import spawn_testproc
+from psutil.tests import spawn_subproc
 from psutil.tests import terminate
 
-
 if BSD:
     from psutil._psutil_posix import getpagesize
 
@@ -78,7 +77,7 @@ class BSDTestCase(PsutilTestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.pid = spawn_testproc().pid
+        cls.pid = spawn_subproc().pid
 
     @classmethod
     def tearDownClass(cls):
@@ -117,9 +116,9 @@ class BSDTestCase(PsutilTestCase):
             assert usage.total == total
             # 10 MB tolerance
             if abs(usage.free - free) > 10 * 1024 * 1024:
-                raise self.fail(f"psutil={usage.free}, df={free}")
+                raise pytest.fail(f"psutil={usage.free}, df={free}")
             if abs(usage.used - used) > 10 * 1024 * 1024:
-                raise self.fail(f"psutil={usage.used}, df={used}")
+                raise pytest.fail(f"psutil={usage.used}, df={used}")
 
     @pytest.mark.skipif(
         not shutil.which("sysctl"), reason="sysctl cmd not available"
@@ -162,7 +161,7 @@ class BSDTestCase(PsutilTestCase):
 class FreeBSDPsutilTestCase(PsutilTestCase):
     @classmethod
     def setUpClass(cls):
-        cls.pid = spawn_testproc().pid
+        cls.pid = spawn_subproc().pid
 
     @classmethod
     def tearDownClass(cls):
@@ -389,10 +388,6 @@ class FreeBSDSystemTestCase(PsutilTestCase):
             < 200000
         )
 
-    # def test_cpu_stats_traps(self):
-    #    self.assertAlmostEqual(psutil.cpu_stats().traps,
-    #                           sysctl('vm.stats.sys.v_trap'), delta=1000)
-
     # --- swap memory
 
     def test_swapmem_free(self):

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_connections.py

@@ -42,7 +42,6 @@ from psutil.tests import tcp_socketpair
 from psutil.tests import unix_socketpair
 from psutil.tests import wait_for_file
 
-
 SOCK_SEQPACKET = getattr(socket, "SOCK_SEQPACKET", object())
 
 
@@ -204,7 +203,7 @@ class TestConnectedSocket(ConnectionTestCase):
 
     # On SunOS, even after we close() it, the server socket stays around
     # in TIME_WAIT state.
-    @pytest.mark.skipif(SUNOS, reason="unreliable on SUONS")
+    @pytest.mark.skipif(SUNOS, reason="unreliable on SUNOS")
     def test_tcp(self):
         addr = ("127.0.0.1", 0)
         assert this_proc_net_connections(kind='tcp4') == []
@@ -218,8 +217,8 @@ class TestConnectedSocket(ConnectionTestCase):
             # commenteed.
             # client.close()
             # cons = this_proc_net_connections(kind='all')
-            # self.assertEqual(len(cons), 1)
-            # self.assertEqual(cons[0].status, psutil.CONN_CLOSE_WAIT)
+            # assert len(cons) == 1
+            # assert cons[0].status == psutil.CONN_CLOSE_WAIT
         finally:
             server.close()
             client.close()

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_contracts.py

@@ -9,7 +9,6 @@ returned types and APIs availability.
 Some of these are duplicates of tests test_system.py and test_process.py.
 """
 
-import platform
 import signal
 
 import psutil
@@ -22,6 +21,7 @@ from psutil import OPENBSD
 from psutil import POSIX
 from psutil import SUNOS
 from psutil import WINDOWS
+from psutil.tests import AARCH64
 from psutil.tests import GITHUB_ACTIONS
 from psutil.tests import HAS_CPU_FREQ
 from psutil.tests import HAS_NET_IO_COUNTERS
@@ -35,7 +35,6 @@ from psutil.tests import is_namedtuple
 from psutil.tests import kernel_version
 from psutil.tests import pytest
 
-
 # ===================================================================
 # --- APIs availability
 # ===================================================================
@@ -49,62 +48,58 @@ class TestAvailConstantsAPIs(PsutilTestCase):
         assert hasattr(psutil, "PROCFS_PATH") == (LINUX or SUNOS or AIX)
 
     def test_win_priority(self):
-        ae = self.assertEqual
-        ae(hasattr(psutil, "ABOVE_NORMAL_PRIORITY_CLASS"), WINDOWS)
-        ae(hasattr(psutil, "BELOW_NORMAL_PRIORITY_CLASS"), WINDOWS)
-        ae(hasattr(psutil, "HIGH_PRIORITY_CLASS"), WINDOWS)
-        ae(hasattr(psutil, "IDLE_PRIORITY_CLASS"), WINDOWS)
-        ae(hasattr(psutil, "NORMAL_PRIORITY_CLASS"), WINDOWS)
-        ae(hasattr(psutil, "REALTIME_PRIORITY_CLASS"), WINDOWS)
+        assert hasattr(psutil, "ABOVE_NORMAL_PRIORITY_CLASS") == WINDOWS
+        assert hasattr(psutil, "BELOW_NORMAL_PRIORITY_CLASS") == WINDOWS
+        assert hasattr(psutil, "HIGH_PRIORITY_CLASS") == WINDOWS
+        assert hasattr(psutil, "IDLE_PRIORITY_CLASS") == WINDOWS
+        assert hasattr(psutil, "NORMAL_PRIORITY_CLASS") == WINDOWS
+        assert hasattr(psutil, "REALTIME_PRIORITY_CLASS") == WINDOWS
 
     def test_linux_ioprio_linux(self):
-        ae = self.assertEqual
-        ae(hasattr(psutil, "IOPRIO_CLASS_NONE"), LINUX)
-        ae(hasattr(psutil, "IOPRIO_CLASS_RT"), LINUX)
-        ae(hasattr(psutil, "IOPRIO_CLASS_BE"), LINUX)
-        ae(hasattr(psutil, "IOPRIO_CLASS_IDLE"), LINUX)
+        assert hasattr(psutil, "IOPRIO_CLASS_NONE") == LINUX
+        assert hasattr(psutil, "IOPRIO_CLASS_RT") == LINUX
+        assert hasattr(psutil, "IOPRIO_CLASS_BE") == LINUX
+        assert hasattr(psutil, "IOPRIO_CLASS_IDLE") == LINUX
 
     def test_linux_ioprio_windows(self):
-        ae = self.assertEqual
-        ae(hasattr(psutil, "IOPRIO_HIGH"), WINDOWS)
-        ae(hasattr(psutil, "IOPRIO_NORMAL"), WINDOWS)
-        ae(hasattr(psutil, "IOPRIO_LOW"), WINDOWS)
-        ae(hasattr(psutil, "IOPRIO_VERYLOW"), WINDOWS)
+        assert hasattr(psutil, "IOPRIO_HIGH") == WINDOWS
+        assert hasattr(psutil, "IOPRIO_NORMAL") == WINDOWS
+        assert hasattr(psutil, "IOPRIO_LOW") == WINDOWS
+        assert hasattr(psutil, "IOPRIO_VERYLOW") == WINDOWS
 
     @pytest.mark.skipif(
         GITHUB_ACTIONS and LINUX,
         reason="unsupported on GITHUB_ACTIONS + LINUX",
     )
     def test_rlimit(self):
-        ae = self.assertEqual
-        ae(hasattr(psutil, "RLIM_INFINITY"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_AS"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_CORE"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_CPU"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_DATA"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_FSIZE"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_MEMLOCK"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_NOFILE"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_NPROC"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_RSS"), LINUX or FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_STACK"), LINUX or FREEBSD)
-
-        ae(hasattr(psutil, "RLIMIT_LOCKS"), LINUX)
+        assert hasattr(psutil, "RLIM_INFINITY") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_AS") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_CORE") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_CPU") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_DATA") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_FSIZE") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_MEMLOCK") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_NOFILE") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_NPROC") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_RSS") == LINUX or FREEBSD
+        assert hasattr(psutil, "RLIMIT_STACK") == LINUX or FREEBSD
+
+        assert hasattr(psutil, "RLIMIT_LOCKS") == LINUX
         if POSIX:
             if kernel_version() >= (2, 6, 8):
-                ae(hasattr(psutil, "RLIMIT_MSGQUEUE"), LINUX)
+                assert hasattr(psutil, "RLIMIT_MSGQUEUE") == LINUX
             if kernel_version() >= (2, 6, 12):
-                ae(hasattr(psutil, "RLIMIT_NICE"), LINUX)
+                assert hasattr(psutil, "RLIMIT_NICE") == LINUX
             if kernel_version() >= (2, 6, 12):
-                ae(hasattr(psutil, "RLIMIT_RTPRIO"), LINUX)
+                assert hasattr(psutil, "RLIMIT_RTPRIO") == LINUX
             if kernel_version() >= (2, 6, 25):
-                ae(hasattr(psutil, "RLIMIT_RTTIME"), LINUX)
+                assert hasattr(psutil, "RLIMIT_RTTIME") == LINUX
             if kernel_version() >= (2, 6, 8):
-                ae(hasattr(psutil, "RLIMIT_SIGPENDING"), LINUX)
+                assert hasattr(psutil, "RLIMIT_SIGPENDING") == LINUX
 
-        ae(hasattr(psutil, "RLIMIT_SWAP"), FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_SBSIZE"), FREEBSD)
-        ae(hasattr(psutil, "RLIMIT_NPTS"), FREEBSD)
+        assert hasattr(psutil, "RLIMIT_SWAP") == FREEBSD
+        assert hasattr(psutil, "RLIMIT_SBSIZE") == FREEBSD
+        assert hasattr(psutil, "RLIMIT_NPTS") == FREEBSD
 
 
 class TestAvailSystemAPIs(PsutilTestCase):
@@ -114,6 +109,7 @@ class TestAvailSystemAPIs(PsutilTestCase):
     def test_win_service_get(self):
         assert hasattr(psutil, "win_service_get") == WINDOWS
 
+    @pytest.mark.skipif(MACOS and AARCH64, reason="skipped due to #1892")
     def test_cpu_freq(self):
         assert hasattr(psutil, "cpu_freq") == (
             LINUX or MACOS or WINDOWS or FREEBSD or OPENBSD
@@ -226,9 +222,7 @@ class TestSystemAPITypes(PsutilTestCase):
         assert isinstance(psutil.cpu_count(), int)
 
     # TODO: remove this once 1892 is fixed
-    @pytest.mark.skipif(
-        MACOS and platform.machine() == 'arm64', reason="skipped due to #1892"
-    )
+    @pytest.mark.skipif(MACOS and AARCH64, reason="skipped due to #1892")
     @pytest.mark.skipif(not HAS_CPU_FREQ, reason="not supported")
     def test_cpu_freq(self):
         if psutil.cpu_freq() is None:
@@ -313,12 +307,14 @@ class TestSystemAPITypes(PsutilTestCase):
             assert isinstance(user.terminal, (str, type(None)))
             assert isinstance(user.host, (str, type(None)))
             assert isinstance(user.pid, (int, type(None)))
+            if isinstance(user.pid, int):
+                assert user.pid > 0
 
 
 class TestProcessWaitType(PsutilTestCase):
     @pytest.mark.skipif(not POSIX, reason="not POSIX")
     def test_negative_signal(self):
-        p = psutil.Process(self.spawn_testproc().pid)
+        p = psutil.Process(self.spawn_subproc().pid)
         p.terminate()
         code = p.wait()
         assert code == -signal.SIGTERM

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_linux.py

@@ -31,8 +31,7 @@ from psutil.tests import HAS_BATTERY
 from psutil.tests import HAS_CPU_FREQ
 from psutil.tests import HAS_GETLOADAVG
 from psutil.tests import HAS_RLIMIT
-from psutil.tests import PYPY
-from psutil.tests import PYTEST_PARALLEL
+from psutil.tests import RISCV64
 from psutil.tests import TOLERANCE_DISK_USAGE
 from psutil.tests import TOLERANCE_SYS_MEM
 from psutil.tests import PsutilTestCase
@@ -45,7 +44,6 @@ from psutil.tests import safe_rmpath
 from psutil.tests import sh
 from psutil.tests import skip_on_not_implemented
 
-
 if LINUX:
     from psutil._pslinux import CLOCK_TICKS
     from psutil._pslinux import RootFsDeviceFinder
@@ -243,10 +241,8 @@ class TestSystemVirtualMemoryAgainstFree(PsutilTestCase):
         # memory.
         # https://gitlab.com/procps-ng/procps/commit/
         #     2184e90d2e7cdb582f9a5b706b47015e56707e4d
-        if get_free_version_info() < (3, 3, 12):
+        if get_free_version_info() < (4, 0, 0):
             raise pytest.skip("free version too old")
-        if get_free_version_info() >= (4, 0, 0):
-            raise pytest.skip("free version too recent")
         cli_value = free_physmem().used
         psutil_value = psutil.virtual_memory().used
         assert abs(cli_value - psutil_value) < TOLERANCE_SYS_MEM
@@ -298,10 +294,8 @@ class TestSystemVirtualMemoryAgainstVmstat(PsutilTestCase):
         # memory.
         # https://gitlab.com/procps-ng/procps/commit/
         #     2184e90d2e7cdb582f9a5b706b47015e56707e4d
-        if get_free_version_info() < (3, 3, 12):
+        if get_free_version_info() < (4, 0, 0):
             raise pytest.skip("free version too old")
-        if get_free_version_info() >= (4, 0, 0):
-            raise pytest.skip("free version too recent")
         vmstat_value = vmstat('used memory') * 1024
         psutil_value = psutil.virtual_memory().used
         assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
@@ -776,7 +770,8 @@ class TestSystemCPUFrequency(PsutilTestCase):
 
     @pytest.mark.skipif(not HAS_CPU_FREQ, reason="not supported")
     @pytest.mark.skipif(
-        AARCH64, reason="aarch64 does not report mhz in /proc/cpuinfo"
+        AARCH64 or RISCV64,
+        reason=f"{platform.machine()} does not report mhz in /proc/cpuinfo",
     )
     def test_emulate_use_cpuinfo(self):
         # Emulate a case where /sys/devices/system/cpu/cpufreq* does not
@@ -915,7 +910,7 @@ class TestSystemCPUStats(PsutilTestCase):
     # def test_ctx_switches(self):
     #     vmstat_value = vmstat("context switches")
     #     psutil_value = psutil.cpu_stats().ctx_switches
-    #     self.assertAlmostEqual(vmstat_value, psutil_value, delta=500)
+    #     assert abs(vmstat_value - psutil_value) < 500
 
     def test_interrupts(self):
         vmstat_value = vmstat("interrupts")
@@ -977,9 +972,8 @@ class TestSystemNetIfAddrs(PsutilTestCase):
     #         if re.search(r"^\d+:", line):
     #             found += 1
     #             name = line.split(':')[1].strip()
-    #             self.assertIn(name, nics)
-    #     self.assertEqual(len(nics), found, msg="{}\n---\n{}".format(
-    #         pprint.pformat(nics), out))
+    #             assert name in nics
+    #     assert len(nics) == found
 
 
 @pytest.mark.skipif(not LINUX, reason="LINUX only")
@@ -1034,7 +1028,7 @@ class TestSystemNetIfStats(PsutilTestCase):
                         assert ifconfig_flags == psutil_flags
 
         if not matches_found:
-            raise self.fail("no matches were found")
+            raise pytest.fail("no matches were found")
 
 
 @pytest.mark.skipif(not LINUX, reason="LINUX only")
@@ -1095,13 +1089,12 @@ class TestSystemNetConnections(PsutilTestCase):
     @mock.patch('psutil._pslinux.supports_ipv6', return_value=False)
     def test_emulate_ipv6_unsupported(self, supports_ipv6, inet_ntop):
         # see: https://github.com/giampaolo/psutil/issues/623
-        try:
-            s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-            self.addCleanup(s.close)
-            s.bind(("::1", 0))
-        except OSError:
-            pass
-        psutil.net_connections(kind='inet6')
+        with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("::1", 0))
+            except OSError:
+                pass
+            psutil.net_connections(kind='inet6')
 
     def test_emulate_unix(self):
         content = textwrap.dedent("""\
@@ -1525,14 +1518,12 @@ class TestMisc(PsutilTestCase):
                 psutil.cpu_times(percpu=True)
             with pytest.raises(OSError):
                 psutil.boot_time()
-            # self.assertRaises(OSError, psutil.pids)
             with pytest.raises(OSError):
                 psutil.net_connections()
             with pytest.raises(OSError):
                 psutil.net_io_counters()
             with pytest.raises(OSError):
                 psutil.net_if_stats()
-            # self.assertRaises(OSError, psutil.disk_io_counters)
             with pytest.raises(OSError):
                 psutil.disk_partitions()
             with pytest.raises(psutil.NoSuchProcess):
@@ -1541,17 +1532,19 @@ class TestMisc(PsutilTestCase):
             psutil.PROCFS_PATH = "/proc"
 
     @retry_on_failure()
-    @pytest.mark.skipif(PYTEST_PARALLEL, reason="skip if pytest-parallel")
+    @pytest.mark.xdist_group(name="serial")
     def test_issue_687(self):
         # In case of thread ID:
         # - pid_exists() is supposed to return False
         # - Process(tid) is supposed to work
         # - pids() should not return the TID
         # See: https://github.com/giampaolo/psutil/issues/687
+
+        p = psutil.Process()
+        nthreads = len(p.threads())
         with ThreadTask():
-            p = psutil.Process()
             threads = p.threads()
-            assert len(threads) == 2
+            assert len(threads) == nthreads + 1
             tid = sorted(threads, key=lambda x: x.id)[1].id
             assert p.pid != tid
             pt = psutil.Process(tid)
@@ -1824,7 +1817,7 @@ class TestSensorsFans(PsutilTestCase):
 class TestProcess(PsutilTestCase):
     @retry_on_failure()
     def test_parse_smaps_vs_memory_maps(self):
-        sproc = self.spawn_testproc()
+        sproc = self.spawn_subproc()
         uss, pss, swap = psutil._pslinux.Process(sproc.pid)._parse_smaps()
         maps = psutil.Process(sproc.pid).memory_maps(grouped=False)
         assert (
@@ -1867,8 +1860,6 @@ class TestProcess(PsutilTestCase):
             assert pss == 3 * 1024
             assert swap == 15 * 1024
 
-    # On PYPY file descriptors are not closed fast enough.
-    @pytest.mark.skipif(PYPY, reason="unreliable on PYPY")
     def test_open_files_mode(self):
         def get_test_file(fname):
             p = psutil.Process()
@@ -1966,14 +1957,6 @@ class TestProcess(PsutilTestCase):
             assert psutil._pslinux.Process(os.getpid()).terminal() is None
             assert m.called
 
-    # TODO: re-enable this test.
-    # def test_num_ctx_switches_mocked(self):
-    #     with mock.patch('psutil._common.open', create=True) as m:
-    #         self.assertRaises(
-    #             NotImplementedError,
-    #             psutil._pslinux.Process(os.getpid()).num_ctx_switches)
-    #         assert m.called
-
     def test_cmdline_mocked(self):
         # see: https://github.com/giampaolo/psutil/issues/639
         p = psutil.Process()
@@ -2063,6 +2046,15 @@ class TestProcess(PsutilTestCase):
                 assert m.called
                 assert ret == ""
 
+    def test_cwd_mocked(self):
+        # https://github.com/giampaolo/psutil/issues/2514
+        with mock.patch(
+            'psutil._pslinux.readlink', side_effect=FileNotFoundError
+        ) as m:
+            ret = psutil.Process().cwd()
+            assert m.called
+            assert ret == ""
+
     def test_issue_1014(self):
         # Emulates a case where smaps file does not exist. In this case
         # wrap_exception decorator should not raise NoSuchProcess.
@@ -2200,6 +2192,11 @@ class TestProcess(PsutilTestCase):
                 assert p.net_connections() == []
                 assert m.called
 
+    def test_create_time_monotonic(self):
+        p = psutil.Process()
+        assert p._proc.create_time() != p._proc.create_time(monotonic=True)
+        assert p._get_ident()[1] == p._proc.create_time(monotonic=True)
+
 
 @pytest.mark.skipif(not LINUX, reason="LINUX only")
 class TestProcessAgainstStatus(PsutilTestCase):

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_memleaks.py

@@ -14,10 +14,8 @@ PyPy appears to be completely unstable for this framework, probably
 because of how its JIT handles memory, so tests are skipped.
 """
 
-
 import functools
 import os
-import platform
 
 import psutil
 import psutil._common
@@ -27,6 +25,7 @@ from psutil import OPENBSD
 from psutil import POSIX
 from psutil import SUNOS
 from psutil import WINDOWS
+from psutil.tests import AARCH64
 from psutil.tests import HAS_CPU_AFFINITY
 from psutil.tests import HAS_CPU_FREQ
 from psutil.tests import HAS_ENVIRON
@@ -45,11 +44,10 @@ from psutil.tests import get_testfn
 from psutil.tests import process_namespace
 from psutil.tests import pytest
 from psutil.tests import skip_on_access_denied
-from psutil.tests import spawn_testproc
+from psutil.tests import spawn_subproc
 from psutil.tests import system_namespace
 from psutil.tests import terminate
 
-
 cext = psutil._psplatform.cext
 thisproc = psutil.Process()
 FEW_TIMES = 5
@@ -274,7 +272,7 @@ class TestTerminatedProcessLeaks(TestProcessObjectLeaks):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.subp = spawn_testproc()
+        cls.subp = spawn_subproc()
         cls.proc = psutil.Process(cls.subp.pid)
         cls.proc.kill()
         cls.proc.wait()
@@ -363,9 +361,7 @@ class TestModuleFunctionsLeaks(TestMemoryLeak):
 
     @fewtimes_if_linux()
     # TODO: remove this once 1892 is fixed
-    @pytest.mark.skipif(
-        MACOS and platform.machine() == 'arm64', reason="skipped due to #1892"
-    )
+    @pytest.mark.skipif(MACOS and AARCH64, reason="skipped due to #1892")
     @pytest.mark.skipif(not HAS_CPU_FREQ, reason="not supported")
     def test_cpu_freq(self):
         self.execute(psutil.cpu_freq)

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_misc.py

@@ -35,7 +35,6 @@ from psutil.tests import pytest
 from psutil.tests import reload_module
 from psutil.tests import system_namespace
 
-
 # ===================================================================
 # --- Test classes' repr(), str(), ...
 # ===================================================================
@@ -49,7 +48,7 @@ class TestSpecialMethods(PsutilTestCase):
             psutil.Process(2**128)
 
     def test_process__repr__(self, func=repr):
-        p = psutil.Process(self.spawn_testproc().pid)
+        p = psutil.Process(self.spawn_subproc().pid)
         r = func(p)
         assert "psutil.Process" in r
         assert f"pid={p.pid}" in r
@@ -218,7 +217,9 @@ class TestMisc(PsutilTestCase):
                             fun.__doc__ is not None
                             and 'deprecated' not in fun.__doc__.lower()
                         ):
-                            raise self.fail(f"{name!r} not in psutil.__all__")
+                            raise pytest.fail(
+                                f"{name!r} not in psutil.__all__"
+                            )
 
         # Import 'star' will break if __all__ is inconsistent, see:
         # https://github.com/giampaolo/psutil/issues/656
@@ -254,7 +255,7 @@ class TestMisc(PsutilTestCase):
 
         ns = process_namespace(proc)
         for fun, name in ns.iter(ns.getters, clear_cache=True):
-            with self.subTest(proc=proc, name=name):
+            with self.subTest(proc=str(proc), name=name):
                 try:
                     ret = fun()
                 except psutil.Error:
@@ -342,7 +343,7 @@ class TestMisc(PsutilTestCase):
         with mock.patch.object(
             psutil.Process, '_get_ident', side_effect=psutil.NoSuchProcess(1)
         ) as meth:
-            with self.assertRaises(psutil.NoSuchProcess):
+            with pytest.raises(psutil.NoSuchProcess):
                 psutil.Process()
             assert meth.called
 
@@ -545,35 +546,28 @@ class TestCommonModule(PsutilTestCase):
         assert parse_environ_block("a=1\0b=2") == {k("a"): "1"}
 
     def test_supports_ipv6(self):
-        self.addCleanup(supports_ipv6.cache_clear)
         if supports_ipv6():
             with mock.patch('psutil._common.socket') as s:
                 s.has_ipv6 = False
-                supports_ipv6.cache_clear()
                 assert not supports_ipv6()
 
-            supports_ipv6.cache_clear()
             with mock.patch(
                 'psutil._common.socket.socket', side_effect=OSError
             ) as s:
                 assert not supports_ipv6()
                 assert s.called
 
-            supports_ipv6.cache_clear()
             with mock.patch(
                 'psutil._common.socket.socket', side_effect=socket.gaierror
             ) as s:
                 assert not supports_ipv6()
-                supports_ipv6.cache_clear()
                 assert s.called
 
-            supports_ipv6.cache_clear()
             with mock.patch(
                 'psutil._common.socket.socket.bind',
                 side_effect=socket.gaierror,
             ) as s:
                 assert not supports_ipv6()
-                supports_ipv6.cache_clear()
                 assert s.called
         else:
             with pytest.raises(OSError):

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_osx.py

@@ -6,13 +6,13 @@
 
 """macOS specific tests."""
 
-import platform
 import re
 import time
 
 import psutil
 from psutil import MACOS
 from psutil import POSIX
+from psutil.tests import AARCH64
 from psutil.tests import CI_TESTING
 from psutil.tests import HAS_BATTERY
 from psutil.tests import TOLERANCE_DISK_USAGE
@@ -21,10 +21,9 @@ from psutil.tests import PsutilTestCase
 from psutil.tests import pytest
 from psutil.tests import retry_on_failure
 from psutil.tests import sh
-from psutil.tests import spawn_testproc
+from psutil.tests import spawn_subproc
 from psutil.tests import terminate
 
-
 if POSIX:
     from psutil._psutil_posix import getpagesize
 
@@ -56,7 +55,7 @@ def vm_stat(field):
 class TestProcess(PsutilTestCase):
     @classmethod
     def setUpClass(cls):
-        cls.pid = spawn_testproc().pid
+        cls.pid = spawn_subproc().pid
 
     @classmethod
     def tearDownClass(cls):
@@ -115,9 +114,7 @@ class TestSystemAPIs(PsutilTestCase):
         assert num == psutil.cpu_count(logical=False)
 
     # TODO: remove this once 1892 is fixed
-    @pytest.mark.skipif(
-        MACOS and platform.machine() == 'arm64', reason="skipped due to #1892"
-    )
+    @pytest.mark.skipif(MACOS and AARCH64, reason="skipped due to #1892")
     def test_cpu_freq(self):
         freq = psutil.cpu_freq()
         assert freq.current * 1000 * 1000 == sysctl("sysctl hw.cpufrequency")
@@ -131,7 +128,7 @@ class TestSystemAPIs(PsutilTestCase):
         assert sysctl_hwphymem == psutil.virtual_memory().total
 
     @pytest.mark.skipif(
-        CI_TESTING and MACOS and platform.machine() == 'arm64',
+        CI_TESTING and MACOS and AARCH64,
         reason="skipped on MACOS + ARM64 + CI_TESTING",
     )
     @retry_on_failure()
@@ -140,6 +137,10 @@ class TestSystemAPIs(PsutilTestCase):
         psutil_val = psutil.virtual_memory().free
         assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM
 
+    @pytest.mark.skipif(
+        CI_TESTING and MACOS and AARCH64,
+        reason="skipped on MACOS + ARM64 + CI_TESTING",
+    )
     @retry_on_failure()
     def test_vmem_active(self):
         vmstat_val = vm_stat("active")
@@ -195,3 +196,11 @@ class TestSystemAPIs(PsutilTestCase):
         psutil_result = psutil.sensors_battery()
         assert psutil_result.power_plugged == power_plugged
         assert psutil_result.percent == int(percent)
+
+    # --- others
+
+    def test_boot_time(self):
+        out = sh('sysctl kern.boottime')
+        a = float(re.search(r"sec\s*=\s*(\d+)", out).groups(0)[0])
+        b = psutil.boot_time()
+        assert a == b