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

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

@@ -10,7 +10,6 @@ import datetime
 import enum
 import errno
 import os
-import platform
 import pprint
 import shutil
 import signal
@@ -43,7 +42,6 @@ from psutil.tests import HAS_NET_IO_COUNTERS
 from psutil.tests import HAS_SENSORS_BATTERY
 from psutil.tests import HAS_SENSORS_FANS
 from psutil.tests import HAS_SENSORS_TEMPERATURES
-from psutil.tests import IS_64BIT
 from psutil.tests import MACOS_12PLUS
 from psutil.tests import PYPY
 from psutil.tests import UNICODE_SUFFIX
@@ -52,7 +50,6 @@ from psutil.tests import check_net_address
 from psutil.tests import pytest
 from psutil.tests import retry_on_failure
 
-
 # ===================================================================
 # --- System-related API tests
 # ===================================================================
@@ -61,7 +58,7 @@ from psutil.tests import retry_on_failure
 class TestProcessIter(PsutilTestCase):
     def test_pid_presence(self):
         assert os.getpid() in [x.pid for x in psutil.process_iter()]
-        sproc = self.spawn_testproc()
+        sproc = self.spawn_subproc()
         assert sproc.pid in [x.pid for x in psutil.process_iter()]
         p = psutil.Process(sproc.pid)
         p.kill()
@@ -133,16 +130,16 @@ class TestProcessIter(PsutilTestCase):
 class TestProcessAPIs(PsutilTestCase):
     @pytest.mark.skipif(
         PYPY and WINDOWS,
-        reason="spawn_testproc() unreliable on PYPY + WINDOWS",
+        reason="spawn_subproc() unreliable on PYPY + WINDOWS",
     )
     def test_wait_procs(self):
         def callback(p):
             pids.append(p.pid)
 
         pids = []
-        sproc1 = self.spawn_testproc()
-        sproc2 = self.spawn_testproc()
-        sproc3 = self.spawn_testproc()
+        sproc1 = self.spawn_subproc()
+        sproc2 = self.spawn_subproc()
+        sproc3 = self.spawn_subproc()
         procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
         with pytest.raises(ValueError):
             psutil.wait_procs(procs, timeout=-1)
@@ -196,19 +193,19 @@ class TestProcessAPIs(PsutilTestCase):
 
     @pytest.mark.skipif(
         PYPY and WINDOWS,
-        reason="spawn_testproc() unreliable on PYPY + WINDOWS",
+        reason="spawn_subproc() unreliable on PYPY + WINDOWS",
     )
     def test_wait_procs_no_timeout(self):
-        sproc1 = self.spawn_testproc()
-        sproc2 = self.spawn_testproc()
-        sproc3 = self.spawn_testproc()
+        sproc1 = self.spawn_subproc()
+        sproc2 = self.spawn_subproc()
+        sproc3 = self.spawn_subproc()
         procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
         for p in procs:
             p.terminate()
         psutil.wait_procs(procs)
 
     def test_pid_exists(self):
-        sproc = self.spawn_testproc()
+        sproc = self.spawn_subproc()
         assert psutil.pid_exists(sproc.pid)
         p = psutil.Process(sproc.pid)
         p.kill()
@@ -325,9 +322,9 @@ class TestMemoryAPIs(PsutilTestCase):
                 assert isinstance(value, int)
             if name != 'total':
                 if not value >= 0:
-                    raise self.fail(f"{name!r} < 0 ({value})")
+                    raise pytest.fail(f"{name!r} < 0 ({value})")
                 if value > mem.total:
-                    raise self.fail(
+                    raise pytest.fail(
                         f"{name!r} > total (total={mem.total}, {name}={value})"
                     )
 
@@ -417,9 +414,7 @@ class TestCpuAPIs(PsutilTestCase):
         #         for field in new._fields:
         #             new_t = getattr(new, field)
         #             last_t = getattr(last, field)
-        #             self.assertGreaterEqual(
-        #                 new_t, last_t,
-        #                 msg="{} {}".format(new_t, last_t))
+        #             assert new_t >= last_t
         #         last = new
 
     def test_cpu_times_time_increases(self):
@@ -430,7 +425,7 @@ class TestCpuAPIs(PsutilTestCase):
             t2 = sum(psutil.cpu_times())
             if t2 > t1:
                 return
-        raise self.fail("time remained the same")
+        raise pytest.fail("time remained the same")
 
     def test_per_cpu_times(self):
         # Check type, value >= 0, str().
@@ -462,8 +457,7 @@ class TestCpuAPIs(PsutilTestCase):
         #         for field in newcpu._fields:
         #             new_t = getattr(newcpu, field)
         #             last_t = getattr(lastcpu, field)
-        #             self.assertGreaterEqual(
-        #                 new_t, last_t, msg="{} {}".format(lastcpu, newcpu))
+        #             assert new_t >= last_t
         #     last = new
 
     def test_per_cpu_times_2(self):
@@ -473,7 +467,7 @@ class TestCpuAPIs(PsutilTestCase):
         giveup_at = time.time() + GLOBAL_TIMEOUT
         while True:
             if time.time() >= giveup_at:
-                return self.fail("timeout")
+                return pytest.fail("timeout")
             tot2 = psutil.cpu_times(percpu=True)
             for t1, t2 in zip(tot1, tot2):
                 t1, t2 = psutil._cpu_busy_time(t1), psutil._cpu_busy_time(t2)
@@ -482,7 +476,7 @@ class TestCpuAPIs(PsutilTestCase):
                     return None
 
     @pytest.mark.skipif(
-        CI_TESTING and OPENBSD, reason="unreliable on OPENBSD + CI"
+        (CI_TESTING and OPENBSD) or MACOS, reason="unreliable on OPENBSD + CI"
     )
     @retry_on_failure(30)
     def test_cpu_times_comparison(self):
@@ -582,9 +576,7 @@ class TestCpuAPIs(PsutilTestCase):
                 assert value > 0
 
     # 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):
         def check_ls(ls):
@@ -619,9 +611,6 @@ class TestCpuAPIs(PsutilTestCase):
 
 
 class TestDiskAPIs(PsutilTestCase):
-    @pytest.mark.skipif(
-        PYPY and not IS_64BIT, reason="unreliable on PYPY32 + 32BIT"
-    )
     def test_disk_usage(self):
         usage = psutil.disk_usage(os.getcwd())
         assert usage._fields == ('total', 'used', 'free', 'percent')
@@ -810,8 +799,9 @@ class TestNetAPIs(PsutilTestCase):
 
         # Not reliable on all platforms (net_if_addrs() reports more
         # interfaces).
-        # self.assertEqual(sorted(nics.keys()),
-        #                  sorted(psutil.net_io_counters(pernic=True).keys()))
+        # assert sorted(nics.keys()) == sorted(
+        #     psutil.net_io_counters(pernic=True).keys()
+        # )
 
         families = {socket.AF_INET, socket.AF_INET6, psutil.AF_LINK}
         for nic, addrs in nics.items():

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

@@ -56,7 +56,6 @@ from psutil.tests import unix_socketpair
 from psutil.tests import wait_for_file
 from psutil.tests import wait_for_pid
 
-
 # ===================================================================
 # --- Unit tests for test utilities.
 # ===================================================================
@@ -218,7 +217,7 @@ class TestFSTestUtils(PsutilTestCase):
 
 class TestProcessUtils(PsutilTestCase):
     def test_reap_children(self):
-        subp = self.spawn_testproc()
+        subp = self.spawn_subproc()
         p = psutil.Process(subp.pid)
         assert p.is_running()
         reap_children()
@@ -254,14 +253,14 @@ class TestProcessUtils(PsutilTestCase):
 
     def test_terminate(self):
         # by subprocess.Popen
-        p = self.spawn_testproc()
+        p = self.spawn_subproc()
         terminate(p)
-        self.assertPidGone(p.pid)
+        self.assert_pid_gone(p.pid)
         terminate(p)
         # by psutil.Process
-        p = psutil.Process(self.spawn_testproc().pid)
+        p = psutil.Process(self.spawn_subproc().pid)
         terminate(p)
-        self.assertPidGone(p.pid)
+        self.assert_pid_gone(p.pid)
         terminate(p)
         # by psutil.Popen
         cmd = [
@@ -276,20 +275,20 @@ class TestProcessUtils(PsutilTestCase):
             env=PYTHON_EXE_ENV,
         )
         terminate(p)
-        self.assertPidGone(p.pid)
+        self.assert_pid_gone(p.pid)
         terminate(p)
         # by PID
-        pid = self.spawn_testproc().pid
+        pid = self.spawn_subproc().pid
         terminate(pid)
-        self.assertPidGone(p.pid)
+        self.assert_pid_gone(p.pid)
         terminate(pid)
         # zombie
         if POSIX:
             parent, zombie = self.spawn_zombie()
             terminate(parent)
             terminate(zombie)
-            self.assertPidGone(parent.pid)
-            self.assertPidGone(zombie.pid)
+            self.assert_pid_gone(parent.pid)
+            self.assert_pid_gone(zombie.pid)
 
 
 class TestNetUtils(PsutilTestCase):
@@ -398,7 +397,7 @@ class TestMemLeakClass(TestMemoryLeak):
 
         try:
             # will consume around 60M in total
-            with pytest.raises(AssertionError, match="extra-mem"):
+            with pytest.raises(pytest.fail.Exception, match="extra-mem"):
                 self.execute(fun, times=100)
         finally:
             del ls
@@ -411,7 +410,7 @@ class TestMemLeakClass(TestMemoryLeak):
 
         box = []
         kind = "fd" if POSIX else "handle"
-        with pytest.raises(AssertionError, match="unclosed " + kind):
+        with pytest.raises(pytest.fail.Exception, match="unclosed " + kind):
             self.execute(fun)
 
     def test_tolerance(self):
@@ -436,7 +435,7 @@ class TestMemLeakClass(TestMemoryLeak):
         def fun_2():
             pass
 
-        with pytest.raises(AssertionError):
+        with pytest.raises(pytest.fail.Exception):
             self.execute_w_exc(ZeroDivisionError, fun_2)
 
 
@@ -460,9 +459,9 @@ class TestFakePytest(PsutilTestCase):
             with fake_pytest.raises(ValueError, match="foo") as cm:
                 raise ValueError("bar")
         except AssertionError as err:
-            assert str(err) == '"foo" does not match "bar"'
+            assert str(err) == '"foo" does not match "bar"'  # noqa: PT017
         else:
-            raise self.fail("exception not raised")
+            raise pytest.fail("exception not raised")
 
     def test_mark(self):
         @fake_pytest.mark.xdist_group(name="serial")
@@ -523,11 +522,8 @@ class TestFakePytest(PsutilTestCase):
                         pass
                 """).lstrip())
         with mock.patch.object(psutil.tests, "HERE", tmpdir):
-            with self.assertWarnsRegex(
-                UserWarning, "Fake pytest module was used"
-            ):
-                suite = fake_pytest.main()
-                assert suite.countTestCases() == 1
+            suite = fake_pytest.main()
+            assert suite.countTestCases() == 1
 
     def test_warns(self):
         # success
@@ -541,7 +537,7 @@ class TestFakePytest(PsutilTestCase):
         except AssertionError:
             pass
         else:
-            raise self.fail("exception not raised")
+            raise pytest.fail("exception not raised")
 
         # match success
         with fake_pytest.warns(UserWarning, match="foo"):
@@ -554,7 +550,11 @@ class TestFakePytest(PsutilTestCase):
         except AssertionError:
             pass
         else:
-            raise self.fail("exception not raised")
+            raise pytest.fail("exception not raised")
+
+    def test_fail(self):
+        with fake_pytest.raises(fake_pytest.fail.Exception):
+            raise fake_pytest.fail("reason")
 
 
 class TestTestingUtils(PsutilTestCase):

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

@@ -73,6 +73,9 @@ from contextlib import closing
 
 import psutil
 from psutil import BSD
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
 from psutil import POSIX
 from psutil import WINDOWS
 from psutil.tests import ASCII_FS
@@ -94,7 +97,7 @@ from psutil.tests import pytest
 from psutil.tests import safe_mkdir
 from psutil.tests import safe_rmpath
 from psutil.tests import skip_on_access_denied
-from psutil.tests import spawn_testproc
+from psutil.tests import spawn_subproc
 from psutil.tests import terminate
 
 
@@ -107,7 +110,7 @@ def try_unicode(suffix):
     try:
         safe_rmpath(testfn)
         create_py_exe(testfn)
-        sproc = spawn_testproc(cmd=[testfn])
+        sproc = spawn_subproc(cmd=[testfn])
         shutil.copyfile(testfn, testfn + '-2')
         safe_rmpath(testfn + '-2')
     except (UnicodeEncodeError, OSError):
@@ -166,7 +169,7 @@ class TestFSAPIs(BaseUnicodeTest):
             "-c",
             "import time; [time.sleep(0.1) for x in range(100)]",
         ]
-        subp = self.spawn_testproc(cmd)
+        subp = self.spawn_subproc(cmd)
         p = psutil.Process(subp.pid)
         exe = p.exe()
         assert isinstance(exe, str)
@@ -179,7 +182,7 @@ class TestFSAPIs(BaseUnicodeTest):
             "-c",
             "import time; [time.sleep(0.1) for x in range(100)]",
         ]
-        subp = self.spawn_testproc(cmd)
+        subp = self.spawn_subproc(cmd)
         name = psutil.Process(subp.pid).name()
         assert isinstance(name, str)
         if self.expect_exact_path_match():
@@ -191,7 +194,7 @@ class TestFSAPIs(BaseUnicodeTest):
             "-c",
             "import time; [time.sleep(0.1) for x in range(100)]",
         ]
-        subp = self.spawn_testproc(cmd)
+        subp = self.spawn_subproc(cmd)
         p = psutil.Process(subp.pid)
         cmdline = p.cmdline()
         for part in cmdline:
@@ -211,6 +214,9 @@ class TestFSAPIs(BaseUnicodeTest):
             assert cwd == dname
 
     @pytest.mark.skipif(PYPY and WINDOWS, reason="fails on PYPY + WINDOWS")
+    @pytest.mark.skipif(
+        NETBSD or OPENBSD, reason="broken on NETBSD or OPENBSD"
+    )
     def test_proc_open_files(self):
         p = psutil.Process()
         start = set(p.open_files())
@@ -231,6 +237,8 @@ class TestFSAPIs(BaseUnicodeTest):
         with closing(sock):
             conn = psutil.Process().net_connections('unix')[0]
             assert isinstance(conn.laddr, str)
+            if not conn.laddr and MACOS and CI_TESTING:
+                raise pytest.skip("unreliable on OSX")
             assert conn.laddr == name
 
     @pytest.mark.skipif(not POSIX, reason="POSIX only")
@@ -260,7 +268,6 @@ class TestFSAPIs(BaseUnicodeTest):
         psutil.disk_usage(dname)
 
     @pytest.mark.skipif(not HAS_MEMORY_MAPS, reason="not supported")
-    @pytest.mark.skipif(PYPY, reason="unstable on PYPY")
     def test_memory_maps(self):
         with copyload_shared_lib(suffix=self.funky_suffix) as funky_path:
 
@@ -284,7 +291,7 @@ class TestFSAPIsWithInvalidPath(TestFSAPIs):
     funky_suffix = INVALID_UNICODE_SUFFIX
 
     def expect_exact_path_match(self):
-        return True
+        return not MACOS
 
 
 # ===================================================================
@@ -304,7 +311,7 @@ class TestNonFSAPIS(BaseUnicodeTest):
         # with fs paths.
         env = os.environ.copy()
         env['FUNNY_ARG'] = self.funky_suffix
-        sproc = self.spawn_testproc(env=env)
+        sproc = self.spawn_subproc(env=env)
         p = psutil.Process(sproc.pid)
         env = p.environ()
         for k, v in env.items():

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

@@ -6,6 +6,7 @@
 
 """Windows specific tests."""
 
+import ctypes
 import datetime
 import glob
 import os
@@ -31,10 +32,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 WINDOWS and not PYPY:
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
@@ -141,7 +141,7 @@ class TestSystemAPIs(WindowsTestCase):
             if "pseudo-interface" in nic.replace(' ', '-').lower():
                 continue
             if nic not in out:
-                raise self.fail(
+                raise pytest.fail(
                     f"{nic!r} nic wasn't found in 'ipconfig /all' output"
                 )
 
@@ -222,10 +222,12 @@ class TestSystemAPIs(WindowsTestCase):
                     assert usage.free == wmi_free
                     # 10 MB tolerance
                     if abs(usage.free - wmi_free) > 10 * 1024 * 1024:
-                        raise self.fail(f"psutil={usage.free}, wmi={wmi_free}")
+                        raise pytest.fail(
+                            f"psutil={usage.free}, wmi={wmi_free}"
+                        )
                     break
             else:
-                raise self.fail(f"can't find partition {ps_part!r}")
+                raise pytest.fail(f"can't find partition {ps_part!r}")
 
     @retry_on_failure()
     def test_disk_usage(self):
@@ -253,6 +255,38 @@ class TestSystemAPIs(WindowsTestCase):
         ]
         assert sys_value == psutil_value
 
+    def test_convert_dos_path_drive(self):
+        winpath = 'C:\\Windows\\Temp'
+        driveletter = 'C:'
+        # Mocked NT device path for C:
+        devicepath = '\\Device\\HarddiskVolume1'
+
+        # Path returned by RtlDosPathNameToNtPathName
+        ntpath1 = '\\??\\C:\\Windows\\Temp'
+        # Mocked normalized NT path
+        ntpath2 = '\\Device\\HarddiskVolume1\\Windows\\Temp'
+
+        devices = {devicepath: driveletter}
+
+        with mock.patch(
+            'psutil._pswindows.cext.QueryDosDevice', side_effect=devices.get
+        ) as m:
+            assert psutil._pswindows.convert_dos_path(ntpath1) == winpath
+            assert psutil._pswindows.convert_dos_path(ntpath2) == winpath
+            assert m.called
+
+    def test_convert_dos_path_unc(self):
+        # UNC path
+        winpath = '\\\\localhost\\C$\\Windows\\Temp'
+        # Path returned by RtlDosPathNameToNtPathName
+        ntpath1 = '\\??\\UNC\\localhost\\C$\\Windows\\Temp'
+        # Normalized NT path
+        ntpath2 = '\\Device\\Mup\\localhost\\C$\\Windows\\Temp'
+
+        assert psutil._pswindows.convert_dos_path(winpath) == winpath
+        assert psutil._pswindows.convert_dos_path(ntpath1) == winpath
+        assert psutil._pswindows.convert_dos_path(ntpath2) == winpath
+
     def test_net_if_stats(self):
         ps_names = set(cext.net_if_stats())
         wmi_adapters = wmi.WMI().Win32_NetworkAdapter()
@@ -272,18 +306,14 @@ class TestSystemAPIs(WindowsTestCase):
         )
         psutil_dt = datetime.datetime.fromtimestamp(psutil.boot_time())
         diff = abs((wmi_btime_dt - psutil_dt).total_seconds())
-        assert diff <= 5
+        assert diff <= 5, (psutil_dt, wmi_btime_dt)
 
-    def test_boot_time_fluctuation(self):
-        # https://github.com/giampaolo/psutil/issues/1007
-        with mock.patch('psutil._pswindows.cext.boot_time', return_value=5):
-            assert psutil.boot_time() == 5
-        with mock.patch('psutil._pswindows.cext.boot_time', return_value=4):
-            assert psutil.boot_time() == 5
-        with mock.patch('psutil._pswindows.cext.boot_time', return_value=6):
-            assert psutil.boot_time() == 5
-        with mock.patch('psutil._pswindows.cext.boot_time', return_value=333):
-            assert psutil.boot_time() == 333
+    def test_uptime(self):
+        # ...against GetTickCount64() (Windows < 7, does not include
+        # time spent during suspend / hybernate).
+        ms = ctypes.windll.kernel32.GetTickCount64()
+        secs = ms / 1000.0
+        assert abs(cext.uptime() - secs) < 0.5
 
 
 # ===================================================================
@@ -364,7 +394,7 @@ class TestSensorsBattery(WindowsTestCase):
 class TestProcess(WindowsTestCase):
     @classmethod
     def setUpClass(cls):
-        cls.pid = spawn_testproc().pid
+        cls.pid = spawn_subproc().pid
 
     @classmethod
     def tearDownClass(cls):
@@ -409,7 +439,7 @@ class TestProcess(WindowsTestCase):
         assert p.num_handles() == before
 
     def test_ctrl_signals(self):
-        p = psutil.Process(self.spawn_testproc().pid)
+        p = psutil.Process(self.spawn_subproc().pid)
         p.send_signal(signal.CTRL_C_EVENT)
         p.send_signal(signal.CTRL_BREAK_EVENT)
         p.kill()
@@ -442,17 +472,14 @@ class TestProcess(WindowsTestCase):
     # XXX - occasional failures
 
     # def test_cpu_times(self):
-    #     handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
-    #                                   win32con.FALSE, os.getpid())
+    #     handle = win32api.OpenProcess(
+    #         win32con.PROCESS_QUERY_INFORMATION, win32con.FALSE, os.getpid()
+    #     )
     #     self.addCleanup(win32api.CloseHandle, handle)
-    #     sys_value = win32process.GetProcessTimes(handle)
-    #     psutil_value = psutil.Process().cpu_times()
-    #     self.assertAlmostEqual(
-    #         psutil_value.user, sys_value['UserTime'] / 10000000.0,
-    #         delta=0.2)
-    #     self.assertAlmostEqual(
-    #         psutil_value.user, sys_value['KernelTime'] / 10000000.0,
-    #         delta=0.2)
+    #     a = psutil.Process().cpu_times()
+    #     b = win32process.GetProcessTimes(handle)
+    #     assert abs(a.user - b['UserTime'] / 10000000.0) < 0.2
+    #     assert abs(a.user - b['KernelTime'] / 10000000.0) < 0.2
 
     def test_nice(self):
         handle = win32api.OpenProcess(
@@ -572,7 +599,7 @@ class TestProcessWMI(WindowsTestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.pid = spawn_testproc().pid
+        cls.pid = spawn_subproc().pid
 
     @classmethod
     def tearDownClass(cls):
@@ -624,7 +651,7 @@ class TestProcessWMI(WindowsTestCase):
         # returned instead.
         wmi_usage = int(w.PageFileUsage)
         if vms not in {wmi_usage, wmi_usage * 1024}:
-            raise self.fail(f"wmi={wmi_usage}, psutil={vms}")
+            raise pytest.fail(f"wmi={wmi_usage}, psutil={vms}")
 
     def test_create_time(self):
         w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
@@ -652,7 +679,7 @@ class TestDualProcessImplementation(PsutilTestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.pid = spawn_testproc().pid
+        cls.pid = spawn_subproc().pid
 
     @classmethod
     def tearDownClass(cls):
@@ -772,10 +799,10 @@ class RemoteProcessTestCase(PsutilTestCase):
 
         env = os.environ.copy()
         env["THINK_OF_A_NUMBER"] = str(os.getpid())
-        self.proc32 = self.spawn_testproc(
+        self.proc32 = self.spawn_subproc(
             [self.python32] + self.test_args, env=env, stdin=subprocess.PIPE
         )
-        self.proc64 = self.spawn_testproc(
+        self.proc64 = self.spawn_subproc(
             [self.python64] + self.test_args, env=env, stdin=subprocess.PIPE
         )
 
@@ -844,6 +871,11 @@ class TestServices(PsutilTestCase):
             "stopped",
         }
         for serv in psutil.win_service_iter():
+            if serv.name() == "WaaSMedicSvc":
+                # known issue in Windows 11 reading the description
+                # https://learn.microsoft.com/en-us/answers/questions/1320388/in-windows-11-version-22h2-there-it-shows-(failed
+                # https://github.com/giampaolo/psutil/issues/2383
+                continue
             data = serv.as_dict()
             assert isinstance(data['name'], str)
             assert data['name'].strip()

{py2docfx-0.1.20rc2245107.dist-info → py2docfx-0.1.21.dev2246704.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py2docfx
-Version: 0.1.20rc2245107
+Version: 0.1.21.dev2246704
 Summary: A package built based on Sphinx which download source code package and generate yaml files supported by docfx.
 Author: Microsoft Corporation
 License: MIT License