o 8Va%@sdZddlZddlZddlZddlZddlZddlmZeddZ z ddl Z e eddZ Wn e y9dZ Ynwe r\e jZe jZe jZe jjZe jjZe jjZe jjZddlmZnQGdd d Zd*d d ZGd d d ZGdddeZGdddeZGdddeZGdddeZddZddZddZddZddZejd d!d"d#Zd$d%Z ejd&d'Z!ejd(d)Z"dS)+z$py.test hacks to support XFAIL/XPASSN)SymPyDeprecationWarningZTRAVIS_BUILD_NUMBERZ_running_pytestF)Failedc@seZdZddZddZdS) ExceptionInfocC ||_dSN)value)selfrr 6/usr/lib/python3/dist-packages/sympy/testing/pytest.py__init__$ zExceptionInfo.__init__cCs d|jS)Nz)formatrrr r r __repr__'s zExceptionInfo.__repr__N)__name__ __module__ __qualname__r rr r r r r#s 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)expectedExceptioncodeer r r raises+s"6 rc@s$eZdZddZddZddZdS)rcCrr)r)rrr r r r ur zRaisesContext.__init__cCsdSrr rr r r __enter__xszRaisesContext.__enter__cCs|durtdt||jS)Nr)r issubclassr)rexc_type exc_value tracebackr r r __exit__{s zRaisesContext.__exit__N)rrrr rr"r r r r rts rc@ eZdZdS)XFailNrrrr r r r r$r$c@r#)XPassNr%r r r r r'r&r'c@r#)SkippedNr%r r r r r(r&r(c@r#)rNr%r r r r rr&rcsfdd}t|}|S)Nc sPzWnty"}zt|}|dkrtjtdd}~wwtj)NZTimeout) Exceptionrr$rr(r')rmessagefuncr r wrappers   zXFAIL..wrapper functoolsupdate_wrapper)r,r-r r+r XFAILs  r1cCst|rr()rr r r skipr3csfdd}|S)z0Similar to ``skip()``, but this is a decorator. csfdd}t||}|S)Ncstrr2r reasonr r func_wrapperr4z+SKIP..wrapper..func_wrapperr.r,r7r5r r r-s  zSKIP..wrapperr )r6r-r r5r SKIPs r9cs(d_fdd}t|}|_|S)NTcs dSrr r r+r r r7r zslow..func_wrapper)Z_slowr/r0 __wrapped__r8r r+r slows   r;cCs|S)zBDummy decorator for marking tests that fail when cache is disabledr r+r r r nocache_failsr<)matchc#stjdd}tdtd|dVWdn1s!wYtfdd|Ds@dd d |Df}t|dS) aLike raises but tests that warnings are emitted. >>> from sympy.testing.pytest import warns >>> import warnings >>> with warns(UserWarning): ... warnings.warn('deprecated', UserWarning) >>> 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: []. TrecordignorealwaysNc3s|] }t|jVqdSr)rcategory.0w warningclsr r szwarns..z^Failed: DID NOT WARN. No warnings of type %s was emitted. The list of emitted warnings is: %s.cSsg|]}|jqSr )r*rDr r r szwarns..)warningscatch_warnings simplefilterfilterwarningsanyr)rHr>warnrecmsgr rGr warnss rRcs*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)NTFr r rSr,r r func_wraps  "z _both_exp_pow..func_wrap)Zsympy.core.parametersrSr/r0)r,rUr-r rTr _both_exp_pows  rVccs6tt dVWddS1swYdS)aSShorthand 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``. >>> from sympy.testing.pytest import warns_deprecated_sympy >>> from sympy.utilities.exceptions import SymPyDeprecationWarning >>> with warns_deprecated_sympy(): ... SymPyDeprecationWarning("Don't use", feature="old thing", ... deprecated_since_version="1.0", issue=123).warn() >>> 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: []. N)rRrr r r r warns_deprecated_sympys "rWccsrtjdd}td|dVWdn1swY|D]}t|j|s6t|j|j|j|jq"dS)arContext manager to suppress warnings during tests. This function is useful for suppressing warnings during tests. The warns function should be used to assert that a warning is raised. The ignore_warnings function is useful in situation when the warning is not guaranteed to be raised (e.g. on importing a module) or if the warning comes from third-party code. When the warning is coming (reliably) from SymPy the warns function should be preferred to ignore_warnings. >>> from sympy.testing.pytest import ignore_warnings >>> import warnings Here's a warning: >>> with warnings.catch_warnings(): # reset warnings in doctest ... warnings.simplefilter('error') ... warnings.warn('deprecated', UserWarning) Traceback (most recent call last): ... UserWarning: deprecated Let's suppress it with ignore_warnings: >>> with warnings.catch_warnings(): # reset warnings in doctest ... warnings.simplefilter('error') ... with ignore_warnings(UserWarning): ... warnings.warn('deprecated', UserWarning) (No warning emitted) Tr?rBN) rKrLrMrrC warn_explicitr*filenamelineno)rHrPrFr r r ignore_warningss#  r[r)#__doc__sysr/os contextlibrKZsympy.utilities.exceptionsrgetenvZ ON_TRAVISZpytestgetattrZ USE_PYTEST ImportErrorrrRr3ZmarkZxfailr1r9r;r<Z_pytest.outcomesrrrr)r$r'r(contextmanagerrVrWr[r r r r sT    I   !