Gecko [ theprintave.ca ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2024-11-28 06:59
__init__.py	475 B	-rw-r--r--	2022-02-07 13:12
cert.pem.no_trailing_newline	1.38 KB	-rw-r--r--	2022-02-07 13:12
crash_test_dummy.py	549 B	-rw-r--r--	2022-02-07 13:12
ignore_test_failure.py	30.72 KB	-rw-r--r--	2024-11-22 17:49
iosim.py	17.74 KB	-rw-r--r--	2022-02-07 13:12
key.pem.no_trailing_newline	1.67 KB	-rw-r--r--	2022-02-07 13:12
mock_win32process.py	1.27 KB	-rw-r--r--	2022-02-07 13:12
myrebuilder1.py	151 B	-rw-r--r--	2022-02-07 13:12
myrebuilder2.py	151 B	-rw-r--r--	2022-02-07 13:12
plugin_basic.py	901 B	-rw-r--r--	2022-02-07 13:12
plugin_extra1.py	392 B	-rw-r--r--	2022-02-07 13:12
plugin_extra2.py	550 B	-rw-r--r--	2022-02-07 13:12
process_cmdline.py	123 B	-rw-r--r--	2022-02-07 13:12
process_echoer.py	214 B	-rw-r--r--	2022-02-07 13:12
process_fds.py	984 B	-rw-r--r--	2022-02-07 13:12
process_getargv.py	234 B	-rw-r--r--	2022-02-07 13:12
process_getenv.py	268 B	-rw-r--r--	2022-02-07 13:12
process_linger.py	297 B	-rw-r--r--	2022-02-07 13:12
process_reader.py	178 B	-rw-r--r--	2022-02-07 13:12
process_signal.py	220 B	-rw-r--r--	2022-02-07 13:12
process_stdinreader.py	739 B	-rw-r--r--	2022-02-07 13:12
process_tester.py	779 B	-rw-r--r--	2022-02-07 13:12
process_tty.py	130 B	-rw-r--r--	2022-02-07 13:12
process_twisted.py	1.15 KB	-rw-r--r--	2022-02-07 13:12
proto_helpers.py	1.34 KB	-rw-r--r--	2022-02-07 13:12
reflect_helper_IE.py	60 B	-rw-r--r--	2022-02-07 13:12
reflect_helper_VE.py	81 B	-rw-r--r--	2022-02-07 13:12
reflect_helper_ZDE.py	48 B	-rw-r--r--	2022-02-07 13:12
server.pem	4.34 KB	-rw-r--r--	2022-02-07 13:12
ssl_helpers.py	1.61 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_consumer.py	1.14 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_halfclose.py	2 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_hostpeer.py	1.06 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_lastwrite.py	1.13 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_loseconn.py	1.55 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_producer.py	1.45 KB	-rw-r--r--	2022-02-07 13:12
stdio_test_write.py	902 B	-rw-r--r--	2022-02-07 13:12
stdio_test_writeseq.py	894 B	-rw-r--r--	2022-02-07 13:12
test_abstract.py	3.35 KB	-rw-r--r--	2022-02-07 13:12
test_adbapi.py	25.56 KB	-rw-r--r--	2022-02-07 13:12
test_amp.py	107.92 KB	-rw-r--r--	2022-02-07 13:12
test_application.py	33.34 KB	-rw-r--r--	2022-02-07 13:12
test_compat.py	17.75 KB	-rw-r--r--	2022-02-07 13:12
test_context.py	1.43 KB	-rw-r--r--	2022-02-07 13:12
test_cooperator.py	20.84 KB	-rw-r--r--	2022-02-07 13:12
test_defer.py	121.86 KB	-rw-r--r--	2022-02-07 13:12
test_defgen.py	10.38 KB	-rw-r--r--	2022-02-07 13:12
test_dict.py	1.49 KB	-rw-r--r--	2022-02-07 13:12
test_dirdbm.py	6.69 KB	-rw-r--r--	2022-02-07 13:12
test_error.py	8.72 KB	-rw-r--r--	2022-02-07 13:12
test_factories.py	4.46 KB	-rw-r--r--	2022-02-07 13:12
test_fdesc.py	7.28 KB	-rw-r--r--	2022-02-07 13:12
test_finger.py	1.85 KB	-rw-r--r--	2022-02-07 13:12
test_formmethod.py	3.87 KB	-rw-r--r--	2022-02-07 13:12
test_ftp.py	126.96 KB	-rw-r--r--	2022-02-07 13:12
test_ftp_options.py	2.63 KB	-rw-r--r--	2022-02-07 13:12
test_htb.py	3.08 KB	-rw-r--r--	2022-02-07 13:12
test_ident.py	6.56 KB	-rw-r--r--	2022-02-07 13:12
test_internet.py	45.38 KB	-rw-r--r--	2022-02-07 13:12
test_iosim.py	8.7 KB	-rw-r--r--	2022-02-07 13:12
test_iutils.py	13.31 KB	-rw-r--r--	2022-02-07 13:12
test_lockfile.py	14.98 KB	-rw-r--r--	2022-02-07 13:12
test_log.py	35.23 KB	-rw-r--r--	2022-02-07 13:12
test_logfile.py	17.47 KB	-rw-r--r--	2022-02-07 13:12
test_loopback.py	13.99 KB	-rw-r--r--	2022-02-07 13:12
test_main.py	2.12 KB	-rw-r--r--	2022-02-07 13:12
test_memcache.py	24.69 KB	-rw-r--r--	2022-02-07 13:12
test_modules.py	17.02 KB	-rw-r--r--	2024-11-22 17:49
test_monkey.py	5.39 KB	-rw-r--r--	2022-02-07 13:12
test_paths.py	69.31 KB	-rw-r--r--	2022-02-07 13:12
test_pcp.py	12.23 KB	-rw-r--r--	2022-02-07 13:12
test_persisted.py	13.09 KB	-rw-r--r--	2022-02-07 13:12
test_plugin.py	24.79 KB	-rw-r--r--	2022-02-07 13:12
test_policies.py	32.29 KB	-rw-r--r--	2022-02-07 13:12
test_postfix.py	4.32 KB	-rw-r--r--	2022-02-07 13:12
test_process.py	85.16 KB	-rw-r--r--	2022-02-07 13:12
test_protocols.py	7.16 KB	-rw-r--r--	2022-02-07 13:12
test_randbytes.py	3.19 KB	-rw-r--r--	2022-02-07 13:12
test_rebuild.py	7.15 KB	-rw-r--r--	2022-02-07 13:12
test_reflect.py	23.9 KB	-rw-r--r--	2022-02-07 13:12
test_roots.py	1.6 KB	-rw-r--r--	2022-02-07 13:12
test_shortcut.py	1.92 KB	-rw-r--r--	2022-02-07 13:12
test_sip.py	24.9 KB	-rw-r--r--	2022-02-07 13:12
test_sob.py	5.53 KB	-rw-r--r--	2022-02-07 13:12
test_socks.py	17.09 KB	-rw-r--r--	2022-02-07 13:12
test_ssl.py	22.75 KB	-rw-r--r--	2022-02-07 13:12
test_sslverify.py	113.89 KB	-rw-r--r--	2024-11-22 17:49
test_stateful.py	1.97 KB	-rw-r--r--	2022-02-07 13:12
test_stdio.py	12.43 KB	-rw-r--r--	2022-02-07 13:12
test_strerror.py	5.12 KB	-rw-r--r--	2022-02-07 13:12
test_strports.py	1.67 KB	-rw-r--r--	2022-02-07 13:12
test_task.py	45.26 KB	-rw-r--r--	2022-02-07 13:12
test_tcp.py	64.27 KB	-rw-r--r--	2022-02-07 13:12
test_tcp_internals.py	12.73 KB	-rw-r--r--	2022-02-07 13:12
test_text.py	6.22 KB	-rw-r--r--	2022-02-07 13:12
test_threadable.py	3.26 KB	-rw-r--r--	2022-02-07 13:12
test_threadpool.py	21.44 KB	-rw-r--r--	2022-02-07 13:12
test_threads.py	12.9 KB	-rw-r--r--	2022-02-07 13:12
test_tpfile.py	1.51 KB	-rw-r--r--	2022-02-07 13:12
test_twistd.py	72.04 KB	-rw-r--r--	2022-02-07 13:12
test_twisted.py	6.13 KB	-rw-r--r--	2022-02-07 13:12
test_udp.py	24.43 KB	-rw-r--r--	2022-02-07 13:12
test_unix.py	13.26 KB	-rw-r--r--	2022-02-07 13:12
test_usage.py	22.76 KB	-rw-r--r--	2022-02-07 13:12
testutils.py	5.06 KB	-rw-r--r--	2022-02-07 13:12

Rename

# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Tests for L{twisted.python.compat}.
"""

import codecs
import io
import sys
import traceback
from unittest import skipIf

from twisted.python.compat import (
    _PYPY,
    _get_async_param,
    bytesEnviron,
    cmp,
    comparable,
    execfile,
    intToBytes,
    ioType,
    iterbytes,
    lazyByteSlice,
    nativeString,
    networkString,
    reraise,
)
from twisted.python.filepath import FilePath
from twisted.python.runtime import platform
from twisted.trial.unittest import SynchronousTestCase, TestCase

class IOTypeTests(SynchronousTestCase):
    """
    Test cases for determining a file-like object's type.
    """

def test_3StringIO(self):
        """
        An L{io.StringIO} accepts and returns text.
        """
        self.assertEqual(ioType(io.StringIO()), str)

def test_3BytesIO(self):
        """
        An L{io.BytesIO} accepts and returns bytes.
        """
        self.assertEqual(ioType(io.BytesIO()), bytes)

def test_3openTextMode(self):
        """
        A file opened via 'io.open' in text mode accepts and returns text.
        """
        with open(self.mktemp(), "w") as f:
            self.assertEqual(ioType(f), str)

def test_3openBinaryMode(self):
        """
        A file opened via 'io.open' in binary mode accepts and returns bytes.
        """
        with open(self.mktemp(), "wb") as f:
            self.assertEqual(ioType(f), bytes)

def test_codecsOpenBytes(self):
        """
        The L{codecs} module, oddly, returns a file-like object which returns
        bytes when not passed an 'encoding' argument.
        """
        with codecs.open(self.mktemp(), "wb") as f:
            self.assertEqual(ioType(f), bytes)

def test_codecsOpenText(self):
        """
        When passed an encoding, however, the L{codecs} module returns unicode.
        """
        with codecs.open(self.mktemp(), "wb", encoding="utf-8") as f:
            self.assertEqual(ioType(f), str)

def test_defaultToText(self):
        """
        When passed an object about which no sensible decision can be made, err
        on the side of unicode.
        """
        self.assertEqual(ioType(object()), str)

class CompatTests(SynchronousTestCase):
    """
    Various utility functions in C{twisted.python.compat} provide same
    functionality as modern Python variants.
    """

def test_set(self):
        """
        L{set} should behave like the expected set interface.
        """
        a = set()
        a.add("b")
        a.add("c")
        a.add("a")
        b = list(a)
        b.sort()
        self.assertEqual(b, ["a", "b", "c"])
        a.remove("b")
        b = list(a)
        b.sort()
        self.assertEqual(b, ["a", "c"])

a.discard("d")

b = {"r", "s"}
        d = a.union(b)
        b = list(d)
        b.sort()
        self.assertEqual(b, ["a", "c", "r", "s"])

def test_frozenset(self):
        """
        L{frozenset} should behave like the expected frozenset interface.
        """
        a = frozenset(["a", "b"])
        self.assertRaises(AttributeError, getattr, a, "add")
        self.assertEqual(sorted(a), ["a", "b"])

b = frozenset(["r", "s"])
        d = a.union(b)
        b = list(d)
        b.sort()
        self.assertEqual(b, ["a", "b", "r", "s"])

class ExecfileCompatTests(SynchronousTestCase):
    """
    Tests for the Python 3-friendly L{execfile} implementation.
    """

def writeScript(self, content):
        """
        Write L{content} to a new temporary file, returning the L{FilePath}
        for the new file.
        """
        path = self.mktemp()
        with open(path, "wb") as f:
            f.write(content.encode("ascii"))
        return FilePath(path.encode("utf-8"))

def test_execfileGlobals(self):
        """
        L{execfile} executes the specified file in the given global namespace.
        """
        script = self.writeScript("foo += 1\n")
        globalNamespace = {"foo": 1}
        execfile(script.path, globalNamespace)
        self.assertEqual(2, globalNamespace["foo"])

def test_execfileGlobalsAndLocals(self):
        """
        L{execfile} executes the specified file in the given global and local
        namespaces.
        """
        script = self.writeScript("foo += 1\n")
        globalNamespace = {"foo": 10}
        localNamespace = {"foo": 20}
        execfile(script.path, globalNamespace, localNamespace)
        self.assertEqual(10, globalNamespace["foo"])
        self.assertEqual(21, localNamespace["foo"])

def test_execfileUniversalNewlines(self):
        """
        L{execfile} reads in the specified file using universal newlines so
        that scripts written on one platform will work on another.
        """
        for lineEnding in "\n", "\r", "\r\n":
            script = self.writeScript("foo = 'okay'" + lineEnding)
            globalNamespace = {"foo": None}
            execfile(script.path, globalNamespace)
            self.assertEqual("okay", globalNamespace["foo"])

class PYPYTest(SynchronousTestCase):
    """
    Identification of PyPy.
    """

def test_PYPY(self):
        """
        On PyPy, L{_PYPY} is True.
        """
        if "PyPy" in sys.version:
            self.assertTrue(_PYPY)
        else:
            self.assertFalse(_PYPY)

@comparable
class Comparable:
    """
    Objects that can be compared to each other, but not others.
    """

def __init__(self, value):
        self.value = value

def __cmp__(self, other):
        if not isinstance(other, Comparable):
            return NotImplemented
        return cmp(self.value, other.value)

class ComparableTests(SynchronousTestCase):
    """
    L{comparable} decorated classes emulate Python 2's C{__cmp__} semantics.
    """

def test_equality(self):
        """
        Instances of a class that is decorated by C{comparable} support
        equality comparisons.
        """
        # Make explicitly sure we're using ==:
        self.assertTrue(Comparable(1) == Comparable(1))
        self.assertFalse(Comparable(2) == Comparable(1))

def test_nonEquality(self):
        """
        Instances of a class that is decorated by C{comparable} support
        inequality comparisons.
        """
        # Make explicitly sure we're using !=:
        self.assertFalse(Comparable(1) != Comparable(1))
        self.assertTrue(Comparable(2) != Comparable(1))

def test_greaterThan(self):
        """
        Instances of a class that is decorated by C{comparable} support
        greater-than comparisons.
        """
        self.assertTrue(Comparable(2) > Comparable(1))
        self.assertFalse(Comparable(0) > Comparable(3))

def test_greaterThanOrEqual(self):
        """
        Instances of a class that is decorated by C{comparable} support
        greater-than-or-equal comparisons.
        """
        self.assertTrue(Comparable(1) >= Comparable(1))
        self.assertTrue(Comparable(2) >= Comparable(1))
        self.assertFalse(Comparable(0) >= Comparable(3))

def test_lessThan(self):
        """
        Instances of a class that is decorated by C{comparable} support
        less-than comparisons.
        """
        self.assertTrue(Comparable(0) < Comparable(3))
        self.assertFalse(Comparable(2) < Comparable(0))

def test_lessThanOrEqual(self):
        """
        Instances of a class that is decorated by C{comparable} support
        less-than-or-equal comparisons.
        """
        self.assertTrue(Comparable(3) <= Comparable(3))
        self.assertTrue(Comparable(0) <= Comparable(3))
        self.assertFalse(Comparable(2) <= Comparable(0))

class Python3ComparableTests(SynchronousTestCase):
    """
    Python 3-specific functionality of C{comparable}.
    """

def test_notImplementedEquals(self):
        """
        Instances of a class that is decorated by C{comparable} support
        returning C{NotImplemented} from C{__eq__} if it is returned by the
        underlying C{__cmp__} call.
        """
        self.assertEqual(Comparable(1).__eq__(object()), NotImplemented)

def test_notImplementedNotEquals(self):
        """
        Instances of a class that is decorated by C{comparable} support
        returning C{NotImplemented} from C{__ne__} if it is returned by the
        underlying C{__cmp__} call.
        """
        self.assertEqual(Comparable(1).__ne__(object()), NotImplemented)

def test_notImplementedGreaterThan(self):
        """
        Instances of a class that is decorated by C{comparable} support
        returning C{NotImplemented} from C{__gt__} if it is returned by the
        underlying C{__cmp__} call.
        """
        self.assertEqual(Comparable(1).__gt__(object()), NotImplemented)

def test_notImplementedLessThan(self):
        """
        Instances of a class that is decorated by C{comparable} support
        returning C{NotImplemented} from C{__lt__} if it is returned by the
        underlying C{__cmp__} call.
        """
        self.assertEqual(Comparable(1).__lt__(object()), NotImplemented)

def test_notImplementedGreaterThanEquals(self):
        """
        Instances of a class that is decorated by C{comparable} support
        returning C{NotImplemented} from C{__ge__} if it is returned by the
        underlying C{__cmp__} call.
        """
        self.assertEqual(Comparable(1).__ge__(object()), NotImplemented)

def test_notImplementedLessThanEquals(self):
        """
        Instances of a class that is decorated by C{comparable} support
        returning C{NotImplemented} from C{__le__} if it is returned by the
        underlying C{__cmp__} call.
        """
        self.assertEqual(Comparable(1).__le__(object()), NotImplemented)

class CmpTests(SynchronousTestCase):
    """
    L{cmp} should behave like the built-in Python 2 C{cmp}.
    """

def test_equals(self):
        """
        L{cmp} returns 0 for equal objects.
        """
        self.assertEqual(cmp("a", "a"), 0)
        self.assertEqual(cmp(1, 1), 0)
        self.assertEqual(cmp([1], [1]), 0)

def test_greaterThan(self):
        """
        L{cmp} returns 1 if its first argument is bigger than its second.
        """
        self.assertEqual(cmp(4, 0), 1)
        self.assertEqual(cmp(b"z", b"a"), 1)

def test_lessThan(self):
        """
        L{cmp} returns -1 if its first argument is smaller than its second.
        """
        self.assertEqual(cmp(0.1, 2.3), -1)
        self.assertEqual(cmp(b"a", b"d"), -1)

class StringTests(SynchronousTestCase):
    """
    Compatibility functions and types for strings.
    """

def assertNativeString(self, original, expected):
        """
        Raise an exception indicating a failed test if the output of
        C{nativeString(original)} is unequal to the expected string, or is not
        a native string.
        """
        self.assertEqual(nativeString(original), expected)
        self.assertIsInstance(nativeString(original), str)

def test_nonASCIIBytesToString(self):
        """
        C{nativeString} raises a C{UnicodeError} if input bytes are not ASCII
        decodable.
        """
        self.assertRaises(UnicodeError, nativeString, b"\xFF")

def test_nonASCIIUnicodeToString(self):
        """
        C{nativeString} raises a C{UnicodeError} if input Unicode is not ASCII
        encodable.
        """
        self.assertRaises(UnicodeError, nativeString, "\u1234")

def test_bytesToString(self):
        """
        C{nativeString} converts bytes to the native string format, assuming
        an ASCII encoding if applicable.
        """
        self.assertNativeString(b"hello", "hello")

def test_unicodeToString(self):
        """
        C{nativeString} converts unicode to the native string format, assuming
        an ASCII encoding if applicable.
        """
        self.assertNativeString("Good day", "Good day")

def test_stringToString(self):
        """
        C{nativeString} leaves native strings as native strings.
        """
        self.assertNativeString("Hello!", "Hello!")

def test_unexpectedType(self):
        """
        C{nativeString} raises a C{TypeError} if given an object that is not a
        string of some sort.
        """
        self.assertRaises(TypeError, nativeString, 1)

class NetworkStringTests(SynchronousTestCase):
    """
    Tests for L{networkString}.
    """

def test_str(self):
        """
        L{networkString} returns a C{unicode} object passed to it encoded into
        a C{bytes} instance.
        """
        self.assertEqual(b"foo", networkString("foo"))

def test_unicodeOutOfRange(self):
        """
        L{networkString} raises L{UnicodeError} if passed a C{unicode} instance
        containing characters not encodable in ASCII.
        """
        self.assertRaises(UnicodeError, networkString, "\N{SNOWMAN}")

def test_nonString(self):
        """
        L{networkString} raises L{TypeError} if passed a non-string object or
        the wrong type of string object.
        """
        self.assertRaises(TypeError, networkString, object())
        self.assertRaises(TypeError, networkString, b"bytes")

class ReraiseTests(SynchronousTestCase):
    """
    L{reraise} re-raises exceptions on both Python 2 and Python 3.
    """

def test_reraiseWithNone(self):
        """
        Calling L{reraise} with an exception instance and a traceback of
        L{None} re-raises it with a new traceback.
        """
        try:
            1 / 0
        except BaseException:
            typ, value, tb = sys.exc_info()
        try:
            reraise(value, None)
        except BaseException:
            typ2, value2, tb2 = sys.exc_info()
            self.assertEqual(typ2, ZeroDivisionError)
            self.assertIs(value, value2)
            self.assertNotEqual(
                traceback.format_tb(tb)[-1], traceback.format_tb(tb2)[-1]
            )
        else:
            self.fail("The exception was not raised.")

def test_reraiseWithTraceback(self):
        """
        Calling L{reraise} with an exception instance and a traceback
        re-raises the exception with the given traceback.
        """
        try:
            1 / 0
        except BaseException:
            typ, value, tb = sys.exc_info()
        try:
            reraise(value, tb)
        except BaseException:
            typ2, value2, tb2 = sys.exc_info()
            self.assertEqual(typ2, ZeroDivisionError)
            self.assertIs(value, value2)
            self.assertEqual(traceback.format_tb(tb)[-1], traceback.format_tb(tb2)[-1])
        else:
            self.fail("The exception was not raised.")

class Python3BytesTests(SynchronousTestCase):
    """
    Tests for L{iterbytes}, L{intToBytes}, L{lazyByteSlice}.
    """

def test_iteration(self):
        """
        When L{iterbytes} is called with a bytestring, the returned object
        can be iterated over, resulting in the individual bytes of the
        bytestring.
        """
        input = b"abcd"
        result = list(iterbytes(input))
        self.assertEqual(result, [b"a", b"b", b"c", b"d"])

def test_intToBytes(self):
        """
        When L{intToBytes} is called with an integer, the result is an
        ASCII-encoded string representation of the number.
        """
        self.assertEqual(intToBytes(213), b"213")

def test_lazyByteSliceNoOffset(self):
        """
        L{lazyByteSlice} called with some bytes returns a semantically equal
        version of these bytes.
        """
        data = b"123XYZ"
        self.assertEqual(bytes(lazyByteSlice(data)), data)

def test_lazyByteSliceOffset(self):
        """
        L{lazyByteSlice} called with some bytes and an offset returns a
        semantically equal version of these bytes starting at the given offset.
        """
        data = b"123XYZ"
        self.assertEqual(bytes(lazyByteSlice(data, 2)), data[2:])

def test_lazyByteSliceOffsetAndLength(self):
        """
        L{lazyByteSlice} called with some bytes, an offset and a length returns
        a semantically equal version of these bytes starting at the given
        offset, up to the given length.
        """
        data = b"123XYZ"
        self.assertEqual(bytes(lazyByteSlice(data, 2, 3)), data[2:5])

class BytesEnvironTests(TestCase):
    """
    Tests for L{BytesEnviron}.
    """

@skipIf(platform.isWindows(), "Environment vars are always str on Windows.")
    def test_alwaysBytes(self):
        """
        The output of L{BytesEnviron} should always be a L{dict} with L{bytes}
        values and L{bytes} keys.
        """
        result = bytesEnviron()
        types = set()

for key, val in result.items():
            types.add(type(key))
            types.add(type(val))

self.assertEqual(list(types), [bytes])

class GetAsyncParamTests(SynchronousTestCase):
    """
    Tests for L{twisted.python.compat._get_async_param}
    """

def test_get_async_param(self):
        """
        L{twisted.python.compat._get_async_param} uses isAsync by default,
        or deprecated async keyword argument if isAsync is None.
        """
        self.assertEqual(_get_async_param(isAsync=False), False)
        self.assertEqual(_get_async_param(isAsync=True), True)
        self.assertEqual(_get_async_param(isAsync=None, **{"async": False}), False)
        self.assertEqual(_get_async_param(isAsync=None, **{"async": True}), True)
        self.assertRaises(TypeError, _get_async_param, False, {"async": False})

def test_get_async_param_deprecation(self):
        """
        L{twisted.python.compat._get_async_param} raises a deprecation
        warning if async keyword argument is passed.
        """
        self.assertEqual(_get_async_param(isAsync=None, **{"async": False}), False)
        currentWarnings = self.flushWarnings(
            offendingFunctions=[self.test_get_async_param_deprecation]
        )
        self.assertEqual(
            currentWarnings[0]["message"],
            "'async' keyword argument is deprecated, please use isAsync",
        )