ó ¡¼™\c@ s dZddlmZmZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z yXddlZddlmZddlmZddlmZmZeed eƒZWnek rïeZnXejd dƒZes»dd „Zd efd „ƒYZdefd„ƒYZ defd„ƒYZ!defd„ƒYZ"defd„ƒYZd„Z#d„Zd„Z$d„Z%ej&d„ƒZn'ej'j(j)Z#ej'j(j%Z%d„Z$ej&d„ƒZ*ej&d„ƒZ+dS(s$py.test hacks to support XFAIL/XPASSiÿÿÿÿ(tprint_functiontdivisionN(tget_function_namet string_types(tSymPyDeprecationWarning(traises(twarns(tskiptFailedt_running_pytesttTRAVIS_BUILD_NUMBERcC s|dkrt|ƒSt|ƒrQy |ƒWn|k rAdSXtdƒ‚n*t|tƒrotdƒ‚n tdƒ‚dS(sµ 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.utilities.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 Ns DID NOT RAISEs¯'raises(xxx, "code")' has been phased out; change 'raises(xxx, "expression")' to 'raises(xxx, lambda: expression)', 'raises(xxx, "statement")' to 'with raises(xxx): statement's1raises() expects a callable for the 2nd argument.(tNonet RaisesContexttcallableRt isinstanceRt TypeError(texpectedExceptiontcode((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyRs5      R cB s#eZd„Zd„Zd„ZRS(cC s ||_dS(N(R(tselfR((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyt__init__cscC sdS(N(R (R((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyt __enter__fscC s+|dkrtdƒ‚nt||jƒS(Ns DID NOT RAISE(R Rt issubclassR(Rtexc_typet exc_valuet traceback((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyt__exit__is (t__name__t __module__RRR(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyR bs  tXFailcB seZRS((RR(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyRnstXPasscB seZRS((RR(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyRqstSkippedcB seZRS((RR(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyRtsRcB seZRS((RR(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyRwsc s%‡fd†}tj|ˆƒ}|S(Nc spy ˆƒWnLtk rY}t|ƒ}|dkrJttˆƒƒ‚qZtdƒ‚nXttˆƒƒ‚dS(NtTimeout(t ExceptiontstrRRRR(tetmessage(tfunc(s5lib/python2.7/site-packages/sympy/utilities/pytest.pytwrapper{s   (t functoolstupdate_wrapper(R$R%((R$s5lib/python2.7/site-packages/sympy/utilities/pytest.pytXFAILzs cC st|ƒ‚dS(N(R(R!((s5lib/python2.7/site-packages/sympy/utilities/pytest.pyR‰sc s‡fd†}|S(s2Similar to :func:`skip`, but this is a decorator. c s%‡fd†}tj||ƒ}|S(Nc stˆƒ‚dS(N(R((treason(s5lib/python2.7/site-packages/sympy/utilities/pytest.pyt func_wrappers(R&R'(R$R*(R)(s5lib/python2.7/site-packages/sympy/utilities/pytest.pyR%Žs((R)R%((R)s5lib/python2.7/site-packages/sympy/utilities/pytest.pytSKIPŒsc s7tˆ_‡fd†}tj|ˆƒ}ˆ|_|S(Nc s ˆƒdS(N(((R$(s5lib/python2.7/site-packages/sympy/utilities/pytest.pyR*šs(tTruet_slowR&R't __wrapped__(R$R*((R$s5lib/python2.7/site-packages/sympy/utilities/pytest.pytslow—s   c+ sÀ|jddƒ}|r+td|ƒ‚ntjdtƒ,}tjdƒtjd|ˆƒdVWdQXt‡fd†|Dƒƒs¼d ˆg|D]}|j^q”f}t |ƒ‚ndS( sÓLike raises but tests that warnings are emitted. >>> from sympy.utilities.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: []. tmatchtsInvalid keyword arguments: %strecordtignoretalwaysNc3 s!|]}t|jˆƒVqdS(N(Rtcategory(t.0tw(t warningcls(s5lib/python2.7/site-packages/sympy/utilities/pytest.pys ¿ss^Failed: DID NOT WARN. No warnings of type %s was emitted. The list of emitted warnings is: %s.( tpopRtwarningstcatch_warningsR,t simplefiltertfilterwarningstanyR#R(R8tkwargsR0twarnrecR7tmsg((R8s5lib/python2.7/site-packages/sympy/utilities/pytest.pyR¡s  #c s‡fd†}|S(Nc s"tj|ƒ‡fd†ƒ}|S(Nc stˆƒdS(N(R(targsR?(R)(s5lib/python2.7/site-packages/sympy/utilities/pytest.pytinnerÍs(R&twraps(R$RC(R)(s5lib/python2.7/site-packages/sympy/utilities/pytest.pytskippingÌs((R)RE((R)s5lib/python2.7/site-packages/sympy/utilities/pytest.pyR+Ëscc sttƒ dVWdQXdS(snShorthand 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.utilities.pytest import warns_deprecated_sympy >>> from sympy.utilities.exceptions import SymPyDeprecationWarning >>> import warnings >>> 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(RR(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pytwarns_deprecated_sympyÕs cc s|tjdtƒ}tjd|ƒdVWdQXxE|D]=}t|j|ƒs7tj|j|j|j|j ƒq7q7WdS(stContext 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.utilities.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) R2R4N( R:R;R,R<RR5t warn_explicitR#tfilenametlineno(R8R@R7((s5lib/python2.7/site-packages/sympy/utilities/pytest.pytignore_warningsðs #  (,t__doc__t __future__RRtsysR&tost contextlibR:tsympy.core.compatibilityRRtsympy.utilities.exceptionsRtpyt_pytest.python_apiRt_pytest.recwarnRt_pytest.outcomesRRtgetattrtFalset USE_PYTESTt ImportErrortgetenvR t ON_TRAVIStobjectR R RRRR(R+R/tcontextmanagerttesttmarktxfailRFRJ(((s5lib/python2.7/site-packages/sympy/utilities/pytest.pytsD         H    '