py2docfx 0.1.15rc2025477__py3-none-any.whl → 0.1.16.dev2052678__py3-none-any.whl

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

@@ -1,264 +0,0 @@
-# odbc test suite kindly contributed by Frank Millman.
-import os
-import sys
-import tempfile
-import unittest
-
-import odbc
-import pythoncom
-from pywin32_testutil import TestSkipped
-from win32com.client import constants
-
-# We use the DAO ODBC driver
-from win32com.client.gencache import EnsureDispatch
-
-
-class TestStuff(unittest.TestCase):
-    def setUp(self):
-        self.tablename = "pywin32test_users"
-        self.db_filename = None
-        self.conn = self.cur = None
-        try:
-            # Test any database if a connection string is supplied...
-            conn_str = os.environ["TEST_ODBC_CONNECTION_STRING"]
-        except KeyError:
-            # Create a local MSAccess DB for testing.
-            self.db_filename = tempfile.NamedTemporaryFile().name + ".mdb"
-
-            # Create a brand-new database - what is the story with these?
-            for suffix in (".36", ".35", ".30"):
-                try:
-                    dbe = EnsureDispatch("DAO.DBEngine" + suffix)
-                    break
-                except pythoncom.com_error:
-                    pass
-            else:
-                raise TestSkipped("Can't find a DB engine")
-
-            workspace = dbe.Workspaces(0)
-
-            newdb = workspace.CreateDatabase(
-                self.db_filename, constants.dbLangGeneral, constants.dbEncrypt
-            )
-
-            newdb.Close()
-
-            conn_str = (
-                "Driver={{Microsoft Access Driver (*.mdb)}};dbq={};Uid=;Pwd=;".format(
-                    self.db_filename,
-                )
-            )
-        # print("Connection string:", conn_str)
-        self.conn = odbc.odbc(conn_str)
-        # And we expect a 'users' table for these tests.
-        self.cur = self.conn.cursor()
-        ## self.cur.setoutputsize(1000)
-        try:
-            self.cur.execute("""drop table %s""" % self.tablename)
-        except (odbc.error, odbc.progError):
-            pass
-
-        ## This needs to be adjusted for sql server syntax for unicode fields
-        ##  - memo -> TEXT
-        ##  - varchar -> nvarchar
-        self.assertEqual(
-            self.cur.execute(
-                """create table %s (
-                    userid varchar(25),
-                    username varchar(25),
-                    bitfield bit,
-                    intfield integer,
-                    floatfield float,
-                    datefield datetime,
-                    rawfield varbinary(100),
-                    longtextfield memo,
-                    longbinaryfield image
-            )"""
-                % self.tablename
-            ),
-            -1,
-        )
-
-    def tearDown(self):
-        if self.cur is not None:
-            try:
-                self.cur.execute("""drop table %s""" % self.tablename)
-            except (odbc.error, odbc.progError) as why:
-                print("Failed to delete test table %s" % self.tablename, why)
-
-            self.cur.close()
-            self.cur = None
-        if self.conn is not None:
-            self.conn.close()
-            self.conn = None
-        if self.db_filename is not None:
-            try:
-                os.unlink(self.db_filename)
-            except OSError:
-                pass
-
-    def test_insert_select(self, userid="Frank", username="Frank Millman"):
-        self.assertEqual(
-            self.cur.execute(
-                "insert into %s (userid, username) \
-            values (?,?)"
-                % self.tablename,
-                [userid, username],
-            ),
-            1,
-        )
-        self.assertEqual(
-            self.cur.execute(
-                "select * from %s \
-            where userid = ?"
-                % self.tablename,
-                [userid.lower()],
-            ),
-            0,
-        )
-        self.assertEqual(
-            self.cur.execute(
-                "select * from %s \
-            where username = ?"
-                % self.tablename,
-                [username.lower()],
-            ),
-            0,
-        )
-
-    def test_insert_select_unicode(self, userid="Frank", username="Frank Millman"):
-        self.assertEqual(
-            self.cur.execute(
-                "insert into %s (userid, username)\
-            values (?,?)"
-                % self.tablename,
-                [userid, username],
-            ),
-            1,
-        )
-        self.assertEqual(
-            self.cur.execute(
-                "select * from %s \
-            where userid = ?"
-                % self.tablename,
-                [userid.lower()],
-            ),
-            0,
-        )
-        self.assertEqual(
-            self.cur.execute(
-                "select * from %s \
-            where username = ?"
-                % self.tablename,
-                [username.lower()],
-            ),
-            0,
-        )
-
-    def test_insert_select_unicode_ext(self):
-        userid = "t-\xe0\xf2"
-        username = "test-\xe0\xf2 name"
-        self.test_insert_select_unicode(userid, username)
-
-    def _test_val(self, fieldName, value):
-        for x in range(100):
-            self.cur.execute("delete from %s where userid='Frank'" % self.tablename)
-            self.assertEqual(
-                self.cur.execute(
-                    f"insert into {self.tablename} (userid, {fieldName}) values (?,?)",
-                    ["Frank", value],
-                ),
-                1,
-            )
-            self.cur.execute(
-                f"select {fieldName} from {self.tablename} where userid = ?",
-                ["Frank"],
-            )
-            rows = self.cur.fetchmany()
-            self.assertEqual(1, len(rows))
-            row = rows[0]
-            self.assertEqual(row[0], value)
-
-    def testBit(self):
-        self._test_val("bitfield", 1)
-        self._test_val("bitfield", 0)
-
-    def testInt(self):
-        self._test_val("intfield", 1)
-        self._test_val("intfield", 0)
-        self._test_val("intfield", sys.maxsize)
-
-    def testFloat(self):
-        self._test_val("floatfield", 1.01)
-        self._test_val("floatfield", 0)
-
-    def testVarchar(
-        self,
-    ):
-        self._test_val("username", "foo")
-
-    def testLongVarchar(self):
-        """Test a long text field in excess of internal cursor data size (65536)"""
-        self._test_val("longtextfield", "abc" * 70000)
-
-    def testLongBinary(self):
-        """Test a long raw field in excess of internal cursor data size (65536)"""
-        self._test_val("longbinaryfield", memoryview(b"\0\1\2" * 70000))
-
-    def testRaw(self):
-        ## Test binary data
-        self._test_val("rawfield", memoryview(b"\1\2\3\4\0\5\6\7"))
-
-    def test_widechar(self):
-        """Test a unicode character that would be mangled if bound as plain character.
-        For example, previously the below was returned as ascii 'a'
-        """
-        self._test_val("username", "\u0101")
-
-    def testDates(self):
-        import datetime
-
-        for v in ((1900, 12, 25, 23, 39, 59),):
-            d = datetime.datetime(*v)
-            self._test_val("datefield", d)
-
-    def test_set_nonzero_length(self):
-        self.assertEqual(
-            self.cur.execute(
-                "insert into %s (userid,username) values (?,?)" % self.tablename,
-                ["Frank", "Frank Millman"],
-            ),
-            1,
-        )
-        self.assertEqual(
-            self.cur.execute("update %s set username = ?" % self.tablename, ["Frank"]),
-            1,
-        )
-        self.assertEqual(self.cur.execute("select * from %s" % self.tablename), 0)
-        self.assertEqual(len(self.cur.fetchone()[1]), 5)
-
-    def test_set_zero_length(self):
-        self.assertEqual(
-            self.cur.execute(
-                "insert into %s (userid,username) values (?,?)" % self.tablename,
-                [b"Frank", ""],
-            ),
-            1,
-        )
-        self.assertEqual(self.cur.execute("select * from %s" % self.tablename), 0)
-        self.assertEqual(len(self.cur.fetchone()[1]), 0)
-
-    def test_set_zero_length_unicode(self):
-        self.assertEqual(
-            self.cur.execute(
-                "insert into %s (userid,username) values (?,?)" % self.tablename,
-                ["Frank", ""],
-            ),
-            1,
-        )
-        self.assertEqual(self.cur.execute("select * from %s" % self.tablename), 0)
-        self.assertEqual(len(self.cur.fetchone()[1]), 0)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,111 +0,0 @@
-import datetime
-import operator
-import time
-import unittest
-
-import pywintypes
-
-
-class TestCase(unittest.TestCase):
-    def testPyTimeFormat(self):
-        struct_current = time.localtime()
-        pytime_current = pywintypes.Time(struct_current)
-        # try and test all the standard parts of the format
-        # Note we used to include '%Z' testing, but that was pretty useless as
-        # it always returned the local timezone.
-        format_strings = "%a %A %b %B %c %d %H %I %j %m %M %p %S %U %w %W %x %X %y %Y"
-        for fmt in format_strings.split():
-            v1 = pytime_current.Format(fmt)
-            v2 = time.strftime(fmt, struct_current)
-            self.assertEqual(v1, v2, f"format {fmt} failed - {v1!r} != {v2!r}")
-
-    def testPyTimePrint(self):
-        # This used to crash with an invalid, or too early time.
-        # We don't really want to check that it does cause a ValueError
-        # (as hopefully this won't be true forever).  So either working, or
-        # ValueError is OK.
-        try:
-            t = pywintypes.Time(-2)
-            t.Format()
-        except ValueError:
-            return
-
-    def testTimeInDict(self):
-        d = {}
-        d["t1"] = pywintypes.Time(1)
-        self.assertEqual(d["t1"], pywintypes.Time(1))
-
-    def testPyTimeCompare(self):
-        t1 = pywintypes.Time(100)
-        t1_2 = pywintypes.Time(100)
-        t2 = pywintypes.Time(101)
-
-        self.assertEqual(t1, t1_2)
-        self.assertTrue(t1 <= t1_2)
-        self.assertTrue(t1_2 >= t1)
-
-        self.assertNotEqual(t1, t2)
-        self.assertTrue(t1 < t2)
-        self.assertTrue(t2 > t1)
-
-    def testPyTimeCompareOther(self):
-        t1 = pywintypes.Time(100)
-        t2 = None
-        self.assertNotEqual(t1, t2)
-
-    def testTimeTuple(self):
-        now = datetime.datetime.now()  # has usec...
-        # timetuple() lost usec - pt must be <=...
-        pt = pywintypes.Time(now.timetuple())
-        # *sob* - only if we have a datetime object can we compare like this.
-        if isinstance(pt, datetime.datetime):
-            self.assertTrue(pt <= now)
-
-    def testTimeTuplems(self):
-        now = datetime.datetime.now()  # has usec...
-        tt = now.timetuple() + (now.microsecond // 1000,)
-        pt = pywintypes.Time(tt)
-        # we can't compare if using the old type, as it loses all sub-second res.
-        if isinstance(pt, datetime.datetime):
-            # but even with datetime, we lose sub-millisecond.
-            expectedDelta = datetime.timedelta(milliseconds=1)
-            self.assertTrue(-expectedDelta < (now - pt) < expectedDelta)
-
-    def testPyTimeFromTime(self):
-        t1 = pywintypes.Time(time.time())
-        self.assertTrue(pywintypes.Time(t1) is t1)
-
-    def testPyTimeTooLarge(self):
-        MAX_TIMESTAMP = 0x7FFFFFFFFFFFFFFF  # used by some API function to mean "never"
-        ts = pywintypes.TimeStamp(MAX_TIMESTAMP)
-        self.assertEqual(ts, datetime.datetime.max)
-
-    def testGUID(self):
-        s = "{00020400-0000-0000-C000-000000000046}"
-        iid = pywintypes.IID(s)
-        iid2 = pywintypes.IID(memoryview(iid), True)
-        self.assertEqual(iid, iid2)
-        self.assertRaises(ValueError, pywintypes.IID, b"00", True)  # too short
-        self.assertRaises(TypeError, pywintypes.IID, 0, True)  # no buffer
-
-    def testGUIDRichCmp(self):
-        s = "{00020400-0000-0000-C000-000000000046}"
-        iid = pywintypes.IID(s)
-        self.assertFalse(s is None)
-        self.assertFalse(None == s)
-        self.assertTrue(s is not None)
-        self.assertTrue(None != s)
-        self.assertRaises(TypeError, operator.gt, None, s)
-        self.assertRaises(TypeError, operator.gt, s, None)
-        self.assertRaises(TypeError, operator.lt, None, s)
-        self.assertRaises(TypeError, operator.lt, s, None)
-
-    def testGUIDInDict(self):
-        s = "{00020400-0000-0000-C000-000000000046}"
-        iid = pywintypes.IID(s)
-        d = {"item": iid}
-        self.assertEqual(d["item"], iid)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,166 +0,0 @@
-# Tests for the win32security module.
-import unittest
-
-import ntsecuritycon
-import pywintypes
-import win32api
-import win32con
-import win32security
-import winerror
-from pywin32_testutil import TestSkipped, testmain
-
-
-class SecurityTests(unittest.TestCase):
-    def setUp(self):
-        self.pwr_sid = win32security.LookupAccountName("", "Power Users")[0]
-        try:
-            self.admin_sid = win32security.LookupAccountName("", "Administrator")[0]
-        except pywintypes.error as exc:
-            # in automation we see:
-            # pywintypes.error: (1332, 'LookupAccountName', 'No mapping between account names and security IDs was done.')
-            if exc.winerror != winerror.ERROR_NONE_MAPPED:
-                raise
-            self.admin_sid = None
-
-    def tearDown(self):
-        pass
-
-    def testEqual(self):
-        if self.admin_sid is None:
-            raise TestSkipped("No 'Administrator' account is available")
-        self.assertEqual(
-            win32security.LookupAccountName("", "Administrator")[0],
-            win32security.LookupAccountName("", "Administrator")[0],
-        )
-
-    def testNESID(self):
-        self.assertTrue(self.pwr_sid == self.pwr_sid)
-        if self.admin_sid:
-            self.assertTrue(self.pwr_sid != self.admin_sid)
-
-    def testNEOther(self):
-        self.assertTrue(self.pwr_sid is not None)
-        self.assertTrue(None != self.pwr_sid)
-        self.assertFalse(self.pwr_sid is None)
-        self.assertFalse(None == self.pwr_sid)
-        self.assertNotEqual(None, self.pwr_sid)
-
-    def testSIDInDict(self):
-        d = {"foo": self.pwr_sid}
-        self.assertEqual(d["foo"], self.pwr_sid)
-
-    def testBuffer(self):
-        if self.admin_sid is None:
-            raise TestSkipped("No 'Administrator' account is available")
-        self.assertEqual(
-            memoryview(win32security.LookupAccountName("", "Administrator")[0]),
-            memoryview(win32security.LookupAccountName("", "Administrator")[0]),
-        )
-
-    def testMemory(self):
-        pwr_sid = self.pwr_sid
-        admin_sid = self.admin_sid
-        sd1 = win32security.SECURITY_DESCRIPTOR()
-        sd2 = win32security.SECURITY_DESCRIPTOR()
-        sd3 = win32security.SECURITY_DESCRIPTOR()
-        dacl = win32security.ACL()
-        dacl.AddAccessAllowedAce(
-            win32security.ACL_REVISION, win32con.GENERIC_READ, pwr_sid
-        )
-        if admin_sid is not None:
-            dacl.AddAccessAllowedAce(
-                win32security.ACL_REVISION, win32con.GENERIC_ALL, admin_sid
-            )
-        sd4 = win32security.SECURITY_DESCRIPTOR()
-        sacl = win32security.ACL()
-        if admin_sid is not None:
-            sacl.AddAuditAccessAce(
-                win32security.ACL_REVISION, win32con.DELETE, admin_sid, 1, 1
-            )
-        sacl.AddAuditAccessAce(
-            win32security.ACL_REVISION, win32con.GENERIC_ALL, pwr_sid, 1, 1
-        )
-        for x in range(0, 200000):
-            if admin_sid is not None:
-                sd1.SetSecurityDescriptorOwner(admin_sid, 0)
-            sd2.SetSecurityDescriptorGroup(pwr_sid, 0)
-            sd3.SetSecurityDescriptorDacl(1, dacl, 0)
-            sd4.SetSecurityDescriptorSacl(1, sacl, 0)
-
-
-class DomainTests(unittest.TestCase):
-    def setUp(self):
-        self.ds_handle = None
-        try:
-            # saving the handle means the other test itself should bind faster.
-            self.ds_handle = win32security.DsBind()
-        except win32security.error as exc:
-            if exc.winerror != winerror.ERROR_NO_SUCH_DOMAIN:
-                raise
-            raise TestSkipped(exc)
-
-    def tearDown(self):
-        if self.ds_handle is not None:
-            self.ds_handle.close()
-
-
-class TestDS(DomainTests):
-    def testDsGetDcName(self):
-        # Not sure what we can actually test here!  At least calling it
-        # does something :)
-        win32security.DsGetDcName()
-
-    def testDsListServerInfo(self):
-        # again, not checking much, just exercising the code.
-        h = win32security.DsBind()
-        for status, ignore, site in win32security.DsListSites(h):
-            for status, ignore, server in win32security.DsListServersInSite(h, site):
-                info = win32security.DsListInfoForServer(h, server)
-            for status, ignore, domain in win32security.DsListDomainsInSite(h, site):
-                pass
-
-    def testDsCrackNames(self):
-        h = win32security.DsBind()
-        fmt_offered = ntsecuritycon.DS_FQDN_1779_NAME
-        name = win32api.GetUserNameEx(fmt_offered)
-        result = win32security.DsCrackNames(h, 0, fmt_offered, fmt_offered, (name,))
-        self.assertEqual(name, result[0][2])
-
-    def testDsCrackNamesSyntax(self):
-        # Do a syntax check only - that allows us to avoid binding.
-        # But must use DS_CANONICAL_NAME (or _EX)
-        expected = win32api.GetUserNameEx(win32api.NameCanonical)
-        fmt_offered = ntsecuritycon.DS_FQDN_1779_NAME
-        name = win32api.GetUserNameEx(fmt_offered)
-        result = win32security.DsCrackNames(
-            None,
-            ntsecuritycon.DS_NAME_FLAG_SYNTACTICAL_ONLY,
-            fmt_offered,
-            ntsecuritycon.DS_CANONICAL_NAME,
-            (name,),
-        )
-        self.assertEqual(expected, result[0][2])
-
-
-class TestTranslate(DomainTests):
-    def _testTranslate(self, fmt_from, fmt_to):
-        name = win32api.GetUserNameEx(fmt_from)
-        expected = win32api.GetUserNameEx(fmt_to)
-        got = win32security.TranslateName(name, fmt_from, fmt_to)
-        self.assertEqual(got, expected)
-
-    def testTranslate1(self):
-        self._testTranslate(win32api.NameFullyQualifiedDN, win32api.NameSamCompatible)
-
-    def testTranslate2(self):
-        self._testTranslate(win32api.NameSamCompatible, win32api.NameFullyQualifiedDN)
-
-    def testTranslate3(self):
-        self._testTranslate(win32api.NameFullyQualifiedDN, win32api.NameUniqueId)
-
-    def testTranslate4(self):
-        self._testTranslate(win32api.NameUniqueId, win32api.NameFullyQualifiedDN)
-
-
-if __name__ == "__main__":
-    testmain()