[PIR] fix some pir case in windows (#67533)

wanghuancoder · web-flow · commit 1aaef122436b · 2024-08-20T15:17:58.000+08:00
* fix some pir case in windows
diff --git a/test/deprecated/legacy_test/CMakeLists.txt b/test/deprecated/legacy_test/CMakeLists.txt
@@ -657,8 +657,9 @@ endif()
 set_tests_properties(test_inplace_addto_strategy_deprecated PROPERTIES TIMEOUT
                                                                        120)
 
-set(TEST_CINN_OPS test_slice_op_deprecated test_layer_norm_op_deprecated
-                  test_instance_norm_op_deprecated)
+set(TEST_CINN_OPS
+    test_slice_op_deprecated test_layer_norm_op_deprecated
+    test_instance_norm_op_deprecated test_group_norm_op_deprecated)
 
 foreach(TEST_CINN_OP ${TEST_CINN_OPS})
   if(WITH_CINN)
@@ -738,3 +739,4 @@ set_tests_properties(test_conv3d_layer_deprecated PROPERTIES TIMEOUT 100)
 set_tests_properties(test_attribute_var_deprecated PROPERTIES TIMEOUT 100)
 set_tests_properties(test_inference_api_deprecated PROPERTIES TIMEOUT 100)
 set_tests_properties(test_lbfgs_deprecated PROPERTIES TIMEOUT 100)
+set_tests_properties(test_group_norm_op_deprecated PROPERTIES TIMEOUT 1000)
diff --git a/test/deprecated/legacy_test/test_group_norm_op_deprecated.py b/test/deprecated/legacy_test/test_group_norm_op_deprecated.py
@@ -1468,6 +1468,7 @@ def get_eager_desire(self, place):
     def get_static_desire(self, place):
         core._set_prim_all_enabled(False)
         paddle.enable_static()
+
         if isinstance(place, base.CPUPlace):
             paddle.set_device("cpu")
         if isinstance(place, base.CUDAPlace):
diff --git a/test/legacy_test/CMakeLists.txt b/test/legacy_test/CMakeLists.txt
@@ -886,7 +886,6 @@ set_tests_properties(
   test_buffer_shared_memory_reuse_pass_and_fuse_optimization_op_pass
   PROPERTIES TIMEOUT 120)
 set_tests_properties(test_pool_max_op PROPERTIES TIMEOUT 500)
-set_tests_properties(test_group_norm_op PROPERTIES TIMEOUT 1000)
 set_tests_properties(test_imperative_transformer_sorted_gradient
                      PROPERTIES TIMEOUT 120)
 set_tests_properties(test_imperative_optimizer PROPERTIES TIMEOUT 250)
@@ -1029,7 +1028,6 @@ set(TEST_CINN_OPS
     test_batch_norm_op_prim_nchw
     test_batch_norm_op_prim_nhwc
     test_dropout_op
-    test_group_norm_op
     test_tile_op
     test_sum_op
     test_squeeze2_op
diff --git a/test/legacy_test/test_dot_op.py b/test/legacy_test/test_dot_op.py
@@ -84,31 +84,6 @@ def init_dtype(self):
         self.dtype = np.float64
 
 
-class DotOpEmptyInput(unittest.TestCase):
-    def test_1d_input(self):
-        data = np.array([], dtype=np.float32)
-        x = paddle.to_tensor(np.reshape(data, [0]), dtype='float32')
-        y = paddle.to_tensor(np.reshape(data, [0]), dtype='float32')
-        np_out = np.dot(data, data)
-        pd_out = paddle.dot(x, y)
-
-        self.assertEqual(np_out, pd_out)
-
-    def test_2d_input(self):
-        data = np.array([], dtype=np.float32)
-        x = paddle.to_tensor(np.reshape(data, [0, 0]), dtype='float32')
-        y = paddle.to_tensor(np.reshape(data, [0, 0]), dtype='float32')
-        pd_out = paddle.dot(x, y)
-        self.assertEqual(pd_out.shape, (0,))
-
-    def test_3d_input_error(self):
-        data = np.array([], dtype=np.float32)
-        x = paddle.to_tensor(np.reshape(data, [0, 0, 0]), dtype='float32')
-        y = paddle.to_tensor(np.reshape(data, [0, 0, 0]), dtype='float32')
-
-        self.assertRaises(Exception, paddle.dot, x, y)
-
-
 class DotOpBatch(DotOp):
     def init_input_output(self):
         self.x = (
diff --git a/test/legacy_test/test_dot_op_0d.py b/test/legacy_test/test_dot_op_0d.py
@@ -0,0 +1,53 @@
+#  Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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
+#
+#    https://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.
+
+import unittest
+
+import numpy as np
+
+import paddle
+
+
+class DotOpEmptyInput(unittest.TestCase):
+    def test_1d_input(self):
+        data = np.array([], dtype=np.float32)
+        x = paddle.to_tensor(np.reshape(data, [0]), dtype='float32')
+        y = paddle.to_tensor(np.reshape(data, [0]), dtype='float32')
+        np_out = np.dot(data, data)
+        pd_out = paddle.dot(x, y)
+
+        self.assertEqual(np_out, pd_out)
+
+    def test_2d_input(self):
+        data = np.array([], dtype=np.float32)
+        x = paddle.to_tensor(np.reshape(data, [0, 0]), dtype='float32')
+        y = paddle.to_tensor(np.reshape(data, [0, 0]), dtype='float32')
+        pd_out = paddle.dot(x, y)
+        self.assertEqual(
+            pd_out.shape,
+            [
+                0,
+            ],
+        )
+
+    def test_3d_input_error(self):
+        data = np.array([], dtype=np.float32)
+        x = paddle.to_tensor(np.reshape(data, [0, 0, 0]), dtype='float32')
+        y = paddle.to_tensor(np.reshape(data, [0, 0, 0]), dtype='float32')
+
+        self.assertRaises(Exception, paddle.dot, x, y)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/legacy_test/test_pad_op.py b/test/legacy_test/test_pad_op.py
@@ -321,28 +321,32 @@ def init_case(self):
         self.paddings = [(0, 1), (1, 0)]
         self.pad_value = 0.5
 
-    def test_order(self):
+    def test_order_dygraph(self):
         self.init_case()
+        place = paddle.CPUPlace()
+        if core.is_compiled_with_cuda():
+            place = paddle.CUDAPlace(0)
+
+        paddle.disable_static(place)
         x_np = np.random.random(self.shape).astype('float32')
         paddings_np = self.paddings.copy()
         x = paddle.to_tensor(x_np)
         paddings = list(np.array(self.paddings).flatten())
 
         # pad_from_left_axis
-        pad_from_left_axis = True
         out_np = np.pad(
             x_np, paddings_np, mode="constant", constant_values=self.pad_value
         )
         out = paddle.nn.functional.pad(
             x,
             paddings,
             mode='constant',
-            pad_from_left_axis=pad_from_left_axis,
+            value=self.pad_value,
+            pad_from_left_axis=True,
         )
         np.testing.assert_array_equal(out, out_np)
 
         # pad_from_right_axis:
-        pad_from_left_axis = False
         paddings_np.reverse()
         out_np = np.pad(
             x_np, paddings_np, mode="constant", constant_values=self.pad_value
@@ -351,10 +355,72 @@ def test_order(self):
             x,
             paddings,
             mode='constant',
-            pad_from_left_axis=pad_from_left_axis,
+            value=self.pad_value,
+            pad_from_left_axis=False,
         )
         np.testing.assert_array_equal(out, out_np)
 
+        paddle.enable_static()
+
+    @test_with_pir_api
+    def test_order_static(self):
+        self.init_case()
+        place = paddle.CPUPlace()
+        if core.is_compiled_with_cuda():
+            place = paddle.CUDAPlace(0)
+        x_np = np.random.random(self.shape).astype('float32')
+        paddings_np = self.paddings.copy()
+        paddings = list(np.array(self.paddings).flatten())
+
+        with static_guard():
+            main_prog = paddle.static.Program()
+            startup_prog = paddle.static.Program()
+            with paddle.static.program_guard(main_prog, startup_prog):
+                x = paddle.static.data(
+                    name="x", shape=self.shape, dtype="float32"
+                )
+                y_pad_from_left_axis = paddle.nn.functional.pad(
+                    x,
+                    paddings,
+                    mode='constant',
+                    value=self.pad_value,
+                    pad_from_left_axis=True,
+                )
+                y_pad_from_right_axis = paddle.nn.functional.pad(
+                    x,
+                    paddings,
+                    mode='constant',
+                    value=self.pad_value,
+                    pad_from_left_axis=False,
+                )
+            exe = paddle.static.Executor(place)
+            exe.run(startup_prog)
+            res = exe.run(
+                main_prog,
+                feed={"x": x_np},
+                fetch_list=[y_pad_from_left_axis, y_pad_from_right_axis],
+            )
+            pd_out_pad_from_left_axis, pd_out_pad_from_right_axis = res
+            out_np_pad_from_left_axis = np.pad(
+                x_np,
+                paddings_np,
+                mode="constant",
+                constant_values=self.pad_value,
+            )
+            paddings_np.reverse()
+            out_np_pad_from_right_axis = np.pad(
+                x_np,
+                paddings_np,
+                mode="constant",
+                constant_values=self.pad_value,
+            )
+            np.testing.assert_array_equal(
+                pd_out_pad_from_left_axis, out_np_pad_from_left_axis
+            )
+            np.testing.assert_array_equal(
+                pd_out_pad_from_right_axis, out_np_pad_from_right_axis
+            )
+
 
 # test padding order for cases when length of padding is not 2(N-2) or 2N
 class TestPadOrder(unittest.TestCase):
@@ -363,8 +429,13 @@ def init_case(self):
         self.paddings = [(0, 1)]
         self.pad_value = 0.5
 
-    def test_order(self):
+    def test_order_dygraph(self):
         self.init_case()
+        place = paddle.CPUPlace()
+        if core.is_compiled_with_cuda():
+            place = paddle.CUDAPlace(0)
+
+        paddle.disable_static(place)
         x_np = np.random.random(self.shape).astype('float32')
         paddings_np = self.paddings.copy()
         paddings_np += [(0, 0)] * (len(self.shape) - len(paddings_np))
@@ -377,9 +448,46 @@ def test_order(self):
         out_np = np.pad(
             x_np, paddings_np, mode="constant", constant_values=self.pad_value
         )
-        out = paddle.nn.functional.pad(x, paddings, mode='constant')
+        out = paddle.nn.functional.pad(
+            x, paddings, mode='constant', value=self.pad_value
+        )
         np.testing.assert_array_equal(out, out_np)
 
+    @test_with_pir_api
+    def test_order_static(self):
+        self.init_case()
+        place = paddle.CPUPlace()
+        if core.is_compiled_with_cuda():
+            place = paddle.CUDAPlace(0)
+
+        paddle.disable_static(place)
+        x_np = np.random.random(self.shape).astype('float32')
+        paddings_np = self.paddings.copy()
+        paddings_np += [(0, 0)] * (len(self.shape) - len(paddings_np))
+        paddings = list(np.array(self.paddings).flatten())
+
+        with static_guard():
+            main_prog = paddle.static.Program()
+            startup_prog = paddle.static.Program()
+            with paddle.static.program_guard(main_prog, startup_prog):
+                x = paddle.static.data(
+                    name="x", shape=self.shape, dtype="float32"
+                )
+                y = paddle.nn.functional.pad(
+                    x, paddings, mode='constant', value=self.pad_value
+                )
+            exe = paddle.static.Executor(place)
+            exe.run(startup_prog)
+            res = exe.run(main_prog, feed={"x": x_np}, fetch_list=[y])
+            paddings_np.reverse()
+            out_np = np.pad(
+                x_np,
+                paddings_np,
+                mode="constant",
+                constant_values=self.pad_value,
+            )
+            np.testing.assert_array_equal(res[0], out_np)
+
 
 class TestPadOrder2N3D(TestPadOrder2N):
     def init_case(self):
diff --git a/test/legacy_test/test_sum_op.py b/test/legacy_test/test_sum_op.py
@@ -839,27 +839,30 @@ def test_grad(self):
 
 class TestSumAPIWarnings(unittest.TestCase):
     def test_warnings(self):
-        with warnings.catch_warnings(record=True) as context:
-            warnings.simplefilter("always")
-            paddle.enable_static()
-            helper = LayerHelper("sum")
-            data = paddle.static.data(
-                name='data', shape=[32, 32], dtype='float32'
-            )
-            out = helper.create_variable_for_type_inference(dtype=data.dtype)
-            attrs = {'dim': [1], 'keep_dim': True, 'reduce_all': True}
-            os.environ["FLAGS_print_extra_attrs"] = '1'
-            helper.append_op(
-                type="reduce_sum",
-                inputs={'X': data},
-                outputs={'Out': out},
-                attrs=attrs,
-            )
-            self.assertTrue(
-                "op reduce_sum's attr reduce_all = True is not the default value: False"
-                in str(context[-1].message)
-            )
-            os.environ["FLAGS_print_extra_attrs"] = '0'
+        with paddle.pir_utils.OldIrGuard():
+            with warnings.catch_warnings(record=True) as context:
+                warnings.simplefilter("always")
+                paddle.enable_static()
+                helper = LayerHelper("sum")
+                data = paddle.static.data(
+                    name='data', shape=[32, 32], dtype='float32'
+                )
+                out = helper.create_variable_for_type_inference(
+                    dtype=data.dtype
+                )
+                attrs = {'dim': [1], 'keep_dim': True, 'reduce_all': True}
+                os.environ["FLAGS_print_extra_attrs"] = '1'
+                helper.append_op(
+                    type="reduce_sum",
+                    inputs={'X': data},
+                    outputs={'Out': out},
+                    attrs=attrs,
+                )
+                self.assertTrue(
+                    "op reduce_sum's attr reduce_all = True is not the default value: False"
+                    in str(context[-1].message)
+                )
+                os.environ["FLAGS_print_extra_attrs"] = '0'
 
 
 if __name__ == "__main__":
