f gZ9XddlmZddlZddlZddlmZmZmZmZm Z GddZ dS))contextmanagerN) ParserElementParseExceptionKeyword__diag__ __compat__ceZdZdZGddZGddZe dd dd d ed ej e d ej e de dedej edej edej ee fde defdZ dS)pyparsing_testzB namespace class for classes useful in writing unit tests c6eZdZdZdZdZdZdZdZdZ dS) &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 ci|_dSN) _save_contextselfs a/home/jenkins/workspace/simtester-sanitize/venv/lib/python3.11/site-packages/pyparsing/testing.py__init__z/pyparsing_test.reset_pyparsing_context.__init__/s!#D   ctj|jd<tj|jd<tj|jd<tj|jd<tj|jd<tjrtjj |jd<n d|jd<tj |jd<tj |jd<d tj D|jd <d tji|jd <|S) Ndefault_whitespacedefault_keyword_charsliteral_string_classverbose_stacktracepackrat_enabledpackrat_cache_size packrat_parserecursion_enabledc:i|]}|tt|S)getattrr).0names r z?pyparsing_test.reset_pyparsing_context.save..Hs1...26gh--...rrcollect_all_And_tokensr )rDEFAULT_WHITE_CHARSrrDEFAULT_KEYWORD_CHARS_literalStringClassr_packratEnabled packrat_cachesize_parse_left_recursion_enabledr _all_namesr r%rs rsavez+pyparsing_test.reset_pyparsing_context.save2s7D7XD 3 4:A:WD 6 71  5 68E7WD 3 44A4QD 0 1, @!/4"#788<@"#782?2FD  /5  2 3..:B:M...D z * )**K0D | ,Krctj|jdkrtj|jd|jdt_|jdt _tj|jd|jdD](\}}|r tj n tj |)dt_ |jdr tj |jdn|jd t_|jd t_|jd t _|S) NrrrrrFrrrrr )rr&rset_default_whitespace_charsrrr'inlineLiteralsUsingitemsrenabledisabler)enable_packratr,r-r r%)rr#values rrestorez.pyparsing_test.reset_pyparsing_context.restoreRsE1%&:;<<:&';<04/ABV/WM ,,0,>?V,WG )  -"#9:    $1*=CCEE G G e?E?x/?FFFF,1M )!"34 K,T-?@T-UVVVV'+'9/'J $484F#5M 1150B<0PJ -Krcrt|}|j|j|Sr)typerupdate)rrets rcopyz+pyparsing_test.reset_pyparsing_context.copyss2$t**,,C   $ $T%7 8 8 8Jrc*|Sr)r/rs r __enter__z0pyparsing_test.reset_pyparsing_context.__enter__xs99;; rc.|dSr)r8)rargss r__exit__z/pyparsing_test.reset_pyparsing_context.__exit__{s LLNNNNNrN) __name__ __module__ __qualname____doc__rr/r8r=r?rBr rrreset_pyparsing_contextr sz  0 $ $ $   @   B            rrGcXeZdZdZ d dZ d dZ d dZ d dZee ddfdZ dS) &pyparsing_test.TestParseResultsAssertszk A mixin class to add parse results assertion methods to normal unittest.TestCase classes. Nc|*|||||,||||dSdS)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``. Nmsg) assertEqualas_listas_dict)rresult expected_list expected_dictrLs rassertParseResultsEqualsz?pyparsing_test.TestParseResultsAsserts.assertParseResultsEqualssh(  0@0@c JJJ(  0@0@c JJJJJ)(rTc||d}|r"t|n!t|||||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) parse_all)rQrLN parse_stringprintdumprNrS)rexpr test_stringrQrLverboserPs rassertParseAndCheckListz>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckListsw&&{d&CCF (fkkmm$$$$fnn&&'''  ) )& SV ) W W W W Wrc||d}|r"t|n!t|||||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)rRrLNrV)rrZr[rRrLr\rPs rassertParseAndCheckDictz>pyparsing_test.TestParseResultsAsserts.assertParseAndCheckDictsw&&{T&BBF (fkkmm$$$$fnn&&'''  ) )& SV ) W W W W Wrc|\}}|||||nddSdt||D}|D]\}}} td| Dd} td| Dd} | J|| | p|5t |t r| dddn #1swxYwYtd| Dd} td | Dd} | | fd kr||| | | p| td |||||nddS) 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)] Nzfailed runTestsrKc"g|] \}}g||R Sr r )r"rptexpecteds r zOpyparsing_test.TestParseResultsAsserts.assertRunTestResults..s9!C!# x  rc3DK|]}t|t|VdSr) isinstancestrr"exps r zNpyparsing_test.TestParseResultsAsserts.assertRunTestResults..s1 Q QJsC.s[%c4006@Y5O5Or)expected_exceptionrLc3DK|]}t|t|VdSr)rglistris rrkzNpyparsing_test.TestParseResultsAsserts.assertRunTestResults..1JJJsD4I4IJJJJJJJrc3DK|]}t|t|VdSr)rgdictris rrkzNpyparsing_test.TestParseResultsAsserts.assertRunTestResults..rrrNN)rQrRrLzno validation for ) assertTruezipnext assertRaisesrgrnrSrX)rrun_tests_reportexpected_parse_resultsrLrun_test_successrun_test_resultsmergedr[rPrdfail_msgrorQrRs rassertRunTestResultsz;pyparsing_test.TestParseResultsAsserts.assertRunTestResultssZ2B . .%-$##FW %()9;Q%R%RF28# D# D- VX Q Q Q Q QSWXX%)#+  &&"&1**+=8?s+))&fi88)"(L)))))))))))))))) %)JJJJJD%%M%)JJJJJD%%M&}5EE55"*7*7 (C 6B;BBCCCC OO S_ccBS      sB;;B? B? c#6K|`t|trtj|}||||5}|VddddS#1swxYwYdS|||5}|VddddS#1swxYwYdS)NrK)rgrhreescapeassertRaisesRegexry)rexc_type expected_msgrLctxs rassertRaisesParseExceptionzApyparsing_test.TestParseResultsAsserts.assertRaisesParseExceptions:'lC00;#%9\#:#:L++Hl+LLPSIII&&xS&99SIIIs$AAA<BBB)NNN)NTru) rCrDrErFrSr]r`rrrrr rrTestParseResultsAssertsrI~s  GK K K K KGK X X X XGK X X X XFJ@ @ @ @ D )$       rrNT|)indentbase_1s start_lineend_line expand_tabseol_mark mark_spaces mark_controlrrreturnc |r|}ttrdz|tjt |}|dkrXdt tddtddD} d | d <t | } d nTt|t fd ttdd d gzD} | | }|U|dkrO|dkr3t ddd} | | }n| d|}|d}|t|}t|t|}ttd||}|dkr |||z |} n*d|d||z |D} | sd Stt |td| D} ddzzz} | dkrP| |rd ndzd dt|rdndt| dzdDzdz}nd }|rd nd| zd dt| dz Dzdz}d}| |rd ndz|| dz zzdz}||zdfdt'| ||zDzdzS)u Helpful method for debugging a parser - prints a string with line and column numbers. (Line and column numbers are 1-based by default - if debugging a parse action, pass base_1=False, to correspond to the loc value passed to the parse action.) :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 :param indent: str | int - (optional) string to indent with line and column numbers; if an int is passed, converted to " " * indent :param base_1: bool - (optional) whether to label string using base 1; if False, string will be labeled based at 0 (default=True) :return: str - input string with leading line numbers and column number headers  Nunicodeci|]\}}|| Sr r )r"cus rr$z4pyparsing_test.with_line_numbers..'s+"""!QAq"""rr!i$i3$i!$rci|]}|Sr r )r"rord_mark_controls rr$z4pyparsing_test.with_line_numbers..0sMMMQQ(MMMr i $i#$) rcg|]}|dzS)␊r r"lines rrez4pyparsing_test.with_line_numbers..Cs)!%u rrc34K|]}t|VdSr)lenrs rrkz3pyparsing_test.with_line_numbers..Js(993t99999999rrcc3.K|]}d|dzdzVdS)zc rdNr r"is rrkz3pyparsing_test.with_line_numbers..PsI 0!a%300rr c3,K|]}d|dzdzVdS)z r Nr rs rrkz3pyparsing_test.with_line_numbers..[s3XXQ01q5B,00XXXXXXrr 12345678900c3<K|]\}}|dd|VdS)d:Nr )r"rrrr lineno_widths rrkz3pyparsing_test.with_line_numbers..es^At?1l?????t?X??r)start) expandtabsrginttypingcastrhrwrange maketransordrq translatereplacerminmax splitlinessplitjoin enumerate)rrrrrrrrrtranstable_maptbls_lines max_line_lenleadheader0header1digitsheader2rrs ` ` @@rwith_line_numbersz pyparsing_test.with_line_numberssH   A fc " " "6\F""$$  #!;sL99Ly((""%(q"uVV7L7L%M%M"""'-s#mmN33#&|#4#4 mmMMMM$uQ||2D2Du2LMMM C  A  "{c'9'9i''mmF$;$;<<KK$$IIc;//  J  1vvHxQ((Q ++X66 9 $ $llnnZ&%88%CDGG)* V8Kh8V)WG 23x==)) 9999999 |a/00 2  (22S*''"#511As<3;NPQ7R7RSS   GG "RRs ggXX%<-SUBU@V:W:WXXXXX Y    &)BBc *V,"9L7M-N NQU U   ii( V8KLLL     r)NNTrNN)rCrDrErFrGr staticmethodrhrOptionalrboolUnionrr rrr r seffffffffP{{{{{{{{z,0)- ,0-1n *,n n n n OC(n /#&n  n  n _S) n oc*n  S#X&n n  n n n \n n n rr ) contextlibrrrcorerrrrr r r rrrs&%%%%% Y Y Y Y Y Y Y Y Y Y r