ó
    ×›‘hMa  ã                  óÊ   • S r SSKJr  SSKJr  SSKJrJr  SSKJ	r	J
r
Jr  SSKJrJrJr   " S S\5      r        SS	 jr " S
 S\5      r " S S\5      r " S S\5      rg)z(
Tests for L{twisted.web.http_headers}.
é    )Úannotations)ÚSequence)ÚSynchronousTestCaseÚTestCase)ÚHeadersÚInvalidHeaderNameÚ_nameEncoder)ÚbytesLinearWhitespaceComponentsÚsanitizedBytesÚtextLinearWhitespaceComponentsc                  ó6   • \ rS rSrSrSS jrSS jrSS jrSrg)	ÚNameEncoderTestsé   z/
Test L{twisted.web.http_headers._NameEncoder}
c                óH  • U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S	5      S
5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        g)zS
L{_NameEncoder.encode} returns the canonical capitalization for
the given header.
ó   testó   Tests
   test-stuffó
   Test-Stuffs   content-md5ó   Content-MD5s   dntó   DNTs   etagó   ETags   p3pó   P3Ps   teó   TEó   www-authenticateó   WWW-Authenticates   WWW-authenticates   Www-Authenticates   x-xss-protectionó   X-XSS-ProtectionN©ÚassertEqualr	   Úencode©Úselfs    ÚfC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/web/test/test_http_headers.pyÚtest_encodeNameÚ NameEncoderTests.test_encodeName   s5  € ð
 	×Ñœ×,Ò,¨WÓ5°wÔ?Ø×Ñœ×,Ò,¨]Ó;¸]ÔKØ×Ñœ×,Ò,¨^Ó<¸nÔMØ×Ñœ×,Ò,¨VÓ4°fÔ=Ø×Ñœ×,Ò,¨WÓ5°wÔ?Ø×Ñœ×,Ò,¨VÓ4°fÔ=Ø×Ñœ×,Ò,¨UÓ3°UÔ;Ø×Ñœ×,Ò,Ð-@ÓAÐCVÔWØ×Ñœ×,Ò,Ð-@ÓAÐCVÔWØ×Ñœ×,Ò,Ð-@ÓAÐCVÔWØ×Ñœ×,Ò,Ð-@ÓAÐCVÕWó    c                óH  • U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S	5      S
5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        U R                  [        R                  " S5      S5        g)zb
L{_NameEncoder.encode} returns the canonical capitalization for
a header name given as a L{str}.
Útestr   z
test-stuffr   úcontent-md5r   Údntr   Úetagr   Úp3pr   Úter   úwww-authenticater   zWWW-authenticatezWww-Authenticatezx-xss-protectionr   Nr   r   s    r!   Útest_encodeNameStrÚ#NameEncoderTests.test_encodeNameStr+   s5  € ð
 	×Ñœ×,Ò,¨VÓ4°gÔ>Ø×Ñœ×,Ò,¨\Ó:¸MÔJØ×Ñœ×,Ò,¨]Ó;¸^ÔLØ×Ñœ×,Ò,¨UÓ3°VÔ<Ø×Ñœ×,Ò,¨VÓ4°gÔ>Ø×Ñœ×,Ò,¨UÓ3°VÔ<Ø×Ñœ×,Ò,¨TÓ2°EÔ:Ø×Ñœ×,Ò,Ð-?Ó@ÐBUÔVØ×Ñœ×,Ò,Ð-?Ó@ÐBUÔVØ×Ñœ×,Ò,Ð-?Ó@ÐBUÔVØ×Ñœ×,Ò,Ð-?Ó@ÐBUÕVr$   c                óö   • [        5       n[        [        R                  S-   5       H  nUR	                  SU 3S5        M     U R                  [        [        R                  5      [        R                  5        g)z8
Only a limited number of HTTP header names get cached.
éÈ   zhello-ÚvalueN)r   Úranger	   Ú_MAX_CACHED_HEADERSÚaddRawHeaderr   ÚlenÚ_canonicalHeaderCache)r    ÚheadersÚis      r!   Útest_maxCachedHeadersÚ&NameEncoderTests.test_maxCachedHeaders<   s_   € ô “)ˆÜ”|×7Ñ7¸#Ñ=Ö>ˆAØ× Ñ  6¨!¨ ¨wÖ7ñ ?à×ÑÜ”×2Ñ2Ó3´\×5UÑ5Uõ	
r$   © N©ÚreturnÚNone)	Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r"   r-   r9   Ú__static_attributes__r;   r$   r!   r   r      s   † ñôXô"W÷"	
r$   r   c                ó¶  • SnU HÑ  n/ nUR                  [        X4/05      5        [        5       nUR                  X45        UR                  U5        [        5       nUR                  X4/5        UR                  U5        U HQ  nU R	                  [        UR                  5       5      X2/4/5        U R	                  UR                  U5      U/5        MS     MÓ     g)a¶  
Assert that the components are sanitized to the expected value as
both a header 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 values; see
    C{textLinearWhitespaceComponents} and
    C{bytesLinearWhitespaceComponents}

@param expected: The expected sanitized form of the component as
    a header value.
s   NameN)Úappendr   r4   ÚsetRawHeadersr   ÚlistÚgetAllRawHeadersÚgetRawHeaders)	ÚtestCaseÚ
componentsÚexpectedÚnameÚ	componentr7   ÚaddedÚ	setHeaderÚheaders	            r!   ÚassertSanitizedrS   H   s¿   € ð" €DÛˆ	ØˆØ�‰”w  kÐ2Ó3Ô4ä“	ˆØ×Ñ˜4Ô+Ø�‰�uÔä“Iˆ	Ø×Ñ  kÔ2Ø�‰�yÔ!ãˆFØ× Ñ ¤ f×&=Ñ&=Ó&?Ó!@ÀDÈ*ÐCUÐBVÔWØ× Ñ  ×!5Ñ!5°dÓ!;¸h¸ZÖHó ò  r$   c                  óÖ   • \ rS rSrSrSS jrSS jrSS jrSS jrSS jr	SS jr
SS	 jrSS
 jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSrg)ÚBytesHeadersTestsék   z=
Tests for L{Headers}, using L{bytes} arguments for methods.
c                ó.   • [        U [        [        5        g©zN
Linear whitespace in header names or values is replaced with a
single space.
N)rS   r
   r   r   s    r!   Útest_sanitizeLinearWhitespaceÚ/BytesHeadersTests.test_sanitizeLinearWhitespacep   s   € ô
 	˜Ô=¼~ÕNr$   c                ód   • [        SS/05      nU R                  UR                  S5      S/5        g)z`
The header values passed to L{Headers.__init__} can be retrieved via
L{Headers.getRawHeaders}.
s   Fooó   baró   fooN©r   r   rJ   ©r    Úhs     r!   Útest_initializerÚ"BytesHeadersTests.test_initializerw   s0   € ô
 �V˜f˜XÐ&Ó'ˆØ×Ñ˜Ÿ™¨Ó0°6°(Õ;r$   c                ó  • SS/n[        5       nUR                  SU5        U R                  UR                  S5      5        U R                  UR                  S5      5        U R	                  UR                  S5      U5        g)zr
L{Headers.setRawHeaders} sets the header values for the given
header name to the sequence of byte string values.
ó   value1ó   value2r   r   N©r   rG   Ú
assertTrueÚ	hasHeaderr   rJ   )r    ÚrawValuer`   s      r!   Útest_setRawHeadersÚ$BytesHeadersTests.test_setRawHeaders   sf   € ð
 ˜yÐ)ˆÜ‹IˆØ	�‰˜ Ô*Ø�‰˜Ÿ™ GÓ,Ô-Ø�‰˜Ÿ™ GÓ,Ô-Ø×Ñ˜Ÿ™¨Ó1°8Õ<r$   c                óê   • [        5       nUR                  SS5        U R                  UR                  S5      S/5        UR                  SS5        U R                  UR                  S5      SS/5        g)ú>
L{Headers.addRawHeader} adds a new value for a given header.
r   ó   lemuró   pandaN©r   r4   r   rJ   r_   s     r!   Útest_addRawHeaderÚ#BytesHeadersTests.test_addRawHeader‹   s`   € ô ‹IˆØ	�‰�w Ô)Ø×Ñ˜Ÿ™¨Ó1°H°:Ô>Ø	�‰�w Ô)Ø×Ñ˜Ÿ™¨Ó1°H¸hÐ3GÕHr$   c                óT   • U R                  [        5       R                  S5      5        g)úb
L{Headers.getRawHeaders} returns L{None} if the header is not found and
no default is specified.
r   N©ÚassertIsNoner   rJ   r   s    r!   Útest_getRawHeadersNoDefaultÚ-BytesHeadersTests.test_getRawHeadersNoDefault•   s   € ð
 	×Ñœ'›)×1Ñ1°'Ó:Õ;r$   c                óp   • [        5       n[        5       nU R                  UR                  SU5      U5        g)úW
L{Headers.getRawHeaders} returns the specified default value when no
header is found.
r   N)r   ÚobjectÚassertIdenticalrJ   ©r    r`   Údefaults      r!   Útest_getRawHeadersDefaultValueÚ0BytesHeadersTests.test_getRawHeadersDefaultValueœ   s-   € ô
 ‹IˆÜ“(ˆØ×Ñ˜QŸ_™_¨W°gÓ>ÀÕHr$   c                óÚ   • [        5       nS/nUR                  SU5        U R                  UR                  SU5      S   [        5        U R                  UR                  SU5      S/5        g)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.
r1   ó   keyr   ó   valueN)r   rG   ÚassertIsInstancerJ   Úbytesr   r}   s      r!   Ú*test_getRawHeadersWithDefaultMatchingValueÚ<BytesHeadersTests.test_getRawHeadersWithDefaultMatchingValue¥   s]   € ô ‹IˆØ�)ˆØ	�‰˜ Ô(Ø×Ñ˜aŸo™o¨f°gÓ>¸qÑAÄ5ÔIØ×Ñ˜Ÿ™¨°Ó9¸H¸:ÕFr$   c                óÆ   • [        5       nUR                  SS/5        U R                  UR                  S5      S/5        U R                  UR                  S5      S/5        g)úU
L{Headers.getRawHeaders} returns the values which have been set for a
given header.
r   rn   r   N©r   rG   r   rJ   r_   s     r!   Útest_getRawHeadersÚ$BytesHeadersTests.test_getRawHeaders±   sQ   € ô
 ‹IˆØ	�‰˜ ( Ô,Ø×Ñ˜Ÿ™¨Ó1°H°:Ô>Ø×Ñ˜Ÿ™¨Ó1°H°:Õ>r$   c                ó¾   • [        5       nUR                  SS/5        U R                  UR                  S5      5        U R                  UR                  S5      5        g)úQ
Check that L{Headers.hasHeader} returns C{True} when the given header
is found.
r   rn   r   N©r   rG   rg   rh   r_   s     r!   Útest_hasHeaderTrueÚ$BytesHeadersTests.test_hasHeaderTrue»   sE   € ô
 ‹IˆØ	�‰˜ ( Ô,Ø�‰˜Ÿ™ GÓ,Ô-Ø�‰˜Ÿ™ GÓ,Õ-r$   c                óT   • U R                  [        5       R                  S5      5        g)úK
L{Headers.hasHeader} returns C{False} when the given header is not
found.
r   N©ÚassertFalser   rh   r   s    r!   Útest_hasHeaderFalseÚ%BytesHeadersTests.test_hasHeaderFalseÅ   s   € ð
 	×Ñœ›×,Ñ,¨WÓ5Õ6r$   c                ó¨  • [        5       nUR                  SS/5        U R                  UR                  S5      5        UR	                  S5        U R                  UR                  S5      5        UR                  SS/5        U R                  UR                  S5      5        UR	                  S5        U R                  UR                  S5      5        g)ú>
Check that L{Headers.removeHeader} removes the given header.
r]   rn   r\   ro   s   BarN©r   rG   rg   rh   ÚremoveHeaderr•   r_   s     r!   Útest_removeHeaderÚ#BytesHeadersTests.test_removeHeaderÌ   s›   € ô ‹Iˆà	�‰˜  
Ô+Ø�‰˜Ÿ™ FÓ+Ô,Ø	�‰�vÔØ×Ñ˜Ÿ™ VÓ,Ô-à	�‰˜  
Ô+Ø�‰˜Ÿ™ FÓ+Ô,Ø	�‰�vÔØ×Ñ˜Ÿ™ VÓ,Õ-r$   c                óŒ   • [        5       nUR                  S5        U R                  [        UR	                  5       5      / 5        g)úS
L{Headers.removeHeader} is a no-operation when the specified header is
not found.
r   N©r   r›   r   rH   rI   r_   s     r!   Útest_removeHeaderDoesntExistÚ.BytesHeadersTests.test_removeHeaderDoesntExistÜ   s5   € ô
 ‹IˆØ	�‰�wÔØ×Ñœ˜a×0Ñ0Ó2Ó3°RÕ8r$   c                óö   • [        5       nUR                  SS/5        UR                  SS/5        UR                  5        VVs1 s H  u  p#U[        U5      4iM     nnnU R	                  USS15        gs  snnf )ú§
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   ó   lemursr   ó   basic aksljdlk=©r   )r¦   ©r   )r¥   N©r   rG   rI   Útupler   ©r    r`   ÚkÚvÚ
allHeaderss        r!   Útest_getAllRawHeadersÚ'BytesHeadersTests.test_getAllRawHeaderså   sw   € ô ‹IˆØ	�‰˜ ) Ô-Ø	�‰Ð+Ð.@Ð-AÔBà01×0BÑ0BÔ0DÔEÒ0D©¨�qœ% ›(“mÑ0Dˆ
ÑEà×ÑØØ9Ð;RÐSõ	
ùó Fs   ÁA5c                ó  • [        5       nUR                  SS/5        [        5       nUR                  SS/5        [        5       nUR                  SSS/5        U R                  X5        U R                  X5        U R                  X5        g)úi
A L{Headers} instance compares equal to itself and to another
L{Headers} instance with the same values.
r]   ro   rn   N©r   rG   r   ÚassertNotEqual)r    ÚfirstÚsecondÚthirds       r!   Útest_headersComparisonÚ(BytesHeadersTests.test_headersComparisonö   s|   € ô
 “	ˆØ×Ñ˜F X JÔ/Ü“ˆØ×Ñ˜V h ZÔ0Ü“	ˆØ×Ñ˜F X¨xÐ$8Ô9Ø×Ñ˜Ô&Ø×Ñ˜Ô'Ø×Ñ˜EÕ)r$   c                ó”   • [        5       nU R                  US5        U R                  U[        5       5        U R                  US5        g)úN
An instance of L{Headers} does not compare equal to other unrelated
objects.
r;   r]   N©r   r´   r{   r_   s     r!   Útest_otherComparisonÚ&BytesHeadersTests.test_otherComparison  s=   € ô
 ‹IˆØ×Ñ˜A˜rÔ"Ø×Ñ˜Aœv›xÔ(Ø×Ñ˜A˜vÕ&r$   c           
     ó”   • SnSnSnU R                  [        [        XU/05      5      SUR                  5       < SU< SU< S35        g)	za
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   Ú
capitalize©r    ÚfooÚbarÚbazs       r!   Ú	test_reprÚBytesHeadersTests.test_repr  sU   € ð
 ˆØˆØˆØ×ÑÜ”˜# S˜zÐ*Ó+Ó,Ø˜Ÿ™Ó)Ñ,¨C°©w°b¸¹¸tÐDõ	
r$   c           
     ó”   • SnSnSnU R                  [        [        XU/05      5      SUR                  5       < SU< SU< S35        g)	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]   s   barás   bazárÁ   rÂ   rÃ   rÄ   NrÅ   rÈ   s       r!   Útest_reprWithRawBytesÚ'BytesHeadersTests.test_reprWithRawBytes  sW   € ð ˆð ˆØˆØ×ÑÜ”˜# S˜zÐ*Ó+Ó,Ø˜Ÿ™Ó)Ñ,¨C°©w°b¸¹¸tÐDõ	
r$   c           
     ó¬   • SnSnSn " S S[         5      nU R                  [        U" XU/05      5      SUR                  5       < SU< SU< S	35        g
)úz
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                  ó   • \ rS rSrSrg)Ú9BytesHeadersTests.test_subclassRepr.<locals>.FunnyHeadersi6  r;   N©r?   r@   rA   rB   rD   r;   r$   r!   ÚFunnyHeadersrÔ   6  ó   † Úr$   rÖ   úFunnyHeaders({rÂ   rÃ   rÄ   N)r   r   rÆ   rÇ   )r    rÉ   rÊ   rË   rÖ   s        r!   Útest_subclassReprÚ#BytesHeadersTests.test_subclassRepr-  sc   € ð
 ˆØˆØˆô	œ7ô 	ð 	×ÑÜ‘˜s¨# JÐ/Ó0Ó1Ø˜cŸn™nÓ.Ñ1°°S±G¸2¸c¹WÀDÐIõ	
r$   c                ót  • [        5       nUR                  SS/5        UR                  5       nU R                  UR	                  S5      S/5        UR                  SS5        U R                  UR	                  S5      S/5        UR                  SS5        U R                  UR	                  S5      SS/5        g)ú–
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©r   rG   Úcopyr   rJ   r4   ©r    r`   r8   s      r!   Ú	test_copyÚBytesHeadersTests.test_copy>  s–   € ô ‹IˆØ	�‰˜ & Ô*Ø�F‰F‹HˆØ×Ñ˜Ÿ™¨Ó1°F°8Ô<Ø	�‰�w Ô'Ø×Ñ˜Ÿ™¨Ó1°F°8Ô<Ø	�‰�w Ô'Ø×Ñ˜Ÿ™¨Ó1°F¸FÐ3CÕDr$   r;   Nr<   )r?   r@   rA   rB   rC   rY   ra   rj   rq   rw   r   r†   r‹   r�   r–   rœ   r¡   r¯   r¸   r½   rÌ   rÏ   rÙ   rà   rD   r;   r$   r!   rU   rU   k   sk   † ñôOô<ô
=ôIô<ôIô
Gô?ô.ô7ô.ô 9ô
ô"*ô'ô
ô
ô"
÷"Er$   rU   c                  óô   • \ rS rSrSrSS jrSS jrSS jrSS jrSS jr	SS jr
SS	 jrSS
 jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSS jrSrg)ÚUnicodeHeadersTestsiN  z;
Tests for L{Headers}, using L{str} arguments for methods.
c                ó.   • [        U [        [        5        grX   )rS   r   r   r   s    r!   rY   Ú1UnicodeHeadersTests.test_sanitizeLinearWhitespaceS  s   € ô
 	˜Ô<¼nÕMr$   c                ó¨   • [        SS/05      nU R                  UR                  S5      S/5        U R                  UR                  S5      S/5        g)a  
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     r!   ra   Ú$UnicodeHeadersTests.test_initializerZ  sK   € ô �U˜U˜GÐ$Ó%ˆØ×Ñ˜Ÿ™¨Ó0°6°(Ô;Ø×Ñ˜Ÿ™¨Ó/°%°Õ9r$   c                óÐ  • SS/nSS/n[        5       nUR                  SU5        U R                  UR                  S5      5        U R                  UR                  S5      5        U R                  UR                  S5      5        U R                  UR                  S5      5        U R	                  UR                  S5      U5        U R	                  UR                  S5      U5        g	)
zp
L{Headers.setRawHeaders} sets the header values for the given
header name to the sequence of strings, encoded.
Úvalue1Úvalue2rd   re   r&   r   r   ÚTestNrf   )r    ri   ÚrawEncodedValuer`   s       r!   rj   Ú&UnicodeHeadersTests.test_setRawHeadersf  s³   € ð
 ˜hÐ'ˆØ$ iÐ0ˆÜ‹IˆØ	�‰˜ Ô)Ø�‰˜Ÿ™ GÓ,Ô-Ø�‰˜Ÿ™ GÓ,Ô-Ø�‰˜Ÿ™ FÓ+Ô,Ø�‰˜Ÿ™ FÓ+Ô,Ø×Ñ˜Ÿ™¨Ó0°(Ô;Ø×Ñ˜Ÿ™¨Ó1°?ÕCr$   c                ó  • [        5       nU R                  [        5         UR                  SS/5        SSS5        U R                  [        5         UR	                  S5        SSS5        g! , (       d  f       N>= f! , (       d  f       g= f)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)r   ÚassertRaisesÚUnicodeEncodeErrorrG   rh   r_   s     r!   Útest_nameNotEncodableÚ)UnicodeHeadersTests.test_nameNotEncodablev  sh   € ô ‹Iˆð ×ÑÔ1Õ2Ø�O‰O˜H u gÔ.÷ 3ð ×ÑÔ1Õ2Ø�K‰K˜Ô!÷ 3Ð2÷ 3Õ2ú÷ 3Õ2ús    A,ÁA=Á,
A:Á=
Bc                óv  • [        5       nU R                  [        UR                  SS/5        U R                  [        UR                  SS/5        U R                  [        UR                  SS/5        U R                  [        UR                  SS/5        U R                  [        UR                  SS/5        g)zl
HTTP header names must be tokens, so any names containing non-token
characters raises L{InvalidHeaderName}
ó   ás   valô   Ã¡s   a bzc
dzc	dN)r   rò   r   rG   r_   s     r!   Útest_nameNotTokenÚ%UnicodeHeadersTests.test_nameNotToken…  s–   € ô
 ‹Iˆð 	×ÑÔ+¨Q¯_©_¸gÈÀxÔPØ×ÑÔ+¨Q¯_©_¸hÈÈÔQð 	×ÑÔ+¨Q¯_©_¸fÀvÀhÔOØ×ÑÔ+¨Q¯_©_¸fÀvÀhÔOØ×ÑÔ+¨Q¯_©_¸fÀvÀhÕOr$   c                ó  • [        5       nUR                  SS/5        U R                  UR                  S5      5        U R	                  UR                  S5      S/5        U R                  UR                  S5      5        g)ze
Passing L{str} to any function that takes a header name will encode
said header name as ISO-8859-1.
rÊ   r]   r\   Nrf   r_   s     r!   Útest_nameEncodingÚ%UnicodeHeadersTests.test_nameEncoding•  sf   € ô
 ‹Iˆð 	
�‰˜ ˜xÔ(ð 	�‰˜Ÿ™ FÓ+Ô,Ø×Ñ˜Ÿ™¨Ó0°6°(Ô;ð 	�‰˜Ÿ™ EÓ*Õ+r$   c                óÆ   • [        5       nUR                  SSS/5        U R                  UR                  S5      5        U R	                  UR                  S5      SS/5        g)zd
Passing L{str} to L{Headers.setRawHeaders} will encode the name as
ISO-8859-1 and values as UTF-8.
Úxrð   r]   ó   xs   â˜ƒNrf   r_   s     r!   Útest_rawHeadersValueEncodingÚ0UnicodeHeadersTests.test_rawHeadersValueEncoding¦  sQ   € ô
 ‹IˆØ	�‰˜˜h¨Ð/Ô0Ø�‰˜Ÿ™ DÓ)Ô*Ø×Ñ˜Ÿ™¨Ó.°À&Ð0IÕJr$   c                ó0  • [        5       nUR                  SS5        U R                  UR                  S5      S/5        UR                  SS5        U R                  UR                  S5      SS/5        U R                  UR                  S5      SS/5        g)rm   r&   ÚlemurÚpandar   rn   ro   Nrp   r_   s     r!   rq   Ú%UnicodeHeadersTests.test_addRawHeader°  s~   € ô ‹IˆØ	�‰�v˜wÔ'Ø×Ñ˜Ÿ™¨Ó0°7°)Ô<Ø	�‰�v˜wÔ'Ø×Ñ˜Ÿ™¨Ó0°7¸GÐ2DÔEØ×Ñ˜Ÿ™¨Ó1°H¸hÐ3GÕHr$   c                óT   • U R                  [        5       R                  S5      5        g)rt   r&   Nru   r   s    r!   rw   Ú/UnicodeHeadersTests.test_getRawHeadersNoDefault»  s   € ð
 	×Ñœ'›)×1Ñ1°&Ó9Õ:r$   c                óD  • [        5       n[        5       nU R                  UR                  SU5      U5        U R                  UR                  SS5      S5        U R	                  UR                  SS/5      S/5        U R	                  UR                  SS/5      S/5        g)rz   r&   Nrð   )r   r{   r|   rJ   r   r}   s      r!   r   Ú2UnicodeHeadersTests.test_getRawHeadersDefaultValueÂ  sŠ   € ô
 ‹IˆÜ“(ˆØ×Ñ˜QŸ_™_¨V°WÓ=¸wÔGØ×Ñ˜QŸ_™_¨V°TÓ:¸DÔAØ×Ñ˜Ÿ™¨°$°Ó8¸4¸&ÔAØ×ÑØ�O‰O˜F ] OÓ4ØˆOõ	
r$   c                óÚ   • [        5       nS/nUR                  SU5        U R                  UR                  SU5      S   [        5        U R                  UR                  SU5      S/5        g)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ƒ   r‚   Úkeyr   r1   N)r   rG   r„   rJ   Ústrr   r}   s      r!   r†   Ú>UnicodeHeadersTests.test_getRawHeadersWithDefaultMatchingValueÑ  s]   € ô ‹IˆØ�*ˆØ	�‰˜ Ô(Ø×Ñ˜aŸo™o¨e°WÓ=¸aÑ@Ä#ÔFØ×Ñ˜Ÿ™¨°Ó8¸7¸)ÕDr$   c                óN  • [        5       nUR                  SS/5        U R                  UR                  S5      S/5        U R                  UR                  S5      S/5        U R                  UR                  S5      S/5        U R                  UR                  S5      S/5        g)r‰   r&   r  rì   r   rn   r   NrŠ   r_   s     r!   r‹   Ú&UnicodeHeadersTests.test_getRawHeadersÝ  s‡   € ô
 ‹IˆØ	�‰˜  	Ô*Ø×Ñ˜Ÿ™¨Ó0°7°)Ô<Ø×Ñ˜Ÿ™¨Ó0°7°)Ô<Ø×Ñ˜Ÿ™¨Ó1°H°:Ô>Ø×Ñ˜Ÿ™¨Ó1°H°:Õ>r$   c                ó>  • [        5       nUR                  SS/5        U R                  UR                  S5      5        U R                  UR                  S5      5        U R                  UR                  S5      5        U R                  UR                  S5      5        g)rŽ   r&   r  rì   r   r   Nr�   r_   s     r!   r�   Ú&UnicodeHeadersTests.test_hasHeaderTrueé  so   € ô
 ‹IˆØ	�‰˜  	Ô*Ø�‰˜Ÿ™ FÓ+Ô,Ø�‰˜Ÿ™ FÓ+Ô,Ø�‰˜Ÿ™ GÓ,Ô-Ø�‰˜Ÿ™ GÓ,Õ-r$   c                óT   • U R                  [        5       R                  S5      5        g)r“   r&   Nr”   r   s    r!   r–   Ú'UnicodeHeadersTests.test_hasHeaderFalseõ  s   € ð
 	×Ñœ›×,Ñ,¨VÓ4Õ5r$   c                ó(  • [        5       nUR                  SS/5        U R                  UR                  S5      5        UR	                  S5        U R                  UR                  S5      5        U R                  UR                  S5      5        UR                  SS/5        U R                  UR                  S5      5        UR	                  S5        U R                  UR                  S5      5        U R                  UR                  S5      5        g)	r™   rÉ   r  r]   rÊ   r  ÚBarr\   Nrš   r_   s     r!   rœ   Ú%UnicodeHeadersTests.test_removeHeaderü  sÉ   € ô ‹Iˆà	�‰˜ ˜yÔ)Ø�‰˜Ÿ™ EÓ*Ô+Ø	�‰�uÔØ×Ñ˜Ÿ™ UÓ+Ô,Ø×Ñ˜Ÿ™ VÓ,Ô-à	�‰˜ ˜yÔ)Ø�‰˜Ÿ™ EÓ*Ô+Ø	�‰�uÔØ×Ñ˜Ÿ™ UÓ+Ô,Ø×Ñ˜Ÿ™ VÓ,Õ-r$   c                óŒ   • [        5       nUR                  S5        U R                  [        UR	                  5       5      / 5        g)rŸ   r&   Nr    r_   s     r!   r¡   Ú0UnicodeHeadersTests.test_removeHeaderDoesntExist  s5   € ô
 ‹IˆØ	�‰�vÔØ×Ñœ˜a×0Ñ0Ó2Ó3°RÕ8r$   c                ó  • [        5       nUR                  SS/5        UR                  SS/5        UR                  SS/5        UR                  5        VVs1 s H  u  p#U[        U5      4iM     nnnU R	                  U1 Sk5        gs  snnf )	r¤   r&   Úlemursr,   zbasic aksljdlk=r'   Úkjdfdfgdfgnsd>   r¨   ©r   )s   kjdfdfgdfgnsdr§   Nr©   r«   s        r!   r¯   Ú)UnicodeHeadersTests.test_getAllRawHeaders  s„   € ô ‹IˆØ	�‰˜  
Ô+Ø	�‰Ð*Ð->Ð,?Ô@Ø	�‰˜¨Ð'8Ô9à01×0BÑ0BÔ0DÔEÒ0D©¨�qœ% ›(“mÑ0Dˆ
ÑEà×ÑØòõ	
ùó Fs   ÁBc                ó0  • [        5       nUR                  SS/5        [        5       nUR                  SS/5        [        5       nUR                  SSS/5        U R                  X5        U R                  X5        U R                  X5        [        5       nUR                  SS/5        [        5       nUR                  SS/5        [        5       nUR                  SSS/5        U R                  X5        U R                  X%5        U R                  X65        g)r²   rÉ   r  r  r]   ro   rn   Nr³   )r    rµ   r¶   r·   Ú
firstBytesÚsecondBytesÚ
thirdBytess          r!   r¸   Ú*UnicodeHeadersTests.test_headersComparison-  sö   € ô
 “	ˆØ×Ñ˜E G 9Ô-Ü“ˆØ×Ñ˜U W IÔ.Ü“	ˆØ×Ñ˜E G¨WÐ#5Ô6à×Ñ˜Ô&Ø×Ñ˜Ô'Ø×Ñ˜EÔ)ô “Yˆ
Ø× Ñ  ¨(¨Ô4Ü“iˆØ×!Ñ! &¨8¨*Ô5Ü“Yˆ
Ø× Ñ  ¨(°GÐ)<Ô=à×Ñ˜Ô+Ø×Ñ˜Ô-Ø×Ñ˜Õ+r$   c                ó”   • [        5       nU R                  US5        U R                  U[        5       5        U R                  US5        g)r»   r;   rÉ   Nr¼   r_   s     r!   r½   Ú(UnicodeHeadersTests.test_otherComparisonI  s=   € ô
 ‹IˆØ×Ñ˜A˜rÔ"Ø×Ñ˜Aœv›xÔ(Ø×Ñ˜A˜uÕ%r$   c           
     ó¸   • SnSnSnSnSnSU-   nSU-   nU R                  [        [        XU/05      5      SR                  XEUR	                  S5      5      5        g	)
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'z'bar\xe2\x98\x83'ÚbzHeaders({{{}: [{}, {!r}]}})Úutf8N)r   rÆ   r   Úformatr   )r    rÉ   rÊ   rË   Ú
fooEncodedÚ
barEncodeds         r!   rÌ   ÚUnicodeHeadersTests.test_reprS  so   € ð ˆØˆØˆØˆ
Ø+ˆ
Ø˜:Ñ%ˆ
Ø˜:Ñ%ˆ
Ø×ÑÜ”˜# S˜zÐ*Ó+Ó,Ø)×0Ñ0Ø¨¯
©
°6Ó(:óõ	
r$   c                ó¶   • SnSnSnSnSn " S S[         5      nU R                  [        U" XU/05      5      SU< S	U< S
UR                  S5      < S35        g)rÒ   rÉ   r'  rË   zb'Foo'zb'bar\xe2\x98\x83'c                  ó   • \ rS rSrSrg)Ú;UnicodeHeadersTests.test_subclassRepr.<locals>.FunnyHeadersir  r;   NrÕ   r;   r$   r!   rÖ   r0  r  r×   r$   rÖ   rØ   rÂ   rÃ   r)  rÄ   N)r   r   rÆ   r   )r    rÉ   rÊ   rË   r+  r,  rÖ   s          r!   rÙ   Ú%UnicodeHeadersTests.test_subclassReprg  sb   € ð
 ˆØˆØˆØˆ
Ø,ˆ
ô	œ7ô 	ð 	×ÑÜ‘˜s¨# JÐ/Ó0Ô1ã›: s§z¡z°&Ö'9ð;õ	
r$   c                óB  • [        5       nUR                  SS/5        UR                  5       nU R                  UR	                  S5      S/5        U R                  UR	                  S5      S/5        UR                  SS5        U R                  UR	                  S5      S/5        U R                  UR	                  S5      S/5        UR                  SS5        U R                  UR	                  S5      SS/5        U R                  UR	                  S5      SS/5        g	)
rÜ   r&   u   fooâ˜ƒr   s   fooâ˜ƒrÊ   rì   rÀ   r\   NrÝ   rß   s      r!   rà   ÚUnicodeHeadersTests.test_copy{  sù   € ô ‹IˆØ	�‰˜  Ô.Ø�F‰F‹Hˆð 	×Ñ˜Ÿ™¨Ó0°;°-Ô@Ø×Ñ˜Ÿ™¨Ó1Ð4FÐ3GÔHð 	
�‰�v˜uÔ%ð 	×Ñ˜Ÿ™¨Ó0°;°-Ô@Ø×Ñ˜Ÿ™¨Ó1Ð4FÐ3GÔHð 	
�‰�v˜vÔ&ð 	×Ñ˜Ÿ™¨Ó0°;ÀÐ2FÔGØ×Ñ˜Ÿ™¨Ó1Ð4FÈÐ3OÕPr$   r;   Nr<   )r?   r@   rA   rB   rC   rY   ra   rj   rô   rù   rü   r  rq   rw   r   r†   r‹   r�   r–   rœ   r¡   r¯   r¸   r½   rÌ   rÙ   rà   rD   r;   r$   r!   rã   rã   N  s|   † ñôNô
:ôDô "ôPô ,ô"Kô	Iô;ô
ô
Eô
?ô
.ô6ô.ô$9ô
ô,,ô8&ô
ô(
÷(Qr$   rã   c                  ó,   • \ rS rSrSrSS jrSS jrSrg)ÚMixedHeadersTestsi˜  za
Tests for L{Headers}, mixing L{bytes} and L{str} arguments for methods
where that is permitted.
c                óè   • [        5       nUR                  SS5        UR                  SS5        U R                  UR                  S5      S/5        U R                  UR                  S5      S/5        g)z<
L{Headers.addRawHeader} accepts mixed L{str} and L{bytes}.
ó   bytesr  ó   Bytesó   strÚStrr…   Nrp   r_   s     r!   rq   Ú#MixedHeadersTests.test_addRawHeaderž  s]   € ô ‹IˆØ	�‰�x Ô'Ø	�‰�u˜hÔ'à×Ñ˜Ÿ™¨Ó2°V°HÔ=Ø×Ñ˜Ÿ™¨Ó/°'°Õ;r$   c                óÈ  • [        5       nUR                  SS/5        UR                  SS/5        UR                  SSS/5        UR                  SSS/5        U R                  UR                  S5      S/5        U R                  UR                  S5      S/5        U R                  UR                  S5      SS/5        U R                  UR                  S	5      S
S/5        g)z=
L{Headers.setRawHeaders} accepts mixed L{str} and L{bytes}.
r7  r  z	mixed-strs   mixed-bytesr8  r:  z	Mixed-Strr…   s   Mixed-Bytesr9  NrŠ   r_   s     r!   rj   Ú$MixedHeadersTests.test_setRawHeaders©  sÃ   € ô ‹IˆØ	�‰˜ 8 *Ô-Ø	�‰˜ ˜wÔ'Ø	�‰˜ h°Ð%6Ô7Ø	�‰˜¨°Ð(9Ô:à×Ñ˜Ÿ™¨Ó2°X°JÔ?Ø×Ñ˜Ÿ™¨Ó/°%°Ô9Ø×Ñ˜Ÿ™¨Ó5¸ÀÐ7GÔHØ×Ñ˜Ÿ™¨Ó8¸6À8Ð:LÕMr$   r;   Nr<   )r?   r@   rA   rB   rC   rq   rj   rD   r;   r$   r!   r5  r5  ˜  s   † ñô
	<÷Nr$   r5  N)rK   r   rL   zSequence[bytes] | Sequence[str]rM   r…   r=   r>   )rC   Ú
__future__r   Útypingr   Útwisted.trial.unittestr   r   Útwisted.web.http_headersr   r   r	   Útwisted.web.test.requesthelperr
   r   r   r   rS   rU   rã   r5  r;   r$   r!   Ú<module>rC     sŽ   ðñõ #å ç @ß MÑ M÷ñ ô0
Ð*ô 0
ðf IØð IØ$Cð IØOTð Ià	ô IôF`E˜ô `EôFGQ˜(ô GQôT
N˜õ Nr$   