From 9318759bfac4a39d73191ad286d54f8aa481ca6d Mon Sep 17 00:00:00 2001 From: Andy Ly Date: Wed, 10 Apr 2019 10:49:53 -0700 Subject: [PATCH] [Grappler] Clean up ArithmeticOptimizer test style. PiperOrigin-RevId: 242898904 --- tensorflow/core/grappler/optimizers/BUILD | 4 +- .../optimizers/arithmetic_optimizer_test.cc | 1345 +++++++++-------- 2 files changed, 709 insertions(+), 640 deletions(-) diff --git a/tensorflow/core/grappler/optimizers/BUILD b/tensorflow/core/grappler/optimizers/BUILD index da2d2acc878..27075ad0b97 100644 --- a/tensorflow/core/grappler/optimizers/BUILD +++ b/tensorflow/core/grappler/optimizers/BUILD @@ -1,8 +1,7 @@ licenses(["notice"]) # Apache 2.0 -load("//tensorflow:tensorflow.bzl", "tf_cc_test") +load("//tensorflow:tensorflow.bzl", "tf_cc_test", "tf_kernel_library") load("//tensorflow:tensorflow.bzl", "tf_cuda_cc_test") -load("//tensorflow:tensorflow.bzl", "tf_kernel_library") # Platform specific build config load( @@ -314,6 +313,7 @@ tf_cuda_cc_test( "//tensorflow/core/grappler:grappler_item", "//tensorflow/core/grappler:utils", "//tensorflow/core/grappler/inputs:trivial_test_graph_input_yielder", + "@com_google_absl//absl/strings", ], ) diff --git a/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc b/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc index 6a9d7557620..94508c68368 100644 --- a/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc +++ b/tensorflow/core/grappler/optimizers/arithmetic_optimizer_test.cc @@ -14,6 +14,9 @@ limitations under the License. ==============================================================================*/ #include "tensorflow/core/grappler/optimizers/arithmetic_optimizer.h" + +#include "absl/strings/str_cat.h" +#include "tensorflow/cc/ops/array_ops.h" #include "tensorflow/cc/ops/math_ops.h" #include "tensorflow/cc/ops/standard_ops.h" #include "tensorflow/core/framework/node_def.pb.h" @@ -110,25 +113,25 @@ TEST_F(ArithmeticOptimizerTest, OpDedupping) { item.fetch = {"div"}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(2, output.node_size()); + EXPECT_EQ(output.node_size(), 2); const NodeDef* new_c1 = node_map.GetNode("c1"); ASSERT_NE(new_c1, nullptr); const NodeDef* new_div = node_map.GetNode("div"); ASSERT_NE(new_div, nullptr); - EXPECT_EQ(2, new_div->input_size()); - EXPECT_EQ("c1", new_div->input(0)); - EXPECT_EQ("c1", new_div->input(1)); + ASSERT_EQ(new_div->input_size(), 2); + EXPECT_EQ(new_div->input(0), "c1"); + EXPECT_EQ(new_div->input(1), "c1"); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, OpDeduppingAssertAndCheckNumerics) { @@ -149,7 +152,7 @@ TEST_F(ArithmeticOptimizerTest, OpDeduppingAssertAndCheckNumerics) { bool_t.scalar().setConstant(true); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", bool_t}}); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; @@ -157,18 +160,18 @@ TEST_F(ArithmeticOptimizerTest, OpDeduppingAssertAndCheckNumerics) { OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(5, output.node_size()); + EXPECT_EQ(output.node_size(), 5); const NodeDef* new_div = node_map.GetNode("div"); ASSERT_NE(new_div, nullptr); - EXPECT_EQ(4, new_div->input_size()); - EXPECT_EQ("check1", new_div->input(0)); - EXPECT_EQ("check1", new_div->input(1)); - EXPECT_EQ("^assert1", new_div->input(2)); - EXPECT_EQ("^assert1", new_div->input(3)); + ASSERT_EQ(new_div->input_size(), 4); + EXPECT_EQ(new_div->input(0), "check1"); + EXPECT_EQ(new_div->input(1), "check1"); + EXPECT_EQ(new_div->input(2), "^assert1"); + EXPECT_EQ(new_div->input(3), "^assert1"); auto tensors = EvaluateNodes(output, item.fetch, {{"Placeholder", bool_t}}); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + EXPECT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, OpDedupCommutative) { @@ -182,32 +185,32 @@ TEST_F(ArithmeticOptimizerTest, OpDedupCommutative) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); item.fetch = {"div1"}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(4, output.node_size()); + EXPECT_EQ(output.node_size(), 4); const NodeDef* new_c1 = node_map.GetNode("c1"); ASSERT_NE(new_c1, nullptr); const NodeDef* new_c2 = node_map.GetNode("c2"); ASSERT_NE(new_c2, nullptr); const NodeDef* new_mul1 = node_map.GetNode("mul1"); ASSERT_NE(new_mul1, nullptr); - EXPECT_EQ(2, new_mul1->input_size()); - EXPECT_EQ("c1", new_mul1->input(0)); - EXPECT_EQ("c2", new_mul1->input(1)); + ASSERT_EQ(new_mul1->input_size(), 2); + EXPECT_EQ(new_mul1->input(0), "c1"); + EXPECT_EQ(new_mul1->input(1), "c2"); const NodeDef* new_div1 = node_map.GetNode("div1"); ASSERT_NE(new_div1, nullptr); - EXPECT_EQ(2, new_div1->input_size()); - EXPECT_EQ("mul1", new_div1->input(0)); - EXPECT_EQ("mul1", new_div1->input(1)); + ASSERT_EQ(new_div1->input_size(), 2); + EXPECT_EQ(new_div1->input(0), "mul1"); + EXPECT_EQ(new_div1->input(1), "mul1"); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, ReplaceMulWithSquare) { @@ -223,36 +226,38 @@ TEST_F(ArithmeticOptimizerTest, ReplaceMulWithSquare) { item.fetch = {"id", "id2"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - ASSERT_EQ(2, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 2); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyReplaceMulWithSquare(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); - EXPECT_EQ(6, output.node_size()); + EXPECT_EQ(output.node_size(), 6); NodeMap node_map(&output); const string p = "ArithmeticOptimizer/ReplaceMulWithSquare"; - const NodeDef* square_node = node_map.GetNode(strings::StrCat(p, "_", "mul")); + const NodeDef* square_node = node_map.GetNode(absl::StrCat(p, "_", "mul")); ASSERT_NE(square_node, nullptr); - EXPECT_EQ("Square", square_node->op()); - EXPECT_EQ("c", square_node->input(0)); - EXPECT_EQ("^d", square_node->input(1)); + EXPECT_EQ(square_node->op(), "Square"); + ASSERT_EQ(square_node->input_size(), 2); + EXPECT_EQ(square_node->input(0), "c"); + EXPECT_EQ(square_node->input(1), "^d"); const NodeDef* square_node2 = - node_map.GetNode(strings::StrCat(p, "_", "mul_no_nan")); + node_map.GetNode(absl::StrCat(p, "_", "mul_no_nan")); ASSERT_NE(square_node2, nullptr); - EXPECT_EQ("Square", square_node2->op()); - EXPECT_EQ("d", square_node2->input(0)); + EXPECT_EQ(square_node2->op(), "Square"); + ASSERT_EQ(square_node2->input_size(), 1); + EXPECT_EQ(square_node2->input(0), "d"); auto tensors = EvaluateNodes(output, item.fetch); - ASSERT_EQ(2, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 2); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, RemoveInvolution_AdjacentNodes) { +TEST_F(ArithmeticOptimizerTest, RemoveInvolutionAdjacentNodes) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto c = ops::Const(s.WithOpName("c"), {1.0f, 2.0f}, {1, 2}); @@ -266,7 +271,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveInvolution_AdjacentNodes) { item.fetch = {"id"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -274,16 +279,17 @@ TEST_F(ArithmeticOptimizerTest, RemoveInvolution_AdjacentNodes) { OptimizeAndPrune(&optimizer, &item, &output); // Negation and Reciprocal nodes cancelled each other. - EXPECT_EQ(2, output.node_size()); - EXPECT_EQ("id", output.node(1).name()); - EXPECT_EQ("c", output.node(1).input(0)); + ASSERT_EQ(output.node_size(), 2); + EXPECT_EQ(output.node(1).name(), "id"); + ASSERT_EQ(output.node(1).input_size(), 1); + EXPECT_EQ(output.node(1).input(0), "c"); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, RemoveInvolution_AroundValuePreservingChain) { +TEST_F(ArithmeticOptimizerTest, RemoveInvolutionAroundValuePreservingChain) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto c = ops::Const(s.WithOpName("c"), {1.0f, 2.0f}, {1, 2}); @@ -299,7 +305,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveInvolution_AroundValuePreservingChain) { item.fetch = fetch; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -307,27 +313,29 @@ TEST_F(ArithmeticOptimizerTest, RemoveInvolution_AroundValuePreservingChain) { OptimizeTwiceAndPrune(&optimizer, &item, &output); // Check that Reciprocal nodes were removed from the graph. - EXPECT_EQ(3, output.node_size()); + EXPECT_EQ(output.node_size(), 3); // And const directly flows into squeeze. int found = 0; for (const NodeDef& node : output.node()) { if (node.name() == "squeeze") { - EXPECT_EQ("c", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "c"); found++; } else if (node.name() == "id2") { - EXPECT_EQ("squeeze", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "squeeze"); found++; } } - EXPECT_EQ(2, found); + EXPECT_EQ(found, 2); auto tensors = EvaluateNodes(output, fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, RemoveInvolution_SkipControlDependencies) { +TEST_F(ArithmeticOptimizerTest, RemoveInvolutionSkipControlDependencies) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto c = ops::Const(s.WithOpName("c"), {1.0f, 2.0f}, {1, 2}); @@ -345,7 +353,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveInvolution_SkipControlDependencies) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -356,8 +364,8 @@ TEST_F(ArithmeticOptimizerTest, RemoveInvolution_SkipControlDependencies) { VerifyGraphsMatch(item.graph, output, __LINE__); auto tensors = EvaluateNodes(output, fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, TrivialSumsSimple) { @@ -371,36 +379,39 @@ TEST_F(ArithmeticOptimizerTest, TrivialSumsSimple) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(5, output.node_size()); + EXPECT_EQ(output.node_size(), 5); const string optimized_const_name = AggregationConstName("add"); const string optimized_mul_name = AggregationMulName("add"); const NodeDef* new_const = node_map.GetNode(optimized_const_name); ASSERT_NE(new_const, nullptr); - EXPECT_EQ("^x", new_const->input(0)); - EXPECT_EQ(string("\0\0\0@", 4), - new_const->attr().at("value").tensor().tensor_content()); + ASSERT_EQ(new_const->input_size(), 1); + EXPECT_EQ(new_const->input(0), "^x"); + EXPECT_EQ(new_const->attr().at("value").tensor().tensor_content(), + string("\0\0\0@", 4)); const NodeDef* new_mul = node_map.GetNode(optimized_mul_name); ASSERT_NE(new_mul, nullptr); - EXPECT_EQ(optimized_const_name, new_mul->input(0)); - EXPECT_EQ("x", new_mul->input(1)); + ASSERT_EQ(new_mul->input_size(), 2); + EXPECT_EQ(new_mul->input(0), optimized_const_name); + EXPECT_EQ(new_mul->input(1), "x"); const NodeDef* new_id = node_map.GetNode("id"); ASSERT_NE(new_id, nullptr); - EXPECT_EQ(optimized_mul_name, new_id->input(0)); + ASSERT_EQ(new_id->input_size(), 1); + EXPECT_EQ(new_id->input(0), optimized_mul_name); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, TrivialSumsSimpleWithControlDep) { @@ -415,37 +426,40 @@ TEST_F(ArithmeticOptimizerTest, TrivialSumsSimpleWithControlDep) { std::vector fetch = {"id"}; auto tensors_expected = EvaluateNodes(item.graph, fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(6, output.node_size()); + EXPECT_EQ(output.node_size(), 6); const string optimized_const_name = AggregationConstName("add"); const string optimized_mul_name = AggregationMulName("add"); const NodeDef* new_const = node_map.GetNode(optimized_const_name); ASSERT_NE(new_const, nullptr); - EXPECT_EQ("^x", new_const->input(0)); - EXPECT_EQ(string("\0\0\0@", 4), - new_const->attr().at("value").tensor().tensor_content()); + ASSERT_EQ(new_const->input_size(), 1); + EXPECT_EQ(new_const->input(0), "^x"); + EXPECT_EQ(new_const->attr().at("value").tensor().tensor_content(), + string("\0\0\0@", 4)); const NodeDef* new_mul = node_map.GetNode(optimized_mul_name); ASSERT_NE(new_mul, nullptr); - EXPECT_EQ(optimized_const_name, new_mul->input(0)); - EXPECT_EQ("x", new_mul->input(1)); - EXPECT_EQ("^y", new_mul->input(2)); + ASSERT_EQ(new_mul->input_size(), 3); + EXPECT_EQ(new_mul->input(0), optimized_const_name); + EXPECT_EQ(new_mul->input(1), "x"); + EXPECT_EQ(new_mul->input(2), "^y"); const NodeDef* new_id = node_map.GetNode("id"); ASSERT_NE(new_id, nullptr); - EXPECT_EQ(optimized_mul_name, new_id->input(0)); + ASSERT_EQ(new_id->input_size(), 1); + EXPECT_EQ(new_id->input(0), optimized_mul_name); auto tensors = EvaluateNodes(output, fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, TrivialSumsRepeatedAdd) { @@ -483,51 +497,51 @@ TEST_F(ArithmeticOptimizerTest, TrivialSumsRepeatedAdd) { // Add_5(Const(2), Const(2)))) NodeMap node_map(&output); - EXPECT_EQ(17, output.node_size()); + EXPECT_EQ(output.node_size(), 17); const NodeDef* id_node = node_map.GetNode("id"); ASSERT_NE(id_node, nullptr); - EXPECT_EQ(1, id_node->input_size()); - EXPECT_EQ(HoistMulName("Add_6"), id_node->input(0)); + ASSERT_EQ(id_node->input_size(), 1); + EXPECT_EQ(id_node->input(0), HoistMulName("Add_6")); const NodeDef* mul_node = node_map.GetNode(HoistMulName("Add_6")); ASSERT_NE(mul_node, nullptr); - EXPECT_EQ(2, mul_node->input_size()); - EXPECT_EQ("Placeholder", mul_node->input(0)); - EXPECT_EQ(HoistAddName("Add_6"), mul_node->input(1)); + ASSERT_EQ(mul_node->input_size(), 2); + EXPECT_EQ(mul_node->input(0), "Placeholder"); + EXPECT_EQ(mul_node->input(1), HoistAddName("Add_6")); const NodeDef* add_6_node = node_map.GetNode(HoistAddName("Add_6")); ASSERT_NE(add_6_node, nullptr); - EXPECT_EQ(2, add_6_node->input_size()); - EXPECT_EQ(HoistAddName("Add_4"), add_6_node->input(0)); - EXPECT_EQ(HoistAddName("Add_5"), add_6_node->input(1)); + ASSERT_EQ(add_6_node->input_size(), 2); + EXPECT_EQ(add_6_node->input(0), HoistAddName("Add_4")); + EXPECT_EQ(add_6_node->input(1), HoistAddName("Add_5")); const NodeDef* add_4_node = node_map.GetNode(HoistAddName("Add_4")); ASSERT_NE(add_4_node, nullptr); - EXPECT_EQ("Add", add_4_node->op()); - EXPECT_EQ(2, add_4_node->input_size()); - EXPECT_EQ(AggregationConstName("Add"), add_4_node->input(0)); - EXPECT_EQ(AggregationConstName("Add_1"), add_4_node->input(1)); + EXPECT_EQ(add_4_node->op(), "Add"); + ASSERT_EQ(2, add_4_node->input_size()); + EXPECT_EQ(add_4_node->input(0), AggregationConstName("Add")); + EXPECT_EQ(add_4_node->input(1), AggregationConstName("Add_1")); const NodeDef* add_5_node = node_map.GetNode(HoistAddName("Add_5")); ASSERT_NE(add_5_node, nullptr); - EXPECT_EQ("Add", add_5_node->op()); - EXPECT_EQ(2, add_5_node->input_size()); - EXPECT_EQ(AggregationConstName("Add"), add_5_node->input(0)); - EXPECT_EQ(AggregationConstName("Add_1"), add_5_node->input(1)); + EXPECT_EQ(add_5_node->op(), "Add"); + ASSERT_EQ(add_5_node->input_size(), 2); + EXPECT_EQ(add_5_node->input(0), AggregationConstName("Add")); + EXPECT_EQ(add_5_node->input(1), AggregationConstName("Add_1")); const NodeDef* add_const_node = node_map.GetNode(AggregationConstName("Add")); ASSERT_NE(add_const_node, nullptr); - EXPECT_EQ("Const", add_const_node->op()); - EXPECT_EQ(1, add_const_node->input_size()); - EXPECT_EQ("^Placeholder", add_const_node->input(0)); + EXPECT_EQ(add_const_node->op(), "Const"); + ASSERT_EQ(add_const_node->input_size(), 1); + EXPECT_EQ(add_const_node->input(0), "^Placeholder"); const NodeDef* add_1_const_node = node_map.GetNode(AggregationConstName("Add_1")); ASSERT_NE(add_1_const_node, nullptr); - EXPECT_EQ("Const", add_1_const_node->op()); - EXPECT_EQ(1, add_1_const_node->input_size()); - EXPECT_EQ("^Placeholder", add_1_const_node->input(0)); + EXPECT_EQ(add_1_const_node->op(), "Const"); + ASSERT_EQ(add_1_const_node->input_size(), 1); + EXPECT_EQ(add_1_const_node->input(0), "^Placeholder"); } TEST_F(ArithmeticOptimizerTest, HoistFactorMul) { @@ -551,7 +565,7 @@ TEST_F(ArithmeticOptimizerTest, HoistFactorMul) { item.fetch = {"id"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; EnableOnlyHoistCommonFactor(&optimizer); @@ -573,26 +587,29 @@ TEST_F(ArithmeticOptimizerTest, HoistFactorMul) { if (use_addn && !matching_shapes) { VerifyGraphsMatch(item.graph, output, __LINE__); } else { - EXPECT_EQ(9, output.node_size()); + EXPECT_EQ(output.node_size(), 9); const NodeDef* new_add_node = node_map.GetNode(HoistAddName("add")); ASSERT_NE(new_add_node, nullptr) << "Hoisted Add node not found"; - EXPECT_EQ("y1", new_add_node->input(0)); - EXPECT_EQ("y2", new_add_node->input(1)); + ASSERT_EQ(new_add_node->input_size(), 2); + EXPECT_EQ(new_add_node->input(0), "y1"); + EXPECT_EQ(new_add_node->input(1), "y2"); const NodeDef* new_mul_node = node_map.GetNode(HoistMulName("add")); ASSERT_NE(new_mul_node, nullptr) << "Hoisted Mul node not found"; - EXPECT_EQ("x", new_mul_node->input(0)); - EXPECT_EQ(new_add_node->name(), new_mul_node->input(1)); + ASSERT_EQ(new_mul_node->input_size(), 2); + EXPECT_EQ(new_mul_node->input(0), "x"); + EXPECT_EQ(new_mul_node->input(1), new_add_node->name()); const NodeDef* id_node = node_map.GetNode("id"); ASSERT_NE(id_node, nullptr) << "Id node not found"; - EXPECT_EQ("id", id_node->name()); - EXPECT_EQ(HoistMulName("add"), id_node->input(0)); + EXPECT_EQ(id_node->name(), "id"); + ASSERT_EQ(id_node->input_size(), 1); + EXPECT_EQ(id_node->input(0), HoistMulName("add")); } auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } } } @@ -630,7 +647,7 @@ TEST_F(ArithmeticOptimizerTest, HoistFactorDiv) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; EnableOnlyHoistCommonFactor(&optimizer); @@ -653,29 +670,32 @@ TEST_F(ArithmeticOptimizerTest, HoistFactorDiv) { if ((use_addn && !matching_shapes) || use_ints) { VerifyGraphsMatch(item.graph, output, __LINE__); } else { - EXPECT_EQ(9, output.node_size()); + EXPECT_EQ(output.node_size(), 9); const NodeDef* new_add_node = node_map.GetNode(HoistAddName("add")); ASSERT_TRUE(new_add_node != nullptr) << "Hoisted Add node not found"; - EXPECT_EQ("y1", new_add_node->input(0)); - EXPECT_EQ("y2", new_add_node->input(1)); + ASSERT_EQ(new_add_node->input_size(), 2); + EXPECT_EQ(new_add_node->input(0), "y1"); + EXPECT_EQ(new_add_node->input(1), "y2"); const NodeDef* new_div_node = node_map.GetNode(HoistDivName("add")); ASSERT_TRUE(new_div_node != nullptr) << "Hoisted Div node not found"; - EXPECT_EQ(new_add_node->name(), new_div_node->input(0)); - EXPECT_EQ("x", new_div_node->input(1)); + ASSERT_EQ(new_div_node->input_size(), 2); + EXPECT_EQ(new_div_node->input(0), new_add_node->name()); + EXPECT_EQ(new_div_node->input(1), "x"); const NodeDef* id_node = node_map.GetNode("id"); ASSERT_TRUE(id_node != nullptr) << "Id node not found"; EXPECT_EQ("id", id_node->name()); - EXPECT_EQ(HoistDivName("add"), id_node->input(0)); + ASSERT_EQ(id_node->input_size(), 1); + EXPECT_EQ(id_node->input(0), HoistDivName("add")); } auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); if (use_ints) { - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } else { - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } } } @@ -696,27 +716,28 @@ TEST_F(ArithmeticOptimizerTest, FuseConjAndTranspose) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(7, output.node_size()); + EXPECT_EQ(output.node_size(), 7); const string p = "ArithmeticOptimizer/FoldConjugateIntoTranspose"; - const string optimized_name = strings::StrCat(p, "_", "trans"); + const string optimized_name = absl::StrCat(p, "_", "trans"); const NodeDef* trans_fused_node = node_map.GetNode(optimized_name); ASSERT_NE(trans_fused_node, nullptr); - EXPECT_EQ("ConjugateTranspose", trans_fused_node->op()); - EXPECT_EQ("z", trans_fused_node->input(0)); - EXPECT_EQ("perm", trans_fused_node->input(1)); + EXPECT_EQ(trans_fused_node->op(), "ConjugateTranspose"); + ASSERT_EQ(trans_fused_node->input_size(), 2); + EXPECT_EQ(trans_fused_node->input(0), "z"); + EXPECT_EQ(trans_fused_node->input(1), "perm"); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } TEST_F(ArithmeticOptimizerTest, FuseConjAndConjugateTranspose) { @@ -735,27 +756,28 @@ TEST_F(ArithmeticOptimizerTest, FuseConjAndConjugateTranspose) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(7, output.node_size()); + EXPECT_EQ(output.node_size(), 7); const string p = "ArithmeticOptimizer/FoldConjugateIntoTranspose"; - const string optimized_name = strings::StrCat(p, "_", "conjugate_trans"); + const string optimized_name = absl::StrCat(p, "_", "conjugate_trans"); const NodeDef* conjugate_trans_fused_node = node_map.GetNode(optimized_name); ASSERT_NE(conjugate_trans_fused_node, nullptr); - EXPECT_EQ("Transpose", conjugate_trans_fused_node->op()); - EXPECT_EQ("z", conjugate_trans_fused_node->input(0)); - EXPECT_EQ("perm", conjugate_trans_fused_node->input(1)); + EXPECT_EQ(conjugate_trans_fused_node->op(), "Transpose"); + ASSERT_EQ(conjugate_trans_fused_node->input_size(), 2); + EXPECT_EQ(conjugate_trans_fused_node->input(0), "z"); + EXPECT_EQ(conjugate_trans_fused_node->input(1), "perm"); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } TEST_F(ArithmeticOptimizerTest, FuseTransposeAndConj) { @@ -772,27 +794,28 @@ TEST_F(ArithmeticOptimizerTest, FuseTransposeAndConj) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(7, output.node_size()); + EXPECT_EQ(output.node_size(), 7); const string p = "ArithmeticOptimizer/FoldConjugateIntoTranspose"; - const string optimized_name = strings::StrCat(p, "_", "conj"); + const string optimized_name = absl::StrCat(p, "_", "conj"); const NodeDef* conj_fused_node = node_map.GetNode(optimized_name); ASSERT_NE(conj_fused_node, nullptr); - EXPECT_EQ("ConjugateTranspose", conj_fused_node->op()); - EXPECT_EQ("z", conj_fused_node->input(0)); - EXPECT_EQ("perm", conj_fused_node->input(1)); + EXPECT_EQ(conj_fused_node->op(), "ConjugateTranspose"); + ASSERT_EQ(conj_fused_node->input_size(), 2); + EXPECT_EQ(conj_fused_node->input(0), "z"); + EXPECT_EQ(conj_fused_node->input(1), "perm"); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } TEST_F(ArithmeticOptimizerTest, FoldTransposeIntoMatMul) { @@ -822,7 +845,7 @@ TEST_F(ArithmeticOptimizerTest, FoldTransposeIntoMatMul) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; EnableOnlyFoldTransposeIntoMatMul(&optimizer); @@ -830,15 +853,16 @@ TEST_F(ArithmeticOptimizerTest, FoldTransposeIntoMatMul) { OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - EXPECT_EQ(8, output.node_size()); + EXPECT_EQ(output.node_size(), 8); const string p = "ArithmeticOptimizer/FoldTransposeIntoMatMul"; - const string optimized_name = strings::StrCat(p, "_", "matmul"); + const string optimized_name = absl::StrCat(p, "_", "matmul"); const NodeDef* matmul_fused_node = node_map.GetNode(optimized_name); ASSERT_NE(matmul_fused_node, nullptr); - EXPECT_EQ("a", matmul_fused_node->input(0)); - EXPECT_EQ("b", matmul_fused_node->input(1)); + ASSERT_EQ(matmul_fused_node->input_size(), 2); + EXPECT_EQ(matmul_fused_node->input(0), "a"); + EXPECT_EQ(matmul_fused_node->input(1), "b"); if (matmul_type == "BatchMatMul") { EXPECT_TRUE(matmul_fused_node->attr().at("adj_x").b()); @@ -854,8 +878,8 @@ TEST_F(ArithmeticOptimizerTest, FoldTransposeIntoMatMul) { EXPECT_EQ(identity_node->input(0), optimized_name); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } } @@ -882,31 +906,32 @@ TEST_F(ArithmeticOptimizerTest, FoldConjugateTransposeIntoBatchMatMul) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); ArithmeticOptimizer optimizer; GraphDef output; OptimizeTwice(&optimizer, &item, &output); NodeMap node_map(&output); - ASSERT_EQ(11, output.node_size()); + EXPECT_EQ(output.node_size(), 11); const string p = "ArithmeticOptimizer/FoldTransposeIntoMatMul"; - const string optimized_name = strings::StrCat(p, "_", "matmul"); + const string optimized_name = absl::StrCat(p, "_", "matmul"); const NodeDef* optimized_matmul = node_map.GetNode(optimized_name); ASSERT_NE(optimized_matmul, nullptr); - EXPECT_EQ("a", optimized_matmul->input(0)); - EXPECT_EQ("b", optimized_matmul->input(1)); + ASSERT_EQ(optimized_matmul->input_size(), 2); + EXPECT_EQ(optimized_matmul->input(0), "a"); + EXPECT_EQ(optimized_matmul->input(1), "b"); EXPECT_TRUE(optimized_matmul->attr().at("adj_x").b()); EXPECT_TRUE(optimized_matmul->attr().at("adj_y").b()); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_IdentityReshape) { +TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshapeIdentityReshape) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); Output inputs = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({-1, 3, 28, 28})); @@ -927,21 +952,21 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_IdentityReshape) { auto x_t = GenerateRandomTensor(TensorShape({3, 3, 28, 28})); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", x_t}}); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyRemoveRedundantReshape(&optimizer); OptimizeTwiceAndPrune(&optimizer, &item, &output); - EXPECT_EQ(0, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 0); auto tensors = EvaluateNodes(output, item.fetch, {{"Placeholder", x_t}}); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, - RemoveRedundantReshape_IdentityReshapeBetweenSymbolicShapes) { + RemoveRedundantReshapeIdentityReshapeBetweenSymbolicShapes) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); Output inputs = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({-1, 3, -1, -1})); @@ -968,7 +993,7 @@ TEST_F(ArithmeticOptimizerTest, TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; // Assume valid feed shape in aggressive mode. @@ -976,13 +1001,13 @@ TEST_F(ArithmeticOptimizerTest, EnableOnlyRemoveRedundantReshape(&optimizer); OptimizeTwiceAndPrune(&optimizer, &item, &output); - EXPECT_EQ(0, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 0); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_NotAssumeValidFeeds) { +TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshapeNotAssumeValidFeeds) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); Output inputs = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({4, 3, 28, 28})); @@ -997,7 +1022,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_NotAssumeValidFeeds) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1006,15 +1031,15 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_NotAssumeValidFeeds) { // The reshape is preserved because the shape of the placeholder can be // different from the shape of the actual feed. - EXPECT_EQ(1, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 1); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, - RemoveRedundantReshape_AssumeValidFeedsInAggressiveMode) { + RemoveRedundantReshapeAssumeValidFeedsInAggressiveMode) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); Output inputs = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({4, 3, 28, 28})); @@ -1029,20 +1054,20 @@ TEST_F(ArithmeticOptimizerTest, TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer(RewriterConfig::AGGRESSIVE); EnableOnlyRemoveRedundantReshape(&optimizer); OptimizeTwiceAndPrune(&optimizer, &item, &output); - EXPECT_EQ(0, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 0); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_NotIdentityReshape) { +TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshapeNotIdentityReshape) { // Reshape from [-1,3,28,28] to [8,-1,28,28] is not identity, because it can // be from [4,3,28,28] to [8,6,28,28]. tensorflow::Scope s = tensorflow::Scope::NewRootScope(); @@ -1057,21 +1082,21 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_NotIdentityReshape) { auto x_t = GenerateRandomTensor(TensorShape({8, 3, 28, 28})); item.feed = {{"Placeholder", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyRemoveRedundantReshape(&optimizer); OptimizeTwiceAndPrune(&optimizer, &item, &output); - EXPECT_EQ(1, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 1); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, - RemoveRedundantReshape_NotIdentityReshapeTooManyUnknownDimSizes) { + RemoveRedundantReshapeNotIdentityReshapeTooManyUnknownDimSizes) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); Output inputs = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({4, 3})); @@ -1087,10 +1112,10 @@ TEST_F(ArithmeticOptimizerTest, EnableOnlyRemoveRedundantReshape(&optimizer); OptimizeTwiceAndPrune(&optimizer, &item, &output); - EXPECT_EQ(1, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 1); } -TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_CombineReshapes) { +TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshapeCombineReshapes) { // Converts an NCHW_VECT_C tensor to NHWC and then flattens it to 2D. The two // reshapes should be combined. tensorflow::Scope s = tensorflow::Scope::NewRootScope(); @@ -1114,20 +1139,20 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantReshape_CombineReshapes) { auto x_t = GenerateRandomTensor(TensorShape({8, 3, 28, 28, 4})); item.feed = {{"nchw_vect_c", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyRemoveRedundantReshape(&optimizer); OptimizeTwiceAndPrune(&optimizer, &item, &output); - EXPECT_EQ(1, CountOpNodes(output, "Reshape")); + EXPECT_EQ(CountOpNodes(output, "Reshape"), 1); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } -TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_ProducerIsCast) { +TEST_F(ArithmeticOptimizerTest, ReorderTransposeCastProducerIsCast) { tensorflow::Scope s = tensorflow::Scope::NewRootScope().WithDevice("/CPU:0"); Output nhwc_uint8 = ops::Placeholder(s, DT_UINT8, ops::Placeholder::Shape({8, 28, 28, 3})); @@ -1143,7 +1168,7 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_ProducerIsCast) { auto input_t = GenerateRandomTensor(TensorShape({8, 28, 28, 3})); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1153,25 +1178,26 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_ProducerIsCast) { for (const NodeDef& node : output.node()) { if (node.op() == "Transpose") { EXPECT_EQ(transpose_node, nullptr); - EXPECT_EQ(DT_UINT8, node.attr().at("T").type()); + EXPECT_EQ(node.attr().at("T").type(), DT_UINT8); transpose_node = &node; } } - EXPECT_NE(transpose_node, nullptr); + ASSERT_NE(transpose_node, nullptr); for (const NodeDef& node : output.node()) { if (node.op() == "Cast") { - EXPECT_EQ(NodeName(node.input(0)), transpose_node->name()); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(transpose_node->name(), NodeName(node.input(0))); } } auto tensors = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } -TEST_F(ArithmeticOptimizerTest, ReorderS2DCast_ProducerIsCast) { +TEST_F(ArithmeticOptimizerTest, ReorderS2DCastProducerIsCast) { // TODO(jingyue): Evaluate S2D+Cast on GPU as well. We can't simply put nodes // under a /GPU:0 scope, because this test would fail if the testing machine // doesn't have a GPU. Maybe EvaluateNodes should allow soft placement? @@ -1189,7 +1215,7 @@ TEST_F(ArithmeticOptimizerTest, ReorderS2DCast_ProducerIsCast) { auto input_t = GenerateRandomTensor(TensorShape({8, 28, 28, 3})); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1199,25 +1225,26 @@ TEST_F(ArithmeticOptimizerTest, ReorderS2DCast_ProducerIsCast) { for (const NodeDef& node : output.node()) { if (node.op() == "SpaceToDepth") { EXPECT_EQ(s2d_node, nullptr); - EXPECT_EQ(DT_UINT8, node.attr().at("T").type()); + EXPECT_EQ(node.attr().at("T").type(), DT_UINT8); s2d_node = &node; } } - EXPECT_NE(s2d_node, nullptr); + ASSERT_NE(s2d_node, nullptr); for (const NodeDef& node : output.node()) { if (node.op() == "Cast") { - EXPECT_EQ(NodeName(node.input(0)), s2d_node->name()); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(s2d_node->name(), NodeName(node.input(0))); } } auto tensors = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } -TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_ProducerIsTranspose) { +TEST_F(ArithmeticOptimizerTest, ReorderTransposeCastProducerIsTranspose) { tensorflow::Scope s = tensorflow::Scope::NewRootScope().WithDevice("/CPU:0"); Output nhwc_fp32 = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({8, 28, 28, 3})); @@ -1234,7 +1261,7 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_ProducerIsTranspose) { GenerateConstantTensor(TensorShape({8, 28, 28, 3}), 42.0f); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1245,22 +1272,24 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_ProducerIsTranspose) { if (node.op() == "Cast") { EXPECT_EQ(cast_node, nullptr); cast_node = &node; + ASSERT_EQ(node.input_size(), 1); EXPECT_EQ(NodeName(node.input(0)), "Placeholder"); } } - EXPECT_NE(cast_node, nullptr); + ASSERT_NE(cast_node, nullptr); for (const NodeDef& node : output.node()) { if (node.op() == "Transpose") { - EXPECT_EQ(DT_UINT8, node.attr().at("T").type()); - EXPECT_EQ(NodeName(node.input(0)), cast_node->name()); + EXPECT_EQ(node.attr().at("T").type(), DT_UINT8); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(cast_node->name(), NodeName(node.input(0))); } } auto tensors = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } TEST_F(ArithmeticOptimizerTest, ReorderTransposeReverseCast) { @@ -1282,7 +1311,7 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeReverseCast) { auto input_t = GenerateRandomTensor(TensorShape({8, 28, 28, 3})); auto tensors_expected = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1294,30 +1323,33 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeReverseCast) { for (const NodeDef& node : output.node()) { if (node.op() == "Transpose") { EXPECT_EQ(transpose_node, nullptr); - EXPECT_EQ(DT_UINT8, node.attr().at("T").type()); + EXPECT_EQ(node.attr().at("T").type(), DT_UINT8); transpose_node = &node; } else if (node.op() == "ReverseV2") { EXPECT_EQ(reverse_node, nullptr); - EXPECT_EQ(DT_UINT8, node.attr().at("T").type()); + EXPECT_EQ(node.attr().at("T").type(), DT_UINT8); reverse_node = &node; } else if (node.op() == "Cast") { cast_node = &node; } } - EXPECT_NE(cast_node, nullptr); - EXPECT_NE(reverse_node, nullptr); - EXPECT_NE(transpose_node, nullptr); + ASSERT_NE(cast_node, nullptr); + ASSERT_NE(reverse_node, nullptr); + ASSERT_NE(transpose_node, nullptr); + ASSERT_EQ(reverse_node->input_size(), 2); EXPECT_EQ(NodeName(reverse_node->input(0)), "Placeholder"); + ASSERT_EQ(transpose_node->input_size(), 2); EXPECT_EQ(NodeName(transpose_node->input(0)), reverse_node->name()); + ASSERT_EQ(cast_node->input_size(), 1); EXPECT_EQ(NodeName(cast_node->input(0)), transpose_node->name()); auto tensors = EvaluateNodes(item.graph, item.fetch, {{"Placeholder", input_t}}); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } -TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_CheckNumericsToIdentity) { +TEST_F(ArithmeticOptimizerTest, ReorderTransposeCastCheckNumericsToIdentity) { tensorflow::Scope s = tensorflow::Scope::NewRootScope().WithDevice("/CPU:0"); Output nhwc_uint8 = ops::Placeholder(s, DT_UINT8, ops::Placeholder::Shape({8, 28, 28, 3})); @@ -1334,7 +1366,7 @@ TEST_F(ArithmeticOptimizerTest, ReorderTransposeCast_CheckNumericsToIdentity) { CompareGraphs(item.graph, output); } -TEST_F(ArithmeticOptimizerTest, NoReorderTransposeCast_ProducerIsCast) { +TEST_F(ArithmeticOptimizerTest, NoReorderTransposeCastProducerIsCast) { tensorflow::Scope s = tensorflow::Scope::NewRootScope().WithDevice("/CPU:0"); Output nhwc_fp32 = ops::Placeholder(s, DT_FLOAT, ops::Placeholder::Shape({8, 28, 28, 3})); @@ -1352,7 +1384,7 @@ TEST_F(ArithmeticOptimizerTest, NoReorderTransposeCast_ProducerIsCast) { CompareGraphs(item.graph, output); } -TEST_F(ArithmeticOptimizerTest, NoReorderTransposeCast_ProducerIsTranspose) { +TEST_F(ArithmeticOptimizerTest, NoReorderTransposeCastProducerIsTranspose) { tensorflow::Scope s = tensorflow::Scope::NewRootScope().WithDevice("/CPU:0"); Output nhwc_uint8 = ops::Placeholder(s, DT_UINT8, ops::Placeholder::Shape({8, 28, 28, 3})); @@ -1425,7 +1457,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveIdentityTransposesMultipleOutputs) { auto x_t = GenerateRandomTensor(TensorShape({8, 12, 28, 28})); item.feed = {{"inputs", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1434,6 +1466,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveIdentityTransposesMultipleOutputs) { for (const NodeDef& node : output.node()) { if (node.op() == "Concat") { + ASSERT_EQ(node.input_size(), 3); EXPECT_EQ(node.input(0), "Split"); EXPECT_EQ(node.input(1), "Split:1"); EXPECT_EQ(node.input(2), "Split:2"); @@ -1441,8 +1474,8 @@ TEST_F(ArithmeticOptimizerTest, RemoveIdentityTransposesMultipleOutputs) { } auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, RemoveTransposesWithControlDependency) { @@ -1462,7 +1495,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveTransposesWithControlDependency) { auto x_t = GenerateRandomTensor(TensorShape({2, 3})); item.feed = {{"Placeholder", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1471,13 +1504,13 @@ TEST_F(ArithmeticOptimizerTest, RemoveTransposesWithControlDependency) { NodeMap node_map(&output); const NodeDef* outputs_node = node_map.GetNode("outputs"); - EXPECT_EQ(2, outputs_node->input_size()); + ASSERT_EQ(outputs_node->input_size(), 2); EXPECT_EQ(outputs_node->input(0), "outputs_const"); EXPECT_EQ(outputs_node->input(1), "^Placeholder"); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, NotRemoveTransposes) { @@ -1501,7 +1534,7 @@ TEST_F(ArithmeticOptimizerTest, NotRemoveTransposes) { EnableOnlyRemoveIdentityTranspose(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); - EXPECT_EQ(6, output.node_size()); + EXPECT_EQ(output.node_size(), 6); } TEST_F(ArithmeticOptimizerTest, RemoveIdentityTransposesThroughChain) { @@ -1532,12 +1565,12 @@ TEST_F(ArithmeticOptimizerTest, RemoveIdentityTransposesThroughChain) { for (const NodeDef& node : output.node()) { nodes_after_optimization.insert(node.name()); if (node.name() == "id") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("inputs", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "inputs"); } if (node.name() == "id1") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("id", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "id"); } } EXPECT_EQ(nodes_after_optimization, @@ -1579,12 +1612,13 @@ TEST_F(ArithmeticOptimizerTest, FoldMulToTransposeConv) { const NodeDef* folded_conv_weights = node_map.GetNode(folded_conv->input(1)); ASSERT_NE(folded_conv_weights, nullptr); - EXPECT_EQ("Mul", folded_conv_weights->op()); + EXPECT_EQ(folded_conv_weights->op(), "Mul"); // Its input should be a transpose of `inputs`. const NodeDef* transpose = node_map.GetNode(NodeName(folded_conv->input(0))); ASSERT_NE(transpose, nullptr); - EXPECT_EQ("inputs", transpose->input(0)); + ASSERT_EQ(transpose->input_size(), 2); + EXPECT_EQ(transpose->input(0), "inputs"); } TEST_F(ArithmeticOptimizerTest, NotFoldMulAcrossPreservedTranspose) { @@ -1623,6 +1657,8 @@ TEST_F(ArithmeticOptimizerTest, NotFoldMulAcrossPreservedTranspose) { NodeMap node_map(&output); const NodeDef* inputs_nchw_node_def = node_map.GetNode(inputs_nchw.node()->name()); + ASSERT_NE(inputs_nchw_node_def, nullptr); + ASSERT_EQ(inputs_nchw_node_def->input_size(), 2); EXPECT_EQ(NodeName(inputs_nchw_node_def->input(0)), scaled_inputs.node()->name()); } @@ -1653,8 +1689,13 @@ TEST_F(ArithmeticOptimizerTest, FoldMulToConv) { NodeMap node_map(&output); // `conv` is now a folded convolution on `inputs` and scaled weights. const NodeDef* folded_conv = node_map.GetNode(conv.node()->name()); - CHECK_EQ(inputs.node()->name(), NodeName(folded_conv->input(0))); - CHECK_EQ(node_map.GetNode(NodeName(folded_conv->input(1)))->op(), "Mul"); + ASSERT_NE(folded_conv, nullptr); + ASSERT_EQ(folded_conv->input_size(), 2); + CHECK_EQ(NodeName(folded_conv->input(0)), inputs.node()->name()); + const NodeDef* folded_conv_input_1 = + node_map.GetNode(NodeName(folded_conv->input(1))); + ASSERT_NE(folded_conv_input_1, nullptr); + CHECK_EQ(folded_conv_input_1->op(), "Mul"); } TEST_F(ArithmeticOptimizerTest, OptimizeCastMulTransposeConv) { @@ -1691,8 +1732,8 @@ TEST_F(ArithmeticOptimizerTest, OptimizeCastMulTransposeConv) { // Expected names for reordered cast and transpose. const string p = "ArithmeticOptimizer/ReorderCastLikeAndValuePreserving_"; - const string optimized_cast_name = strings::StrCat(p, "float_Cast"); - const string optimized_transpose_name = strings::StrCat(p, "uint8_Transpose"); + const string optimized_cast_name = absl::StrCat(p, "float_Cast"); + const string optimized_transpose_name = absl::StrCat(p, "uint8_Transpose"); // Expected names for folded multiply and conv. const string optimized_weights = @@ -1712,8 +1753,11 @@ TEST_F(ArithmeticOptimizerTest, OptimizeCastMulTransposeConv) { ASSERT_NE(conv_node, nullptr); EXPECT_EQ(output.node_size(), 7); + ASSERT_EQ(transpose_node->input_size(), 2); EXPECT_EQ(transpose_node->input(0), inputs_node->name()); + ASSERT_EQ(cast_node->input_size(), 1); EXPECT_EQ(cast_node->input(0), transpose_node->name()); + ASSERT_EQ(conv_node->input_size(), 2); EXPECT_EQ(conv_node->input(0), cast_node->name()); EXPECT_EQ(conv_node->input(1), weights_node->name()); } @@ -1747,7 +1791,7 @@ TEST_F(ArithmeticOptimizerTest, OptimizeMultipleMulTransposeConv) { NodeMap node_map(&output); - using strings::StrCat; + using absl::StrCat; const string p = "ArithmeticOptimizer/FoldMultiplyIntoConv_"; const string optimized_weights = StrCat(p, "scaled_Conv2D_weights"); const string optimized_weights_1 = StrCat(p, "scaled_Conv2D_1_weights_1"); @@ -1762,6 +1806,8 @@ TEST_F(ArithmeticOptimizerTest, OptimizeMultipleMulTransposeConv) { ASSERT_NE(conv_node, nullptr); ASSERT_NE(conv_node_1, nullptr); + ASSERT_EQ(conv_node->input_size(), 2); + ASSERT_EQ(conv_node_1->input_size(), 2); EXPECT_EQ(conv_node->input(1), weights_node->name()); EXPECT_EQ(conv_node_1->input(1), weights_node_1->name()); } @@ -1781,7 +1827,7 @@ TEST_F(ArithmeticOptimizerTest, CombineBitcasts) { auto x_t = GenerateRandomTensor(TensorShape({2, 3})); item.feed = {{"inputs", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1791,13 +1837,13 @@ TEST_F(ArithmeticOptimizerTest, CombineBitcasts) { NodeMap node_map(&output); // Bitcasts combined into a single op and inputs redirected to updated Bitcast - EXPECT_EQ(3, output.node_size()); - EXPECT_EQ(1, CountOpNodes(output, "Bitcast")); + EXPECT_EQ(output.node_size(), 3); + EXPECT_EQ(CountOpNodes(output, "Bitcast"), 1); EXPECT_TRUE(IsNodesDirectlyConnected(node_map, "inputs", "bc2")); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } TEST_F(ArithmeticOptimizerTest, CombineAndRemoveBitcasts) { @@ -1815,7 +1861,7 @@ TEST_F(ArithmeticOptimizerTest, CombineAndRemoveBitcasts) { auto x_t = GenerateRandomTensor(TensorShape({2, 3})); item.feed = {{"inputs", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1825,13 +1871,13 @@ TEST_F(ArithmeticOptimizerTest, CombineAndRemoveBitcasts) { NodeMap node_map(&output); // Bitcasts removed and inputs redirected to outputs - EXPECT_EQ(2, output.node_size()); - EXPECT_EQ(0, CountOpNodes(output, "Bitcast")); + EXPECT_EQ(output.node_size(), 2); + EXPECT_EQ(CountOpNodes(output, "Bitcast"), 0); EXPECT_TRUE(IsNodesDirectlyConnected(node_map, "inputs", "outputs")); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } TEST_F(ArithmeticOptimizerTest, RemoveRedundantCast) { @@ -1848,7 +1894,7 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantCast) { auto x_t = GenerateRandomTensor(TensorShape({2, 3})); item.feed = {{"inputs", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, item.feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1858,16 +1904,16 @@ TEST_F(ArithmeticOptimizerTest, RemoveRedundantCast) { NodeMap node_map(&output); // Cast removed and inputs redirected to outputs - EXPECT_EQ(2, output.node_size()); - EXPECT_EQ(0, CountOpNodes(output, "Cast")); + EXPECT_EQ(output.node_size(), 2); + EXPECT_EQ(CountOpNodes(output, "Cast"), 0); EXPECT_TRUE(IsNodesDirectlyConnected(node_map, "inputs", "outputs")); auto tensors = EvaluateNodes(output, item.fetch, item.feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } -TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfIdenticalShape) { +TEST_F(ArithmeticOptimizerTest, AddOpsRewriteAddOpsOfIdenticalShape) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); tensorflow::Scope sx = s.NewSubScope("x"); tensorflow::Scope sy = s.NewSubScope("y"); @@ -1890,7 +1936,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfIdenticalShape) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1905,7 +1951,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfIdenticalShape) { // + c --> AddN(a, b, c) // / \ // a b - EXPECT_EQ(5, output.node_size()); + EXPECT_EQ(output.node_size(), 5); NodeMap node_map(&output); @@ -1914,24 +1960,24 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfIdenticalShape) { node_map.GetNode("y/ArithmeticOptimizer/AddOpsRewrite_Add_abc"); ASSERT_NE(collapsed_add, nullptr); - EXPECT_EQ("AddN", collapsed_add->op()); - EXPECT_EQ(3, collapsed_add->input_size()); - EXPECT_EQ("a", collapsed_add->input(0)); - EXPECT_EQ("b", collapsed_add->input(1)); - EXPECT_EQ("c", collapsed_add->input(2)); + EXPECT_EQ(collapsed_add->op(), "AddN"); + ASSERT_EQ(collapsed_add->input_size(), 3); + EXPECT_EQ(collapsed_add->input(0), "a"); + EXPECT_EQ(collapsed_add->input(1), "b"); + EXPECT_EQ(collapsed_add->input(2), "c"); // check output was re-wired to new node const NodeDef* updated_outputs = node_map.GetNode("outputs"); ASSERT_NE(updated_outputs, nullptr); - - EXPECT_EQ(collapsed_add->name(), updated_outputs->input(0)); + ASSERT_EQ(updated_outputs->input_size(), 1); + EXPECT_EQ(updated_outputs->input(0), collapsed_add->name()); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MultiplePasses) { +TEST_F(ArithmeticOptimizerTest, AddOpsRewriteMultiplePasses) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto a = ops::Variable(s.WithOpName("a"), {2, 2}, DT_FLOAT); @@ -1962,7 +2008,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MultiplePasses) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}, {"x", x_t}, {"y", y_t}, {"z", z_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -1979,7 +2025,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MultiplePasses) { // + c x + --> AddN(a, b, c) AddN(x, y, z)) // / \ / \ // a b y z - EXPECT_EQ(10, output.node_size()); + EXPECT_EQ(output.node_size(), 10); NodeMap node_map(&output); @@ -1988,38 +2034,38 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MultiplePasses) { node_map.GetNode("ArithmeticOptimizer/AddOpsRewrite_Add_abc"); ASSERT_NE(collapsed_left, nullptr); - EXPECT_EQ("AddN", collapsed_left->op()); - EXPECT_EQ(3, collapsed_left->input_size()); - EXPECT_EQ("a", collapsed_left->input(0)); - EXPECT_EQ("b", collapsed_left->input(1)); - EXPECT_EQ("c", collapsed_left->input(2)); + EXPECT_EQ(collapsed_left->op(), "AddN"); + ASSERT_EQ(collapsed_left->input_size(), 3); + EXPECT_EQ(collapsed_left->input(0), "a"); + EXPECT_EQ(collapsed_left->input(1), "b"); + EXPECT_EQ(collapsed_left->input(2), "c"); // check right Add subtree replaced with AddN const NodeDef* collapsed_right = node_map.GetNode("ArithmeticOptimizer/AddOpsRewrite_Add_xyz"); ASSERT_NE(collapsed_right, nullptr); - EXPECT_EQ("AddN", collapsed_right->op()); - EXPECT_EQ(3, collapsed_right->input_size()); - EXPECT_EQ("x", collapsed_right->input(0)); - EXPECT_EQ("y", collapsed_right->input(1)); - EXPECT_EQ("z", collapsed_right->input(2)); + EXPECT_EQ(collapsed_right->op(), "AddN"); + ASSERT_EQ(collapsed_right->input_size(), 3); + EXPECT_EQ(collapsed_right->input(0), "x"); + EXPECT_EQ(collapsed_right->input(1), "y"); + EXPECT_EQ(collapsed_right->input(2), "z"); // check that Mul inputs re-wired to new Nodes const NodeDef* updated_mul = node_map.GetNode("Mul"); ASSERT_NE(updated_mul, nullptr); - EXPECT_EQ("Mul", updated_mul->op()); - EXPECT_EQ(2, updated_mul->input_size()); - EXPECT_EQ(collapsed_left->name(), updated_mul->input(0)); - EXPECT_EQ(collapsed_right->name(), updated_mul->input(1)); + EXPECT_EQ(updated_mul->op(), "Mul"); + ASSERT_EQ(updated_mul->input_size(), 2); + EXPECT_EQ(updated_mul->input(0), collapsed_left->name()); + EXPECT_EQ(updated_mul->input(1), collapsed_right->name()); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddInputMultipleTimes) { +TEST_F(ArithmeticOptimizerTest, AddOpsRewriteAddInputMultipleTimes) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto a = ops::Variable(s.WithOpName("a"), {2, 2}, DT_FLOAT); @@ -2040,7 +2086,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddInputMultipleTimes) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2055,7 +2101,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddInputMultipleTimes) { // + + --> AddN(a, b, b, c) // / \ / \ ^ // a b c b added twice! - EXPECT_EQ(5, output.node_size()); + EXPECT_EQ(output.node_size(), 5); NodeMap node_map(&output); @@ -2064,19 +2110,19 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddInputMultipleTimes) { node_map.GetNode("ArithmeticOptimizer/AddOpsRewrite_Add_all"); ASSERT_NE(collapsed_add, nullptr); - EXPECT_EQ("AddN", collapsed_add->op()); - EXPECT_EQ(4, collapsed_add->input_size()); - EXPECT_EQ("a", collapsed_add->input(0)); - EXPECT_EQ("b", collapsed_add->input(1)); - EXPECT_EQ("b", collapsed_add->input(2)); - EXPECT_EQ("c", collapsed_add->input(3)); + EXPECT_EQ(collapsed_add->op(), "AddN"); + ASSERT_EQ(collapsed_add->input_size(), 4); + EXPECT_EQ(collapsed_add->input(0), "a"); + EXPECT_EQ(collapsed_add->input(1), "b"); + EXPECT_EQ(collapsed_add->input(2), "b"); + EXPECT_EQ(collapsed_add->input(3), "c"); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfSymbolicallyEqualShape) { +TEST_F(ArithmeticOptimizerTest, AddOpsRewriteAddOpsOfSymbolicallyEqualShape) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); // unknown input shape propagated symbolically through the graph @@ -2100,7 +2146,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfSymbolicallyEqualShape) { auto x_t = GenerateRandomTensor(TensorShape({2, 2})); std::vector> feed = {{"input", x_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2115,7 +2161,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfSymbolicallyEqualShape) { // + c --> AddN(a, b, c) // / \ // a b - EXPECT_EQ(6, output.node_size()); + EXPECT_EQ(output.node_size(), 6); NodeMap node_map(&output); @@ -2123,23 +2169,24 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_AddOpsOfSymbolicallyEqualShape) { const NodeDef* collapsed_add = node_map.GetNode("ArithmeticOptimizer/AddOpsRewrite_Add_abc"); ASSERT_NE(collapsed_add, nullptr); - EXPECT_EQ("AddN", collapsed_add->op()); - EXPECT_EQ(3, collapsed_add->input_size()); - EXPECT_EQ("a", collapsed_add->input(0)); - EXPECT_EQ("b", collapsed_add->input(1)); - EXPECT_EQ("c", collapsed_add->input(2)); + EXPECT_EQ(collapsed_add->op(), "AddN"); + ASSERT_EQ(collapsed_add->input_size(), 3); + EXPECT_EQ(collapsed_add->input(0), "a"); + EXPECT_EQ(collapsed_add->input(1), "b"); + EXPECT_EQ(collapsed_add->input(2), "c"); // check output was re-wired to new node const NodeDef* updated_outputs = node_map.GetNode("outputs"); ASSERT_NE(updated_outputs, nullptr); - EXPECT_EQ(collapsed_add->name(), updated_outputs->input(0)); + ASSERT_EQ(updated_outputs->input_size(), 1); + EXPECT_EQ(updated_outputs->input(0), collapsed_add->name()); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCast) { +TEST_F(ArithmeticOptimizerTest, AddOpsRewriteMinimizeBCast) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto a = ops::Variable(s.WithOpName("a"), {32}, DT_FLOAT); @@ -2170,7 +2217,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCast) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}, {"x", x_t}, {"y", y_t}, {"z", z_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2189,7 +2236,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCast) { // + c x + --> AddN(a, x) AddN(b, y) // / \ / \ // a b y z - EXPECT_EQ(12, output.node_size()); + EXPECT_EQ(output.node_size(), 12); NodeMap node_map(&output); // expected names of outer and inner nodes @@ -2203,54 +2250,55 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCast) { // Add [a, x] first const NodeDef* add_ax_node = node_map.GetNode(inner_0_add_name); ASSERT_NE(add_ax_node, nullptr); - EXPECT_EQ("AddN", add_ax_node->op()); - EXPECT_EQ(2, add_ax_node->input_size()); - EXPECT_EQ("a", add_ax_node->input(0)); - EXPECT_EQ("x", add_ax_node->input(1)); + EXPECT_EQ(add_ax_node->op(), "AddN"); + ASSERT_EQ(add_ax_node->input_size(), 2); + EXPECT_EQ(add_ax_node->input(0), "a"); + EXPECT_EQ(add_ax_node->input(1), "x"); // Then add [b, y] const NodeDef* add_by_node = node_map.GetNode(inner_1_add_name); ASSERT_NE(add_by_node, nullptr); - EXPECT_EQ("AddN", add_by_node->op()); - EXPECT_EQ(2, add_by_node->input_size()); - EXPECT_EQ("b", add_by_node->input(0)); - EXPECT_EQ("y", add_by_node->input(1)); + EXPECT_EQ(add_by_node->op(), "AddN"); + ASSERT_EQ(2, add_by_node->input_size()); + EXPECT_EQ(add_by_node->input(0), "b"); + EXPECT_EQ(add_by_node->input(1), "y"); // Then add [c, z] const NodeDef* add_cz_node = node_map.GetNode(inner_2_add_name); ASSERT_NE(add_cz_node, nullptr); - EXPECT_EQ("AddN", add_cz_node->op()); - EXPECT_EQ(2, add_cz_node->input_size()); - EXPECT_EQ("c", add_cz_node->input(0)); - EXPECT_EQ("z", add_cz_node->input(1)); + EXPECT_EQ(add_cz_node->op(), "AddN"); + ASSERT_EQ(add_cz_node->input_size(), 2); + EXPECT_EQ(add_cz_node->input(0), "c"); + EXPECT_EQ(add_cz_node->input(1), "z"); // Then add results together starting from smaller shapes [a, x] + [b, y] const NodeDef* outer_0_node = node_map.GetNode(outer_0_add_name); ASSERT_NE(outer_0_node, nullptr); - EXPECT_EQ("Add", outer_0_node->op()); - EXPECT_EQ(2, outer_0_node->input_size()); - EXPECT_EQ(inner_0_add_name, outer_0_node->input(0)); - EXPECT_EQ(inner_1_add_name, outer_0_node->input(1)); + EXPECT_EQ(outer_0_node->op(), "Add"); + ASSERT_EQ(outer_0_node->input_size(), 2); + EXPECT_EQ(outer_0_node->input(0), inner_0_add_name); + EXPECT_EQ(outer_0_node->input(1), inner_1_add_name); // And finally top level Add node const NodeDef* outer_node = node_map.GetNode(outer_add_name); ASSERT_NE(outer_node, nullptr); - EXPECT_EQ("Add", outer_node->op()); - EXPECT_EQ(2, outer_node->input_size()); - EXPECT_EQ(outer_0_add_name, outer_node->input(0)); - EXPECT_EQ(inner_2_add_name, outer_node->input(1)); + EXPECT_EQ(outer_node->op(), "Add"); + ASSERT_EQ(outer_node->input_size(), 2); + EXPECT_EQ(outer_node->input(0), outer_0_add_name); + EXPECT_EQ(outer_node->input(1), inner_2_add_name); // And outputs reading new top level Add node const NodeDef* updated_outputs = node_map.GetNode("outputs"); ASSERT_NE(updated_outputs, nullptr); - EXPECT_EQ(outer_add_name, updated_outputs->input(0)); + ASSERT_EQ(updated_outputs->input_size(), 1); + EXPECT_EQ(updated_outputs->input(0), outer_add_name); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } -TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCastWithSymbolicShapes) { +TEST_F(ArithmeticOptimizerTest, AddOpsRewriteMinimizeBCastWithSymbolicShapes) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); // We have a small input with one unknown dimension @@ -2281,7 +2329,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCastWithSymbolicShapes) { auto v_t = GenerateRandomTensor(TensorShape({1, 32, 32})); std::vector> feed = {{"small", s_t}, {"v", v_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2296,7 +2344,7 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCastWithSymbolicShapes) { // + c --> + b // / \ / \ // a b a c - EXPECT_EQ(9, output.node_size()); + EXPECT_EQ(output.node_size(), 9); NodeMap node_map(&output); // expected names of outer and inner nodes @@ -2306,25 +2354,27 @@ TEST_F(ArithmeticOptimizerTest, AddOpsRewrite_MinimizeBCastWithSymbolicShapes) { // outer Add node const NodeDef* outer_add = node_map.GetNode(outer_add_name); ASSERT_NE(outer_add, nullptr); - EXPECT_EQ("Add", outer_add->op()); - EXPECT_EQ(inner_add_name, outer_add->input(0)); - EXPECT_EQ("b", outer_add->input(1)); + EXPECT_EQ(outer_add->op(), "Add"); + ASSERT_EQ(outer_add->input_size(), 2); + EXPECT_EQ(outer_add->input(0), inner_add_name); + EXPECT_EQ(outer_add->input(1), "b"); // inner AddN node const NodeDef* inner_add = node_map.GetNode(inner_add_name); ASSERT_NE(inner_add, nullptr); - EXPECT_EQ(2, inner_add->input_size()); - EXPECT_EQ("a", inner_add->input(0)); - EXPECT_EQ("c", inner_add->input(1)); + ASSERT_EQ(inner_add->input_size(), 2); + EXPECT_EQ(inner_add->input(0), "a"); + EXPECT_EQ(inner_add->input(1), "c"); // check output was re-wired to new node const NodeDef* updated_outputs = node_map.GetNode("outputs"); ASSERT_NE(updated_outputs, nullptr); - EXPECT_EQ(outer_add_name, updated_outputs->input(0)); + ASSERT_EQ(updated_outputs->input_size(), 1); + EXPECT_EQ(updated_outputs->input(0), outer_add_name); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, RemoveNegation) { @@ -2358,61 +2408,61 @@ TEST_F(ArithmeticOptimizerTest, RemoveNegation) { auto y_t = GenerateRandomTensor(TensorShape({2, 2})); std::vector> feed = {{"x", x_t}, {"y", y_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyRemoveNegation(&optimizer); OptimizeTwice(&optimizer, &item, &output); - EXPECT_EQ(item.graph.node_size(), output.node_size()); + EXPECT_EQ(output.node_size(), item.graph.node_size()); int found = 0; for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "Add_negx_y") { ++found; - EXPECT_EQ("Sub", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("y", node.input(0)); - EXPECT_EQ("x", node.input(1)); + EXPECT_EQ(node.op(), "Sub"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "y"); + EXPECT_EQ(node.input(1), "x"); } else if (node.name() == "Add_x_negy") { ++found; - EXPECT_EQ("Sub", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); - EXPECT_EQ("y", node.input(1)); + EXPECT_EQ(node.op(), "Sub"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); + EXPECT_EQ(node.input(1), "y"); } else if (node.name() == "Add_negx_negy") { ++found; - EXPECT_EQ("Sub", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("Neg_x", node.input(0)); - EXPECT_EQ("y", node.input(1)); + EXPECT_EQ(node.op(), "Sub"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "Neg_x"); + EXPECT_EQ(node.input(1), "y"); } else if (node.name() == "Sub_x_negy") { ++found; - EXPECT_EQ("Add", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); - EXPECT_EQ("y", node.input(1)); + EXPECT_EQ(node.op(), "Add"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); + EXPECT_EQ(node.input(1), "y"); } else if (node.name() == "Sub_negx_negy") { ++found; - EXPECT_EQ("Sub", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("y", node.input(0)); - EXPECT_EQ("x", node.input(1)); + EXPECT_EQ(node.op(), "Sub"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "y"); + EXPECT_EQ(node.input(1), "x"); } else if (node.name() == "Add_negx_with_dep_y") { ++found; - EXPECT_EQ("Sub", node.op()); - EXPECT_EQ(3, node.input_size()); - EXPECT_EQ("y", node.input(0)); - EXPECT_EQ("x", node.input(1)); - EXPECT_EQ("^Add_x_y", node.input(2)); + EXPECT_EQ(node.op(), "Sub"); + ASSERT_EQ(node.input_size(), 3); + EXPECT_EQ(node.input(0), "y"); + EXPECT_EQ(node.input(1), "x"); + EXPECT_EQ(node.input(2), "^Add_x_y"); } } - EXPECT_EQ(6, found); + EXPECT_EQ(found, 6); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, ConvertSqrtDivToRsqrtMul) { @@ -2426,28 +2476,28 @@ TEST_F(ArithmeticOptimizerTest, ConvertSqrtDivToRsqrtMul) { item.fetch = {"output"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlySqrtDivToRsqrtMul(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); - EXPECT_EQ(item.graph.node_size(), output.node_size()); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); + EXPECT_EQ(output.node_size(), item.graph.node_size()); for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "output") { - EXPECT_EQ("Mul", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); - EXPECT_EQ("sqrt_y", node.input(1)); + EXPECT_EQ(node.op(), "Mul"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); + EXPECT_EQ(node.input(1), "sqrt_y"); } else if (node.name() == "sqrt_y") { - EXPECT_EQ("Rsqrt", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("y", node.input(0)); + EXPECT_EQ(node.op(), "Rsqrt"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "y"); } } } @@ -2465,31 +2515,31 @@ TEST_F(ArithmeticOptimizerTest, DoNotConvertSqrtDivToRsqrtMulDivisorFetchNode) { item.fetch = {"grad", "output0"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - ASSERT_EQ(2, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 2); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlySqrtDivToRsqrtMul(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); auto tensors = EvaluateNodes(output, item.fetch); - ASSERT_EQ(2, tensors.size()); + ASSERT_EQ(tensors.size(), 2); for (int i = 0; i < tensors.size(); i++) { EXPECT_EQ(tensors[i].NumElements(), tensors_expected[i].NumElements()); - test::ExpectTensorNear(tensors_expected[i], tensors[i], 1e-6); + test::ExpectTensorNear(tensors[i], tensors_expected[i], 1e-6); } - EXPECT_EQ(item.graph.node_size(), output.node_size()); + EXPECT_EQ(output.node_size(), item.graph.node_size()); for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "grad") { - EXPECT_EQ("Div", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("mul1", node.input(0)); - EXPECT_EQ("output0", node.input(1)); + EXPECT_EQ(node.op(), "Div"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "mul1"); + EXPECT_EQ(node.input(1), "output0"); } else if (node.name() == "output0") { - EXPECT_EQ("Sqrt", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("floats", node.input(0)); + EXPECT_EQ(node.op(), "Sqrt"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "floats"); } } } @@ -2505,28 +2555,28 @@ TEST_F(ArithmeticOptimizerTest, FuseSquaredDiff) { item.fetch = {"output"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); const auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyFuseSquaredDiff(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); const auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); - EXPECT_EQ(item.graph.node_size(), output.node_size()); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); + EXPECT_EQ(output.node_size(), item.graph.node_size()); for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "output") { - EXPECT_EQ("Identity", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("sub_x_y", node.input(0)); + EXPECT_EQ(node.op(), "Identity"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "sub_x_y"); } else if (node.name() == "sub_x_y") { - EXPECT_EQ("SquaredDifference", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); - EXPECT_EQ("y", node.input(1)); + EXPECT_EQ(node.op(), "SquaredDifference"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); + EXPECT_EQ(node.input(1), "y"); } } } @@ -2542,31 +2592,31 @@ TEST_F(ArithmeticOptimizerTest, DoNotFuseSquaredDiffFetchNode) { item.fetch = {"output", "sub_x_y"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); const auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - ASSERT_EQ(2, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 2); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyFuseSquaredDiff(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); const auto tensors = EvaluateNodes(output, item.fetch); - ASSERT_EQ(2, tensors.size()); + ASSERT_EQ(tensors.size(), 2); for (int i = 0; i < tensors.size(); i++) { EXPECT_EQ(tensors[i].NumElements(), tensors_expected[i].NumElements()); - test::ExpectTensorNear(tensors_expected[i], tensors[i], 1e-6); + test::ExpectTensorNear(tensors[i], tensors_expected[i], 1e-6); } - EXPECT_EQ(item.graph.node_size(), output.node_size()); + EXPECT_EQ(output.node_size(), item.graph.node_size()); for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "output") { - EXPECT_EQ("Square", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("sub_x_y", node.input(0)); + EXPECT_EQ(node.op(), "Square"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "sub_x_y"); } else if (node.name() == "sub_x_y") { - EXPECT_EQ("Sub", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); - EXPECT_EQ("y", node.input(1)); + EXPECT_EQ(node.op(), "Sub"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); + EXPECT_EQ(node.input(1), "y"); } } } @@ -2581,23 +2631,23 @@ TEST_F(ArithmeticOptimizerTest, ConvertLogSoftmax) { item.fetch = {"output"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); const auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyLogSoftmax(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); const auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); - EXPECT_EQ(item.graph.node_size() - 1, output.node_size()); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); + EXPECT_EQ(output.node_size(), item.graph.node_size() - 1); for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "output") { - EXPECT_EQ("LogSoftmax", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "LogSoftmax"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "x"); } } } @@ -2613,14 +2663,14 @@ TEST_F(ArithmeticOptimizerTest, DoNotConvertLogSoftmaxArgFetchNode) { item.fetch = {"softmax", "final_output"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); const auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - ASSERT_EQ(2, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 2); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyLogSoftmax(&optimizer); OptimizeTwice(&optimizer, &item, &output); const auto tensors = EvaluateNodes(output, item.fetch); - ASSERT_EQ(2, tensors.size()); + ASSERT_EQ(tensors.size(), 2); // Should be a NoOp since we are not allowed to change the output of fetch // nodes. @@ -2628,7 +2678,7 @@ TEST_F(ArithmeticOptimizerTest, DoNotConvertLogSoftmaxArgFetchNode) { for (int i = 0; i < tensors.size(); i++) { EXPECT_EQ(tensors[i].NumElements(), tensors_expected[i].NumElements()); - test::ExpectTensorNear(tensors_expected[i], tensors[i], 1e-6); + test::ExpectTensorNear(tensors[i], tensors_expected[i], 1e-6); } } @@ -2660,14 +2710,14 @@ TEST_F(ArithmeticOptimizerTest, ConvertPow) { "out_1", "out", "out_bcast1", "out_bcast2"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(9, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 9); GraphDef got; ArithmeticOptimizer optimizer; EnableOnlyConvertPow(&optimizer); OptimizeAndPrune(&optimizer, &item, &got); auto tensors = EvaluateNodes(got, item.fetch); - EXPECT_EQ(9, tensors.size()); + ASSERT_EQ(tensors.size(), 9); for (int i = 0; i < tensors.size(); ++i) { EXPECT_EQ(tensors[i].NumElements(), tensors_expected[i].NumElements()); @@ -2708,14 +2758,14 @@ TEST_F(ArithmeticOptimizerTest, Log1p) { item.fetch = {"out1", "out2"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(2, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 2); GraphDef got; ArithmeticOptimizer optimizer; EnableOnlyLog1p(&optimizer); OptimizeAndPrune(&optimizer, &item, &got); auto tensors = EvaluateNodes(got, item.fetch); - EXPECT_EQ(2, tensors.size()); + ASSERT_EQ(tensors.size(), 2); for (int i = 0; i < 2; ++i) { EXPECT_EQ(tensors[i].NumElements(), tensors_expected[i].NumElements()); @@ -2746,14 +2796,14 @@ TEST_F(ArithmeticOptimizerTest, Expm1) { item.fetch = {"out1", "out2"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(2, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 2); GraphDef got; ArithmeticOptimizer optimizer; EnableOnlyExpm1(&optimizer); OptimizeAndPrune(&optimizer, &item, &got); auto tensors = EvaluateNodes(got, item.fetch); - EXPECT_EQ(2, tensors.size()); + ASSERT_EQ(tensors.size(), 2); for (int i = 0; i < 2; ++i) { EXPECT_EQ(tensors[i].NumElements(), tensors_expected[i].NumElements()); @@ -2792,7 +2842,7 @@ TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_SimpleSwap) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2811,17 +2861,19 @@ TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_SimpleSwap) { const NodeDef* mul1_node = node_map.GetNode("mul1"); ASSERT_NE(mul1_node, nullptr); - EXPECT_EQ("a", mul1_node->input(0)); - EXPECT_EQ("c", mul1_node->input(1)); + ASSERT_EQ(mul1_node->input_size(), 2); + EXPECT_EQ(mul1_node->input(0), "a"); + EXPECT_EQ(mul1_node->input(1), "c"); const NodeDef* mul2_node = node_map.GetNode("mul2"); ASSERT_NE(mul2_node, nullptr); - EXPECT_EQ("mul1", mul2_node->input(0)); - EXPECT_EQ("b", mul2_node->input(1)); + ASSERT_EQ(mul2_node->input_size(), 2); + EXPECT_EQ(mul2_node->input(0), "mul1"); + EXPECT_EQ(mul2_node->input(1), "b"); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_FlattenTallGraph) { @@ -2852,7 +2904,7 @@ TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_FlattenTallGraph) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}, {"d", d_t}, {"e", e_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2876,27 +2928,31 @@ TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_FlattenTallGraph) { const NodeDef* mul1_node = node_map.GetNode("mul1"); ASSERT_NE(mul1_node, nullptr); - EXPECT_EQ("a", mul1_node->input(0)); - EXPECT_EQ("c", mul1_node->input(1)); + ASSERT_EQ(mul1_node->input_size(), 2); + EXPECT_EQ(mul1_node->input(0), "a"); + EXPECT_EQ(mul1_node->input(1), "c"); const NodeDef* mul2_node = node_map.GetNode("mul2"); ASSERT_NE(mul2_node, nullptr); - EXPECT_EQ("d", mul2_node->input(0)); - EXPECT_EQ("e", mul2_node->input(1)); + ASSERT_EQ(mul2_node->input_size(), 2); + EXPECT_EQ(mul2_node->input(0), "d"); + EXPECT_EQ(mul2_node->input(1), "e"); const NodeDef* mul3_node = node_map.GetNode("mul3"); ASSERT_NE(mul3_node, nullptr); - EXPECT_EQ("mul1", mul3_node->input(0)); - EXPECT_EQ("mul2", mul3_node->input(1)); + ASSERT_EQ(mul3_node->input_size(), 2); + EXPECT_EQ(mul3_node->input(0), "mul1"); + EXPECT_EQ(mul3_node->input(1), "mul2"); const NodeDef* mul4_node = node_map.GetNode("mul4"); ASSERT_NE(mul4_node, nullptr); - EXPECT_EQ("mul3", mul4_node->input(0)); - EXPECT_EQ("b", mul4_node->input(1)); + ASSERT_EQ(mul4_node->input_size(), 2); + EXPECT_EQ(mul4_node->input(0), "mul3"); + EXPECT_EQ(mul4_node->input(1), "b"); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_BuildTreeUp) { @@ -2925,7 +2981,7 @@ TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_BuildTreeUp) { std::vector> feed = { {"a", a_t}, {"b", b_t}, {"c", c_t}, {"D", d_t}}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch, feed); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -2946,22 +3002,25 @@ TEST_F(ArithmeticOptimizerTest, MinimizeBroadcasts_BuildTreeUp) { const NodeDef* mul1_node = node_map.GetNode("mul2"); ASSERT_NE(mul1_node, nullptr); - EXPECT_EQ("a", mul1_node->input(0)); - EXPECT_EQ("b", mul1_node->input(1)); + ASSERT_EQ(mul1_node->input_size(), 2); + EXPECT_EQ(mul1_node->input(0), "a"); + EXPECT_EQ(mul1_node->input(1), "b"); const NodeDef* mul2_node = node_map.GetNode("mul1"); ASSERT_NE(mul2_node, nullptr); - EXPECT_EQ("mul2", mul2_node->input(0)); - EXPECT_EQ("c", mul2_node->input(1)); + ASSERT_EQ(mul2_node->input_size(), 2); + EXPECT_EQ(mul2_node->input(0), "mul2"); + EXPECT_EQ(mul2_node->input(1), "c"); const NodeDef* mul3_node = node_map.GetNode("mul3"); ASSERT_NE(mul3_node, nullptr); - EXPECT_EQ("D", mul3_node->input(0)); - EXPECT_EQ("mul1", mul3_node->input(1)); + ASSERT_EQ(mul3_node->input_size(), 2); + EXPECT_EQ(mul3_node->input(0), "D"); + EXPECT_EQ(mul3_node->input(1), "mul1"); auto tensors = EvaluateNodes(output, item.fetch, feed); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, HoistCWiseUnaryFromConcat) { @@ -3021,55 +3080,55 @@ TEST_F(ArithmeticOptimizerTest, HoistCWiseUnaryFromConcat) { int found = 0; for (const NodeDef& node : output.node()) { if (node.name() == "concat") { - ASSERT_EQ(4, node.input_size()); - EXPECT_EQ("sin_a", node.input(0)); - EXPECT_EQ("b", node.input(1)); - EXPECT_EQ("c", node.input(2)); - EXPECT_EQ("axis", node.input(3)); + ASSERT_EQ(node.input_size(), 4); + EXPECT_EQ(node.input(0), "sin_a"); + EXPECT_EQ(node.input(1), "b"); + EXPECT_EQ(node.input(2), "c"); + EXPECT_EQ(node.input(3), "axis"); found++; } if (node.name() == "exp_a") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("concat", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "concat"); found++; } if (node.name() == "id") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("exp_a", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "exp_a"); found++; } if (node.name() == "concat2") { - ASSERT_EQ(4, node.input_size()); - EXPECT_EQ("sin_a", node.input(0)); - EXPECT_EQ("b", node.input(1)); - EXPECT_EQ("c", node.input(2)); - EXPECT_EQ("axis", node.input(3)); + ASSERT_EQ(node.input_size(), 4); + EXPECT_EQ(node.input(0), "sin_a"); + EXPECT_EQ(node.input(1), "b"); + EXPECT_EQ(node.input(2), "c"); + EXPECT_EQ(node.input(3), "axis"); found++; } if (node.name() == "exp_a2") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("concat2", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "concat2"); found++; } if (node.name() == "cos_exp_a2") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("exp_a2", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "exp_a2"); found++; } if (node.name() == "id2") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("cos_exp_a2", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "cos_exp_a2"); found++; } } - EXPECT_EQ(7, found); + EXPECT_EQ(found, 7); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(tensors.size(), tensors_expected.size()); + ASSERT_EQ(tensors.size(), tensors_expected.size()); EXPECT_EQ(tensors.size(), item.fetch.size()); for (int i = 0; i < item.fetch.size(); ++i) { - test::ExpectTensorNear(tensors_expected[i], tensors[i], 1e-6); + test::ExpectTensorNear(tensors[i], tensors_expected[i], 1e-6); } } @@ -3132,69 +3191,69 @@ TEST_F(ArithmeticOptimizerTest, HoistCWiseUnaryIntoSplit) { EXPECT_NE(node.name(), "cos_exp_b2"); if (node.name() == "split1") { - ASSERT_EQ(2, node.input_size()); - EXPECT_EQ("axis", node.input(0)); - EXPECT_EQ("ArithmeticOptimizer/_sin_a_split1", node.input(1)); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "axis"); + EXPECT_EQ(node.input(1), "ArithmeticOptimizer/_sin_a_split1"); found++; } if (node.name() == "ArithmeticOptimizer/_sin_a_split1") { - EXPECT_EQ("Sin", node.op()); - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "Sin"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "x"); found++; } if (node.name() == "id_a") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("split1", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "split1"); found++; } if (node.name() == "exp_b") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("split1:1", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "split1:1"); found++; } if (node.name() == "id_b") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("exp_b", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "exp_b"); found++; } if (node.name() == "ArithmeticOptimizer/_exp_a2_split2") { - EXPECT_EQ("Exp", node.op()); - ASSERT_EQ(1, node.input_size()); - ASSERT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "Exp"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "x"); found++; } if (node.name() == "ArithmeticOptimizer/_cos_exp_a2_split2") { - EXPECT_EQ("Cos", node.op()); - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("ArithmeticOptimizer/_exp_a2_split2", node.input(0)); + EXPECT_EQ(node.op(), "Cos"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "ArithmeticOptimizer/_exp_a2_split2"); found++; } if (node.name() == "split2") { - ASSERT_EQ(3, node.input_size()); - EXPECT_EQ("ArithmeticOptimizer/_cos_exp_a2_split2", node.input(0)); - EXPECT_EQ("size_splits2", node.input(1)); - EXPECT_EQ("axis", node.input(2)); + ASSERT_EQ(node.input_size(), 3); + EXPECT_EQ(node.input(0), "ArithmeticOptimizer/_cos_exp_a2_split2"); + EXPECT_EQ(node.input(1), "size_splits2"); + EXPECT_EQ(node.input(2), "axis"); found++; } if (node.name() == "id_a2") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("split2", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "split2"); found++; } if (node.name() == "id_b2") { - ASSERT_EQ(1, node.input_size()); - EXPECT_EQ("split2:1", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "split2:1"); found++; } } - EXPECT_EQ(10, found); + EXPECT_EQ(found, 10); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(tensors.size(), tensors_expected.size()); + ASSERT_EQ(tensors.size(), tensors_expected.size()); EXPECT_EQ(tensors.size(), item.fetch.size()); for (int i = 0; i < item.fetch.size(); ++i) { - test::ExpectTensorNear(tensors_expected[i], tensors[i], 1e-6); + test::ExpectTensorNear(tensors[i], tensors_expected[i], 1e-6); } } @@ -3222,26 +3281,26 @@ TEST_F(ArithmeticOptimizerTest, RemoveIdempotent) { int found = 0; for (const NodeDef& node : output.node()) { if (node.name() == "out1") { - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("sn1", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "sn1"); found++; } else if (node.name() == "out2") { - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("id1", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "id1"); found++; } else if (node.name() == "sn1") { - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("a", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "a"); found++; } } - EXPECT_EQ(3, found); + EXPECT_EQ(found, 3); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(tensors.size(), tensors_expected.size()); + ASSERT_EQ(tensors.size(), tensors_expected.size()); EXPECT_EQ(tensors.size(), item.fetch.size()); for (int i = 0; i < item.fetch.size(); ++i) { - test::ExpectTensorNear(tensors_expected[i], tensors[i], 1e-6); + test::ExpectTensorNear(tensors[i], tensors_expected[i], 1e-6); } } @@ -3284,62 +3343,68 @@ TEST_F(ArithmeticOptimizerTest, RemoveLogicalNot) { int found = 0; for (const NodeDef& node : output.node()) { if (node.name() == "id_not_eq") { - EXPECT_EQ("eq", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "eq"); ++found; } if (node.name() == "id_not_neq") { - EXPECT_EQ("neq", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "neq"); ++found; } if (node.name() == "id_not_lt") { - EXPECT_EQ("lt", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "lt"); ++found; } if (node.name() == "id_not_le") { - EXPECT_EQ("le", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "le"); ++found; } if (node.name() == "id_not_gt") { - EXPECT_EQ("gt", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "gt"); ++found; } if (node.name() == "id_not_ge") { - EXPECT_EQ("ge", node.input(0)); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "ge"); ++found; } if (node.name() == "eq") { - EXPECT_EQ("NotEqual", node.op()); + EXPECT_EQ(node.op(), "NotEqual"); ++found; } if (node.name() == "neq") { - EXPECT_EQ("Equal", node.op()); + EXPECT_EQ(node.op(), "Equal"); ++found; } if (node.name() == "lt") { - EXPECT_EQ("GreaterEqual", node.op()); + EXPECT_EQ(node.op(), "GreaterEqual"); ++found; } if (node.name() == "le") { - EXPECT_EQ("Greater", node.op()); + EXPECT_EQ(node.op(), "Greater"); ++found; } if (node.name() == "gt") { - EXPECT_EQ("LessEqual", node.op()); + EXPECT_EQ(node.op(), "LessEqual"); ++found; } if (node.name() == "ge") { - EXPECT_EQ("Less", node.op()); + EXPECT_EQ(node.op(), "Less"); ++found; } } - EXPECT_EQ(12, found); + EXPECT_EQ(found, 12); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(tensors.size(), tensors_expected.size()); + ASSERT_EQ(tensors.size(), tensors_expected.size()); EXPECT_EQ(tensors.size(), item.fetch.size()); for (int i = 0; i < item.fetch.size(); ++i) { - test::ExpectTensorEqual(tensors_expected[i], tensors[i]); + test::ExpectTensorEqual(tensors[i], tensors_expected[i]); } } @@ -3354,34 +3419,34 @@ TEST_F(ArithmeticOptimizerTest, OptimizeMaxOrMinOfMonotonicElementWise) { item.fetch = {"final_out"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyOptimizeMaxOrMinOfMonotonic(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); - EXPECT_EQ(item.graph.node_size(), output.node_size()); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); + EXPECT_EQ(output.node_size(), item.graph.node_size()); // Check if the inputs are switched int required_node_count = 0; for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "sqrt") { - EXPECT_EQ("Sqrt", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("reduce_max", node.input(0)); + EXPECT_EQ(node.op(), "Sqrt"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "reduce_max"); ++required_node_count; } else if (node.name() == "reduce_max") { - EXPECT_EQ("Max", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "Max"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); ++required_node_count; } } - EXPECT_EQ(2, required_node_count); + EXPECT_EQ(required_node_count, 2); } TEST_F(ArithmeticOptimizerTest, OptimizeArgMaxOrArgMinOfMonotonicElementWise) { @@ -3395,38 +3460,38 @@ TEST_F(ArithmeticOptimizerTest, OptimizeArgMaxOrArgMinOfMonotonicElementWise) { item.fetch = {"final_out"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); const auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyOptimizeMaxOrMinOfMonotonic(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); const auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); - EXPECT_EQ(item.graph.node_size() - 1, output.node_size()); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); + EXPECT_EQ(output.node_size(), item.graph.node_size() - 1); // Check if the inputs are switched int required_node_count = 0; for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "final_out") { - EXPECT_EQ("Identity", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("arg_max", node.input(0)); + EXPECT_EQ(node.op(), "Identity"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "arg_max"); ++required_node_count; } else if (node.name() == "arg_max") { - EXPECT_EQ("ArgMax", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "ArgMax"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); ++required_node_count; } } - EXPECT_EQ(2, required_node_count); + EXPECT_EQ(required_node_count, 2); } TEST_F(ArithmeticOptimizerTest, - OptimizeMaxOrMinOfMonotonicElementWise_DoNotChangeFetchNode) { + OptimizeMaxOrMinOfMonotonicElementWiseDoNotChangeFetchNode) { tensorflow::Scope s = tensorflow::Scope::NewRootScope(); auto x = ops::Const(s.WithOpName("x"), {1.0f, 2.0f}, {1, 2}); Output sqrt = ops::Sqrt(s.WithOpName("sqrt"), x); @@ -3437,7 +3502,7 @@ TEST_F(ArithmeticOptimizerTest, item.fetch = {"sqrt", "final_out"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(2, tensors_expected.size()); + EXPECT_EQ(tensors_expected.size(), 2); GraphDef output; ArithmeticOptimizer optimizer; @@ -3461,7 +3526,7 @@ TEST_F(ArithmeticOptimizerTest, item.fetch = {"z"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - ASSERT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -3473,7 +3538,7 @@ TEST_F(ArithmeticOptimizerTest, VerifyGraphsMatch(item.graph, output, __LINE__); auto tensors = EvaluateNodes(output, item.fetch); - ASSERT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); test::ExpectTensorEqual(tensors[0], tensors_expected[0]); test::ExpectTensorEqual(tensors[0], Tensor(-2)); } @@ -3490,30 +3555,30 @@ TEST_F(ArithmeticOptimizerTest, item.fetch = {"final_out"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyOptimizeMaxOrMinOfMonotonic(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); - EXPECT_EQ(item.graph.node_size(), output.node_size()); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); + EXPECT_EQ(output.node_size(), item.graph.node_size()); // Check if the inputs are switched int required_node_count = 0; for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "neg") { - EXPECT_EQ("Neg", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("reduce_max", node.input(0)); + EXPECT_EQ(node.op(), "Neg"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "reduce_max"); ++required_node_count; } else if (node.name() == "reduce_max") { - EXPECT_EQ("Min", node.op()); - EXPECT_EQ(2, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "Min"); + ASSERT_EQ(node.input_size(), 2); + EXPECT_EQ(node.input(0), "x"); ++required_node_count; } } @@ -3532,7 +3597,7 @@ TEST_F(ArithmeticOptimizerTest, item.fetch = {"max_pool"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - ASSERT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -3543,8 +3608,8 @@ TEST_F(ArithmeticOptimizerTest, VerifyGraphsMatch(item.graph, output, __LINE__); auto tensors = EvaluateNodes(output, item.fetch); - ASSERT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, OptimizeMaxOrMinOfMonotonicElementWiseMaxPool) { @@ -3559,34 +3624,34 @@ TEST_F(ArithmeticOptimizerTest, OptimizeMaxOrMinOfMonotonicElementWiseMaxPool) { item.fetch = {"final_out"}; TF_CHECK_OK(s.ToGraphDef(&item.graph)); auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyOptimizeMaxOrMinOfMonotonic(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); + ASSERT_EQ(tensors.size(), 1); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); - EXPECT_EQ(item.graph.node_size(), output.node_size()); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); + EXPECT_EQ(output.node_size(), item.graph.node_size()); // Check if the inputs are switched int required_node_count = 0; for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "sqrt") { - EXPECT_EQ("Sqrt", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("max_pool", node.input(0)); + EXPECT_EQ(node.op(), "Sqrt"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "max_pool"); ++required_node_count; } else if (node.name() == "max_pool") { - EXPECT_EQ("MaxPool", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "MaxPool"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "x"); ++required_node_count; } } - EXPECT_EQ(2, required_node_count); + EXPECT_EQ(required_node_count, 2); } TEST_F(ArithmeticOptimizerTest, UnaryOpsComposition) { @@ -3608,42 +3673,42 @@ TEST_F(ArithmeticOptimizerTest, UnaryOpsComposition) { } auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; EnableOnlyUnaryOpsComposition(&optimizer); OptimizeAndPrune(&optimizer, &item, &output); - EXPECT_EQ(3, output.node_size()); + EXPECT_EQ(output.node_size(), 3); // Check that Sqrt/Log/Relu were replaced with a single op. int required_node_count = 0; for (int i = 0; i < output.node_size(); ++i) { const NodeDef& node = output.node(i); if (node.name() == "final_out") { - EXPECT_EQ("Identity", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("relu/unary_ops_composition", node.input(0)); + EXPECT_EQ(node.op(), "Identity"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "relu/unary_ops_composition"); ++required_node_count; } else if (node.name() == "relu/unary_ops_composition") { - EXPECT_EQ("_UnaryOpsComposition", node.op()); - EXPECT_EQ(1, node.input_size()); - EXPECT_EQ("x", node.input(0)); + EXPECT_EQ(node.op(), "_UnaryOpsComposition"); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ(node.input(0), "x"); auto op_names = node.attr().at("op_names").list().s(); - EXPECT_EQ(3, op_names.size()); - EXPECT_EQ("Sqrt", op_names[0]); - EXPECT_EQ("Log", op_names[1]); - EXPECT_EQ("Relu", op_names[2]); + ASSERT_EQ(op_names.size(), 3); + EXPECT_EQ(op_names[0], "Sqrt"); + EXPECT_EQ(op_names[1], "Log"); + EXPECT_EQ(op_names[2], "Relu"); ++required_node_count; } } - EXPECT_EQ(2, required_node_count); + EXPECT_EQ(required_node_count, 2); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorNear(tensors_expected[0], tensors[0], 1e-6); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorNear(tensors[0], tensors_expected[0], 1e-6); } TEST_F(ArithmeticOptimizerTest, RemoveStackStridedSliceSameAxis) { @@ -3781,29 +3846,29 @@ TEST_F(ArithmeticOptimizerTest, RemoveStackStridedSliceSameAxis) { auto tensors_expected = EvaluateNodes(item.graph, item.fetch); // stacked[:, 0, :] == a. - test::ExpectTensorEqual(tensors_expected[fA], - tensors_expected[fASliceOut]); + test::ExpectTensorEqual(tensors_expected[fASliceOut], + tensors_expected[fA]); // stacked[:, 1, :] == b. - test::ExpectTensorEqual(tensors_expected[fB], - tensors_expected[fBSliceOut]); + test::ExpectTensorEqual(tensors_expected[fBSliceOut], + tensors_expected[fB]); // stacked[:, 2, :] == c. - test::ExpectTensorEqual(tensors_expected[fC], - tensors_expected[fCSliceOut]); + test::ExpectTensorEqual(tensors_expected[fCSliceOut], + tensors_expected[fC]); // stacked[:, 0:1, :] == expand_dims(a, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedA], - tensors_expected[fASlice01Out]); + test::ExpectTensorEqual(tensors_expected[fASlice01Out], + tensors_expected[fExpandedA]); // stacked[:, :1, :] == expand_dims(a, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedA], - tensors_expected[fASliceTo1Out]); + test::ExpectTensorEqual(tensors_expected[fASliceTo1Out], + tensors_expected[fExpandedA]); // stacked[:, 1:2, :] == expand_dims(b, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedB], - tensors_expected[fBSlice12Out]); + test::ExpectTensorEqual(tensors_expected[fBSlice12Out], + tensors_expected[fExpandedB]); // stacked[:, 2:, :] == expand_dims(c, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedC], - tensors_expected[fCSlice2ToOut]); + test::ExpectTensorEqual(tensors_expected[fCSlice2ToOut], + tensors_expected[fExpandedC]); GraphDef output; ArithmeticOptimizer optimizer; @@ -3812,43 +3877,47 @@ TEST_F(ArithmeticOptimizerTest, RemoveStackStridedSliceSameAxis) { for (const auto& node : output.node()) { if (node.name() == "pa_slice_out") { + ASSERT_EQ(node.input_size(), 1); EXPECT_EQ(node.input(0), "a"); } else if (node.name() == "pb_slice_out") { + ASSERT_EQ(node.input_size(), 1); EXPECT_EQ(node.input(0), "b"); } else if (node.name() == "pc_slice_out") { + ASSERT_EQ(node.input_size(), 1); EXPECT_EQ(node.input(0), "c"); } else if (str_util::EndsWith(node.name(), "_out")) { - EXPECT_EQ(strings::StrCat(node.input(0), "_out"), - strings::StrCat( - "ArithmeticOptimizer/RemoveStackStridedSliceSameAxis_", - node.name())); + ASSERT_EQ(node.input_size(), 1); + EXPECT_EQ( + absl::StrCat(node.input(0), "_out"), + absl::StrCat("ArithmeticOptimizer/RemoveStackStridedSliceSameAxis_", + node.name())); } } auto tensors = EvaluateNodes(output, item.fetch); // stacked[:, 0, :] == a. - test::ExpectTensorEqual(tensors_expected[fA], tensors[fASliceOut]); + test::ExpectTensorEqual(tensors[fASliceOut], tensors_expected[fA]); // stacked[:, 1, :] == b. - test::ExpectTensorEqual(tensors_expected[fB], tensors[fBSliceOut]); + test::ExpectTensorEqual(tensors[fBSliceOut], tensors_expected[fB]); // stacked[:, 2, :] == c. - test::ExpectTensorEqual(tensors_expected[fC], tensors[fCSliceOut]); + test::ExpectTensorEqual(tensors[fCSliceOut], tensors_expected[fC]); // stacked[:, 0:1, :] == expand_dims(a, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedA], - tensors[fASlice01Out]); + test::ExpectTensorEqual(tensors[fASlice01Out], + tensors_expected[fExpandedA]); // stacked[:, :1, :] == expand_dims(a, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedA], - tensors[fASliceTo1Out]); + test::ExpectTensorEqual(tensors[fASliceTo1Out], + tensors_expected[fExpandedA]); // stacked[:, 1:2, :] == expand_dims(b, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedB], - tensors[fBSlice12Out]); + test::ExpectTensorEqual(tensors[fBSlice12Out], + tensors_expected[fExpandedB]); // stacked[:, 2:, :] == expand_dims(c, 1). - test::ExpectTensorEqual(tensors_expected[fExpandedC], - tensors[fCSlice2ToOut]); + test::ExpectTensorEqual(tensors[fCSlice2ToOut], + tensors_expected[fExpandedC]); } TEST_F(ArithmeticOptimizerTest, SimplifyAggregationBFloat16) { @@ -3862,7 +3931,7 @@ TEST_F(ArithmeticOptimizerTest, SimplifyAggregationBFloat16) { TF_CHECK_OK(s.ToGraphDef(&item.graph)); item.fetch = {"id"}; auto tensors_expected = EvaluateNodes(item.graph, item.fetch); - EXPECT_EQ(1, tensors_expected.size()); + ASSERT_EQ(tensors_expected.size(), 1); GraphDef output; ArithmeticOptimizer optimizer; @@ -3870,11 +3939,11 @@ TEST_F(ArithmeticOptimizerTest, SimplifyAggregationBFloat16) { OptimizeAndPrune(&optimizer, &item, &output); // Extra node created for multiplier. - EXPECT_EQ(5, output.node_size()); + EXPECT_EQ(output.node_size(), 5); auto tensors = EvaluateNodes(output, item.fetch); - EXPECT_EQ(1, tensors.size()); - test::ExpectTensorEqual(tensors_expected[0], tensors[0]); + ASSERT_EQ(tensors.size(), 1); + test::ExpectTensorEqual(tensors[0], tensors_expected[0]); } } // namespace grappler