【Error Message No.35 BUAA】Update error massage of test\cpp\eager\task_tests\forward_autograd_test.cc (#66594)

Fripping · web-flow · commit 33fc6f99eeb6 · 2024-07-31T10:04:12.000+08:00
* update error message

* update error message

* update the error message

* Delete test/cpp/utils/.ipynb_checkpoints directory

* Delete test/cpp/eager/task_tests/.ipynb_checkpoints directory

* Update forward_autograd_test.cc
diff --git a/test/cpp/eager/task_tests/forward_autograd_test.cc b/test/cpp/eager/task_tests/forward_autograd_test.cc
@@ -65,8 +65,16 @@ TEST(Forward, SingleNode) {
     GradNodeScale* scale_node = dynamic_cast<GradNodeScale*>(grad_node);
 
     CHECK_NOTNULL(scale_node);
-    CHECK_EQ(static_cast<int>(meta->OutRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(meta->OutRankInfo().second), 0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta->OutRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta->OutRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta->OutRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta->OutRankInfo().second) is not 0"));
   }
 }
 
@@ -127,17 +135,33 @@ TEST(Forward, LinearNodes) {
     GradNodeScale* scale_node0 = dynamic_cast<GradNodeScale*>(grad_node0);
 
     CHECK_NOTNULL(scale_node0);
-    CHECK_EQ(static_cast<int>(meta0->OutRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(meta0->OutRankInfo().second), 0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta0->OutRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta0->OutRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta0->OutRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta0->OutRankInfo().second) is not 0"));
 
     // Node 1
     AutogradMeta* meta1 = EagerUtils::autograd_meta(&out1);
     GradNodeBase* grad_node1 = meta1->GradNode();
     GradNodeScale* scale_node1 = dynamic_cast<GradNodeScale*>(grad_node1);
 
     CHECK_NOTNULL(scale_node1);
-    CHECK_EQ(static_cast<int>(meta1->OutRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(meta1->OutRankInfo().second), 0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta1->OutRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta1->OutRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta1->OutRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta1->OutRankInfo().second) is not 0"));
 
     // 2. TensorWrapper: No TensorWrapper for ScaleNode
     // 3. NextEdges: Node 1 -> Node 0
@@ -146,11 +170,27 @@ TEST(Forward, LinearNodes) {
         grad_node1->OutputMeta();
     const auto& node1_meta = node1_metas[0];
 
-    CHECK_EQ(static_cast<int>(node1_meta[0].GetEdge().GetEdgeRankInfo().first),
-             0);
-    CHECK_EQ(static_cast<int>(node1_meta[0].GetEdge().GetEdgeRankInfo().second),
-             0);
-    CHECK_EQ(node1_meta[0].GetEdge().GetGradNode(), grad_node0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(node1_meta[0].GetEdge().GetEdgeRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(node1_meta[0].GetEdge().GetEdgeRankInfo().first)"
+            "is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(node1_meta[0].GetEdge().GetEdgeRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(node1_meta[0].GetEdge().GetEdgeRankInfo().second)"
+            "is not 0"));
+    PADDLE_ENFORCE_EQ(node1_meta[0].GetEdge().GetGradNode(),
+                      grad_node0,
+                      phi::errors::InvalidArgument(
+                          "node1_meta[0].GetEdge().GetGradNode()"
+                          "is not equal with grad_node0"
+                          "the value of grad_node0 is %d"
+                          "and node1_meta[0].GetEdge().GetGradNode() is %d",
+                          grad_node0,
+                          node1_meta[0].GetEdge().GetGradNode()));
   }
 }
 
@@ -221,26 +261,50 @@ TEST(Forward, BranchedNodes) {
     GradNodeScale* scale_node0 = dynamic_cast<GradNodeScale*>(grad_node0);
 
     CHECK_NOTNULL(scale_node0);
-    CHECK_EQ(static_cast<int>(meta0->OutRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(meta0->OutRankInfo().second), 0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta0->OutRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta0->OutRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta0->OutRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta0->OutRankInfo().second) is not 0"));
 
     // Node 1
     AutogradMeta* meta1 = EagerUtils::autograd_meta(&out1);
     GradNodeBase* grad_node1 = meta1->GradNode();
     GradNodeScale* scale_node1 = dynamic_cast<GradNodeScale*>(grad_node1);
 
     CHECK_NOTNULL(scale_node1);
-    CHECK_EQ(static_cast<int>(meta1->OutRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(meta1->OutRankInfo().second), 0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta1->OutRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta1->OutRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta1->OutRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta1->OutRankInfo().second) is not 0"));
 
     // Node 2
     AutogradMeta* meta2 = EagerUtils::autograd_meta(&out2);
     GradNodeBase* grad_node2 = meta2->GradNode();
     GradNodeScale* scale_node2 = dynamic_cast<GradNodeScale*>(grad_node2);
 
     CHECK_NOTNULL(scale_node2);
-    CHECK_EQ(static_cast<int>(meta2->OutRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(meta2->OutRankInfo().second), 0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta2->OutRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta2->OutRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(meta2->OutRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(meta2->OutRankInfo().second) is not 0"));
 
     // 2. TensorWrapper: No TensorWrapper for ScaleNode
     // 3. NextEdges
@@ -249,19 +313,49 @@ TEST(Forward, BranchedNodes) {
         node1_metas = grad_node1->OutputMeta();
     const Edge& node1_edge = node1_metas[0][0].GetEdge();
 
-    CHECK_EQ(static_cast<int>(node1_edge.GetEdgeRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(node1_edge.GetEdgeRankInfo().second), 0);
-    CHECK_EQ(node1_edge.GetGradNode(), grad_node0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(node1_edge.GetEdgeRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(node1_edge.GetEdgeRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(node1_edge.GetEdgeRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(node1_edge.GetEdgeRankInfo().second) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        node1_edge.GetGradNode(),
+        grad_node0,
+        phi::errors::InvalidArgument(
+            "node1_edge.GetGradNode() is not equal with grad_node0"
+            "the value of node1_edge.GetGradNode() is %d and grad_node0 is %d",
+            node1_edge.GetGradNode(),
+            grad_node0));
 
     // Node 2 -> Node 0
     const paddle::small_vector<std::vector<egr::GradSlotMeta>,
                                egr::kSlotSmallVectorSize>& node2_metas =
         grad_node2->OutputMeta();
     const Edge& node2_edge = node2_metas[0][0].GetEdge();
 
-    CHECK_EQ(static_cast<int>(node2_edge.GetEdgeRankInfo().first), 0);
-    CHECK_EQ(static_cast<int>(node2_edge.GetEdgeRankInfo().second), 0);
-    CHECK_EQ(node2_edge.GetGradNode(), grad_node0);
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(node2_edge.GetEdgeRankInfo().first),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(node2_edge.GetEdgeRankInfo().first) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        static_cast<int>(node2_edge.GetEdgeRankInfo().second),
+        0,
+        phi::errors::InvalidArgument(
+            "static_cast<int>(node2_edge.GetEdgeRankInfo().second) is not 0"));
+    PADDLE_ENFORCE_EQ(
+        node2_edge.GetGradNode(),
+        grad_node0,
+        phi::errors::InvalidArgument(
+            "node2_edge.GetGradNode() is not equal with grad_node0"
+            "the value of node2_edge.GetGradNode() is %d and grad_node0 is %d",
+            node2_edge.GetGradNode(),
+            grad_node0));
   }
 }
 
