py2docfx 0.1.15.dev2025501__py3-none-any.whl → 0.1.15.dev2038808__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32pipe.py

@@ -1,148 +0,0 @@
-import threading
-import time
-import unittest
-
-import pywintypes
-import win32con
-import win32event
-import win32file
-import win32pipe
-import winerror
-
-
-class PipeTests(unittest.TestCase):
-    pipename = "\\\\.\\pipe\\python_test_pipe"
-
-    def _serverThread(self, pipe_handle, event, wait_time):
-        # just do one connection and terminate.
-        hr = win32pipe.ConnectNamedPipe(pipe_handle)
-        self.assertTrue(
-            hr in (0, winerror.ERROR_PIPE_CONNECTED), f"Got error code 0x{hr:x}"
-        )
-        hr, got = win32file.ReadFile(pipe_handle, 100)
-        self.assertEqual(got, b"foo\0bar")
-        time.sleep(wait_time)
-        win32file.WriteFile(pipe_handle, b"bar\0foo")
-        pipe_handle.Close()
-        event.set()
-
-    def startPipeServer(self, event, wait_time=0):
-        openMode = win32pipe.PIPE_ACCESS_DUPLEX
-        pipeMode = win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_WAIT
-
-        sa = pywintypes.SECURITY_ATTRIBUTES()
-        sa.SetSecurityDescriptorDacl(1, None, 0)
-
-        pipe_handle = win32pipe.CreateNamedPipe(
-            self.pipename,
-            openMode,
-            pipeMode,
-            win32pipe.PIPE_UNLIMITED_INSTANCES,
-            0,
-            0,
-            2000,
-            sa,
-        )
-
-        threading.Thread(
-            target=self._serverThread, args=(pipe_handle, event, wait_time)
-        ).start()
-
-    def testCallNamedPipe(self):
-        event = threading.Event()
-        self.startPipeServer(event)
-
-        got = win32pipe.CallNamedPipe(
-            self.pipename, b"foo\0bar", 1024, win32pipe.NMPWAIT_WAIT_FOREVER
-        )
-        self.assertEqual(got, b"bar\0foo")
-        event.wait(5)
-        self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
-
-    def testTransactNamedPipeBlocking(self):
-        event = threading.Event()
-        self.startPipeServer(event)
-        open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
-
-        hpipe = win32file.CreateFile(
-            self.pipename,
-            open_mode,
-            0,  # no sharing
-            None,  # default security
-            win32con.OPEN_EXISTING,
-            0,  # win32con.FILE_FLAG_OVERLAPPED,
-            None,
-        )
-
-        # set to message mode.
-        win32pipe.SetNamedPipeHandleState(
-            hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None
-        )
-
-        hr, got = win32pipe.TransactNamedPipe(hpipe, b"foo\0bar", 1024, None)
-        self.assertEqual(got, b"bar\0foo")
-        event.wait(5)
-        self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
-
-    def testTransactNamedPipeBlockingBuffer(self):
-        # Like testTransactNamedPipeBlocking, but a pre-allocated buffer is
-        # passed (not really that useful, but it exercises the code path)
-        event = threading.Event()
-        self.startPipeServer(event)
-        open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
-
-        hpipe = win32file.CreateFile(
-            self.pipename,
-            open_mode,
-            0,  # no sharing
-            None,  # default security
-            win32con.OPEN_EXISTING,
-            0,  # win32con.FILE_FLAG_OVERLAPPED,
-            None,
-        )
-
-        # set to message mode.
-        win32pipe.SetNamedPipeHandleState(
-            hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None
-        )
-
-        buffer = win32file.AllocateReadBuffer(1024)
-        hr, got = win32pipe.TransactNamedPipe(hpipe, b"foo\0bar", buffer, None)
-        self.assertEqual(got, b"bar\0foo")
-        event.wait(5)
-        self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
-
-    def testTransactNamedPipeAsync(self):
-        event = threading.Event()
-        overlapped = pywintypes.OVERLAPPED()
-        overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
-        self.startPipeServer(event, 0.5)
-        open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
-
-        hpipe = win32file.CreateFile(
-            self.pipename,
-            open_mode,
-            0,  # no sharing
-            None,  # default security
-            win32con.OPEN_EXISTING,
-            win32con.FILE_FLAG_OVERLAPPED,
-            None,
-        )
-
-        # set to message mode.
-        win32pipe.SetNamedPipeHandleState(
-            hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None
-        )
-
-        buffer = win32file.AllocateReadBuffer(1024)
-        hr, got = win32pipe.TransactNamedPipe(hpipe, b"foo\0bar", buffer, overlapped)
-        self.assertEqual(hr, winerror.ERROR_IO_PENDING)
-        nbytes = win32file.GetOverlappedResult(hpipe, overlapped, True)
-        got = buffer[:nbytes]
-        self.assertEqual(got, b"bar\0foo")
-        event.wait(5)
-        self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32print.py

@@ -1,24 +0,0 @@
-# Tests (scarce) for win32print module
-
-import unittest
-
-import win32print as wprn
-
-
-class Win32PrintTestCase(unittest.TestCase):
-    def setUp(self):
-        self.printer_idx = 0
-        self.printer_levels_all = list(range(1, 10))
-        self.local_printers = wprn.EnumPrinters(wprn.PRINTER_ENUM_LOCAL, None, 1)
-
-    def test_printer_levels_read_dummy(self):
-        if not self.local_printers:
-            print("Test didn't run (no local printers)!")
-            return
-        ph = wprn.OpenPrinter(self.local_printers[self.printer_idx][2])
-        for level in self.printer_levels_all:
-            wprn.GetPrinter(ph, level)
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32profile.py

@@ -1,19 +0,0 @@
-"""Test win32profile"""
-
-import os
-import unittest
-
-import win32profile
-
-
-class Tester(unittest.TestCase):
-    def test_environment(self):
-        os.environ["FOO"] = "bar=baz"
-        env = win32profile.GetEnvironmentStrings()
-        self.assertIn("FOO", env)
-        self.assertEqual(env["FOO"], "bar=baz")
-        self.assertEqual(os.environ["FOO"], "bar=baz")
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32rcparser.py

@@ -1,70 +0,0 @@
-import os
-import tempfile
-import unittest
-
-import win32con
-import win32rcparser
-
-
-class TestParser(unittest.TestCase):
-    def setUp(self):
-        rc_file = os.path.join(os.path.dirname(__file__), "win32rcparser", "test.rc")
-        self.resources = win32rcparser.Parse(rc_file)
-
-    def testStrings(self):
-        for sid, expected in (
-            ("IDS_TEST_STRING4", "Test 'single quoted' string"),
-            ("IDS_TEST_STRING1", 'Test "quoted" string'),
-            ("IDS_TEST_STRING3", 'String with single " quote'),
-            ("IDS_TEST_STRING2", "Test string"),
-        ):
-            got = self.resources.stringTable[sid].value
-            self.assertEqual(got, expected)
-
-    def testStandardIds(self):
-        for idc in "IDOK IDCANCEL".split():
-            correct = getattr(win32con, idc)
-            self.assertEqual(self.resources.names[correct], idc)
-            self.assertEqual(self.resources.ids[idc], correct)
-
-    def testTabStop(self):
-        d = self.resources.dialogs["IDD_TEST_DIALOG2"]
-        tabstop_names = ["IDC_EDIT1", "IDOK"]  # should have WS_TABSTOP
-        tabstop_ids = [self.resources.ids[name] for name in tabstop_names]
-        notabstop_names = ["IDC_EDIT2"]  # should have WS_TABSTOP
-        notabstop_ids = [self.resources.ids[name] for name in notabstop_names]
-        num_ok = 0
-        for cdef in d[1:]:  # skip dlgdef
-            # print(cdef)
-            cid = cdef[2]
-            style = cdef[-2]
-            styleex = cdef[-1]
-            if cid in tabstop_ids:
-                self.assertEqual(style & win32con.WS_TABSTOP, win32con.WS_TABSTOP)
-                num_ok += 1
-            elif cid in notabstop_ids:
-                self.assertEqual(style & win32con.WS_TABSTOP, 0)
-                num_ok += 1
-        self.assertEqual(num_ok, len(tabstop_ids) + len(notabstop_ids))
-
-
-class TestGenerated(TestParser):
-    def setUp(self):
-        # don't call base!
-        rc_file = os.path.join(os.path.dirname(__file__), "win32rcparser", "test.rc")
-        py_file = tempfile.mktemp("test_win32rcparser.py")
-        try:
-            win32rcparser.GenerateFrozenResource(rc_file, py_file)
-            py_source = open(py_file).read()
-        finally:
-            if os.path.isfile(py_file):
-                os.unlink(py_file)
-
-        # poor-man's import :)
-        globs = {}
-        exec(py_source, globs, globs)
-        self.resources = globs["FakeParser"]()
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32timezone.py

@@ -1,16 +0,0 @@
-# Test module for win32timezone
-
-import doctest
-import unittest
-
-import win32timezone
-
-
-class Win32TimeZoneTest(unittest.TestCase):
-    def testWin32TZ(self):
-        failed, total = doctest.testmod(win32timezone, verbose=False)
-        self.assertFalse(failed)
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32trace.py

@@ -1,366 +0,0 @@
-import os
-import sys
-import threading
-import time
-import unittest
-
-import win32trace
-from pywin32_testutil import TestSkipped
-
-if __name__ == "__main__":
-    this_file = sys.argv[0]
-else:
-    this_file = __file__
-
-
-def SkipIfCI():
-    # This test often fails in CI, probably when it is being run multiple times
-    # (ie, for different Python versions)
-    # Github actions always have a `CI` variable.
-    if "CI" in os.environ:
-        raise TestSkipped("We skip this test on CI")
-
-
-def CheckNoOtherReaders():
-    win32trace.write("Hi")
-    time.sleep(0.05)
-    if win32trace.read() != "Hi":
-        # Reset everything so following tests still fail with this error!
-        win32trace.TermRead()
-        win32trace.TermWrite()
-        raise AssertionError(
-            "An existing win32trace reader appears to be "
-            "running - please stop this process and try again"
-        )
-
-
-class TestInitOps(unittest.TestCase):
-    def setUp(self):
-        SkipIfCI()
-        # clear old data
-        win32trace.InitRead()
-        win32trace.read()
-        win32trace.TermRead()
-
-    def tearDown(self):
-        try:
-            win32trace.TermRead()
-        except win32trace.error:
-            pass
-        try:
-            win32trace.TermWrite()
-        except win32trace.error:
-            pass
-
-    def testInitTermRead(self):
-        self.assertRaises(win32trace.error, win32trace.read)
-        win32trace.InitRead()
-        result = win32trace.read()
-        self.assertEqual(result, "")
-        win32trace.TermRead()
-        self.assertRaises(win32trace.error, win32trace.read)
-
-        win32trace.InitRead()
-        self.assertRaises(win32trace.error, win32trace.InitRead)
-        win32trace.InitWrite()
-        self.assertRaises(win32trace.error, win32trace.InitWrite)
-        win32trace.TermWrite()
-        win32trace.TermRead()
-
-    def testInitTermWrite(self):
-        self.assertRaises(win32trace.error, win32trace.write, "Hei")
-        win32trace.InitWrite()
-        win32trace.write("Johan Galtung")
-        win32trace.TermWrite()
-        self.assertRaises(win32trace.error, win32trace.write, "Hei")
-
-    def testTermSematics(self):
-        win32trace.InitWrite()
-        win32trace.write("Ta da")
-
-        # if we both Write and Read are terminated at the same time,
-        # we lose the data as the win32 object is closed.  Note that
-        # if another writer is running, we do *not* lose the data - so
-        # test for either the correct data or an empty string
-        win32trace.TermWrite()
-        win32trace.InitRead()
-        self.assertTrue(win32trace.read() in ("Ta da", ""))
-        win32trace.TermRead()
-
-        # we keep the data because we init read before terminating write
-        win32trace.InitWrite()
-        win32trace.write("Ta da")
-        win32trace.InitRead()
-        win32trace.TermWrite()
-        self.assertEqual("Ta da", win32trace.read())
-        win32trace.TermRead()
-
-
-class BasicSetupTearDown(unittest.TestCase):
-    def setUp(self):
-        SkipIfCI()
-        win32trace.InitRead()
-        # If any other writers are running (even if not actively writing),
-        # terminating the module will *not* close the handle, meaning old data
-        # will remain. This can cause other tests to fail.
-        win32trace.read()
-        win32trace.InitWrite()
-
-    def tearDown(self):
-        win32trace.TermWrite()
-        win32trace.TermRead()
-
-
-class TestModuleOps(BasicSetupTearDown):
-    def testRoundTrip(self):
-        win32trace.write("Syver Enstad")
-        syverEnstad = win32trace.read()
-        self.assertEqual("Syver Enstad", syverEnstad)
-
-    def testRoundTripUnicode(self):
-        win32trace.write("\xa9opyright Syver Enstad")
-        syverEnstad = win32trace.read()
-        self.assertEqual("\xa9opyright Syver Enstad", syverEnstad)
-
-    def testBlockingRead(self):
-        win32trace.write("Syver Enstad")
-        self.assertEqual("Syver Enstad", win32trace.blockingread())
-
-    def testBlockingReadUnicode(self):
-        win32trace.write("\xa9opyright Syver Enstad")
-        self.assertEqual("\xa9opyright Syver Enstad", win32trace.blockingread())
-
-    def testFlush(self):
-        win32trace.flush()
-
-
-class TestTraceObjectOps(BasicSetupTearDown):
-    def testInit(self):
-        win32trace.TermRead()
-        win32trace.TermWrite()
-        traceObject = win32trace.GetTracer()
-        self.assertRaises(win32trace.error, traceObject.read)
-        self.assertRaises(win32trace.error, traceObject.write, "")
-        win32trace.InitRead()
-        win32trace.InitWrite()
-        self.assertEqual("", traceObject.read())
-        traceObject.write("Syver")
-
-    def testFlush(self):
-        traceObject = win32trace.GetTracer()
-        traceObject.flush()
-
-    def testIsatty(self):
-        tracer = win32trace.GetTracer()
-        self.assertFalse(tracer.isatty())
-
-    def testRoundTrip(self):
-        traceObject = win32trace.GetTracer()
-        traceObject.write("Syver Enstad")
-        self.assertEqual("Syver Enstad", traceObject.read())
-
-
-class WriterThread(threading.Thread):
-    def run(self):
-        self.writeCount = 0
-        for each in range(self.BucketCount):
-            win32trace.write(str(each))
-        self.writeCount = self.BucketCount
-
-    def verifyWritten(self):
-        return self.writeCount == self.BucketCount
-
-
-class TestMultipleThreadsWriting(unittest.TestCase):
-    # FullBucket is the thread count
-    FullBucket = 50
-    BucketCount = 9  # buckets must be a single digit number (ie. less than 10)
-
-    def setUp(self):
-        SkipIfCI()
-        WriterThread.BucketCount = self.BucketCount
-        win32trace.InitRead()
-        win32trace.read()  # clear any old data.
-        win32trace.InitWrite()
-        CheckNoOtherReaders()
-        self.threads = [WriterThread() for each in range(self.FullBucket)]
-        self.buckets = list(range(self.BucketCount))
-        for each in self.buckets:
-            self.buckets[each] = 0
-
-    def tearDown(self):
-        win32trace.TermRead()
-        win32trace.TermWrite()
-
-    def areBucketsFull(self):
-        bucketsAreFull = True
-        for each in self.buckets:
-            self.assertLessEqual(each, self.FullBucket)
-            if each != self.FullBucket:
-                bucketsAreFull = False
-                break
-        return bucketsAreFull
-
-    def read(self):
-        while 1:
-            readString = win32trace.blockingread()
-            for ch in readString:
-                integer = int(ch)
-                count = self.buckets[integer]
-                self.assertNotEqual(count, -1)
-                self.buckets[integer] = count + 1
-                if self.buckets[integer] == self.FullBucket:
-                    if self.areBucketsFull():
-                        return
-
-    def testThreads(self):
-        for each in self.threads:
-            each.start()
-        self.read()
-        for each in self.threads:
-            each.join()
-        for each in self.threads:
-            self.assertTrue(each.verifyWritten())
-        self.assertTrue(self.areBucketsFull())
-
-
-class TestHugeChunks(unittest.TestCase):
-    # BiggestChunk is the size where we stop stressing the writer
-    BiggestChunk = 2**16  # 256k should do it.
-
-    def setUp(self):
-        SkipIfCI()
-        win32trace.InitRead()
-        win32trace.read()  # clear any old data
-        win32trace.InitWrite()
-
-    def testHugeChunks(self):
-        data = "*" * 1023 + "\n"
-        while len(data) <= self.BiggestChunk:
-            win32trace.write(data)
-            data += data
-        # If we made it here, we passed.
-
-    def tearDown(self):
-        win32trace.TermRead()
-        win32trace.TermWrite()
-
-
-import win32event
-import win32process
-
-
-class TraceWriteProcess:
-    def __init__(self, threadCount):
-        self.exitCode = -1
-        self.threadCount = threadCount
-
-    def start(self):
-        procHandle, threadHandle, procId, threadId = win32process.CreateProcess(
-            None,  # appName
-            'python.exe "{}" /run_test_process {} {}'.format(
-                this_file, self.BucketCount, self.threadCount
-            ),
-            None,  # process security
-            None,  # thread security
-            0,  # inherit handles
-            win32process.NORMAL_PRIORITY_CLASS,
-            None,  # new environment
-            None,  # Current directory
-            win32process.STARTUPINFO(),  # startup info
-        )
-        self.processHandle = procHandle
-
-    def join(self):
-        win32event.WaitForSingleObject(self.processHandle, win32event.INFINITE)
-        self.exitCode = win32process.GetExitCodeProcess(self.processHandle)
-
-    def verifyWritten(self):
-        return self.exitCode == 0
-
-
-class TestOutofProcess(unittest.TestCase):
-    BucketCount = 9
-    FullBucket = 50
-
-    def setUp(self):
-        SkipIfCI()
-        win32trace.InitRead()
-        TraceWriteProcess.BucketCount = self.BucketCount
-        self.setUpWriters()
-        self.buckets = list(range(self.BucketCount))
-        for each in self.buckets:
-            self.buckets[each] = 0
-
-    def tearDown(self):
-        win32trace.TermRead()
-
-    def setUpWriters(self):
-        self.processes = []
-        # 5 processes, quot threads in each process
-        quot, remainder = divmod(self.FullBucket, 5)
-        for each in range(5):
-            self.processes.append(TraceWriteProcess(quot))
-        if remainder:
-            self.processes.append(TraceWriteProcess(remainder))
-
-    def areBucketsFull(self):
-        bucketsAreFull = True
-        for each in self.buckets:
-            self.assertLessEqual(each, self.FullBucket)
-            if each != self.FullBucket:
-                bucketsAreFull = False
-                break
-        return bucketsAreFull
-
-    def read(self):
-        while 1:
-            readString = win32trace.blockingread()
-            for ch in readString:
-                integer = int(ch)
-                count = self.buckets[integer]
-                self.assertNotEqual(count, -1)
-                self.buckets[integer] = count + 1
-                if self.buckets[integer] == self.FullBucket:
-                    if self.areBucketsFull():
-                        return
-
-    def testProcesses(self):
-        for each in self.processes:
-            each.start()
-        self.read()
-        for each in self.processes:
-            each.join()
-        for each in self.processes:
-            self.assertTrue(each.verifyWritten())
-        self.assertTrue(self.areBucketsFull())
-
-
-def _RunAsTestProcess():
-    # Run as an external process by the main tests.
-    WriterThread.BucketCount = int(sys.argv[2])
-    threadCount = int(sys.argv[3])
-    threads = [WriterThread() for each in range(threadCount)]
-    win32trace.InitWrite()
-    for t in threads:
-        t.start()
-    for t in threads:
-        t.join()
-    for t in threads:
-        if not t.verifyWritten():
-            sys.exit(-1)
-
-
-if __name__ == "__main__":
-    if sys.argv[1:2] == ["/run_test_process"]:
-        _RunAsTestProcess()
-        sys.exit(0)
-    # If some other win32traceutil reader is running, these tests fail
-    # badly (as the other reader sometimes sees the output!)
-    win32trace.InitRead()
-    win32trace.InitWrite()
-    CheckNoOtherReaders()
-    # reset state so test env is back to normal
-    win32trace.TermRead()
-    win32trace.TermWrite()
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32ts.py

@@ -1,19 +0,0 @@
-# Tests for win32ts module
-
-import unittest
-
-import win32ts
-
-
-class Win32TsTestCase(unittest.TestCase):
-    def test_is_remote_session(self):
-        ret = win32ts.WTSQuerySessionInformation(
-            win32ts.WTS_CURRENT_SERVER_HANDLE,
-            win32ts.WTS_CURRENT_SESSION,
-            win32ts.WTSIsRemoteSession,
-        )
-        self.assertIsInstance(ret, bool)
-
-
-if __name__ == "__main__":
-    unittest.main()