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

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

@@ -1,229 +0,0 @@
-# Some tests of the win32security sspi functions.
-# Stolen from Roger's original test_sspi.c, a version of which is in "Demos"
-# See also the other SSPI demos.
-import unittest
-
-import sspi
-import sspicon
-import win32api
-import win32security
-from pywin32_testutil import TestSkipped, testmain
-
-
-# It is quite likely that the Kerberos tests will fail due to not being
-# installed.  The NTLM tests do *not* get the same behaviour as they should
-# always be there.
-def applyHandlingSkips(func, *args):
-    try:
-        return func(*args)
-    except win32api.error as exc:
-        if exc.winerror in [
-            sspicon.SEC_E_NO_CREDENTIALS,
-            sspicon.SEC_E_NO_AUTHENTICATING_AUTHORITY,
-        ]:
-            raise TestSkipped(exc)
-        raise
-
-
-class TestSSPI(unittest.TestCase):
-    def assertRaisesHRESULT(self, hr, func, *args):
-        try:
-            func(*args)
-            raise AssertionError(f"expecting {hr} failure")
-        except win32security.error as exc:
-            self.assertEqual(exc.winerror, hr)
-
-    def _doAuth(self, pkg_name):
-        sspiclient = sspi.ClientAuth(pkg_name, targetspn=win32api.GetUserName())
-        sspiserver = sspi.ServerAuth(pkg_name)
-
-        sec_buffer = None
-        err = 1
-        while err != 0:
-            err, sec_buffer = sspiclient.authorize(sec_buffer)
-            err, sec_buffer = sspiserver.authorize(sec_buffer)
-        return sspiclient, sspiserver
-
-    def _doTestImpersonate(self, pkg_name):
-        # Just for the sake of code exercising!
-        sspiclient, sspiserver = self._doAuth(pkg_name)
-        sspiserver.ctxt.ImpersonateSecurityContext()
-        sspiserver.ctxt.RevertSecurityContext()
-
-    def testImpersonateKerberos(self):
-        applyHandlingSkips(self._doTestImpersonate, "Kerberos")
-
-    def testImpersonateNTLM(self):
-        self._doTestImpersonate("NTLM")
-
-    def _doTestEncrypt(self, pkg_name):
-        sspiclient, sspiserver = self._doAuth(pkg_name)
-
-        pkg_size_info = sspiclient.ctxt.QueryContextAttributes(
-            sspicon.SECPKG_ATTR_SIZES
-        )
-        msg = b"some data to be encrypted ......"
-
-        trailersize = pkg_size_info["SecurityTrailer"]
-        encbuf = win32security.PySecBufferDescType()
-        encbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA))
-        encbuf.append(
-            win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN)
-        )
-        encbuf[0].Buffer = msg
-        sspiclient.ctxt.EncryptMessage(0, encbuf, 1)
-        sspiserver.ctxt.DecryptMessage(encbuf, 1)
-        self.assertEqual(msg, encbuf[0].Buffer)
-        # and test the higher-level functions
-        data_in = b"hello"
-        data, sig = sspiclient.encrypt(data_in)
-        self.assertEqual(sspiserver.decrypt(data, sig), data_in)
-
-        data, sig = sspiserver.encrypt(data_in)
-        self.assertEqual(sspiclient.decrypt(data, sig), data_in)
-
-    def _doTestEncryptStream(self, pkg_name):
-        # Test out the SSPI/GSSAPI interop wrapping examples at
-        # https://learn.microsoft.com/en-us/windows/win32/secauthn/sspi-kerberos-interoperability-with-gssapi
-
-        sspiclient, sspiserver = self._doAuth(pkg_name)
-
-        pkg_size_info = sspiclient.ctxt.QueryContextAttributes(
-            sspicon.SECPKG_ATTR_SIZES
-        )
-        msg = b"some data to be encrypted ......"
-
-        trailersize = pkg_size_info["SecurityTrailer"]
-        blocksize = pkg_size_info["BlockSize"]
-        encbuf = win32security.PySecBufferDescType()
-        encbuf.append(
-            win32security.PySecBufferType(trailersize, sspicon.SECBUFFER_TOKEN)
-        )
-        encbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA))
-        encbuf.append(
-            win32security.PySecBufferType(blocksize, sspicon.SECBUFFER_PADDING)
-        )
-        encbuf[1].Buffer = msg
-        sspiclient.ctxt.EncryptMessage(0, encbuf, 1)
-
-        encmsg = encbuf[0].Buffer + encbuf[1].Buffer + encbuf[2].Buffer
-        decbuf = win32security.PySecBufferDescType()
-        decbuf.append(
-            win32security.PySecBufferType(len(encmsg), sspicon.SECBUFFER_STREAM)
-        )
-        decbuf.append(win32security.PySecBufferType(0, sspicon.SECBUFFER_DATA))
-        decbuf[0].Buffer = encmsg
-
-        sspiserver.ctxt.DecryptMessage(decbuf, 1)
-        self.assertEqual(msg, decbuf[1].Buffer)
-
-    def testEncryptNTLM(self):
-        self._doTestEncrypt("NTLM")
-
-    def testEncryptStreamNTLM(self):
-        self._doTestEncryptStream("NTLM")
-
-    def testEncryptKerberos(self):
-        applyHandlingSkips(self._doTestEncrypt, "Kerberos")
-
-    def testEncryptStreamKerberos(self):
-        applyHandlingSkips(self._doTestEncryptStream, "Kerberos")
-
-    def _doTestSign(self, pkg_name):
-        sspiclient, sspiserver = self._doAuth(pkg_name)
-
-        pkg_size_info = sspiclient.ctxt.QueryContextAttributes(
-            sspicon.SECPKG_ATTR_SIZES
-        )
-        msg = b"some data to be encrypted ......"
-
-        sigsize = pkg_size_info["MaxSignature"]
-        sigbuf = win32security.PySecBufferDescType()
-        sigbuf.append(win32security.PySecBufferType(len(msg), sspicon.SECBUFFER_DATA))
-        sigbuf.append(win32security.PySecBufferType(sigsize, sspicon.SECBUFFER_TOKEN))
-        sigbuf[0].Buffer = msg
-        sspiclient.ctxt.MakeSignature(0, sigbuf, 0)
-        sspiserver.ctxt.VerifySignature(sigbuf, 0)
-        # and test the higher-level functions
-        sspiclient.next_seq_num = 1
-        sspiserver.next_seq_num = 1
-        data = b"hello"
-        key = sspiclient.sign(data)
-        sspiserver.verify(data, key)
-        key = sspiclient.sign(data)
-        self.assertRaisesHRESULT(
-            sspicon.SEC_E_MESSAGE_ALTERED, sspiserver.verify, data + data, key
-        )
-
-        # and the other way
-        key = sspiserver.sign(data)
-        sspiclient.verify(data, key)
-        key = sspiserver.sign(data)
-        self.assertRaisesHRESULT(
-            sspicon.SEC_E_MESSAGE_ALTERED, sspiclient.verify, data + data, key
-        )
-
-    def testSignNTLM(self):
-        self._doTestSign("NTLM")
-
-    def testSignKerberos(self):
-        applyHandlingSkips(self._doTestSign, "Kerberos")
-
-    def _testSequenceSign(self):
-        # Only Kerberos supports sequence detection.
-        sspiclient, sspiserver = self._doAuth("Kerberos")
-        key = sspiclient.sign(b"hello")
-        sspiclient.sign(b"hello")
-        self.assertRaisesHRESULT(
-            sspicon.SEC_E_OUT_OF_SEQUENCE, sspiserver.verify, b"hello", key
-        )
-
-    def testSequenceSign(self):
-        applyHandlingSkips(self._testSequenceSign)
-
-    def _testSequenceEncrypt(self):
-        # Only Kerberos supports sequence detection.
-        sspiclient, sspiserver = self._doAuth("Kerberos")
-        blob, key = sspiclient.encrypt(b"hello")
-        blob, key = sspiclient.encrypt(b"hello")
-        self.assertRaisesHRESULT(
-            sspicon.SEC_E_OUT_OF_SEQUENCE, sspiserver.decrypt, blob, key
-        )
-
-    def testSequenceEncrypt(self):
-        applyHandlingSkips(self._testSequenceEncrypt)
-
-    def testSecBufferRepr(self):
-        desc = win32security.PySecBufferDescType()
-        self.assertRegex(
-            repr(desc),
-            r"PySecBufferDesc\(ulVersion: 0 \| cBuffers: 0 \| pBuffers: 0x[\da-fA-F]{8,16}\)",
-        )
-
-        buffer1 = win32security.PySecBufferType(0, sspicon.SECBUFFER_TOKEN)
-        self.assertRegex(
-            repr(buffer1),
-            r"PySecBuffer\(cbBuffer: 0 \| BufferType: 2 \| pvBuffer: 0x[\da-fA-F]{8,16}\)",
-        )
-        desc.append(buffer1)
-
-        self.assertRegex(
-            repr(desc),
-            r"PySecBufferDesc\(ulVersion: 0 \| cBuffers: 1 \| pBuffers: 0x[\da-fA-F]{8,16}\)",
-        )
-
-        buffer2 = win32security.PySecBufferType(4, sspicon.SECBUFFER_DATA)
-        self.assertRegex(
-            repr(buffer2),
-            r"PySecBuffer\(cbBuffer: 4 \| BufferType: 1 \| pvBuffer: 0x[\da-fA-F]{8,16}\)",
-        )
-        desc.append(buffer2)
-
-        self.assertRegex(
-            repr(desc),
-            r"PySecBufferDesc\(ulVersion: 0 \| cBuffers: 2 \| pBuffers: 0x[\da-fA-F]{8,16}\)",
-        )
-
-
-if __name__ == "__main__":
-    testmain()

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

@@ -1,273 +0,0 @@
-# General test module for win32api - please add some :)
-
-import datetime
-import os
-import sys
-import tempfile
-import time
-import unittest
-
-import win32api
-import win32con
-import win32event
-import winerror
-from pywin32_testutil import TestSkipped
-
-
-class TestError(Exception):
-    pass
-
-
-class CurrentUserTestCase(unittest.TestCase):
-    def testGetCurrentUser(self):
-        domain = win32api.GetDomainName()
-        if domain == "NT AUTHORITY":
-            # Running as a service account, so the comparison will fail
-            raise TestSkipped("running as service account")
-        name = f"{domain}\\{win32api.GetUserName()}"
-        self.assertEqual(name, win32api.GetUserNameEx(win32api.NameSamCompatible))
-
-
-class TestTime(unittest.TestCase):
-    def testTimezone(self):
-        # GetTimeZoneInformation
-        rc, tzinfo = win32api.GetTimeZoneInformation()
-        if rc == win32con.TIME_ZONE_ID_DAYLIGHT:
-            tz_str = tzinfo[4]
-            tz_time = tzinfo[5]
-        else:
-            tz_str = tzinfo[1]
-            tz_time = tzinfo[2]
-        # for the sake of code exercise but don't output
-        tz_str.encode()
-        if not isinstance(tz_time, datetime.datetime) and not isinstance(
-            tz_time, tuple
-        ):
-            tz_time.Format()
-
-    def TestDateFormat(self):
-        DATE_LONGDATE = 2
-        date_flags = DATE_LONGDATE
-        win32api.GetDateFormat(0, date_flags, None)
-        win32api.GetDateFormat(0, date_flags, 0)
-        win32api.GetDateFormat(0, date_flags, datetime.datetime.now())
-        win32api.GetDateFormat(0, date_flags, time.time())
-
-    def TestTimeFormat(self):
-        win32api.GetTimeFormat(0, 0, None)
-        win32api.GetTimeFormat(0, 0, 0)
-        win32api.GetTimeFormat(0, 0, datetime.datetime.now())
-        win32api.GetTimeFormat(0, 0, time.time())
-
-
-class Registry(unittest.TestCase):
-    key_name = r"PythonTestHarness\Whatever"
-
-    def test1(self):
-        # This used to leave a stale exception behind.
-        def reg_operation():
-            hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, self.key_name)
-            raise TestError
-
-        # do the test
-        try:
-            try:
-                try:
-                    reg_operation()
-                except:
-                    raise TestError  # Force a TestError
-            finally:
-                win32api.RegDeleteKey(win32con.HKEY_CURRENT_USER, self.key_name)
-        except TestError:
-            pass
-
-    def testValues(self):
-        key_name = r"PythonTestHarness\win32api"
-        ## tuples containing value name, value type, data
-        values = (
-            (None, win32con.REG_SZ, "This is default unnamed value"),
-            ("REG_SZ", win32con.REG_SZ, "REG_SZ text data"),
-            ("REG_EXPAND_SZ", win32con.REG_EXPAND_SZ, "%systemdir%"),
-            ## REG_MULTI_SZ value needs to be a list since strings are returned as a list
-            (
-                "REG_MULTI_SZ",
-                win32con.REG_MULTI_SZ,
-                ["string 1", "string 2", "string 3", "string 4"],
-            ),
-            ("REG_MULTI_SZ_empty", win32con.REG_MULTI_SZ, []),
-            ("REG_DWORD", win32con.REG_DWORD, 666),
-            ("REG_QWORD_INT", win32con.REG_QWORD, 99),
-            ("REG_QWORD", win32con.REG_QWORD, 2**33),
-            (
-                "REG_BINARY",
-                win32con.REG_BINARY,
-                b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x01\x00",
-            ),
-        )
-
-        hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, key_name)
-        for value_name, reg_type, data in values:
-            win32api.RegSetValueEx(hkey, value_name, None, reg_type, data)
-
-        for value_name, orig_type, orig_data in values:
-            data, typ = win32api.RegQueryValueEx(hkey, value_name)
-            self.assertEqual(typ, orig_type)
-            self.assertEqual(data, orig_data)
-
-    def testNotifyChange(self):
-        def change():
-            hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, self.key_name)
-            try:
-                win32api.RegSetValue(hkey, None, win32con.REG_SZ, "foo")
-            finally:
-                win32api.RegDeleteKey(win32con.HKEY_CURRENT_USER, self.key_name)
-
-        evt = win32event.CreateEvent(None, 0, 0, None)
-        ## REG_NOTIFY_CHANGE_LAST_SET - values
-        ## REG_CHANGE_NOTIFY_NAME - keys
-        ## REG_NOTIFY_CHANGE_SECURITY - security descriptor
-        ## REG_NOTIFY_CHANGE_ATTRIBUTES
-        win32api.RegNotifyChangeKeyValue(
-            win32con.HKEY_CURRENT_USER,
-            1,
-            win32api.REG_NOTIFY_CHANGE_LAST_SET,
-            evt,
-            True,
-        )
-        ret_code = win32event.WaitForSingleObject(evt, 0)
-        # Should be no change.
-        self.assertTrue(ret_code == win32con.WAIT_TIMEOUT)
-        change()
-        # Our event should now be in a signalled state.
-        ret_code = win32event.WaitForSingleObject(evt, 0)
-        self.assertTrue(ret_code == win32con.WAIT_OBJECT_0)
-
-
-class FileNames(unittest.TestCase):
-    def testShortLongPathNames(self):
-        try:
-            me = __file__
-        except NameError:
-            me = sys.argv[0]
-        fname = os.path.abspath(me).lower()
-        short_name = win32api.GetShortPathName(fname).lower()
-        long_name = win32api.GetLongPathName(short_name).lower()
-        self.assertTrue(
-            long_name == fname,
-            f"Expected long name ('{long_name}') to be original name ('{fname}')",
-        )
-        self.assertEqual(long_name, win32api.GetLongPathNameW(short_name).lower())
-        long_name = win32api.GetLongPathNameW(short_name).lower()
-        self.assertTrue(
-            isinstance(long_name, str),
-            f"GetLongPathNameW returned type '{type(long_name)}'",
-        )
-        self.assertTrue(
-            long_name == fname,
-            f"Expected long name ('{long_name}') to be original name ('{fname}')",
-        )
-
-    def testShortUnicodeNames(self):
-        try:
-            me = __file__
-        except NameError:
-            me = sys.argv[0]
-        fname = os.path.abspath(me).lower()
-        # passing unicode should cause GetShortPathNameW to be called.
-        short_name = win32api.GetShortPathName(str(fname)).lower()
-        self.assertTrue(isinstance(short_name, str))
-        long_name = win32api.GetLongPathName(short_name).lower()
-        self.assertTrue(
-            long_name == fname,
-            f"Expected long name ('{long_name}') to be original name ('{fname}')",
-        )
-        self.assertEqual(long_name, win32api.GetLongPathNameW(short_name).lower())
-        long_name = win32api.GetLongPathNameW(short_name).lower()
-        self.assertTrue(
-            isinstance(long_name, str),
-            f"GetLongPathNameW returned type '{type(long_name)}'",
-        )
-        self.assertTrue(
-            long_name == fname,
-            f"Expected long name ('{long_name}') to be original name ('{fname}')",
-        )
-
-    def testLongLongPathNames(self):
-        # We need filename where the FQN is > 256 - simplest way is to create a
-        # 250 character directory in the cwd (except - cwd may be on a drive
-        # not supporting \\\\?\\ (eg, network share) - so use temp.
-        import win32file
-
-        basename = "a" * 250
-        # but we need to ensure we use the 'long' version of the
-        # temp dir for later comparison.
-        long_temp_dir = win32api.GetLongPathNameW(tempfile.gettempdir())
-        fname = "\\\\?\\" + os.path.join(long_temp_dir, basename)
-        try:
-            win32file.CreateDirectoryW(fname, None)
-        except win32api.error as details:
-            if details.winerror != winerror.ERROR_ALREADY_EXISTS:
-                raise
-        try:
-            # GetFileAttributes automatically calls GetFileAttributesW when
-            # passed unicode
-            try:
-                attr = win32api.GetFileAttributes(fname)
-            except win32api.error as details:
-                if details.winerror != winerror.ERROR_FILENAME_EXCED_RANGE:
-                    raise
-
-            attr = win32api.GetFileAttributes(str(fname))
-            self.assertTrue(attr & win32con.FILE_ATTRIBUTE_DIRECTORY, attr)
-
-            long_name = win32api.GetLongPathNameW(fname)
-            self.assertEqual(long_name.lower(), fname.lower())
-        finally:
-            win32file.RemoveDirectory(fname)
-
-
-class FormatMessage(unittest.TestCase):
-    def test_FromString(self):
-        msg = "Hello %1, how are you %2?"
-        inserts = ["Mark", "today"]
-        result = win32api.FormatMessage(
-            win32con.FORMAT_MESSAGE_FROM_STRING,
-            msg,  # source
-            0,  # ID
-            0,  # LangID
-            inserts,
-        )
-        self.assertEqual(result, "Hello Mark, how are you today?")
-
-
-class Misc(unittest.TestCase):
-    def test_last_error(self):
-        for x in (0, 1, -1, winerror.TRUST_E_PROVIDER_UNKNOWN):
-            win32api.SetLastError(x)
-            self.assertEqual(x, win32api.GetLastError())
-
-    def testVkKeyScan(self):
-        # hopefully ' ' doesn't depend on the locale!
-        self.assertEqual(win32api.VkKeyScan(" "), 32)
-
-    def testVkKeyScanEx(self):
-        # hopefully ' ' doesn't depend on the locale!
-        self.assertEqual(win32api.VkKeyScanEx(" ", 0), 32)
-
-    def testGetSystemPowerStatus(self):
-        # Dummy
-        sps = win32api.GetSystemPowerStatus()
-        self.assertIsInstance(sps, dict)
-        test_keys = (
-            "ACLineStatus",
-            "BatteryFlag",
-            "BatteryLifePercent",
-            "SystemStatusFlag",
-            "BatteryLifeTime",
-            "BatteryFullLifeTime",
-        )
-        self.assertEqual(set(test_keys), set(sps))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,59 +0,0 @@
-# tests for win32gui
-import unittest
-
-import win32clipboard
-
-
-class TestGetSetClipboardData(unittest.TestCase):
-    def copyData(self, data, format_):
-        win32clipboard.OpenClipboard()
-        ret = None
-        try:
-            win32clipboard.SetClipboardData(format_, data)
-            ret = win32clipboard.GetClipboardData(format_)
-        finally:
-            win32clipboard.CloseClipboard()
-        return ret
-
-    def copyText(self, data, format_):
-        win32clipboard.OpenClipboard()
-        ret = None
-        try:
-            win32clipboard.SetClipboardText(data, format_)
-            ret = win32clipboard.GetClipboardData(format_)
-        finally:
-            win32clipboard.CloseClipboard()
-        return ret
-
-    def test_data(self):
-        test_data = {
-            "Dummy str": win32clipboard.CF_UNICODETEXT,
-            b"Dummy bytes text": win32clipboard.CF_TEXT,
-            b"Dummy\x00\xff bytes": win32clipboard.CF_DIB,
-        }
-        for data, fmt in test_data.items():
-            self.assertEqual(data, self.copyData(data, fmt))
-        test_data = {
-            "Dummy str": (win32clipboard.CF_TEXT, win32clipboard.CF_DIB),
-            b"Dummy\x00\xff bytes": (win32clipboard.CF_UNICODETEXT,),
-        }
-        for data, formats in test_data.items():
-            for fmt in formats:
-                self.assertNotEqual(data, self.copyData(data, fmt))
-
-    def test_text(self):
-        test_data = {
-            "Dummy str": win32clipboard.CF_UNICODETEXT,
-            b"Dummy bytes": win32clipboard.CF_TEXT,
-        }
-        for data, fmt in test_data.items():
-            self.assertEqual(data, self.copyText(data, fmt))
-            self.assertRaises(ValueError, self.copyText, data, win32clipboard.CF_DIB)
-        s = "Dummy str"
-        self.assertEqual(
-            s.encode(), self.copyText(s, win32clipboard.CF_TEXT)
-        )  # @TODO - cfati: Do we want this?
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,91 +0,0 @@
-import copy
-import unittest
-
-import win32cred
-
-
-class TestCredFunctions(unittest.TestCase):
-    def setUp(self):
-        self.flags = 0
-        self.dummy_cred = {
-            "TargetName": "DumyyUser",
-            "Type": win32cred.CRED_TYPE_GENERIC,
-            "Flags": self.flags,
-        }
-
-    def create_dummy_cred(self):
-        cred = copy.deepcopy(self.dummy_cred)
-        cred.update(
-            {
-                "Persist": win32cred.CRED_PERSIST_SESSION,
-            }
-        )
-        try:
-            win32cred.CredWrite(cred, self.flags)
-        except Exception as e:
-            print(e)
-
-    def is_dummy_cred(self):
-        return (
-            len(
-                [
-                    e
-                    for e in win32cred.CredEnumerate()
-                    if e["TargetName"] == self.dummy_cred["TargetName"]
-                ]
-            )
-            == 1
-        )
-
-    def test_creddelete(self):
-        self.create_dummy_cred()
-        self.assertTrue(self.is_dummy_cred())
-        self.assertIsNone(win32cred.CredDelete(**self.dummy_cred))
-        self.assertFalse(self.is_dummy_cred())
-        self.create_dummy_cred()
-        self.assertTrue(self.is_dummy_cred())
-        self.assertIsNone(win32cred.CredDelete(*self.dummy_cred.values()))
-        self.assertFalse(self.is_dummy_cred())
-        self.create_dummy_cred()
-        self.assertTrue(self.is_dummy_cred())
-        self.assertIsNone(
-            win32cred.CredDelete(self.dummy_cred["TargetName"], self.dummy_cred["Type"])
-        )
-        self.assertFalse(self.is_dummy_cred())
-        self.create_dummy_cred()
-        self.assertTrue(self.is_dummy_cred())
-        self.assertIsNone(win32cred.CredDelete(self.dummy_cred))
-        self.assertFalse(self.is_dummy_cred())
-        self.create_dummy_cred()
-        self.assertTrue(self.is_dummy_cred())
-        self.assertIsNone(win32cred.CredDelete(Target=self.dummy_cred))
-        self.assertFalse(self.is_dummy_cred())
-        self.create_dummy_cred()
-        self.assertTrue(self.is_dummy_cred())
-        self.assertRaises(TypeError, win32cred.CredDelete, "")
-        self.assertRaises(KeyError, win32cred.CredDelete, {})
-        self.assertRaises(KeyError, win32cred.CredDelete, {"TargetName": ""})
-        self.assertRaises(
-            TypeError, win32cred.CredDelete, {"TargetName": "", "Type": 3.141593}
-        )
-        self.assertIsNone(win32cred.CredDelete(self.dummy_cred))
-        self.assertFalse(self.is_dummy_cred())
-
-    def test_credgetsessiontypes(self):
-        res = win32cred.CredGetSessionTypes()
-        self.assertEqual(len(res), win32cred.CRED_TYPE_MAXIMUM)
-        for i in range(1, len(res)):
-            self.assertEqual(res[:i], win32cred.CredGetSessionTypes(i))
-            self.assertEqual(
-                res[:i], win32cred.CredGetSessionTypes(MaximumPersistCount=i)
-            )
-        self.assertRaises(
-            ValueError,
-            win32cred.CredGetSessionTypes,
-            0,
-        )
-        self.assertRaises(
-            ValueError,
-            win32cred.CredGetSessionTypes,
-            MaximumPersistCount=win32cred.CRED_TYPE_MAXIMUM + 1,
-        )