HEX

File: //usr/lib/python3/dist-packages/twisted/mail/test/__pycache__/test_imap.cpython-310.pyc
o

�b��@s�dZddlZddlZddlZddlZddlZddlZddlmZddl	m
Z
ddlmZddl
mZmZmZmZddlmZddlmZdd	lmZmZdd
lmZddlmZmZmZddlm Z dd
l!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;m<Z<ddl=m>Z>m?Z?ddl@mAZAmBZBz
ddlCmDZDmEZEWn
eFy�dZDdZEYnwdd�ZGGdd�deB�ZHGdd�d�ZIGdd �d eA�ZJGd!d"�d"eA�ZKGd#d$�d$eB�ZLee,jMe,jNe,jO�Gd%d&�d&��ZPee,jMe,jN�Gd'd(�d(��ZQGd)d*�d*e,jR�ZSGd+d,�d,eSe,jT�ZUGd-d.�d.e,jV�ZWGd/d0�d0e,jX�ZYGd1d2�d2�ZZGd3d4�d4eZeB�Z[Gd5d6�d6eA�Z\Gd7d8�d8eZeB�Z]ee"�Gd9d:�d:��Z^Gd;d<�d<�Z_Gd=d>�d>eZeB�Z`Gd?d@�d@eB�ZaGdAdB�dBeZeB�ZbGdCdD�dDeB�ZcGdEdF�dFe,jX�ZdGdGdH�dHeZeB�ZeGdIdJ�dJ�ZfGdKdL�dLef�ZgGdMdN�dNegeA�ZhGdOdP�dPegeA�ZiGdQdR�dRefeA�ZjGdSdT�dTefeA�ZkGdUdV�dVefeA�ZlGdWdX�dXefeB�ZmGdYdZ�dZefeA�ZnGd[d\�d\efeA�ZoGd]d^�d^e,jV�Zpee,jq�Gd_d`�d`e8jr��ZsGdadb�dbeBeZ�ZtGdcdd�ddeB�ZuGdedf�dfeBeZ�ZvGdgdh�dheZeB�Zwee,jx�Gdidj�djeBeZ��ZyGdkdl�dl�Zzee,j{�Gdmdn�dn��Z|ee,j}�Gdodp�dp��Z~Gdqdr�dreB�ZeeDds�ee'��e(d�dt�Gdudv�dveZeB���Z�Gdwdx�dxeP�Z�Gdydz�dzeZeB�Z�Gd{d|�d|eB�Z�Gd}d~�d~�Z�Gdd��d�eB�Z�Gd�d��d�eB�Z�Gd�d��d��Z�Gd�d��d�e�eA�Z�Gd�d��d�e�eB�Z�Gd�d��d�eA�Z�dS)�z"
Test case for twisted.mail.imap4
�N)�OrderedDict��BytesIO)�chain)�List�Optional�Tuple�Type)�skipIf)�implementer)�verifyClass�verifyObject)�'InMemoryUsernamePasswordDatabaseDontUse)�CramMD5Credentials�IUsernameHashedPassword�IUsernamePassword��UnauthorizedLogin)�IRealm�Portal)�defer�error�
interfaces�reactor)�Clock)�imap4)�
MessageSet)�IChallengeResponse�IClientAuthentication�ICloseableMailboxIMAP)�loopback)�failure�log�util)�	iterbytes�nativeString�
networkString)�StringTransport� StringTransportWithDisconnection)�SynchronousTestCase�TestCase)�ClientTLSContext�ServerTLSContextcCs|fdd�S)NcSs|�S�N�)�result�fr.r.�=/usr/lib/python3/dist-packages/twisted/mail/test/test_imap.py�<lambda>8�zstrip.<locals>.<lambda>r.)r0r.r.r1�strip7�r4c@sveZdZddgddgddgddgd	d
ggZdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Z	dd�Z
dd�Zdd�ZdS)�IMAP4UTF7Tests�Hello world�Hello worldz
Hello & worldsHello &- world�Helloÿworld�Hello&AP8-worlduÿþýüs
&AP8A,gD9APw-u~peter/mail/日本語/台北s~peter/mail/&ZeVnLIqe-/&U,BTFw-cC�"d}|�|�dd�|�d��dS)z�
        Specifying an error policy to C{unicode.encode} with the
        I{imap4-utf-7} codec should produce the same result as not
        specifying the error policy.
        r7�imap4-utf-7�strictN��assertEqual�encode��self�textr.r.r1�test_encodeWithErrorsGs�z$IMAP4UTF7Tests.test_encodeWithErrorscCr;)zO
        Similar to L{test_encodeWithErrors}, but for C{bytes.decode}.
        r8r<r=N�r?�decode�rB�bytesr.r.r1�test_decodeWithErrorsRs�z$IMAP4UTF7Tests.test_decodeWithErrorscCsd}|�|�d�d�dS)z�
        Unicode strings that contain an ampersand (C{&}) can be
        encoded to bytes with the I{imap4-utf-7} codec.
        u
&Hello&½&r<s&-Hello&-&AL0-&-Nr>rAr.r.r1�test_encodeAmpersand[s
�z#IMAP4UTF7Tests.test_encodeAmpersandcCs|�d�d�d�dS)z�
        An I{imap4-utf-7} encoded string that does not shift back to
        ASCII (i.e., it lacks a final C{-}) can be decoded.
        s&AL0r<�½NrE�rBr.r.r1�!test_decodeWithoutFinalASCIIShiftfs�z0IMAP4UTF7Tests.test_decodeWithoutFinalASCIIShiftcCs&t�d�td��}|�|��d�dS)zl
        C{codecs.getreader('imap4-utf-7')} returns the I{imap4-utf-7} stream
        reader class.
        r<r:r9N)�codecs�	getreaderrr?�read)rB�readerr.r.r1�test_getreaderpszIMAP4UTF7Tests.test_getreadercCs2t�}t�d�|�}|�d�|�|��d�dS)zl
        C{codecs.getwriter('imap4-utf-7')} returns the I{imap4-utf-7} stream
        writer class.
        r<r9r:N)rrN�	getwriter�writer?�getvalue)rB�output�writerr.r.r1�test_getwriterxs
zIMAP4UTF7Tests.test_getwritercCs&|jD]
\}}|�|�d�|�qdS)z�
        The I{imap4-utf-7} can be used to encode a unicode string into a byte
        string according to the IMAP4 modified UTF-7 encoding rules.
        r<N)�testsr?r@�rB�inputrVr.r.r1�test_encode���zIMAP4UTF7Tests.test_encodecCs&|jD]
\}}|�||�d��qdS)z�
        The I{imap4-utf-7} can be used to decode a byte string into a unicode
        string according to the IMAP4 modified UTF-7 encoding rules.
        r<N)rYr?rFrZr.r.r1�test_decode�r]zIMAP4UTF7Tests.test_decodecCs|ttdd�tdd��D]}t|���}|�|t|��d��|�t|�|�d��q|�d�d�d�|�d�d�d�dS)	z�
        The IMAP4 modified UTF-7 implementation encodes all printable
        characters which are in ASCII using the corresponding ASCII byte.
        � �&�'�r<�&s&-N)r�range�chrr@r?rF)rB�o�charbyter.r.r1�test_printableSingletons�sz'IMAP4UTF7Tests.test_printableSingletonsN)
�__name__�
__module__�__qualname__rYrDrIrJrMrRrXr\r^rhr.r.r.r1r6;s$��	

r6c@�,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�BufferingConsumercC�
g|_dSr-)�bufferrLr.r.r1�__init__��
zBufferingConsumer.__init__cCs$|j�|�|jr|j��dSdSr-)ro�append�consumer�resumeProducingrGr.r.r1rT�s�zBufferingConsumer.writecCs||_|j��dSr-)rsrt)rBrs�	streamingr.r.r1�registerProducer��z"BufferingConsumer.registerProducercCs
d|_dSr-)rsrLr.r.r1�unregisterProducer�rqz$BufferingConsumer.unregisterProducerN)rirjrkrprTrvrxr.r.r.r1rm�s
rmc@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�MessageProducerTestscsrd�t�}d|d<d|d<d|d<d|d	<t|d
d�dd�}t��t�|������}����fdd
�}|�|�S)NsThis is body text.  Rar.�sender@host�from�recipient@domain�to�booga booga boo�subject�
text/plain�content-typer.�{cs(��|����d��j�d��dS)N�sf{119}
From: sender@host
To: recipient@domain
Subject: booga booga boo
Content-Type: text/plain

)�assertIdenticalr?�joinro�r/��body�c�prBr.r1�
cbProduced�s
��z7MessageProducerTests.testSinglePart.<locals>.cbProduced�r�FakeyMessagermr�MessageProducer�beginProducing�addCallback)rB�headers�msg�dr�r.r�r1�testSinglePart�s


z#MessageProducerTests.testSinglePartc
s�d}d�t�}d|d<d|d<d|d<d	|d
<t�}d|d<d|d
<t|d
d|dt|d
d�dd�g�}t��t�|������}����fdd�}|�|�S)Nr��&Contained body message text.  Squarge.rzr{r|r}r~r�%multipart/alternative; boundary="xyz"r��this is subject textr�r.r�c�,��|����d��j�d�d�dS)Nr�s�{239}
From: sender@host
To: recipient@domain
Subject: booga booga boo
Content-Type: multipart/alternative; boundary="xyz"


--xyz
Subject: this is subject text
Content-Type: text/plain

�
--xyz--
��failUnlessIdenticalr?r�ror��r��	innerBodyr�rBr.r1r��s

�
��z<MessageProducerTests.testSingleMultiPart.<locals>.cbProducedr��rB�	outerBodyr��innerHeadersr�r�r�r.r�r1�testSingleMultiPart�s.�	


z(MessageProducerTests.testSingleMultiPartcs�d}d�d�t�}d|d<d|d<d|d	<d
|d<t�}d|d	<d
|d<t�}d|d	<d|d<t|dd|dt|dd�dd�t|dd�dd�g�}t��t�|������}�����fdd�}|�|�S)Nr�r��.Secondary <i>message</i> text of squarge body.rzr{r|r}r~rr�r�r�r��<b>this is subject</b>�	text/htmlr.r�cs4��|����d��j�d�d�d�dS)Nr�s�{354}
From: sender@host
To: recipient@domain
Subject: booga booga boo
Content-Type: multipart/alternative; boundary="xyz"


--xyz
Subject: this is subject text
Content-Type: text/plain

sE
--xyz
Subject: <b>this is subject</b>
Content-Type: text/html

r�r�r��r��
innerBody1�
innerBody2r�rBr.r1r�s

�
�
�
��z>MessageProducerTests.testMultipleMultiPart.<locals>.cbProducedr�)rBr�r�r��
innerHeaders2r�r�r�r.r�r1�testMultipleMultiPart�s:��


z*MessageProducerTests.testMultipleMultiPartc
s�d}d�t�}d|d<d|d<d|d<d	|d
<t�}d|d<d|d
<t|d
d|dt|d
d�dd�g�}t��t�|��dd��_����}����fdd�}|�|�S)z>
        A boundary is generated if none is provided.
        r�r�rzr{r|r}r~r�multipart/alternativer�r�r�r.Nr�cSs
t�d�S)Nz$aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa)�uuid�UUIDr.r.r.r1r2K�
z?MessageProducerTests.test_multiPartNoBoundary.<locals>.<lambda>cr�)Nr�s	{341}
From: sender@host
To: recipient@domain
Subject: booga booga boo
Content-Type: multipart/alternative; boundary="----=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"


------=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Subject: this is subject text
Content-Type: text/plain

s-
------=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa--
r�r�r�r.r1r�Os

���zAMessageProducerTests.test_multiPartNoBoundary.<locals>.cbProduced)rr�rmrr��_uuid4r�r�r�r.r�r1�test_multiPartNoBoundary1s0�	



z-MessageProducerTests.test_multiPartNoBoundaryc
s�d}d�t�}d|d<d|d<d|d<d	|d
<t�}d|d<d|d
<t|d
d|dt|d
d�dd�g�}t��t�|������}����fdd�}|�|�S)z>
        A boundary without does not have them added.
        r�r�rzr{r|r}r~rz#multipart/alternative; boundary=xyzr�r�r�r.Nr�cr�)Nr�s�{237}
From: sender@host
To: recipient@domain
Subject: booga booga boo
Content-Type: multipart/alternative; boundary=xyz


--xyz
Subject: this is subject text
Content-Type: text/plain

r�r�r�r�r.r1r��s
���z?MessageProducerTests.test_multiPartNoQuotes.<locals>.cbProducedr�r�r.r�r1�test_multiPartNoQuotesfs.�	


z+MessageProducerTests.test_multiPartNoQuotesN)rirjrkr�r�r�r�r�r.r.r.r1ry�s-65ryc@�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&S)'�MessageSetTestsz"
    Tests for L{MessageSet}.
    cCst�}t�}|�||�|�|d�|d}|�t|�d�|�t|�dg�|d}|�t|�d�|�t|�gd��|d}|�||�|�t||�gd��|�d�|�t|�d�|�t|�gd��|�||�|�d	d
�|�t|�d�|�t|�gd��d
S)a4
        Test the following properties of L{MessageSet} addition and
        equality:

            1. Two empty L{MessageSet}s are equal to each other;

            2. A L{MessageSet} is not equal to any other object;

            2. Adding a L{MessageSet} and another L{MessageSet} or an
               L{int} representing a single message or a sequence of
               L{int}s representing a sequence of message numbers
               produces a new L{MessageSet} that:

            3. Has a length equal to the number of messages within
               each sequence of message numbers;

            4. Yields each message number in ascending order when
               iterated over;

            6. L{MessageSet.add} with a single message or a start and
               end message satisfies 3 and 4 above.
        r.��r��r��r��r���)r�r�r�r����)r�r�r�r�r�r�r�N)rr?�assertNotEqual�len�list�add)rB�m1�m2r.r.r1�!test_equalityIterationAndAddition�s(
z1MessageSetTests.test_equalityIterationAndAdditioncCs|�tttdd��dS)z�
        A L{MessageSet} that has a range that ends with L{None} raises
        a L{TypeError} when its length is requested.
        r�N)�assertRaises�	TypeErrorr�rrLr.r.r1�test_lengthWithWildcardRange��z,MessageSetTests.test_lengthWithWildcardRangecCsttdd��dS)zD
        L{MessageSet.__repr__} does not raise an exception
        r�r�N)�reprrrLr.r.r1�test_reprSanity�szMessageSetTests.test_reprSanitycCsXt�d�t�d�t�dd�t�dd�g}gd�}t||�D]\}}|�t|�|�qdS)z�
        In a L{MessageSet}, in the presence of wildcards, if the
        highest message id is known, the wildcard should get replaced
        by that high value.
        �*�1:*s3:*r�s*:2)�*�1:*z3:6z2:6N�r�parseIdList�zipr?�str�rB�inputs�outputs�irfr.r.r1�&test_stringRepresentationWithWildcards�s

��z6MessageSetTests.test_stringRepresentationWithWildcardscCsDt�d�t�d�g}ddg}t||�D]\}}|�t|�|�qdS)z�
        In a L{MessageSet}, inverting the high and low numbers in a
        range doesn't affect the meaning of the range.  For example,
        3:2 displays just like 2:3, because according to the RFC they
        have the same meaning.
        �2:3s3:2�2:3Nr�r�r.r.r1�&test_stringRepresentationWithInversion�s���z6MessageSetTests.test_stringRepresentationWithInversioncCs>td�}|�t|�d�|�t|�d�|�t|�dg�dS)z�
        Creating a L{MessageSet} with a single message number adds
        only that message to the L{MessageSet}; its serialized form
        includes only that message number, its length is one, and it
        yields only that message number.
        r��1N�rr?r�r�r��rB�mr.r.r1�"test_createWithSingleMessageNumbersz2MessageSetTests.test_createWithSingleMessageNumbercCsBtdd�}|�t|�d�|�t|�d�|�t|�gd��dS)a?
        Creating a L{MessageSet} with both a start and end message
        number adds the sequence between to the L{MessageSet}; its
        serialized form consists that range, its length is the length
        of the sequence, and it yields the message numbers inclusively
        between the start and end.
        r��
z1:10)
r�r�r�r�r�r�r�r��	r�Nr�r�r.r.r1�test_createWithSequences
z'MessageSetTests.test_createWithSequencecCs:td�}|�t|�d�|�t|�d�|�tt|�dS)z�
        Creating a L{MessageSet} with a single L{None}, representing
        C{*}, adds C{*} to the range; its serialized form includes
        only C{*}, its length is one, but it cannot be iterated over
        because its endpoint is unknown.
        Nr�r�)rr?r�r�r�r�r�r�r.r.r1�test_createWithSingleWildcard!sz-MessageSetTests.test_createWithSingleWildcardcCsHtd�}d|_|�t|�dg�tdd�}d|_|�t|�gd��dS)z�
        Setting L{MessageSet.last} replaces L{None}, representing
        C{*}, with that number, making that L{MessageSet} iterable.
        Nr�r�r�r�)r�lastr?r�)rB�singleMessageReplaced�
rangeReplacedr.r.r1�test_setLastSingleWildcard-s
z*MessageSetTests.test_setLastSingleWildcardcCs4tdd�}|�dd�d|_|�t|�gd��dS)zL
        Setting L{MessageSet.last} replaces L{None} in all ranges.
        r�Nr�r��r�r�r�r�r�)rr�r�r?r�r�r.r.r1�test_setLastWithWildcardRange:s
z-MessageSetTests.test_setLastWithWildcardRangecCsFtdd�}d|_|�t��d|_Wd�dS1swYdS)z9
        L{MessageSet.last} cannot be set twice.
        r�Nr�r�)rr�r��
ValueErrorr�r.r.r1�test_setLastTwiceFailsCs

"�z&MessageSetTests.test_setLastTwiceFailscCshtd�}d|_|�d�|�t|�ddg�|�t|d�gd��|�dd�|�t|�gd��dS)a
        Adding a L{None}, representing C{*}, or a sequence that
        includes L{None} to a L{MessageSet} whose
        L{last<MessageSet.last>} property has been set replaces all
        occurrences of L{None} with the value of
        L{last<MessageSet.last>}.
        r�r�N)Nr�)r�r�r�r�)r�r�r�)rr�r�r?r�)rB�hasLastr.r.r1�test_lastOverridesNoneInAddLs
z+MessageSetTests.test_lastOverridesNoneInAddcCs"tdd�}d|_|�|jd�dS)zF
        Accessing L{MessageSet.last} returns the last value.
        r�Nr�)rr�r?r�r.r.r1�test_getLast_s
zMessageSetTests.test_getLastcCs�t�}|�d�|�t|�dg�t�}|�d�|�t|�d�t�}|�d�|�t|�gd��t�}|�d�|�t|�d�t�}|�tdd��|�t|�gd��dS)z�
        L{MessageSet.extend} accepts as its arugment an L{int} or
        L{None}, or a sequence L{int}s or L{None}s of length two, or
        another L{MessageSet}, combining its argument with its
        instance's existing ranges.
        r�Nr�r�r��NNr�)r�extendr?r�r�)rB�
extendWithInt�extendWithNone�extendWithSequenceOfInts�extendWithSequenceOfNones�extendWithMessageSetr.r.r1�test_extendgs



zMessageSetTests.test_extendcCs�tdd�}tdd�tdd�}|�d|�|�d|�|d}|�t��d|vWd�n1s3wY|d}|�dd�|�t��
d|vWd�dS1sWwYdS)	z�
        A L{MessageSet} contains a number if the number falls within
        one of its ranges, and raises L{TypeError} if any range
        contains L{None}.
        r�r�r�r�r�N)r��r�)r�assertIn�assertNotInr�r�r�)rB�hasFive�doesNotHaveFive�hasFiveButHasNone�hasFiveButHasNoneInSequencer.r.r1�
test_contains�s

�
"�zMessageSetTests.test_containscCs�tdd�}tdd�}||}|tdd�}|�t|d�gd��|�t|d	�gd
��|�t|d�gd��|�t|d
�gd��|�t|d	�gd��|�t|td��gd��dS)z�
        Adding a sequence of message numbers to a L{MessageSet} that
        begins or ends immediately before or after an existing
        sequence in that L{MessageSet}, or overlaps one, merges the two.
        r�r�r�r�r�r�)r�r�)r�r�r�r�)r�r�r�)r�r�)r�r�r�r�)r�r�)r�r�r�r�r�)r�r�r�r�r�r�r�r�r�)r�r�r�r�r�r�r�N)rr?r�)rB�
mergeAfter�mergeBefore�mergeBetweenSequence�mergeBetweenNumberr.r.r1�test_rangesMerged�s

�z!MessageSetTests.test_rangesMergedcCsZ|�tdd�tdd��|�ttdd��gd��tdd�}d|_|�t|�ddg�dS)a�
        Test the C{seq-range} examples from Section 9, "Formal Syntax"
        of RFC 3501::

            Example: 2:4 and 4:2 are equivalent and indicate values
                     2, 3, and 4.

            Example: a unique identifier sequence range of
                     3291:* includes the UID of the last message in
                     the mailbox, even if that value is less than 3291.

        @see: U{http://tools.ietf.org/html/rfc3501#section-9}
        r�r��r�r�r�i�Ni�)r?rr�r�r�r.r.r1�test_seq_rangeExamples�s

z&MessageSetTests.test_seq_rangeExamplescCs�td�tdd�td�tdd�}d|_|�d�d	d
�|D��d�tdd�tdd�}d
|_|�d�dd
�|D��d�dS)a�
        Test the C{sequence-set} examples from Section 9, "Formal
        Syntax" of RFC 3501.  In particular, L{MessageSet} reorders
        and coalesces overlaps::

            Example: a message sequence number set of
                     2,4:7,9,12:* for a mailbox with 15 messages is
                     equivalent to 2,4,5,6,7,9,12,13,14,15

            Example: a message sequence number set of *:4,5:7
                     for a mailbox with 10 messages is equivalent to
                     10,9,8,7,6,5,4,5,6,7 and MAY be reordered and
                     overlap coalesced to be 4,5,6,7,8,9,10.

        @see: U{http://tools.ietf.org/html/rfc3501#section-9}
        r�r�r�r�r�N��,cs��|]}t|�VqdSr-�r���.0r�r.r.r1�	<genexpr>���z<MessageSetTests.test_sequence_setExamples.<locals>.<genexpr>z2,4,5,6,7,9,12,13,14,15r�r�csrr-rr	r.r.r1r�rz4,5,6,7,8,9,10)rr�r?r�)rB�fromFifteenMessages�fromTenMessagesr.r.r1�test_sequence_setExamples�s"�� z)MessageSetTests.test_sequence_setExamplesN)rirjrk�__doc__r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrr.r.r.r1r��s(3

		r�c@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Z d<d=�Z!d>d?�Z"d@dA�Z#dBdC�Z$dDdE�Z%dFdG�Z&dHdI�Z'dJdK�Z(dLdM�Z)dNdO�Z*dPdQ�Z+dRS)S�IMAP4HelperTestszA
    Tests for various helper utilities in the IMAP4 module.
    cCstt�ddgd��dS)zI
        L{imap4.Command}'s C{repr} does not raise an exception.
        sCOMMANDsarg�extraN)r�r�CommandrLr.r.r1�test_commandRepr��z!IMAP4HelperTests.test_commandReprcsbd�t��t��}t�|������}����fdd�}�fdd�}|�|�|�|�|�|�S)Nsxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzcs0��|����dt���fd��j��|S)Ns{%d}
%br�)r�r?r�r�ror���br�r�rBr.r1r��s z6IMAP4HelperTests.test_fileProducer.<locals>.cbProducedcs���|Sr-)rtr�)r�r.r1�cbResume�sz4IMAP4HelperTests.test_fileProducer.<locals>.cbResume)rmrr�FileProducerr�r�)rBr0r�r�rr.rr1�test_fileProducer�s




z"IMAP4HelperTests.test_fileProducercCs�dgd�ddggdgd�gd�gdgd	�gd
�gg}|D]%\}}}t�|d�}|D]
}|�|�|��q)|D]
}|�|�|��q6qdS)N�foo/%gum/bar�zfoo/barzoo/lalagum/barzfoo/gumx/barzfoo/gum/baz�foo/xgum/bar�foo/gum/bar�foo/x%x/bar��foo�barzfuz fuz fuzz	foo/*/bar�foo/xyz/barz
foo/xx/baz)�foo/xyx/bar�
foo/xx/bar�foo/xxxxxxxxxxxxxx/bar�foo/xyz*abc/bar�r#zfoo/abc/barzfoo/xyzab/cbarzfoo/xyza/bcbar�zfoo/xyzabc/barzfoo/xyz/abc/barzfoo/xyz/123/abc/bar�/�r�wildcardToRegexp�assertFalse�match�
assertTrue�rB�cases�wildcard�fail�succeed�xr.r.r1�
test_wildcards*������zIMAP4HelperTests.test_wildcardcCs�dgd�gd�gdgd�gd�gdgd�gd	�gg}|D]'\}}}t�|d�}|D]}|�|�|�|�q)|D]}|�|�|�|�q7qdS)
Nrr)rrz
foo/x/gum/barrr )r$r%r&zfoo/x/x/barr'r(r)r+r0r.r.r1�test_wildcardNoDelim s*������z%IMAP4HelperTests.test_wildcardNoDelimcCsLddd�dfg}|D]\}}t�|�}|�t|�d��t|�d���q
dS)z�
        L{imap4._formatHeaders} accepts a C{dict} of header name/value pairs and
        returns a string representing those headers in the standard multiline,
        C{":"}-separated format.
        �Value1�Value2)�Header1�Header2s"Header2: Value2
Header1: Value1
TN)r�_formatHeadersr?�sorted�
splitlines)rBr1r[�expectedrVr.r.r1�test_headerFormatter:s��
��z%IMAP4HelperTests.test_headerFormattercCs�gd�}ddgddggd�gd�gd�gd�gd	�gd
�gd�gd�d
gddgdggd�dggd�dggd�dgg}gd�}|D]}|�tjtj|�q@t||�D]
\}}|�t�|�|�qQdS)N)sHello WorldsHello "World!"sWorld "Hello" "How are you?"s"Hello world" How "are you?"sfoo bar "baz buz" NILsfoo bar "baz buz" "NIL"sfoo NIL "baz buz" barsfoo "NIL" "baz buz" bars"NIL" bar "baz buz" foosoo \"oo\" oos"oo \"oo\" oo"�oo 	 oos	"oo 	 oo"�oo \t oos
"oo \t oo"�oo \o oo�
"oo \o oo"rCrD�Hello�WorldsWorld!)rFrEsHow are you?)r8sHowsare you?)�foo�bar�baz buzN)rGrHrI�NIL)rGNrIrH)rGrJrIrH)rJrHrIrG)�oos"oo"rK�
oo "oo" oorKrA)rKs\trKrB)rK�\orKrC)s"mismatched quotesmismatched quote"smismatched"quotes"oops here is" another")r�r�MismatchedQuoting�splitQuotedr�r?)rBr1�answers�errors�s�caser?r.r.r1�test_quotedSplitterMs6��z$IMAP4HelperTests.test_quotedSplittercCs�gd�gd�gd�ddgdgd�dgddgd	�gd
ddd
gd�d
ddd
g	dgd�ddgg}d
ggd�dgdgddgdgddggddgdgddgdgg}t||�D]
\}}|�t�|�|�qPdS)N)�a�b�c�d�e)
rU� �"rVrWrZr[rZrXrY)rUrVrWrXrYrU)rVrWrXrV)rWrXrYr[rZ)r[rZrVrWrZrZr[sabcde)rUsbc �desabcr\sbcdsabscdesa s es bc  )r�r?r�collapseStrings)rBr1rPrSr?r.r.r1�test_stringCollapser�s&�


�
�z%IMAP4HelperTests.test_stringCollapsercsd�dgd�}�fdd�}|dt|�|fddgd	�g|g�|d
ddgd
ddddddgd�ggd�ggd�ggd�ggd�gd�gdddg
dddddgddddd gg
�|d!d"g�|d#d$g�|d%d&g�|d'd(g�|d'd(g�|d)d*d+g�|d)d*d+g�dS),N�
sxxr�cst�|�}��||g�dSr-)r�parseNestedParensr?)rSr?�parsedrLr.r1�check�s
z0IMAP4HelperTests.test_parenParser.<locals>.checks8(BODY.PEEK[HEADER.FIELDS.NOT (subject bcc cc)] {%d}
%b)�	BODY.PEEKsHEADER.FIELDS.NOT)ssubjectsbccsccs(FLAGS (\Seen) INTERNALDATE "17-Jul-1996 02:44:25 -0700" RFC822.SIZE 4286 ENVELOPE ("Wed, 17 Jul 1996 02:23:25 -0700 (PDT)" "IMAP4rev1 WG mtg summary and minutes" (("Terry Gray" NIL gray cac.washington.edu)) (("Terry Gray" NIL gray cac.washington.edu)) (("Terry Gray" NIL gray cac.washington.edu)) ((NIL NIL imap cac.washington.edu)) ((NIL NIL minutes CNRI.Reston.VA.US) ("John Klensin" NIL KLENSIN INFOODS.MIT.EDU)) NIL NIL <B27397-0100000@cac.washington.edu>) BODY (TEXT PLAIN (CHARSET US-ASCII) NIL NIL 7BIT 3028 92))�FLAGSs\SeensINTERNALDATEs17-Jul-1996 02:44:25 -0700sRFC822.SIZEs4286sENVELOPEs%Wed, 17 Jul 1996 02:23:25 -0700 (PDT)s$IMAP4rev1 WG mtg summary and minutes)s
Terry GrayNsgray�cac.washington.edu)NNsimapre)NNsminutessCNRI.Reston.VA.US)sJohn KlensinNsKLENSINsINFOODS.MIT.EDUs#<B27397-0100000@cac.washington.edu>�BODYsTEXT�PLAIN�CHARSETsUS-ASCIIs7BITs3028s92s("oo \"oo\" oo")rLs("oo \\ oo")soo \\ oos("oo \ oo")soo \ oos	("oo \o")soo \os(oo \o)rKrM)r�r�)rBrRrbr.rLr1�test_parenParser�s^
�
�����2z!IMAP4HelperTests.test_parenParserc
Cs�gd�gd�gd�gd�gd�gd�gd�gd�gd	�g	}|D]5\}}}|�d
�}t��}|�|�|�t|j�d�|�t|jdt	||���|�t
|jd�|�qdS)
N)�ENVELOPE�Envelope�envelope)�FLAGS�Flags�flags)�INTERNALDATE�InternalDate�internaldate)�
RFC822.HEADER�RFC822Headerz
rfc822.header)�RFC822.SIZE�
RFC822Sizezrfc822.size)�RFC822.TEXT�
RFC822Textzrfc822.text)�RFC822ry�rfc822)�UIDr{�uid)�
BODYSTRUCTURE�
BodyStructure�
bodystructure�asciir�r)r@r�_FetchParser�parseStringr?r�r/r/�
isinstance�getattrr�)rBr1�inp�outp�asStringr�r.r.r1�test_fetchParserSimple�s$�

�z'IMAP4HelperTests.test_fetchParserSimplecCs�ddgd�fgddgd�fgddgd	�fgg}|D]2\}}t��}|�|�|�t|j�|d
�dd�|jD�}|��|d
��|�||d
�qdS)NsALLr�)�flags�internaldate�rfc822.size�envelopesFULLr�)r�r�r�r�sbodysFASTr�)r�r�r�rcSsg|]}t|����d��qS)r�)r��lowerr@)r
�tokenr.r.r1�
<listcomp>sz;IMAP4HelperTests.test_fetchParserMacros.<locals>.<listcomp>r�)rr�r�r?r�r/�sort)rBr1r�r�r��expectedResultr.r.r1�test_fetchParserMacross
��	
�z'IMAP4HelperTests.test_fetchParserMacroscCs�tj}|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�|jdj
d�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdjd�|�t|jd�d	�|�}|�d
�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj
|j
��|�|jdj
jd�|�|jdj
jd�|�|jdjd�|�t|jd�d�|�}|�d
�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj
|j
��|�|jdj
jd�|�|jdj
jd�|�|jdjd�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj
|j
��|�|jdj
jd�|�|jdj
jgd��|�|jdjd�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj
|j
��|�|jdj
jd�|�|jdj
jgd��|�|jdjd�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj
|j
��|�|jdj
jd�|�|jdj
jgd��|�|jdjd�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj|j��|�|jdjd�|�|jdjd�|�|jdjd�|�|jdjd�|�t|jd�d�|�}|�d�|�t|j�d�|�t|jd|j��|�|jdj	d�|�t|jdj
|j
��|�|jdjd�|�|jdj
jddg�|�|jdjd�|�|jdjd�|�|jdjd�|�t|jd�d�dS)Nrfr�rF�BODYrcTsBODY[]zBODY[]sBODY[HEADER]r.zBODY[HEADER]sBODY.PEEK[HEADER]s+BODY[HEADER.FIELDS (Subject Cc Message-Id)])sSUBJECTsCC�
MESSAGE-IDs0BODY.PEEK[HEADER.FIELDS (Subject Cc Message-Id)]s4BODY.PEEK[HEADER.FIELDS.NOT (Subject Cc Message-Id)]s/BODY[HEADER.FIELDS.NOT (Subject Cc Message-Id)]sBODY[1.MIME]<10.50>�rr��2s?BODY.PEEK[1.3.9.11.HEADER.FIELDS.NOT (Message-Id Date)]<103.69>)rr�r�r�r�sDATE�g�Es:BODY[1.3.9.11.HEADER.FIELDS.NOT (Message-Id Date)]<103.69>)rr�r�r?r�r/r/r��Body�peek�headerr��empty�Header�negate�fieldsrH�mime�MIME�part�partialBegin�
partialLength)rB�Pr�r.r.r1�test_fetchParserBodys�





�
�
�
��z%IMAP4HelperTests.test_fetchParserBodycCs|t��}|�d�|�t|j�d�|�|jdjd�|�|jd|j�|�|jdj	|j
�|�t|jd�d�dS)z�
        Parsing a C{BODY} whose C{HEADER} values require quoting
        results in a object that perserves that quoting when
        serialized.
        sBODY[HEADER.FIELDS ((Quoted)]r�rFsBODY[HEADER.FIELDS ("(Quoted")]N)rr�r�r?r�r/r��assertIsInstancer�r�r�rH�rBr�r.r.r1�test_fetchParserQuotedHeader�s
z-IMAP4HelperTests.test_fetchParserQuotedHeadercCs&t��}|�d�|�t|j��dS)z=
        Parsing an empty string results in no data.
        r�N)rr�r�r-r�r/r�r.r.r1�test_fetchParserEmptyString�s
z,IMAP4HelperTests.test_fetchParserEmptyStringcC�t��}|�t|jd�dS)z\
        Parsing a string with an unknown attribute raises an
        L{Exception}.
        sUNKNOWNN�rr�r��	Exceptionr�r�r.r.r1� test_fetchParserUnknownAttribute��z1IMAP4HelperTests.test_fetchParserUnknownAttributecCr�)zf
        Parsing a string that prematurely ends in whitespace raises an
        L{Exception}.
        sBODY[HEADER.FIELDS  Nr�r�r.r.r1�0test_fetchParserIncompleteStringEndsInWhitespace�r�zAIMAP4HelperTests.test_fetchParserIncompleteStringEndsInWhitespacecCr�)z
        Parsing a string that contains an unexpected character rather
        than whitespace raises an L{Exception}.
        sBODY[HEADER.FIELDS!]Nr�r�r.r.r1�"test_fetchParserExpectedWhitespace�r�z3IMAP4HelperTests.test_fetchParserExpectedWhitespacecCs|t��}|�d�|�t|j�d�|�|jd|j�|�|jdjd�|�|jdj	|j
�|�t|jd�d�dS)z:
        A C{BODY} can contain a C{TEXT} section.
        s
BODY[TEXT]r�rFN)rr�r�r?r�r/r�r�r�rC�TextrHr�r.r.r1�test_fetchParserTextSection�s
z,IMAP4HelperTests.test_fetchParserTextSectioncCr�)z[
        Parsing a C{BODY} with an unknown section raises an
        L{Exception}.
        s
BODY[UNKNOWN]Nr�r�r.r.r1�test_fetchParserUnknownSection�r�z/IMAP4HelperTests.test_fetchParserUnknownSectioncC�4t��}|�t|jd�t��}|�t|jd�dS)ze
        Parsing a C{BODY} with an unterminated section list raises an
        L{Exception}.
        sBODY[HEADERsBODY[HEADER.FIELDS (SUBJECT)Nr�r�r.r.r1�#test_fetchParserMissingSectionClose�sz4IMAP4HelperTests.test_fetchParserMissingSectionClosecCr�)z�
        Parsing a C{BODY} whose C{HEADER.FIELDS} list does not begin
        with an open parenthesis (C{(}) or end with a close
        parenthesis (C{)}) raises an L{Exception}.
        sBODY[HEADER.FIELDS Missing)]sBODY[HEADER.FIELDS (Missing]Nr�r�r.r.r1�(test_fetchParserHeaderMissingParentheses�sz9IMAP4HelperTests.test_fetchParserHeaderMissingParenthesescCr�)zk
        Parsing a C{BODY} with a range that lacks a period (C{.})
        raises an L{Exception}.
        sBODY<01>Nr�r�r.r.r1�test_fetchParserDotlessPartial�r�z/IMAP4HelperTests.test_fetchParserDotlessPartialcCr�)z�
        Parsing a C{BODY} with a partial range that's missing its
        closing greater than sign (C{>}) raises an L{EXCEPTION}.
        sBODY<0Nr�r�r.r.r1�test_fetchParserUnclosedPartial�r�z0IMAP4HelperTests.test_fetchParserUnclosedPartialcCs.dddtd�ddg}d}|�t�|�|�dS)Nr!r"�baz�this is a file
�buz�bizs4"foo" "bar" "baz" {16}
this is a file
 "buz" "biz")rr?r�collapseNestedLists)rB�inputStructurerVr.r.r1�
test_files�s�	zIMAP4HelperTests.test_filescCs<dt�d�dtd�dt�d�dg}d}|�t�|�|�dS)	NrGrHsbazr�sthis is
quotedsbuzr�sC"foo" bar "baz" {16}
this is a file
 {15}
this is
quoted buz "")r�DontQuoteMerr?r�rZr.r.r1�test_quoteAvoider�s��z"IMAP4HelperTests.test_quoteAvoidercCs2ddggfg}|D]
\}}|�t�|�|�q	dS)Ns({10}
0123456789)s
0123456789)r?rr`)rBr1rSr?r.r.r1�
test_literalss

��zIMAP4HelperTests.test_literalscCs�tjdd�tjdddd�t�tjdd�tjdd��tjdd�t�tjdd�tjdd�tjdd��t�t�t�tjdd	d
d�tjddd
d�tjddddd�t�tjdd����t�tjdd���g}gd�}t||�D]
\}}|�||�qjdS)Nr�)�flagged)r=�	unflagged�deleted)r��today)�before)�unseen)�new�	yesterdayi�)r=�since�smaller�tuesdayi')r=r��larger)r=r�r�r��spam)rz1:5�r|)�FLAGGEDz(DELETED UNFLAGGED)z(OR FLAGGED DELETED)z(BEFORE "today")z(OR DELETED (OR UNSEEN NEW))z�(OR (NOT (OR (SINCE "yesterday" SMALLER 1000) (OR (BEFORE "tuesday" LARGER 10000) (OR (BEFORE "today" DELETED UNSEEN) (NOT (SUBJECT "spam")))))) (NOT (UID 1:5))))r�Query�Or�Notr�r?)rBr�r��queryr?r.r.r1�test_queryBuilders*

$�����z"IMAP4HelperTests.test_queryBuildercC�tjdd�}|�d|�dS)z�
        When passed the C{keyword} argument, L{imap4.Query} returns an unquoted
        string.

        @see: U{http://tools.ietf.org/html/rfc3501#section-9}
        @see: U{http://tools.ietf.org/html/rfc3501#section-6.4.4}
        �twisted)�keywordz(KEYWORD twisted)N�rr�r?�rBr�r.r.r1�test_queryKeywordFlagWithQuotes>�z0IMAP4HelperTests.test_queryKeywordFlagWithQuotescCr�)z�
        When passed the C{unkeyword} argument, L{imap4.Query} returns an
        unquoted string.

        @see: U{http://tools.ietf.org/html/rfc3501#section-9}
        @see: U{http://tools.ietf.org/html/rfc3501#section-6.4.4}
        r�)�	unkeywordz(UNKEYWORD twisted)Nr�r�r.r.r1�!test_queryUnkeywordFlagWithQuotesIr�z2IMAP4HelperTests.test_queryUnkeywordFlagWithQuotescCs$tjt�dd�d�}|�|d�dS)z�
        When passed a L{MessageSet}, L{imap4.Query} returns a query
        containing a quoted string representing the ID sequence.
        r�N��messagesz(MESSAGES "1:*"))rr�rr?r�r.r.r1�test_queryWithMesssageSetTsz*IMAP4HelperTests.test_queryWithMesssageSetcCstjdd�}|�|d�dS)zl
        When passed an L{int}, L{imap4.Query} returns a query
        containing a quoted integer.
        r�r�z(MESSAGES "1")Nr�r�r.r.r1�test_queryWithInteger\sz&IMAP4HelperTests.test_queryWithIntegercCs|�tjtjtjdd��dS)zq
        An L{imap4.Or} query with less than two arguments raises an
        L{imap4.IllegalQueryError}.
        r�r�N)r�r�IllegalQueryErrorr�r�rLr.r.r1�test_queryOrIllegalQuerydsz)IMAP4HelperTests.test_queryOrIllegalQueryc
Csn|�d|���d�tjd
i|di���|�d|���d�tjd
i|dd�dd�td�D��fi���d	S)z�
        Helper to implement tests for value filtering of KEYWORD and UNKEYWORD
        queries.

        @param keyword: A native string giving the name of the L{imap4.Query}
            keyword argument to test.
        �(z twistedrocks)ztwisted (){%*"\] rocksztwisted %s rocks�csrr-)re)r
�chr.r.r1rrz9IMAP4HelperTests._keywordFilteringTest.<locals>.<genexpr>�!Nr.)r?�upperrr�r�rd)rBr�r.r.r1�_keywordFilteringTestks	�����z&IMAP4HelperTests._keywordFilteringTestcC�|�d�dS)a�
        When passed the C{keyword} argument, L{imap4.Query} returns an
        C{atom} that consists of one or more non-special characters.

        List of the invalid characters:

            ( ) { % * " \ ] CTL SP

        @see: U{ABNF definition of CTL and SP<https://tools.ietf.org/html/rfc2234>}
        @see: U{IMAP4 grammar<http://tools.ietf.org/html/rfc3501#section-9>}
        @see: U{IMAP4 SEARCH specification<http://tools.ietf.org/html/rfc3501#section-6.4.4>}
        r�N�r�rLr.r.r1�test_queryKeywordFlag��
z&IMAP4HelperTests.test_queryKeywordFlagcCr�)a�
        When passed the C{unkeyword} argument, L{imap4.Query} returns an
        C{atom} that consists of one or more non-special characters.

        List of the invalid characters:

            ( ) { % * " \ ] CTL SP

        @see: U{ABNF definition of CTL and SP<https://tools.ietf.org/html/rfc2234>}
        @see: U{IMAP4 grammar<http://tools.ietf.org/html/rfc3501#section-9>}
        @see: U{IMAP4 SEARCH specification<http://tools.ietf.org/html/rfc3501#section-6.4.4>}
        r�Nr�rLr.r.r1�test_queryUnkeywordFlag�r�z(IMAP4HelperTests.test_queryUnkeywordFlagcC�*gd�}|D]}|�tjtj|d�qdS)z|
        Trying to parse an invalid representation of a sequence range raises an
        L{IllegalIdentifierError}.
        )s*:*rGs4:sbar:5�90N�r�r�IllegalIdentifierErrorr��rBr�r[r.r.r1�test_invalidIdListParser�s��z)IMAP4HelperTests.test_invalidIdListParsercCr�)z�
        Zeroes and negative values are not accepted in id range expressions. RFC
        3501 states that sequence numbers and sequence ranges consist of
        non-negative numbers (RFC 3501 section 9, the seq-number grammar item).
        )s0:5s0:0s*:0�0s-3:5s1:-2s-1r�Nr�r�r.r.r1�#test_invalidIdListParserNonPositive�s��z4IMAP4HelperTests.test_invalidIdListParserNonPositivecCsZgd�}tdd�tdd�tdd�tdd�tdd�td�tdd�td�td�td�tdd�tdd�tdd�tdd	�td�tdd�td�tdd�td
d	�tdd�td
�td	d�tdd�g}gd
�}t||�D]
\}}|�t�|�|�qmt||�D]*\}}|dur�|�ttt�|��q�tt�|��}|�||d|�d|�d|���q�dS)zi
        The function to parse sequence ranges yields appropriate L{MessageSet}
        objects.
        )r�s5:*s1:2,5:*r��1s1,2s1,3,5s1:10s1:10,11s	1:5,10:20s1,5:10s1,5:10,15:20s
1:10,15,20:25�4:2r�Nr�r�r�r���r�r�)NNNr�r�r�r�r�r��r��
�r�zlen(z) = z != )rr�r?rr�r�r�r�)rBr�r��lengthsr[r?�Lr.r.r1�test_parseIdList�s2�"�z!IMAP4HelperTests.test_parseIdListcCs|�ttjd�dS)zu
        L{imap4.parseTime} raises L{ValueError} when given a a time
        string whose format is invalid.
        �invalidN�r�r�r�	parseTimerLr.r.r1�test_parseTimeInvalidFormat�sz,IMAP4HelperTests.test_parseTimeInvalidFormatcCs&gd�}|D]
}|�ttj|�qdS)zv
        L{imap4.parseTime} raises L{ValueError} when given a time
        string composed of invalid values.
        )zinvalid-July-2017z2-invalid-2017z2-July-invalidNr)rB�invalidStringsrr.r.r1�test_parseTimeInvalidValues�s�z,IMAP4HelperTests.test_parseTimeInvalidValuescCsJt�}|��|��|��|��|��d�}t�||���}|�	||�dS)z�
        L{imap4.statusRequestHelper} builds a L{dict} mapping the
        requested status names to values extracted from the provided
        L{IMailboxIMAP}'s.
        )�MESSAGES�RECENT�UIDNEXT�UIDVALIDITY�UNSEENN)
�
SimpleMailbox�getMessageCount�getRecentCount�
getUIDNext�getUIDValidity�getUnseenCountr�statusRequestHelper�keysr?)rB�mboxr?r/r.r.r1�test_statusRequestHelpers�z)IMAP4HelperTests.test_statusRequestHelperN),rirjrkrrrr6r7r@rTr^rir�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrr
rr.r.r.r1r�sT:Ot
#
3
rc@s�eZdZUdZgZeeeeee	fe
d<dZdZdZ
dd�Zdd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd)dd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�ZdS)*r�z\Flag1�Flag2z\AnotherSysFlag�LastFlagr�rr�FcC�g|_|jj|_|jj|_dSr-��	listenersrr�addListener�remove�removeListenerrLr.r.r1rp�
zSimpleMailbox.__init__cC�|jSr-�rorLr.r.r1�getFlags$�zSimpleMailbox.getFlagscC�dS)N�*r.rLr.r.r1r'�zSimpleMailbox.getUIDValiditycC�t|j�dS�Nr��r�r�rLr.r.r1r*�zSimpleMailbox.getUIDNextcCr()Nr�r.rLr.r.r1r-r*zSimpleMailbox.getMessageCountcCr()Nr�r.rLr.r.r1r0r*zSimpleMailbox.getRecentCountcCr()Nr�r.rLr.r.r1r3r*zSimpleMailbox.getUnseenCountcCr$r-��rwrLr.r.r1�isWriteable6r'zSimpleMailbox.isWriteablecC�dSr-r.rLr.r.r1�destroy9r*zSimpleMailbox.destroycCr()Nr*r.rLr.r.r1�getHierarchicalDelimiter<r*z&SimpleMailbox.getHierarchicalDelimitercC�vi}d|vr|��|d<d|vr|��|d<d|vr"|��d|d<d|vr,|��|d<d|vr6|��|d<t�|�S)Nrrr
r�rr�rr�getUIDrrr4�rB�names�rr.r.r1�
requestStatus?s
zSimpleMailbox.requestStatusNcCs.|j�||||jf�|jd7_t�d�Sr,�r�rr�mUIDrr4�rB�messagero�dater.r.r1�
addMessageMs
zSimpleMailbox.addMessagecC�Jg}|jD]
}d|dvr|�|�q|D]}|j�|�qdd�|D�S)N�\Deletedr�cS�g|]}|d�qS�r�r.r	r.r.r1r�Y�z)SimpleMailbox.expunge.<locals>.<listcomp>�r�rrr!�rB�deleter�r.r.r1�expungeRs

�zSimpleMailbox.expungecCs
d|_dS�NT)�closedrLr.r.r1�close[rqzSimpleMailbox.closecCr2r-r.�rBr�r|r.r.r1�fetch^�zSimpleMailbox.fetchcCr2r-r.�rBr?r.r.r1r7brPzSimpleMailbox.getUIDcCr2r-r.�rBr�ro�moder|r.r.r1�storefrPzSimpleMailbox.storer-)rirjrkror�rrrHr��int�__annotations__r=r0rLrpr&rrrrrr1r3r4r;rArJrMrOr7rTr.r.r.r1rs.

	rc@s�eZdZUdZdZgZeeee	ee
fed<dZdZ
dZdd�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd(dd�Zd d!�Zd"d#�Zd$d%�Zd&d'�ZdS))�UncloseableMailboxz*
    A mailbox that cannot be closed.
    rr�rr�FcCrr-rrLr.r.r1rpwr#zUncloseableMailbox.__init__cCr$)zB
        The flags

        @return: A sequence of flags.
        r%rLr.r.r1r&|�zUncloseableMailbox.getFlagscCr()zF
        The UID validity value.

        @return: The value.
        r)r.rLr.r.r1r��z!UncloseableMailbox.getUIDValiditycCr+)z:
        The next UID.

        @return: The UID.
        r�r-rLr.r.r1r��zUncloseableMailbox.getUIDNextcCr()zG
        The number of messages.

        @return: The number.
        r�r.rLr.r.r1r�rYz"UncloseableMailbox.getMessageCountcCr()�D
        The recent messages.

        @return: The number.
        r�r.rLr.r.r1r�rYz!UncloseableMailbox.getRecentCountcCr()r[r�r.rLr.r.r1r�rYz!UncloseableMailbox.getUnseenCountcCr$)z`
        The recent messages.

        @return: Whether or not the mailbox is writable.
        r/rLr.r.r1r1�rXzUncloseableMailbox.isWriteablecCr()z'
        Destroy this mailbox.
        Nr.rLr.r.r1r3�szUncloseableMailbox.destroycCr()zU
        Return the hierarchical delimiter.

        @return: The delimiter.
        r*r.rLr.r.r1r4�rYz+UncloseableMailbox.getHierarchicalDelimitercCr5)z�
        Return the mailbox's status.

        @param names: The status items to include.

        @return: A L{dict} of status data.
        rrr
r�rrr6r8r.r.r1r;�s
z UncloseableMailbox.requestStatusNcCs.|j�||||jf�|jd7_t�d�S)a
        Add a message to the mailbox.

        @param message: The message body.

        @param flags: The message flags.

        @param date: The message date.

        @return: A L{Deferred} that fires when the message has been
            added.
        r�Nr<r>r.r.r1rA�s

zUncloseableMailbox.addMessagecCrB)zj
        Delete messages marked for deletion.

        @return: A L{list} of deleted message IDs.
        rCr�cSrDrEr.r	r.r.r1r��rFz.UncloseableMailbox.expunge.<locals>.<listcomp>rGrHr.r.r1rJ�s

�zUncloseableMailbox.expungecCr2r-r.rNr.r.r1rO�rPzUncloseableMailbox.fetchcCr2r-r.rQr.r.r1r7�rPzUncloseableMailbox.getUIDcCr2r-r.rRr.r.r1rT�rPzUncloseableMailbox.storer-)rirjrkrror�rrrHr�rUrVr=r0rLrpr&rrrrrr1r3r4r;rArJrOr7rTr.r.r.r1rWks.

rWc@s&eZdZdZeZdd�Zddd�ZdS)	�AccountWithoutNamespaceszL
    An in-memory account that does not provide L{INamespacePresenter}.
    cC�|��Sr-)�mailboxFactory)rB�name�idr.r.r1�
_emptyMailbox
�z&AccountWithoutNamespaces._emptyMailboxr�cCs tj�||�}|dur||_|Sr-)r�
MemoryAccount�selectr0)rBr_r0rr.r.r1rd
szAccountWithoutNamespaces.selectN�r�)rirjrkrrr^rardr.r.r.r1r\s
r\c@�eZdZdZdS)�AccountzD
    An in-memory account that provides L{INamespacePresenter}.
    N�rirjrkrr.r.r.r1rg�rgc@s$eZdZed�Zdd�Zdd�ZdS)�SimpleServer�testusercOs^tjj|g|�Ri|��t|d�}t|�}t�}|�dd�||_||_|�	|�d|_
dS)N��
accountHolderrk�
password-testF)r�IMAP4Serverrp�	TestRealmrr�addUser�checker�portal�registerChecker�timeoutTest)rB�args�kw�realmrsr�r.r.r1rps


zSimpleServer.__init__cCs|jrdStj�||�dSr-)rurro�lineReceived�rB�liner.r.r1ry(szSimpleServer.lineReceivedN)rirjrkrg�
theAccountrpryr.r.r.r1rjsrjc@s6eZdZddd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�SimpleClientNcCstj�||�||_g|_dSr-)r�IMAP4Clientrp�deferred�events)rBr�contextFactoryr.r.r1rp1s
zSimpleClient.__init__cCs|j�d�dSr-)r�callback)rB�capsr.r.r1�serverGreeting6�zSimpleClient.serverGreetingcC�|j�d|g�|j��dS)N�modeChanged�r�rr�	transport�loseConnection)rB�	writeabler.r.r1r�9�zSimpleClient.modeChangedcCr�)N�flagsChangedr��rB�newFlagsr.r.r1r�=r�zSimpleClient.flagsChangedcCs |j�d||g�|j��dS)N�newMessagesr�)rB�exists�recentr.r.r1r�AszSimpleClient.newMessagesr-)rirjrkrpr�r�r�r�r.r.r.r1r}0s
r}c@s^eZdZUdZeeed<dZeeed<dd�Z	dd�Z
dd	�Zd
d�Zdd
�Z
dd�ZdS)�IMAP4HelperMixinN�	serverCTX�	clientCTXcCsJt��}t|jd�|_t||jd�|_||_gt	_
td�}t	|_|t_
dS)N�r�rk)r�Deferredrjr��serverr}r��client�	connectedrr�rg�mboxTyper|)rBr�r|r.r.r1�setUpKs
zIMAP4HelperMixin.setUpcCs|`|`|`dSr-)r�r�r�rLr.r.r1�tearDownVszIMAP4HelperMixin.tearDowncCs|jj��dSr-)r�r�r�)rB�ignorer.r.r1�
_cbStopClient[r�zIMAP4HelperMixin._cbStopClientcCs0|jj��|jj��t�|dt|��dS)N�
Problem with )r�r�r�r�r"�errr�)rBr!r.r.r1�
_ebGeneral^szIMAP4HelperMixin._ebGeneralcCst�|j|j�Sr-)r �
loopbackAsyncr�r�rLr.r.r1r cr�zIMAP4HelperMixin.loopbackcCs.|�tj�t|j�}t|�}|�||�dS)a.
        Assert that the provided failure is an L{IMAP4Exception} with
        the given message.

        @param failure: A failure whose value L{IMAP4Exception}
        @type failure: L{failure.Failure}

        @param expected: The expected failure message.
        @type expected: L{bytes}
        N)�trapr�IMAP4Exceptionr��valuer�r?)rBr!r?r?r.r.r1�assertClientFailureMessagefs
z+IMAP4HelperMixin.assertClientFailureMessage)rirjrkr�rr,rVr�r+r�r�r�r�r r�r.r.r.r1r�Fs
r�c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Z d=d>�Z!d?d@�Z"dAdB�Z#dCdD�Z$dEdF�Z%dGdH�Z&dIdJ�Z'dKdL�Z(dMdN�Z)dOdP�Z*dQdR�Z+dSdT�Z,dUdV�Z-dWdX�Z.dYdZ�Z/d[d\�Z0d]d^�Z1d_d`�Z2dadb�Z3dcdd�Z4dedf�Z5dgS)h�IMAP4ServerTestscs^i���fdd�}�j�t|����j�}t����|g�}dddd��|����fdd��S)Nc���fdd�}�j���|�S)Nc���|��jj��dSr-��updater�r�r��r��r�rBr.r1�gotCaps}�
zAIMAP4ServerTests.testCapability.<locals>.getCaps.<locals>.gotCaps�r��getCapabilitiesr��r�r�r.r1�getCaps|�z0IMAP4ServerTests.testCapability.<locals>.getCaps)�	IMAP4rev1�	NAMESPACE�IDLEc������Sr-�r?��_�r�r?rBr.r1r2��z1IMAP4ServerTests.testCapability.<locals>.<lambda>)r�r�r4�
addErrbackr�r�
gatherResultsr �rBr��d1r�r.r�r1�testCapabilityyszIMAP4ServerTests.testCapabilitycsni�t�jjd<��fdd�}�j�t|����j�}t�	��
�|g�}ddddgd��|����fdd��S)N�CRAM-MD5cr�)Ncr�r-r�r�r�r.r1r��r�zIIMAP4ServerTests.testCapabilityWithAuth.<locals>.getCaps.<locals>.gotCapsr�r�r�r.r1r��r�z8IMAP4ServerTests.testCapabilityWithAuth.<locals>.getCaps)r�r�r��AUTHcr�r-r�r��r��expCaprBr.r1r2�r�z9IMAP4ServerTests.testCapabilityWithAuth.<locals>.<lambda>)rr��challengersr�r�r4r�r�rr�r r�r.r�r1�testCapabilityWithAuth�s�z'IMAP4ServerTests.testCapabilityWithAuthcsDd�_�fdd�}�j�t|����j����}|��fdd��S)Nrcs$�fdd�}�j���t|��dS)Nc�
d�_dSr,)�	loggedOutr.rLr.r1�setLoggedOut�rqzAIMAP4ServerTests.testLogout.<locals>.logout.<locals>.setLoggedOut)r��logoutr�r4)r�rLr.r1r��sz+IMAP4ServerTests.testLogout.<locals>.logoutcs���jd�Sr,)r?r�r�rLr.r1r2��z-IMAP4ServerTests.testLogout.<locals>.<lambda>)r�r�r�r4r�r�r )rBr�r�r.rLr1�
testLogout�s
zIMAP4ServerTests.testLogoutcsDd�_�fdd�}�j�t|����j����}|��fdd��S)Ncs �fdd�}�j���|�dS)Ncs|�_�jj��dSr-)�	responsesr�r�r�)r�rLr.r1�setResponses�sz=IMAP4ServerTests.testNoop.<locals>.noop.<locals>.setResponses)r��noopr�)r�rLr.r1r��sz'IMAP4ServerTests.testNoop.<locals>.noopcs���jg�Sr-)r?r�r�rLr.r1r2�r�z+IMAP4ServerTests.testNoop.<locals>.<lambda>)r�r�r�r4r�r�r )rBr�r�r.rLr1�testNoop�s
zIMAP4ServerTests.testNoopcsB�fdd�}�j�t|����j�}t�|���g�}|��j�S)Nc��j�dd�}|��j�dS�Nrkrn)r��loginr�r��r�rLr.r1r���z)IMAP4ServerTests.testLogin.<locals>.login)	r�r�r4r�r�rr�r �_cbTestLogin�rBr�r�r�r.rLr1�	testLogin�szIMAP4ServerTests.testLogincC�&|�|jjtj�|�|jjd�dS�N�auth�r?r��accountrjr|�state�rB�ignoredr.r.r1r���zIMAP4ServerTests._cbTestLogincsF�fdd�}�j�t|����j�}���}t�||g�}|��j�S)Ncr��Nrkswrong-password�r�r��addBothr�r�rLr.r1r��r�z/IMAP4ServerTests.testFailedLogin.<locals>.login)	r�r�r4r�r�r rr��_cbTestFailedLogin�rBr�r��d2r�r.rLr1�testFailedLogin�s
z IMAP4ServerTests.testFailedLogincCs$|�|jjd�|�|jjd�dS)N�unauth)r?r�r�r�r�r.r.r1r���z#IMAP4ServerTests._cbTestFailedLogincsNd�j_�fdd�}�j�t|����j�}���}t�	||g�}|��j
�S)zj
        Attempting to log into a server that has no L{Portal} results
        in a failed login.
        Ncr�r�r�r�rLr.r1r��r�z7IMAP4ServerTests.test_loginWithoutPortal.<locals>.login)r�rsr�r�r4r�r�r rr�r�r�r.rLr1�test_loginWithoutPortal�sz(IMAP4ServerTests.test_loginWithoutPortalcsZdd�}|�jjj_�fdd�}�j�t|����j�}��	�}t
�||g�}|��j�S)z�
        The server responds with a C{BAD} response when its portal
        attempts to log a user in with checker that claims to support
        L{IAccount} but returns an an avatar interface that is not
        L{IAccount}.
        c_sdddd�fS)NzNot IAccountzNot an accountcSr2r-r.r.r.r.r1r2��zVIMAP4ServerTests.test_nonIAccountAvatar.<locals>.brokenRequestAvatar.<locals>.<lambda>r.)r��__r.r.r1�brokenRequestAvatar�r.zDIMAP4ServerTests.test_nonIAccountAvatar.<locals>.brokenRequestAvatarcr�r�r�r�rLr.r1r��r�z6IMAP4ServerTests.test_nonIAccountAvatar.<locals>.login)
r�rsrx�
requestAvatarr�r�r4r�r�r rr�r�)rBr�r�r�r�r�r.rLr1�test_nonIAccountAvatar�sz'IMAP4ServerTests.test_nonIAccountAvatarcs�Gdd�dt���fdd�}|�j_�fdd�}�j�t|��}|��jd�|j��fdd	��}|��j�|�	�j
����}t�
||g�}|��j�S)
z�
        Any exception raised by L{IMAP4Server.authenticateLogin} that
        is not L{UnauthorizedLogin} is logged results in a C{BAD}
        response.
        c@rf)zAIMAP4ServerTests.test_loginException.<locals>.UnexpectedException�2
            An unexpected exception.
            Nrhr.r.r.r1�UnexpectedExceptionrir�c��d��)N�Whoopsr.)�user�passwd�r�r.r1�raisesUnexpectedExceptionrbzGIMAP4ServerTests.test_loginException.<locals>.raisesUnexpectedExceptionc��j�dd�Sr��r�r�r.rLr.r1r�r.z3IMAP4ServerTests.test_loginException.<locals>.loginsServer error: Whoopsc��������dSr-�r/�flushLoggedErrorsr��r�rBr.r1�assertErrorLoggedsz?IMAP4ServerTests.test_loginException.<locals>.assertErrorLogged)r�r��authenticateLoginr�r�r4r�r�r�r�r�r rr�r�)rBr�r�r�rr�r�r.rr1�test_loginException�sz$IMAP4ServerTests.test_loginExceptioncsPddi�jj_�fdd�}�j�t|����j�}t�	��
�|g�}|��j�S)N�
{test}user�{test}passwordcs4�j�dd�}|�tjdt���|��j�dS)Nrrr�)r�r�r�r"r�r�r�r�r�rLr.r1r�!sz9IMAP4ServerTests.testLoginRequiringQuoting.<locals>.login)r�rr�usersr�r�r4r�r�rr�r �_cbTestLoginRequiringQuotingr�r.rLr1�testLoginRequiringQuotings
z*IMAP4ServerTests.testLoginRequiringQuotingcCr�r�r�r�r.r.r1r*r�z-IMAP4ServerTests._cbTestLoginRequiringQuotingcs�d�_�fdd�}�fdd�}�j�t|��}|�t|��|��j����}t�||g�}|j�fdd��}|��j	ddggggg�|S)	Ncr�r�r�r.rLr.r1r�1r.z-IMAP4ServerTests.testNamespace.<locals>.loginc��fdd�}�j���|�S)Nc�|�_��d�dSr-��
namespaceArgsr��rvrLr.r1�gotNamespace5rwzGIMAP4ServerTests.testNamespace.<locals>.namespace.<locals>.gotNamespace�r��	namespacer��rrLr.r1r4�z1IMAP4ServerTests.testNamespace.<locals>.namespacecs2�jD]}|D]
}|D]}��|t�qqq�jSr-)r
r�r�)r��
namespaces�pairr�rLr.r1�assertAllPairsNativeStringsAs
��zCIMAP4ServerTests.testNamespace.<locals>.assertAllPairsNativeStringsr�r*)
r
r�r�r4r�r�r rr�r?)rBr�rr�r�r�rr.rLr1�
testNamespace.szIMAP4ServerTests.testNamespacecs�td��j_d�_�fdd�}�fdd�}�j�t|��}|�t|��|��j���	�}t
�||g�}|��fdd��|��jgggg�|S)	z�
        A mailbox that does not provide L{INamespacePresenter} returns
        empty L{list}s for its personal, shared, and user namespaces.
        rkNcr�r�r�r.rLr.r1r�Tr.z<IMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.logincr
)Ncrr-rrrLr.r1rXrwzVIMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.namespace.<locals>.gotNamespacerrrLr.r1rWrz@IMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.namespacec��jSr-)r
r�rLr.r1r2cr3z?IMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.<lambda>)
r\r�r|r
r�r�r4r�r�r rr�r?)rBr�rr�r�r�r.rLr1�test_mailboxWithoutNamespaceLsz-IMAP4ServerTests.test_mailboxWithoutNamespacecsrtj�d�d�_�fdd�}�fdd�}�j�t|��}|�t|��|��j���	�}t
�||g���j�S)N�test-mailboxcr�r�r�r.rLr.r1r�kr.z*IMAP4ServerTests.testSelect.<locals>.loginc�&�fdd�}�j�d�}|�|�|S)Ncrr-)�selectedArgsr�rrLr.r1�selectedorwz=IMAP4ServerTests.testSelect.<locals>.select.<locals>.selectedr)r�rdr�)rr�rLr.r1rdn�
z+IMAP4ServerTests.testSelect.<locals>.select)
rjr|�
addMailboxrr�r�r4r�r�r rr��
_cbTestSelect)rBr�rdr�r�r.rLr1�
testSelectgs	zIMAP4ServerTests.testSelectcs��fdd�}�fdd�}�j�t|���j�t|���j��jd��j��j��j��j�t��j��	�g�}|j�fdd��}|S)zh
        A client that selects a mailbox that does not exist receives a
        C{NO} response.
        cr�r�r�r.rLr.r1r��r.z9IMAP4ServerTests.test_selectWithoutMailbox.<locals>.loginc��j�d�S)Nr�r�rdr.rLr.r1rd�r5z:IMAP4ServerTests.test_selectWithoutMailbox.<locals>.select�No such mailboxc����jj�dSr-)�assertIsNoner�rr�rLr.r1�assertNoMailboxSelected�szKIMAP4ServerTests.test_selectWithoutMailbox.<locals>.assertNoMailboxSelected)
r�r�r4r�r�r�r�rr�r )rBr�rd�connectionCompleter'r.rLr1�test_selectWithoutMailbox}sz*IMAP4ServerTests.test_selectWithoutMailboxc	C�:tjjd}|�|jj|�|�|jdddddd��dS)N�TEST-MAILBOXr�r�r)rT��EXISTSrrrm�
READ-WRITE)rjr|�	mailboxesr?r�rr�rBr�rr.r.r1r ����zIMAP4ServerTests._cbTestSelectcsvtj�d�d�_�fdd�}�fdd�}�j�t|��}|�t|��|��j���	�}t
�||g�}|��j�S)a�
        L{IMAP4Client.examine} issues an I{EXAMINE} command to the server and
        returns a L{Deferred} which fires with a C{dict} with as many of the
        following keys as the server includes in its response: C{'FLAGS'},
        C{'EXISTS'}, C{'RECENT'}, C{'UNSEEN'}, C{'READ-WRITE'}, C{'READ-ONLY'},
        C{'UIDVALIDITY'}, and C{'PERMANENTFLAGS'}.

        Unfortunately the server doesn't generate all of these so it's hard to
        test the client's handling of them here.  See
        L{IMAP4ClientExamineTests} below.

        See U{RFC 3501<http://www.faqs.org/rfcs/rfc3501.html>}, section 6.3.2,
        for details.
        rNcr�r�r�r.rLr.r1r��r.z,IMAP4ServerTests.test_examine.<locals>.logincr)Ncrr-)�examinedArgsr�rrLr.r1�examined�rwz@IMAP4ServerTests.test_examine.<locals>.examine.<locals>.examinedr)r��examiner�)r3r�rLr.r1r4�rz.IMAP4ServerTests.test_examine.<locals>.examine)
rjr|rr2r�r�r4r�r�r rr��_cbTestExamine)rBr�r4r�r�r�r.rLr1�test_examine�s	zIMAP4ServerTests.test_examinec	Cr*)Nr+r�r�r)rFr,)rjr|r/r?r�rr2r0r.r.r1r5�r1zIMAP4ServerTests._cbTestExaminecs�d�d��fdd���fdd���fdd�}�����fd	d
�}g�_�j�t|���t|��}���}t�||g�}|��j���S)N)�testbox�test/boxztest/�test/box/box�INBOX)r7r8c��j�d�dSr,�r/rrr.rLr.r1�cb�r�z'IMAP4ServerTests.testCreate.<locals>.cbcr;�Nrr<�r!rLr.r1�eb�r�z'IMAP4ServerTests.testCreate.<locals>.ebcr�r�r�r.rLr.r1r��r.z*IMAP4ServerTests.testCreate.<locals>.logincsB��D]}�j�|�}|�t������q|��j�j�dSr-)r��creater�r4r��addCallbacksr�r�)r_r��r=r@r3rBr4r.r1rA�sz+IMAP4ServerTests.testCreate.<locals>.create)r/r�r�r4r rr��
_cbTestCreate)rBr�rAr�r�r�r.rCr1�
testCreate�szIMAP4ServerTests.testCreatecCsX|�|jdgt|�dgt|��ttjj�}tgd��}|�|dd�|D��dS)Nr�r)�inboxr7r8�testr9cS�g|]}|���qSr.�r�)r
�ar.r.r1r��rFz2IMAP4ServerTests._cbTestCreate.<locals>.<listcomp>)r?r/r�r=rjr|r/)rBr�r4r3rrPr.r.r1rD�s&zIMAP4ServerTests._cbTestCreatec�tj�d��fdd�}�fdd�}�j�t|��}|�t|��j�|��j�j���	�}t
�||g�}|��fdd��|S)N�	delete/mecr�r�r�r.rLr.r1r��r.z*IMAP4ServerTests.testDelete.<locals>.logincr"�NrL�r�rIr.rLr.r1rI�r5z+IMAP4ServerTests.testDelete.<locals>.deletecs��ttjj�g�Sr-)r?r�rjr|r/r�rLr.r1r2	rFz-IMAP4ServerTests.testDelete.<locals>.<lambda>�rjr|rr�r�r4rBr�r�r rr�)rBr�rIr�r�r�r.rLr1�
testDelete�s
�zIMAP4ServerTests.testDeletecs�tj�d�tj�d��fdd�}�fdd�}�fdd�}�j�t|��}|�t|��j�|�|�|��j	���
�}t�||g�}|��fd	d
��|S)z�
        Attempting to delete a mailbox with hierarchically inferior
        names fails with an informative error.

        @see: U{https://tools.ietf.org/html/rfc3501#section-6.3.4}

        @return: A L{Deferred} with assertions.
        rIrLcr�r�r�r.rLr.r1r�	r.zGIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.logincr"�NrIrNr.rLr.r1rI	r5zHIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.deletecs&|�tj���t|j�td��dS)Ns-Name "DELETE" has inferior hierarchical names)r�rr�r?r�r�r?rLr.r1�assertIMAPException	s
�zUIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.assertIMAPExceptioncs��ttjj�ddg�S)N�DELETEz	DELETE/ME)r?r=rjr|r/r�rLr.r1r2+	s�zJIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.<lambda>)
rjr|rr�r�r4rBr�r�r�r rr�)rBr�rIrR�loggedIn�
loopedBackr�r.rLr1�'testDeleteWithInferiorHierarchicalNames
	s	

�z8IMAP4ServerTests.testDeleteWithInferiorHierarchicalNamesc�d�_�fdd�}�fdd�}�fdd�}�j�t|��}|�t|��j�|�|�|��j�j����}t	�
||g�}|��fdd��|S)	Ncr�r�r�r.rLr.r1r�4	r.z6IMAP4ServerTests.testIllegalInboxDelete.<locals>.logincr")NrFrNr.rLr.r1rI7	r5z7IMAP4ServerTests.testIllegalInboxDelete.<locals>.deletec�
|�_dSr-��stashedr�rLr.r1�stash:	rqz6IMAP4ServerTests.testIllegalInboxDelete.<locals>.stashc���t�jtj��Sr-�r/r�rZr!�Failurer�rLr.r1r2D	rFz9IMAP4ServerTests.testIllegalInboxDelete.<locals>.<lambda>�rZr�r�r4rBr�r�r�r rr�)rBr�rIr[r�r�r�r.rLr1�testIllegalInboxDelete1	�

�z'IMAP4ServerTests.testIllegalInboxDeletecs��fdd�}�fdd�}�fdd�}d�_�j�t|��}|�t|���|�|��j�j����}t	�
||g�}|��fdd��|S)	Ncr�r�r�r.rLr.r1r�I	r.z5IMAP4ServerTests.testNonExistentDelete.<locals>.logincr"rMrNr.rLr.r1rIL	r5z6IMAP4ServerTests.testNonExistentDelete.<locals>.deletecrXr-r?r?rLr.r1�deleteFailedO	rqz<IMAP4ServerTests.testNonExistentDelete.<locals>.deleteFailedcs��t�jj�td��S)Nr$�r?r�r!r�r�rLr.r1r2Y	sz8IMAP4ServerTests.testNonExistentDelete.<locals>.<lambda>)r!r�r�r4r�rBr�r�r rr�)rBr�rIrbr�r�r�r.rLr1�testNonExistentDeleteH	s
�z&IMAP4ServerTests.testNonExistentDeletecs�t�}d|_tj�d|�tj�d��fdd�}�fdd�}�fdd	�}d�_�j�t|��}|�t|���	|�|�
�j�j���
�}t�||g�}td
��|���fdd��|S)
N)z	\NoselectrIrLcr�r�r�r.rLr.r1r�c	r.z1IMAP4ServerTests.testIllegalDelete.<locals>.logincr"rQrNr.rLr.r1rIf	r5z2IMAP4ServerTests.testIllegalDelete.<locals>.deletecrXr-r?r?rLr.r1rbi	rqz8IMAP4ServerTests.testIllegalDelete.<locals>.deleteFaileds<Hierarchically inferior mailboxes exist and \Noselect is setcs��t�jj���Sr-rcr��r?rBr.r1r2u	rFz4IMAP4ServerTests.testIllegalDelete.<locals>.<lambda>)rrorjr|rr!r�r�r4r�rBr�r�r rr�r�)rBr�r�rIrbr�r�r�r.rer1�testIllegalDelete]	s$�z"IMAP4ServerTests.testIllegalDeletecrK)N�oldmboxcr�r�r�r.rLr.r1r�{	r.z*IMAP4ServerTests.testRename.<locals>.logincr�)Nsoldmboxsnewname�r��renamer.rLr.r1ri~	r.z+IMAP4ServerTests.testRename.<locals>.renamecs��ttjj���dg�S)N�NEWNAME)r?r�rjr|r/rr�rLr.r1r2�	s�z-IMAP4ServerTests.testRename.<locals>.<lambda>rO�rBr�rir�r�r�r.rLr1�
testRenamex	�
�zIMAP4ServerTests.testRenamecrW)	Ncr�r�r�r.rLr.r1r��	r.z6IMAP4ServerTests.testIllegalInboxRename.<locals>.logincr�)NrF�frotzrhr.rLr.r1ri�	r.z7IMAP4ServerTests.testIllegalInboxRename.<locals>.renamecrXr-rY)�stuffrLr.r1r[�	rqz6IMAP4ServerTests.testIllegalInboxRename.<locals>.stashcr\r-r]r�rLr.r1r2�	rFz9IMAP4ServerTests.testIllegalInboxRename.<locals>.<lambda>r_)rBr�rir[r�r�r�r.rLr1�testIllegalInboxRename�	raz'IMAP4ServerTests.testIllegalInboxRenamecs�tj�d�tj�d��fdd�}�fdd�}�j�t|��}|�t|��j�|��j�j���	�}t
�||g�}|��j�S)Nz
oldmbox/m1z
oldmbox/m2cr�r�r�r.rLr.r1r��	r.z6IMAP4ServerTests.testHierarchicalRename.<locals>.logincr�)Nrg�newnamerhr.rLr.r1ri�	r.z7IMAP4ServerTests.testHierarchicalRename.<locals>.rename)
rjr|rAr�r�r4rBr�r�r rr��_cbTestHierarchicalRenamerkr.rLr1�testHierarchicalRename�	sz'IMAP4ServerTests.testHierarchicalRenamecCs:tjj��}gd�}tt|��}|�|dd�|D��dS)N)rqz
newname/m1z
newname/m2cSrHr.rI)r
rRr.r.r1r��	rFz>IMAP4ServerTests._cbTestHierarchicalRename.<locals>.<listcomp>)rjr|r/rr�r=r?)rBr��mboxesr?r.r.r1rr�	sz*IMAP4ServerTests._cbTestHierarchicalRenamecsv�fdd�}�fdd�}�j�t|��}|�t|��j�|��j�j����}t�||g�}|��fdd��|S)Ncr�r�r�r.rLr.r1r��	r.z-IMAP4ServerTests.testSubscribe.<locals>.logincr"�Nz	this/mbox)r��	subscriber.rLr.r1rv�	r5z1IMAP4ServerTests.testSubscribe.<locals>.subscribec���tjjdg�S)N�	THIS/MBOX�r?rjr|�
subscriptionsr�rLr.r1r2�	�
�z0IMAP4ServerTests.testSubscribe.<locals>.<lambda>)	r�r�r4rBr�r�r rr�)rBr�rvr�r�r�r.rLr1�
testSubscribe�	s
�zIMAP4ServerTests.testSubscribecs�ddgtj_�fdd�}�fdd�}�j�t|��}|�t|��j�|��j�j���	�}t
�||g�}|��fdd��|S)	Nrx�	THAT/MBOXcr�r�r�r.rLr.r1r��	r.z/IMAP4ServerTests.testUnsubscribe.<locals>.logincr"ru)r��unsubscriber.rLr.r1r~�	r5z5IMAP4ServerTests.testUnsubscribe.<locals>.unsubscribecrw)Nr}ryr�rLr.r1r2�	r{z2IMAP4ServerTests.testUnsubscribe.<locals>.<lambda>)rjr|rzr�r�r4rBr�r�r rr�)rBr�r~r�r�r�r.rLr1�testUnsubscribe�	rmz IMAP4ServerTests.testUnsubscribecs�tj�d�tj�d�tj�d��fdd�}�fdd�}d�_�j�t|��}|�t|��j�|�|�j�|��j	�j���
�}t�||g���fdd	��S)
N�
root/subthingzroot/another-thingznon-root/subthingcr�r�r�r.rLr.r1r��	r.z*IMAP4ServerTests._listSetup.<locals>.logincrXr-��listed)rPrLr.r1r��	rqz+IMAP4ServerTests._listSetup.<locals>.listedcrr-r�r�rLr.r1r2�	r3z-IMAP4ServerTests._listSetup.<locals>.<lambda>)
rjr|rr�r�r�r4rBr�r�r rr�)rBr0r�r�r�r�r.rLr1�
_listSetup�	szIMAP4ServerTests._listSetupcCs2|D]}|�|dtd�|�|dtd�q|S)z�
        Assert a C{LIST} response's delimiter and mailbox are native
        strings.

        @param results: A list of tuples as returned by
            L{IMAP4Client.list} or L{IMAP4Client.lsub}.
        r�zdelimiter %r is not a strr�zmailbox %r is not a str)r�r�)rB�resultsr/r.r.r1�'assertListDelimiterAndMailboxAreStrings�	sz8IMAP4ServerTests.assertListDelimiterAndMailboxAreStringscs,�fdd�}��|�}|j�fdd��}|S)Ncr��N�root�%)r�r�r.rLr.r1�mailboxList
r.z.IMAP4ServerTests.testList.<locals>.mailboxListcsjttj�ddfttj�ddfg}td�D]}|�d�\}}}��t|�||f|�q��|d|���dS)Nr*�
ROOT/SUBTHINGzROOT/ANOTHER-THINGr�rzMore results than expected: )r=rrord�popr�r-)r��expectedContentsr�ro�	delimiter�mailboxrLr.r1�assertListContents	
s��z5IMAP4ServerTests.testList.<locals>.assertListContents)r�r�)rBr�r�r�r.rLr1�testList
s

zIMAP4ServerTests.testListcsJtj�d��fdd�}��|�}|��j�|��jtjddfg�|S)Nr�cr�r�)r��lsubr.rLr.r1r�
r.z'IMAP4ServerTests.testLSub.<locals>.lsubr*)	rjr|rvr�r�r�r?rro)rBr�r�r.rLr1�testLSub
s
zIMAP4ServerTests.testLSubcs�tj�d��fdd�}�fdd�}�fdd�}d�_�j�t|��}|�t|��j�|�|�j�|��j	�j���
�}t�||g�}|��fdd	��|S)
Nr�cr�r�r�r.rLr.r1r�)
r.z*IMAP4ServerTests.testStatus.<locals>.loginc��j�dddd�S)Nr�rr
r�r��statusr.rLr.r1r�,
�z+IMAP4ServerTests.testStatus.<locals>.statuscrXr-��statusedr�rLr.r1r�/
rqz-IMAP4ServerTests.testStatus.<locals>.statusedcs���jdddd��S)Nr�s10r�)rr
r)r?r�r�rLr.r1r2:
s�z-IMAP4ServerTests.testStatus.<locals>.<lambda>)
rjr|rr�r�r�r4rBr�r�r rr�)rBr�r�r�r�r�r�r.rLr1�
testStatus&
s
�zIMAP4ServerTests.testStatuscs��fdd�}�fdd�}�fdd�}�fdd�}d�_�_�j�t|��}|�t|��j�|�||�|��j�j����}t	�
||g���j�S)	Ncr�r�r�r.rLr.r1r�A
r.z0IMAP4ServerTests.testFailedStatus.<locals>.logincr�)Nzroot/nonexistentrr
rr�r.rLr.r1r�D
s�z1IMAP4ServerTests.testFailedStatus.<locals>.statuscrXr-r�r�rLr.r1r�I
rqz3IMAP4ServerTests.testFailedStatus.<locals>.statusedcrXr-r?r?rLr.r1�failedL
rqz1IMAP4ServerTests.testFailedStatus.<locals>.failed)r�r!r�r�r4rBr�r�r rr��_cbTestFailedStatus)rBr�r�r�r�r�r�r.rLr1�testFailedStatus@
sz!IMAP4ServerTests.testFailedStatuscCs$|�|jd�|�|jjjd�dS)N)sCould not open mailbox)r?r�r!r�rvr�r.r.r1r�W
�z$IMAP4ServerTests._cbTestFailedStatusc�t�td��tj�d��fdd�}tj��fdd��}�j�	t
|��}|�t
|��j�|��j
�j����}t�||g�}|�	�j��S)N�rfc822.messager�cr�r�r�r.rLr.r1r�_
r.z.IMAP4ServerTests.testFullAppend.<locals>.loginc3sP�t�d��}�j�d|dd�V}t�|�Wd�dS1s!wYdS)N�rbr�)�\SEEN�\DELETEDz%Tue, 17 Jun 2003 11:22:16 -0600 (MDT))�openr�rrr�returnValue�r?r/��infilerBr.r1rrb
s��"�z/IMAP4ServerTests.testFullAppend.<locals>.append)r#�sibpath�__file__rjr|rr�inlineCallbacksr�r�r4rBr�r�r r��_cbTestFullAppend�rBr�rrr�r�r�r.r�r1�testFullAppend[
s
zIMAP4ServerTests.testFullAppendcCs�tjjd}|�dt|j��|�ddgddf|jddd��t|d��}|�|��|jdd���Wd�dS1sAwYdS)Nr�r�r�r�s%Tue, 17 Jun 2003 11:22:16 -0600 (MDT)rr��	rjr|r/r?r�r�r�rPrU�rBr�r��mbr0r.r.r1r�v
s� "�z"IMAP4ServerTests._cbTestFullAppendcr�)Nr��PARTIAL/SUBTHINGcr�r�r�r.rLr.r1r��
r.z1IMAP4ServerTests.testPartialAppend.<locals>.loginc3sn�t�d��'}�j�t�dtdtj���f�d�jj	|��V}t
�|�Wd�dS1s0wYdS)Nr�sAPPENDz)PARTIAL/SUBTHING (\SEEN) "Right now" {%d}r.)r�r��sendCommandrrr&�os�path�getsize�_IMAP4Client__cbContinueAppendrr�r�r�r.r1rr�
s"�����"�z2IMAP4ServerTests.testPartialAppend.<locals>.append)r#r�r�rjr|rrr�r�r�r4rBr�r�r r��_cbTestPartialAppendr�r.r�r1�testPartialAppend�
sz"IMAP4ServerTests.testPartialAppendcCs�tjjd}|�dt|j��|�dgddf|jddd��t|d��}|�|��|jdd���Wd�dS1s@wYdS)Nr�r�r�s	Right nowrr�r�r�r.r.r1r��
s" "�z%IMAP4ServerTests._cbTestPartialAppendcs|tj�d��fdd�}�fdd�}�fdd�}�j�t|��}|�t|��j�|�t|��j�|��j�j���	�S)N�
root/subthingcr�r�r�r.rLr.r1r��
r.z*IMAP4ServerTests._testCheck.<locals>.logincr")Nr�r#r.rLr.r1rd�
r5z+IMAP4ServerTests._testCheck.<locals>.selectc�
�j��Sr-)r�rbr.rLr.r1rb�
rqz*IMAP4ServerTests._testCheck.<locals>.check)
rjr|rr�r�r4rBr�r�r )rBr�rdrbr�r.rLr1�
_testCheck�
szIMAP4ServerTests._testCheckcCr])zf
        Trigger the L{imap.IMAP4Server._cbSelectWork} callback
        by selecting an mbox.
        )r�rLr.r.r1�
test_check�
szIMAP4ServerTests.test_checkcs6ddd�}�fdd�}��td|����}|�|�S)	zr
        Trigger the L{imap.IMAP4Server._ebSelectWork} errback
        by failing when we select an mbox.
        r�cSs
t�d��)N�encoding)r�IllegalMailboxEncoding)rBr_r0r.r.r1�
failSelect�
rqz3IMAP4ServerTests.test_checkFail.<locals>.failSelectcs$���}��|djjdd�dS)Nr�rsSELECT failed: Server error)rr?r�rv)r��failuresrLr.r1�
checkResponse�
�z6IMAP4ServerTests.test_checkFail.<locals>.checkResponserdNre)�patchrgr�r�)rBr�r�r�r.rLr1�test_checkFail�
s


zIMAP4ServerTests.test_checkFailcs�t�}gd�|_tj�d|��fdd�}�fdd�}�fdd�}�j�t|��}|�t|��j	�|�t|��j	�|��j
�j	����}t�
||g���j|�S)	N�)s	Message 1)rC�AnotherFlagNr�s	Message 2)r�Nr�)s	Message 3)rCNr�r�cr�r�r�r.rLr.r1r��
r.z)IMAP4ServerTests.testClose.<locals>.logincr")Nsmailboxr#r.rLr.r1rd�
r5z*IMAP4ServerTests.testClose.<locals>.selectcr�r-)r�rMr.rLr.r1rM�
rqz)IMAP4ServerTests.testClose.<locals>.close)rr�rjr|rr�r�r4rBr�r�r rr��_cbTestClose)rBr�r�rdrMr�r�r.rLr1�	testClose�
s
zIMAP4ServerTests.testClosecCs4|�t|j�d�|�|jdd�|�|j�dS)Nr�rr�)r?r�r�r/rL�rBr�r�r.r.r1r��
szIMAP4ServerTests._cbTestClosec	s�t�}gd�|_tj�d|��fdd�}�fdd�}�fdd�}�fd	d
�}d�_�j�t|��}|�	t|��j
�|�	t|��j
�|�	|�j
�|�	�j�j
����}t
�||g�}|��j|�S)Nr�r�cr�r�r�r.rLr.r1r��
r.z+IMAP4ServerTests.testExpunge.<locals>.logincr")Nr�r#r.rLr.r1rd�
r5z,IMAP4ServerTests.testExpunge.<locals>.selectcr�r-)r�rJr.rLr.r1rJrqz-IMAP4ServerTests.testExpunge.<locals>.expungecs���jjdu�|�_dSr-)r-r�rr��r�rLr.r1�expunged�
z.IMAP4ServerTests.testExpunge.<locals>.expunged)rr�rjr|rr�r�r�r4rBr�r�r rr��_cbTestExpunge)	rBr�r�rdrJr�r�r�r�r.rLr1�testExpunge�
s 
zIMAP4ServerTests.testExpungecCs:|�t|j�d�|�|jdd�|�|jddg�dS)Nr�rr�r�)r?r�r�r�r�r.r.r1r�szIMAP4ServerTests._cbTestExpungeN)6rirjrkr�r�r�r�r�r�r�r�r�r�rr	rrrr!r)r r6r5rErDrPrVr`rdrfrlrprsrrr|rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r.r.r.r1r�xsh
	
#%'

$ r�c@sHeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Z d<d=�Z!d>d?�Z"d@dA�Z#dBdC�Z$dDdE�Z%dFdG�Z&dHdI�Z'dJdK�Z(dLdM�Z)dNdO�Z*dPS)Q�IMAP4ServerParsingTestsz6
    Test L{imap4.IMAP4Server}'s command parsing.
    cCs.t�|_t��|_|j�|j�|j��dSr-)r'r�rror��makeConnection�clearrLr.r.r1r�s
zIMAP4ServerParsingTests.setUpcC�|j�t�t����dSr-�r��connectionLostr!r^r�ConnectionDonerLr.r.r1r�%�z IMAP4ServerParsingTests.tearDowncsLGdd�dt���fdd�}d|j_||j_|j�d�|�|����dS)zO
        L{imap4.IMAP4Server} logs exceptions raised by parse methods.
        c@rf)zSIMAP4ServerParsingTests.test_parseMethodExceptionLogged.<locals>.UnhandledException�1
            An unhandled exception.
            Nrhr.r.r.r1�UnhandledException-rir�c���r-r.)r{�r�r.r1�raisesValueError2r*zQIMAP4ServerParsingTests.test_parseMethodExceptionLogged.<locals>.raisesValueError�command�invalidN)r�r��
parseState�
parse_commandryr/r)rBr�r.r�r1�test_parseMethodExceptionLogged(sz7IMAP4ServerParsingTests.test_parseMethodExceptionLoggedcCs:|j�d�|�|j��d�|j�t�t�	d���dS)z�
        L{imap4.IMAP4Server.parse_command} sends a C{BAD} response to
        a line that includes a tag but no command.
        �001s001 BAD Missing command
�DoneN)
r�r�r?r�r�r�r!r^rr�rLr.r.r1�test_missingCommand<s
�z+IMAP4ServerParsingTests.test_missingCommandcC�"|j�d�|�|j��d�dS)zf
        L{imap4.IMAP4Server.parse_command} sends a C{BAD} response to
        an empty line.
        r�s* BAD Null command
N)r�r�r?r�r�rLr.r.r1�test_emptyLineIsz&IMAP4ServerParsingTests.test_emptyLinecsJ�fdd�}||j_|j�d�|dg��|�|j��d�||g��dS)aV
        Assert that the given exception results in the expected
        response.

        @param exception: The exception to raise.
        @type exception: L{Exception}

        @param tag: The IMAP tag.

        @type: L{bytes}

        @param expectedResponse: The expected bad response.
        @type expectedResponse: L{bytes}
        cr�r-r.)�tag�cmd�rest��	exceptionr.r1�raisesbr*zDIMAP4ServerParsingTests.assertParseExceptionResponse.<locals>.raisesrZr�N)r��dispatchCommandr�r�r?r�r��rBr�r��expectedResponser�r.r�r1�assertParseExceptionResponseRs z4IMAP4ServerParsingTests.assertParseExceptionResponsecC�|�t�d�dd�dS)zt
        When a parsing method raises L{IllegalClientResponse}, the
        server sends a C{BAD} response.
        �client responser��%BAD Illegal syntax: client response
N)r�r�IllegalClientResponserLr.r.r1�'test_parsingRaisesIllegalClientResponsek�
�z?IMAP4ServerParsingTests.test_parsingRaisesIllegalClientResponsecCr�)zn
        When a parsing method raises L{IllegalOperation}, the server
        sends a C{NO} response.
        �	operationr��!NO Illegal operation: operation
N)r�r�IllegalOperationrLr.r.r1�*test_parsingRaisesIllegalOperationResponsevr�zBIMAP4ServerParsingTests.test_parsingRaisesIllegalOperationResponsecCr�)zt
        When a parsing method raises L{IllegalMailboxEncoding}, the
        server sends a C{NO} response.
        r�r��#NO Illegal mailbox name: encoding
N)r�rr�rLr.r.r1�(test_parsingRaisesIllegalMailboxEncoding�r�z@IMAP4ServerParsingTests.test_parsingRaisesIllegalMailboxEncodingcCr�)zi
        L{imap4.IMAP4Server} responds to an unsupported command with a
        C{BAD} response.
        s001 HULLABALOOs001 BAD Unsupported command
N)r�ryr?r�r�rLr.r.r1�test_unsupportedCommand�sz/IMAP4ServerParsingTests.test_unsupportedCommandcCs4|j�d�|�|j��dtd��d�d�dS)z~
        L{imap4.IMAP4Server} responds with a C{BAD} response to a
        command with more arguments than expected.
        s001 LOGIN A B Cs8001 BAD Illegal syntax: Too many arguments for command: �Czutf-8r_N)r�ryr?r�r�r�r@rLr.r.r1�test_tooManyArgumentsForCommand�s���z7IMAP4ServerParsingTests.test_tooManyArgumentsForCommandcsf�fdd�}|�|jjd�|f|jjdd�|j_|j�|dd�|�|j��d�||g��dS)	aR
        Assert that the given exception results in the expected
        response.

        @param exception: The exception to raise.
        @type exception: L{Exception}

        @param: The IMAP tag.

        @type: L{bytes}

        @param expectedResponse: The expected bad response.
        @type expectedResponse: L{bytes}
        cr�r-r.)�serverInstancer�r�r�r�r.r1r��r*zFIMAP4ServerParsingTests.assertCommandExceptionResponse.<locals>.raisesr�r�N�LOGINsuser passwdrZ)r?r�r��unauth_LOGINr�r�r�r�r�r.r�r1�assertCommandExceptionResponse�s
 z6IMAP4ServerParsingTests.assertCommandExceptionResponsecCr�)zm
        When a command raises L{IllegalClientResponse}, the
        server sends a C{BAD} response.
        r�r�r�N)rrr�rLr.r.r1�'test_commandRaisesIllegalClientResponse�r�z?IMAP4ServerParsingTests.test_commandRaisesIllegalClientResponsecCr�)zg
        When a command raises L{IllegalOperation}, the server sends a
        C{NO} response.
        r�r�r�N)rrr�rLr.r.r1�*test_commandRaisesIllegalOperationResponse�r�zBIMAP4ServerParsingTests.test_commandRaisesIllegalOperationResponsecCr�)zm
        When a command raises L{IllegalMailboxEncoding}, the server
        sends a C{NO} response.
        r�r�r�N)rrr�rLr.r.r1�(test_commandRaisesIllegalMailboxEncoding�r�z@IMAP4ServerParsingTests.test_commandRaisesIllegalMailboxEncodingcCs6Gdd�dt�}|�|d�dd�|�|�|��dS)z�
        Wehn a command raises an unhandled exception, the server sends
        a C{BAD} response and logs the exception.
        c@rf)zXIMAP4ServerParsingTests.test_commandRaisesUnhandledException.<locals>.UnhandledExceptionr�Nrhr.r.r.r1r��rir��	unhandledr�sBAD Server error: unhandled
N)r�rr/r)rBr�r.r.r1�$test_commandRaisesUnhandledException�s�z<IMAP4ServerParsingTests.test_commandRaisesUnhandledExceptioncCs*d|j_|j�d�|�|j��d�dS)zx
        A string literal whose length exceeds the maximum allowed
        length results in a C{BAD} response.
        r�s001 LOGIN {5}
sE001 BAD Illegal syntax: Literal too long! I accept at most 4 octets
N)r��_literalStringLimitryr?r�r�rLr.r.r1�test_stringLiteralTooLong�s�z1IMAP4ServerParsingTests.test_stringLiteralTooLongcCs"dD]}|�tj|jj|�qdS)zQ
        An empty string argument raises L{imap4.IllegalClientResponse}.
        )r�r_rZN�r�rr�r��arg_astring)rBr�r.r.r1�test_arg_astringEmptyLines
��z1IMAP4ServerParsingTests.test_arg_astringEmptyLinecC�|�tj|jjd�dS)zh
        An unmatched quote in a string argument raises
        L{imap4.IllegalClientResponse}.
        s"openNrrLr.r.r1�test_arg_astringUnmatchedQuotes
��z7IMAP4ServerParsingTests.test_arg_astringUnmatchedQuotescCr)zn
        An unmatched brace in a string literal's size raises
        L{imap4.IllegalClientResponse}.
        s{0NrrLr.r.r1�&test_arg_astringUnmatchedLiteralBracesr�z>IMAP4ServerParsingTests.test_arg_astringUnmatchedLiteralBracescCr)zc
        A non-integral string literal size raises
        L{imap4.IllegalClientResponse}.
        �{[object Object]}NrrLr.r.r1�"test_arg_astringInvalidLiteralSizerz:IMAP4ServerParsingTests.test_arg_astringInvalidLiteralSizecCr)z@
        An empty atom raises L{IllegalClientResponse}.
        r�N�r�rr�r��arg_atomrLr.r.r1�test_arg_atomEmptyLine#rz.IMAP4ServerParsingTests.test_arg_atomEmptyLinecCr)zC
        A malformed atom raises L{IllegalClientResponse}.
        s
 not an atom NrrLr.r.r1�test_arg_atomMalformedAtom)s�z2IMAP4ServerParsingTests.test_arg_atomMalformedAtomcCr)zN
        An empty parenthesized list raises L{IllegalClientResponse}.
        r�N�r�rr�r��	arg_plistrLr.r.r1�test_arg_plistEmptyLine1rz/IMAP4ServerParsingTests.test_arg_plistEmptyLinecC�,|�tj|jjd�|�tj|jjd�dS)ze
        A parenthesized with unmatched parentheses raises
        L{IllegalClientResponse}.
        s(foosfoo)NrrLr.r.r1�"test_arg_plistUnmatchedParentheses7�z:IMAP4ServerParsingTests.test_arg_plistUnmatchedParenthesescCr)zH
        An empty file literal raises L{IllegalClientResponse}.
        r�N�r�rr�r��arg_literalrLr.r.r1�test_arg_literalEmptyLine?rz1IMAP4ServerParsingTests.test_arg_literalEmptyLinecCr)zZ
        A literal with unmatched braces raises
        L{IllegalClientResponse}.
        s{10s10}NrrLr.r.r1�test_arg_literalUnmatchedBracesErz7IMAP4ServerParsingTests.test_arg_literalUnmatchedBracescCr)z\
        A non-integral literal size raises
        L{imap4.IllegalClientResponse}.
        rNrrLr.r.r1�"test_arg_literalInvalidLiteralSizeMrz:IMAP4ServerParsingTests.test_arg_literalInvalidLiteralSizecCs$d}|j�|�\}}|�|d�dS)zH
        A sequence set returns the unparsed portion of a line.
        s1:* blah blah blahsblah blah blahN)r��
arg_seqsetr?)rB�sequencer�r�r.r.r1�test_arg_seqsetReturnsRestVsz2IMAP4ServerParsingTests.test_arg_seqsetReturnsRestcCr)zL
        An invalid sequence raises L{imap4.IllegalClientResponse}.
        sx:yN)r�rr�r�r#rLr.r.r1�test_arg_seqsetInvalidSequence^rz6IMAP4ServerParsingTests.test_arg_seqsetInvalidSequencecCs0d}|j�|�\}}|�||g�|�|�dS)zJ
        A single flag that is not contained in a list is parsed.
        sflagN)r��arg_flaglistr?r-)rB�flagrar�r.r.r1�test_arg_flaglistOneFlagdsz0IMAP4ServerParsingTests.test_arg_flaglistOneFlagcCr)zk
        A list of flags with unmatched parentheses raises
        L{imap4.IllegalClientResponse}.
        s(invalidN�r�rr�r�r'rLr.r.r1�&test_arg_flaglistMismatchedParentehsesms
�z>IMAP4ServerParsingTests.test_arg_flaglistMismatchedParentehsescCr)zo
        A list of flags that contains a malformed flag raises
        L{imap4.IllegalClientResponse}.
        s	(first )s(first second)Nr*rLr.r.r1�test_arg_flaglistMalformedFlagxs��z6IMAP4ServerParsingTests.test_arg_flaglistMalformedFlagcC�.d}|j�|�\}}|�|�|�||�dS)z�
        A line that does not begin with an open parenthesis (C{(}) is
        parsed as L{None}, and the remainder is the whole line.
        snot (N)r��	opt_plistr&r?)rBr{�plist�	remainderr.r.r1�$test_opt_plistMissingOpenParenthesis��
z<IMAP4ServerParsingTests.test_opt_plistMissingOpenParenthesiscCr-)z�
        A line that does not begin with a double quote (C{"}) is
        parsed as L{None}, and the remainder is the whole line.
        snot "N)r��opt_datetimer&r?)rBr{�dtr0r.r.r1�!test_opt_datetimeMissingOpenQuote�r2z9IMAP4ServerParsingTests.test_opt_datetimeMissingOpenQuotecC�d}|�tj|jj|�dS)zx
        A line that does not have a closing double quote (C{"}) raises
        L{imap4.IllegalClientResponse}.
        s"21-Jul-2017 19:37:07 -0700N)r�rr�r�r3rzr.r.r1�"test_opt_datetimeMissingCloseQuote��z:IMAP4ServerParsingTests.test_opt_datetimeMissingCloseQuotecCr6)z�
        A line that contains C{CHARSET} but no character set
        identifier raises L{imap4.IllegalClientResponse}.
        rhN)r�rr�r��opt_charsetrzr.r.r1�!test_opt_charsetMissingIdentifier�r8z9IMAP4ServerParsingTests.test_opt_charsetMissingIdentifiercC�0d}|j�|�\}}|�|d�|�|d�dS)z�
        A line that ends with a C{CHARSET} identifier is parsed as
        that identifier, and the remainder is the empty string.
        s
CHARSET UTF-8�UTF-8r�N�r�r9r?�rBr{�
identifierr0r.r.r1�test_opt_charsetEndOfLine�sz1IMAP4ServerParsingTests.test_opt_charsetEndOfLinecCr;)z�
        A line that has additional data after a C{CHARSET} identifier
        is parsed as that identifier, and the remainder is that
        additional data.
        sCHARSET UTF-8 remainderr<s	remainderNr=r>r.r.r1�test_opt_charsetWithRemainder�sz5IMAP4ServerParsingTests.test_opt_charsetWithRemainderN)+rirjrkrr�r�r�r�r�r�r�r�r�r�r�rrrrrr
r
rrrrrrrr r!r"r%r&r)r+r,r1r5r7r:r@rAr.r.r.r1r�sR
						


r�c@speZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�ZdS)�IMAP4ServerSearchTestszS
    Tests for the behavior of the search_* functions in L{imap4.IMAP4Server}.
    cCsDt�|�dg|_dg|_dg|_d|_tddigddd	d�|_dS)
Nz10-Dec-2009z13-Dec-2009z16-Dec-2009rr@zMon, 13 Dec 2009 21:25:10 GMTz13 Dec 2009 00:00:00 GMTr���)r�r��earlierQuery�
sameDateQuery�
laterQuery�seqr�r�rLr.r.r1r��s

�zIMAP4ServerSearchTests.setUpcC�<|�|j�|j|j|j��|�|j�|j|j|j��dS)z�
        L{imap4.IMAP4Server.search_SENTBEFORE} returns True if the message date
        is earlier than the query date.
        N)r-r��search_SENTBEFORErDrGr�r/rFrLr.r.r1�test_searchSentBefore����z,IMAP4ServerSearchTests.test_searchSentBeforecCs^|�|j�dg|j|jd��|�|j�dg|j|jd��|�|j�dg|j|jd��dS)zq
        L{imap4.IMAP4Server.search_UID} returns True if the message UID is in
        the search range.
        r�)r�rCs2:*r�N)r-r��
search_UIDrGr�r/rLr.r.r1�test_searchWildcard�s
�"z*IMAP4ServerSearchTests.test_searchWildcardcCs"|�|j�dg|j|jd��dS)z�
        L{imap4.IMAP4Server.search_UID} should return True if there is a
        wildcard, because a wildcard means "highest UID in the mailbox".
        s1235:*)rCr�N)r/r�rLrGr�rLr.r.r1�test_searchWildcardHigh�s�z.IMAP4ServerSearchTests.test_searchWildcardHighcCs"t�d�}|�t|�gd��dS)�|
        L{imap4.IMAP4Server.search_SENTON} returns True if the message date is
        the same as the query date.
        r�rN)rr�r?r�)rB�msgsetr.r.r1�test_reversedSearchTerms�s
z/IMAP4ServerSearchTests.test_reversedSearchTermscCsX|�|j�|j|j|j��|�|j�|j|j|j��|�|j�|j|j|j��dS)rON)	r-r��
search_SENTONrDrGr�r/rErFrLr.r.r1�test_searchSentOn���� z(IMAP4ServerSearchTests.test_searchSentOncCrH)z~
        L{imap4.IMAP4Server.search_SENTSINCE} returns True if the message date
        is later than the query date.
        N)r/r��search_SENTSINCErDrGr�r-rFrLr.r.r1�test_searchSentSince
rKz+IMAP4ServerSearchTests.test_searchSentSincecCs�|�|j�dg|jdg|j|j|jd��|�|j�dg|jdg|j|j|jd��|�|j�dg|jdg|j|j|jd��dS)z�
        L{imap4.IMAP4Server.search_OR} returns true if either of the two
        expressions supplied to it returns true and returns false if neither
        does.
        �	SENTSINCEr��SENTONN)r/r��	search_ORrDrFrGr�r-rLr.r.r1�
test_searchOr
s0������z$IMAP4ServerSearchTests.test_searchOrcCsL|�|j�dg|j|j|jd��|�|j�dg|j|j|jd��dS)z~
        L{imap4.IMAP4Server.search_NOT} returns the negation of the result
        of the expression supplied to it.
        rWr�rXN)r-r��
search_NOTrDrGr�r/rFrLr.r.r1�test_searchNot3
s����z%IMAP4ServerSearchTests.test_searchNotcC�X|�|j�|j|j|j��|�|j�|j|j|j��|�|j�|j|j|j��dS)z�
        L{imap4.IMAP4Server.search_BEFORE} returns True if the
        internal message date is before the query date.
        N)	r-r��
search_BEFORErDrGr�rEr/rFrLr.r.r1�test_searchBeforeC
rTz(IMAP4ServerSearchTests.test_searchBeforecCsX|�|j�|j|j|j��|�|j�|j|j|j��|�|j�|j|j|j��dS)z�
        L{imap4.IMAP4Server.search_ON} returns True if the
        internal message date is the same as the query date.
        N)r-r��	search_ONrDrGr�rErFrLr.r.r1�
test_searchOnP
s z$IMAP4ServerSearchTests.test_searchOncCr])z�
        L{imap4.IMAP4Server.search_SINCE} returns True if the
        internal message date is greater than the query date.
        N)	r/r��search_SINCErDrGr�rEr-rFrLr.r.r1�test_searchSinceY
s
� z'IMAP4ServerSearchTests.test_searchSinceN)rirjrkrr�rJrMrNrQrSrVrZr\r_rarcr.r.r.r1rB�s	

	rBc@s&eZdZdZdZddd�Zdd�ZdS)rpz�
    A L{IRealm} for tests.

    @cvar theAccount: An C{Account} instance.  Tests can set this to
        ensure predictable account retrieval.
    Ncs(�r�fdd��_dS�fdd��_dS)ab
        Create a realm for testing.

        @param accountHolder: (optional) An object whose C{theAccount}
            attribute will be returned instead of
            L{TestRealm.theAccount}.  Attribute access occurs on every
            avatar request, so any modifications to
            C{accountHolder.theAccount} will be reflected here.
        crr-�r|r.rlr.r1r2{
r3z$TestRealm.__init__.<locals>.<lambda>crr-rdr.rLr.r1r2}
r3N)�_getAccount)rBrmr.)rmrBr1rpp
s
zTestRealm.__init__cGstj|��dd�fS)NcSr2r-r.r.r.r.r1r2�
r�z)TestRealm.requestAvatar.<locals>.<lambda>)r�IAccountre)rB�avatarId�mindrr.r.r1r�
�zTestRealm.requestAvatarr-)rirjrkrr|rpr�r.r.r.r1rpe
s

rpc@s,eZdZeefZddiZdd�Zdd�ZdS)�TestCheckerrk�secretcCs2|j|jvrt�|j|j|j��|j|j�SdSr-)�usernamerr�
maybeDeferred�
checkPasswordr��_cbCheck�rB�credentialsr.r.r1�requestAvatarId�
s���zTestChecker.requestAvatarIdcCs|r|St��r-r)rBr/rlr.r.r1ro�
szTestChecker._cbCheckN)	rirjrkrr�credentialInterfacesrrrror.r.r.r1rj�
s
rjc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)S)*�AuthenticatorTestscCsNt�|�t�}td�|_t|�|_|j�t��|j|j	_d|_
|j|_dS)Nrkr)r�r�rprgr|rrsrtrjr��
authenticatedr�)rBrxr.r.r1r��
s



zAuthenticatorTests.setUpcCs�ttt�Gdd�d��}|�}tt|�t�d|i�}|j|_t�}|�|�|�	|j
t�d��|�
d|���|��|�d�|�
t�|���|���|��|�t�d�d�|�|��d	�d
S)z�
        L{imap4.IMAP4Server} accepts a L{dict} mapping challenge type
        names to L{twisted.mail.interfaces.IChallengeResponse}
        providers.
        c@rl)
z>AuthenticatorTests.test_customChallengers.<locals>.SPECIALAuthcSr()N�SPECIALr.rLr.r.r1�getChallenge�
r*zKAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.getChallengecSs|�dd�\|_|_dSr,)�splitrl�password�rB�responser.r.r1�setResponse�
�zJAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.setResponsecSr(�NFr.rLr.r.r1�moreChallenges�
r*zMAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.moreChallengescSs|j|_dSr-)ry)rBryr.r.r1rn�
r5zLAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.checkPasswordN)rirjrkrwr|rrnr.r.r.r1�SPECIALAuth�
s
r�rv�Connection done.sAUTH=SPECIALs001 AUTHENTICATE SPECIAL
susername passwordr_s"001 OK Authentication successful
N)rrrr
rrorsr'r��
addCleanupr�rr�r�r�r��dataReceived�base64�	b64encoderwr?)rBr��specialr�r�r.r.r1�test_customChallengers�
s 


z)AuthenticatorTests.test_customChallengerscCsZt��}|j|_t�}|�|�|�|jt�d��|�	�|�
d�|�|��d�dS)z_
        An unsupported C{AUTHENTICATE} method results in a negative
        response.
        r�s001 AUTHENTICATE UNKNOWN
s(001 NO AUTHENTICATE method unsupported
N)
rrorsr'r�r�r�rr�r�r�r?r�)rBr�r�r.r.r1�test_unsupportedMethod�
s

�z)AuthenticatorTests.test_unsupportedMethodcsxtj�jjd<t�d�}�j�|�d�j_�fdd�}�j�	t
|��}|��jd�|�
�j�j�t�|���g�S)zv
        An L{imap4.IMAP4Server} that is missing a L{Portal} responds
        negatively to an authentication
        rrkNcr"�Nrk�r��authenticater.rLr.r1r��
r5z3AuthenticatorTests.test_missingPortal.<locals>.auths Temporary authentication failure)r�LOGINCredentialsr�r��LOGINAuthenticatorr��registerAuthenticatorrsr�r�r4r�r�rBr�r�rr�r )rB�cAuthr�r�r.rLr1�test_missingPortal�
s
�z%AuthenticatorTests.test_missingPortalcs�tt�Gdd�d��}tt�Gdd�d��}|�}tt|�|�jjd<�j�|���fdd�}�j�	t
|��}|��jdt
|j��d	��|��j�j�t�|���g�S)
z�
        When a challenger's
        L{getChallenge<IChallengeResponse.getChallenge>} method raises
        any exception, a C{NO} response is sent.
        c@�(eZdZdZdd�Zdd�Zdd�ZdS)	zRAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallengesA challenge failurecSs
t|j��r-)r�r?rLr.r.r1rwrqz_AuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenge.getChallengecSr(�zw
                Never called.

                @param response: See L{IChallengeResponse.setResponse}
                Nr.rzr.r.r1r|r�z^AuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenge.setResponsecSr(�z/
                Never called.
                Nr.rLr.r.r1rr�zaAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenge.moreChallengesN�rirjrkr?rwr|rr.r.r.r1�ValueErrorAuthChallenge�
�
r�c@�eZdZdd�Zdd�ZdS)zRAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthenticatorcSr()N�ERRORr.rLr.r.r1�getNamer*zZAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthenticator.getNamecSr()NsIGNOREDr.)rB�secret�chalr.r.r1�challengeResponser*zdAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthenticator.challengeResponseN)rirjrkr�r�r.r.r.r1�ValueErrorAuthenticator�r�r�cr"r�r�r.rLr.r1r�r5z?AuthenticatorTests.test_challengerRaisesException.<locals>.authzServer error: r�)rrrr
r�r�r�r�r�r�r4r�r�r�r?r@rBr�r�rr�r )rBr�r��badr�r�r.rLr1�test_challengerRaisesException�
s 
�z1AuthenticatorTests.test_challengerRaisesExceptioncCs�tt�Gdd�d��}|�}tt|�t��}|j|_||jd<t�}|�|�|�	|j
t�d��|�
d|���|��|�d�|�
t�|���|���|��|�d�|�|��d�d	|jd
g��dS)z�
        A client that responds with a challenge that cannot be decoded
        as Base 64 receives an L{IllegalClientResponse}.
        c@r�)	zEAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallengesMalformed Response - not base64cSr()Ns
SomeChallenger.rLr.r.r1rw4r*zRAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenge.getChallengecSr(r�r.rzr.r.r1r|7r�zQAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenge.setResponsecSr(r�r.rLr.r.r1r>r�zTAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenge.moreChallengesNr�r.r.r.r1�NotBase64AuthChallenge0r�r�s	NOTBASE64r�sAUTH=NOTBASE64s001 AUTHENTICATE NOTBASE64
s Not base64
r�s001 NO Authentication failed: r_N)rrr
rrorsr�r'r�r�r�rr�r�r�r�r�r�r�rwr?r�r?)rBr��	notBase64r�r�r.r.r1�test_authNotBase64*s(




�z%AuthenticatorTests.test_authNotBase64cs�t�}t|�}|�j_tj�jjd<}tt|�t�	d�}�j
�|��fdd�}�j�
t|��}|��jd�|��j�j�t����|g�}|S)z�
        A challenger that causes the login to fail
        L{UnhandledCredentials} results in an C{NO} response.

        @return: A L{Deferred} that fires when the authorization has
            failed.
        rrkcr"r�r�r.rLr.r1r�rr5z:AuthenticatorTests.test_unhandledCredentials.<locals>.auths+Authentication failed: server misconfigured)rprr�rsrr�r�rrr�r�r�r�r�r4r�r�rBr�r�rr�r )rBrxrs�	loginCredr�r�r�r�r.rLr1�test_unhandledCredentials]s 

�z,AuthenticatorTests.test_unhandledCredentialsc
s�Gdd�dt��G�fdd�d�}t�}t|�}|�|��|�j_tj�jjd<}t	t
|�t�d�}�j�
|��fdd�}��fd	d
�}�j�t|��}|��jd�|�t|��|��j�j�t����|g�}	|	S)z�
        If the portal raises an exception other than
        L{UnauthorizedLogin} or L{UnhandledCredentials}, the server
        responds with a C{BAD} response and the exception is logged.
        c@rf)zKAuthenticatorTests.test_unexpectedLoginFailure.<locals>.UnexpectedExceptionr�Nrhr.r.r.r1r��rir�cs$eZdZdZeefZ�fdd�ZdS)zFAuthenticatorTests.test_unexpectedLoginFailure.<locals>.FailingCheckerzz
            A credentials checker whose L{requestAvatarId} method
            raises L{UnexpectedException}.
            cr�)NzUnexpected error.r.rpr�r.r1rr�rbzVAuthenticatorTests.test_unexpectedLoginFailure.<locals>.FailingChecker.requestAvatarIdN)rirjrkrrrrsrrr.r�r.r1�FailingChecker�sr�rrkcr"r�r�r.rLr.r1r��r5z<AuthenticatorTests.test_unexpectedLoginFailure.<locals>.authcr�r-r�r.rr.r1�assertUnexpectedExceptionLogged�rizWAuthenticatorTests.test_unexpectedLoginFailure.<locals>.assertUnexpectedExceptionLoggeds'Server error: login failed unexpectedly)r�rprrtr�rsrr�r�rrr�r�r�r�r�r4r�r�rBr�r�rr�r )
rBr�rxrsr�r�r�r�r�r�r.rr1�test_unexpectedLoginFailure~s(

�z.AuthenticatorTests.test_unexpectedLoginFailurecs�t�jjd<t�d�}�j�|��fdd�}�fdd�}�j�t	|��}|�
t	|��j�|�
�j�j���
�}t�||g�}|��j�S)Nr�rkcr"r�r�r.rLr.r1r��r5z,AuthenticatorTests.testCramMD5.<locals>.authcr�r,�rur.rLr.r1�authed�rqz.AuthenticatorTests.testCramMD5.<locals>.authed)rr�r�r�CramMD5ClientAuthenticatorr�r�r�r�r4rBr�r�r rr��_cbTestCramMD5)rBr�r�r�r�r�r�r.rLr1�testCramMD5�s
zAuthenticatorTests.testCramMD5cC�$|�|jd�|�|jj|j�dSr,�r?rur�r�r�r.r.r1r��r�z!AuthenticatorTests._cbTestCramMD5cs�t�jjd<t�d�}�j�|��fdd�}�fdd�}�fdd�}�j�t	|��}|�
t	|�t	|��|�
�j�j�t
����|g�}|��j�S)	Nr�rkcr"�Nsnot the secretr�r.rLr.r1�misauth�r5z5AuthenticatorTests.testFailedCramMD5.<locals>.misauthcr�r,r�r.rLr.r1r��rqz4AuthenticatorTests.testFailedCramMD5.<locals>.authedcr��N���r�r.rLr.r1�	misauthed�rqz7AuthenticatorTests.testFailedCramMD5.<locals>.misauthed)rr�r�rr�r�r�r�r�r4rBr�r�rr�r �_cbTestFailedCramMD5�rBr�r�r�r�r�r�r.rLr1�testFailedCramMD5�s
z$AuthenticatorTests.testFailedCramMD5cC�"|�|jd�|�|jjd�dSr�r�r�r.r.r1r���z'AuthenticatorTests._cbTestFailedCramMD5c�tj�jjd<}tt|�t�d�}�j�|��fdd�}�fdd�}�j	�
t|��}|�t|��j
�|��j�j
�t����|g�}|�
�j�S)Nrrkcr"r�r�r.rLr.r1r��r5z*AuthenticatorTests.testLOGIN.<locals>.authcr�r,r�r.rLr.r1r��rqz,AuthenticatorTests.testLOGIN.<locals>.authed)rr�r�r�rrr�r�r�r�r�r4rBr�r�rr�r �_cbTestLOGIN)rBr�r�r�r�r�r�r.rLr1�	testLOGIN��

zAuthenticatorTests.testLOGINcCr�r,r�r�r.r.r1r��r�zAuthenticatorTests._cbTestLOGINc�tj�jjd<t�d�}�j�|��fdd�}�fdd�}�fdd�}�j�t	|��}|�
t	|�t	|��|�
�j�j�t
����|g�}|��j�S)	Nrrkcr"r�r�r.rLr.r1r��r5z3AuthenticatorTests.testFailedLOGIN.<locals>.misauthcr�r,r�r.rLr.r1r��rqz2AuthenticatorTests.testFailedLOGIN.<locals>.authedcr�r�r�r.rLr.r1r�rqz5AuthenticatorTests.testFailedLOGIN.<locals>.misauthed)rr�r�r�r�r�r�r�r�r4rBr�r�rr�r �_cbTestFailedLOGINr�r.rLr1�testFailedLOGIN��
z"AuthenticatorTests.testFailedLOGINcCr�r�r�r�r.r.r1r�
r�z%AuthenticatorTests._cbTestFailedLOGINcr�)Nrgrkcr"r�r�r.rLr.r1r�r5z*AuthenticatorTests.testPLAIN.<locals>.authcr�r,r�r.rLr.r1r�rqz,AuthenticatorTests.testPLAIN.<locals>.authed)r�PLAINCredentialsr�r�rr�PLAINAuthenticatorr�r�r�r�r4rBr�r�rr�r �_cbTestPLAIN)rB�	plainCredr�r�r�r�r�r.rLr1�	testPLAINr�zAuthenticatorTests.testPLAINcCr�r,r�r�r.r.r1r�"r�zAuthenticatorTests._cbTestPLAINcr�)	Nrgrkcr"r�r�r.rLr.r1r�+r5z3AuthenticatorTests.testFailedPLAIN.<locals>.misauthcr�r,r�r.rLr.r1r�.rqz2AuthenticatorTests.testFailedPLAIN.<locals>.authedcr�r�r�r.rLr.r1r�1rqz5AuthenticatorTests.testFailedPLAIN.<locals>.misauthed)rr�r�r�r�r�r�r�r�r4rBr�r�rr�r �_cbTestFailedPLAINr�r.rLr1�testFailedPLAIN&r�z"AuthenticatorTests.testFailedPLAINcCr�r�r�r�r.r.r1r�:r�z%AuthenticatorTests._cbTestFailedPLAINN)rirjrkr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r.r.r.r1rt�
s*+43!2rtc@r�)	�SASLPLAINTestsz�
    Tests for I{SASL PLAIN} authentication, as implemented by
    L{imap4.PLAINAuthenticator} and L{imap4.PLAINCredentials}.

    @see: U{http://www.faqs.org/rfcs/rfc2595.html}
    @see: U{http://www.faqs.org/rfcs/rfc4616.html}
    cCs>d}d}d}t�|�}|�||�}|�|d|d|�dS)z�
        L{PLAINAuthenticator.challengeResponse} returns challenge strings of
        the form::

            NUL<authn-id>NUL<secret>
        rkrks	challenge�N)rr�r�r?)rBrlr�r�r�r{r.r.r1�#test_authenticatorChallengeResponseHs
z2SASLPLAINTests.test_authenticatorChallengeResponsecCs2t��}|�d�|�|jd�|�|jd�dS)z�
        L{PLAINCredentials.setResponse} parses challenge strings of the
        form::

            NUL<authn-id>NUL<secret>
        stestusersecretrkrkN)rr�r|r?rlry�rB�credr.r.r1�test_credentialsSetResponseVs
z*SASLPLAINTests.test_credentialsSetResponsecCsBt��}|�tj|jd�|�tj|jd�|�tj|jd�dS)z�
        L{PLAINCredentials.setResponse} raises L{imap4.IllegalClientResponse}
        when passed a string not of the expected form.
        shelloshelloworldshelloworldZoom!N)rr�r�r�r|r�r.r.r1�test_credentialsInvalidResponsebs
�
�z.SASLPLAINTests.test_credentialsInvalidResponseN)rirjrkrr�r�r�r.r.r.r1r�?s
r�c@sleZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�UnsolicitedResponseTestsc�\�fdd�}�fdd�}�j�t|��}|�t|����j�t����|g�}|��j�S)Ncr�r�r�r.rLr.r1r�sr.z5UnsolicitedResponseTests.testReadWrite.<locals>.logincr;r,�r�r�r.rLr.r1rTvr�z8UnsolicitedResponseTests.testReadWrite.<locals>.loggedIn)	r�r�r4r�r�rr�r �_cbTestReadWrite�rBr�rTr�r�r.rLr1�
testReadWriter�z&UnsolicitedResponseTests.testReadWritecC�|jj}|�|ddgg�dS)Nr�r��r�r�r?�rBr��Er.r.r1r�~�z)UnsolicitedResponseTests._cbTestReadWritecr�)Ncr�r�r�r.rLr.r1r��r.z4UnsolicitedResponseTests.testReadOnly.<locals>.logincr;r>r�r.rLr.r1rT�r�z7UnsolicitedResponseTests.testReadOnly.<locals>.loggedIn)	r�r�r4r�r�rr�r �_cbTestReadOnlyr�r.rLr1�testReadOnly�r�z%UnsolicitedResponseTests.testReadOnlycCr�)Nr�rr�r�r.r.r1r��r�z(UnsolicitedResponseTests._cbTestReadOnlycsrddggdgd���fdd�}��fdd�}�j�t|��}|�t|����j�t����|g�}|��j��S)	N�	\AnsweredrC�\Recent)r�r�r�cr�r�r�r.rLr.r1r��r.z6UnsolicitedResponseTests.testFlagChange.<locals>.logincs�j���dSr-)r�r�r.�rorBr.r1rT�r�z9UnsolicitedResponseTests.testFlagChange.<locals>.loggedIn)	r�r�r4r�r�rr�r �_cbTestFlagChanger�r.r�r1�testFlagChange�sz'UnsolicitedResponseTests.testFlagChangecCsJ|jj}dd�|��D�}|jdd�d�|jdd�d�|�||�dS)NcSs g|]}d|d|dig�qS)r�rr�r.)r
r5r.r.r1r��s z>UnsolicitedResponseTests._cbTestFlagChange.<locals>.<listcomp>cS�|dSr>r.�rfr.r.r1r2��z<UnsolicitedResponseTests._cbTestFlagChange.<locals>.<lambda>)�keycSr�r>r.r�r.r.r1r2�r�)r�r��itemsr�r?)rBr�ror��expectr.r.r1r��s
z*UnsolicitedResponseTests._cbTestFlagChangecr�)Ncr�r�r�r.rLr.r1r��r.z7UnsolicitedResponseTests.testNewMessages.<locals>.logincs�j�dd�dS�Nr��r�r�r.rLr.r1rT�r�z:UnsolicitedResponseTests.testNewMessages.<locals>.loggedIn)	r�r�r4r�r�rr�r �_cbTestNewMessagesr�r.rLr1�testNewMessages�r�z(UnsolicitedResponseTests.testNewMessagescC�|jj}|�|gd�g�dS)N)r�r�Nr�r�r.r.r1r��r�z+UnsolicitedResponseTests._cbTestNewMessagescr�)Ncr�r�r�r.rLr.r1r��r.z=UnsolicitedResponseTests.testNewRecentMessages.<locals>.logincs�j�dd�dSr�r�r.rLr.r1rT�r�z@UnsolicitedResponseTests.testNewRecentMessages.<locals>.loggedIn)	r�r�r4r�r�rr�r �_cbTestNewRecentMessagesr�r.rLr1�testNewRecentMessages�r�z.UnsolicitedResponseTests.testNewRecentMessagescCr�)N�r�Nr�r�r�r.r.r1r��r�z1UnsolicitedResponseTests._cbTestNewRecentMessagescr�)Ncr�r�r�r.rLr.r1r��r.z@UnsolicitedResponseTests.testNewMessagesAndRecent.<locals>.logincs�j�dd�dS)Nr�r�r�r.rLr.r1rT�r�zCUnsolicitedResponseTests.testNewMessagesAndRecent.<locals>.loggedIn)	r�r�r4r�r�rr�r �_cbTestNewMessagesAndRecentr�r.rLr1�testNewMessagesAndRecent�r�z1UnsolicitedResponseTests.testNewMessagesAndRecentcCs$|jj}|�|gd�gd�g�dS)N)r�r�Nr�r�r�r.r.r1r��r�z4UnsolicitedResponseTests._cbTestNewMessagesAndRecentN)rirjrkr�r�r�r�r�r�r�r�r�r�r�r�r.r.r.r1r�qsr�c@�0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�ClientCapabilityTestszT
    Tests for issuance of the CAPABILITY command and handling of its response.
    cCs0t�|_t��|_|j�|j�|j�d�dS)zS
        Create an L{imap4.IMAP4Client} connected to a L{StringTransport}.
        s* OK [IMAP4rev1]
N)r'r�rr~�protocolr�r�rLr.r.r1r��s
zClientCapabilityTests.setUpc�@�jjdd�}�j�d��j�d��fdd�}|�|�|S)z�
        A capability response consisting only of atoms without C{'='} in them
        should result in a dict mapping those atoms to L{None}.
        F��useCaches&* CAPABILITY IMAP4rev1 LOGINDISABLED
�0001 OK Capability completed.
cs��|ddd��dS)N)r�s
LOGINDISABLEDr���capabilitiesrLr.r1�gotCapabilities��z?ClientCapabilityTests.test_simpleAtoms.<locals>.gotCapabilities�r�r�r�r��rB�capabilitiesResultr�r.rLr1�test_simpleAtoms�s
z&ClientCapabilityTests.test_simpleAtomscr�)a�
        A capability response consisting of atoms including C{'='} should have
        those atoms split on that byte and have capabilities in the same
        category aggregated into lists in the resulting dictionary.

        (n.b. - I made up the word "category atom"; the protocol has no notion
        of structure here, but rather allows each capability to define the
        semantics of its entry in the capability response in a freeform manner.
        If I had realized this earlier, the API for capabilities would look
        different.  As it is, we can hope that no one defines any crazy
        semantics which are incompatible with this API, or try to figure out a
        better API when someone does. -exarkun)
        Fr�s.* CAPABILITY IMAP4rev1 AUTH=LOGIN AUTH=PLAIN
r�cs��|dddgd��dS)Nrrg)r�r�r�r�rLr.r1r�s�zAClientCapabilityTests.test_categoryAtoms.<locals>.gotCapabilitiesr�r�r.rLr1�test_categoryAtoms�s
z(ClientCapabilityTests.test_categoryAtomscr�)z�
        A capability response consisting of both simple and category atoms of
        the same type should result in a list containing L{None} as well as the
        values for the category.
        Fr�s0* CAPABILITY IMAP4rev1 FOO FOO=BAR BAR=FOO BAR
r�cs ��|dddgddgd��dS)N�BAR�FOO)r�rrr�r�rLr.r1r�s�z>ClientCapabilityTests.test_mixedAtoms.<locals>.gotCapabilitiesr�r�r.rLr1�test_mixedAtomss�
z%ClientCapabilityTests.test_mixedAtomsN)rirjrkrr�rrrr.r.r.r1r��s	r�c@� eZdZdZdd�Zdd�ZdS)�StillSimplerClientzH
    An IMAP4 client which keeps track of unsolicited flag changes.
    cCstj�|�i|_dSr-)rr~rprorLr.r.r1rp,�
zStillSimplerClient.__init__cCs|j�|�dSr-)ror�r�r.r.r1r�0r�zStillSimplerClient.flagsChangedN)rirjrkrrpr�r.r.r.r1r'src@sTeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�ZdS)�HandCraftedTestscspt��t���������d���fdd����fdd����fdd�}��dd�}��d	�|�|�|S)
N�* OK [IMAP4rev1]cs�������dd�dS)Nr�s0003 FETCH 1 (RFC822)�r?r�r>�r��rBr�r.r1�cbCheckTransport;s�z>HandCraftedTests.testTrailingLiteral.<locals>.cbCheckTransportcs,��d�}��d���d�|���|S)Nr�s6* 1 FETCH (RFC822 {10}
0123456789
 RFC822.SIZE 10)
s0003 OK FETCH
)�fetchMessager�r��r�r�)r�rr.r1�cbSelectAs
�

z6HandCraftedTests.testTrailingLiteral.<locals>.cbSelectcs"��d�}��d�|���|S�NrF�0002 OK SELECT)rdryr�r)r�rr.r1�cbLoginJs


z5HandCraftedTests.testTrailingLiteral.<locals>.cbLogin�blah�0001 OK LOGIN
)r'rr~r�ryr�r�r�)rBrr�r.)r�rrrBr�r1�testTrailingLiteral5s

	

z$HandCraftedTests.testTrailingLiteralcCs�|jj�dd�t�}|j�|�|��|j�d�|�|��d�|��|j�d�|�|��d�|��|j�d�|�	|���|j�d�|�|��d	�|�|jj
d
�|j�t�
d��dS)
z]
        String literals whose data is not immediately available are
        parsed.
        rkrns01 LOGIN {8}
s+ Ready for 8 octets of text
stestuser {13}
s+ Ready for 13 octets of text
spasswords-test
�01 OK LOGIN succeeded
r�r�N)r�rrrqr'r�r�r�r?r��	assertNotr�r�rr�r
r.r.r1�test_fragmentedStringLiteralsUs z.HandCraftedTests.test_fragmentedStringLiteralscCs�ddi|jj_t�}|j�|�|��|j�d�|�|��d�|��|j�d�|�|��d�|�|jj	d�|j�
t�d��dS)	z3
        Empty string literals are parsed.
        r�s01 LOGIN {0}
s+ Ready for 0 octets of text
s{0}
rr�r�N)
r�rrrr'r�r�r�r?r�r�r�rr�r
r.r.r1�test_emptyStringLiteralosz(HandCraftedTests.test_emptyStringLiteralc�tt��t��������d��fdd�}�fdd�}�fdd�}���fdd	�}|��t|���t|���|�S)
a^
        If unsolicited data is received along with solicited data in the
        response to a I{FETCH} command issued by L{IMAP4Client.fetchSpecific},
        the unsolicited data is passed to the appropriate callback and not
        included in the result with which the L{Deferred} returned by
        L{IMAP4Client.fetchSpecific} fires.
        r
c���dd�}��d�|S�Nrr�r�r�r�r�r.r1r���
zRHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.loginc���d�}��d�|Sr�rdryr�r�r.r1rd��

zSHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.selectcsz�jdddgd�}��d���d���d���d���d	���d
���d���d���d���d�|S)
Nr��
HEADER.FIELDS�SUBJECT��
headerType�
headerArgss1* 1 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {38}
s$Subject: Suprise for your woman...
r_�)
s* 1 FETCH (FLAGS (\Seen))
s1* 2 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {75}
sISubject: What you been doing. Order your meds here . ,. handcuff madsen
�0003 OK FETCH completed
��
fetchSpecificr�r�r�r.r1rO�s �





�


zRHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.fetchcs^�������dd���|dddggdggdddggdggd�����jd	d
gi�dS)Nr��,0003 FETCH 1:* BODY[HEADER.FIELDS (SUBJECT)]r�r$r%z&Subject: Suprise for your woman...

zKSubject: What you been doing. Order your meds here . ,. handcuff madsen

�r�r�r��\Seen�r?r�r>ro��res�r�rBr�r.r1rG�s&���	����zQHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.test�r'rr�ryr�r4�rBr�rdrOrGr.r3r1�2test_unsolicitedResponseMixedWithSolicitedResponse�s



�zCHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponsecs�t��t���������d��fdd�}�fdd�}�fdd�}��fdd	�}|�}|�t|��|�t|��|�|�|S)
zf
        Literals should be recognized even when they are not preceded by
        whitespace.
        r
crrrr��r�r.r1r��r zFHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.logincr!)N�inboxrr"r�r7r.r1rd�r#zGHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.selectcs*�jdddgd�}��d���d�|S)Nr�r$r%r&s8* 1 FETCH (BODY[HEADER.FIELDS ({7}
SUBJECT)] "Hello")
r*r+r�r7r.r1rO�s��
zFHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.fetchcs:�������dd���|ddddggdggi�dS)Nr�r-r�r�r$r%�Hellorr�r
r.r1rG�s��zEHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.test�r'rr~r�ryr�r4)rBr�rdrOrGr�r.�r�rBr�r1�&test_literalWithoutPrecedingWhitespace�s


	
z7HandCraftedTests.test_literalWithoutPrecedingWhitespacecspt��t���������d��fdd�}�fdd�}���fdd�}|�}|�t|��|�t|��|S)z�
        If the server sends a literal length which cannot be parsed as an
        integer, L{IMAP4Client.lineReceived} should cause the protocol to be
        disconnected by raising L{imap4.IllegalServerResponse}.
        r
crrrr�r7r.r1r�r z<HandCraftedTests.test_nonIntegerLiteralLength.<locals>.logincr!rr"r�r7r.r1rd
r#z=HandCraftedTests.test_nonIntegerLiteralLength.<locals>.selectcs@�jdddgd��������dd���tj�jd�dS)Nr�r$r%r&r�r-s* 1 FETCH {xyz}
...)r,r?r�r>r�r�IllegalServerResponser�r.r;r.r1rOs���z<HandCraftedTests.test_nonIntegerLiteralLength.<locals>.fetchr:)rBr�rdrOr�r.r;r1�test_nonIntegerLiteralLength�s

z-HandCraftedTests.test_nonIntegerLiteralLengthcsrt�}t����|���d��fdd�}�fdd�}�fdd�}��fdd	�}|��t|���t|���|�S)
a
        Any unrequested flag information received along with other requested
        information in an untagged I{FETCH} received in response to a request
        issued with L{IMAP4Client.fetchSpecific} is passed to the
        C{flagsChanged} callback.
        r
crrrr�r�r.r1r�3r zLHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.logincr!rr"r�r�r.r1rd8r#zMHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.selectcs\�jdddgd�}��d���d���d���d���d	���d
���d�|S)Nr�r$r%r&s1* 1 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {22}
sSubject: subject one
s FLAGS (\Recent))
s?* 2 FETCH (FLAGS (\Seen) BODY[HEADER.FIELDS ("SUBJECT")] {22}
sSubject: subject two
r)r*r+r�r�r.r1rO=s�


�


zLHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.fetchcsJ��|dddggdggdddggdggd�����jdgdgd��dS)	Nr�r$r%zSubject: subject one
zSubject: subject two
r.r�r/)r?ror1�r�rBr.r1rGNs��	����zKHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.testr4)rBr�r�rdrOrGr.r?r1�,test_flagsChangedInsideFetchSpecificResponse's



�z=HandCraftedTests.test_flagsChangedInsideFetchSpecificResponsecr)
a
        Any unrequested flag information received along with other requested
        information in an untagged I{FETCH} received in response to a request
        issued with L{IMAP4Client.fetchMessage} is passed to the
        C{flagsChanged} callback.
        r
crrrr�r�r.r1r�xr zKHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.logincr!rr"r�r�r.r1rd}r#zLHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.selectcsT��d�}��d���d���d���d���d���d���d�|S)	Nr�s* 1 FETCH (RFC822 {24}
sSubject: first subject
s FLAGS (\Seen))
s.* 2 FETCH (FLAGS (\Recent \Seen) RFC822 {25}
sSubject: second subject
r)r*)rr�r�r�r.r1rO�s







zKHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.fetchcsP�������dd���|ddiddid�����jdgddgd��dS)	Nr�s0003 FETCH 1:* (RFC822)ryzSubject: first subject
zSubject: second subject
r.r/r�r0r1r3r.r1rG�s���zJHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.testr4r5r.r3r1�+test_flagsChangedInsideFetchMessageResponsels



�z<HandCraftedTests.test_flagsChangedInsideFetchMessageResponsecCs�t�}t��}||_|�|�|�d�t�d�}|�|�|�d�}|�	|t
j�|�d�|�
tj�}|�t|�d�|�|djjdd�|S)z�
        When decoding a base64 encoded authentication message from the server,
        decoding errors are logged and then the client closes the connection.
        sP* OK [CAPABILITY IMAP4rev1 IDLE NAMESPACE AUTH=CRAM-MD5] Twisted IMAP4rev1 Readyrkr�s+ Something bad! and bad
r�rsSomething bad! and bad)r(rr~r�r�ryr�r�r��
assertFailurerr�r�rr=r?r�r�rv)rBr�r�r�r��loggedr.r.r1�-test_authenticationChallengeDecodingException�s 
�



z>HandCraftedTests.test_authenticationChallengeDecodingExceptionN)rirjrkrrrr6r<r>r@rArDr.r.r.r1r	4s L.+E8r	c@s.eZdZUdZejZeejed<dd�Z	dS)�PreauthIMAP4ClientMixinav
    Mixin for L{SynchronousTestCase} subclasses which
    provides a C{setUp} method which creates an L{IMAP4Client}
    connected to a L{StringTransport} and puts it into the
    I{authenticated} state.

    @ivar transport: A L{StringTransport} to which C{client} is
        connected.

    @ivar client: An L{IMAP4Client} which is connected to
        C{transport}.
    �clientProtocolcCs0t�|_|��|_|j�|j�|j�d�dS)zm
        Create an IMAP4Client connected to a fake transport and in the
        authenticated state.
        s* PREAUTH Hello unittest
N)r'r�rFr�r�r�rLr.r.r1r��s
zPreauthIMAP4ClientMixin.setUpN)
rirjrkrrr~rFr	rVr�r.r.r.r1rE�s

rEc@�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"S)#�SelectionTestsMixinzl
    Mixin for test cases which defines tests which apply to both I{EXAMINE} and
    I{SELECT} support.
    cCs2t|j|j�d�}|�|j��d|jd�|S)z�
        Issue either an I{EXAMINE} or I{SELECT} command (depending on
        C{self.method}), assert that the correct bytes are written to the
        transport, and return the L{Deferred} returned by whichever method was
        called.
        �fooboxs0001 s	 foobox
)r�r��methodr?r�r�r��rBr�r.r.r1�_examineOrSelect�s
�z$SelectionTestsMixin._examineOrSelectcGs4|D]
}|j�|d�q|j�d|jd�dS)z�
        Deliver the given (unterminated) response lines to C{self.client} and
        then deliver a tagged SELECT or EXAMINE completion line to finish the
        SELECT or EXAMINE response.
        r_s0001 OK [READ-ONLY] s completed
N)r�r�r�)rB�linesr{r.r.r1�	_response�s
�zSelectionTestsMixin._responsecC�.|��}|�d�|�|�|�ddd��dS)a
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{EXISTS} response, the L{Deferred} return by L{IMAP4Client.select} or
        L{IMAP4Client.examine} fires with a C{dict} including the value
        associated with the C{'EXISTS'} key.
        s
* 3 EXISTSFr�)r.r-N�rLrNr?�successResultOfrKr.r.r1�test_exists��
zSelectionTestsMixin.test_existscC�$|��}|�d�|�|tj�dS)a
        If the server returns a non-integer EXISTS value in its response to a
        I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by
        L{IMAP4Client.select} or L{IMAP4Client.examine} fails with
        L{IllegalServerResponse}.
        s* foo EXISTSN�rLrN�failureResultOfrr=rKr.r.r1�test_nonIntegerExists�
z)SelectionTestsMixin.test_nonIntegerExistscCrO)a
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{RECENT} response, the L{Deferred} return by L{IMAP4Client.select} or
        L{IMAP4Client.examine} fires with a C{dict} including the value
        associated with the C{'RECENT'} key.
        s
* 5 RECENTFr�)r.rNrPrKr.r.r1�test_recentrSzSelectionTestsMixin.test_recentcCrT)a
        If the server returns a non-integer RECENT value in its response to a
        I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by
        L{IMAP4Client.select} or L{IMAP4Client.examine} fails with
        L{IllegalServerResponse}.
        s* foo RECENTNrUrKr.r.r1�test_nonIntegerRecentrXz)SelectionTestsMixin.test_nonIntegerRecentcCrO)a
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{UNSEEN} response, the L{Deferred} returned by L{IMAP4Client.select} or
        L{IMAP4Client.examine} fires with a C{dict} including the value
        associated with the C{'UNSEEN'} key.
        s)* OK [UNSEEN 8] Message 8 is first unseenFr�)r.rNrPrKr.r.r1�test_unseen)rSzSelectionTestsMixin.test_unseencCrT)a
        If the server returns a non-integer UNSEEN value in its response to a
        I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by
        L{IMAP4Client.select} or L{IMAP4Client.examine} fails with
        L{IllegalServerResponse}.
        s-* OK [UNSEEN foo] Message foo is first unseenNrUrKr.r.r1�test_nonIntegerUnseen4rXz)SelectionTestsMixin.test_nonIntegerUnseencCrO)a)
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{UIDVALIDITY} response, the L{Deferred} returned by
        L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict}
        including the value associated with the C{'UIDVALIDITY'} key.
        s#* OK [UIDVALIDITY 12345] UIDs validFr�)r.rNrPrKr.r.r1�test_uidvalidity?�

�z$SelectionTestsMixin.test_uidvaliditycCrT)a
        If the server returns a non-integer UIDVALIDITY value in its response to
        a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by
        L{IMAP4Client.select} or L{IMAP4Client.examine} fails with
        L{IllegalServerResponse}.
        s!* OK [UIDVALIDITY foo] UIDs validNrUrKr.r.r1�test_nonIntegerUIDVALIDITYLrXz.SelectionTestsMixin.test_nonIntegerUIDVALIDITYcCrO)a!
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{UIDNEXT} response, the L{Deferred} returned by L{IMAP4Client.select}
        or L{IMAP4Client.examine} fires with a C{dict} including the value
        associated with the C{'UIDNEXT'} key.
        s&* OK [UIDNEXT 4392] Predicted next UIDFi()r.r
NrPrKr.r.r1�test_uidnextWr^z SelectionTestsMixin.test_uidnextcCrT)a
        If the server returns a non-integer UIDNEXT value in its response to a
        I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by
        L{IMAP4Client.select} or L{IMAP4Client.examine} fails with
        L{IllegalServerResponse}.
        s%* OK [UIDNEXT foo] Predicted next UIDNrUrKr.r.r1�test_nonIntegerUIDNEXTdrXz*SelectionTestsMixin.test_nonIntegerUIDNEXTcCrO)�
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{FLAGS} response, the L{Deferred} returned by L{IMAP4Client.select} or
        L{IMAP4Client.examine} fires with a C{dict} including the value
        associated with the C{'FLAGS'} key.
        s2* FLAGS (\Answered \Flagged \Deleted \Seen \Draft)F)r�z\FlaggedrCr/z\Draft)r.rmNrPrKr.r.r1�
test_flagsos
��zSelectionTestsMixin.test_flagscCrO)rbsN* OK [PERMANENTFLAGS (\Starred)] Just one permanent flag in that list up thereF)z\Starred)r.�PERMANENTFLAGSNrPrKr.r.r1�test_permanentflags�s��z'SelectionTestsMixin.test_permanentflagscC�,|��}|�d�|�|�|�ddi�dS)z�
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{OK} with unrecognized response code text, parsing does not fail.
        s3* OK [X-MADE-UP] I just made this response text up.r.FNrPrKr.r.r1�test_unrecognizedOk�s
z'SelectionTestsMixin.test_unrecognizedOkcCrf)z�
        If the server response to a I{SELECT} or I{EXAMINE} command includes an
        I{OK} with no response code text, parsing does not fail.
        s* OKr.FNrPrKr.r.r1�test_bareOk�s
zSelectionTestsMixin.test_bareOkN)rirjrkrrLrNrRrWrYrZr[r\r]r_r`rarcrergrhr.r.r.r1rH�s$


rHc@�eZdZdZdZdZdS)�IMAP4ClientExamineTestsa�
    Tests for the L{IMAP4Client.examine} method.

    An example of usage of the EXAMINE command from RFC 3501, section 6.3.2::

        S: * 17 EXISTS
        S: * 2 RECENT
        S: * OK [UNSEEN 8] Message 8 is first unseen
        S: * OK [UIDVALIDITY 3857529045] UIDs valid
        S: * OK [UIDNEXT 4392] Predicted next UID
        S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft)
        S: * OK [PERMANENTFLAGS ()] No permanent flags permitted
        S: A932 OK [READ-ONLY] EXAMINE completed
    r4sEXAMINEN�rirjrkrrJr�r.r.r.r1rj�srjc@ri)�IMAP4ClientSelectTestsa
    Tests for the L{IMAP4Client.select} method.

    An example of usage of the SELECT command from RFC 3501, section 6.3.1::

        C: A142 SELECT INBOX
        S: * 172 EXISTS
        S: * 1 RECENT
        S: * OK [UNSEEN 12] Message 12 is first unseen
        S: * OK [UIDVALIDITY 3857529045] UIDs valid
        S: * OK [UIDNEXT 4392] Predicted next UID
        S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft)
        S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited
        S: A142 OK [READ-WRITE] SELECT completed
    rdsSELECTNrkr.r.r.r1rl�srlc@r�)�IMAP4ClientExpungeTestsa
    Tests for the L{IMAP4Client.expunge} method.

    An example of usage of the EXPUNGE command from RFC 3501, section 6.4.3::

        C: A202 EXPUNGE
        S: * 3 EXPUNGE
        S: * 3 EXPUNGE
        S: * 5 EXPUNGE
        S: * 8 EXPUNGE
        S: A202 OK EXPUNGE completed
    cCs*|j��}|�|j��d�|j��|S)Ns0001 EXPUNGE
)r�rJr?r�r�r�rKr.r.r1�_expunge�s

z IMAP4ClientExpungeTests._expungecCs2|D]}|j�td|�d���q|j�d�dS)Nz* z EXPUNGEs0001 OK EXPUNGE COMPLETED)r�ryr&)rB�sequenceNumbers�numberr.r.r1rN�sz!IMAP4ClientExpungeTests._responsecC�0|��}|�gd��|�|�|�gd��dS)z�
        L{IMAP4Client.expunge} sends the I{EXPUNGE} command and returns a
        L{Deferred} which fires with a C{list} of message sequence numbers
        given by the server's response.
        )r�r�r�r�N)rnrNr?rQrKr.r.r1�test_expunge��z$IMAP4ClientExpungeTests.test_expungecC�(|��}|�gd��|�|tj�dS)z�
        If the server responds with a non-integer where a message sequence
        number is expected, the L{Deferred} returned by L{IMAP4Client.expunge}
        fails with L{IllegalServerResponse}.
        )r�r�r!r�N)rnrNrVrr=rKr.r.r1�test_nonIntegerExpunged��z/IMAP4ClientExpungeTests.test_nonIntegerExpungedN)rirjrkrrnrNrrrur.r.r.r1rm�s

rmc@r�)�IMAP4ClientSearchTestsa�
    Tests for the L{IMAP4Client.search} method.

    An example of usage of the SEARCH command from RFC 3501, section 6.4.4::

        C: A282 SEARCH FLAGGED SINCE 1-Feb-1994 NOT FROM "Smith"
        S: * SEARCH 2 84 882
        S: A282 OK SEARCH completed
        C: A283 SEARCH TEXT "string not in mailbox"
        S: * SEARCH
        S: A283 OK SEARCH completed
        C: A284 SEARCH CHARSET UTF-8 TEXT {6}
        C: XXXXXX
        S: * SEARCH 43
        S: A284 OK SEARCH completed
    cCs*|j�tjdd��}|�|j��d�|S)N�ABCDEF)rCs0001 SEARCH (TEXT "ABCDEF")
)r��searchrr�r?r�r�rKr.r.r1�_searchszIMAP4ClientSearchTests._searchc	Cs0|j�dtd�tt|����|j�d�dS)Ns	* SEARCH � s0001 OK SEARCH completed)r�ryr&r��mapr�)rB�messageNumbersr.r.r1rNs�z IMAP4ClientSearchTests._responsecCrq)z�
        L{IMAP4Client.search} sends the I{SEARCH} command and returns a
        L{Deferred} which fires with a C{list} of message sequence numbers
        given by the server's response.
        )r�r�r�N)rzrNr?rQrKr.r.r1�test_searchrsz"IMAP4ClientSearchTests.test_searchcCrt)z�
        If the server responds with a non-integer where a message sequence
        number is expected, the L{Deferred} returned by L{IMAP4Client.search}
        fails with L{IllegalServerResponse}.
        )r�r!r�N)rzrNrVrr=rKr.r.r1�test_nonIntegerFound$rvz+IMAP4ClientSearchTests.test_nonIntegerFoundN)rirjrkrrzrNr~rr.r.r.r1rw�s
rwc@r�)'�IMAP4ClientFetchTestszV
    Tests for the L{IMAP4Client.fetch} method.

    See RFC 3501, section 6.4.5.
    cCs�|j�d�}|�|j��d�|j�d�|j�d�|j�d�|j�d�|j�d�|�|�|�dd	idd
iddiddid
��dS)a
        L{IMAP4Client.fetchUID} sends the I{FETCH UID} command and returns a
        L{Deferred} which fires with a C{dict} mapping message sequence numbers
        to C{dict}s mapping C{'UID'} to that message's I{UID} in the server's
        response.
        �1:7�0001 FETCH 1:7 (UID)
�* 2 FETCH (UID 22)s* 3 FETCH (UID 23)�* 4 FETCH (UID 24)s* 5 FETCH (UID 25)�0001 OK FETCH completedr{�22�23�24�25�r�r�r�r�N)r��fetchUIDr?r�r�ryrQrKr.r.r1�
test_fetchUID6s�z#IMAP4ClientFetchTests.test_fetchUIDcCsH|j�d�}|�|j��d�|j�d�|j�d�|�|tj�dS)z�
        If the server responds with a non-integer where a message sequence
        number is expected, the L{Deferred} returned by L{IMAP4Client.fetchUID}
        fails with L{IllegalServerResponse}.
        r�s0001 FETCH 1 (UID)
s* foo FETCH (UID 22)r�N�	r�r�r?r�r�ryrVrr=rKr.r.r1�test_fetchUIDNonIntegerFoundIs
z2IMAP4ClientFetchTests.test_fetchUIDNonIntegerFoundcCs`|j�d�}|�|j��d�|j�d�|j�d�|j�d�|j�d�|�|tj�dS)z�
        If the server responds with an incomplete I{FETCH} response line, the
        L{Deferred} returned by L{IMAP4Client.fetchUID} fails with
        L{IllegalServerResponse}.
        r�r�r�s* 3 FETCH (UID)r�r�Nr�rKr.r.r1�test_incompleteFetchUIDResponseUsz5IMAP4ClientFetchTests.test_incompleteFetchUIDResponsecCsT|j�d�}|�|j��d�|j�d�|j�d�|�|�|�dddii�dS)	a
        L{IMAP4Client.fetchBody} sends the I{FETCH BODY} command and returns a
        L{Deferred} which fires with a C{dict} mapping message sequence numbers
        to C{dict}s mapping C{'RFC822.TEXT'} to that message's body as given in
        the server's response.
        �3s0001 FETCH 3 (RFC822.TEXT)
s&* 3 FETCH (RFC822.TEXT "Message text")r�r�rwzMessage textN)r��	fetchBodyr?r�r�ryrQrKr.r.r1�test_fetchBodycs
z$IMAP4ClientFetchTests.test_fetchBodycC�X|j�d�}|�|j��d�|j�d�|j�d�|�|�|�ddgdggi�dS)	aI
        L{IMAP4Client.fetchSpecific} sends the I{BODY[]} command if no
        parameters beyond the message set to retrieve are given.  It returns a
        L{Deferred} which fires with a C{dict} mapping message sequence numbers
        to C{list}s of corresponding message data given by the server's
        response.
        �7�0001 FETCH 7 BODY[]
s* 7 FETCH (BODY[] "Some body")r�r�r��	Some bodyN�r�r,r?r�r�ryrQrKr.r.r1�test_fetchSpecificps
"z(IMAP4ClientFetchTests.test_fetchSpecificcCs\|jjddd�}|�|j��d�|j�d�|j�d�|�|�|�ddgd	ggi�d
S)z�
        L{IMAP4Client.fetchSpecific} issues a I{BODY.PEEK[]} command if passed
        C{True} for the C{peek} parameter.
        �6T)r�s0001 FETCH 6 BODY.PEEK[]
s* 6 FETCH (BODY[] "Some body")r�r�r�r�Nr�rKr.r.r1�test_fetchSpecificPeek~s
"z,IMAP4ClientFetchTests.test_fetchSpecificPeekcCs^|jjddd�}|�|j��d�|j�d�|j�d�|�|�|�ddd	gd
ggi�dS)a;
        L{IMAP4Client.fetchSpecific}, when passed a sequence for
        C{headerNumber}, sends the I{BODY[N.M]} command.  It returns a
        L{Deferred} which fires with a C{dict} mapping message sequence numbers
        to C{list}s of corresponding message data given by the server's
        response.
        r�r���headerNumbers0001 FETCH 7 BODY[1.2.3]
s#* 7 FETCH (BODY[1.2.3] "Some body")r�r�r�z1.2.3r�Nr�rKr.r.r1�test_fetchSpecificNumbered�s�z0IMAP4ClientFetchTests.test_fetchSpecificNumberedcC�^|jjddd�}|�|j��d�|j�d�|j�d�|�|�|�dddgd	ggi�d
S)a1
        L{IMAP4Client.fetchSpecific}, when passed C{'TEXT'} for C{headerType},
        sends the I{BODY[TEXT]} command.  It returns a L{Deferred} which fires
        with a C{dict} mapping message sequence numbers to C{list}s of
        corresponding message data given by the server's response.
        �8�TEXT�r'�0001 FETCH 8 BODY[TEXT]
s"* 8 FETCH (BODY[TEXT] "Some body")r�r�r�r�Nr�rKr.r.r1�test_fetchSpecificText���z,IMAP4ClientFetchTests.test_fetchSpecificTextcCs`|jjdddd�}|�|j��d�|j�d�|j�d�|�|�|�dd	d
gdggi�dS)
ah
        If passed a value for the C{headerNumber} parameter and C{'TEXT'} for
        the C{headerType} parameter, L{IMAP4Client.fetchSpecific} sends a
        I{BODY[number.TEXT]} request and returns a L{Deferred} which fires with
        a C{dict} mapping message sequence numbers to C{list}s of message data
        given by the server's response.
        �4r�r�)r'r�s0001 FETCH 4 BODY[7.TEXT]
s$* 4 FETCH (BODY[7.TEXT] "Some body")r�r�r�z7.TEXTr�Nr�rKr.r.r1�test_fetchSpecificNumberedText�s�z4IMAP4ClientFetchTests.test_fetchSpecificNumberedTextcC�L|jjddd�}|�|j��d�|j�d�|j�d�|�|tj�dS)z�
        If the server responds to a I{BODY[TEXT]} request with a I{FETCH} line
        which is truncated after the I{BODY[TEXT]} tokens, the L{Deferred}
        returned by L{IMAP4Client.fetchUID} fails with
        L{IllegalServerResponse}.
        r�r�r�r�s* 8 FETCH (BODY[TEXT])r�N�	r�r,r?r�r�ryrVrr=rKr.r.r1�(test_incompleteFetchSpecificTextResponse��
z>IMAP4ClientFetchTests.test_incompleteFetchSpecificTextResponsecCr�)a1
        L{IMAP4Client.fetchSpecific}, when passed C{'MIME'} for C{headerType},
        sends the I{BODY[MIME]} command.  It returns a L{Deferred} which fires
        with a C{dict} mapping message sequence numbers to C{list}s of
        corresponding message data given by the server's response.
        r�r�r�s0001 FETCH 8 BODY[MIME]
s"* 8 FETCH (BODY[MIME] "Some body")r�r�r�r�Nr�rKr.r.r1�test_fetchSpecificMIME�r�z,IMAP4ClientFetchTests.test_fetchSpecificMIMEcCsd|jjddddd�}|�|j��d�|j�d�|j�d�|�|�|�d	d
dgddggi�d
S)aX
        L{IMAP4Client.fetchSpecific}, when passed C{offset} and C{length},
        sends a partial content request (like I{BODY[TEXT]<offset.length>}).
        It returns a L{Deferred} which fires with a C{dict} mapping message
        sequence numbers to C{list}s of corresponding message data given by the
        server's response.
        �9r�rr�)r'�offset�lengths0001 FETCH 9 BODY[TEXT]<17.3>
s * 9 FETCH (BODY[TEXT]<17> "foo")r�r�r�z<17>r!Nr�rKr.r.r1�test_fetchSpecificPartial�s�z/IMAP4ClientFetchTests.test_fetchSpecificPartialcCr�)a
        If the server responds to a I{BODY[TEXT]} request with a I{FETCH} line
        which is truncated after the I{BODY[TEXT]<offset>} tokens, the
        L{Deferred} returned by L{IMAP4Client.fetchUID} fails with
        L{IllegalServerResponse}.
        r�r�r�r�s* 8 FETCH (BODY[TEXT]<17>)r�Nr�rKr.r.r1�+test_incompleteFetchSpecificPartialResponse�r�zAIMAP4ClientFetchTests.test_incompleteFetchSpecificPartialResponsecCr�)	aA
        If the body of a message begins with I{<} and ends with I{>} (as,
        for example, HTML bodies typically will), this is still interpreted
        as the body by L{IMAP4Client.fetchSpecific} (and particularly, not
        as a length indicator for a response to a request for a partial
        body).
        r�r�s&* 7 FETCH (BODY[] "<html>test</html>")r�r�r�z<html>test</html>Nr�rKr.r.r1�test_fetchSpecificHTML�s�z,IMAP4ClientFetchTests.test_fetchSpecificHTMLcCs||jjd|d�}|�|j��d|�d�d�|j�d|�d�d�|j�d�|�|�|�d	d
|ggdggi�dS)
a�
        Assert that the provided C{BODY} section, when invoked with no
        arguments, produces an empty list, and that it returns a
        L{Deferred} which fires with a C{dict} mapping message
        sequence numbers to C{list}s of corresponding message data
        given by the server's response.

        @param section: The C{BODY} section to test: either
            C{'HEADER.FIELDS'} or C{'HEADER.FIELDS.NOT'}
        @type section: L{str}
        �10r�s0001 FETCH 10 BODY[r�s ()]
s* 10 FETCH (BODY[s ()] "")r�r�r�r�N)r�r,r?r�r�r@ryrQ)rB�sectionr�r.r.r1�&assertFetchSpecificFieldsWithEmptyLists��&z<IMAP4ClientFetchTests.assertFetchSpecificFieldsWithEmptyListcCr�)az
        L{IMAP4Client.fetchSpecific}, when passed C{'HEADER.FIELDS'}
        for C{headerType} but no C{headerArgs}, sends the
        I{BODY[HEADER.FIELDS]} command with no arguments.  It returns
        a L{Deferred} which fires with a C{dict} mapping message
        sequence numbers to C{list}s of corresponding message data
        given by the server's response.
        r$N�r�rLr.r.r1�,test_fetchSpecificHeaderFieldsWithoutHeaders�	zBIMAP4ClientFetchTests.test_fetchSpecificHeaderFieldsWithoutHeaderscCr�)a�
        L{IMAP4Client.fetchSpecific}, when passed
        C{'HEADER.FIELDS.NOT'} for C{headerType} but no C{headerArgs},
        sends the I{BODY[HEADER.FIELDS.NOT]} command with no
        arguments.  It returns a L{Deferred} which fires with a
        C{dict} mapping message sequence numbers to C{list}s of
        corresponding message data given by the server's response.
        zHEADER.FIELDS.NOTNr�rLr.r.r1�/test_fetchSpecificHeaderFieldsNotWithoutHeaders&r�zEIMAP4ClientFetchTests.test_fetchSpecificHeaderFieldsNotWithoutHeaderscCr�)a=
        L{IMAP4Client.fetchSpecific}, when passed C{'HEADER'} for
        C{headerType}, sends the I{BODY[HEADER]} command.  It returns
        a L{Deferred} which fires with a C{dict} mapping message
        sequence numbers to C{list}s of corresponding message data
        given by the server's response.
        �11�HEADERr�s0001 FETCH 11 BODY[HEADER]
sJ* 11 FETCH (BODY[HEADER] "From: someone@localhost
Subject: Some subject")r�r�r�z.From: someone@localhost
Subject: Some subjectNr�rKr.r.r1�test_fetchSpecificHeader1s �����z.IMAP4ClientFetchTests.test_fetchSpecificHeaderN)rirjrkrr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r.r.r.r1r�/s(


r�c@steZdZdZeZdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�IMAP4ClientStoreTestsa�
    Tests for the L{IMAP4Client.setFlags}, L{IMAP4Client.addFlags}, and
    L{IMAP4Client.removeFlags} methods.

    An example of usage of the STORE command, in terms of which these three
    methods are implemented, from RFC 3501, section 6.4.6::

        C: A003 STORE 2:4 +FLAGS (\Deleted)
        S: * 2 FETCH (FLAGS (\Deleted \Seen))
        S: * 3 FETCH (FLAGS (\Deleted))
        S: * 4 FETCH (FLAGS (\Deleted \Flagged \Seen))
        S: A003 OK STORE completed
    cCsht|j|�ddd�}|�|j��d|d�|j�d�|j�d�|�|�|�dd	d
dgii�dS)
am
        Test a non-silent flag modifying method.  Call the method, assert that
        the correct bytes are sent, deliver a I{FETCH} response, and assert
        that the result of the Deferred returned by the method is correct.

        @param method: The name of the method to test.
        @param item: The data item which is expected to be specified.
        r���\Readr/F�
0001 STORE 3 � (\Read \Seen)
s* 3 FETCH (FLAGS (\Read \Seen))�0001 OK STORE completedr�rmr�r/N�r�r�r?r�r�ryrQ�rBrJ�itemr�r.r.r1�
_flagsTest_s	�"z IMAP4ClientStoreTests._flagsTestcCsPt|j|�ddd�}|�|j��d|d�|j�d�|�|�|�i�dS)ag
        Test a silent flag modifying method.  Call the method, assert that the
        correct bytes are sent, deliver an I{OK} response, and assert that the
        result of the Deferred returned by the method is correct.

        @param method: The name of the method to test.
        @param item: The data item which is expected to be specified.
        r�r�Tr�r�r�Nr�r�r.r.r1�_flagsSilentlyTestps	�z(IMAP4ClientStoreTests._flagsSilentlyTestcCstt|j|�ddd�}|�|j��d|d�|j�d�|j�d�|�|�|�i�|�|jjdd	d
gi�dS)a�
        Test unsolicited data received in response to a silent flag modifying
        method.  Call the method, assert that the correct bytes are sent,
        deliver the unsolicited I{FETCH} response, and assert that the result
        of the Deferred returned by the method is correct.

        @param method: The name of the method to test.
        @param item: The data item which is expected to be specified.
        r�r�Tr�r�s* 2 FETCH (FLAGS (\Read \Seen))r�r�r�r/N)r�r�r?r�r�ryrQror�r.r.r1�%_flagsSilentlyWithUnsolicitedDataTest�s
�z;IMAP4ClientStoreTests._flagsSilentlyWithUnsolicitedDataTestcC�|�dd�dS)aQ
        When passed a C{False} value for the C{silent} parameter,
        L{IMAP4Client.setFlags} sends the I{STORE} command with a I{FLAGS} data
        item and returns a L{Deferred} which fires with a C{dict} mapping
        message sequence numbers to C{dict}s mapping C{'FLAGS'} to the new
        flags of those messages.
        �setFlagsrdN�r�rLr.r.r1�
test_setFlags�sz#IMAP4ClientStoreTests.test_setFlagscCr�)z�
        When passed a C{True} value for the C{silent} parameter,
        L{IMAP4Client.setFlags} sends the I{STORE} command with a
        I{FLAGS.SILENT} data item and returns a L{Deferred} which fires with an
        empty dictionary.
        r��FLAGS.SILENTN�r�rLr.r.r1�test_setFlagsSilently��z+IMAP4ClientStoreTests.test_setFlagsSilentlycCr�)z�
        If unsolicited flag data is received in response to a I{STORE}
        I{FLAGS.SILENT} request, that data is passed to the C{flagsChanged}
        callback.
        r�r�N�r�rLr.r.r1�(test_setFlagsSilentlyWithUnsolicitedData��z>IMAP4ClientStoreTests.test_setFlagsSilentlyWithUnsolicitedDatacCr�)z{
        L{IMAP4Client.addFlags} is like L{IMAP4Client.setFlags}, but sends
        I{+FLAGS} instead of I{FLAGS}.
        �addFlagss+FLAGSNr�rLr.r.r1�
test_addFlags��z#IMAP4ClientStoreTests.test_addFlagscCr�)z�
        L{IMAP4Client.addFlags} with a C{True} value for C{silent} behaves like
        L{IMAP4Client.setFlags} with a C{True} value for C{silent}, but it
        sends I{+FLAGS.SILENT} instead of I{FLAGS.SILENT}.
        r��
+FLAGS.SILENTNr�rLr.r.r1�test_addFlagsSilently�r�z+IMAP4ClientStoreTests.test_addFlagsSilentlycCr�)z�
        L{IMAP4Client.addFlags} behaves like L{IMAP4Client.setFlags} when used
        in silent mode and unsolicited data is received.
        r�r�Nr�rLr.r.r1�(test_addFlagsSilentlyWithUnsolicitedData�r�z>IMAP4ClientStoreTests.test_addFlagsSilentlyWithUnsolicitedDatacCr�)z~
        L{IMAP4Client.removeFlags} is like L{IMAP4Client.setFlags}, but sends
        I{-FLAGS} instead of I{FLAGS}.
        �removeFlagss-FLAGSNr�rLr.r.r1�test_removeFlags�r�z&IMAP4ClientStoreTests.test_removeFlagscCr�)z�
        L{IMAP4Client.removeFlags} with a C{True} value for C{silent} behaves
        like L{IMAP4Client.setFlags} with a C{True} value for C{silent}, but it
        sends I{-FLAGS.SILENT} instead of I{FLAGS.SILENT}.
        r��
-FLAGS.SILENTNr�rLr.r.r1�test_removeFlagsSilently�r�z.IMAP4ClientStoreTests.test_removeFlagsSilentlycCr�)z�
        L{IMAP4Client.removeFlags} behaves like L{IMAP4Client.setFlags} when
        used in silent mode and unsolicited data is received.
        r�r�Nr�rLr.r.r1�+test_removeFlagsSilentlyWithUnsolicitedData�r�zAIMAP4ClientStoreTests.test_removeFlagsSilentlyWithUnsolicitedDataN)rirjrkrrrFr�r�r�r�r�r�r�r�r�r�r�r�r.r.r.r1r�Ns
	r�c@r)�IMAP4ClientStatusTestsa_
    Tests for the L{IMAP4Client.status} method.

    An example of usage of the STATUS command from RFC 3501, section
    5.1.2::

        C: A042 STATUS blurdybloop (UIDNEXT MESSAGES)
        S: * STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292)
        S: A042 OK STATUS completed

    @see: U{https://tools.ietf.org/html/rfc3501#section-5.1.2}
    cCs2|�t|jjdd�}|�t|�dtdh��dS)z�
        Only allow sending the C{STATUS} names defined in RFC 3501.

        @see: U{https://tools.ietf.org/html/rfc3501#section-5.1.2}
        r�zIMPOSSIBLE?!zUnknown names: N)r�r�r�r�r?r�r�)rB�excr.r.r1�testUnknownName�s�z&IMAP4ClientStatusTests.testUnknownNamecCsJ|j�dd�}|�|j��d�|j�d�|j�d�|�|tj�dS)z�
        C{STATUS} names that cannot be decoded as ASCII cause the
        status Deferred to fail with L{IllegalServerResponse}
        �blurdyblooprs$0001 STATUS blurdybloop (MESSAGES)
s?* STATUS blurdybloop (MESSAGES 1 ASCIINAME "OK" NOT�ASCII "NO")s0001 OK STATUS completedN)	r�r�r?r�r�ryrVrr=rKr.r.r1�testUndecodableName�s��z*IMAP4ClientStatusTests.testUndecodableNameN)rirjrkrr�r�r.r.r.r1r��s
r�c@s4eZdZdZeZdd�Zdd�Zdd�Zdd	�Z	d
S)�IMAP4ClientCopyTestsz�
    Tests for the L{IMAP4Client.copy} method.

    An example of the C{COPY} command, which this method implements,
    from RFC 3501, section 6.4.7::

        C: A003 COPY 2:4 MEETING
        S: A003 OK COPY completed
    cC�J|jjdddd�}|�|j��d�|j�d�|�|�|�gdf�dS)	z�
        L{IMAP4Client.copy} copies the messages identified by their
        sequence numbers to the mailbox, returning a L{Deferred} that
        succeeds with a true value.
        r��MEETINGFr��0001 COPY 2:3 MEETING
�0001 OK COPY completed�OK COPY completedN�r��copyr?r�r�ryrQrKr.r.r1�test_copySequenceNumbers��z-IMAP4ClientCopyTests.test_copySequenceNumberscC�J|jjdddd�}|�|j��d�|j�d�|�|�|�jtj	�dS)z�
        L{IMAP4Client.copy} returns a L{Deferred} that fails with an
        L{IMAP4Exception} when the messages specified by the given
        sequence numbers could not be copied to the mailbox.
        r�r�Fr�r��0001 BAD COPY failedN�
r�r�r?r�r�ryr�rVrr�rKr.r.r1�test_copySequenceNumbersFails'r�z2IMAP4ClientCopyTests.test_copySequenceNumbersFailscCr�)	z�
        L{IMAP4Client.copy} copies the messages identified by their
        UIDs to the mailbox, returning a L{Deferred} that succeeds
        with a true value.
        r�r�Tr��0001 UID COPY 2:3 MEETING
r�r�Nr�rKr.r.r1�
test_copyUIDs7r�z"IMAP4ClientCopyTests.test_copyUIDscCr�)z�
        L{IMAP4Client.copy} returns a L{Deferred} that fails with an
        L{IMAP4Exception} when the messages specified by the given
        UIDs could not be copied to the mailbox.
        r�r�Tr�r�r�Nr�rKr.r.r1�test_copyUIDsFailsGr�z'IMAP4ClientCopyTests.test_copyUIDsFailsN)
rirjrkrrrFr�r�r�r�r.r.r.r1r�
s
r�c@seZdZdZdZdd�ZdS)�FakeyServerrdNcCr2r-r.rLr.r.r1�sendServerGreeting\r*zFakeyServer.sendServerGreeting)rirjrkr��timeoutr�r.r.r.r1r�Xsr�c@�XeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�ZdS)r�)r�ror@�_bodyr|cCs2||_||_||_t|�|_||_||_||_dSr-)r�ror�r��sizer@r|�subpart)rBr�ror@r�r|r�r.r.r1rpds

zFakeyMessage.__init__cG�||f|_|jSr-)�got_headersr�)rBr�r9r.r.r1�
getHeadersm�
zFakeyMessage.getHeaderscCr$r-r%rLr.r.r1r&qr'zFakeyMessage.getFlagscCr$r-)r@rLr.r.r1�getInternalDatetr'zFakeyMessage.getInternalDatecCs
t|j�Sr-)rr�rLr.r.r1�getBodyFilewrqzFakeyMessage.getBodyFilecCr$r-)r�rLr.r.r1�getSizezr'zFakeyMessage.getSizecCr$r-r�rLr.r.r1r7}r'zFakeyMessage.getUIDcCs
|jduSr-)r�rLr.r.r1�isMultipart�rqzFakeyMessage.isMultipartcCs||_|j|Sr-)�got_subpartr�)rBr�r.r.r1�
getSubPart�s
zFakeyMessage.getSubPartN)
rirjrk�showAttributesrpr�r&r�rrr7rrr.r.r.r1r�`s	r�c@sFeZdZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Z	dd
d�Z
dS)�
NewStoreTestsNcCs@d|_|_t��|_d|j_||j_t��|_	t
|j	�|_dS�Nrd)�received_messages�received_uidrror�r�rrr�r�r}r�rLr.r.r1r��s

zNewStoreTests.setUpcCr2r-r.�rBr5r.r.r1r �r*zNewStoreTests.addListenercCr2r-r.r
r.r.r1r"�r*zNewStoreTests.removeListenercOr�r-)�	storeArgsr{)rBrvrwr.r.r1rT�r�zNewStoreTests.storecsl�fdd�}�fdd�}�j�t|���|���j���j��fdd�}tj�j�j	dd�}|�|�|S)	Ncs���j�j�j�j�Sr-)�functionr�ro�silentr|r.rLr.r1r��r}z+NewStoreTests._storeWork.<locals>.connectedcrXr-r���RrLr.r1r/�rqz(NewStoreTests._storeWork.<locals>.resultcs$���j�j����j�j�dSr-)r?r/r?r�expectedArgsrrLr.r1rb�r�z'NewStoreTests._storeWork.<locals>.checkF��noisy�
r�r�r4r�r�r�r �loopbackTCPr�r�)rBr�r/rbr�r.rLr1�
_storeWork�s�

zNewStoreTests._storeWorkrcCs�|jj|_d|_gd�|_d|_||_gd�gd�gd�d�|_dgd�idgd�idgd�id�|_t	�
�}|�d�|�d�|�d�|gd�d	fd
d	if|_|�
�S)Nz1,5,9)z\Az\B�CF)r�r�r�rmr�r�r�rr|)r�r�rr�ror
r|r{r?rrr�rr)rBr|r�r.r.r1�testSetFlags�s&

�


�


zNewStoreTests.testSetFlagsr�)rirjrkr/rr�r r"rTrrr.r.r.r1r�s	rc@r�)�GetBodyStructureTestsz�
    Tests for L{imap4.getBodyStructure}, a helper for constructing a list which
    directly corresponds to the wire information needed for a I{BODY} or
    I{BODYSTRUCTURE} response.
    c

Cs�d}d}d}d}d}d}d}t|d|d	|d
|||d�dd
|dd�}t�|�}	|�||d|ddg|||t|�g|	�dS)z�
        L{imap4.getBodyStructure} accepts a L{IMessagePart} provider and returns
        a list giving the basic fields for the I{BODY} response for that
        message.
        �hello, world�image�jpeg�us-ascii�some kind of id�
great justice�maximumr*�
; charset=�; x=y�r��
content-id�content-description�content-transfer-encodingr.r�r�N�charsetr5�y�r�r�getBodyStructurer?r��
rBr��major�minorr&r?�descriptionr�r��	structurer.r.r1�test_singlePart�s>��

�	�z%GetBodyStructureTests.test_singlePartc
Cs�tiddddd�}t�|�}|dd�\}}|�d|�|�d|�tddiddddd�}t�|�}|dd�\}}|�d|�|�d|�tddiddddd�}	t�|	�}
|
dd�\}}|�d|�|�d|�dS)	z�
        L{imap4.getBodyStructure} returns L{None} for the major and
        minor MIME types of a L{IMessagePart} provider whose headers
        lack a C{Content-Type}, or have an empty value for it.
        r.r�r�Nr�r�r��
)r�rr)�assertIs)
rB�missing�missingContentTypeStructure�missingMajor�missingMinorr��emptyContentTypeStructure�
emptyMajor�
emptyMinor�newline�newlineContentTypeStructure�newlineMajor�newlineMinorr.r.r1�test_emptyContentType�s


z+GetBodyStructureTests.test_emptyContentTypecCsLtddiddddd�}t�|�}|dd�\}}|�|d�|�|d�dS)z�
        L{imap4.getBodyStructure} returns only a non-L{None} major
        MIME type for a L{IMessagePart} provider whose headers only
        have a main a C{Content-Type}.
        r��mainr.r�r�Nr�)r�rr)r?r1)rBr>�
mainStructure�	mainMajor�	mainMinorr.r.r1�test_onlyMajorContentTypes

z/GetBodyStructureTests.test_onlyMajorContentTypec
Cs�d}d}d}d}d}d}d}d}t|d	|d
|d||||dd
dd�dd|dd�}	tj|	dd�}
|�||d|ddg|||t|�|dgd�gd
dg|
�dS)z�
        L{imap4.getBodyStructure} returns a list giving the basic and extended
        fields for a I{BODYSTRUCTURE} response if passed C{True} for the
        C{extended} parameter.
        rrrrrrr�abcdefabcdefr*r r!zattachment; name=foo; size=bar�fr�France�r�r#r$r%�content-md5�content-disposition�content-language�content-locationr.r�r�NT��extendedr&r5r'�
attachment)r_r!r�r"r()rBr�r+r,r&r?r-r��md5r�r.r.r.r1�test_singlePartExtendedsP�
�

�
�z-GetBodyStructureTests.test_singlePartExtendedc
Csbd}d}d}td|d|idd|dd	�}tj|d
d�}|�||d	d	d	d	t|�d	d	d	d	g|�d	S)z�
        For fields with no information contained in the message headers,
        L{imap4.getBodyStructure} fills in L{None} values in its result.
        rrrr�r*r.r�r�NTrKr()rBr+r,r�r�r.r.r.r1�test_singlePartWithMissingNs��z0GetBodyStructureTests.test_singlePartWithMissingc
Cs�d}d}d}d}d}d}d}t|d|d	|d
|||d�dd
|dd�}t�|�}	|�||d|ddg|||t|�t|���g|	�dS)z�
        For a I{text/*} message, the number of lines in the message body are
        included after the common single-part basic fields.
        �"hello, world
how are you?
goodbye
rCrrrrrr*r r!r"r.r�r�Nr&r5r')r�rr)r?r�r>r*r.r.r1�
test_textPart_s@��


�
�z#GetBodyStructureTests.test_textPartc
Cs�d}d}d}d}d}d}d}t|d|d	|d
dd|||d
�dd|dd�}tddidddd|g�}	t�|	�}
|�dddddddt�|�t�|�dg
|
�dS)z�
        For a I{message/rfc822} message, the common basic fields are followed
        by information about the contained message.
        rQrCrrrrrr*r r!zAlice <alice@example.com>zBob <bob@example.com>)r�r{r}r#r$r%r.r�r�Nr��message/rfc822r�r?rzrr�)r�rr)r?�getEnvelope)rBr�r+r,r&r?r-r�r��	containerr.r.r.r1�test_rfc822Message�sZ����
��z(GetBodyStructureTests.test_rfc822MessagecCsttddddd�dddd	d
�}tddiddd
dd
�}tddidddd||g�}|�t�|�t�|�dgt�|��d
S)z�
        For a I{multipart/*} message, L{imap4.getBodyStructure} returns a list
        containing the body structure information for each part of the message
        followed by an element giving the MIME subtype of the message.
        zimage/jpeg; x=yrrrr"r.r��hello worldr�Nr�ztext/plain; charset=us-ascii�
some stuff�Azmultipart/related�+�related�r�r?rr)�rB�
oneSubPart�anotherSubPartrUr.r.r1�test_multiPart�sJ��������z$GetBodyStructureTests.test_multiPartc	Cs�tddddd�dddd	d
�}tddiddd
dd
�}tddddd�dddd||g�}|�tj|dd�tj|dd�dddgdddggddgtj|dd��d
S)a)
        When passed a I{multipart/*} message and C{True} for the C{extended}
        argument, L{imap4.getBodyStructure} includes extended structure
        information from the parts of the multipart message and extended
        structure information about the multipart message itself.
        simage/jpeg; x=yssome kind of ids
great justicesmaximum)�content-types
content-idscontent-descriptionscontent-transfer-encodingr.r�rWr�Nrastext/plain; charset=us-asciirXrYzmultipart/related; foo=bar�es�Spainzattachment; name=monkeys)r�rIrJrHrZTrKr[r!r"rMr_�monkeysr\r]r.r.r1�test_multiPartExtended�sX������
�	�z,GetBodyStructureTests.test_multiPartExtendedN)
rirjrkrr/r=rBrOrPrRrVr`rer.r.r.r1r�s(1(83rc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�ZdUdd�Z	dd�Z
dUdd�Zdd�Ze
�e
jd�Zz	e
�e
jd�Wne
jyJdZYn
we
�e
je�dZeed�dd��ZdUdd�Zdd �ZdUd!d"�Zd#d$�ZdUd%d&�ZdUd'd(�Zd)d*�ZdUd+d,�Zd-d.�ZdUd/d0�Zd1d2�Zd3d4�Z dUd5d6�Z!d7d8�Z"dUd9d:�Z#d;d<�Z$dUd=d>�Z%d?d@�Z&dAdB�Z'dCdD�Z(dUdEdF�Z)dGdH�Z*dUdIdJ�Z+dKdL�Z,dUdMdN�Z-dOdP�Z.dUdQdR�Z/dSdT�Z0dS)V�
NewFetchTestscCsFd|_|_d|_t��|_d|j_||j_t�	�|_
t|j
�|_dSr)
rr	r/rror�r�rrr�r�r}r�rLr.r.r1r�/s

zNewFetchTests.setUpcCr2r-r.r
r.r.r1r 9r*zNewFetchTests.addListenercCr2r-r.r
r.r.r1r"<r*zNewFetchTests.removeListenercCs&||_||_tttt|j��|j��Sr-)rr	�iterr�rdr��msgObjsrNr.r.r1rO?szNewFetchTests.fetchcs��rttt�j���j�D]\}}t|����j|d<q
�fdd�}�j���fdd���|���j	��
�j�tj
�j�jdd�}|��fdd��|S)	Nr{crXr-r�rrLr.r1r/Irqz(NewFetchTests._fetchWork.<locals>.resultcs���j��Sr-�rr�r��rBr|r.r1r2Mr�z*NewFetchTests._fetchWork.<locals>.<lambda>Frc����j�j�Sr-�r?r/r?�r5rLr.r1r2S�)r�rdr�rhr�r7r?r�r�r�r�r�r rr�r�)rBr|r�r�r/r�r.rjr1�
_fetchWorkDs��zNewFetchTests._fetchWorkc	sn�fdd��_d�_tiddddd�tiddddd�tiddddd�g�_d	d
id	did	did
��_��d�S)Ncs�j�|�Sr-�r�r�)r��urLr.r1r2Wr�z,NewFetchTests.testFetchUID.<locals>.<lambda>r�r.r�r����u'r{�12345�999�10101)rr�r�r)rr�r�rhr?rorLr.rLr1�testFetchUIDVs��
zNewFetchTests.testFetchUIDrcCsd|jj|_d|_tigd�dddd�tigd�dddd�g|_dgd�idgd�id�|_|�|�S)	Nr�)�FlagA�FlagB�\FlagCr��1�)rzrxryr�rm�rr�)r��
fetchFlagsrr�r�rhr?rorjr.r.r1�testFetchFlagsfs
�

�
zNewFetchTests.testFetchFlagscC�
|�d�Sr,)r~rLr.r.r1�testFetchFlagsUIDsrqzNewFetchTests.testFetchFlagsUIDc
Cs�|jj|_d|_tiddddd�tiddddd�tidddd	d�tidd
ddd�g|_dd
iddiddiddid�|_|�|�S)N�13r.sFri, 02 Nov 2003 21:25:10 GMTr�i�ZsThu, 29 Dec 2013 11:31:52 EST�esMon, 10 Mar 1992 02:44:30 CST��sSat, 11 Jan 2000 14:40:24 PSTi/rpz02-Nov-2003 21:25:10 +0000z29-Dec-2013 11:31:52 -0500z10-Mar-1992 02:44:30 -0600z11-Jan-2000 14:40:24 -0800)rr�r�r�)r��fetchInternalDaterr�r�rhr?rorjr.r.r1�testFetchInternalDatevs
��
z#NewFetchTests.testFetchInternalDatecCrr,)r�rLr.r.r1�testFetchInternalDateUID�rqz&NewFetchTests.testFetchInternalDateUIDN�
es_AR.UTF8TFz'The es_AR.UTF8 locale is not installed.cCs8t�tjd�}t�tjd�|�tjtj|�|�d�S)zC
        The month name in the date is locale independent.
        Nr�r�)�locale�	setlocale�LC_ALLr�r�)rB�
currentLocaler.r.r1�'test_fetchInternalDateLocaleIndependent�s
z5NewFetchTests.test_fetchInternalDateLocaleIndependentcCsv|jj|_d|_tdddddd�dd	d	d
d�g|_ddddgd
�ggd
�ggd
�ggd�gddddg
ii|_|�|�S)N�15zuser@domainzresu@domain�thursdayzit is a messagezid-id-id-yayaya)r{r}r@rz
message-idr.r�ixrrj)NNr��domain)NN�resur�)r��
fetchEnveloperr�r�rhr?rorjr.r.r1�testFetchEnvelope�s@
������
zNewFetchTests.testFetchEnvelopecCrr,)r�rLr.r.r1�testFetchEnvelopeUID�rqz"NewFetchTests.testFetchEnvelopeUIDcCst|jj|_d|_tdddddddd	d
�ddd
dd�g|_ddddgd�dddddddddggdd	gii|_|�|�S)a[
        L{IMAP4Client.fetchBodyStructure} issues a I{FETCH BODYSTRUCTURE}
        command and returns a Deferred which fires with a structure giving the
        result of parsing the server's response.  The structure is a list
        reflecting the parenthesized data sent by the server, as described by
        RFC 3501, section 7.4.2.
        �3:9,10:*�#text/plain; name=thing; key="value"�this-is-the-content-id�!describing-the-content-goes-here!�8BIT�abcdef123456zattachment; filename=monkeysrbzhttp://example.com/monkeysrFr.r��Body
Text
Goes
Here
�Nrr}rC�plain�r�r�r_�thing�20r�rM�filenamerd�r��fetchBodyStructurerr�r�rhr?rorjr.r.r1�test_fetchBodyStructure�sJ
�
��
���
z%NewFetchTests.test_fetchBodyStructurecCr)z�
        If passed C{True} for the C{uid} argument, C{fetchBodyStructure} can
        also issue a I{UID FETCH BODYSTRUCTURE} command.
        r�)r�rLr.r.r1�testFetchBodyStructureUID�s
z'NewFetchTests.testFetchBodyStructureUIDcCs�|jj|_d|_tdddddddd	d
�ddd
dd�}tdddd�dddd|g�g|_ddddgd�ddddddddgdd	gdddgdddgii|_|�|�S)z�
        L{IMAP4Client.fetchBodyStructure} can also parse the response to a
        I{FETCH BODYSTRUCTURE} command for a multipart message.
        r�r�r�r�r�rD�123456abcdef�inlinezouter space)r�r#r$r%rIrGrHrJr.r�r�r�Nzmultipart/mixed; boundary="xyz"�en�nearby)r�rIrJrr}rCr�r�r�r��mixed�boundary�xyzr�)rBr|�innerMessager.r.r1� test_fetchBodyStructureMultipartsl
�
��������
z.NewFetchTests.test_fetchBodyStructureMultipartc
CsV|jj|_d|_tiddddtddiddddd�g�g|_d	d
gd�ii|_|�|�S)N�21r.r��Yea whatever�fr��	image/jpg�Body Body Bodyrr��NNNNNN�12�r��fetchSimplifiedBodyrr�r�rhr?rorjr.r.r1�testFetchSimplifiedBodyDs*
����
z%NewFetchTests.testFetchSimplifiedBodycCrr,)r�rLr.r.r1�testFetchSimplifiedBodyUID^rqz(NewFetchTests.testFetchSimplifiedBodyUIDcCsF|jj|_d|_tddiddddd�g|_dd	gd
�ii|_|�|�S)Nr�r�r�r.r�r�r�rr�)rCr�NNNNr�r�r�rjr.r.r1�testFetchSimplifiedBodyTextas
���
z)NewFetchTests.testFetchSimplifiedBodyTextcCrr,)r�rLr.r.r1�testFetchSimplifiedBodyTextUIDorqz,NewFetchTests.testFetchSimplifiedBodyTextUIDcCs�|jj|_d|_tddiddddtddidd	d
dd�g�g|_ddd
ddddddddgd�ggd�gddddddg
gd�dg
ii|_|�|�S)Nr�r�rSr.r�r�r�r�r�r�rr�r?rzr��NNN)r�jpgNNNN�14r�r�rjr.r.r1�testFetchSimplifiedBodyRFC822rsZ
��������
z+NewFetchTests.testFetchSimplifiedBodyRFC822cCrr,)r�rLr.r.r1� testFetchSimplifiedBodyRFC822UID�rqz.NewFetchTests.testFetchSimplifiedBodyRFC822UIDcCs�|jj|_d|_tddiddddd�tdd	iddd
dd�g}tddidd
dd|�}tddidd
dd|g�}|g|_ddgd�gd�dgdgii|_|�d�S)ah
        L{IMAP4Client.fetchSimplifiedBody} returns a dictionary mapping message
        sequence numbers to fetch responses for the corresponding messages.  In
        particular, for a multipart message, the value in the dictionary maps
        the string C{"BODY"} to a list giving the body structure information for
        that message, in the form of a list of subpart body structure
        information followed by the subtype of the message (eg C{"alternative"}
        for a I{multipart/alternative} message).  This structure is self-similar
        in the case where a subpart is itself multipart.
        r�r�r�r.sdatesStuffr{Nr�sThingsi�~r�r�s
Irrelevantr�zmultipart/mixedsRootOfírr�)rCr�NNNN�5r�)rC�htmlNNNNr�r��alternativer�Fr�)rB�singlesr�r�r.r.r1�!test_fetchSimplifiedBodyMultipart�sJ
�����
����

z/NewFetchTests.test_fetchSimplifiedBodyMultipartcC�B|jj|_d|_tddiddddd�g|_dd	d
ii|_|�|�S)Nz1,3,7,10101r��Valuer.r�sBODY TEXT
�[rryzHeader: Value

BODY TEXT
)r�rrr�r�rhr?rorjr.r.r1�testFetchMessage�s
�
zNewFetchTests.testFetchMessagecCrr,)r�rLr.r.r1�testFetchMessageUID�rqz!NewFetchTests.testFetchMessageUIDcCsX|jj|_d|_tddd�ddddd�g|_tt�ddd���}dd	|ii|_	|�
|�S)
Nz9,6,2�V1�V2)�H1�H2r.r��crrs)r��fetchHeadersrr�r�rhr%rr<r?ro)rBr|r�r.r.r1�testFetchHeaders�s
��
zNewFetchTests.testFetchHeaderscCrr,)r�rLr.r.r1�testFetchHeadersUIDrqz!NewFetchTests.testFetchHeadersUIDcCr�)Nz
1,2,3,4,5,6,7r�r�r.r�sBody goes here
�rrwzBody goes here
)r�r�rr�r�rhr?rorjr.r.r1�
testFetchBodys
��
zNewFetchTests.testFetchBodycCrr,)r�rLr.r.r1�testFetchBodyUIDrqzNewFetchTests.testFetchBodyUIDc	s*�jj�_d�_d}d}d}t�}d|d<d|d<d	|d
<d|d<t�}d
|d
<d|d<t�}d|d
<d|d<t|dd|dt|dd|dd�t|dd|dd�g�g�_dddgdggi�_�fdd�}�j�	�fdd���j�	|��j�	�j
��j��j�t
j�j�jdd�}|�	�fdd��|S)zT
        Test the server's handling of requests for specific body sections.
        r�r�r�r�rzr{r|r}r~rr�r�r�r�r�r�r.Nr�rr�z&Contained body message text.  Squarge.crXr-r�rrLr.r1r/7rqz0NewFetchTests.testFetchBodyParts.<locals>.resultcs�j�jdd�S)Nr�r�rir�rLr.r1r2;rnz2NewFetchTests.testFetchBodyParts.<locals>.<lambda>Frcrkr-rl��ignrLr.r1r2Brn�r�r,rr�rr�rhr?r�r�r�r�r�r rr�)	rBr�r�r�r�r�r�r/r�r.rLr1�testFetchBodyPartssL
���

�z NewFetchTests.testFetchBodyPartscs��jj�_d�_dg�d}t�}d|d<d|d<d|d	<d
|d<t|dd
|dd
�g�_dddgdggi�_�fdd�}�j�	��fdd���j�	|��j�	�j
��j��j�t
j�j�jdd�}|�	�fdd��|S)z�
        Single-part messages have an implicit first part which clients
        should be able to retrieve explicitly.  Test that a client
        requesting part 1 of a text/plain message receives the body of the
        text/plain part.
        r�r�sDA bodyrzr{r|r}r~rr�r�r.Nr�rr�zDA bodycrXr-r�rrLr.r1r/Yrqz>NewFetchTests.test_fetchBodyPartOfNonMultipart.<locals>.resultcs�j�j�d�S)Nr�rir���partsrBr.r1r2]rnz@NewFetchTests.test_fetchBodyPartOfNonMultipart.<locals>.<lambda>Frcrkr-rlr�rLr.r1r2drnr�)rBr�r�r/r�r.r�r1� test_fetchBodyPartOfNonMultipartEs*
�z.NewFetchTests.test_fetchBodyPartOfNonMultipartcCs>|jj|_d|_tiddddd�g|_dddii|_|�|�S)	Nz	1:100,2:*r.r�sxxxxxxxxxxxxxxxxxxxxr�rrur�)r��	fetchSizerr�r�rhr?rorjr.r.r1�
testFetchSizegs
��
zNewFetchTests.testFetchSizecCrr,)r�rLr.r.r1�testFetchSizeUIDrrqzNewFetchTests.testFetchSizeUIDcCs�|jj|_d|_tiddddd�tidddd	d�g|_gd�d
dddgd�ggd�gddddddg
gd
�d�gd�ddddgd�ggd�gddddddg
gd�d�d�|_|�|�S)Nz1,3)z\XYZz\YZX�Abcs%Sun, 25 Jul 2010 06:20:30 -0400 (EDT)sxyzxyzi�)z\Onez\Two�ThreesMon, 14 Apr 2003 19:43:44 -0400sabcabcabcabcrZz25-Jul-2010 06:20:30 -0400r�r�)NNNNNNr�)rmrprurjr�z14-Apr-2003 19:43:44 -0400r�r�r|)r��	fetchFullrr�r�rhr?rorjr.r.r1�
testFetchFullusj
��������
&zNewFetchTests.testFetchFullcCrr,)r�rLr.r.r1�testFetchFullUID�rqzNewFetchTests.testFetchFullUIDcCs�|jj|_d|_tiddddd�tiddddd�g|_ddgd	�ggd	�gddddddg
d
dgd�ddgd	�ggd	�gddddddg
d
d
gd�d�|_|�|�S)Nz1,2:3r.sMon, 14 Apr 2003 19:43:44 +0400sLalalarssTue, 15 Apr 2003 19:43:44 +0200sAlalali�Nr�r�z14-Apr-2003 19:43:44 +0400)rjrurprmz15-Apr-2003 19:43:44 +0200r|)r��fetchAllrr�r�rhr?rorjr.r.r1�testFetchAll�sR
��������
$zNewFetchTests.testFetchAllcCrr,)r�rLr.r.r1�testFetchAllUID�rqzNewFetchTests.testFetchAllUIDcCsD|jj|_d|_tiddddd�g|_ddgdd	d
�i|_|�|�S)Nr�)�\Xs19 Mar 2003 19:22:21 -0500r�r�rr�z19-Mar-2003 19:22:21 -0500�0)rmrpru)r��	fetchFastrr�r�rhr?rorjr.r.r1�
testFetchFast�s
���
zNewFetchTests.testFetchFastcCrr,)r�rLr.r.r1�testFetchFastUID�rqzNewFetchTests.testFetchFastUIDr�)1rirjrkr�r r"rOrorwr~r�r�r�r�r�r�r��Error�noEsARLocaler
r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r.r.r.r1rf.sb


�


%
1

A

4
@	

1
"
=
1
rfc@rG)#�DefaultSearchTestszz
    Test the behavior of the server's SEARCH implementation, particularly in
    the face of unhandled search terms.
    cCs�t��|_d|j_||j_t��|_t|j�|_	t
iddddd�t
iddddd�t
iddddd�t
iddddd�t
iddddd�g|_dS)	Nrdr.r�rrrsr�i!Ni"N)rror�r�rrr�r�r}r�r�rhrLr.r.r1r�s


�zDefaultSearchTests.setUpcCs tttdt|j�d�|j��S)zW
        Pretend to be a mailbox and let C{self.server} lookup messages on me.
        r�)r�r�rdr�rhrNr.r.r1rOs zDefaultSearchTests.fetchcsZ��fdd�}�j�t|��}��fdd�}|�|�|��j�|��j����|S)a�
        Issue a search with given query and verify that the returned messages
        match the given expected messages.

        @param queryTerms: A string giving the search query.
        @param expectedMessages: A list of the message sequence numbers
            expected as the result of the search.
        @return: A L{Deferred} which fires when the test is complete.
        c��j���Sr-�r�ryr.��
queryTermsrBr.r1ry!r5z8DefaultSearchTests._messageSetSearchTest.<locals>.searchcs��|��dSr-r�r�)�expectedMessagesrBr.r1�searched&r�z:DefaultSearchTests._messageSetSearchTest.<locals>.searched)r�r�r4r�r�r�r )rBr�r�ryr�r�r.)r�r�rBr1�_messageSetSearchTests
z(DefaultSearchTests._messageSetSearchTestcC�|�ddg�S)z�
        Test that a search which starts with a message set properly limits
        the search results to messages in that set.
        r�r��r�rLr.r.r1�test_searchMessageSet/sz(DefaultSearchTests.test_searchMessageSetcC�|�dgd��S)zv
        If the search filter ends with a star, all the message from the
        starting point are returned.
        z2:*r�r�rLr.r.r1�test_searchMessageSetWithStar6r�z0DefaultSearchTests.test_searchMessageSetWithStarcCr�)z�
        If the search filter starts with a star, the result should be identical
        with if the filter would end with a star.
        z*:2r�r�rLr.r.r1�"test_searchMessageSetWithStarFirst=r�z5DefaultSearchTests.test_searchMessageSetWithStarFirstcCr�)z�
        If the search filter ends with a star, all the message from the
        starting point are returned (also for the SEARCH UID case).
        zUID 10000:*r�r�rLr.r.r1� test_searchMessageSetUIDWithStarDr�z3DefaultSearchTests.test_searchMessageSetUIDWithStarcCr�)z�
        If the search filter starts with a star, the result should be identical
        with if the filter would end with a star (also for the SEARCH UID case).
        zUID *:10000r�r�rLr.r.r1�%test_searchMessageSetUIDWithStarFirstKr�z8DefaultSearchTests.test_searchMessageSetUIDWithStarFirstcCr�)z�
        A search filter of 1234:* should include the UID of the last message in
        the mailbox, even if its UID is less than 1234.
        zUID 30000:*r�r�rLr.r.r1�,test_searchMessageSetUIDWithStarAndHighStartRrZz?DefaultSearchTests.test_searchMessageSetUIDWithStarAndHighStartcCr�)z�
        If the search filter contains nesting terms, one of which includes a
        message sequence set with a wildcard, IT ALL WORKS GOOD.
        z(6:*)r�r�rLr.r.r1�test_searchMessageSetWithListZsz0DefaultSearchTests.test_searchMessageSetWithListcCs|�dddg�S)z�
        If the search filter contains an I{OR} term, all messages
        which match either subexpression are returned.
        zOR 1 2r�r�r�rLr.r.r1rZdr�z DefaultSearchTests.test_searchOrcCr�)z�
        If the search filter contains an I{OR} term with a
        subexpression which includes a message sequence set wildcard,
        all messages in that set are considered for inclusion in the
        results.
        z
OR 2:* 2:*r�r�rLr.r.r1�test_searchOrMessageSetkr�z*DefaultSearchTests.test_searchOrMessageSetcCr�)z�
        If the search filter contains a I{NOT} term, all messages
        which do not match the subexpression are returned.
        zNOT 3)r�r�r�r�r�rLr.r.r1r\tr�z!DefaultSearchTests.test_searchNotcCr�)z�
        If the search filter contains a I{NOT} term with a
        subexpression which includes a message sequence set wildcard,
        no messages in that set are considered for inclusion in the
        result.
        zNOT 2:*r�r�rLr.r.r1�test_searchNotMessageSet{sz+DefaultSearchTests.test_searchNotMessageSetcCr�)z�
        If the search filter contains multiple terms implicitly
        conjoined with a message sequence set wildcard, only the
        intersection of the results of each term are returned.
        z2:* 3r�r�rLr.r.r1�test_searchAndMessageSet�rZz+DefaultSearchTests.test_searchAndMessageSetc�^d���fdd�}�j�t|��}��|tj�}�fdd�}|�|�|��j����|S)z�
        If the search criteria is not a valid key, a NO result is returned to
        the client (resulting in an error callback), and an IllegalQueryError is
        logged on the server side.
        �FOOcr�r-r�r.r�r.r1ry�r5z=DefaultSearchTests.test_searchInvalidCriteria.<locals>.searchc�L�jj���jj����tj�}��t|�d���t	d�t	|��dS)��
            Verify that the server logs an IllegalQueryError and the
            client raises an IMAP4Exception with 'Search failed:...'
            r�s)SEARCH failed: Invalid search command FOON�
r�r�r�r�rrr�r?r�r��r�rQrLr.r1�
errorReceived�s�zDDefaultSearchTests.test_searchInvalidCriteria.<locals>.errorReceived�	r�r�r4rBrr�r�r�r �rBryr�r	r.r�r1�test_searchInvalidCriteria�s
z-DefaultSearchTests.test_searchInvalidCriteriaN)rirjrkrr�rOr�r�r�r�r�r�r�r�rZrr\rrrr.r.r.r1r��s$
		r�c@s`eZdZdd�Zdd�Zdd�ZeZdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dS)�FetchSearchStoreTestscCsXd|_|_d|_d|_d|_d|_t��|_d|j_	||j_
t��|_
t|j
�|_dSr)r?r/�server_received_query�server_received_uid�server_received_parts�server_received_messagesrror�r�rrr�r�r}r�rLr.r.r1r��s

zFetchSearchStoreTests.setUpcCs&|dgkr
t�d��||_||_|jS)Nrz"FOO is not a valid search criteria)rr�rrr?)rBr�r|r.r.r1ry�s


zFetchSearchStoreTests.searchcOr2r-r.)rBrJrwr.r.r1r �r*z!FetchSearchStoreTests.addListenercsn��fdd�}�fdd�}�j�t|���|���j���j��fdd�}tj�j�j	dd�}|�|�|S)	Ncs�jj�j�d�S)Nr�)r�ryr�r.rjr.r1ry�r�z1FetchSearchStoreTests._searchWork.<locals>.searchcrXr-r�rrLr.r1r/�rqz1FetchSearchStoreTests._searchWork.<locals>.resultcsR���j�ju����j�j����j�j���t��j�	d���j
�dS)N�charmap)r-r/r?r?r|rrr`r�r@rrrLr.r1rb�s�z0FetchSearchStoreTests._searchWork.<locals>.checkFrr)rBr|ryr/rbr�r.rjr1�_searchWork�s�

z!FetchSearchStoreTests._searchWorkcCs:t�tjdd�tjddd��|_gd�|_d|_|�d�S)N�r�	substring�r����r�r�)r�r�r�r�r)rr�r�r�r?r|rrLr.r.r1�
testSearch�s
�

z FetchSearchStoreTests.testSearchcCs:t�tjdd�tjddd��|_d|_gd�|_|�d�S)Nrrrrrr�r�)rr�r�r�r|r?rrLr.r.r1�
testUIDSearch�s
�

z#FetchSearchStoreTests.testUIDSearchc	CsHz|j|dWSttfy|j|dYSty#YdSw)Nr{r�r))r?r��
IndexError�KeyError�rBr�r.r.r1r7�s�zFetchSearchStoreTests.getUIDcCs||_t|�|_|jSr-)rr�rr?rNr.r.r1rOs
zFetchSearchStoreTests.fetchcs`�fdd�}�j�t|���|���j���j��fdd�}tj�j�j	dd�}|�|�|S)NcrXr-r�rrLr.r1r/rqz0FetchSearchStoreTests._fetchWork.<locals>.resultcs����j�ju��jo�j���jo�j���jr,�j��D]
\}}t|�|d<q!��	�j�j���	�j�j
���	�j�j���	t��j
�t��j��dS)Nr{)r-r/r?r�r�rr|r�r�r?rrr�r�r)r��k�vrLr.r1rbs��

�z/FetchSearchStoreTests._fetchWork.<locals>.checkFrr)rBrOr/rbr�r.rLr1ro
s�

z FetchSearchStoreTests._fetchWorkcr)z�
        If, as part of a search, an ISearchableMailbox raises an
        IllegalQueryError (e.g. due to invalid search criteria), client sees a
        failure response, and an IllegalQueryError is logged on the server.
        rcr�r-r�r.�r�rBr.r1ry1r5z6FetchSearchStoreTests.test_invalidTerm.<locals>.searchcr)rr�s1SEARCH failed: FOO is not a valid search criteriaNrrrLr.r1r	7s�z=FetchSearchStoreTests.test_invalidTerm.<locals>.errorReceivedr
rr.r!r1�test_invalidTerm)s
z&FetchSearchStoreTests.test_invalidTermN)rirjrkr�ryr r"rrrr7rOror"r.r.r.r1r
�s
			r
c@r�)�FakeMailboxcCrnr-rrLr.r.r1rpOrqzFakeMailbox.__init__cCs|j�|||f�t�d�Sr-)rvrrrr4)rBr�ror@r.r.r1rARr�zFakeMailbox.addMessageN)rirjrkrprAr.r.r.r1r#Nsr#c@�$eZdZdd�Zdd�Zdd�ZdS)�FeaturefulMessagecCr()Nror.rLr.r.r1r&Yr*zFeaturefulMessage.getFlagscCr()Nrrr.rLr.r.r1r�\r*z!FeaturefulMessage.getInternalDatecCstd�S)N�openrrLr.r.r1r�_rbzFeaturefulMessage.openN)rirjrkr&r�r�r.r.r.r1r%Wsr%c@r�)�MessageCopierMailboxcCrnr-)�msgsrLr.r.r1rperqzMessageCopierMailbox.__init__cCs|j�|�t|j�Sr-)r(rrr�rr.r.r1r�hrzMessageCopierMailbox.copyN)rirjrkrpr�r.r.r.r1r'cr�r'c@r$)�CopyWorkerTestscsHt��}|j}t��|dd�tdd�D�d��}��fdd�}|�|�S)NcSsg|]}|t�f�qSr.)r%r	r.r.r1r�|sz9CopyWorkerTests.testFeaturefulMessage.<locals>.<listcomp>r�r�r�csh�jD]}��|d��d���|dd���|dd�q|D]\}}��|���|d�q"dS)Nrr&r�ror�rr)rvr?rPr/)r�rJr�r/�r�rBr.r1�cbCopy~s

�z5CopyWorkerTests.testFeaturefulMessage.<locals>.cbCopy)rro�_IMAP4Server__cbCopyr#rdr��rBrRr0r�r+r.r*r1�testFeaturefulMessagens


z%CopyWorkerTests.testFeaturefulMessagecsbt��}|j}t��dd�tdd�D�}|dd�ttdd�|�D�d��}��fdd�}|�|�S)	Nc	Ss0g|]}tdt|�iddd|f|dd��qS)zHeader-Counterr.�DatesBody %dr�N)r�r�r	r.r.r1r��s���z;CopyWorkerTests.testUnfeaturefulMessage.<locals>.<listcomp>r�r�cS�g|]}|�qSr.r.�r
�imr.r.r1r��rnr�cs�g}�jD]}|�|d�����|dd���|dd�q|��tdd�tdd�D��}��||�|D]\}}��|���|d�q9dS)	Nrr�r.r�r/css�|]	}d||fVqdS)sHeader-Counter: %d

Body %dNr.r	r.r.r1r�s�
�zJCopyWorkerTests.testUnfeaturefulMessage.<locals>.cbCopy.<locals>.<genexpr>r�)rvrrrPr?r�r=rdr/)r��seenrJ�expr�r/r*r.r1r+�s
�
�z7CopyWorkerTests.testUnfeaturefulMessage.<locals>.cbCopy)rror,r#rdr�r�)rBrRr0r(r�r+r.r*r1�testUnfeaturefulMessage�s�"
z'CopyWorkerTests.testUnfeaturefulMessagecsdt��}|j}t��dd�tdd�D��|dd�ttdd���D�d��}���fdd�}|�|�S)	NcSsg|]}t��qSr.)�objectr	r.r.r1r���z5CopyWorkerTests.testMessageCopier.<locals>.<listcomp>r�r�cSr0r.r.r1r.r.r1r��rnstagc	sH��|ttdgdtdd����t��j�D]
\}}��||�qdS)Nr�r�r�)r?r�r�rdr(r�)r��origr��r�r(rBr.r1r+�s"�z1CopyWorkerTests.testMessageCopier.<locals>.cbCopy)rror,r'rdr�r�r-r.r9r1�testMessageCopier�s"
z!CopyWorkerTests.testMessageCopierN)rirjrkr.r5r:r.r.r.r1r)ms"r)zOpenSSL not presentzReactor doesn't support SSLc@speZdZdZdZer
e�Zere�Zdd�Zdd�Zdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dd�Zdd�ZdS)�TLSTestsNcCstj|j|jdd�S)NFr)r rr�r�rLr.r.r1r �rizTLSTests.loopbackc	s�tj�d�g���fdd�}��fdd�}��fdd�}��fdd	�}��fd
d�}d�j_|||||g��D]
}�j�t|��q8�j��j	�j
����fd
d�}���}|�|�|S)Nr8c���d��j�dd�Sr�)rrr�r�r.��calledrBr.r1r���
z)TLSTests.testAPileOfThings.<locals>.logincr<)Nr8�%)rrr�r�r.r=r.r1r��r?z(TLSTests.testAPileOfThings.<locals>.listcr<)Nr8r
)rrr�r�r.r=r.r1r��r?z*TLSTests.testAPileOfThings.<locals>.statuscs��d��j�d�S)Nr8)rrr�r4r.r=r.r1r4�s
z+TLSTests.testAPileOfThings.<locals>.examinecs��d��j��Sr-)rrr�r�r.r=r.r1r��s

z*TLSTests.testAPileOfThings.<locals>.logoutTcs8���jjd����jjd���t��t���dSrK)r?r��
startedTLSr�r�r�r>�methodsrBr.r1rb�sz)TLSTests.testAPileOfThings.<locals>.check)rjr|rr��requireTransportSecurityr�r�r4rBr�r�r )	rBr�r�r�r4r�rJrbr�r.rBr1�testAPileOfThings�s 
zTLSTests.testAPileOfThingscs��jj�dd�g��j�t�d���j��fdd����fdd����j	���j
���j���
�}|���fdd��|S)Nrkrncr")Nrnr�r�rLr.r1r2�r�z)TLSTests.testLoginLogin.<locals>.<lambda>cr�r-)r�r�r�rLr.r1r2�r�cs��t��d�Sr,)r?r�rm�rB�successr.r1r2rn)r�rrrqr�r�rr�r�r�rrr�r�r�r rKr.rFr1�testLoginLogin�s$
����zTLSTests.testLoginLogincsjg��j�t�jj���fdd�}�j�|��j��j����}|���fdd��t�|�jg�S)z�
        Begin a C{STARTTLS} sequence and assert that it results in a
        TLS session.

        @return: A L{Deferred} that fires when the underlying
            connection between the client and server has been terminated.
        cs��tj��jj��dSr-)r/r�
ISSLTransport�
providedByr�r�rrLr.r1�checkSecurer�z6TLSTests.startTLSAndAssertSession.<locals>.checkSecurecs
����Sr-)r/rmrFr.r1r2r�z3TLSTests.startTLSAndAssertSession.<locals>.<lambda>)	r�r�r4r��startTLSrrr rr�)rBrKr�r.rFr1�startTLSAndAssertSessionsz!TLSTests.startTLSAndAssertSessioncCs(|��}|j�|j�|j�|j�|S)z�
        L{IMAP4Client.startTLS} triggers TLS negotiation and returns a
        L{Deferred} which fires after the client's transport is using
        encryption.
        )rMr�r�r�r�r�)rB�disconnectedr.r.r1�
test_startTLSszTLSTests.test_startTLScCsnGdd�dt�}||j|jd�|_|��}|j�t|jj��|j�|j	d�|j�|j
�|j�|j�|S)z]
        A server that receives a second C{STARTTLS} sends a C{NO}
        response.
        c@�eZdZdd�ZdS)z:TLSTests.test_doubleSTARTTLS.<locals>.DoubleSTARTTLSClientcSs |jst�|�S|�t�d��S)NsSTARTTLS)rAr}rLr�rrrLr.r.r1rL-s
zCTLSTests.test_doubleSTARTTLS.<locals>.DoubleSTARTTLSClient.startTLSN)rirjrkrLr.r.r.r1�DoubleSTARTTLSClient,�rQr�sTLS already negotiated)r}r�r�r�rMr�r4rLr�r�r�r�)rBrQrNr.r.r1�test_doubleSTARTTLS&s��zTLSTests.test_doubleSTARTTLScsltjtjd��j_tj�fdd��}�j�t	|����
�}�j�t	|���j��j��j��j
�|S)z�
        Starting a TLS negotiation with an L{IMAP4Server} that already
        has C{LOGIN} and C{PLAIN} L{IChallengeResponse} factories uses
        those factories.
        )rrgc3s>��j��V}��d|���d|d���d|d�dS)Nr�rrg)r�r�r�r�rLr.r1�assertLOGINandPLAINNs
�zJTLSTests.test_startTLSWithExistingChallengers.<locals>.assertLOGINandPLAIN)rr�r�r�r�rr�r�r�r4rMr�r�r�)rBrTrNr.rLr1�$test_startTLSWithExistingChallengersCs
�z-TLSTests.test_startTLSWithExistingChallengerscs`dd��j_�j��fdd���j��jd��j��j��j��j�t�	��
��jg�S)z|
        A client that attempts to log in before issuing the
        C{STARTTLS} command receives a C{NO} response.
        cSst�gdf�S)NzOK Begin TLS negotiation now)rr4r.r.r.r1r2fs�z3TLSTests.test_loginBeforeSTARTTLS.<locals>.<lambda>cr�)Nswrongstimer�r�rLr.r1r2jr�s!LOGIN is disabled before STARTTLS)r�rLr�r�r�r�r�r�rr�r rLr.rLr1�test_loginBeforeSTARTTLS`s
��z!TLSTests.test_loginBeforeSTARTTLScs|g��fdd�}�j�|��j��fdd���j��fdd���j��j��j��j���fdd�}����|�S)Ncsd�j_dSr~)r��canStartTLSr�rLr.r1�breakServerTLSzr5z3TLSTests.testFailedStartTLS.<locals>.breakServerTLScr�r-)r�rLr�rLr.r1r2~r�z-TLSTests.testFailedStartTLS.<locals>.<lambda>cs��|�tj��Sr-)rrr�rr�)r�)r�r.r1r2�r7cs �������dtj�dSr>)r/r�rr�r�r�rBr.r1rb�s
z*TLSTests.testFailedStartTLS.<locals>.check)r�r�r�r�r�r )rBrXrbr.rYr1�testFailedStartTLSws
�zTLSTests.testFailedStartTLS)rirjrkr�r�r,r+r rErHrMrOrSrUrVrZr.r.r.r1r;�s )r;c@s eZdZdZdZdZdd�ZdS)�SlowMailboxr�NcCs*t��}|�|j|jd�|j�d�|S)Nr.)rr��	callLater�howSlowr��
fetchDeferred)rBr�r|r�r.r.r1rO�szSlowMailbox.fetch)rirjrkr]r\r^rOr.r.r.r1r[�s
r[c@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�TimeoutTestscspt��d�j_d�j_�j�j_d�_���fdd�}�fdd���j�t	|��}|�
�j�t�
|���g�S)z{
        The *client* has a timeout mechanism which will close connections that
        are inactive for a period.
        Tr�Ncs&�j�dd�}��d�|���|S)Nrkrnr�)r�r��advancer�r��r�rB�timedOutr.r1r��s

z.TimeoutTests.test_serverTimeout.<locals>.logincs��d�|�tj�dSr-)r�r�r�TimeoutErrorr?rLr.r1rb�r�z1TimeoutTests.test_serverTimeout.<locals>.timedOut)rr�rur�r�r\rr�r�r4r�r�rr�r )rBr�r�r.rar1�test_serverTimeout�s
zTimeoutTests.test_serverTimeoutcsZt���j�j_�fdd�}��fdd�}�j�t|��}|�t|��t�|���g�S)z4
        The server times out a connection.
        cr�r�r�r.rLr.r1r��r.z/TimeoutTests.test_serverTimesOut.<locals>.loginc����jjd�dS�Nr��r`r��POSTAUTH_TIMEOUTr.r?r.r1�
expireTime�r�z4TimeoutTests.test_serverTimesOut.<locals>.expireTime)	rr\r�r�r�r4rr�r )rBr�rir�r.r?r1�test_serverTimesOut�s
z TimeoutTests.test_serverTimesOutcs���tjdt�tj�d�tjjd���t����t	���j
�j_
�fdd�}�fdd�}��fdd	�}��fd
d�}�fdd
�}�j�
t|��}|�
t|��|�
t|��|�
t|��|�
t|��t�|���g�S)z^
        The server unsets the selected mailbox when timing out a
        connection.
        r^�mailbox-test�MAILBOX-TESTcr�r�r�r.rLr.r1r��r.z7TimeoutTests.test_serverUnselectsMailbox.<locals>.logincr"�Nrkr#r.rLr.r1rd�r5z8TimeoutTests.test_serverUnselectsMailbox.<locals>.selectcs����jj�dSr-)r1r�rr.�rrBr.r1�	assertSet�riz;TimeoutTests.test_serverUnselectsMailbox.<locals>.assertSetcrerfrgr.r?r.r1ri�r�z<TimeoutTests.test_serverUnselectsMailbox.<locals>.expireTimecr%r-)r-r�rr.rLr.r1�assertUnset�r�z=TimeoutTests.test_serverUnselectsMailbox.<locals>.assertUnset)r�rjr|rWrr/r-rrJrr\r�r�r�r4rr�r )rBr�rdrorirpr�r.�r�rrBr1�test_serverUnselectsMailbox�s"
z(TimeoutTests.test_serverUnselectsMailboxcs�tj�d�tjjd�tt��t���j�j_�fdd�}�fdd�}��fdd�}��fd	d
�}��fdd�}�j	�
t|��}|�
t|��|�
t|��|�
t|��|�
t|��t�
|���g�S)
zi
        The server closes the selected, closeable mailbox when timing
        out a connection.
        rkrlcr�r�r�r.rLr.r1r��r.z?TimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.logincr"rmr#r.rLr.r1rd�r5z@TimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.selectc����j�dSr-)r-rLr.rnr.r1�assertMailboxOpenr�zKTimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.assertMailboxOpencrerfrgr.r?r.r1rir�zDTimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.expireTimecrsr-)r/rLr.rnr.r1�assertMailboxClosedr�zMTimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.assertMailboxClosed)rjr|rr/r
rrr\r�r�r�r4rr�r )rBr�rdrtrirur�r.rqr1�#test_serverTimesOutAndClosesMailbox�s 

z0TimeoutTests.test_serverTimesOutAndClosesMailboxcs�t���jt_t��t_�j�j_ttj_	tj�
d��j�d��fdd�}�fdd�}�fdd�}�fd	d
�}�fdd�}tj�|��j
�t|��}|�t|��|�t|��|�t|��|��j�|��j�t�|���g�}|S)
zM
        The connection timeout does not take effect during fetches.
        rkr�cr�r�r�r.rLr.r1r�#r.z7TimeoutTests.test_longFetchDoesntTimeout.<locals>.logincs�j�d��j�d�S)Nr�rk)r��
setTimeoutr�rdr.rLr.r1rd&sz8TimeoutTests.test_longFetchDoesntTimeout.<locals>.selectcr")Nr�rpr.rLr.r1rO*r5z7TimeoutTests.test_longFetchDoesntTimeout.<locals>.fetchcs���jjd�dS)Nr�)r�r�r�r.rLr.r1�stillConnected-riz@TimeoutTests.test_longFetchDoesntTimeout.<locals>.stillConnectedcstd�D]}��d�qdS)Nr�g�?)rdr`)r�r�r�r.r1�	cbAdvance0s�z;TimeoutTests.test_longFetchDoesntTimeout.<locals>.cbAdvance)rr\r[rr�r^r�rjr|r^rrwr�r�r4r�r�r�r�r )rBr�rdrOrxryr�r�r.r?r1�test_longFetchDoesntTimeouts*

z(TimeoutTests.test_longFetchDoesntTimeoutcs�t�}t�}|j|_|j|j_|j�|�g�|jj���fdd�|j_|�dg|jjdgd�|�	���|�d|jjdg�|�
��dS)z{
        The *server* has a timeout mechanism which will close connections that
        are inactive for a period.
        cs��d��|�fdSr,)rr)�reason��connLost�lostr.r1r2Ns
��z<TimeoutTests.test_idleClientDoesDisconnect.<locals>.<lambda>gg@r�g@N)rr(r�r�r\r�r��pump�timeOutr-r/)rBr�r�r.r|r1�test_idleClientDoesDisconnect?s
z*TimeoutTests.test_idleClientDoesDisconnectN)	rirjrkrdrjrrrvrzr�r.r.r.r1r_�s'&)r_c@rP)�DisconnectionTestscCsBt��}t�}|�|�|�|�dd�tj�}|�t�d��|S)Nrkzexample.com�Connection closed)	rr~r(r�rBr�rr�r�)rBr��tr�r.r.r1�"testClientDisconnectFailsDeferreds]s
�z5DisconnectionTests.testClientDisconnectFailsDeferredsN)rirjrkr�r.r.r.r1r�\rRr�c@r)�SynchronousMailboxzb
    Trivial, in-memory mailbox implementation which can produce a message
    synchronously.
    cCs
||_dSr-r�)rBr�r.r.r1rpnrqzSynchronousMailbox.__init__ccs0�|rJd��|D]}||j|dfVq	dS)NzCannot handle uid requests.r�r�)rBrPr|r�r.r.r1rOqs
��zSynchronousMailbox.fetchN)rirjrkrrprOr.r.r.r1r�hsr�c	@s|eZdZdZeigdddd�eigdddd�eigdddd�gZdd�Zd	d
�Zdd�fd
d�Zdd�Z	dd�Z
dd�ZdS)�PipeliningTestszM
    Tests for various aspects of the IMAP4 server's pipelining support.
    r�r�Nr��2cCsVg|_t�|_t�dd|j�|_|j�|j�t|j	�}d|j_
||j_|j��dSr)
�	iteratorsr'r�rro�iterateInReactorr�r�r�r�r�rr�)rBr�r.r.r1r��s
zPipeliningTests.setUpcCst��}|j�||f�|S)z�
        A fake L{imap4.iterateInReactor} that records the iterators it
        receives.

        @param iterator: An iterator.

        @return: A L{Deferred} associated with this iterator.
        )rr�r�rr)rB�iteratorr�r.r.r1r��s	z PipeliningTests.iterateInReactorcCr(rKr.r.r.r.r1r2�r�zPipeliningTests.<lambda>cCsn|jr1|�r3|jddD]}|jjr|jj��|jjsq
|j�d�d�d�|jr5|�sdSdSdSdS)a�
        Advance pending iterators enqueued with L{iterateInReactor} in
        a round-robin fashion, resuming the transport's producer until
        it has completed.  This ensures bodies are flushed.

        @param asLongAs: (optional) An optional predicate function.
            Flushing iterators continues as long as there are
            iterators and this returns L{True}.
        rr�N)r�r��producerrtr�r�)rB�asLongAs�er.r.r1�flushPending�s
���zPipeliningTests.flushPendingcCr�r-r�rLr.r.r1r��r�zPipeliningTests.tearDowncCs�|j�d�|��|�|j��d�dtdt|j	d�
����f�dtdt|j	d�
����f�d	td
t|j	d�
����f�g��dS)
z�
        Test that pipelined FETCH commands which can be responded to
        synchronously are responded to correctly.
        s901 FETCH 1 BODY[]
02 FETCH 2 BODY[]
03 FETCH 3 BODY[]
r��* 1 FETCH (BODY[] )
�"01 OK FETCH completed
{5}


%sr�* 2 FETCH (BODY[] )
z"02 OK FETCH completed
{5}


%sr�s* 3 FETCH (BODY[] )
z"03 OK FETCH completed
{5}


%sr�N)r�r�r�r?r�r�r�r&r%r�rrPrLr.r.r1�test_synchronousFetch�s8����������z%PipeliningTests.test_synchronousFetchcCs�|j�d�t�ttgd���}|j|d�|�|j�	�d�
dtdt|j
d�����f�g��|j��|jjdd	�|�|j�	��|��|�|j�	�d�
d
dtdt|j
d
�����f�g��dS)z�
        When a server status change occurs during an ongoing FETCH
        command, the server status is buffered until the FETCH
        completes.
        s01 FETCH 1,2 BODY[]
)TTF)r�r�r�z{5}


%srT)r�r�s* [READ-WRITE]
r�r�N)r�r��	functools�partial�nextrgr�r?r�r�r�r&r%r�rrPr�r�r-)rB�twicer.r.r1�test_bufferedServerStatus�s@�����
�����z)PipeliningTests.test_bufferedServerStatus)rirjrkrr�r�r�r�r�r�r�r�r.r.r.r1r�ws�
#r�c@r)�IMAP4ServerFetchTestszV
    This test case is for the FETCH tests that require
    a C{StringTransport}.
    cCs,t�|_t��|_d|j_|j�|j�dSr)r'r�rror�r�r�rLr.r.r1r�s
zIMAP4ServerFetchTests.setUpcCsL|j��|j�d�d}|�|j��|�|j��|j�t�d��dS)a
        If by any chance, extra bytes got appended at the end of a valid
        FETCH arguments, the client should get a BAD - arguments invalid
        response.

        See U{RFC 3501<http://tools.ietf.org/html/rfc3501#section-6.4.5>},
        section 6.4.5,
        s0001 FETCH 1 FULLL
s+0001 BAD Illegal syntax: Invalid Argument
r�N)	r�r�r�r�r?r�r�rr�)rBr?r.r.r1�"test_fetchWithPartialValidArguments


z8IMAP4ServerFetchTests.test_fetchWithPartialValidArgumentN)rirjrkrr�r�r.r.r.r1r�sr�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�LiteralTestsMixinz�
    Shared tests for literal classes.

    @ivar literalFactory: A callable that returns instances of the
        literal under test.
    cCst��|_dS)z
        Shared setup.
        N)rr�rrLr.r.r1r�5szLiteralTestsMixin.setUpcCs0|�d|j�}|�d|�d��|�|j�dS)ze
        The literal returns L{None} when given less data than the
        literal requires.
        rNs
incomplete)�literalFactoryrr1rT�assertNoResult)rB�literalr.r.r1�test_partialWrite;sz#LiteralTestsMixin.test_partialWritecCsFd}|�t|�|j�}|�|�}|�|t�|�|�|�|j�dS)zz
        The literal returns an empty L{bytes} instance when given
        exactly the data the literal requires.
        �completeN)r�r�rrTr�rHr-r��rB�datar��leftoverr.r.r1�test_exactWriteDs

z!LiteralTestsMixin.test_exactWritecCs0d}|�td�|j�}|�|�}|�|d�dS)zt
        The literal returns any left over L{bytes} when given more
        data than the literal requires.
        scompleteleftoverr��leftoverN)r�r�rrTr?r�r.r.r1�test_overlongWriteQs
z$LiteralTestsMixin.test_overlongWritecCs,|�d|j�}d}|�|�}|�||�dS)zo
        The literal returns an empty L{bytes} instance
        when given an empty L{bytes} instance.
        rr�N)r�rrTr?)rBr�r�r�r.r.r1�test_emptyLiteral]s
z#LiteralTestsMixin.test_emptyLiteralN)	rirjrkrr�r�r�r�r�r.r.r.r1r�-s	
r�c@seZdZdZejZdd�ZdS)�LiteralStringTestsz+
    Tests for L{self.literalFactory}.
    cCs\d}d}t�t|�|j�}t|�D]}|�|�q|�d�|�|j�}|�|||f�dS)z�
        Calling L{imap4.LiteralString.callback} with a line fires the
        instance's L{Deferred} with a 2-L{tuple} whose first element
        is the collected data and whose second is the provided line.
        �datarN)	r�
LiteralStringr�rr$rTr�rQr?)rBr��extrar�r�r/r.r.r1�
test_callbackqs
z LiteralStringTests.test_callbackN)rirjrkrrr�r�r�r.r.r.r1r�jsr�c@s&eZdZdZejZdd�Zdd�ZdS)�LiteralFileTestsz)
    Tests for L{imap4.LiteralFile}.
    cCstd}d}t�t|�|j�}t|�D]}|�|�q|�d�|�|j�}|�t|�d�|\}}|�|�	�d�dS)z�
        Calling L{imap4.LiteralFile.callback} with a line fires the
        instance's L{Deferred} with a 2-L{tuple} whose first element
        is the file and whose second is the provided line.
        r�rr�N)
r�LiteralFiler�rr$rTr�rQr?rP�rBr�r�r�r�r/�dataFiler.r.r1r��s
zLiteralFileTests.test_callbackcCs�d}d}|�tjdd�t�t|�|j�}t|�D]}|�|�q|�d�|�|j�}|�	t|�d�|\}}|�	|�
�d�dS)a=
        A L{imap4.LiteralFile} whose size exceeds the maximum
        in-memory size spools its content to disk, and invoking its
        L{callback} with a line fires the instance's L{Deferred} with
        a 2-L{tuple} whose first element is the spooled file and whose second
        is the provided line.
        r�r�_memoryFileLimitr�r�N)r�rr�r�rr$rTr�rQr?rPr�r.r.r1�test_callbackSpooledToDisk�s
z+LiteralFileTests.test_callbackSpooledToDiskN)	rirjrkrrr�r�r�r�r.r.r.r1r��s
r�c@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�WriteBufferTestsz)
    Tests for L{imap4.WriteBuffer}.
    cCst�|_dSr-)r'r�rLr.r.r1r��r5zWriteBufferTests.setUpcCs4t�|j�}d|j}|�|�|�|j���dS)zd
        L{imap4.WriteBuffer} buffers writes that are smaller than its
        buffer size.
        �xN)r�WriteBufferr��
bufferSizerTr-r��rB�bufr�r.r.r1r��s

z"WriteBufferTests.test_partialWritecCs:t�|j�}d|jd}|�|�|�|j��|�dS)z�
        L{imap4.WriteBuffer} writes data without buffering it when
        the size of the data exceeds the size of its buffer.
        r�r�N)rr�r�r�rTr?r�r�r.r.r1r��s
z#WriteBufferTests.test_overlongWritecCsXt�|j�}d|j}d}|�|�|�|j���|�|�|�|j��||�dS)zp
        L{imap4.WriteBuffer} buffers writes until its buffer's size
        exceeds its maximum value.
        r��yN)rr�r�r�rTr-r�r?)rBr��	firstData�
secondDatar.r.r1�test_writesImplyFlush�s


z&WriteBufferTests.test_writesImplyFlushcCsNt�|j�}d|j}|�|�|�|j���|��|�|j��|�dS)z{
        L{imap4.WriteBuffer.flush} flushes the buffer even when its
        size is smaller than the buffer size.
        r�N)	rr�r�r�rTr-r��flushr?r�r.r.r1�test_explicitFlush�s

z#WriteBufferTests.test_explicitFlushcCs(t�|j�}|��|�|j���dS)z_
        L{imap4.WriteBuffer.flush} has no effect if when the buffer is
        empty.
        N)rr�r�r�r-r�)rBr�r.r.r1�test_explicitFlushEmptyBuffer�sz.WriteBufferTests.test_explicitFlushEmptyBufferN)
rirjrkrr�r�r�r�r�r�r.r.r.r1r��sr�)�rr�rNr�r�r�r��collectionsr�ior�	itertoolsr�typingrrrr	�unittestr
�zope.interfacer�zope.interface.verifyrr
�twisted.cred.checkersr�twisted.cred.credentialsrrr�twisted.cred.errorr�twisted.cred.portalrr�twisted.internetrrrr�twisted.internet.taskr�twisted.mailr�twisted.mail.imap4r�twisted.mail.interfacesrrr�twisted.protocolsr �twisted.pythonr!r"r#�twisted.python.compatr$r%r&�twisted.test.proto_helpersr'r(�twisted.trial.unittestr)r*�twisted.test.ssl_helpersr+r,�ImportErrorr4r6rmryr�r�IMailboxInfo�IMailbox�ICloseableMailboxrrW�MemoryAccountWithoutNamespacesr\rcrgrorjr~r}r�r�r�rBrprjrtr�r�r�rr	rErHrjrlrmrwr�r�r�r�r��IMessage�
FancyStrMixinr�rrrfr��ISearchableMailboxr
r#�IMessageFiler%�IMessageCopierr'r)�IReactorSSLr;r[r_r�r�r�r�r�r�r�r�r.r.r.r1�<module>s�ehM:S2)'(.2gO
I.2!/N'BfS7		
QMC=8