o o h4@sJUdZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z ddl mZedddkZz ddlZeedd ZWn eyVd ZYnwe e e ge fed <e e ge fed <e e ge fed <e e ge fed <e e ge fed<e e ge fed<e e ge fed<erejZejZejjZejjZejjZejjZejjZddlm Z nKGdddZ!d2dd ZGdddZ"Gddde#Z$Gddde#Z%Gddde#Z&Gddde#Z dd Zd d Zd!d Zd"dZd#dZd$dZej'd%d&d'd(d)Z(d*d+Z)ej'd,d-Z*d.d/Z+d0d1Z,dS)3z$py.test hacks to support XFAIL/XPASSN)AnyCallable)SymPyDeprecationWarning)ignore_warningsCItrue_running_pytestFraisesXFAILskipSKIPslowtooslow nocache_fail)Failedc@seZdZddZddZdS) ExceptionInfocC ||_dSN)value)selfrrh/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/testing/pytest.py__init__5 zExceptionInfo.__init__cCs d|jS)Nz)formatrrrrr__repr__8 zExceptionInfo.__repr__N)__name__ __module__ __qualname__rrrrrrr4s rc Csp|durt|St|r+z|Wtd|y*}z t|WYd}~Sd}~wwt|tr4tdtd)a Tests that ``code`` raises the exception ``expectedException``. ``code`` may be a callable, such as a lambda expression or function name. If ``code`` is not given or None, ``raises`` will return a context manager for use in ``with`` statements; the code to execute then comes from the scope of the ``with``. ``raises()`` does nothing if the callable raises the expected exception, otherwise it raises an AssertionError. Examples ======== >>> from sympy.testing.pytest import raises >>> raises(ZeroDivisionError, lambda: 1/0) >>> raises(ZeroDivisionError, lambda: 1/2) Traceback (most recent call last): ... Failed: DID NOT RAISE >>> with raises(ZeroDivisionError): ... n = 1/0 >>> with raises(ZeroDivisionError): ... n = 1/2 Traceback (most recent call last): ... Failed: DID NOT RAISE Note that you cannot test multiple statements via ``with raises``: >>> with raises(ZeroDivisionError): ... n = 1/0 # will execute and raise, aborting the ``with`` ... n = 9999/0 # never executed This is just what ``with`` is supposed to do: abort the contained statement sequence at the first exception and let the context manager deal with the exception. To test multiple statements, you'll need a separate ``with`` for each: >>> with raises(ZeroDivisionError): ... n = 1/0 # will execute and raise >>> with raises(ZeroDivisionError): ... n = 9999/0 # will also execute and raise N DID NOT RAISEz'raises(xxx, "code")' has been phased out; change 'raises(xxx, "expression")' to 'raises(xxx, lambda: expression)', 'raises(xxx, "statement")' to 'with raises(xxx): statement'z1raises() expects a callable for the 2nd argument.) RaisesContextcallablerr isinstancestr TypeError)expectedExceptioncodeerrrr <s"6 c@s$eZdZddZddZddZdS)r"cCrr)r')rr'rrrrrzRaisesContext.__init__cCsdSrrrrrr __enter__szRaisesContext.__enter__cCs|durtdt||jS)Nr!)r issubclassr')rexc_type exc_value tracebackrrr__exit__s zRaisesContext.__exit__N)rrr rr*r/rrrrr"s r"c@ eZdZdS)XFailNrrr rrrrr1r1c@r0)XPassNr2rrrrr4r3r4c@r0)SkippedNr2rrrrr5r3r5c@r0)rNr2rrrrrr3rcsfdd}t|}|S)Nc sPzWnty"}zt|}|dkrtjtdd}~wwtj)NTimeout) Exceptionr%r1rr5r4)r)messagefuncrrwrappers   zXFAIL..wrapper functoolsupdate_wrapper)r:r;rr9rr s  cCst|rr5)r%rrrr cfdd}|S)z0Similar to ``skip()``, but this is a decorator. csfdd}t||}|S)Ncstrr?rreasonrr func_wrapperr@z+SKIP..wrapper..func_wrapperr<r:rDrBrrr;s  zSKIP..wrapperr)rCr;rrBrr  cs(d_fdd}t|}|_|S)NTcs dSrrrr9rrrDrzslow..func_wrapper)_slowr=r> __wrapped__rErr9rr s   cCs*d|_d|_dd}t||}||_|S)NTcSs tddS)NzToo slow)r rrrrrDrztooslow..func_wrapper)rG_tooslowr=r>rHrErrrrs  cCs|S)zBDummy decorator for marking tests that fail when cache is disabledrr9rrrrsT)matchtest_stacklevelc#stjdd}tdtjdd|VWdn1s!wYtfdd|Ds@d d d |Df}t||D]#}t|jsLJt |tj  t |j setd jd |dqB|rtD]}|j}tj|d}|drn |dkrdSqltd|D]}|j|krd|jd|jd|ddd}t|qtkr tt} | jjjdddd} | sdSg} |D] }| |j j qt!| dd }|"} Wdn1swY| D]} d| d| vr td | d!| d"qdSdS)#a Like raises but tests that warnings are emitted. >>> from sympy.testing.pytest import warns >>> import warnings >>> with warns(UserWarning): ... warnings.warn('deprecated', UserWarning, stacklevel=2) >>> with warns(UserWarning): ... pass Traceback (most recent call last): ... Failed: DID NOT WARN. No warnings of type UserWarning was emitted. The list of emitted warnings is: []. ``test_stacklevel`` makes it check that the ``stacklevel`` parameter to ``warn()`` is set so that the warning shows the user line of code (the code under the warns() context manager). Set this to False if this is ambiguous or if the context manager does not test the direct user code that emits the warning. If the warning is a ``SymPyDeprecationWarning``, this additionally tests that the ``active_deprecations_target`` is a real target in the ``active-deprecations.md`` file. T)recorderroralways)categoryNc3s|] }t|jVqdSr)r+rP.0w warningclsrr szwarns..z^Failed: DID NOT WARN. No warnings of type %s was emitted. The list of emitted warnings is: %s.cSsg|]}|jqSrr8rQrrr szwarns..z?Failed: WRONG MESSAGE. A warning with of the correct category (z:) was issued, but it did not match the given match regex ()test_z doctest.pyzDCould not find the file for the given warning to test the stacklevelzFailed: Warning has the wrong stacklevel. The warning stacklevel needs to be set so that the line of code shown in the warning message is user code that calls the deprecated code (the current stacklevel is showing code from z (line z ), expected   docsrc explanationzactive-deprecations.mdzutf-8)encoding(z)=zThe active deprecations target zJ does not appear to be a valid target in the active-deprecations.md file (z).)#warningscatch_warnings simplefilterfilterwarningsanyrr+rPrecompileIrKr%r8rinspectstackfilenameospathsplit startswith RuntimeErrorlinenoreplacerpathlibPath__file__parentexistsappendactive_deprecations_targetopenread)rUrKrLwarnrecmsgrSfthisfilefile this_fileactive_deprecations_filetargetstexttargetrrTrwarnss|        rcs*ddlmfdd}t|}|S)a8 Decorator used to run the test twice: the first time `e^x` is represented as ``Pow(E, x)``, the second time as ``exp(x)`` (exponential object is not a power). This is a temporary trick helping to manage the elimination of the class ``exp`` in favor of a replacement by ``Pow(E, ...)``. r) _exp_is_powcsbd Wdn1swYd WddS1s*wYdS)NTFrrrr:rr func_wrap;s  "z _both_exp_pow..func_wrap)sympy.core.parametersrr=r>)r:rr;rrr _both_exp_pow0s  rccs6tt dVWddS1swYdS)a: Shorthand for ``warns(SymPyDeprecationWarning)`` This is the recommended way to test that ``SymPyDeprecationWarning`` is emitted for deprecated features in SymPy. To test for other warnings use ``warns``. To suppress warnings without asserting that they are emitted use ``ignore_warnings``. .. note:: ``warns_deprecated_sympy()`` is only intended for internal use in the SymPy test suite to test that a deprecation warning triggers properly. All other code in the SymPy codebase, including documentation examples, should not use deprecated behavior. If you are a user of SymPy and you want to disable SymPyDeprecationWarnings, use ``warnings`` filters (see :ref:`silencing-sympy-deprecation-warnings`). >>> from sympy.testing.pytest import warns_deprecated_sympy >>> from sympy.utilities.exceptions import sympy_deprecation_warning >>> with warns_deprecated_sympy(): ... sympy_deprecation_warning("Don't use", ... deprecated_since_version="1.0", ... active_deprecations_target="active-deprecations") >>> with warns_deprecated_sympy(): ... pass Traceback (most recent call last): ... Failed: DID NOT WARN. No warnings of type SymPyDeprecationWarning was emitted. The list of emitted warnings is: []. .. note:: Sometimes the stacklevel test will fail because the same warning is emitted multiple times. In this case, you can use :func:`sympy.utilities.exceptions.ignore_warnings` in the code to prevent the ``SymPyDeprecationWarning`` from being emitted again recursively. In rare cases it is impossible to have a consistent ``stacklevel`` for deprecation warnings because different ways of calling a function will produce different call stacks.. In those cases, use ``warns(SymPyDeprecationWarning)`` instead. See Also ======== sympy.utilities.exceptions.SymPyDeprecationWarning sympy.utilities.exceptions.sympy_deprecation_warning sympy.utilities.decorator.deprecated N)rrrrrrwarns_deprecated_sympyEs 5"rcCs$zddl}WdStyYdSw)zTest if running under pyodide.rNFT) pyodide_js ImportError)rrrr_running_under_pyodide~s   rcrA)z2Decorator to skip a test if running under pyodide.cstfdd}|S)NcstrtSr)rr r)r8 test_funcrr test_wrappersz;skip_under_pyodide..decorator..test_wrapper)r=wraps)rrrW)rr decoratorsz%skip_under_pyodide..decoratorr)r8rrrWrskip_under_pyodiderFrr)-__doc__sysrhr=rn contextlibrcrkrutypingrrsympy.utilities.exceptionsrrgetenvON_CIpytestgetattr USE_PYTESTr__annotations__r r markxfailr r r rr_pytest.outcomesrrr"r7r1r4r5contextmanagerrrrrrrrrrsn    I    \ 8