`i UddlZddlZddlZddlZddlmZmZddlZddlZddl Z ddl Z ddl Z ddl m Z ddlmZddlmZddlZddlZddlmZer'ddlZdZejejjfZeedfed <n d ZejfZd Zd Zd ZdZ dZ!e"e#e$e%e&e'e(e e j)j*g Z+dZ,dZ- dDdZ.dZ/dZ0dZ1dZ2dZ3 dEdZ4dZ5dZ6dZ7 dFddd Z8 dGd"Z9 dHd$Z: dId%Z; dJd&Z< dKd'Z= dLd(Z>dMd)Z?ddde#fd*Z@d8d,ZAe jBe jCfZDe jEe jFfZGeGe jHfzZIeJd-d.DZKeJd/d0DZLeKeLzZMeMe jNfzZOeGeOzZPeIeOzZQd1ZR dNd2ZSdOd3ZTd8d4ZUd8d5ZVdOd6ZWd8d7ZXdPd9ZY dQd;ZZdPd<Z[dPd=Z\dRd>Z]dSd@Z^dSdAZ_dTdCZ`dS)UN)TupleType) AxisError)_array)_parameterized) is_availableT. _skip_classesFc|dSdtj|S)N)join tracebackTracebackExceptionfrom_exceptionformat)excs g/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/testing/_loops.py_format_exceptionr s; {t 779/>>sCCJJLL M MMctf}tr|tjjfz } ||i|}d}n&#|$r}|j}|j|d}|}Yd}~nd}~wwxYw||fSN) Exception_is_pytest_available_pytestoutcomesSkipped __traceback__tb_next)implargskw exceptionsresulterroretbs r _call_funcr&'sJ0g&.//  t"r""  _ : G  5=s 1AAAcNt|tsJ|t|tsJ|t|tsJ|}|rtjj||<|rtj||<t ||<t|||\}}||fSr) isinstancestrcopycupyxscipysparsecupyr&)rrr namesp_name scipy_namer"r#s r_call_func_cupyr2;s dC   ?j#66?? 6  J!z5_check_numpy_cupy_error_compatible..vsP))*c**jc.J.JJ))))))r)all _numpy_errorsr9r;s``r"_check_numpy_cupy_error_compatiblerErsC )))))'))) ) ))rc|t|t|}t||)NrD)rrAssertionErrorwith_traceback)r% msg_formatr9r;msgs r!_fail_test_with_unexpected_errorsrKzsR   $Z00%k22  4 4C    , ,R 0 00rct|trSt|tr>|j|jurtd|j|jkrtd|t jdddkrx|vtj |j d}t j |j }|dkrn,|drt|j d|d|d urt }n|sd }||td |t|j d d|dS|t|j d |ddSt#||st|j d||dSt||rt||st|j d||dSdS)Nz?Both numpy and cupy were skipped but with different exceptions.z;Both numpy and cupy were skipped but with different causes.CUPY_CIr ztest_helper.pytest_z.Error was raised from test code. {cupy_error}Tz9Both cupy and numpy are expected to raise errors, but notz&Only numpy raises error {numpy_error}z$Only cupy raises error {cupy_error}zKDifferent types of errors occurred cupy {cupy_error} numpy {numpy_error} zMBoth cupy and numpy raise exceptions cupy {cupy_error} numpy {numpy_error} )r(r __class__rGrosenvirongetr extract_tbrpathbasenamefilename startswithrKrrE)r9r; accept_errorframerXs r_check_cupy_numpy_errorr\s\ :}-- ; 66   {'< < <   ?k. . . MOO O z~~i$$**z/E$Z%=>>rB7##EN33 ' ' '    ) ) " -(BD " " " t  k1 GII I  )  % 6 +       )  $ 4       0 K H H%)  $    % % % % %\22 %[,77 %)  $    % % % % % % %rctjtj|jjSr)r4dtypecharlowertyper^s r_signed_counterpartrcs. ;u{5)).4466 7 7 <z(_make_positive_masks..s' < < <1a+;&;&;!&;&;&;rc>g|]}tj|dkS)r)r.asnumpy)r?rs rriz(_make_positive_masks..s% 1 1 1QDLOOq 1 1 1r)itemsrcr2r(tuplelist) rrr r/r0r1ksrgr"r#s r_make_positive_masksrqs = < < < .isdtypesa a % % 4 3   4 4  Z5<%@%@ 45rc32K|]}| |VdSrrP)r?rhrvs rrAz0_contains_signed_and_unsigned..s0 2 21wwqzz 2Q 2 2 2 2 2 2rc3 K|]}|vV dSrrPr?dvss rrAz0_contains_signed_and_unsigned..s'111qBw111111rc3 K|]}|vV dSrrPrys rrAz0_contains_signed_and_unsigned..s' < <AG < < < < < z5_wraps_partial..decorator..s)G)G)G$)G)G)Gr) functoolswrapsinspect signaturepartial __signature__)rnameswrappeds r decoratorz!_wraps_partial..decorators]'yw''--$.  g H H)G)G)G)G)G H HJJ rrP)rrrs`` r_wraps_partialrs* rc>|||g}d|D}t|g|RS)Ncg|]}||SrrP)r?ns rriz%_wraps_partial_xp..s / / /1Qrr)rr/r0r1rs r_wraps_partial_xprs7 7J 'E / / / / /E ' *E * * **rcttsJttsJttsJfd}|S)Nc Tt f d}|S)Nc t||\}}}}||J||J|s|rt||dSt|ttfs|f}t|ttfs|f}t |t |ksJfdt ||D}tj tj }rK|dkrE|D]B\}} |j | j kr-td |j | j Crt ||D]\}} t| tjr| jjrC|jjs7td |jj| jj| jjrC|jjs7td |jj| jj|D]\}} |j| jksJdgt |z} t'|rKd|D} t)| r0t+||} t-| D] \} } | sd| | < t || D]`\\}} }d}|F|jd kr|d k}n"||}| |} |s || adS) NrZc:g|]\}}t||SrP)_convert_output_to_ndarray)r?cupy_rnumpy_rcheck_sparse_formatr0s rrizI_make_decorator..decorator..test_func..(sK*G*G*G$FG+GW.ACC*G*G*Grz2.0.0z=ndarrays of different dtypes are returned. cupy: {} numpy: {}zIThe state of c_contiguous flag is false. (cupy_result:{} numpy_result:{})zIThe state of f_contiguous flag is false. (cupy_result:{} numpy_result:{})c*g|]}|jtvSrP)r^rf)r?rs rrizI_make_decorator..decorator..test_func..Ps0///L$44///rFrPr)r<r\r(rnrolenzipr4lib NumpyVersion __version__r^rGrndarrayflags c_contiguous f_contiguousshaperrrq enumeraterBrT)rr r8r9r:r;cupy_numpy_result_ndarrays numpy_versionrrmasks needs_maskiflagmaskskiprZ check_funcrcontiguous_checkrr/r1r0 type_checks r test_funcz5_make_decorator..decorator..test_func s *dBgzCC +Zk*j.D.DD+{/F/FF [ ' (35ACCCCkE4=99 +)l lUDM:: -+} {##s<'8'88888*G*G*G*G*G(+; 'E'E*G*G*G & "I2253DEEM 2mg55'A22OFG|w}44, VFL'- 0 02225  A'*; 'E'EAAOFG!'5=99A#M6A(. (AA"0!CCI6$*L$=$+M$>D@D@#A#AA $M6A(. (AA"0!CCI6$*L$=$+M$>D@D@#A#AA$> 5 5|w}44444FS---E,R00 ,//"-/// z??,0dBgzCCE#,Z#8#8,,4#,'+E!H,/.,7,7 0 0'!4#|r)) $ 00!'!1!1!3!3")$-0Jvw///# 0 0rr) rrrZrrrr/r1r0rs ` rrz"_make_decorator..decorator st 4w ; ;_ 0_ 0_ 0_ 0_ 0_ 0_ 0_ 0_ 0_ 0_ 0_ 0 < ;_ 0@r)r(r)) rr/rrrZr0r1rrs ```````` r_make_decoratorrs dC   ?j#66?? 6  J!._checks c4 %XXZZ % %77d??77c>>a9nn/ nn$ % % % %rrP)rtolatolrs r_check_tolerance_keysrs1 % % % F4LLL F4LLLLLrcNd}|j}|||}|||}||fS)Nct|tr\||j}|>|d}|'t d|j|S|S)NrzCan not find tolerance for {})r(rrTrarr)r^rtol1s r_resolvez$_resolve_tolerance.._resolvest c4 775:&&D|wwy))<#7>>uzJJLLLKJrrb)rr"rrrr^rtol1atol1s r_resolve_tolerancersF    LE HUD ! !E HUD ! !E %<rHz>r xp)_check_sparse_formatc  ts9ttsttrtdfd} t | || |||| S)a Decorator that checks NumPy results and CuPy ones are close. Args: rtol(float or dict): Relative tolerance. Besides a float value, a dictionary that maps a dtypes to a float value can be supplied to adjust tolerance per dtype. If the dictionary has ``'default'`` string as its key, its value is used as the default tolerance in case any dtype keys do not match. atol(float or dict): Absolute tolerance. Besides a float value, a dictionary can be supplied as ``rtol``. err_msg(str): The error message to be printed in case of failure. verbose(bool): If ``True``, the conflicting values are appended to the error message. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. type_check(bool): If ``True``, consistency of dtype is also checked. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True`` all error types are acceptable. If it is ``False`` no error is acceptable. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. contiguous_check(bool): If ``True``, consistency of contiguity is also checked. Decorated test fixture is required to return the arrays whose values are close between ``numpy`` case and ``cupy`` case. For example, this test case checks ``numpy.zeros`` and ``cupy.zeros`` should return same value. >>> import unittest >>> from cupy import testing >>> class TestFoo(unittest.TestCase): ... ... @testing.numpy_cupy_allclose() ... def test_foo(self, xp): ... # ... ... # Prepare data with xp ... # ... ... ... xp_result = xp.zeros(10) ... return xp_result .. seealso:: :func:`cupy.testing.assert_allclose` zJWhen `type_check` is `False`, `rtol` and `atol` must be supplied as float.cdt|\}}tj||||dSr)rrassert_allclose) crrrrerr_msgrrverboses rrz'numpy_cupy_allclose..check_funcs;)*atDD uq!UE7GDDDDDr)rr(rrr) rrrrr/rrZr0r1rrrs ```` ` rnumpy_cupy_allclosersn$%%% : dD ! ! :Zd%;%; :9:: :EEEEEEEEE :tZ9I'*/ 1 11rc @fd}t|||d|||S)aDecorator that checks NumPy results and CuPy ones are almost equal. Args: decimal(int): Desired precision. err_msg(str): The error message to be printed in case of failure. verbose(bool): If ``True``, the conflicting values are appended to the error message. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. type_check(bool): If ``True``, consistency of dtype is also checked. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True`` all error types are acceptable. If it is ``False`` no error is acceptable. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. Decorated test fixture is required to return the same arrays in the sense of :func:`cupy.testing.assert_array_almost_equal` (except the type of array module) even if ``xp`` is ``numpy`` or ``cupy``. .. seealso:: :func:`cupy.testing.assert_array_almost_equal` c8tj||dSr)rassert_array_almost_equal)xydecimalrrs rrz1numpy_cupy_array_almost_equal..check_func*s"(AwIIIIIrFr) rrrr/rrZr0r1rs ``` rnumpy_cupy_array_almost_equalr sQBJJJJJJJ :tZ'* > >>rc :fd}t|||d||dS)aDecorator that checks results of NumPy and CuPy are equal w.r.t. spacing. Args: nulp(int): The maximum number of unit in the last place for tolerance. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. type_check(bool): If ``True``, consistency of dtype is also checked. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True``, all error types are acceptable. If it is ``False``, no error is acceptable. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. Decorated test fixture is required to return the same arrays in the sense of :func:`cupy.testing.assert_array_almost_equal_nulp` (except the type of array module) even if ``xp`` is ``numpy`` or ``cupy``. .. seealso:: :func:`cupy.testing.assert_array_almost_equal_nulp` c4tj||dSr)rassert_array_almost_equal_nulp)rrnulps rrz6numpy_cupy_array_almost_equal_nulp..check_funcMs-aD99999rFN)r1r)rr/rrZr0r1rs` r"numpy_cupy_array_almost_equal_nulpr0sF:::::: :tZ'T C C CCrc <fd}t|||d|||S)a Decorator that checks results of NumPy and CuPy ones are equal w.r.t. ulp. Args: maxulp(int): The maximum number of units in the last place that elements of resulting two arrays can differ. dtype(numpy.dtype): Data-type to convert the resulting two array to if given. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. type_check(bool): If ``True``, consistency of dtype is also checked. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True`` all error types are acceptable. If it is ``False`` no error is acceptable. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. Decorated test fixture is required to return the same arrays in the sense of :func:`assert_array_max_ulp` (except the type of array module) even if ``xp`` is ``numpy`` or ``cupy``. .. seealso:: :func:`cupy.testing.assert_array_max_ulp` c6tj||dSr)rassert_array_max_ulp)rrr^maxulps rrz,numpy_cupy_array_max_ulp..check_functs #Aq&%88888rFr)rr^r/rrZr0r1rs`` rnumpy_cupy_array_max_ulprSsDB999999 :tZ'* > >>rc @fd}t|||d|||S)a*Decorator that checks NumPy results and CuPy ones are equal. Args: err_msg(str): The error message to be printed in case of failure. verbose(bool): If ``True``, the conflicting values are appended to the error message. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. type_check(bool): If ``True``, consistency of dtype is also checked. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True`` all error types are acceptable. If it is ``False`` no error is acceptable. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. strides_check(bool): If ``True``, consistency of strides is also checked. Decorated test fixture is required to return the same arrays in the sense of :func:`numpy_cupy_array_equal` (except the type of array module) even if ``xp`` is ``numpy`` or ``cupy``. .. seealso:: :func:`cupy.testing.assert_array_equal` c8tj||dSrrassert_array_equal)rrr strides_checkrs rrz*numpy_cupy_array_equal..check_funcs"!!Q-HHHHHrFr) rrr/rrZr0r1rrs `` ` rnumpy_cupy_array_equalrzsQBIIIIIII :tZ'* > >>rc ptjdtfd}t||ddd||S)aDecorator that checks the resulting lists of NumPy and CuPy's one are equal. Args: err_msg(str): The error message to be printed in case of failure. verbose(bool): If ``True``, the conflicting values are appended to the error message. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. Decorated test fixture is required to return the same list of arrays (except the type of array module) even if ``xp`` is ``numpy`` or ``cupy``. .. seealso:: :func:`cupy.testing.assert_array_list_equal` zNnumpy_cupy_array_list_equal is deprecated. Use numpy_cupy_array_equal instead.c6tj||dSrrrrrrs rrz/numpy_cupy_array_list_equal..check_funcs !!Q99999rF)warningswarnDeprecationWarningr)rrr/r0r1rs`` rnumpy_cupy_array_list_equalrsa, M / :::::: :tUE ': 7 77rc <fd}t|||d|||S)aDecorator that checks the CuPy result is less than NumPy result. Args: err_msg(str): The error message to be printed in case of failure. verbose(bool): If ``True``, the conflicting values are appended to the error message. name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. type_check(bool): If ``True``, consistency of dtype is also checked. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True`` all error types are acceptable. If it is ``False`` no error is acceptable. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. Decorated test fixture is required to return the smaller array when ``xp`` is ``cupy`` than the one when ``xp`` is ``numpy``. .. seealso:: :func:`cupy.testing.assert_array_less` c6tj||dSr)rassert_array_lessrs rrz)numpy_cupy_array_less..check_funcs  Aw88888rFr)rrr/rrZr0r1rs`` rnumpy_cupy_array_lessrsC<999999 :tZ'* > >>rcfd}|S)aDecorator that checks NumPy results are equal to CuPy ones. Args: name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. Decorated test fixture is required to return the same results even if ``xp`` is ``numpy`` or ``cupy``. cJtfd}|S)Nct|| \}}}}|s|rt||ddS||kr1dt|dt|}t|dS)NFrzResults are not equal: cupy: z numpy: )r<r\r)rG) rr r8r9r:r;messagerr/r1r0s rrz6numpy_cupy_equal..decorator..test_funcs *dBgzCC +Zk [ ' !&((((l***K    #l"3"3"35%W--- +*rr)rrr/r1r0s` rrz#numpy_cupy_equal..decoratorsM 4w ; ; . . . . . . . < ; .&rrP)r/r0r1rs``` rnumpy_cupy_equalr s0 , rcRtjdtfd}|S)a-Decorator that checks the NumPy and CuPy throw same errors. Args: name(str): Argument name whose value is either ``numpy`` or ``cupy`` module. sp_name(str or None): Argument name whose value is either ``scipy.sparse`` or ``cupyx.scipy.sparse`` module. If ``None``, no argument is given for the modules. scipy_name(str or None): Argument name whose value is either ``scipy`` or ``cupyx.scipy`` module. If ``None``, no argument is given for the modules. accept_error(bool, Exception or tuple of Exception): Specify acceptable errors. When both NumPy test and CuPy test raises the same type of errors, and the type of the errors is specified with this argument, the errors are ignored and not raised. If it is ``True`` all error types are acceptable. If it is ``False`` no error is acceptable. Decorated test fixture is required throw same errors even if ``xp`` is ``numpy`` or ``cupy``. z-cupy.testing.numpy_cupy_raises is deprecated.cLtfd}|S)Nc^t|| \}}}}t||dS)Nr)r<r\) rr r8r9r:r;rZrr/r1r0s rrz7numpy_cupy_raises..decorator..test_func+s[ *dBgzCC +Zk $J$/1= ? ? ? ? ? ?rr)rrrZr/r1r0s` rrz$numpy_cupy_raises..decorator*sR 4w ; ; ? ? ? ? ? ? ? ? < ; ?r)rrr)r/r0r1rZrs```` rnumpy_cupy_raisesr sR. M7         rr^cfd}|S)aDecorator for parameterized dtype test. Args: dtypes(list of dtypes): dtypes to be tested. name(str): Argument name to which specified dtypes are passed. This decorator adds a keyword argument specified by ``name`` to the test fixture. Then, it runs the fixtures in parallel by passing the each element of ``dtypes`` to the named argument. cDtfd}|S)Nc D]}} tj|j|<|i|(#t$r.}t d||Yd}~[d}~wt $rt d|wxYwdS)Nzskipped: {} = {} ({})is)r4r^rar printrr)rr r^r$dtypesrr/s rrz0for_dtypes..decorator..test_funcHs  ${5116BtHD$%"%%%%$JJJ188uaHHIIIIIIII $e,,,   s$, A?$A A?r)rrrr/s` rrzfor_dtypes..decoratorGsD d # #       $ # rrP)rr/rs`` r for_dtypesr;s*       rc#HK|]}tj|jVdSrr4r^rar?rs rrArA[s-<>Q,>>>>>>rBHILQcn|rt}nt}|r |tz }n |tz }|s |tz }|Sr)_regular_float_dtypesr _int_dtypes_int_bool_dtypes_complex_dtypes) no_float16no_bool no_complexrs r_make_all_dtypesr#csL&#+"" "/! MrcBtt||||S)aDecorator that checks the fixture with all dtypes. Args: name(str): Argument name to which specified dtypes are passed. no_float16(bool): If ``True``, ``numpy.float16`` is omitted from candidate dtypes. no_bool(bool): If ``True``, ``numpy.bool_`` is omitted from candidate dtypes. no_complex(bool): If ``True``, ``numpy.complex64`` and ``numpy.complex128`` are omitted from candidate dtypes. dtypes to be tested: ``numpy.complex64`` (optional), ``numpy.complex128`` (optional), ``numpy.float16`` (optional), ``numpy.float32``, ``numpy.float64``, ``numpy.dtype('b')``, ``numpy.dtype('h')``, ``numpy.dtype('i')``, ``numpy.dtype('l')``, ``numpy.dtype('q')``, ``numpy.dtype('B')``, ``numpy.dtype('H')``, ``numpy.dtype('I')``, ``numpy.dtype('L')``, ``numpy.dtype('Q')``, and ``numpy.bool_`` (optional). The usage is as follows. This test fixture checks if ``cPickle`` successfully reconstructs :class:`cupy.ndarray` for various dtypes. ``dtype`` is an argument inserted by the decorator. >>> import unittest >>> from cupy import testing >>> class TestNpz(unittest.TestCase): ... ... @testing.for_all_dtypes() ... def test_pickle(self, dtype): ... a = testing.shaped_arange((2, 3, 4), dtype=dtype) ... s = pickle.dumps(a) ... b = pickle.loads(s) ... testing.assert_array_equal(a, b) Typically, we use this decorator in combination with decorators that check consistency between NumPy and CuPy like :func:`cupy.testing.numpy_cupy_allclose`. The following is such an example. >>> import unittest >>> from cupy import testing >>> class TestMean(unittest.TestCase): ... ... @testing.for_all_dtypes() ... @testing.numpy_cupy_allclose() ... def test_mean_all(self, xp, dtype): ... a = testing.shaped_arange((2, 3), xp, dtype) ... return a.mean() .. seealso:: :func:`cupy.testing.for_dtypes` r/)rr#)r/r r!r"s rfor_all_dtypesr&ts.l &z7JGG ! ! !!rc^|rtt|Stt|S)aDecorator that checks the fixture with float dtypes. Args: name(str): Argument name to which specified dtypes are passed. no_float16(bool): If ``True``, ``numpy.float16`` is omitted from candidate dtypes. dtypes to be tested are ``numpy.float16`` (optional), ``numpy.float32``, and ``numpy.float64``. .. seealso:: :func:`cupy.testing.for_dtypes`, :func:`cupy.testing.for_all_dtypes` r%)rrr)r/r s rfor_float_dtypesr(s34/d;;;;-d3333rc.tt|S)aDecorator that checks the fixture with signed dtypes. Args: name(str): Argument name to which specified dtypes are passed. dtypes to be tested are ``numpy.dtype('b')``, ``numpy.dtype('h')``, ``numpy.dtype('i')``, ``numpy.dtype('l')``, and ``numpy.dtype('q')``. .. seealso:: :func:`cupy.testing.for_dtypes`, :func:`cupy.testing.for_all_dtypes` r%)rrr%s rfor_signed_dtypesr*s n4 0 0 00rc.tt|S)aDecorator that checks the fixture with unsigned dtypes. Args: name(str): Argument name to which specified dtypes are passed. dtypes to be tested are ``numpy.dtype('B')``, ``numpy.dtype('H')``, ``numpy.dtype('I')``, ``numpy.dtype('L')``, and ``numpy.dtype('Q')``. .. seealso:: :func:`cupy.testing.for_dtypes`, :func:`cupy.testing.for_all_dtypes` r%)rrfr%s rfor_unsigned_dtypesr,s &T 2 2 22rc^|rtt|Stt|S)aDecorator that checks the fixture with integer and optionally bool dtypes. Args: name(str): Argument name to which specified dtypes are passed. no_bool(bool): If ``True``, ``numpy.bool_`` is omitted from candidate dtypes. dtypes to be tested are ``numpy.dtype('b')``, ``numpy.dtype('h')``, ``numpy.dtype('i')``, ``numpy.dtype('l')``, ``numpy.dtype('q')``, ``numpy.dtype('B')``, ``numpy.dtype('H')``, ``numpy.dtype('I')``, ``numpy.dtype('L')``, ``numpy.dtype('Q')``, and ``numpy.bool_`` (optional). .. seealso:: :func:`cupy.testing.for_dtypes`, :func:`cupy.testing.for_all_dtypes` r%)rrr)r/r!s rfor_int_dtypesr.s3 7+D1111*6666rc.tt|S)a8Decorator that checks the fixture with complex dtypes. Args: name(str): Argument name to which specified dtypes are passed. dtypes to be tested are ``numpy.complex64`` and ``numpy.complex128``. .. seealso:: :func:`cupy.testing.for_dtypes`, :func:`cupy.testing.for_all_dtypes` r%)rrr%s rfor_complex_dtypesr0s oD 1 1 11rrbc:ttdkr\}t|S|1ttjdddk}|r!tjfdDng}ttD]8}dd}tj || |z9fdt|DdtDfd }|S) aDecorator that checks the fixture with a product set of dtypes. Args: types(list of dtypes): dtypes to be tested. names(list of str): Argument names to which dtypes are passed. full(bool): If ``True``, then all combinations of dtypes will be tested. Otherwise, the subset of combinations will be tested (see the description below). Decorator adds the keyword arguments specified by ``names`` to the test fixture. Then, it runs the fixtures in parallel with passing (possibly a subset of) the product set of dtypes. The range of dtypes is specified by ``types``. The combination of dtypes to be tested changes depending on the option ``full``. If ``full`` is ``True``, all combinations of ``types`` are tested. Sometimes, such an exhaustive test can be costly. So, if ``full`` is ``False``, only a subset of possible combinations is randomly sampled. If ``full`` is ``None``, the behavior is determined by an environment variable ``CUPY_TEST_FULL_COMBINATION``. If the value is set to ``'1'``, it behaves as if ``full=True``, and otherwise ``full=False``. rNCUPY_TEST_FULL_COMBINATION0rci|]}|SrPrP)r?r/typess rrz*for_dtypes_combination..)s-L-L-LddE-L-L-LrcJg|]}tt| SrP)rnr)r?typsrs rriz*for_dtypes_combination..2s+DDD4uS--..DDDrc,g|]}t|SrP)r)r? assoc_lists rriz*for_dtypes_combination..4s KKKJtJ''KKKrc<tgRfd}|S)Nc~D]}|}|| |i|5#t$r^}dd|D}t d||Yd}~d}~wt$rt |wxYwdS)Nz, c3HK|]\}}d||VdS)z{} = {}N)r)r?r/r^s rrAzOfor_dtypes_combination..decorator..test_func..@sJ$;$;'D%"((u55$;$;$;$;$;$;rzskipped: {} ({}))r*updater r rmrrr)rr rkw_copyr$rJ combinationrs rrz.decorator..test_func7s%  ''))v&&& D$*'****$===))$;$;+1<<>>$;$;$;;;C,33C;;<<<<<<<< &MMM  s9 B:ABB:r)rrr?rs` rrz)for_dtypes_combination..decorator6sE  %u % % %      & %  r)rorrintrRrSrTrproductrangerandomshuffleappendrr}) r5rfullr/ts_shuffled_typesrr?s `` @rfor_dtypes_combinationrJsG4 KKE 5zzQ%&&& |2:>>">DDEEJ L$,-L-L-L-Le-L-L-LMM s5zz"" . .A"111XN N> * * * IIen, - - - -DDDD38DDD KK#k:J:JKKK & rdtyescFt|||}t|||S)aDecorator that checks the fixture with a product set of all dtypes. Args: names(list of str): Argument names to which dtypes are passed. no_float16(bool): If ``True``, ``numpy.float16`` is omitted from candidate dtypes. no_bool(bool): If ``True``, ``numpy.bool_`` is omitted from candidate dtypes. full(bool): If ``True``, then all combinations of dtypes will be tested. Otherwise, the subset of combinations will be tested (see description in :func:`cupy.testing.for_dtypes_combination`). no_complex(bool): If, True, ``numpy.complex64`` and ``numpy.complex128`` are omitted from candidate dtypes. .. seealso:: :func:`cupy.testing.for_dtypes_combination` )r#rJ)rr r!rFr"r5s rfor_all_dtypes_combinationrNLs'( Z* = =E !% 5 55rc0tt||S)aDecorator for parameterized test w.r.t. the product set of signed dtypes. Args: names(list of str): Argument names to which dtypes are passed. full(bool): If ``True``, then all combinations of dtypes will be tested. Otherwise, the subset of combinations will be tested (see description in :func:`cupy.testing.for_dtypes_combination`). .. seealso:: :func:`cupy.testing.for_dtypes_combination` rrF)rJrrPs rfor_signed_dtypes_combinationrQds ".D I I IIrc0tt||S)aDecorator for parameterized test w.r.t. the product set of unsigned dtypes. Args: names(list of str): Argument names to which dtypes are passed. full(bool): If ``True``, then all combinations of dtypes will be tested. Otherwise, the subset of combinations will be tested (see description in :func:`cupy.testing.for_dtypes_combination`). .. seealso:: :func:`cupy.testing.for_dtypes_combination` rP)rJrfrPs rfor_unsigned_dtypes_combinationrSss ""2%d K K KKrcF|rt}nt}t|||S)a5Decorator for parameterized test w.r.t. the product set of int and boolean. Args: names(list of str): Argument names to which dtypes are passed. no_bool(bool): If ``True``, ``numpy.bool_`` is omitted from candidate dtypes. full(bool): If ``True``, then all combinations of dtypes will be tested. Otherwise, the subset of combinations will be tested (see description in :func:`cupy.testing.for_dtypes_combination`). .. seealso:: :func:`cupy.testing.for_dtypes_combination` )rrrJ)rr!rFr5s rfor_int_dtypes_combinationrUs*!  !% 5 55rordercfd}|S)aoDecorator to parameterize tests with order. Args: orders(list of order): orders to be tested. name(str): Argument name to which the specified order is passed. This decorator adds a keyword argument specified by ``name`` to the test fixtures. Then, the fixtures run by passing each element of ``orders`` to the named argument. cDtfd}|S)NcnD]0} ||<|i|#t$rtd|wxYwdS)Nr)rr)rr rVrr/orderss rrz0for_orders..decorator..test_funcsr  $BtHD$%"%%%% $e,,,   s 2r)rrr/rZs` rrzfor_orders..decoratorsD d # #       $ # rrP)rZr/rs`` r for_ordersr[s*       rc&tgd|S)zDecorator that checks the fixture with orders 'C' and 'F'. Args: name(str): Argument name to which the specified order is passed. .. seealso:: :func:`cupy.testing.for_all_dtypes` )NCFrf)r[r%s r for_CF_ordersr`s 000$ 7 77raxiscfd}|S)aDecorator for parametrizing tests with possible contiguous axes. Args: name(str): Argument name to which specified axis are passed. .. note:: 1. Adapted from tests/cupy_tests/fft_tests/test_fft.py. 2. Example: for ``shape = (1, 2, 3)``, the tested axes are ``[(2,), (1, 2), (0, 1, 2)]`` for the C order, and ``[(0,), (0, 1), (0, 1, 2)]`` for the F order. cBtfd}|S)Nc t|j}|j}t|D]}d}|dvr!t|dz |dz dD]}|f|z} n0|dvrtd|dzD]}||fz} nt d || <|g|Ri|l#t $rt d|d |d |jd | wxYwdS) NrP)rr]rrN)r_r^rzPlease specify the array order.rz , ndim isz , shape isz , order is)rrrVrB ValueErrorrr) selfrr ndimrVrajrr/s rrz9for_contiguous_axes..decorator..test_funcs:tz??DJE4[[  J&&"461Q333%%D1H%j(("1ac]]%%H%%%FGGG BtHD++++++++ $adL*lE;;;  s B(Cr)rrr/s` rrz&for_contiguous_axes..decorators? d # #      $ # (rrP)r/rs` rfor_contiguous_axesrjs$. r)F)NNT) rrr TrTFNNT)rr TrTFNN)rrTFNN)rNrTFNN)r TrTFNNF)r TrNN)r TrTFNN)rNN)r^FFF)r^F)rbN)rKFFNF)rbFN)rV)ra)arrrRrCtypingrrr unittestrr4r.cupy.exceptionsr cupy.testingrrr+cupyx.scipy.sparsecupy.testing._pytest_implr_pytest.outcomesrrSkipTestrrr __annotations__rr&r2r6r<AttributeErrorr IndexErrorrreNotImplementedErrorrlinalg LinAlgErrorrCrErKr\rcrqrrrrrrrrrrrrrrr r r complex64 complex128rfloat64float32rfloat16rrnrrfrbool_r_regular_dtypes_dtypesr#r&r(r*r,r.r0rJrNrQrSrUr[r`rjrPrrrs  %%%%%%'''''' 222222<>>'7+3'5M5s#5555!%&MNNN(    $ # # #Iz9j+ u|' ))) 1 1 1*/H%H%H%H%V=== 2 2 2 = = =+++<@(,jjjjZ)')')'X    &@DAFHLF115F1F1F1F1F1RBF8<>B-1$>$>$>$>NFJCG26 C C C CFJN9=(,$>$>$>$>N;?HL:?$>$>$>$>PGK7777B:>GK%)!>!>!>!>H&&&&R $#,))))X:?E$45 6%(88 <>g>>>>>// %+/'*:: * *"