B

®*ã
Š`ã@sFdd
lm
Z

ddlmZ
ddlmZmZmZmZm	Z	
Gdd„dƒZ
dS)é)
Úcontextmanager)
ÚOptionalé
)Ú
ParserElementÚParseExceptionÚKeywordÚ__diag__Ú
__compat__c@s^eZ
dZd
ZGdd„dƒZGdd„dƒZedeee	ee	e
eeeeeed	œd
d„ƒ
ZdS)
Ú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
ú/build/wlanpi-profiler-7IIg1Q/wlanpi-profiler-1.0.11/debian/wlanpi-profiler/opt/wlanpi-profiler/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_CHARSrrÚDEFAULT_KEYWORD_CHARSÚ_literalStringClassrÚ_packratEnabledÚ
packrat_cacheÚsizeÚ_parseÚ_left_recursion_enabledrÚ
_all_namesr	r)
rr
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	)rrrZset_default_whitespace_charsrrrÚinlineLiteralsUsingÚitemsrÚenableÚdisabler Zenable_packratr#r$r	r)rrÚvaluer
r
rÚrestorePs$









z.pyparsing_test.reset_pyparsing_context.restorec
Cst|ƒ
ƒ}
|
j
 |j
¡

|
S)
N)ÚtyperÚupdate)rÚretr
r
rÚcopyqs



z+pyparsing_test.reset_pyparsing_context.copyc

Cs| ¡S)
N)
r&)
rr
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,r0r1r3r
r
r
rÚreset_pyparsing_contexts !r8c@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)ÚassertEqualÚas_listZas_dict)rÚresultÚ
expected_listÚ
expected_dictr9r
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)r=r9N)Úparse_stringÚprintÚdumpr;r?)rÚexprÚtest_stringr=r9Úverboser<r
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)
ÚparseAll)r>r9N)r@rArBr;r?)rrCrDr>r9rEr<r
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
)rÚrptÚ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)rLr-Ú
issubclassÚ	Exception)rrNr
r
rrOÅs

)Úexpected_exceptionr9c
ss|]}
t|
t
ƒr|
V
qdS)
N)rLÚlist)rrNr
r
rrOÓsc
ss|]}
t|
t
ƒr|
V
qdS)
N)rLÚdict)rrNr
r
rrOÖs)NN)r=r>r9zno validation for {!r}zfailed runTests)
r9)	ÚzipÚnextÚassertRaisesrLrQr?rAÚformatÚ
assertTrue)rÚrun_tests_reportÚexpected_parse_resultsr9Úrun_test_successÚrun_test_resultsÚmergedrDr<rJÚfail_msgrRr=r>r
r
rÚassertRunTestResults©s:














z;pyparsing_test.TestParseResultsAsserts.assertRunTestResultsc	cs$|j|
|d

dV
WdQRXdS)N)
r9)
rW)rÚexc_typer9r
r
rÚassertRaisesParseExceptionès
zApyparsing_test.TestParseResultsAsserts.assertRaisesParseException)NNN)NT)NT)NN)r4r5r6r7r?rFrHr`rrrbr
r
r
rÚTestParseResultsAsserts|s



>
rcNTú
|)Ú
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
        NÚunicodec
Ssi|]\}
}||
“qSr
r
)rÚ
cÚ
ur
r
rr
sz4pyparsing_test.with_line_numbers.<locals>.<dictcomp>r
é!i$i3$éi!$Úc
si|]
}
ˆ|
“qSr
r
)rrn)
rkr
rr
sé ú
 i	$i#$)é	rsrc
Ssg|]}
|
d‘qS)
u␊r
)rÚliner
r
rrK'
sz4pyparsing_test.with_line_numbers.<locals>.<listcomp>u␊c
ss|]}
t|
ƒ
V
qdS)
N)
Úlen)rrvr
r
rrO,
sz3pyparsing_test.with_line_numbers.<locals>.<genexpr>écc
ss"|]}
d d
|
dd¡V
qdS)z{}{}zc                                                                                                   rédN)
rX)rÚ
ir
r
rrO2
s
ryÚ

c
ss |]}
d |
d
d¡
V
qdS)z         {}ré
N)
rX)rrzr
r
rrO=
s
r|Z
1234567890c
3s"|]\}
}d |
ˆ
|ˆ¡V
qd
S)z{:{}d}:{}{}N)
rX)rrzrv)riÚlineno_widthr
rrOG
s
)
Ústart)Ú
expandtabsrMÚ	maketransrUÚrangerSÚ	translateÚreplacerwÚminÚmaxÚ
splitlinesÚsplitÚjoinÚ	enumerate)rerfrgrhrirjrkZtblZs_linesZmax_line_lenZleadZheader0Zheader1Zheader2r
)rir}rkrÚwith_line_numbersísH






$












 





,,z pyparsing_test.with_line_numbers)NNTrdNN)r4r5r6r7r8rcÚstaticmethodrMrÚintÚboolrŠr
r
r
rr
shq




 
r
N)Ú
contextlibrÚtypingrÚcorerrrrr	r
r
r
r
rÚ<module>s