%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /usr/lib/python3/dist-packages/twisted/web/test/__pycache__/
Upload File :
Create Path :
Current File : //usr/lib/python3/dist-packages/twisted/web/test/__pycache__/test_http_headers.cpython-312.pyc

�

Ϫ�f�a���dZddlmZddlmZddlmZddlmZddl	m
Z
mZmZ								dd�Z
Gd�d	e�ZGd
�de�ZGd�d
e�Zy)z(
Tests for L{twisted.web.http_headers}.
�)�annotations)�Sequence)�TestCase)�Headers)�bytesLinearWhitespaceComponents�sanitizedBytes�textLinearWhitespaceComponentsc��|D]�}g}|jt||gi��t�}|j||�|j|�t�}|j||g�|j|�|D]Q}|j	t|j
��||gfg�|j	|j|�|g��S��y)a
    Assert that the components are sanitized to the expected value as
    both a header name and value, across all of L{Header}'s setters
    and getters.

    @param testCase: A test case.

    @param components: A sequence of values that contain linear
        whitespace to use as header names and values; see
        C{textLinearWhitespaceComponents} and
        C{bytesLinearWhitespaceComponents}

    @param expected: The expected sanitized form of the component for
        both headers names and their values.
    N)�appendr�addRawHeader�
setRawHeaders�assertEqual�list�getAllRawHeaders�
getRawHeaders)�testCase�
components�expected�	component�headers�added�	setHeader�headers        �D/usr/lib/python3/dist-packages/twisted/web/test/test_http_headers.py�assertSanitizedrs���$ �M�	������w�	�I�;�7�8�9��	��
���9�i�0����u���I�	����	�I�;�7����y�!��	M�F�� � ��V�,�,�.�/�8�h�Z�2H�1I�
�
� � ��!5�!5�h�!?�(��L�		M�M�c���eZdZdZdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z	dd�Z
dd	�Zdd
�Zdd�Z
dd�Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zy)�BytesHeadersTestszE
    Tests for L{Headers}, using L{bytes} arguments for methods.
    c�.�t|tt�y�zf
        Linear whitespace in header names or values is replaced with a
        single space.
        N)rrr��selfs r�test_sanitizeLinearWhitespacez/BytesHeadersTests.test_sanitizeLinearWhitespace>s��
	��=�~�Nrc�d�tddgi�}|j|jd�dg�y)zx
        The header values passed to L{Headers.__init__} can be retrieved via
        L{Headers.getRawHeaders}.
        �Foo�bar�fooN�rrr�r"�hs  r�test_initializerz"BytesHeadersTests.test_initializerEs0��

�V�f�X�&�'���������0�6�(�;rc��ddg}t�}|jd|�|j|jd��|j|jd��|j	|jd�|�y)z�
        L{Headers.setRawHeaders} sets the header values for the given
        header name to the sequence of byte string values.
        �value1�value2�test�TestN�rr
�
assertTrue�	hasHeaderrr)r"�rawValuer*s   r�test_setRawHeadersz$BytesHeadersTests.test_setRawHeadersMsf��
�y�)���I��	�����*�������G�,�-�������G�,�-��������1�8�<rc�`�t�}|jt|jdddi�y)zN
        L{Headers.setRawHeaders} requires values to be of type list.
        �keyr%r&N�r�assertRaises�	TypeErrorr
r)s  r�)test_rawHeadersTypeCheckingValuesIterablez;BytesHeadersTests.test_rawHeadersTypeCheckingValuesIterableYs(��
�I�����)�Q�_�_�f�v�v�>N�Orc��t�}|jt|jddg�}|j	|j
dd�y)zf
        L{Headers.setRawHeaders} requires C{name} to be a L{bytes} or
        L{str} string.
        Nr'r�BHeader name is an instance of <class 'NoneType'>, not bytes or str�rr9r:r
r�args�r"r*�es   r�test_rawHeadersTypeCheckingNamez1BytesHeadersTests.test_rawHeadersTypeCheckingName`sC��

�I�����i����$���I�����
�F�F�1�I�S�	
rc��t�}|jt|jdddg�}|j	|j
dd�y)zn
        L{Headers.setRawHeaders} requires values to a L{list} of L{bytes} or
        L{str} strings.
        r7r&NrzQHeader value at position 1 is an instance of <class 'NoneType'>, not bytes or strr>r@s   r�*test_rawHeadersTypeCheckingValuesAreStringz<BytesHeadersTests.test_rawHeadersTypeCheckingValuesAreStringlsG��

�I�����i����&�6�4�.�Q�����
�F�F�1�I�
�	
rc���t�}|jdd�|j|jd�dg�|jdd�|j|jd�ddg�y)�N
        L{Headers.addRawHeader} adds a new value for a given header.
        r/�lemur�pandaN�rrrrr)s  r�test_addRawHeaderz#BytesHeadersTests.test_addRawHeaderys`��
�I��	���w��)��������1�H�:�>�	���w��)��������1�H�h�3G�Hrc��t�}|jt|jdd�}|j	|j
dd�y)ze
        L{Headers.addRawHeader} requires C{name} to be a L{bytes} or L{str}
        string.
        Nr'rr=�rr9r:rrr?r@s   r�test_addRawHeaderTypeCheckNamez0BytesHeadersTests.test_addRawHeaderTypeCheckName�sA��

�I�����i�����v�F�����
�F�F�1�I�S�	
rc��t�}|jt|jdd�}|j	|j
dd�y)zc
        L{Headers.addRawHeader} requires value to be a L{bytes} or L{str}
        string.
        r7NrzCHeader value is an instance of <class 'NoneType'>, not bytes or strrLr@s   r�test_addRawHeaderTypeCheckValuez1BytesHeadersTests.test_addRawHeaderTypeCheckValue�sA��

�I�����i������F�����
�F�F�1�I�T�	
rc�T�|jt�jd��y)�z
        L{Headers.getRawHeaders} returns L{None} if the header is not found and
        no default is specified.
        r/N��assertIsNonerrr!s r�test_getRawHeadersNoDefaultz-BytesHeadersTests.test_getRawHeadersNoDefault�s��
	
���'�)�1�1�'�:�;rc�p�t�}t�}|j|jd|�|�y)�o
        L{Headers.getRawHeaders} returns the specified default value when no
        header is found.
        r/N)r�object�assertIdenticalr�r"r*�defaults   r�test_getRawHeadersDefaultValuez0BytesHeadersTests.test_getRawHeadersDefaultValue�s-��

�I���(�����Q�_�_�W�g�>��Hrc���t�}dg}|jd|�|j|jd|�dt�|j|jd|�dg�y)z�
        If the object passed as the value list to L{Headers.setRawHeaders}
        is later passed as a default to L{Headers.getRawHeaders}, the
        result nevertheless contains encoded values.
        �valuer7r�valueN)rr
�assertIsInstancer�bytesrrYs   r�*test_getRawHeadersWithDefaultMatchingValuez<BytesHeadersTests.test_getRawHeadersWithDefaultMatchingValue�s]��
�I���)��	�����(����a�o�o�f�g�>�q�A�5�I���������9�H�:�Frc���t�}|jddg�|j|jd�dg�|j|jd�dg�y)�m
        L{Headers.getRawHeaders} returns the values which have been set for a
        given header.
        r/rGr0N�rr
rrr)s  r�test_getRawHeadersz$BytesHeadersTests.test_getRawHeaders�sQ��

�I��	����(��,��������1�H�:�>��������1�H�:�>rc��t�}|jddg�|j|jd��|j|jd��y)�i
        Check that L{Headers.hasHeader} returns C{True} when the given header
        is found.
        r/rGr0N�rr
r2r3r)s  r�test_hasHeaderTruez$BytesHeadersTests.test_hasHeaderTrue�sE��

�I��	����(��,�������G�,�-�������G�,�-rc�T�|jt�jd��y)�c
        L{Headers.hasHeader} returns C{False} when the given header is not
        found.
        r/N��assertFalserr3r!s r�test_hasHeaderFalsez%BytesHeadersTests.test_hasHeaderFalse�s��
	
�����,�,�W�5�6rc��t�}|jddg�|j|jd��|j	d�|j|jd��|jddg�|j|jd��|j	d�|j|jd��y)�N
        Check that L{Headers.removeHeader} removes the given header.
        r'rGr&rHsBarN�rr
r2r3�removeHeaderrmr)s  r�test_removeHeaderz#BytesHeadersTests.test_removeHeader�s���
�I��	�����
�+�������F�+�,�	���v��������V�,�-�	�����
�+�������F�+�,�	���v��������V�,�-rc��t�}|jd�|jt|j	��g�y)�k
        L{Headers.removeHeader} is a no-operation when the specified header is
        not found.
        r/N�rrrrrrr)s  r�test_removeHeaderDoesntExistz.BytesHeadersTests.test_removeHeaderDoesntExist�s5��

�I��	���w������a�0�0�2�3�R�8rc�j�t�}|j|jd�d�|j|jd�d�|j|jd�d�|j|jd�d�|j|jd	�d
�|j|jd�d�|j|jd
�d�|j|jd�d�|j|jd�d�y)zr
        L{Headers._canonicalNameCaps} returns the canonical capitalization for
        the given header.
        r/r0s
test-stuffs
Test-Stuffscontent-md5�Content-MD5sdntsDNTsetagsETagsp3psP3PstesTE�www-authenticate�WWW-Authenticatesx-xss-protectionsX-XSS-ProtectionN)rr�_canonicalNameCapsr)s  r�test_canonicalNameCapsz(BytesHeadersTests.test_canonicalNameCaps�s��

�I������-�-�g�6��@�����-�-�m�<�m�L�����-�-�n�=�~�N�����-�-�f�5�v�>�����-�-�g�6��@�����-�-�f�5�v�>�����-�-�e�4�e�<�����-�-�.A�B�DW�X�����-�-�.A�B�DW�Xrc���t�}|jddg�|jddg�|j�D��chc]\}}|t|�f��}}}|j	|ddh�ycc}}w)��
        L{Headers.getAllRawHeaders} returns an iterable of (k, v) pairs, where
        C{k} is the canonicalized representation of the header name, and C{v}
        is a sequence of values.
        r/�lemursrz�basic aksljdlk=�r{)r�)r0�r�N�rr
r�tupler�r"r*�k�v�
allHeaderss     r�test_getAllRawHeadersz'BytesHeadersTests.test_getAllRawHeaders�sv��
�I��	����)��-�	���+�.@�-A�B�01�0B�0B�0D�E���1�q�%��(�m�E�
�E�����
9�;R�S�	
��Fs�A3c� �t�}|jddg�t�}|jddg�t�}|jdddg�|j||�|j||�|j||�y)��
        A L{Headers} instance compares equal to itself and to another
        L{Headers} instance with the same values.
        r'rHrGN�rr
r�assertNotEqual)r"�first�second�thirds    r�test_headersComparisonz(BytesHeadersTests.test_headersComparisons���
�	��
���F�X�J�/�������V�h�Z�0��	��
���F�X�x�$8�9������&������'����E�5�)rc��t�}|j|d�|j|t��|j|d�y)�f
        An instance of L{Headers} does not compare equal to other unrelated
        objects.
        �r'N�rr�rWr)s  r�test_otherComparisonz&BytesHeadersTests.test_otherComparisons=��

�I�����A�r�"����A�v�x�(����A�v�&rc
�t�d}d}d}|jtt|||gi��d|�d|�d|�d��y)	zy
        The L{repr} of a L{Headers} instance shows the names and values of all
        the headers it contains.
        r'r&�baz�	Headers({�: [�, �]})N�r�reprr�r"�foo�bar�bazs    r�	test_reprzBytesHeadersTests.test_repr%sO��
�����������#��S�z�*�+�,����s�3�'��C�7�$�7�	
rc
�t�d}d}d}|jtt|||gi��d|�d|�d|�d��y)	z�
        The L{repr} of a L{Headers} instance shows the names and values of all
        the headers it contains, not attempting to decode any raw bytes.
        r'sbar�sbaz�r�r�r�r�Nr�r�s    r�test_reprWithRawBytesz'BytesHeadersTests.test_reprWithRawBytes2sQ�������������#��S�z�*�+�,����s�3�'��C�7�$�7�	
rc
��d}d}d}Gd�dt�}|jt||||gi��d|�d|�d|�d	��y
)��
        The L{repr} of an instance of a subclass of L{Headers} uses the name
        of the subclass instead of the string C{"Headers"}.
        r'r&r�c��eZdZy)�9BytesHeadersTests.test_subclassRepr.<locals>.FunnyHeadersN��__name__�
__module__�__qualname__r�rr�FunnyHeadersr�L���rr��FunnyHeaders({r�r�r�N)rrr�)r"r�r�r�r�s     r�test_subclassReprz#BytesHeadersTests.test_subclassReprCs]��
������	�7�	�	
�����s�S�#�J�/�0�1��c�W�C��w�b���t�<�	
rc�t�t�}|jddg�|j�}|j|j	d�dg�|jdd�|j|j	d�dg�|jdd�|j|j	d�ddg�y)��
        L{Headers.copy} creates a new independent copy of an existing
        L{Headers} instance, allowing future modifications without impacts
        between the copies.
        r/r'r&r�N�rr
�copyrrr�r"r*�is   r�	test_copyzBytesHeadersTests.test_copyTs���
�I��	����&��*�
�F�F�H���������1�F�8�<�	���w��'��������1�F�8�<�	���w��'��������1�F�F�3C�DrN��return�None)r�r�r��__doc__r#r+r5r;rBrDrJrMrOrTr[rarerirnrsrwr}r�r�r�r�r�r�r�r�rrrr9s����O�<�
=�P�

�
�I�

�

�<�I�
G�?�.�7�.� 9�Y� 
�"
*�'�
�
�"
�"
Errc��eZdZdZdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z	dd�Z
dd	�Zdd
�Zdd�Z
dd�Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zy)�UnicodeHeadersTestszC
    Tests for L{Headers}, using L{str} arguments for methods.
    c�.�t|tt�yr )rr	rr!s rr#z1UnicodeHeadersTests.test_sanitizeLinearWhitespaceis��
	��<�n�Mrc��tddgi�}|j|jd�dg�|j|jd�dg�y)aC
        The header values passed to L{Headers.__init__} can be retrieved via
        L{Headers.getRawHeaders}. If a L{bytes} argument is given, it returns
        L{bytes} values, and if a L{str} argument is given, it returns
        L{str} values. Both are the same header value, just encoded or
        decoded.
        �Foor�r'r&r�Nr(r)s  rr+z$UnicodeHeadersTests.test_initializerpsK��
�U�U�G�$�%���������0�6�(�;��������/�%��9rc���ddg}ddg}t�}|jd|�|j|jd��|j|jd��|j|jd��|j|jd��|j	|jd�|�|j	|jd�|�y	)
z�
        L{Headers.setRawHeaders} sets the header values for the given
        header name to the sequence of strings, encoded.
        �value1�value2r-r.�testr/r0�TestNr1)r"r4�rawEncodedValuer*s    rr5z&UnicodeHeadersTests.test_setRawHeaders|s���
�h�'��$�i�0���I��	�����)�������G�,�-�������G�,�-�������F�+�,�������F�+�,��������0�(�;��������1�?�Crc��t�}|jt�5|jddg�ddd�|jt�5|j	d�ddd�y#1swY�9xYw#1swYyxYw)z�
        Passing L{str} to any function that takes a header name will encode
        said header name as ISO-8859-1, and if it cannot be encoded, it will
        raise a L{UnicodeDecodeError}.
        �☃�valN)rr9�UnicodeEncodeErrorr
r3r)s  r�test_nameNotEncodablez)UnicodeHeadersTests.test_nameNotEncodable�sx��
�I���
�
�1�
2�	/�
�O�O�H�u�g�.�	/��
�
�1�
2�	"�
�K�K��!�	"�	"�	/�	/��	"�	"�s�A,�A8�,A5�8Bc��t�}|jddg�|j|jd��|j	|jd�dg�|j|jd��y)z}
        Passing L{str} to any function that takes a header name will encode
        said header name as ISO-8859-1.
        �ár'��Nr1r)s  r�test_nameEncodingz%UnicodeHeadersTests.test_nameEncoding�sf��

�I��	
����6�(�+�	
������G�,�-��������1�F�8�<�	
������H�-�.rc���t�}|jdddg�|j|jd��|j	|jd�ddg�y)z|
        Passing L{str} to L{Headers.setRawHeaders} will encode the name as
        ISO-8859-1 and values as UTF-8.
        r�r�r'r�s☃Nr1r)s  r�test_rawHeadersValueEncodingz0UnicodeHeadersTests.test_rawHeadersValueEncoding�sQ��

�I��	����8�V�"4�5�������G�,�-��������1�O�V�3L�Mrc�`�t�}|jt|jdddi�y)zQ
        L{Headers.setRawHeaders} requires values to be of type sequence
        �keyr�r�Nr8r)s  r�test_rawHeadersTypeCheckingz/UnicodeHeadersTests.test_rawHeadersTypeChecking�s'��
�I�����)�Q�_�_�e�e�U�^�Lrc�0�t�}|jdd�|j|jd�dg�|jdd�|j|jd�ddg�|j|jd�ddg�y)rFr��lemur�pandar/rGrHNrIr)s  rrJz%UnicodeHeadersTests.test_addRawHeader�s~��
�I��	���v�w�'��������0�7�)�<�	���v�w�'��������0�7�G�2D�E��������1�H�h�3G�Hrc�T�|jt�jd��y)rQr�NrRr!s rrTz/UnicodeHeadersTests.test_getRawHeadersNoDefault�s��
	
���'�)�1�1�&�9�:rc�D�t�}t�}|j|jd|�|�|j|jdd�d�|j	|jddg�dg�|j	|jddg�dg�y)rVr�Nr�)rrWrXrrrYs   rr[z2UnicodeHeadersTests.test_getRawHeadersDefaultValue�s���

�I���(�����Q�_�_�V�W�=�w�G����Q�_�_�V�T�:�D�A��������$��8�4�&�A����
�O�O�F�]�O�4�
�O�	
rc���t�}dg}|jd|�|j|jd|�dt�|j|jd|�dg�y)z�
        If the object passed as the value list to L{Headers.setRawHeaders}
        is later passed as a default to L{Headers.getRawHeaders}, the
        result nevertheless contains decoded values.
        r^r7r�rr]N)rr
r_r�strrrYs   rraz>UnicodeHeadersTests.test_getRawHeadersWithDefaultMatchingValue�s]��
�I���*��	�����(����a�o�o�e�W�=�a�@�#�F���������8�7�)�Drc�N�t�}|jddg�|j|jd�dg�|j|jd�dg�|j|jd�dg�|j|jd�dg�y)rc�testár��Testá�test�rG�Test�Nrdr)s  rrez&UnicodeHeadersTests.test_getRawHeaders�s���

�I��	����w�i�0��������6��	�B��������6��	�B��������5��z�B��������5��z�Brc�>�t�}|jddg�|j|jd��|j|jd��|j|jd��|j|jd��y)rgr�r�r�r�r�Nrhr)s  rriz&UnicodeHeadersTests.test_hasHeaderTrue�so��

�I��	����w�i�0�������L�1�2�������L�1�2�������K�0�1�������K�0�1rc�T�|jt�jd��y)rkr�Nrlr!s rrnz'UnicodeHeadersTests.test_hasHeaderFalses��
	
�����,�,�\�:�;rc�(�t�}|jddg�|j|jd��|j	d�|j|jd��|j|jd��|jddg�|j|jd��|j	d�|j|jd��|j|jd��y)	rpr�r�r'r�r��Barr&Nrqr)s  rrsz%UnicodeHeadersTests.test_removeHeader	s���
�I��	�����y�)�������E�*�+�	���u��������U�+�,�������V�,�-�	�����y�)�������E�*�+�	���u��������U�+�,�������V�,�-rc��t�}|jd�|jt|j	��g�y)rur�Nrvr)s  rrwz0UnicodeHeadersTests.test_removeHeaderDoesntExists5��

�I��	���v������a�0�0�2�3�R�8rc��t�}|jddg�|jddg�|jddg�|j�D��chc]\}}|t|�f��}}}|j	|hd��ycc}}w)	rr��lemurszwww-authenticatezbasic aksljdlk=zcontent-md5�
kjdfdfgdfgnsd>�r�r��ry)s
kjdfdfgdfgnsdr�Nr�r�s     rr�z)UnicodeHeadersTests.test_getAllRawHeaders$s���
�I��	����x�j�1�	���*�->�,?�@�	���
��'8�9�01�0B�0B�0D�E���1�q�%��(�m�E�
�E�����
�	
��Fs�Bc�<�t�}|jddg�t�}|jddg�t�}|jdddg�|j||�|j||�|j||�t�}|jddg�t�}|jddg�t�}|jdddg�|j||�|j||�|j||�y)r��fooár�r�sfoo�rHrGNr�)r"r�r�r��
firstBytes�secondBytes�
thirdBytess       rr�z*UnicodeHeadersTests.test_headersComparison:s��
�	��
���K�'��3�������[�7�)�4��	��
���K�'�7�);�<������&������'����E�5�)��Y�
�� � ��h�Z�8��i���!�!�*�x�j�9��Y�
�� � ��h��-@�A�����
�+������-�����
�+rc��t�}|j|d�|j|t��|j|d�y)r�r�r�Nr�r)s  rr�z(UnicodeHeadersTests.test_otherComparisonVs=��

�I�����A�r�"����A�v�x�(����A�u�%rc
��d}d}d}d}d}d|z}d|z}|jtt|||gi��dj|||j	d���y	)
z�
        The L{repr} of a L{Headers} instance shows the names and values of all
        the headers it contains. This shows only reprs of bytes values, as
        undecodable headers may cause an exception.
        r��bar☃r�z	'foo\xe1'z'bar\xe2\x98\x83'�bzHeaders({{{}: [{}, {!r}]}})�utf8N)rr�r�format�encode)r"r�r�r��
fooEncoded�
barEncodeds      rr�zUnicodeHeadersTests.test_repr`ss��������!�
�+�
��:�%�
��:�%�
������#��S�z�*�+�,�)�0�0��J��
�
�6�(:�
�	
rc��d}d}d}d}d}Gd�dt�}|jt||||gi��d|�d	|�d
|jd��d��y
)r�r�r�r�z
b'foo\xe1'zb'bar\xe2\x98\x83'c��eZdZy)�;UnicodeHeadersTests.test_subclassRepr.<locals>.FunnyHeadersNr�r�rrr�r�r�rr�r�r�r�r�r�N)rrr�r�)r"r�r�r�r�r�r�s       rr�z%UnicodeHeadersTests.test_subclassReprtsd��
������"�
�,�
�	�7�	�	
�����s�S�#�J�/�0�1��:�s�z�z�&�'9�
;�	
rc�B�t�}|jddg�|j�}|j|j	d�dg�|j|j	d�dg�|jdd�|j|j	d�dg�|j|j	d�dg�|jdd�|j|j	d�ddg�|j|j	d�ddg�y)	r�r�ufoo☃r�sfoo☃r�r�r&Nr�r�s   rr�zUnicodeHeadersTests.test_copy�s���
�I��	����{�m�4�
�F�F�H��	
�������6��
�F��������5�8J�7K�L�	
���|�U�+�	
�������6��
�F��������5�8J�7K�L�	
���|�V�,�	
�������6��e�8L�M��������5�8J�F�7S�TrNr�)r�r�r�r�r#r+r5r�r�r�r�rJrTr[rarerirnrsrwr�r�r�r�r�r�r�rrr�r�ds}���N�
:�D� 
"�/�"N�M�	I�;�

�
E�
C�
2�<�.�$9�
�,,�8&�
�(
�(Urr�c� �eZdZdZdd�Zdd�Zy)�MixedHeadersTestszm
    Tests for L{Headers}, mixing L{bytes} and L{str} arguments for methods
    where that is permitted.
    c���t�}|jdd�|jdd�|j|jd�dg�|j|jd�dg�y)zL
        L{Headers.addRawHeader} accepts mixed L{str} and L{bytes}.
        �bytesr��Bytes�str�Strr`NrIr)s  rrJz#MixedHeadersTests.test_addRawHeader�s]��
�I��	���x��'�	���u�h�'��������2�V�H�=��������/�'��;rc���t�}|jddg�|jddg�|jdddg�|jdddg�|j|jd�dg�|j|jd�dg�|j|jd�ddg�|j|jd	�d
dg�y)zM
        L{Headers.setRawHeaders} accepts mixed L{str} and L{bytes}.
        rr�z	mixed-strsmixed-bytesrrz	Mixed-Strr`sMixed-BytesrNrdr)s  rr5z$MixedHeadersTests.test_setRawHeaders�s���
�I��	����8�*�-�	�����w�'�	����h��%6�7�	������(9�:��������2�X�J�?��������/�%��9��������5���7G�H��������8�6�8�:L�MrNr�)r�r�r�r�rJr5r�rrrr�s���
	<�
NrrN)rrrzSequence[bytes] | Sequence[str]rr`r�r�)r��
__future__r�typingr�twisted.trial.unittestr�twisted.web.http_headersr�twisted.web.test.requesthelperrrr	rrr�rr�rr�<module>rs}���#��+�,���"M��"M�$C�"M�OT�"M�	�"M�JhE��hE�V	~U�(�~U�B
N��Nr

Zerion Mini Shell 1.0