B

�f%dZ4�@sBdd
lm
Z

ddlZddlmZmZmZmZmZ
Gdd�d�Z	dS)�)
�contextmanagerN�
)�
ParserElement�ParseException�Keyword�__diag__�
__compat__c@sfeZ
dZd
ZGdd�d�ZGdd�d�Zedeej	e
ej	e
eeej	eej	eed	�d
d��
ZdS)
�pyparsing_testzB
    namespace class for classes useful in writing unit tests
    c@s@eZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)z&pyparsing_test.reset_pyparsing_contexta�
        Context manager to be used when writing unit tests that modify pyparsing config values:
        - packrat parsing
        - bounded recursion parsing
        - default whitespace characters.
        - default keyword characters
        - literal string auto-conversion class
        - __diag__ settings

        Example::

            with reset_pyparsing_context():
                # test that literals used to construct a grammar are automatically suppressed
                ParserElement.inlineLiteralsUsing(Suppress)

                term = Word(alphas) | Word(nums)
                group = Group('(' + term[...] + ')')

                # assert that the '()' characters are not included in the parsed tokens
                self.assertParseAndCheckList(group, "(abc 123 def)", ['abc', '123', 'def'])

            # after exiting context manager, literals are converted to Literal expressions again
        c

Cs
i|_dS)
N)
�
_save_context)
�self�r�B/opt/alt/python37/lib/python3.7/site-packages/pyparsing/testing.py�__init__-s
z/pyparsing_test.reset_pyparsing_context.__init__c

Cs�tj
|jd
<tj|jd<tj|jd<tj|jd<tj|jd<tjrRtjj	|jd<n
d|jd<tj
|jd<tj|jd<d	d
�tj
D�
|jd<dtji
|jd
<|S)N�default_whitespace�default_keyword_chars�literal_string_class�verbose_stacktrace�packrat_enabled�packrat_cache_size�
packrat_parse�recursion_enabledc
Ssi|]}
tt
|
�|
�qSr)�getattrr)�.0�namerrr
�
<dictcomp>Fs
z?pyparsing_test.reset_pyparsing_context.save.<locals>.<dictcomp>r�collect_all_And_tokensr)r�DEFAULT_WHITE_CHARSr
r�DEFAULT_KEYWORD_CHARSZ_literalStringClassr�_packratEnabledZ
packrat_cache�size�_parse�_left_recursion_enabledrZ
_all_namesrr)
rrrr
�save0s





z+pyparsing_test.reset_pyparsing_context.savec
Cs�tj
|jd
kr t�|jd
�

|jdt_|jdt_t�|jd�

x.|jd��D]\}
}|rjt	j
nt	j|
�

qXWdt_|jdr�t�
|jd�

n|jd	t_|jd
t_|jdt_|S)NrrrrrFrrrrr)rrr
Zset_default_whitespace_charsrrrZinlineLiteralsUsing�itemsrZenableZdisablerZenable_packratr r!rr)rr�valuerrr
�restorePs$









z.pyparsing_test.reset_pyparsing_context.restorec
Cst|�
�}
|
j
�|j
�

|
S)
N)�typer
�update)rZretrrr
�copyqs



z+pyparsing_test.reset_pyparsing_context.copyc

Cs|��S)
N)
r")
rrrr
�	__enter__vs
z0pyparsing_test.reset_pyparsing_context.__enter__c
Gs|��
dS)
N)
r%)r�argsrrr
�__exit__ys
z/pyparsing_test.reset_pyparsing_context.__exit__N)
�__name__�
__module__�__qualname__�__doc__rr"r%r(r)r+rrrr
�reset_pyparsing_contexts !r0c@sJeZ
dZd
Zddd�
Zddd�
Zddd	�
Zdd
d�
Zee	dfdd
�
�
Z
dS)z&pyparsing_test.TestParseResultsAssertszk
        A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
        NcCs<|d
k	r|j||
�
�|d�
|d
k	r8|j||
��|d�
d
S)z�
            Unit test assertion to compare a :class:`ParseResults` object with an optional ``expected_list``,
            and compare any defined results names with an optional ``expected_dict``.
            N)
�msg)ZassertEqual�as_listZas_dict)r�result�
expected_list�
expected_dictr1rrr
�assertParseResultsEquals�s


z?pyparsing_test.TestParseResultsAsserts.assertParseResultsEqualsTcCs@|
j|d
d�}|r t
|���

nt
|���

|j|||d�
dS)z�
            Convenience wrapper assert to test a parser element and input string, and assert that
            the resulting ``ParseResults.asList()`` is equal to the ``expected_list``.
            T)
Z	parse_all)r4r1N)�parse_string�print�dumpr2r6)r�expr�test_stringr4r1�verboser3rrr
�assertParseAndCheckList�s



z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckListcCs@|
j|d
d�}|r t
|���

nt
|���

|j|||d�
dS)z�
            Convenience wrapper assert to test a parser element and input string, and assert that
            the resulting ``ParseResults.asDict()`` is equal to the ``expected_dict``.
            T)
ZparseAll)r5r1N)r7r8r9r2r6)rr:r;r5r1r<r3rrr
�assertParseAndCheckDict�s



z>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDictc
Cs
|
\}}|d
k	r�dd�t||�D�
}x�|D]�\}}}	t
dd�|	D�
d
�}
t
dd�|	D�
d
�}|d
k	r�|j||
pp|d��
t|t�r�|�
Wd
QRXq*t
dd�|	D�
d
�}t
d	d�|	D�
d
�}
||
fd
kr�|j|||
|
p�|d�
q*td�|�
�

q*W|j||d
k	�
r|nd
d�
d
S)ah
            Unit test assertion to evaluate output of ``ParserElement.runTests()``. If a list of
            list-dict tuples is given as the ``expected_parse_results`` argument, then these are zipped
            with the report tuples returned by ``runTests`` and evaluated using ``assertParseResultsEquals``.
            Finally, asserts that the overall ``runTests()`` success value is ``True``.

            :param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests
            :param expected_parse_results (optional): [tuple(str, list, dict, Exception)]
            Nc
Ssg|]\}
}|
|f
��qSrr)rZrpt�expectedrrr
�
<listcomp>�s
zOpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<listcomp>c
ss|]}
t|
t
�r|
V
qdS)
N)�
isinstance�str)r�exprrr
�	<genexpr>�szNpyparsing_test.TestParseResultsAsserts.assertRunTestResults.<locals>.<genexpr>c
ss&|]}
t|
t
�rt|
t�r|
V
qdS)
N)rAr&�
issubclass�	Exception)rrCrrr
rD�s

)�expected_exceptionr1c
ss|]}
t|
t
�r|
V
qdS)
N)rA�list)rrCrrr
rD�sc
ss|]}
t|
t
�r|
V
qdS)
N)rA�dict)rrCrrr
rD�s)NN)r4r5r1zno validation for {!r}zfailed runTests)
r1)	�zip�next�assertRaisesrArFr6r8�formatZ
assertTrue)rZrun_tests_reportZexpected_parse_resultsr1Zrun_test_successZrun_test_resultsZmergedr;r3r?Zfail_msgrGr4r5rrr
�assertRunTestResults�s:














z;pyparsing_test.TestParseResultsAsserts.assertRunTestResultsc	cs$|j|
|d
��
dV
WdQRXdS)N)
r1)
rL)r�exc_typer1rrr
�assertRaisesParseException�s
zApyparsing_test.TestParseResultsAsserts.assertRaisesParseException)NNN)NT)NT)NN)r,r-r.r/r6r=r>rNrrrPrrrr
�TestParseResultsAsserts|s



>
rQNT�
|)�
s�
start_line�end_line�expand_tabs�eol_mark�mark_spaces�mark_control�returncs|r|��}�d
k	r��dkrPt
�dd�ttdd�tdd��D�
d	d
i
B�
}d�n(t
��f
dd�ttdd
��
d	g
D�
�
}|�|�
}|d
k	r�|dkr�|dkr�t
�ddd��
}|�|�
}n|�d|�}|
d
kr�d}
|d
kr�t|�
}t	|t|�
�}t	t
d|
�|�}
�dk�
r|��|
d|�}n dd�|�d�
|
d|�D�
}|�
sFdStt
|�
�
�
t
dd�|D�
�
}	d�
d}
|	dk�
r�|
d�
dd�tt
|	dd��
D�
�
d}nd}||
d�
dd�t|	d�
D�
�
d}|
d|	dd}
||
d�
��
fdd�t||
d �D�
�
dS)!u	
        Helpful method for debugging a parser - prints a string with line and column numbers.
        (Line and column numbers are 1-based.)

        :param s: tuple(bool, str - string to be printed with line and column numbers
        :param start_line: int - (optional) starting line number in s to print (default=1)
        :param end_line: int - (optional) ending line number in s to print (default=len(s))
        :param expand_tabs: bool - (optional) expand tabs to spaces, to match the pyparsing default
        :param eol_mark: str - (optional) string to mark the end of lines, helps visualize trailing spaces (default="|")
        :param mark_spaces: str - (optional) special character to display in place of spaces
        :param mark_control: str - (optional) convert non-printing control characters to a placeholding
                                 character; valid values:
                                 - "unicode" - replaces control chars with Unicode symbols, such as "␍" and "␊"
                                 - any single character string - replace control characters with given string
                                 - None (default) - string is displayed as-is

        :return: str - input string with leading line numbers and column number headers
        NZunicodec
Ssi|]\}
}||
�qSrr)r�
c�
urrr
r
sz4pyparsing_test.with_line_numbers.<locals>.<dictcomp>r
�!i$i3$�i!$�c
si|]
}
�|
�qSrr)rr[)
rYrr
r
s� �
 i	$i#$)�	r`rc
Ssg|]}
|
d�qS)
u␊r)r�linerrr
r@'
sz4pyparsing_test.with_line_numbers.<locals>.<listcomp>u␊c
ss|]}
t|
�
V
qdS)
N)
�len)rrcrrr
rD,
sz3pyparsing_test.with_line_numbers.<locals>.<genexpr>�cc
ss"|]}
d�d
|
dd�V
qdS)z{}{}zc                                                                                                   r�dN)
rM)r�
irrr
rD2
s
rf�

c
ss |]}
d�|
d
d�
V
qdS)z         {}r�
N)
rM)rrgrrr
rD=
s
riZ
1234567890c
3s"|]\}
}d�|
�
|��V
qd
S)z{:{}d}:{}{}N)
rM)rrgrc)rW�lineno_widthrr
rDG
s
)
�start)�
expandtabsrB�	maketransrJ�rangerH�	translate�replacerd�min�max�
splitlines�split�join�	enumerate)rSrTrUrVrWrXrYZtblZs_linesZmax_line_lenZleadZheader0Zheader1Zheader2r)rWrjrYr
�with_line_numbers�sH






$












 





,,z pyparsing_test.with_line_numbers)NNTrRNN)
r,r-r.r/r0rQ�staticmethodrB�typingZOptional�int�boolrwrrrr
r	shq




(
r	)
�
contextlibrryZcorerrrrrr	rrrr
�<module>s