Adjust the location of syntax testcases

.jenkins/check/config/filter_pylint.txt

@@ -123,7 +123,6 @@
 "mindspore/tests/ut/python/parallel/"                                                                   "protected-access"
 "mindspore/tests/ut/python/parameter_feature/test_var_grad.py"                                          "bad-super-call"
 "mindspore/tests/ut/python/parameter_feature/test_var_grad.py"                                          "redefined-outer-name"
-"mindspore/tests/ut/python/pipeline/parse/test_cont_break.py"                                           "unused-variable"
 "mindspore/tests/ut/python/pynative_mode"                                                               "no-else-return"
 "mindspore/tests/ut/python/pynative_mode"                                                               "superfluous-parens"
 "mindspore/tests/ut/python/pynative_mode"                                                               "unused-variable"
@@ -133,17 +132,20 @@
 "mindspore/tests/ut/python/rewrite/test_node.py"                                                        "syntax-error"
 "mindspore/tests/ut/python/rewrite/test_node.py"                                                        "protected-access"
 "mindspore/tests/ut/python/rewrite/test_for.py"                                                         "protected-access"
-"mindspore/tests/ut/python/python_builtin/test_list_tuple.py"                                           "len-as-condition"
 "mindspore/tests/ut/python/rewrite/test_symbol_tree.py"                                                 "len-as-condition"
 "mindspore/tests/ut/python/rewrite/test_lenet.py"                                                       "protected-access"
 "mindspore/tests/ut/python/rewrite/test_if.py"                                                          "protected-access"
 "mindspore/tests/ut/python/test_log.py"                                                                 "possibly-unused-variable"
 "mindspore/tests/ut/python/test_log.py"                                                                 "protected-access"
 "mindspore/tests/ut/python/train/summary/test_summary_collector.py"                                     "protected-access"
-"mindspore/tests/ut/python/pipeline/parse/test_super.py"                                                "bad-super-call"
-"mindspore/tests/ut/python/pipeline/parse/test_super.py"                                                "assignment-from-none"
-"mindspore/tests/ut/python/pipeline/parse/test_dictionary.py"                                           "consider-iterating-dictionary"
+"mindspore/tests/ut/python/pipeline/infer/test_hypermap.py"                                             "useless-super-delegation"
 "mindspore/tests/ut/python/pipeline/parse/test_use_undefined_name_or_unsupported_builtin_function.py"   "pointless-statement"
+"mindspore/tests/ut/python/graph_syntax"                                                                "useless-super-delegation"
+"mindspore/tests/ut/python/graph_syntax/dict/test_dictionary.py"                                        "consider-iterating-dictionary"
+"mindspore/tests/ut/python/graph_syntax/list/test_list_add_list.py"                                     "superfluous-parens"
+"mindspore/tests/ut/python/graph_syntax/control_flow/test_cont_break.py"                                "unused-variable"
+"mindspore/tests/ut/python/graph_syntax/python_builtin_functions/test_list_tuple.py"                    "len-as-condition"
+"mindspore/tests/ut/python/graph_syntax/python_builtin_functions/test_super.py"                         "bad-super-call"
 "mindspore/tests/st/networks/test_gpu_resnet.py"                                                        "superfluous-parens"
 "mindspore/tests/st/networks/test_gpu_resnet.py"                                                        "unused-variable"
 "mindspore/tests/st/networks/test_gpu_lstm.py"                                                          "unused-variable"

tests/st/graph_syntax/python_builtin_functions/test_abs.py

@@ -0,0 +1,41 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""test python built-in functions in graph mode"""
+import pytest
+import numpy as np
+from mindspore import Tensor, context, nn
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_abs_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test abs(Tensor) with a variable tensor in graph mode
+    Expectation: No exception
+    """
+
+    class Net(nn.Cell):
+        def construct(self, y):
+            x = Tensor([-1, 2])
+            return abs(x + y)
+
+    net = Net()
+    assert np.all(net(Tensor([-1, 2])).asnumpy() == np.array([2, 4]))

tests/st/graph_syntax/python_builtin_functions/test_all_any.py

@@ -0,0 +1,96 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""test python built-in functions in graph mode"""
+import pytest
+import numpy as np
+from mindspore import Tensor, context, nn, ms_function
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+@pytest.mark.skip(reason='Not support yet')
+def test_fallback_all_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test all(Tensor) with a variable tensor in graph mode
+    Expectation: No exception
+    """
+
+    class Net(nn.Cell):
+        def construct(self, x, y):
+            return all(x), all(y)
+
+    net = Net()
+    x = Tensor(np.array([0, 1, 2, 3]))
+    y = Tensor(np.array([1, 1]))
+    out1, out2 = net(x, y)
+    assert (not out1) and out2
+
+
+@pytest.mark.skip(reason='Not support yet')
+def test_fallback_all_list_hybrid():
+    """
+    Feature: JIT Fallback
+    Description: Test all(List) in graph mode
+    Expectation: No exception
+    """
+
+    @ms_function
+    def foo(a, b):
+        x = [a, np.array([1]), Tensor(1)]
+        y = [a, np.array([0]), Tensor(1)]
+        z = [b, np.array([1]), Tensor(1)]
+        return all(x), all(y), all(z)
+
+    x, y, z = foo(Tensor([1]), Tensor([0]))
+    assert x and (not y) and (not z)
+
+
+@pytest.mark.skip(reason='Not support yet')
+def test_fallback_any_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test any(Tensor) with a variable tensor in graph mode
+    Expectation: No exception
+    """
+
+    class Net(nn.Cell):
+        def construct(self, x, y):
+            return any(x), any(y)
+
+    net = Net()
+    x = Tensor(np.array([0, 0]))
+    y = Tensor(np.array([1, 0]))
+    out1, out2 = net(x, y)
+    assert (not out1) and out2
+
+
+@pytest.mark.skip(reason='Not support yet')
+def test_fallback_any_list_hybrid():
+    """
+    Feature: JIT Fallback
+    Description: Test any(List) in graph mode
+    Expectation: No exception
+    """
+
+    @ms_function
+    def foo(a, b):
+        x = [a, np.array([1]), Tensor(1)]
+        y = [a, np.array([0]), Tensor(1)]
+        z = [b, np.array([1]), Tensor(1)]
+        return any(x), any(y), any(z)
+
+    x, y, z = foo(Tensor([1]), Tensor([0]))
+    assert x and y and z

tests/st/graph_syntax/python_builtin_functions/test_bool.py

@@ -0,0 +1,38 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""test python built-in functions in graph mode"""
+import pytest
+from mindspore import Tensor, context, ms_function
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_bool_with_input_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test bool() in graph mode with tensor input.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = Tensor([10])
+        return bool(x)
+
+    assert foo()

tests/st/graph_syntax/python_builtin_functions/test_len.py

@@ -17,7 +17,6 @@ import pytest
 import numpy as np
 from mindspore import ms_function, context, Tensor
 
-
 context.set_context(mode=context.GRAPH_MODE)
 
 

tests/st/graph_syntax/python_builtin_functions/test_list_tuple.py

@@ -0,0 +1,168 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""test python built-in functions in graph mode"""
+import pytest
+import numpy as np
+from mindspore import Tensor, context, ms_function
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_list_with_input_constant_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test list() in graph mode with constant tensor.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = list(Tensor([1, 2, 3]))
+        x.append(Tensor([4]))
+        return x
+    out = foo()
+    assert isinstance(out, tuple)
+    assert len(out) == 4
+    assert isinstance(out[0], Tensor)
+    assert out[0].asnumpy() == 1
+    assert isinstance(out[1], Tensor)
+    assert out[1].asnumpy() == 2
+    assert isinstance(out[2], Tensor)
+    assert out[2].asnumpy() == 3
+    assert isinstance(out[3], Tensor)
+    assert out[3].asnumpy() == 4
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_list_with_input_constant_tensor_2():
+    """
+    Feature: JIT Fallback
+    Description: Test list() in graph mode with constant tensor.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = list(Tensor([[1, 2], [3, 4]]))
+        x.append(Tensor([5, 6]))
+        return x
+    out = foo()
+    assert isinstance(out, tuple)
+    assert len(out) == 3
+    assert isinstance(out[0], Tensor)
+    assert np.allclose(out[0].asnumpy(), np.array([1, 2]))
+    assert isinstance(out[1], Tensor)
+    assert np.allclose(out[1].asnumpy(), np.array([3, 4]))
+    assert isinstance(out[2], Tensor)
+    assert np.allclose(out[2].asnumpy(), np.array([5, 6]))
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_builtin_function_list_with_non_constant_tensor():
+    """
+    Feature: Graph list function.
+    Description: When the input to list() is non constant tensor, list function will return correct result.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo(x):
+        return list(x)
+
+    ret = foo(Tensor([[1, 2, 3], [4, 5, 6]]))
+    assert len(ret) == 2
+    assert np.all(ret[0].asnumpy() == np.array([1, 2, 3]))
+    assert np.all(ret[1].asnumpy() == np.array([4, 5, 6]))
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_tuple_with_input_constant_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test tuple() in graph mode with constant tensor.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = tuple(Tensor([1, 2, 3]))
+        return x
+    out = foo()
+    assert isinstance(out, tuple)
+    assert len(out) == 3
+    assert isinstance(out[0], Tensor)
+    assert out[0].asnumpy() == 1
+    assert isinstance(out[1], Tensor)
+    assert out[1].asnumpy() == 2
+    assert isinstance(out[2], Tensor)
+    assert out[2].asnumpy() == 3
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_tuple_with_input_constant_tensor_2():
+    """
+    Feature: JIT Fallback
+    Description: Test tuple() in graph mode with constant tensor.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = list(Tensor([[1, 2], [3, 4]]))
+        return x
+    out = foo()
+    assert isinstance(out, tuple)
+    assert len(out) == 2
+    assert isinstance(out[0], Tensor)
+    assert np.allclose(out[0].asnumpy(), np.array([1, 2]))
+    assert isinstance(out[1], Tensor)
+    assert np.allclose(out[1].asnumpy(), np.array([3, 4]))
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_builtin_function_tuple_with_non_constant_tensor():
+    """
+    Feature: Graph tuple function.
+    Description: When the input to tuple() is non constant tensor, list function will return correct result.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo(x):
+        return tuple(x)
+
+    ret = foo(Tensor([[1, 2, 3], [4, 5, 6]]))
+    assert len(ret) == 2
+    assert np.all(ret[0].asnumpy() == np.array([1, 2, 3]))
+    assert np.all(ret[1].asnumpy() == np.array([4, 5, 6]))

tests/st/graph_syntax/python_builtin_functions/test_round.py

@@ -0,0 +1,66 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""test python built-in functions in graph mode"""
+import pytest
+import numpy as np
+from mindspore import Tensor, context, nn
+from mindspore import dtype as mstype
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_round_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test round(Tensor) with a variable tensor in graph mode
+    Expectation: No exception
+    """
+
+    class Net(nn.Cell):
+        def construct(self, x):
+            return round(x)
+
+    net = Net()
+    x = Tensor(np.array([0.1, 4.51, 9.9]), mstype.float32)
+    out = net(x)
+    expect = Tensor(np.array([0.0, 5.0, 10.0]))
+    np.testing.assert_almost_equal(out.asnumpy(), expect.asnumpy())
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_round_tensor_constant():
+    """
+    Feature: JIT Fallback
+    Description: Test any(Tensor) with a constant tensor in graph mode
+    Expectation: No exception.
+    """
+    class Net(nn.Cell):
+        def construct(self):
+            x = Tensor(np.array([0.1, 4.51, 9.9]), mstype.float32)
+            return round(x)
+
+    net = Net()
+    out = net()
+    expect = Tensor(np.array([0.0, 5.0, 10.0]))
+    np.testing.assert_almost_equal(out.asnumpy(), expect.asnumpy())

tests/st/graph_syntax/python_builtin_functions/test_sum.py

@@ -0,0 +1,126 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""test python built-in functions in graph mode"""
+import pytest
+import numpy as np
+from mindspore import Tensor, context, nn
+from mindspore import dtype as mstype
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_sum_tensor_n_default_1():
+    """
+    Feature: JIT Fallback
+    Description: Description: Test sum(Tensor) in graph mode with tensor and input n is default.
+    Expectation: No exception
+    """
+    class Net(nn.Cell):
+        def construct(self, x):
+            return sum(x)
+
+    net = Net()
+    x = Tensor([3, 4, 5], dtype=mstype.float32)
+    out = net(x)
+    assert out == 12
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_sum_tensor_n_default_2():
+    """
+    Feature: JIT Fallback
+    Description: Description: Test sum(Tensor) in graph mode with tensor and input n is default.
+    Expectation: No exception
+    """
+    class Net(nn.Cell):
+        def construct(self, x):
+            return sum(x)
+
+    net = Net()
+    x = Tensor([[1, 2], [3, 4]], dtype=mstype.float32)
+    out = net(x)
+    assert np.allclose(out.asnumpy(), np.array([4, 6]))
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_sum_with_x_tensor_n_not_default_1():
+    """
+    Feature: JIT Fallback
+    Description: Test sum() in graph mode with input x tensor and input n not default.
+    Expectation: No exception.
+    """
+    class Net(nn.Cell):
+        def construct(self, x, y):
+            return sum(x, y)
+
+    net = Net()
+    x, y = Tensor([3, 4, 5], dtype=mstype.float32), 4
+    out = net(x, y)
+    assert out == 16
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_sum_with_x_tensor_n_not_default_2():
+    """
+    Feature: JIT Fallback
+    Description: Test sum() in graph mode with input x tensor and input n not default.
+    Expectation: No exception.
+    """
+    class Net(nn.Cell):
+        def construct(self, x, y):
+            return sum(x, y)
+
+    net = Net()
+    x, y = Tensor([[1, 2], [3, 4]], dtype=mstype.float32), [5, 6]
+    out = net(x, y)
+    assert np.allclose(out.asnumpy(), np.array([9, 12]))
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+def test_fallback_sum_with_x_list_of_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test sum() in graph mode when input x is list of tensor.
+    Expectation: No exception.
+    """
+    class Net(nn.Cell):
+        def construct(self, x, y):
+            return sum(x, y)
+
+    net = Net()
+    x, y = [1, Tensor([[1, 2], [3, 4]]), Tensor([[1, 2], [3, 4]])], Tensor([[1, 1], [1, 1]])
+    out = net(x, y)
+    assert np.allclose(out.asnumpy(), np.array([[4, 6], [8, 10]]))

tests/st/graph_syntax/test_hyper_param.py

@@ -13,11 +13,17 @@
 # limitations under the License.
 # ============================================================================
 
+import pytest
 import mindspore as ms
 from mindspore import Tensor, Parameter
 from mindspore.nn import Cell
 
 
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
 def test_hyper_param():
     """
     Feature: Resolve parameter.
@@ -47,6 +53,11 @@ def test_hyper_param():
     assert output == output_expect
 
 
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
 def test_hyper_param_with_control_sink():
     """
     Feature: Resolve parameter.

tests/st/graph_syntax/test_ms_class.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-""" test graph fallback """
+""" test ms_class """
 import pytest
 import numpy as np
 
@@ -28,7 +28,7 @@ context.set_context(mode=context.GRAPH_MODE)
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_attr():
+def test_ms_class_attr():
     """
     Feature: JIT Fallback
     Description: Access the attributes of user-defined classes decorated by ms_class.
@@ -58,7 +58,7 @@ def test_fallback_class_attr():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_method():
+def test_ms_class_method():
     """
     Feature: JIT Fallback
     Description: Access the methods of user-defined classes decorated by ms_class.
@@ -93,7 +93,7 @@ def test_fallback_class_method():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_call():
+def test_ms_class_call():
     """
     Feature: JIT Fallback
     Description: Call the __call__ function of user-defined classes decorated by ms_class.
@@ -129,7 +129,7 @@ def test_fallback_class_call():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_input_attr():
+def test_ms_class_input_attr():
     """
     Feature: JIT Fallback
     Description: Access the attributes of user-defined classes decorated by ms_class.
@@ -160,7 +160,7 @@ def test_fallback_class_input_attr():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_input_method():
+def test_ms_class_input_method():
     """
     Feature: JIT Fallback
     Description: Access the methods of user-defined classes decorated by ms_class.
@@ -193,7 +193,7 @@ def test_fallback_class_input_method():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_class_nested():
+def test_ms_class_nested():
     """
     Feature: JIT Fallback
     Description: Test nested ms_class in graph.
@@ -228,7 +228,7 @@ def test_fallback_class_class_nested():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_cell_nested():
+def test_ms_class_cell_nested():
     """
     Feature: JIT Fallback
     Description: Test nested ms_class and cell in graph.
@@ -278,7 +278,7 @@ def test_fallback_class_cell_nested():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_type_attr():
+def test_ms_class_type_attr():
     """
     Feature: JIT Fallback
     Description: Access the attributes of class type.
@@ -312,7 +312,7 @@ def test_fallback_class_type_attr():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_create_instance_attr():
+def test_ms_class_create_instance_attr():
     """
     Feature: JIT Fallback
     Description: Access the attributes of the created class instance.
@@ -342,7 +342,7 @@ def test_fallback_class_create_instance_attr():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_create_instance_method():
+def test_ms_class_create_instance_method():
     """
     Feature: JIT Fallback
     Description: Access the methods of the created class instance.
@@ -378,7 +378,7 @@ def test_fallback_class_create_instance_method():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_class_create_instance_call():
+def test_ms_class_create_instance_call():
     """
     Feature: JIT Fallback
     Description: Call the __call__ function of the created class instance.
@@ -415,7 +415,7 @@ def test_fallback_class_create_instance_call():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_raise_error_not_class_type():
+def test_raise_error_not_class_type():
     """
     Feature: JIT Fallback
     Description: Decorator ms_class cannot be used for non-class types.
@@ -434,7 +434,7 @@ def test_fallback_raise_error_not_class_type():
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.env_onecard
-def test_fallback_raise_error_decorate_cell():
+def test_raise_error_decorate_cell():
     """
     Feature: JIT Fallback
     Description: Decorator ms_class cannot be used for nn.Cell

tests/st/syntax/test_graph_fallback_python_builtin_tensor.py

@@ -1,435 +0,0 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""test python built-in functions in graph mode"""
-import pytest
-import numpy as np
-from mindspore import Tensor, context, nn, ms_function
-from mindspore import dtype as mstype
-
-context.set_context(mode=context.GRAPH_MODE)
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_abs_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test abs(Tensor) with a variable tensor in graph mode
-    Expectation: No exception
-    """
-
-    class Net(nn.Cell):
-        def construct(self, y):
-            x = Tensor([-1, 2])
-            return abs(x + y)
-
-    net = Net()
-    assert np.all(net(Tensor([-1, 2])).asnumpy() == np.array([2, 4]))
-
-
-@pytest.mark.skip(reason='Not support yet')
-def test_fallback_all_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test all(Tensor) with a variable tensor in graph mode
-    Expectation: No exception
-    """
-
-    class Net(nn.Cell):
-        def construct(self, x, y):
-            return all(x), all(y)
-
-    net = Net()
-    x = Tensor(np.array([0, 1, 2, 3]))
-    y = Tensor(np.array([1, 1]))
-    out1, out2 = net(x, y)
-    assert (not out1) and out2
-
-
-@pytest.mark.skip(reason='Not support yet')
-def test_fallback_all_list_hybrid():
-    """
-    Feature: JIT Fallback
-    Description: Test all(List) in graph mode
-    Expectation: No exception
-    """
-
-    @ms_function
-    def foo(a, b):
-        x = [a, np.array([1]), Tensor(1)]
-        y = [a, np.array([0]), Tensor(1)]
-        z = [b, np.array([1]), Tensor(1)]
-        return all(x), all(y), all(z)
-
-    x, y, z = foo(Tensor([1]), Tensor([0]))
-    assert x and (not y) and (not z)
-
-
-@pytest.mark.skip(reason='Not support yet')
-def test_fallback_any_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test any(Tensor) with a variable tensor in graph mode
-    Expectation: No exception
-    """
-
-    class Net(nn.Cell):
-        def construct(self, x, y):
-            return any(x), any(y)
-
-    net = Net()
-    x = Tensor(np.array([0, 0]))
-    y = Tensor(np.array([1, 0]))
-    out1, out2 = net(x, y)
-    assert (not out1) and out2
-
-
-@pytest.mark.skip(reason='Not support yet')
-def test_fallback_any_list_hybrid():
-    """
-    Feature: JIT Fallback
-    Description: Test any(List) in graph mode
-    Expectation: No exception
-    """
-
-    @ms_function
-    def foo(a, b):
-        x = [a, np.array([1]), Tensor(1)]
-        y = [a, np.array([0]), Tensor(1)]
-        z = [b, np.array([1]), Tensor(1)]
-        return any(x), any(y), any(z)
-
-    x, y, z = foo(Tensor([1]), Tensor([0]))
-    assert x and y and z
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_round_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test round(Tensor) with a variable tensor in graph mode
-    Expectation: No exception
-    """
-
-    class Net(nn.Cell):
-        def construct(self, x):
-            return round(x)
-
-    net = Net()
-    x = Tensor(np.array([0.1, 4.51, 9.9]), mstype.float32)
-    out = net(x)
-    expect = Tensor(np.array([0.0, 5.0, 10.0]))
-    np.testing.assert_almost_equal(out.asnumpy(), expect.asnumpy())
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_round_tensor_constant():
-    """
-    Feature: JIT Fallback
-    Description: Test any(Tensor) with a constant tensor in graph mode
-    Expectation: No exception.
-    """
-    class Net(nn.Cell):
-        def construct(self):
-            x = Tensor(np.array([0.1, 4.51, 9.9]), mstype.float32)
-            return round(x)
-
-    net = Net()
-    out = net()
-    expect = Tensor(np.array([0.0, 5.0, 10.0]))
-    np.testing.assert_almost_equal(out.asnumpy(), expect.asnumpy())
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_sum_tensor_n_default_1():
-    """
-    Feature: JIT Fallback
-    Description: Description: Test sum(Tensor) in graph mode with tensor and input n is default.
-    Expectation: No exception
-    """
-    class Net(nn.Cell):
-        def construct(self, x):
-            return sum(x)
-
-    net = Net()
-    x = Tensor([3, 4, 5], dtype=mstype.float32)
-    out = net(x)
-    assert out == 12
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_sum_tensor_n_default_2():
-    """
-    Feature: JIT Fallback
-    Description: Description: Test sum(Tensor) in graph mode with tensor and input n is default.
-    Expectation: No exception
-    """
-    class Net(nn.Cell):
-        def construct(self, x):
-            return sum(x)
-
-    net = Net()
-    x = Tensor([[1, 2], [3, 4]], dtype=mstype.float32)
-    out = net(x)
-    assert np.allclose(out.asnumpy(), np.array([4, 6]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_sum_with_x_tensor_n_not_default_1():
-    """
-    Feature: JIT Fallback
-    Description: Test sum() in graph mode with input x tensor and input n not default.
-    Expectation: No exception.
-    """
-    class Net(nn.Cell):
-        def construct(self, x, y):
-            return sum(x, y)
-
-    net = Net()
-    x, y = Tensor([3, 4, 5], dtype=mstype.float32), 4
-    out = net(x, y)
-    assert out == 16
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_sum_with_x_tensor_n_not_default_2():
-    """
-    Feature: JIT Fallback
-    Description: Test sum() in graph mode with input x tensor and input n not default.
-    Expectation: No exception.
-    """
-    class Net(nn.Cell):
-        def construct(self, x, y):
-            return sum(x, y)
-
-    net = Net()
-    x, y = Tensor([[1, 2], [3, 4]], dtype=mstype.float32), [5, 6]
-    out = net(x, y)
-    assert np.allclose(out.asnumpy(), np.array([9, 12]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_sum_with_x_list_of_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test sum() in graph mode when input x is list of tensor.
-    Expectation: No exception.
-    """
-    class Net(nn.Cell):
-        def construct(self, x, y):
-            return sum(x, y)
-
-    net = Net()
-    x, y = [1, Tensor([[1, 2], [3, 4]]), Tensor([[1, 2], [3, 4]])], Tensor([[1, 1], [1, 1]])
-    out = net(x, y)
-    assert np.allclose(out.asnumpy(), np.array([[4, 6], [8, 10]]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_list_with_input_constant_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test list() in graph mode with constant tensor.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = list(Tensor([1, 2, 3]))
-        x.append(Tensor([4]))
-        return x
-    out = foo()
-    assert isinstance(out, tuple)
-    assert len(out) == 4
-    assert isinstance(out[0], Tensor)
-    assert out[0].asnumpy() == 1
-    assert isinstance(out[1], Tensor)
-    assert out[1].asnumpy() == 2
-    assert isinstance(out[2], Tensor)
-    assert out[2].asnumpy() == 3
-    assert isinstance(out[3], Tensor)
-    assert out[3].asnumpy() == 4
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_list_with_input_constant_tensor_2():
-    """
-    Feature: JIT Fallback
-    Description: Test list() in graph mode with constant tensor.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = list(Tensor([[1, 2], [3, 4]]))
-        x.append(Tensor([5, 6]))
-        return x
-    out = foo()
-    assert isinstance(out, tuple)
-    assert len(out) == 3
-    assert isinstance(out[0], Tensor)
-    assert np.allclose(out[0].asnumpy(), np.array([1, 2]))
-    assert isinstance(out[1], Tensor)
-    assert np.allclose(out[1].asnumpy(), np.array([3, 4]))
-    assert isinstance(out[2], Tensor)
-    assert np.allclose(out[2].asnumpy(), np.array([5, 6]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_builtin_function_list_with_non_constant_tensor():
-    """
-    Feature: Graph list function.
-    Description: When the input to list() is non constant tensor, list function will return correct result.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo(x):
-        return list(x)
-
-    ret = foo(Tensor([[1, 2, 3], [4, 5, 6]]))
-    assert len(ret) == 2
-    assert np.all(ret[0].asnumpy() == np.array([1, 2, 3]))
-    assert np.all(ret[1].asnumpy() == np.array([4, 5, 6]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_tuple_with_input_constant_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test tuple() in graph mode with constant tensor.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = tuple(Tensor([1, 2, 3]))
-        return x
-    out = foo()
-    assert isinstance(out, tuple)
-    assert len(out) == 3
-    assert isinstance(out[0], Tensor)
-    assert out[0].asnumpy() == 1
-    assert isinstance(out[1], Tensor)
-    assert out[1].asnumpy() == 2
-    assert isinstance(out[2], Tensor)
-    assert out[2].asnumpy() == 3
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_tuple_with_input_constant_tensor_2():
-    """
-    Feature: JIT Fallback
-    Description: Test tuple() in graph mode with constant tensor.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = list(Tensor([[1, 2], [3, 4]]))
-        return x
-    out = foo()
-    assert isinstance(out, tuple)
-    assert len(out) == 2
-    assert isinstance(out[0], Tensor)
-    assert np.allclose(out[0].asnumpy(), np.array([1, 2]))
-    assert isinstance(out[1], Tensor)
-    assert np.allclose(out[1].asnumpy(), np.array([3, 4]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_builtin_function_tuple_with_non_constant_tensor():
-    """
-    Feature: Graph tuple function.
-    Description: When the input to tuple() is non constant tensor, list function will return correct result.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo(x):
-        return tuple(x)
-
-    ret = foo(Tensor([[1, 2, 3], [4, 5, 6]]))
-    assert len(ret) == 2
-    assert np.all(ret[0].asnumpy() == np.array([1, 2, 3]))
-    assert np.all(ret[1].asnumpy() == np.array([4, 5, 6]))
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.platform_arm_ascend_training
-@pytest.mark.platform_x86_ascend_training
-@pytest.mark.env_onecard
-def test_fallback_bool_with_input_tensor_2():
-    """
-    Feature: JIT Fallback
-    Description: Test bool() in graph mode with tensor input.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = Tensor([10])
-        return bool(x)
-
-    assert foo()

tests/ut/python/graph_syntax/__init__.py

@@ -0,0 +1,21 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""setup for pytest"""
+import mindspore.context as context
+
+
+# pylint: disable=unused-argument
+def setup_module(module):
+    context.set_context(mode=context.GRAPH_MODE)

tests/ut/python/graph_syntax/control_flow/test_cont_break.py

@@ -71,6 +71,7 @@ class for_loop_with_continue(Cell):
 def test_for_loop_with_continue():
     run_test(for_loop_with_continue, 10)
 
+
 # pylint: disable=unnecessary-pass
 class for_loop_with_cont_break(Cell):
     def __init__(self):
@@ -84,7 +85,6 @@ class for_loop_with_cont_break(Cell):
             if i > 5:
                 x *= 3
                 break
-                # x *= 2
             x = x * 2
             pass
         return x

tests/ut/python/graph_syntax/control_flow/test_if_function.py

@@ -21,6 +21,7 @@ from mindspore import context
 
 context.set_context(mode=context.GRAPH_MODE)
 
+
 def test_if_function():
     class Net(nn.Cell):
         def __init__(self, func):

tests/ut/python/graph_syntax/control_flow/test_while_param.py

@@ -44,6 +44,7 @@ def test_while_loop_phi():
     net = WhileSubGraphParam()
     net(x, y, z)
 
+
 class WhileSubGraphParam2(Cell):
     def __init__(self):
         super().__init__()
@@ -91,6 +92,7 @@ def test_while_loop_phi_3():
     net = WhileSubGraphParam3(x)
     net()
 
+
 class ControlMixedWhileIf(nn.Cell):
     def __init__(self):
         super().__init__()
@@ -130,6 +132,7 @@ class ControlMixedWhileIf(nn.Cell):
         out = out + x
         return out
 
+
 def test_mixed_while_if():
     context.set_context(mode=context.PYNATIVE_MODE)
     x = np.array(2).astype(np.int32)

tests/ut/python/graph_syntax/list/test_list_add_list.py

@@ -29,6 +29,7 @@ class Net(nn.Cell):
     def construct(self):
         return self.value1 + self.value2
 
+
 def test_list_add_list():
     context.set_context(mode=context.GRAPH_MODE)
     net = Net()

tests/ut/python/graph_syntax/list/test_list_mul_number.py

@@ -29,6 +29,7 @@ class Net(nn.Cell):
     def construct(self):
         return self.list_ * self.number1, self.list_ * self.number2
 
+
 def test_list_mul_number():
     """
     Description: test_list_mul_number

tests/ut/python/graph_syntax/list/test_number_mul_list.py

@@ -29,6 +29,7 @@ class Net(nn.Cell):
     def construct(self):
         return self.number1 * self.list_, self.number2 * self.list_
 
+
 def test_number_mul_list():
     """
     Description: test_number_mul_list

tests/ut/python/graph_syntax/numpy/test_parse_numpy.py

@@ -51,6 +51,7 @@ def test_use_numpy_method():
         net()
     assert "Should not use Python object in runtime" in str(err.value)
 
+
 def test_use_numpy_module():
     class Net(nn.Cell):
         def __init__(self):

tests/ut/python/graph_syntax/python_builtin_functions/test_enumerate.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 # ============================================================================
 """ test enumerate"""
+import operator
 import numpy as np
 import pytest
 
 import mindspore.nn as nn
-from mindspore import Tensor
-from mindspore import context
+from mindspore import ms_function, context, Tensor
 
 context.set_context(mode=context.GRAPH_MODE)
 
@@ -287,3 +287,19 @@ def test_enumerate_start_type_error():
     with pytest.raises(TypeError) as ex:
         net(x)
     assert "For 'enumerate', the 'start'" in str(ex.value)
+
+
+def test_fallback_enumerate_with_numpy():
+    """
+    Feature: JIT Fallback
+    Description: Test enumerate in graph mode with numpy input.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = np.array([1, 2])
+        y = enumerate(x)
+        return tuple(y)
+
+    out = foo()
+    assert operator.eq(out, ((0, 1), (1, 2)))

tests/ut/python/graph_syntax/python_builtin_functions/test_filter.py

@@ -0,0 +1,56 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+""" test graph fallback hybrid syntax"""
+import operator
+import numpy as np
+from mindspore import ms_function, context
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+def test_fallback_filter_with_numpy_and_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test filter in graph mode with numpy.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = np.array([1, 2, 3, 4])
+        ret = filter(lambda x: x > 2, x)
+        return tuple(ret)
+
+    out = foo()
+    assert operator.eq(out, (3, 4))
+
+
+def filter_fn(x):
+    return x > 2
+
+
+def test_fallback_filter_with_numpy_and_tensor_2():
+    """
+    Feature: JIT Fallback
+    Description: Test filter in graph mode with numpy.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = np.array([1, 2, 3, 4])
+        ret = filter(filter_fn, x)
+        return tuple(ret)
+
+    out = foo()
+    assert operator.eq(out, (3, 4))

tests/ut/python/graph_syntax/python_builtin_functions/test_graph_fallback_python_builtin.py

@@ -19,6 +19,7 @@ from mindspore import ms_function, context, Tensor
 
 context.set_context(mode=context.GRAPH_MODE)
 
+
 def test_fallback_bin():
     """
     Feature: JIT Fallback
@@ -31,6 +32,7 @@ def test_fallback_bin():
         return x
     assert foo() == '0b11'
 
+
 def test_fallback_chr():
     """
     Feature: JIT Fallback
@@ -98,6 +100,7 @@ def test_fallback_hex():
         return x
     assert foo() == '0xff'
 
+
 def test_fallback_oct():
     """
     Feature: JIT Fallback

tests/ut/python/graph_syntax/python_builtin_functions/test_map.py

@@ -20,71 +20,6 @@ from mindspore import ms_function, context, Tensor
 context.set_context(mode=context.GRAPH_MODE)
 
 
-def test_fallback_len_with_numpy():
-    """
-    Feature: JIT Fallback
-    Description: Test len in graph mode with numpy input.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = np.array([1, 2, 3, 4])
-        return len(x)
-
-    out = foo()
-    assert out == 4
-
-
-def test_fallback_enumerate_with_numpy():
-    """
-    Feature: JIT Fallback
-    Description: Test enumerate in graph mode with numpy input.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = np.array([1, 2])
-        y = enumerate(x)
-        return tuple(y)
-
-    out = foo()
-    assert operator.eq(out, ((0, 1), (1, 2)))
-
-
-def test_fallback_zip_with_numpy():
-    """
-    Feature: JIT Fallback
-    Description: Test zip in graph mode with numpy input.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = np.array([1, 2])
-        y = np.array([10, 20])
-        ret = zip(x, y)
-        return tuple(ret)
-
-    out = foo()
-    assert operator.eq(out, ((1, 10), (2, 20)))
-
-
-def test_fallback_zip_with_numpy_and_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test zip in graph mode with numpy and tensor input.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = np.array([1, 2])
-        y = Tensor([10, 20])
-        ret = zip(x, y)
-        return tuple(ret)
-
-    out = foo()
-    assert operator.eq(out, ((1, 10), (2, 20)))
-
-
 def test_fallback_map_with_numpy():
     """
     Feature: JIT Fallback
@@ -156,39 +91,3 @@ def test_fallback_map_with_numpy_and_tensor_2():
 
     out = foo()
     assert operator.eq(out, (2, 3, 4, 5))
-
-
-def test_fallback_filter_with_numpy_and_tensor():
-    """
-    Feature: JIT Fallback
-    Description: Test filter in graph mode with numpy.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = np.array([1, 2, 3, 4])
-        ret = filter(lambda x: x > 2, x)
-        return tuple(ret)
-
-    out = foo()
-    assert operator.eq(out, (3, 4))
-
-
-def filter_fn(x):
-    return x > 2
-
-
-def test_fallback_filter_with_numpy_and_tensor_2():
-    """
-    Feature: JIT Fallback
-    Description: Test filter in graph mode with numpy.
-    Expectation: No exception.
-    """
-    @ms_function
-    def foo():
-        x = np.array([1, 2, 3, 4])
-        ret = filter(filter_fn, x)
-        return tuple(ret)
-
-    out = foo()
-    assert operator.eq(out, (3, 4))

tests/ut/python/graph_syntax/python_builtin_functions/test_type.py

@@ -18,6 +18,7 @@ from mindspore import ms_function, context, Tensor
 
 context.set_context(mode=context.GRAPH_MODE)
 
+
 def test_fallback_type_with_input_int():
     """
     Feature: JIT Fallback

tests/ut/python/graph_syntax/python_builtin_functions/test_zip.py

@@ -0,0 +1,54 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+""" test graph fallback hybrid syntax"""
+import operator
+import numpy as np
+from mindspore import ms_function, context, Tensor
+
+context.set_context(mode=context.GRAPH_MODE)
+
+
+def test_fallback_zip_with_numpy():
+    """
+    Feature: JIT Fallback
+    Description: Test zip in graph mode with numpy input.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = np.array([1, 2])
+        y = np.array([10, 20])
+        ret = zip(x, y)
+        return tuple(ret)
+
+    out = foo()
+    assert operator.eq(out, ((1, 10), (2, 20)))
+
+
+def test_fallback_zip_with_numpy_and_tensor():
+    """
+    Feature: JIT Fallback
+    Description: Test zip in graph mode with numpy and tensor input.
+    Expectation: No exception.
+    """
+    @ms_function
+    def foo():
+        x = np.array([1, 2])
+        y = Tensor([10, 20])
+        ret = zip(x, y)
+        return tuple(ret)
+
+    out = foo()
+    assert operator.eq(out, ((1, 10), (2, 20)))

tests/ut/python/graph_syntax/statements/test_list_comp.py

@@ -17,26 +17,31 @@ import pytest
 
 from mindspore import context, ms_function
 
+
 @ms_function
 def get_list_comp_1():
     l = [x for x in range(1, 6)]
     return l
 
+
 @ms_function
 def get_list_comp_2():
     l = [x * x for x in range(1, 6)]
     return l
 
+
 @ms_function
 def get_list_comp_3():
     l = [x * x for x in range(1, 11) if x % 2 == 0]
     return l
 
+
 @ms_function
 def get_list_comp_4():
     l = [x * x for x in range(1, 11) if x > 5 if x % 2 == 0]
     return l
 
+
 @ms_function
 def get_list_comp_5():
     # Create a ListComp with multiple comprehension.
@@ -44,16 +49,19 @@ def get_list_comp_5():
     l = [y for x in ((1, 2), (3, 4), (5, 6)) for y in x]  # [1, 2, 3, 4, 5, 6]
     return l
 
+
 @ms_function
 def get_generator_exp_1():
     t = (x for x in range(1, 6))
     return t
 
+
 @ms_function
 def get_generator_exp_2():
     t = (x * x for x in range(1, 11) if x > 5 if x % 2 == 0)
     return t
 
+
 def test_list_comp():
     context.set_context(mode=context.GRAPH_MODE)
     assert get_list_comp_1() == (1, 2, 3, 4, 5)