【Error Message BUAA No. 5】 将报错信息修改为 PADDLE_ENFORCE_EQ 的形式 (#66623)

MufanColin · web-flow · commit 73e1e5c1a9fb · 2024-07-29T10:31:05.000+08:00
* 将 EXPECT_EQ 改成 PADDLE_ENFORCE_EQ

* 将 EXPECT_EQ 改成 PADDLE_ENFORCE_EQ

* 将 EXPECT_EQ 改成 PADDLE_ENFORCE_EQ

* Fix some style errors
diff --git a/test/cpp/eager/data_structure_tests/eager_tensor_test.cc b/test/cpp/eager/data_structure_tests/eager_tensor_test.cc
@@ -29,12 +29,19 @@ class AutogradMetaTest : public AbstractAutogradMeta {
   int val_ = 0;
 };
 }  // namespace eager_test
+
 TEST(Tensor, Constructor) {
   paddle::Tensor et1 = paddle::Tensor();
   paddle::Tensor et2 = paddle::Tensor("et2");
 
-  CHECK_EQ(et1.defined(), false);
-  CHECK_EQ(et2.name(), "et2");
+  PADDLE_ENFORCE_EQ(et1.defined(),
+                    false,
+                    phi::errors::InvalidArgument("Tensor et1 should be "
+                                                 "undefined."));
+  PADDLE_ENFORCE_EQ(et2.name(),
+                    "et2",
+                    phi::errors::InvalidArgument("Tensor name should be "
+                                                 "'et2'."));
 
   phi::DenseTensorMeta meta =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, common::make_ddim({1, 2}));
@@ -48,19 +55,37 @@ TEST(Tensor, Constructor) {
   paddle::Tensor et3 = paddle::Tensor(dt);
   auto* et3_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et3.impl())->data<float>();
-  CHECK_EQ(et3_ptr[0], 5.0f);
-  CHECK_EQ(et3_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(et3_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(et3_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   // copy constructor
   paddle::Tensor et4(et3);
   auto* et4_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et4.impl())->data<float>();
-  CHECK_EQ(et4_ptr[0], 5.0f);
-  CHECK_EQ(et4_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(et4_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(et4_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   paddle::Tensor et5(std::move(et4));
   auto* et5_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et5.impl())->data<float>();
-  CHECK_EQ(et5_ptr[0], 5.0f);
-  CHECK_EQ(et5_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(et5_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(et5_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
 }
 
 TEST(Tensor, MemberFunction) {
@@ -77,43 +102,94 @@ TEST(Tensor, MemberFunction) {
   VLOG(6) << "Make Dense Tensor";
   et3.set_name("et3");
   VLOG(6) << "Set Name";
-  CHECK_EQ(et3.name(), "et3");
-  CHECK_EQ(et3.defined(), false);
+  PADDLE_ENFORCE_EQ(et3.name(),
+                    "et3",
+                    phi::errors::InvalidArgument("Tensor name should be "
+                                                 "'et3'."));
+  PADDLE_ENFORCE_EQ(et3.defined(),
+                    false,
+                    phi::errors::InvalidArgument("Tensor et3 should be "
+                                                 "undefined."));
   et3.set_impl(dt);
   VLOG(6) << "Set impl";
-  CHECK_EQ(et3.initialized(), true);
-  CHECK_EQ(et3.is_cpu(), true);
-  CHECK_EQ(et3.is_gpu(), false);
-  CHECK_EQ(et3.numel(), 2);
+  PADDLE_ENFORCE_EQ(et3.initialized(),
+                    true,
+                    phi::errors::InvalidArgument("Tensor et3 should be "
+                                                 "initialized."));
+  PADDLE_ENFORCE_EQ(et3.is_cpu(),
+                    true,
+                    phi::errors::InvalidArgument("Tensor et3 should be "
+                                                 "on CPU."));
+  PADDLE_ENFORCE_EQ(et3.is_gpu(),
+                    false,
+                    phi::errors::InvalidArgument("Tensor et3 should not be "
+                                                 "on GPU."));
+  PADDLE_ENFORCE_EQ(et3.numel(),
+                    2,
+                    phi::errors::InvalidArgument("Tensor et3 should have "
+                                                 "2 elements."));
   auto expected_dim = common::make_ddim({1, 2});
-  CHECK_EQ(et3.dims(), expected_dim);
-  CHECK_EQ(et3.type(), phi::DataType::FLOAT32);
-  CHECK_EQ(et3.layout(), phi::DataLayout::NCHW);
+  PADDLE_ENFORCE_EQ(et3.dims(),
+                    expected_dim,
+                    phi::errors::InvalidArgument("Tensor dimensions should be "
+                                                 "{1, 2}."));
+  PADDLE_ENFORCE_EQ(et3.type(),
+                    phi::DataType::FLOAT32,
+                    phi::errors::InvalidArgument("Tensor data type should "
+                                                 "be FLOAT32."));
+  PADDLE_ENFORCE_EQ(et3.layout(),
+                    phi::DataLayout::NCHW,
+                    phi::errors::InvalidArgument("Tensor layout should be "
+                                                 "NCHW."));
   CHECK(phi::is_cpu_place(et3.place()));
   VLOG(6) << "Get impl";
   auto* dt3_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et3.impl())->data<float>();
-  CHECK_EQ(dt3_ptr[0], 5.0f);
-  CHECK_EQ(dt3_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(dt3_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(dt3_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   paddle::Tensor et4 = et3;
   VLOG(6) << "copy =";
-  CHECK(et4.initialized() == true);
+  PADDLE_ENFORCE_EQ(et4.initialized(),
+                    true,
+                    phi::errors::InvalidArgument("Tensor et4 should be "
+                                                 "initialized."));
   auto* dt4_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et4.impl())->data<float>();
-  CHECK_EQ(dt4_ptr[0], 5.0f);
-  CHECK_EQ(dt4_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(dt4_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(dt4_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   VLOG(6) << "move =";
   paddle::Tensor et5 = std::move(et4);
   auto* dt5_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et5.impl())->data<float>();
-  CHECK_EQ(dt5_ptr[0], 5.0f);
-  CHECK_EQ(dt5_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(dt5_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(dt5_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   VLOG(6) << "AutogradMeta";
   auto autograd_meta_test = std::make_shared<eager_test::AutogradMetaTest>(2);
   et3.set_autograd_meta(autograd_meta_test);
   auto* tmp_autograd_meta_test =
       static_cast<eager_test::AutogradMetaTest*>(et3.get_autograd_meta());
-  CHECK_EQ(tmp_autograd_meta_test->val_, 2);
+  PADDLE_ENFORCE_EQ(tmp_autograd_meta_test->val_,
+                    2,
+                    phi::errors::InvalidArgument("AutogradMetaTest value "
+                                                 "should be 2."));
 }
 
 TEST(EagerVariable, Constructor) {
@@ -130,25 +206,53 @@ TEST(EagerVariable, Constructor) {
   VLOG(6) << "Make Dense Tensor";
   t3.set_name("t3");
   VLOG(6) << "Set Name";
-  CHECK_EQ(t3.name(), "t3");
-  CHECK_EQ(t3.defined(), false);
+  PADDLE_ENFORCE_EQ(t3.name(),
+                    "t3",
+                    phi::errors::InvalidArgument("Tensor name should be "
+                                                 "'t3'."));
+  PADDLE_ENFORCE_EQ(
+      t3.defined(),
+      false,
+      phi::errors::InvalidArgument("Tensor t3 should be undefined but got %d.",
+                                   t3.defined()));
   t3.set_impl(dt);
 
   egr::EagerVariable et3 = egr::EagerVariable(t3);
   VLOG(6) << "SyncToVar";
-  CHECK_EQ(et3.Var().Get<phi::DenseTensor>().data<float>()[0], 5.0f);
-  CHECK_EQ(et3.Var().Get<phi::DenseTensor>().data<float>()[1], 10.0f);
+  PADDLE_ENFORCE_EQ(et3.Var().Get<phi::DenseTensor>().data<float>()[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(et3.Var().Get<phi::DenseTensor>().data<float>()[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   VLOG(6) << "SyncToTensor";
   paddle::Tensor t4;
   t4.set_impl(et3.GetTensorBase());
-  CHECK(t4.initialized() == true);
+  PADDLE_ENFORCE_EQ(
+      t4.initialized(),
+      true,
+      phi::errors::InvalidArgument(
+          "Tensor t4 should be initialized but got %d.", t4.initialized()));
+
   VLOG(6) << "Check Tensor";
   auto* dt3_tmp_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(t4.impl())->data<float>();
-  CHECK_EQ(dt3_tmp_ptr[0], 5.0f);
-  CHECK_EQ(dt3_tmp_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(dt3_tmp_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(dt3_tmp_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
   t4.reset();
-  CHECK(t4.defined() == false);
+  PADDLE_ENFORCE_EQ(
+      t4.defined(),
+      false,
+      phi::errors::InvalidArgument("Tensor t4 should be undefined but got %d.",
+                                   t4.defined()));
 
   VLOG(6) << "Check Tensor Copy_";
   std::vector<int64_t> rows = {1, 2};
@@ -174,24 +278,45 @@ TEST(EagerVariable, Constructor) {
   auto* dt9_tmp_ptr = std::dynamic_pointer_cast<phi::SelectedRows>(t9.impl())
                           ->value()
                           .data<float>();
-  CHECK_EQ(dt9_tmp_ptr[0], 6.0f);
-  CHECK_EQ(dt9_tmp_ptr[1], 11.0f);
-  CHECK_EQ(std::dynamic_pointer_cast<phi::SelectedRows>(t9.impl())->height(),
-           2);
+  PADDLE_ENFORCE_EQ(dt9_tmp_ptr[0],
+                    6.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "6.0f."));
+  PADDLE_ENFORCE_EQ(dt9_tmp_ptr[1],
+                    11.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "11.0f."));
+  PADDLE_ENFORCE_EQ(
+      std::dynamic_pointer_cast<phi::SelectedRows>(t9.impl())->height(),
+      2,
+      phi::errors::InvalidArgument("SelectedRows height should "
+                                   "be 2."));
 
   VLOG(6) << "Check Tensor Copy_ Dense Tensor";
   t5.copy_(t3, phi::GPUPlace(0), false);
   t6.copy_(t5, phi::CPUPlace(), false);
   auto* dt6_tmp_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(t6.impl())->data<float>();
-  CHECK_EQ(dt6_tmp_ptr[0], 5.0f);
-  CHECK_EQ(dt6_tmp_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(dt6_tmp_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(dt6_tmp_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
 #else
   t5.copy_(t3, phi::CPUPlace(), false);
   auto* dt5_tmp_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(t5.impl())->data<float>();
-  CHECK_EQ(dt5_tmp_ptr[0], 5.0f);
-  CHECK_EQ(dt5_tmp_ptr[1], 10.0f);
+  PADDLE_ENFORCE_EQ(dt5_tmp_ptr[0],
+                    5.0f,
+                    phi::errors::InvalidArgument("First element should be "
+                                                 "5.0f."));
+  PADDLE_ENFORCE_EQ(dt5_tmp_ptr[1],
+                    10.0f,
+                    phi::errors::InvalidArgument("Second element should be "
+                                                 "10.0f."));
 #endif
 
   VLOG(6) << "Finish";
@@ -215,10 +340,16 @@ TEST(EagerVariable, DataLayout) {
   tensor.set_impl(dt);
   auto eager_var = std::make_shared<egr::EagerVariable>(tensor);
   auto layout = paddle::imperative::GetDataLayout(eager_var);
-  CHECK_EQ(layout, phi::DataLayout::UNDEFINED);
+  PADDLE_ENFORCE_EQ(layout,
+                    phi::DataLayout::UNDEFINED,
+                    phi::errors::InvalidArgument("Data layout should be "
+                                                 "UNDEFINED."));
   paddle::imperative::SetDataLayout(eager_var, phi::DataLayout::NCHW);
   layout = paddle::imperative::GetDataLayout(eager_var);
-  CHECK_EQ(layout, phi::DataLayout::NCHW);
+  PADDLE_ENFORCE_EQ(layout,
+                    phi::DataLayout::NCHW,
+                    phi::errors::InvalidArgument("Data layout should be "
+                                                 "NCHW."));
 }
 
 TEST(VariableCompatTensor, MemberFunction) {
