From cdf045a680ba5f05f98fd62600c4fcb2e5c2ec07 Mon Sep 17 00:00:00 2001 From: EmilyBourne Date: Tue, 9 Apr 2024 20:37:09 +0200 Subject: [PATCH] Filter out cast warnings in cast tests (#1824) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Mac in particular is bad at handling warnings in pytest. #1762 introduced lots of warnings as it is testing casting between types. Such behaviour often raises warnings in NumPy. This PR deactivates those warnings for these specific tests thus speeding up the mac tests by ~x2 --------- Co-authored-by: Yaman Güçlü --- CHANGELOG.md | 1 + tests/epyccel/test_arrays.py | 418 ++++++++++++++++++++++++++++++++--- 2 files changed, 387 insertions(+), 32 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9216ed8f33..0a223615ad 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -30,6 +30,7 @@ All notable changes to this project will be documented in this file. ### Changed - #1720 : functions with the `@inline` decorator are no longer exposed to Python in the shared library. - #1720 : Error raised when incompatible arguments are passed to an `inlined` function is now fatal. +- \[TESTS\] Filter out cast warnings in cast tests. - \[INTERNALS\] `FunctionDef` is annotated when it is called, or at the end of the `CodeBlock` if it is never called. - \[INTERNALS\] `InlinedFunctionDef` is only annotated if it is called. - \[INTERNALS\] Build `utilities.metaclasses.ArgumentSingleton` on the fly to ensure correct docstrings. diff --git a/tests/epyccel/test_arrays.py b/tests/epyccel/test_arrays.py index 6578511a23..af63560927 100644 --- a/tests/epyccel/test_arrays.py +++ b/tests/epyccel/test_arrays.py @@ -21,6 +21,7 @@ def check_array_equal(a, b): assert a.dtype is b.dtype assert a.flags.c_contiguous == b.flags.c_contiguous assert a.flags.f_contiguous == b.flags.f_contiguous + #============================================================================== # TEST: VERIFY ARRAY'S DTYPE CORRESPONDENCE TO THE PASSED ELEMENTS #============================================================================== @@ -99,6 +100,7 @@ def test_array_int32_1d_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_add_stride(language): f1 = arrays.array_int32_1d_scalar_add @@ -113,6 +115,7 @@ def test_array_int32_1d_scalar_add_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_sub(language): f1 = arrays.array_int32_1d_scalar_sub @@ -127,6 +130,7 @@ def test_array_int32_1d_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_sub_stride(language): f1 = arrays.array_int32_1d_scalar_sub @@ -141,6 +145,7 @@ def test_array_int32_1d_scalar_sub_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_mul(language): f1 = arrays.array_int32_1d_scalar_mul @@ -155,6 +160,7 @@ def test_array_int32_1d_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_mul_stride(language): f1 = arrays.array_int32_1d_scalar_mul @@ -169,6 +175,7 @@ def test_array_int32_1d_scalar_mul_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_div(language): f1 = arrays.array_int32_1d_scalar_div @@ -183,6 +190,7 @@ def test_array_int32_1d_scalar_div(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_idiv(language): f1 = arrays.array_int32_1d_scalar_idiv @@ -197,6 +205,7 @@ def test_array_int32_1d_scalar_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_scalar_idiv_stride(language): f1 = arrays.array_int32_1d_scalar_idiv @@ -211,6 +220,7 @@ def test_array_int32_1d_scalar_idiv_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_add(language): f1 = arrays.array_int32_1d_add @@ -225,6 +235,7 @@ def test_array_int32_1d_add(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_sub(language): f1 = arrays.array_int32_1d_sub @@ -239,6 +250,7 @@ def test_array_int32_1d_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_mul(language): f1 = arrays.array_int32_1d_mul @@ -253,6 +265,7 @@ def test_array_int32_1d_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_idiv(language): f1 = arrays.array_int32_1d_idiv @@ -267,6 +280,7 @@ def test_array_int32_1d_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_add_augassign(language): f1 = arrays.array_int32_1d_add_augassign @@ -281,6 +295,7 @@ def test_array_int32_1d_add_augassign(language): assert np.array_equal( x1, x2 ) + def test_array_int32_1d_sub_augassign(language): f1 = arrays.array_int32_1d_sub_augassign @@ -295,6 +310,7 @@ def test_array_int32_1d_sub_augassign(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_initialization_1(language): f1 = arrays.array_int_1d_initialization_1 @@ -302,6 +318,7 @@ def test_array_int_1d_initialization_1(language): assert f1() == f2() + @pytest.mark.parametrize( 'language', ( pytest.param("fortran", marks = pytest.mark.fortran), pytest.param("c", marks = [ @@ -318,6 +335,7 @@ def test_array_int_1d_initialization_2(language): assert f1() == f2() + def test_array_int_1d_initialization_3(language): f1 = arrays.array_int_1d_initialization_3 @@ -343,6 +361,7 @@ def test_array_int32_2d_C_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_scalar_add_stride(language): f1 = arrays.array_int32_2d_C_scalar_add @@ -357,6 +376,7 @@ def test_array_int32_2d_C_scalar_add_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_scalar_sub(language): f1 = arrays.array_int32_2d_C_scalar_sub @@ -371,6 +391,7 @@ def test_array_int32_2d_C_scalar_sub(language): assert np.array_equal( x1, x2 ) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.xfail(reason="Ordering is unknown on non-contiguous array"), @@ -395,6 +416,7 @@ def test_array_int32_2d_C_scalar_sub_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_scalar_mul(language): f1 = arrays.array_int32_2d_C_scalar_mul @@ -409,6 +431,7 @@ def test_array_int32_2d_C_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_scalar_mul_stride(language): f1 = arrays.array_int32_2d_C_scalar_mul @@ -423,6 +446,7 @@ def test_array_int32_2d_C_scalar_mul_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_scalar_idiv(language): f1 = arrays.array_int32_2d_C_scalar_idiv @@ -437,6 +461,7 @@ def test_array_int32_2d_C_scalar_idiv(language): assert np.array_equal( x1, x2 ) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.xfail(reason="Ordering is unknown on non-contiguous array"), @@ -461,6 +486,7 @@ def test_array_int32_2d_C_scalar_idiv_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_add(language): f1 = arrays.array_int32_2d_C_add @@ -475,6 +501,7 @@ def test_array_int32_2d_C_add(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_sub(language): f1 = arrays.array_int32_2d_C_sub @@ -489,6 +516,7 @@ def test_array_int32_2d_C_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_mul(language): f1 = arrays.array_int32_2d_C_mul @@ -503,6 +531,7 @@ def test_array_int32_2d_C_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_idiv(language): f1 = arrays.array_int32_2d_C_idiv @@ -535,6 +564,7 @@ def test_array_int32_2d_F_scalar_add(language): assert np.array_equal( x1, x2 ) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.xfail(reason="Ordering is unknown on non-contiguous array"), @@ -559,6 +589,7 @@ def test_array_int32_2d_F_scalar_add_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_scalar_sub(language): f1 = arrays.array_int32_2d_F_scalar_sub @@ -573,6 +604,7 @@ def test_array_int32_2d_F_scalar_sub(language): assert np.array_equal( x1, x2 ) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.xfail(reason="Ordering is unknown on non-contiguous array"), @@ -597,6 +629,7 @@ def test_array_int32_2d_F_scalar_sub_stride(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_scalar_mul(language): f1 = arrays.array_int32_2d_F_scalar_mul @@ -611,6 +644,7 @@ def test_array_int32_2d_F_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_scalar_idiv(language): f1 = arrays.array_int32_2d_F_scalar_idiv @@ -625,6 +659,7 @@ def test_array_int32_2d_F_scalar_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_add(language): f1 = arrays.array_int32_2d_F_add @@ -639,6 +674,7 @@ def test_array_int32_2d_F_add(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_sub(language): f1 = arrays.array_int32_2d_F_sub @@ -653,6 +689,7 @@ def test_array_int32_2d_F_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_mul(language): f1 = arrays.array_int32_2d_F_mul @@ -667,6 +704,7 @@ def test_array_int32_2d_F_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_idiv(language): f1 = arrays.array_int32_2d_F_idiv @@ -700,6 +738,7 @@ def test_array_int_1d_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_scalar_sub(language): f1 = arrays.array_int_1d_scalar_sub @@ -714,6 +753,7 @@ def test_array_int_1d_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_scalar_mul(language): f1 = arrays.array_int_1d_scalar_mul @@ -728,6 +768,7 @@ def test_array_int_1d_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_scalar_idiv(language): f1 = arrays.array_int_1d_scalar_idiv @@ -742,6 +783,7 @@ def test_array_int_1d_scalar_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_add(language): f1 = arrays.array_int_1d_add @@ -756,6 +798,7 @@ def test_array_int_1d_add(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_sub(language): f1 = arrays.array_int_1d_sub @@ -770,6 +813,7 @@ def test_array_int_1d_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_mul(language): f1 = arrays.array_int_1d_mul @@ -784,6 +828,7 @@ def test_array_int_1d_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int_1d_idiv(language): f1 = arrays.array_int_1d_idiv @@ -816,6 +861,7 @@ def test_array_int_2d_C_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_scalar_sub(language): f1 = arrays.array_int_2d_C_scalar_sub @@ -830,6 +876,7 @@ def test_array_int_2d_C_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_scalar_mul(language): f1 = arrays.array_int_2d_C_scalar_mul @@ -844,6 +891,7 @@ def test_array_int_2d_C_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_scalar_idiv(language): f1 = arrays.array_int_2d_C_scalar_idiv @@ -858,6 +906,7 @@ def test_array_int_2d_C_scalar_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_add(language): f1 = arrays.array_int_2d_C_add @@ -872,6 +921,7 @@ def test_array_int_2d_C_add(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_sub(language): f1 = arrays.array_int_2d_C_sub @@ -886,6 +936,7 @@ def test_array_int_2d_C_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_mul(language): f1 = arrays.array_int_2d_C_mul @@ -900,6 +951,7 @@ def test_array_int_2d_C_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_idiv(language): f1 = arrays.array_int_2d_C_idiv @@ -914,6 +966,7 @@ def test_array_int_2d_C_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_C_initialization(language): f1 = arrays.array_int_2d_C_initialization @@ -945,6 +998,7 @@ def test_array_int_2d_F_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_scalar_sub(language): f1 = arrays.array_int_2d_F_scalar_sub @@ -959,6 +1013,7 @@ def test_array_int_2d_F_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_scalar_mul(language): f1 = arrays.array_int_2d_F_scalar_mul @@ -973,6 +1028,7 @@ def test_array_int_2d_F_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_scalar_idiv(language): f1 = arrays.array_int_2d_F_scalar_idiv @@ -987,6 +1043,7 @@ def test_array_int_2d_F_scalar_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_add(language): f1 = arrays.array_int_2d_F_add @@ -1001,6 +1058,7 @@ def test_array_int_2d_F_add(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_sub(language): f1 = arrays.array_int_2d_F_sub @@ -1015,6 +1073,7 @@ def test_array_int_2d_F_sub(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_mul(language): f1 = arrays.array_int_2d_F_mul @@ -1029,6 +1088,7 @@ def test_array_int_2d_F_mul(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_idiv(language): f1 = arrays.array_int_2d_F_idiv @@ -1043,6 +1103,7 @@ def test_array_int_2d_F_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_int_2d_F_initialization(language): f1 = arrays.array_int_2d_F_initialization @@ -1074,6 +1135,7 @@ def test_array_float_1d_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_scalar_sub(language): f1 = arrays.array_float_1d_scalar_sub @@ -1088,6 +1150,7 @@ def test_array_float_1d_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_scalar_mul(language): f1 = arrays.array_float_1d_scalar_mul @@ -1102,6 +1165,7 @@ def test_array_float_1d_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_scalar_div(language): f1 = arrays.array_float_1d_scalar_div @@ -1116,6 +1180,7 @@ def test_array_float_1d_scalar_div(language): assert np.allclose(x1, x2, rtol=RTOL, atol=ATOL) + def test_array_float_1d_scalar_mod(language): f1 = arrays.array_float_1d_scalar_mod f2 = epyccel( f1 , language = language) @@ -1129,6 +1194,7 @@ def test_array_float_1d_scalar_mod(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_scalar_idiv(language): f1 = arrays.array_float_1d_scalar_idiv @@ -1143,6 +1209,7 @@ def test_array_float_1d_scalar_idiv(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_add(language): f1 = arrays.array_float_1d_add @@ -1157,6 +1224,7 @@ def test_array_float_1d_add(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_sub(language): f1 = arrays.array_float_1d_sub @@ -1171,6 +1239,7 @@ def test_array_float_1d_sub(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_mul(language): f1 = arrays.array_float_1d_mul @@ -1185,6 +1254,7 @@ def test_array_float_1d_mul(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_div(language): f1 = arrays.array_float_1d_div @@ -1199,6 +1269,7 @@ def test_array_float_1d_div(language): assert np.array_equal( x1, x2 ) + def test_array_float_1d_mod(language): f1 = arrays.array_float_1d_mod @@ -1213,6 +1284,7 @@ def test_array_float_1d_mod(language): assert np.array_equal( x1, x2) + def test_array_float_1d_idiv(language): f1 = arrays.array_float_1d_idiv @@ -1245,6 +1317,7 @@ def test_array_float_2d_C_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_scalar_sub(language): f1 = arrays.array_float_2d_C_scalar_sub @@ -1259,6 +1332,7 @@ def test_array_float_2d_C_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_scalar_mul(language): f1 = arrays.array_float_2d_C_scalar_mul @@ -1273,6 +1347,7 @@ def test_array_float_2d_C_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_scalar_div(language): f1 = arrays.array_float_2d_C_scalar_div @@ -1287,6 +1362,7 @@ def test_array_float_2d_C_scalar_div(language): assert np.allclose(x1, x2, rtol=RTOL, atol=ATOL) + def test_array_float_2d_C_scalar_mod(language): f1 = arrays.array_float_2d_C_scalar_mod @@ -1301,6 +1377,7 @@ def test_array_float_2d_C_scalar_mod(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_add(language): f1 = arrays.array_float_2d_C_add @@ -1315,6 +1392,7 @@ def test_array_float_2d_C_add(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_sub(language): f1 = arrays.array_float_2d_C_sub @@ -1329,6 +1407,7 @@ def test_array_float_2d_C_sub(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_mul(language): f1 = arrays.array_float_2d_C_mul @@ -1343,6 +1422,7 @@ def test_array_float_2d_C_mul(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_div(language): f1 = arrays.array_float_2d_C_div @@ -1357,6 +1437,7 @@ def test_array_float_2d_C_div(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_mod(language): f1 = arrays.array_float_2d_C_mod @@ -1371,6 +1452,7 @@ def test_array_float_2d_C_mod(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_array_initialization(language): f1 = arrays.array_float_2d_C_array_initialization @@ -1384,6 +1466,7 @@ def test_array_float_2d_C_array_initialization(language): assert np.array_equal(x1, x2) + def test_array_float_3d_C_array_initialization_1(language): f1 = arrays.array_float_3d_C_array_initialization_1 @@ -1401,6 +1484,7 @@ def test_array_float_3d_C_array_initialization_1(language): assert np.array_equal(x1, x2) + def test_array_float_3d_C_array_initialization_2(language): f1 = arrays.array_float_3d_C_array_initialization_2 @@ -1414,6 +1498,7 @@ def test_array_float_3d_C_array_initialization_2(language): assert np.array_equal(x1, x2) + def test_array_float_4d_C_array_initialization(language): f1 = arrays.array_float_4d_C_array_initialization @@ -1430,6 +1515,7 @@ def test_array_float_4d_C_array_initialization(language): f2(x, y, x2) assert np.array_equal(x1, x2) + #============================================================================== # TEST: 2D ARRAYS OF REAL WITH F ORDERING #============================================================================== @@ -1448,6 +1534,7 @@ def test_array_float_2d_F_scalar_add(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_scalar_sub(language): f1 = arrays.array_float_2d_F_scalar_sub @@ -1462,6 +1549,7 @@ def test_array_float_2d_F_scalar_sub(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_scalar_mul(language): f1 = arrays.array_float_2d_F_scalar_mul @@ -1476,6 +1564,7 @@ def test_array_float_2d_F_scalar_mul(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_scalar_div(language): f1 = arrays.array_float_2d_F_scalar_div @@ -1490,6 +1579,7 @@ def test_array_float_2d_F_scalar_div(language): assert np.allclose(x1, x2, rtol=RTOL, atol=ATOL) + def test_array_float_2d_F_scalar_mod(language): f1 = arrays.array_float_2d_F_scalar_mod @@ -1504,6 +1594,7 @@ def test_array_float_2d_F_scalar_mod(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_add(language): f1 = arrays.array_float_2d_F_add @@ -1518,6 +1609,7 @@ def test_array_float_2d_F_add(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_sub(language): f1 = arrays.array_float_2d_F_sub @@ -1532,6 +1624,7 @@ def test_array_float_2d_F_sub(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_mul(language): f1 = arrays.array_float_2d_F_mul @@ -1546,6 +1639,7 @@ def test_array_float_2d_F_mul(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_div(language): f1 = arrays.array_float_2d_F_div @@ -1560,6 +1654,7 @@ def test_array_float_2d_F_div(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_mod(language): f1 = arrays.array_float_2d_F_mod @@ -1574,6 +1669,7 @@ def test_array_float_2d_F_mod(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_array_initialization(language): f1 = arrays.array_float_2d_F_array_initialization @@ -1587,6 +1683,7 @@ def test_array_float_2d_F_array_initialization(language): assert np.array_equal(x1, x2) + def test_array_float_3d_F_array_initialization_1(language): f1 = arrays.array_float_3d_F_array_initialization_1 @@ -1604,6 +1701,7 @@ def test_array_float_3d_F_array_initialization_1(language): assert np.array_equal(x1, x2) + def test_array_float_3d_F_array_initialization_2(language): f1 = arrays.array_float_3d_F_array_initialization_2 @@ -1617,6 +1715,7 @@ def test_array_float_3d_F_array_initialization_2(language): assert np.array_equal(x1, x2) + def test_array_float_4d_F_array_initialization(language): f1 = arrays.array_float_4d_F_array_initialization @@ -1634,6 +1733,7 @@ def test_array_float_4d_F_array_initialization(language): assert np.array_equal(x1, x2) + @pytest.mark.xfail(reason='Inhomogeneous arguments due to unknown shape') def test_array_float_4d_F_array_initialization_mixed_ordering(language): @@ -1656,11 +1756,11 @@ def test_array_float_4d_F_array_initialization_mixed_ordering(language): f2(x, x2) assert np.array_equal(x1, x2) + #============================================================================== # TEST: COMPLEX EXPRESSIONS IN 3D : TEST CONSTANT AND UNKNOWN SHAPES #============================================================================== - def test_array_int32_1d_complex_3d_expr(language): f1 = arrays.array_int32_1d_complex_3d_expr @@ -1675,6 +1775,7 @@ def test_array_int32_1d_complex_3d_expr(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_C_complex_3d_expr(language): f1 = arrays.array_int32_2d_C_complex_3d_expr @@ -1689,6 +1790,7 @@ def test_array_int32_2d_C_complex_3d_expr(language): assert np.array_equal( x1, x2 ) + def test_array_int32_2d_F_complex_3d_expr(language): f1 = arrays.array_int32_2d_F_complex_3d_expr @@ -1703,6 +1805,7 @@ def test_array_int32_2d_F_complex_3d_expr(language): assert np.array_equal( x1, x2 ) + def test_array_int32_in_bool_out_1d_complex_3d_expr(language): f1 = arrays.array_int32_in_bool_out_1d_complex_3d_expr @@ -1718,6 +1821,7 @@ def test_array_int32_in_bool_out_1d_complex_3d_expr(language): assert np.array_equal( r1, r2 ) + def test_array_int32_in_bool_out_2d_C_complex_3d_expr(language): f1 = arrays.array_int32_in_bool_out_2d_C_complex_3d_expr @@ -1733,6 +1837,7 @@ def test_array_int32_in_bool_out_2d_C_complex_3d_expr(language): assert np.array_equal( r1, r2 ) + def test_array_int32_in_bool_out_2d_F_complex_3d_expr(language): f1 = arrays.array_int32_in_bool_out_2d_F_complex_3d_expr @@ -1748,6 +1853,7 @@ def test_array_int32_in_bool_out_2d_F_complex_3d_expr(language): assert np.array_equal( r1, r2 ) + def test_array_float_1d_complex_3d_expr(language): f1 = arrays.array_float_1d_complex_3d_expr @@ -1762,6 +1868,7 @@ def test_array_float_1d_complex_3d_expr(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_C_complex_3d_expr(language): f1 = arrays.array_float_2d_C_complex_3d_expr @@ -1776,6 +1883,7 @@ def test_array_float_2d_C_complex_3d_expr(language): assert np.array_equal( x1, x2 ) + def test_array_float_2d_F_complex_3d_expr(language): f1 = arrays.array_float_2d_F_complex_3d_expr @@ -1802,6 +1910,7 @@ def test_array_float_sum_stack_array(language): x2 = f2() assert np.equal( x1, x2 ) + def test_array_float_div_stack_array(language): f1 = arrays.array_float_1d_div_stack_array @@ -1810,12 +1919,14 @@ def test_array_float_div_stack_array(language): x2 = f2() assert np.equal( x1, x2 ) + def test_multiple_stack_array_1(language): f1 = arrays.multiple_stack_array_1 f2 = epyccel(f1, language = language) assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_multiple_stack_array_2(language): f1 = arrays.multiple_stack_array_2 @@ -1834,6 +1945,7 @@ def test_array_float_sum_2d_stack_array(language): x2 = f2() assert np.equal( x1, x2 ) + def test_array_float_div_2d_stack_array(language): f1 = arrays.array_float_2d_div_stack_array @@ -1842,12 +1954,14 @@ def test_array_float_div_2d_stack_array(language): x2 = f2() assert np.equal( x1, x2 ) + def test_multiple_2d_stack_array_1(language): f1 = arrays.multiple_2d_stack_array_1 f2 = epyccel(f1, language = language) assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_multiple_2d_stack_array_2(language): f1 = arrays.multiple_2d_stack_array_2 @@ -1876,6 +1990,7 @@ def test_array_float_1d_1d_prod(language): f2(x2, y2) assert np.array_equal(y1, y2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -1898,6 +2013,7 @@ def test_array_float_2d_1d_matmul(language): f2(A2, x2, y2) assert np.array_equal(y1, y2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -1918,6 +2034,7 @@ def test_array_float_2d_1d_matmul_creation(language): y2 = f2(A2, x2) assert np.isclose(y1, y2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -1940,6 +2057,7 @@ def test_array_float_2d_1d_matmul_order_F_F(language): f2(A2, x2, y2) assert np.array_equal(y1, y2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -1962,6 +2080,7 @@ def test_array_float_2d_2d_matmul(language): f2(A2, B2, C2) assert np.array_equal(C1, C2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -1984,6 +2103,7 @@ def test_array_float_2d_2d_matmul_F_F_F_F(language): f2(A2, B2, C2) assert np.array_equal(C1, C2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -2009,6 +2129,7 @@ def test_array_float_2d_2d_matmul_mixorder(language): f2(A2, B2, C2) assert np.array_equal(C1, C2) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="matmul not implemented in c"), @@ -2031,6 +2152,7 @@ def test_array_float_2d_2d_matmul_operator(language): f2(A2, B2, C2) assert np.array_equal(C1, C2) + def test_array_float_loopdiff(language): f1 = arrays.array_float_loopdiff f2 = epyccel( f1 , language = language) @@ -2052,6 +2174,7 @@ def test_array_kwargs_full(language): f2 = epyccel( f1 , language = language) assert f1() == f2() + def test_array_kwargs_ones(language): f1 = arrays.array_kwargs_ones f2 = epyccel( f1 , language = language) @@ -2068,6 +2191,7 @@ def test_constant_negative_index(language): f2 = epyccel( f1 , language = language) assert f1(n) == f2(n) + def test_almost_negative_index(language): from numpy.random import randint n = randint(2, 10) @@ -2075,6 +2199,7 @@ def test_almost_negative_index(language): f2 = epyccel( f1 , language = language) assert f1(n) == f2(n) + def test_var_negative_index(language): from numpy.random import randint n = randint(2, 10) @@ -2083,6 +2208,7 @@ def test_var_negative_index(language): f2 = epyccel( f1 , language = language) assert f1(n,idx) == f2(n,idx) + def test_expr_negative_index(language): from numpy.random import randint n = randint(2, 10) @@ -2092,24 +2218,28 @@ def test_expr_negative_index(language): f2 = epyccel( f1 , language = language) assert f1(n,idx1,idx2) == f2(n,idx1,idx2) + def test_multiple_negative_index(language): f1 = arrays.test_multiple_negative_index f2 = epyccel(f1, language = language) assert f1(-2, -1) == f2(-2, -1) + def test_multiple_negative_index_2(language): f1 = arrays.test_multiple_negative_index_2 f2 = epyccel(f1, language = language) assert f1(-4, -2) == f2(-4, -2) + def test_multiple_negative_index_3(language): f1 = arrays.test_multiple_negative_index_3 f2 = epyccel(f1, language = language) assert f1(-1, -1, -3) == f2(-1, -1, -3) + def test_argument_negative_index_1(language): a = arrays.a_1d @@ -2117,6 +2247,7 @@ def test_argument_negative_index_1(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_argument_negative_index_2(language): a = arrays.a_1d @@ -2124,6 +2255,7 @@ def test_argument_negative_index_2(language): f2 = epyccel(f1, language = language) assert f1(a, a) == f2(a, a) + def test_c_order_argument_negative_index(language): a = np.random.randint(20, size=(3,4)) @@ -2131,6 +2263,7 @@ def test_c_order_argument_negative_index(language): f2 = epyccel(f1, language = language) assert f1(a, a) == f2(a, a) + def test_f_order_argument_negative_index(language): a = np.array(np.random.randint(20, size=(3,4)), order='F') @@ -2155,6 +2288,7 @@ def test_array_random_size(language): s1, s2 = f2() assert s1 == s2 + def test_array_variable_size(language): f1 = arrays.array_variable_size f2 = epyccel( f1 , language = language) @@ -2176,6 +2310,7 @@ def test_array_1d_slice_1(language): assert f1(a) == f2(a) + def test_array_1d_slice_2(language): a = arrays.a_1d @@ -2184,6 +2319,7 @@ def test_array_1d_slice_2(language): assert f1(a) == f2(a) + def test_array_1d_slice_3(language): a = arrays.a_1d @@ -2192,6 +2328,7 @@ def test_array_1d_slice_3(language): assert f1(a) == f2(a) + def test_array_1d_slice_4(language): a = arrays.a_1d @@ -2200,6 +2337,7 @@ def test_array_1d_slice_4(language): assert f1(a) == f2(a) + def test_array_1d_slice_5(language): a = arrays.a_1d @@ -2208,6 +2346,7 @@ def test_array_1d_slice_5(language): assert f1(a) == f2(a) + def test_array_1d_slice_6(language): a = arrays.a_1d @@ -2216,6 +2355,7 @@ def test_array_1d_slice_6(language): assert f1(a) == f2(a) + def test_array_1d_slice_7(language): a = arrays.a_1d @@ -2224,6 +2364,7 @@ def test_array_1d_slice_7(language): assert f1(a) == f2(a) + def test_array_1d_slice_8(language): a = arrays.a_1d @@ -2232,6 +2373,7 @@ def test_array_1d_slice_8(language): assert f1(a) == f2(a) + def test_array_1d_slice_9(language): a = arrays.a_1d @@ -2240,6 +2382,7 @@ def test_array_1d_slice_9(language): assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2255,6 +2398,7 @@ def test_array_1d_slice_10(language): assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2270,6 +2414,7 @@ def test_array_1d_slice_11(language): assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2296,6 +2441,7 @@ def test_array_2d_F_slice_1(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_2(language): a = arrays.a_2d_f @@ -2303,6 +2449,7 @@ def test_array_2d_F_slice_2(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_3(language): a = arrays.a_2d_f @@ -2310,6 +2457,7 @@ def test_array_2d_F_slice_3(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_4(language): a = arrays.a_2d_f @@ -2317,6 +2465,7 @@ def test_array_2d_F_slice_4(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_5(language): a = arrays.a_2d_f @@ -2324,6 +2473,7 @@ def test_array_2d_F_slice_5(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_6(language): a = arrays.a_2d_f @@ -2331,6 +2481,7 @@ def test_array_2d_F_slice_6(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_7(language): a = arrays.a_2d_f @@ -2338,6 +2489,7 @@ def test_array_2d_F_slice_7(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_8(language): a = arrays.a_2d_f @@ -2345,6 +2497,7 @@ def test_array_2d_F_slice_8(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_9(language): a = arrays.a_2d_f @@ -2352,6 +2505,7 @@ def test_array_2d_F_slice_9(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_10(language): a = arrays.a_2d_f @@ -2359,6 +2513,7 @@ def test_array_2d_F_slice_10(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_11(language): a = arrays.a_2d_f @@ -2366,6 +2521,7 @@ def test_array_2d_F_slice_11(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_12(language): a = arrays.a_2d_f @@ -2373,6 +2529,7 @@ def test_array_2d_F_slice_12(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_13(language): a = arrays.a_2d_f @@ -2380,6 +2537,7 @@ def test_array_2d_F_slice_13(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_14(language): a = arrays.a_2d_f @@ -2387,6 +2545,7 @@ def test_array_2d_F_slice_14(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_15(language): a = arrays.a_2d_f @@ -2394,6 +2553,7 @@ def test_array_2d_F_slice_15(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_16(language): a = arrays.a_2d_f @@ -2401,6 +2561,7 @@ def test_array_2d_F_slice_16(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_17(language): a = arrays.a_2d_f @@ -2408,6 +2569,7 @@ def test_array_2d_F_slice_17(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_18(language): a = arrays.a_2d_f @@ -2415,6 +2577,7 @@ def test_array_2d_F_slice_18(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_19(language): a = arrays.a_2d_f @@ -2422,6 +2585,7 @@ def test_array_2d_F_slice_19(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_20(language): a = arrays.a_2d_f @@ -2429,6 +2593,7 @@ def test_array_2d_F_slice_20(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2443,6 +2608,7 @@ def test_array_2d_F_slice_21(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2457,6 +2623,7 @@ def test_array_2d_F_slice_22(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2475,7 +2642,6 @@ def test_array_2d_F_slice_23(language): # TEST : 2d array slices order C #============================================================================== - def test_array_2d_C_slice_1(language): a = arrays.a_2d_c @@ -2483,6 +2649,7 @@ def test_array_2d_C_slice_1(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_2(language): a = arrays.a_2d_c @@ -2490,6 +2657,7 @@ def test_array_2d_C_slice_2(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_3(language): a = arrays.a_2d_c @@ -2497,6 +2665,7 @@ def test_array_2d_C_slice_3(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_4(language): a = arrays.a_2d_c @@ -2504,6 +2673,7 @@ def test_array_2d_C_slice_4(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_5(language): a = arrays.a_2d_c @@ -2511,6 +2681,7 @@ def test_array_2d_C_slice_5(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_6(language): a = arrays.a_2d_c @@ -2518,6 +2689,7 @@ def test_array_2d_C_slice_6(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_7(language): a = arrays.a_2d_c @@ -2525,6 +2697,7 @@ def test_array_2d_C_slice_7(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_8(language): a = arrays.a_2d_c @@ -2532,6 +2705,7 @@ def test_array_2d_C_slice_8(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_9(language): a = arrays.a_2d_c @@ -2539,6 +2713,7 @@ def test_array_2d_C_slice_9(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_10(language): a = arrays.a_2d_c @@ -2546,6 +2721,7 @@ def test_array_2d_C_slice_10(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_11(language): a = arrays.a_2d_c @@ -2553,6 +2729,7 @@ def test_array_2d_C_slice_11(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_12(language): a = arrays.a_2d_c @@ -2560,6 +2737,7 @@ def test_array_2d_C_slice_12(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_13(language): a = arrays.a_2d_c @@ -2567,6 +2745,7 @@ def test_array_2d_C_slice_13(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_14(language): a = arrays.a_2d_c @@ -2574,6 +2753,7 @@ def test_array_2d_C_slice_14(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_15(language): a = arrays.a_2d_c @@ -2581,6 +2761,7 @@ def test_array_2d_C_slice_15(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_16(language): a = arrays.a_2d_c @@ -2588,6 +2769,7 @@ def test_array_2d_C_slice_16(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_17(language): a = arrays.a_2d_c @@ -2595,6 +2777,7 @@ def test_array_2d_C_slice_17(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_18(language): a = arrays.a_2d_c @@ -2602,6 +2785,7 @@ def test_array_2d_C_slice_18(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_19(language): a = arrays.a_2d_c @@ -2609,6 +2793,7 @@ def test_array_2d_C_slice_19(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_20(language): a = arrays.a_2d_c @@ -2616,6 +2801,7 @@ def test_array_2d_C_slice_20(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2630,6 +2816,7 @@ def test_array_2d_C_slice_21(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2644,6 +2831,7 @@ def test_array_2d_C_slice_22(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Array slicing does not work with negative variables in c. See #1311"), @@ -2746,6 +2934,7 @@ def test_array_1d_slice_stride_8(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_9(language): a = arrays.a_1d @@ -2768,6 +2957,7 @@ def test_array_1d_slice_stride_10(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_11(language): a = arrays.a_1d @@ -2790,6 +2980,7 @@ def test_array_1d_slice_stride_12(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_13(language): a = arrays.a_1d @@ -2797,6 +2988,7 @@ def test_array_1d_slice_stride_13(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2826,6 +3018,7 @@ def test_array_1d_slice_stride_15(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_16(language): a = arrays.a_1d @@ -2833,6 +3026,7 @@ def test_array_1d_slice_stride_16(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2847,6 +3041,7 @@ def test_array_1d_slice_stride_17(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2861,6 +3056,7 @@ def test_array_1d_slice_stride_18(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_19(language): a = arrays.a_1d @@ -2868,6 +3064,7 @@ def test_array_1d_slice_stride_19(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2882,6 +3079,7 @@ def test_array_1d_slice_stride_20(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2896,6 +3094,7 @@ def test_array_1d_slice_stride_21(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_22(language): a = arrays.a_1d @@ -2903,6 +3102,7 @@ def test_array_1d_slice_stride_22(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_1d_slice_stride_23(language): a = arrays.a_1d @@ -2921,6 +3121,7 @@ def test_array_2d_F_slice_stride_1(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2935,6 +3136,7 @@ def test_array_2d_F_slice_stride_2(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -2949,6 +3151,7 @@ def test_array_2d_F_slice_stride_3(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_stride_4(language): a = arrays.a_2d_f @@ -2956,6 +3159,7 @@ def test_array_2d_F_slice_stride_4(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_stride_5(language): a = arrays.a_2d_f @@ -2963,6 +3167,7 @@ def test_array_2d_F_slice_stride_5(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_stride_6(language): a = arrays.a_2d_f @@ -2970,6 +3175,7 @@ def test_array_2d_F_slice_stride_6(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_stride_7(language): a = arrays.a_2d_f @@ -2985,6 +3191,7 @@ def test_array_2d_F_slice_stride_8(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_F_slice_stride_9(language): a = arrays.a_2d_f @@ -2992,6 +3199,7 @@ def test_array_2d_F_slice_stride_9(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3006,6 +3214,7 @@ def test_array_2d_F_slice_stride_10(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3020,6 +3229,7 @@ def test_array_2d_F_slice_stride_11(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3034,6 +3244,7 @@ def test_array_2d_F_slice_stride_12(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3048,6 +3259,7 @@ def test_array_2d_F_slice_stride_13(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3062,6 +3274,7 @@ def test_array_2d_F_slice_stride_14(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3076,6 +3289,7 @@ def test_array_2d_F_slice_stride_15(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3090,6 +3304,7 @@ def test_array_2d_F_slice_stride_16(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3104,6 +3319,7 @@ def test_array_2d_F_slice_stride_17(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3118,6 +3334,7 @@ def test_array_2d_F_slice_stride_18(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3132,6 +3349,7 @@ def test_array_2d_F_slice_stride_19(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3161,6 +3379,7 @@ def test_array_2d_F_slice_stride_21(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3175,6 +3394,7 @@ def test_array_2d_F_slice_stride_22(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3200,6 +3420,7 @@ def test_array_2d_C_slice_stride_1(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3214,6 +3435,7 @@ def test_array_2d_C_slice_stride_2(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3228,6 +3450,7 @@ def test_array_2d_C_slice_stride_3(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_stride_4(language): a = arrays.a_2d_c @@ -3235,6 +3458,7 @@ def test_array_2d_C_slice_stride_4(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3249,6 +3473,7 @@ def test_array_2d_C_slice_stride_5(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + def test_array_2d_C_slice_stride_6(language): a = arrays.a_2d_c @@ -3256,6 +3481,7 @@ def test_array_2d_C_slice_stride_6(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3278,6 +3504,7 @@ def test_array_2d_C_slice_stride_8(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3292,6 +3519,7 @@ def test_array_2d_C_slice_stride_9(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3306,6 +3534,7 @@ def test_array_2d_C_slice_stride_10(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3320,6 +3549,7 @@ def test_array_2d_C_slice_stride_11(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3334,6 +3564,7 @@ def test_array_2d_C_slice_stride_12(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3348,6 +3579,7 @@ def test_array_2d_C_slice_stride_13(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3362,6 +3594,7 @@ def test_array_2d_C_slice_stride_14(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3376,6 +3609,7 @@ def test_array_2d_C_slice_stride_15(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3390,6 +3624,7 @@ def test_array_2d_C_slice_stride_16(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3404,6 +3639,7 @@ def test_array_2d_C_slice_stride_17(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3418,6 +3654,7 @@ def test_array_2d_C_slice_stride_18(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3432,6 +3669,7 @@ def test_array_2d_C_slice_stride_19(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3446,6 +3684,7 @@ def test_array_2d_C_slice_stride_20(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3460,6 +3699,7 @@ def test_array_2d_C_slice_stride_21(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3474,6 +3714,7 @@ def test_array_2d_C_slice_stride_22(language): f2 = epyccel(f1, language = language) assert f1(a) == f2(a) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3500,6 +3741,7 @@ def test_copy_to_slice_issue_1218(language): epyc_arr = epyc_f(n) check_array_equal(pyth_arr, epyc_arr) + def test_copy_to_slice_1(language): pyth_f = arrays.copy_to_slice_1 epyc_f = epyccel(pyth_f, language = language) @@ -3511,6 +3753,7 @@ def test_copy_to_slice_1(language): epyc_f(epyc_a, b) check_array_equal(pyth_a, epyc_a) + def test_copy_to_slice_2(language): pyth_f = arrays.copy_to_slice_2 epyc_f = epyccel(pyth_f, language = language) @@ -3522,6 +3765,7 @@ def test_copy_to_slice_2(language): epyc_f(epyc_a, b) check_array_equal(pyth_a, epyc_a) + def test_copy_to_slice_3(language): pyth_f = arrays.copy_to_slice_3 epyc_f = epyccel(pyth_f, language = language) @@ -3533,6 +3777,7 @@ def test_copy_to_slice_3(language): epyc_f(epyc_a, b) check_array_equal(pyth_a, epyc_a) + def test_copy_to_slice_4(language): pyth_f = arrays.copy_to_slice_4 epyc_f = epyccel(pyth_f, language = language) @@ -3553,31 +3798,37 @@ def test_arrs_similar_shapes_0(language): f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arrs_similar_shapes_1(language): f1 = arrays.arrs_similar_shapes_1 f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arrs_different_shapes_0(language): f1 = arrays.arrs_different_shapes_0 f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arrs_uncertain_shape_1(language): f1 = arrays.arrs_uncertain_shape_1 f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arrs_2d_similar_shapes_0(language): f1 = arrays.arrs_2d_similar_shapes_0 f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arrs_2d_different_shapes_0(language): f1 = arrays.arrs_2d_different_shapes_0 f2 = epyccel(f1, language = language) assert f1() == f2() + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="Negative start of range does not work in c. See #1311"), @@ -3590,21 +3841,25 @@ def test_arrs_1d_negative_index_1(language): f2 = epyccel(f1, language = language) assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_arrs_1d_negative_index_2(language): f1 = arrays.arrs_1d_negative_index_2 f2 = epyccel(f1, language = language) assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_arrs_1d_int32_index(language): f1 = arrays.arrs_1d_int32_index f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arrs_1d_int64_index(language): f1 = arrays.arrs_1d_int64_index f2 = epyccel(f1, language = language) assert f1() == f2() + def test_arr_tuple_slice_index(language): f1 = arrays.arr_tuple_slice_index f2 = epyccel(f1, language = language) @@ -3614,6 +3869,7 @@ def test_arr_tuple_slice_index(language): check_array_equal(r_python, r_pyccel) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3626,11 +3882,13 @@ def test_arrs_1d_negative_index_negative_step(language): f2 = epyccel(f1, language = language) assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_arrs_1d_negative_step_positive_step(language): f1 = arrays.arrs_1d_negative_step_positive_step f2 = epyccel(f1, language = language) assert np.allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + @pytest.mark.parametrize( 'language', [ pytest.param("c", marks = [ pytest.mark.skip(reason="negative step does not work in c. See #1311"), @@ -3652,11 +3910,13 @@ def test_numpy_arange_one_arg(language): f2 = epyccel(f1, language = language) assert f1() == f2() + def test_numpy_arange_two_arg(language): f1 = arrays.arr_arange_2 f2 = epyccel(f1, language = language) assert f1() == f2() + def test_numpy_arange_full_arg(language): f1 = arrays.arr_arange_3 f2 = epyccel(f1, language = language) @@ -3667,11 +3927,13 @@ def test_numpy_arange_full_arg(language): assert (type(r_f1[1]) is type(r_f2[1])) np.testing.assert_allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_numpy_arange_with_dtype(language): f1 = arrays.arr_arange_4 f2 = epyccel(f1, language = language) assert f1() == f2() + def test_numpy_arange_negative_step(language): f1 = arrays.arr_arange_5 f2 = epyccel(f1, language = language) @@ -3682,6 +3944,7 @@ def test_numpy_arange_negative_step(language): assert (type(r_f1[1]) is type(r_f2[1])) np.testing.assert_allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_numpy_arange_negative_step_2(language): f1 = arrays.arr_arange_6 f2 = epyccel(f1, language = language) @@ -3692,6 +3955,7 @@ def test_numpy_arange_negative_step_2(language): assert (type(r_f1[1]) is type(r_f2[1])) np.testing.assert_allclose(f1(), f2(), rtol=RTOL, atol=ATOL) + def test_numpy_arange_into_slice(language): f1 = arrays.arr_arange_7 f2 = epyccel(f1, language = language) @@ -3725,6 +3989,7 @@ def test_array_float_nested_C_array_initialization(language): assert np.array_equal(x1, x2) + def test_array_float_nested_C_array_initialization_2(language): f1 = arrays.array_float_nested_C_array_initialization_2 f2 = epyccel(f1, language = language) @@ -3742,6 +4007,7 @@ def test_array_float_nested_C_array_initialization_2(language): assert np.array_equal(x1, x2) + def test_array_float_nested_C_array_initialization_3(language): f1 = arrays.array_float_nested_C_array_initialization_3 f2 = epyccel(f1, language = language) @@ -3768,6 +4034,7 @@ def test_arr_bool_sum(language): assert f1() == f2() assert isinstance(f1(), type(f2())) + def test_tuple_sum(language): f1 = arrays.tuple_sum f2 = epyccel(f1, language = language) @@ -3803,6 +4070,7 @@ def test_array_float_nested_F_array_initialization(language): assert np.array_equal(x1, x2) + def test_array_float_nested_F_array_initialization_2(language): f1 = arrays.array_float_nested_F_array_initialization_2 f2 = epyccel(f1, language = language) @@ -3820,6 +4088,7 @@ def test_array_float_nested_F_array_initialization_2(language): assert np.array_equal(x1, x2) + def test_array_float_nested_F_array_initialization_3(language): f1 = arrays.array_float_nested_F_array_initialization_3 f2 = epyccel(f1, language = language) @@ -3847,6 +4116,7 @@ def test_array_view_steps_C_1D_1(language): f2 = epyccel(f1, language = language) check_array_equal(f1(a), f2(a)) + def test_array_view_steps_C_1D_2(language): a = arrays.a_1d @@ -3865,6 +4135,7 @@ def test_array_view_steps_C_2D_1(language): f2 = epyccel(f1, language = language) check_array_equal(f1(a), f2(a)) + def test_array_view_steps_C_2D_2(language): a = arrays.a_2d_c @@ -3872,6 +4143,7 @@ def test_array_view_steps_C_2D_2(language): f2 = epyccel(f1, language = language) check_array_equal(f1(a), f2(a)) + def test_array_view_steps_C_2D_3(language): a = arrays.a_2d_c @@ -3890,6 +4162,7 @@ def test_array_view_steps_F_1D_1(language): f2 = epyccel(f1, language = language) check_array_equal(f1(a), f2(a)) + def test_array_view_steps_F_1D_2(language): a = arrays.a_1d_f @@ -3908,6 +4181,7 @@ def test_array_view_steps_F_2D_1(language): f2 = epyccel(f1, language = language) check_array_equal(f1(a), f2(a)) + def test_array_view_steps_F_2D_2(language): a = arrays.a_2d_f @@ -3915,6 +4189,7 @@ def test_array_view_steps_F_2D_2(language): f2 = epyccel(f1, language = language) check_array_equal(f1(a), f2(a)) + def test_array_view_steps_F_2D_3(language): a = arrays.a_2d_f @@ -3951,6 +4226,7 @@ def test_array_ndmin_1(language): check_array_equal(f1(d), f2(d)) check_array_equal(f1(e), f2(e)) + @pytest.mark.parametrize( 'language', ( pytest.param("fortran", marks = pytest.mark.fortran), pytest.param("c", marks = pytest.mark.c), @@ -3976,6 +4252,7 @@ def test_array_ndmin_2(language): check_array_equal(f1(d), f2(d)) check_array_equal(f1(e), f2(e)) + @pytest.mark.parametrize( 'language', ( pytest.param("fortran", marks = pytest.mark.fortran), pytest.param("c", marks = pytest.mark.c), @@ -4001,6 +4278,7 @@ def test_array_ndmin_4(language): check_array_equal(f1(d), f2(d)) check_array_equal(f1(e), f2(e)) + @pytest.mark.parametrize( 'language', ( pytest.param("fortran", marks = pytest.mark.fortran), pytest.param("c", marks = pytest.mark.c), @@ -4026,6 +4304,10 @@ def test_array_ndmin_2_order(language): check_array_equal(f1(d), f2(d)) check_array_equal(f1(e), f2(e)) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_dtype_conversion_to_bool_from_other_types(language): size = (2, 2) @@ -4060,12 +4342,10 @@ def test_dtype_conversion_to_bool_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_bool(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_bool(cmplx128) -@pytest.mark.parametrize( 'language', ( - pytest.param("fortran", marks = pytest.mark.fortran), - pytest.param("c", marks = pytest.mark.c), - pytest.param("python", marks = pytest.mark.python) - ) -) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_dtype_conversion_to_int8_from_other_types(language): size = (2, 2) @@ -4100,12 +4380,10 @@ def test_dtype_conversion_to_int8_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_int8(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_int8(cmplx128) -@pytest.mark.parametrize( 'language', ( - pytest.param("fortran", marks = pytest.mark.fortran), - pytest.param("c", marks = pytest.mark.c), - pytest.param("python", marks = pytest.mark.python) - ) -) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_dtype_conversion_to_int16_from_other_types(language): size = (2, 2) @@ -4140,12 +4418,10 @@ def test_dtype_conversion_to_int16_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_int16(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_int16(cmplx128) -@pytest.mark.parametrize( 'language', ( - pytest.param("fortran", marks = pytest.mark.fortran), - pytest.param("c", marks = pytest.mark.c), - pytest.param("python", marks = pytest.mark.python) - ) -) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_dtype_conversion_to_int32_from_other_types(language): size = (2, 2) @@ -4180,12 +4456,10 @@ def test_dtype_conversion_to_int32_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_int32(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_int32(cmplx128) -@pytest.mark.parametrize( 'language', ( - pytest.param("fortran", marks = pytest.mark.fortran), - pytest.param("c", marks = pytest.mark.c), - pytest.param("python", marks = pytest.mark.python) - ) -) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_dtype_conversion_to_int64_from_other_types(language): size = (2, 2) @@ -4220,6 +4494,9 @@ def test_dtype_conversion_to_int64_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_int64(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_int64(cmplx128) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") def test_dtype_conversion_to_float32_from_other_types(language): size = (2, 2) @@ -4254,6 +4531,8 @@ def test_dtype_conversion_to_float32_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_float32(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_float32(cmplx128) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") def test_dtype_conversion_to_float64_from_other_types(language): size = (2, 2) @@ -4288,6 +4567,8 @@ def test_dtype_conversion_to_float64_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_float64(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_float64(cmplx128) + +@pytest.mark.filterwarnings("ignore:overflow") def test_dtype_conversion_to_complex64_from_other_types(language): size = (2, 2) @@ -4321,6 +4602,7 @@ def test_dtype_conversion_to_complex64_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_cfloat(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_cfloat(cmplx128) + def test_dtype_conversion_to_complex128_from_other_types(language): size = (2, 2) @@ -4355,12 +4637,10 @@ def test_dtype_conversion_to_complex128_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_cdouble(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_cdouble(cmplx128) -@pytest.mark.parametrize( 'language', ( - pytest.param("fortran", marks = pytest.mark.fortran), - pytest.param("c", marks = pytest.mark.c), - pytest.param("python", marks = pytest.mark.python) - ) -) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_dtype_conversion_to_pyint_from_other_types(language): size = (2, 2) @@ -4395,6 +4675,9 @@ def test_dtype_conversion_to_pyint_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_pyint(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_pyint(cmplx128) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") def test_dtype_conversion_to_pyfloat_from_other_types(language): size = (2, 2) @@ -4429,6 +4712,10 @@ def test_dtype_conversion_to_pyfloat_from_other_types(language): assert epyccel_func(cmplx64) == arrays.dtype_convert_to_pyfloat(cmplx64) assert epyccel_func(cmplx128) == arrays.dtype_convert_to_pyfloat(cmplx128) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_bool(language): size = (1,2) @@ -4498,6 +4785,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_bool(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_bool(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_bool(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int8(language): size = (1,2) @@ -4567,6 +4858,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int8(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int8(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int8(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int16(language): size = (1,2) @@ -4636,6 +4931,9 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int16(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int16(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int16(cmplx128_1, cmplx128_2, cmplx128_3) +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int32(language): size = (1,2) @@ -4705,6 +5003,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int32(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int32(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int32(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int64(language): size = (1,2) @@ -4774,6 +5076,9 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int64(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int64(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int64(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") def test_src_dest_array_diff_sizes_dtype_conversion_to_float32(language): size = (1,2) @@ -4843,6 +5148,8 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_float32(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float32(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float32(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") def test_src_dest_array_diff_sizes_dtype_conversion_to_float64(language): size = (1,2) @@ -4912,6 +5219,8 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_float64(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float64(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float64(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:overflow") def test_src_dest_array_diff_sizes_dtype_conversion_to_cfloat(language): size = (1,2) @@ -4981,6 +5290,7 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_cfloat(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cfloat(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cfloat(cmplx128_1, cmplx128_2, cmplx128_3) + def test_src_dest_array_diff_sizes_dtype_conversion_to_cdouble(language): size = (1,2) @@ -5050,6 +5360,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_cdouble(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cdouble(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cdouble(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_pyint(language): size = (1,2) @@ -5119,6 +5433,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_pyint(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_pyint(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_pyint(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_pyfloat(language): size = (1,2) @@ -5188,6 +5506,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_pyfloat(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_pyfloat(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_pyfloat(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_bool_orderF(language): size = (1,2) @@ -5257,6 +5579,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_bool_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_bool_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_bool_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int8_orderF(language): size = (1,2) @@ -5326,6 +5652,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int8_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int8_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int8_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int16_orderF(language): size = (1,2) @@ -5395,6 +5725,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int16_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int16_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int16_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int32_orderF(language): size = (1,2) @@ -5464,6 +5798,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int32_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int32_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int32_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_int64_orderF(language): size = (1,2) @@ -5533,6 +5871,9 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_int64_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int64_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_int64_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") def test_src_dest_array_diff_sizes_dtype_conversion_to_float32_orderF(language): size = (1,2) @@ -5602,6 +5943,8 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_float32_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float32_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float32_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") def test_src_dest_array_diff_sizes_dtype_conversion_to_float64_orderF(language): size = (1,2) @@ -5671,6 +6014,8 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_float64_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float64_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_float64_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:overflow") def test_src_dest_array_diff_sizes_dtype_conversion_to_cfloat_orderF(language): size = (1,2) @@ -5740,6 +6085,7 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_cfloat_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cfloat_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cfloat_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + def test_src_dest_array_diff_sizes_dtype_conversion_to_cdouble_orderF(language): size = (1,2) @@ -5809,6 +6155,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_cdouble_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cdouble_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_cdouble_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_pyint_orderF(language): size = (1,2) @@ -5878,6 +6228,10 @@ def test_src_dest_array_diff_sizes_dtype_conversion_to_pyint_orderF(language): assert epyccel_func(cmplx64_1, cmplx64_2, cmplx64_3) == arrays.src_dest_diff_sizes_dtype_convert_to_pyint_orderF(cmplx64_1, cmplx64_2, cmplx64_3) assert epyccel_func(cmplx128_1, cmplx128_2, cmplx128_3) == arrays.src_dest_diff_sizes_dtype_convert_to_pyint_orderF(cmplx128_1, cmplx128_2, cmplx128_3) + +@pytest.mark.filterwarnings("ignore:Casting complex values to real discards the imaginary part") +@pytest.mark.filterwarnings("ignore:overflow") +@pytest.mark.filterwarnings("ignore:invalid value encountered in cast") def test_src_dest_array_diff_sizes_dtype_conversion_to_pyfloat_orderF(language): size = (1,2)