Star659
445
代码
代码
Issues36
Pull Requests116
Actions
项目讨论
Wiki
分析
Star659
445
已合并
feat: 增补UT覆盖率 #4270
likun104创建于 21 天前
feat: 增补UT覆盖率 #4270
已合并
likun104创建于 21 天前
从likun104/gebr_update_coverage_04合入到cann/gedevelop
共 154 个文件变更+14268-204
Mtests/ge/ut/ge/CMakeLists.txt+2-0
@@ -236,6 +236,7 @@ set(PASS_TEST_FILES
236 "graph/passes/subgraph_multi_dims_clone_pass_unittest.cc"236 "graph/passes/subgraph_multi_dims_clone_pass_unittest.cc"
237 "graph/passes/create_subgraph_with_scope_pass_unittest.cc"237 "graph/passes/create_subgraph_with_scope_pass_unittest.cc"
238 "graph/passes/subgraph_const_migration_pass_unittest.cc"238 "graph/passes/subgraph_const_migration_pass_unittest.cc"
239+ "graph/passes/symbolic_cond_remove_pass_unittest.cc"
239 "graph/passes/start_of_sequence_pass_unittest.cc"240 "graph/passes/start_of_sequence_pass_unittest.cc"
240 "graph/passes/replace_with_empty_const_pass_unittest.cc"241 "graph/passes/replace_with_empty_const_pass_unittest.cc"
241 "graph/passes/link_gen_mask_nodes_pass_unittest.cc"242 "graph/passes/link_gen_mask_nodes_pass_unittest.cc"
@@ -1532,6 +1533,7 @@ target_link_libraries(ut_eager_style_builder
1532 aihac_symbolizer1533 aihac_symbolizer
1533 ge_running_env1534 ge_running_env
1534 ge_compiler1535 ge_compiler
1536+ cmd_flag_info_static
1535 GTestShared::gtest GTestShared::gtest_main GTestShared::gmock_main ${COMMON_SHARED_LIBRARIES} -lrt -ldl ${AIR_COMMON_LINK_OPTION}1537 GTestShared::gtest GTestShared::gtest_main GTestShared::gmock_main ${COMMON_SHARED_LIBRARIES} -lrt -ldl ${AIR_COMMON_LINK_OPTION}
1536 -Wl,--no-as-needed GTestShared::gmock -Wl,--as-needed1538 -Wl,--no-as-needed GTestShared::gmock -Wl,--as-needed
1537 ascendcl_stub1539 ascendcl_stub
Mtests/ge/ut/ge/common/custom_ops_kernel_info_store_unittest.cc+107-0
@@ -1913,5 +1913,112 @@ TEST_F(UtestCustomOpsKernelInfoStore, GenerateTaskFailsWhenAnnotatedArgsRejectsP
1913 }1913 }
1914}1914}
1915 1915 
1916+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerInitializeAndFinalize) {
1917+ CustomGraphOptimizer optimizer;
1918+ std::map<std::string, std::string> options;
1919+ EXPECT_EQ(optimizer.Initialize(options, nullptr), SUCCESS);
1920+ EXPECT_EQ(optimizer.Finalize(), SUCCESS);
1921+}
1922+ 
1923+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerOptimizeOriginalGraph) {
1924+ CustomGraphOptimizer optimizer;
1925+ auto graph = std::make_shared<ComputeGraph>("test_graph");
1926+ EXPECT_EQ(optimizer.OptimizeOriginalGraph(*graph), SUCCESS);
1927+}
1928+ 
1929+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerOptimizeFusedGraph) {
1930+ CustomGraphOptimizer optimizer;
1931+ auto graph = std::make_shared<ComputeGraph>("test_graph");
1932+ EXPECT_EQ(optimizer.OptimizeFusedGraph(*graph), SUCCESS);
1933+}
1934+ 
1935+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerOptimizeWholeGraphEmptyGraph) {
1936+ CustomGraphOptimizer optimizer;
1937+ auto graph = std::make_shared<ComputeGraph>("empty_graph");
1938+ EXPECT_EQ(optimizer.OptimizeWholeGraph(*graph), SUCCESS);
1939+}
1940+ 
1941+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerOptimizeWholeGraphNonCustomOp) {
1942+ CustomGraphOptimizer optimizer;
1943+ auto graph = std::make_shared<ComputeGraph>("non_custom_graph");
1944+ auto op_desc = std::make_shared<OpDesc>("non_custom_node", "NonCustomType");
1945+ GeTensorDesc input_desc(GeShape({1, 16}), FORMAT_ND, DT_FLOAT16);
1946+ GeTensorDesc output_desc(GeShape({1, 16}), FORMAT_ND, DT_FLOAT16);
1947+ (void)op_desc->AddInputDesc("x", input_desc);
1948+ (void)op_desc->AddOutputDesc("y", output_desc);
1949+ ASSERT_NE(graph->AddNode(op_desc), nullptr);
1950+ EXPECT_EQ(optimizer.OptimizeWholeGraph(*graph), SUCCESS);
1951+}
1952+ 
1953+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerOptimizeWholeGraphBaseOnlyOp) {
1954+ const std::string kTestOpType = "TestBaseOnlyOp_OptimizerTest";
1955+ auto creator = []() -> std::unique_ptr<BaseCustomOp> { return std::make_unique<MockBaseOnlyCustomOp>(); };
1956+ ASSERT_EQ(CustomOpFactory::RegisterCustomOpCreator(AscendString(kTestOpType.c_str()), creator), GRAPH_SUCCESS);
1957+ 
1958+ auto graph = std::make_shared<ComputeGraph>("base_only_graph");
1959+ auto op_desc = std::make_shared<OpDesc>("base_only_node", kTestOpType);
1960+ GeTensorDesc input_desc(GeShape({1, 16}), FORMAT_ND, DT_FLOAT16);
1961+ GeTensorDesc output_desc(GeShape({1, 16}), FORMAT_ND, DT_FLOAT16);
1962+ (void)op_desc->AddInputDesc("x", input_desc);
1963+ (void)op_desc->AddOutputDesc("y", output_desc);
1964+ ASSERT_NE(graph->AddNode(op_desc), nullptr);
1965+ 
1966+ CustomGraphOptimizer optimizer;
1967+ EXPECT_EQ(optimizer.OptimizeWholeGraph(*graph), SUCCESS);
1968+}
1969+ 
1970+TEST_F(UtestCustomOpsKernelInfoStore, CustomGraphOptimizerGetAttributes) {
1971+ CustomGraphOptimizer optimizer;
1972+ GraphOptimizerAttribute attrs;
1973+ EXPECT_EQ(optimizer.GetAttributes(attrs), SUCCESS);
1974+ EXPECT_EQ(attrs.engineName, "DNN_VM_CUSTOM");
1975+}
1976+ 
1977+TEST_F(UtestCustomOpsKernelInfoStore, CustomOpsKernelBuilderCalcOpRunningParamKnownShape) {
1978+ const std::string kTestOpType = "TestCalcOpRunningParam_KnownShape";
1979+ auto creator = []() -> std::unique_ptr<BaseCustomOp> { return std::make_unique<MockCompilableCustomOp>(); };
1980+ ASSERT_EQ(CustomOpFactory::RegisterCustomOpCreator(AscendString(kTestOpType.c_str()), creator), GRAPH_SUCCESS);
1981+ 
1982+ auto graph = std::make_shared<ComputeGraph>("calc_param_graph");
1983+ auto op_desc = std::make_shared<OpDesc>("calc_param_node", kTestOpType);
1984+ op_desc->AppendIrInput("x", kIrInputRequired);
1985+ op_desc->AppendIrOutput("y", kIrOutputRequired);
1986+ GeTensorDesc input_desc(GeShape({1, 16}), FORMAT_ND, DT_FLOAT16);
1987+ GeTensorDesc output_desc(GeShape({1, 16}), FORMAT_ND, DT_FLOAT16);
1988+ (void)op_desc->AddInputDesc("x", input_desc);
1989+ (void)op_desc->AddOutputDesc("y", output_desc);
1990+ auto node = graph->AddNode(op_desc);
1991+ ASSERT_NE(node, nullptr);
1992+ 
1993+ CustomOpsKernelBuilder builder;
1994+ EXPECT_EQ(builder.CalcOpRunningParam(*node), SUCCESS);
1995+}
1996+ 
1997+TEST_F(UtestCustomOpsKernelInfoStore, CustomOpsKernelBuilderCalcOpRunningParamUnknownShape) {
1998+ const std::string kTestOpType = "TestCalcOpRunningParam_UnknownShape";
1999+ auto creator = []() -> std::unique_ptr<BaseCustomOp> { return std::make_unique<MockCompilableCustomOp>(); };
2000+ ASSERT_EQ(CustomOpFactory::RegisterCustomOpCreator(AscendString(kTestOpType.c_str()), creator), GRAPH_SUCCESS);
2001+ 
2002+ auto graph = std::make_shared<ComputeGraph>("calc_param_graph_unknown");
2003+ auto op_desc = std::make_shared<OpDesc>("calc_param_node_unknown", kTestOpType);
2004+ op_desc->AppendIrInput("x", kIrInputRequired);
2005+ op_desc->AppendIrOutput("y", kIrOutputRequired);
2006+ GeTensorDesc input_desc(GeShape({-1, 16}), FORMAT_ND, DT_FLOAT16);
2007+ GeTensorDesc output_desc(GeShape({-1, 16}), FORMAT_ND, DT_FLOAT16);
2008+ (void)op_desc->AddInputDesc("x", input_desc);
2009+ (void)op_desc->AddOutputDesc("y", output_desc);
2010+ auto node = graph->AddNode(op_desc);
2011+ ASSERT_NE(node, nullptr);
2012+ 
2013+ CustomOpsKernelBuilder builder;
2014+ EXPECT_EQ(builder.CalcOpRunningParam(*node), SUCCESS);
2015+}
2016+ 
2017+TEST_F(UtestCustomOpsKernelInfoStore, CustomOpsKernelBuilderInitializeAndFinalize) {
2018+ CustomOpsKernelBuilder builder;
2019+ std::map<std::string, std::string> options;
2020+ EXPECT_EQ(builder.Initialize(options), SUCCESS);
2021+ EXPECT_EQ(builder.Finalize(), SUCCESS);
2022+}
1916} // namespace custom2023} // namespace custom
1917} // namespace ge2024} // namespace ge
Mtests/ge/ut/ge/common/dataslice_unittest.cc+138-0
@@ -1033,4 +1033,142 @@ TEST_F(DataSlice, Cov_InferDavinciSpecialOpSlice_GetOriOutputFail) {
1033 Status ret = DataSliceHelper::InferDavinciAxisSlice(op_desc, axis_type_info);1033 Status ret = DataSliceHelper::InferDavinciAxisSlice(op_desc, axis_type_info);
1034 EXPECT_EQ(ret, FAILED);1034 EXPECT_EQ(ret, FAILED);
1035}1035}
1036+TEST_F(DataSlice, Cov_TransAxisInfo_NZFormat) {
1037+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1038+ GeTensorDesc input_desc(GeShape({2, 2, 3, 4}), FORMAT_FRACTAL_NZ);
1039+ input_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1040+ input_desc.SetOriginFormat(FORMAT_NCHW);
1041+ op_desc->AddInputDesc("input", input_desc);
1042+ GeTensorDesc output_desc(GeShape({2, 2, 3, 4}), FORMAT_FRACTAL_NZ);
1043+ output_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1044+ output_desc.SetOriginFormat(FORMAT_NCHW);
1045+ op_desc->AddOutputDesc("output", output_desc);
1046+ AxisTypeInfo axis_type_info;
1047+ axis_type_info.SetAxisTypes({AxisType::ELEMENTWISE});
1048+ axis_type_info.SetAxisType(AxisType::ELEMENTWISE);
1049+ axis_type_info.SetRelateInputs({{0, {0}}});
1050+ axis_type_info.SetRelateOutputs({{0, {0}}});
1051+ std::vector<AxisTypeInfo> axis_type_vec = {axis_type_info};
1052+ DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec);
1053+ EXPECT_EQ(axis_type_vec.size(), 1U);
1054+}
1055+ 
1056+TEST_F(DataSlice, Cov_TransAxisInfo_NC1HWC0Format) {
1057+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1058+ GeTensorDesc input_desc(GeShape({2, 1, 3, 4, 16}), FORMAT_NC1HWC0);
1059+ input_desc.SetOriginShape(GeShape({2, 16, 3, 4}));
1060+ input_desc.SetOriginFormat(FORMAT_NCHW);
1061+ op_desc->AddInputDesc("input", input_desc);
1062+ GeTensorDesc output_desc(GeShape({2, 1, 3, 4, 16}), FORMAT_NC1HWC0);
1063+ output_desc.SetOriginShape(GeShape({2, 16, 3, 4}));
1064+ output_desc.SetOriginFormat(FORMAT_NCHW);
1065+ op_desc->AddOutputDesc("output", output_desc);
1066+ AxisTypeInfo axis_type_info;
1067+ axis_type_info.SetAxisTypes({AxisType::ELEMENTWISE});
1068+ axis_type_info.SetAxisType(AxisType::ELEMENTWISE);
1069+ axis_type_info.SetRelateInputs({{0, {1}}});
1070+ axis_type_info.SetRelateOutputs({{0, {1}}});
1071+ std::vector<AxisTypeInfo> axis_type_vec = {axis_type_info};
1072+ DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec);
1073+ EXPECT_EQ(axis_type_vec.size(), 1U);
1074+}
1075+ 
1076+TEST_F(DataSlice, Cov_TransAxisInfo_UnsupportedType) {
1077+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1078+ GeTensorDesc input_desc(GeShape({2, 2, 3, 4}), FORMAT_NCHW);
1079+ input_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1080+ input_desc.SetOriginFormat(FORMAT_NCHW);
1081+ op_desc->AddInputDesc("input", input_desc);
1082+ GeTensorDesc output_desc(GeShape({2, 2, 3, 4}), FORMAT_NCHW);
1083+ output_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1084+ output_desc.SetOriginFormat(FORMAT_NCHW);
1085+ op_desc->AddOutputDesc("output", output_desc);
1086+ AxisTypeInfo axis_type_info;
1087+ axis_type_info.SetAxisTypes({AxisType::UNSPLIT});
1088+ axis_type_info.SetAxisType(AxisType::UNSPLIT);
1089+ axis_type_info.SetRelateInputs({{0, {0}}});
1090+ axis_type_info.SetRelateOutputs({{0, {0}}});
1091+ std::vector<AxisTypeInfo> axis_type_vec = {axis_type_info};
1092+ DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec);
1093+ EXPECT_TRUE(axis_type_vec.empty());
1094+}
1095+ 
1096+TEST_F(DataSlice, Cov_TransAxisInfo_SlidingWindowCombination) {
1097+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1098+ GeTensorDesc input_desc(GeShape({2, 2, 3, 4}), FORMAT_NCHW);
1099+ input_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1100+ input_desc.SetOriginFormat(FORMAT_NCHW);
1101+ op_desc->AddInputDesc("input", input_desc);
1102+ GeTensorDesc output_desc(GeShape({2, 2, 3, 4}), FORMAT_NCHW);
1103+ output_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1104+ output_desc.SetOriginFormat(FORMAT_NCHW);
1105+ op_desc->AddOutputDesc("output", output_desc);
1106+ AxisTypeInfo axis_type_info;
1107+ axis_type_info.SetAxisTypes({AxisType::ELEMENTWISE, AxisType::REDUCESUM});
1108+ axis_type_info.SetAxisType(AxisType::ELEMENTWISE);
1109+ axis_type_info.SetRelateInputs({{0, {0}}});
1110+ axis_type_info.SetRelateOutputs({{0, {0}}});
1111+ std::vector<AxisTypeInfo> axis_type_vec = {axis_type_info};
1112+ DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec);
1113+ EXPECT_EQ(axis_type_vec.size(), 1U);
1114+}
1115+ 
1116+TEST_F(DataSlice, Cov_TransAxisInfo_ReduceTypeMultiAxis) {
1117+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1118+ GeTensorDesc input_desc(GeShape({2, 2, 3, 4}), FORMAT_FRACTAL_NZ);
1119+ input_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1120+ input_desc.SetOriginFormat(FORMAT_NCHW);
1121+ op_desc->AddInputDesc("input", input_desc);
1122+ GeTensorDesc output_desc(GeShape({2, 2, 3, 4}), FORMAT_FRACTAL_NZ);
1123+ output_desc.SetOriginShape(GeShape({2, 2, 3, 4}));
1124+ output_desc.SetOriginFormat(FORMAT_NCHW);
1125+ op_desc->AddOutputDesc("output", output_desc);
1126+ AxisTypeInfo axis_type_info;
1127+ axis_type_info.SetAxisTypes({AxisType::REDUCEMEAN});
1128+ axis_type_info.SetAxisType(AxisType::REDUCEMEAN);
1129+ axis_type_info.SetRelateInputs({{0, {2}}});
1130+ axis_type_info.SetRelateOutputs({{0, {2}}});
1131+ std::vector<AxisTypeInfo> axis_type_vec = {axis_type_info};
1132+ DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec);
1133+ EXPECT_TRUE(axis_type_vec.empty());
1134+}
1135+ 
1136+TEST_F(DataSlice, Cov_GetDavinciSliceInfo_InvalidOriInfo) {
1137+ ComputeGraphPtr test_graph = std::make_shared<ComputeGraph>("test_graph");
1138+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1139+ GeTensorDesc output_desc(GeShape({10, 20}), FORMAT_NCHW);
1140+ output_desc.SetOriginShape(GeShape(std::vector<int64_t>{}));
1141+ output_desc.SetOriginFormat(FORMAT_NCHW);
1142+ op_desc->AddOutputDesc("output", output_desc);
1143+ GeTensorDesc input_desc(GeShape({10, 20}), FORMAT_NCHW);
1144+ input_desc.SetOriginShape(GeShape(std::vector<int64_t>{}));
1145+ input_desc.SetOriginFormat(FORMAT_NCHW);
1146+ op_desc->AddInputDesc("input", input_desc);
1147+ NodePtr node = test_graph->AddNode(op_desc);
1148+ std::vector<AxisTypeInfo> axis_type_info;
1149+ Status ret = DataSliceHelper::GetDavinciSliceInfo(node, axis_type_info);
1150+ EXPECT_EQ(ret, SUCCESS);
1151+ EXPECT_TRUE(axis_type_info.empty());
1152+}
1153+ 
1154+TEST_F(DataSlice, Cov_InferDavinciCommonOpSlice_NullPtr) {
1155+ OpDescPtr op_desc = std::make_shared<OpDesc>("Cast", "Cast");
1156+ GeTensorDesc output_desc(GeShape({10, 20}), FORMAT_NCHW);
1157+ output_desc.SetOriginShape(GeShape({10, 20}));
1158+ output_desc.SetOriginFormat(FORMAT_NCHW);
1159+ op_desc->AddOutputDesc("output", output_desc);
1160+ GeTensorDesc input_desc(GeShape({10, 20}), FORMAT_NCHW);
1161+ input_desc.SetOriginShape(GeShape({10, 20}));
1162+ input_desc.SetOriginFormat(FORMAT_NCHW);
1163+ op_desc->AddInputDesc("input", input_desc);
1164+ AxisTypeInfo axis_type_info;
1165+ axis_type_info.SetAxisTypes({AxisType::SLIDINGWINDOW});
1166+ axis_type_info.SetAxisType(AxisType::SLIDINGWINDOW);
1167+ axis_type_info.SetRelateInputs({{0, {0}}});
1168+ axis_type_info.SetRelateOutputs({{0, {0}}});
1169+ axis_type_info.SetOriRelateInputs({{0, {0}}});
1170+ axis_type_info.SetOriRelateOutputs({{0, {0}}});
1171+ Status ret = DataSliceHelper::InferDavinciAxisSlice(op_desc, axis_type_info);
1172+ EXPECT_EQ(ret, FAILED);
1173+}
1036} // namespace ge1174} // namespace ge
Mtests/ge/ut/ge/common/dnnengine_manager_unittest.cc+221-1
@@ -21,7 +21,7 @@
21#include "common/opskernel/ops_kernel_info_types.h"21#include "common/opskernel/ops_kernel_info_types.h"
22#include "framework/engine/dnnengine.h"22#include "framework/engine/dnnengine.h"
23#include "graph/op_desc.h"23#include "graph/op_desc.h"
24-#include "graph/node.h"24+#include "graph/debug/ge_attr_define.h"
25#include "engines/manager/opskernel_manager/dnn_ops_kernel_manager.h"25#include "engines/manager/opskernel_manager/dnn_ops_kernel_manager.h"
26#include "graph/ge_local_context.h"26#include "graph/ge_local_context.h"
27#include "macro_utils/dt_public_unscope.h"27#include "macro_utils/dt_public_unscope.h"
@@ -326,4 +326,224 @@ TEST_F(UtestDnnengineManager, GetDNNEngineName_not_support_dynamic_shape) {
326 okm.ops_kernel_store_["kernel_name"] = std::make_shared<SubOpsKernelInfoStore2>();326 okm.ops_kernel_store_["kernel_name"] = std::make_shared<SubOpsKernelInfoStore2>();
327 EXPECT_EQ(instance.GetDNNEngineName(node), "");327 EXPECT_EQ(instance.GetDNNEngineName(node), "");
328}328}
329+ 
330+TEST_F(UtestDnnengineManager, FinalizeNotInitialized) {
331+ auto &instance = DNNEngineManager::GetInstance();
332+ instance.init_flag_ = false;
333+ EXPECT_EQ(instance.Finalize(), SUCCESS);
334+}
335+ 
336+TEST_F(UtestDnnengineManager, GetCompositeEngineNameRecursiveDepthExceeded) {
337+ auto &instance = DNNEngineManager::GetInstance();
338+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("graph");
339+ auto node = UtAddNode(graph, "data1", "DATA", 0, 1);
340+ OpsKernelManager::GetInstance().composite_engines_["com"] = std::set<std::string>{"engine1"};
341+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_["com"] = "kernel_lib";
342+ EXPECT_EQ(instance.GetCompositeEngineName(node, 30), "");
343+ OpsKernelManager::GetInstance().composite_engines_.clear();
344+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_.clear();
345+}
346+ 
347+TEST_F(UtestDnnengineManager, GetCompositeEngineNameWithCompositeAttr) {
348+ auto &instance = DNNEngineManager::GetInstance();
349+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("graph");
350+ auto node = UtAddNode(graph, "data1", "DATA", 0, 1);
351+ OpsKernelManager::GetInstance().composite_engines_["com"] = std::set<std::string>{"engine1"};
352+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_["com"] = "kernel_lib";
353+ AttrUtils::SetStr(node->GetOpDesc(), ATTR_NAME_COMPOSITE_ENGINE_NAME, "com");
354+ AttrUtils::SetStr(node->GetOpDesc(), ATTR_NAME_COMPOSITE_ENGINE_KERNEL_LIB_NAME, "kernel_lib");
355+ EXPECT_EQ(instance.GetCompositeEngineName(node, 1), "com");
356+ OpsKernelManager::GetInstance().composite_engines_.clear();
357+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_.clear();
358+}
359+ 
360+TEST_F(UtestDnnengineManager, GetCompositeEngineNameAtomicFound) {
361+ auto &instance = DNNEngineManager::GetInstance();
362+ instance.atomic_2_composite_["AIcoreEngine"] = "AIcoreComposite";
363+ EXPECT_EQ(instance.GetCompositeEngineName("AIcoreEngine"), "AIcoreComposite");
364+ EXPECT_EQ(instance.GetCompositeEngineName("nonexistent"), "");
365+ instance.atomic_2_composite_.clear();
366+}
367+ 
368+TEST_F(UtestDnnengineManager, GetCompositeEngineKernelLibNameFound) {
369+ auto &instance = DNNEngineManager::GetInstance();
370+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_["com_engine"] = "kernel_lib";
371+ EXPECT_EQ(instance.GetCompositeEngineKernelLibName("com_engine"), "kernel_lib");
372+ EXPECT_EQ(instance.GetCompositeEngineKernelLibName("nonexistent"), "");
373+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_.clear();
374+}
375+ 
376+TEST_F(UtestDnnengineManager, ReadJsonFileWithEnginesMapNotEmpty) {
377+ auto &instance = DNNEngineManager::GetInstance();
378+ instance.engines_map_["engine"] = std::make_shared<DNNEngine>();
379+ nlohmann::json json_obj;
380+ EXPECT_EQ(instance.ReadJsonFile("/tmp/nonexistent_file_path.json", &json_obj), FAILED);
381+ instance.engines_map_.clear();
382+}
383+ 
384+TEST_F(UtestDnnengineManager, ReadJsonFileWithNullJson) {
385+ auto &instance = DNNEngineManager::GetInstance();
386+ EXPECT_EQ(instance.ReadJsonFile("/tmp/test.json", nullptr), FAILED);
387+}
388+ 
389+TEST_F(UtestDnnengineManager, ParserJsonFileWithNullJsonContent) {
390+ auto &instance = DNNEngineManager::GetInstance();
391+ std::string path = GetModelPath();
392+ path.append("../../../../compiler/plugin/nnengine/ge_config/");
393+ std::string path_copy = path;
394+ path_copy.append("engine_conf_backup.json");
395+ string cmd = "mkdir -p " + path;
396+ system(cmd.data());
397+ path.append("engine_conf.json");
398+ std::string backup_cmd = "cp " + path + " " + path_copy;
399+ system(backup_cmd.data());
400+ std::ofstream ofs(path.c_str(), std::ios::out);
401+ ofs << "null";
402+ ofs.close();
403+ EXPECT_EQ(instance.ParserJsonFile(), SUCCESS);
404+ std::string recover_cmd1 = "rm -rf " + path + ";mv " + path_copy + " " + path;
405+ system(recover_cmd1.data());
406+}
407+ 
408+TEST_F(UtestDnnengineManager, ParserJsonFileSchedulerUnitsNotArray) {
409+ auto &instance = DNNEngineManager::GetInstance();
410+ std::string path = GetModelPath();
411+ path.append("../../../../compiler/plugin/nnengine/ge_config/");
412+ std::string path_copy = path;
413+ path_copy.append("engine_conf_backup.json");
414+ string cmd = "mkdir -p " + path;
415+ system(cmd.data());
416+ path.append("engine_conf.json");
417+ std::string backup_cmd = "cp " + path + " " + path_copy;
418+ system(backup_cmd.data());
419+ std::ofstream ofs(path.c_str(), std::ios::out);
420+ ofs << "{\"schedule_units\":\"not_array\"}";
421+ ofs.close();
422+ EXPECT_EQ(instance.ParserJsonFile(), FAILED);
423+ std::string recover_cmd1 = "rm -rf " + path + ";mv " + path_copy + " " + path;
424+ system(recover_cmd1.data());
425+}
426+ 
427+TEST_F(UtestDnnengineManager, ParserJsonFileCalEnginesNull) {
428+ auto &instance = DNNEngineManager::GetInstance();
429+ std::string path = GetModelPath();
430+ path.append("../../../../compiler/plugin/nnengine/ge_config/");
431+ std::string path_copy = path;
432+ path_copy.append("engine_conf_backup.json");
433+ string cmd = "mkdir -p " + path;
434+ system(cmd.data());
435+ path.append("engine_conf.json");
436+ std::string backup_cmd = "cp " + path + " " + path_copy;
437+ system(backup_cmd.data());
438+ std::ofstream ofs(path.c_str(), std::ios::out);
439+ ofs << "{\"schedule_units\":[{\"cal_engines\":null,\"id\":\"sch1\"}]}";
440+ ofs.close();
441+ EXPECT_EQ(instance.ParserJsonFile(), FAILED);
442+ std::string recover_cmd1 = "rm -rf " + path + ";mv " + path_copy + " " + path;
443+ system(recover_cmd1.data());
444+}
445+ 
446+TEST_F(UtestDnnengineManager, ParserJsonFileEngineIdNull) {
447+ auto &instance = DNNEngineManager::GetInstance();
448+ std::string path = GetModelPath();
449+ path.append("../../../../compiler/plugin/nnengine/ge_config/");
450+ std::string path_copy = path;
451+ path_copy.append("engine_conf_backup.json");
452+ string cmd = "mkdir -p " + path;
453+ system(cmd.data());
454+ path.append("engine_conf.json");
455+ std::string backup_cmd = "cp " + path + " " + path_copy;
456+ system(backup_cmd.data());
457+ std::ofstream ofs(path.c_str(), std::ios::out);
458+ ofs << "{\"schedule_units\":[{\"cal_engines\":[{\"id\":\"\"}],\"id\":\"sch1\"}]}";
459+ ofs.close();
460+ EXPECT_EQ(instance.ParserJsonFile(), FAILED);
461+ std::string recover_cmd1 = "rm -rf " + path + ";mv " + path_copy + " " + path;
462+ system(recover_cmd1.data());
463+}
464+ 
465+TEST_F(UtestDnnengineManager, ParserJsonFileCalEnginesNotArray) {
466+ auto &instance = DNNEngineManager::GetInstance();
467+ std::string path = GetModelPath();
468+ path.append("../../../../compiler/plugin/nnengine/ge_config/");
469+ std::string path_copy = path;
470+ path_copy.append("engine_conf_backup.json");
471+ string cmd = "mkdir -p " + path;
472+ system(cmd.data());
473+ path.append("engine_conf.json");
474+ std::string backup_cmd = "cp " + path + " " + path_copy;
475+ system(backup_cmd.data());
476+ std::ofstream ofs(path.c_str(), std::ios::out);
477+ ofs << "{\"schedule_units\":[{\"cal_engines\":\"not_array\",\"id\":\"sch1\"}]}";
478+ ofs.close();
479+ EXPECT_EQ(instance.ParserJsonFile(), FAILED);
480+ std::string recover_cmd1 = "rm -rf " + path + ";mv " + path_copy + " " + path;
481+ system(recover_cmd1.data());
482+}
483+ 
484+TEST_F(UtestDnnengineManager, CheckJsonFileWithDuplicateEngine) {
485+ auto &instance = DNNEngineManager::GetInstance();
486+ instance.engines_map_["engine1"] = std::make_shared<DNNEngine>();
487+ instance.schedulers_["sch1"] = SchedulerConf();
488+ instance.schedulers_["sch1"].cal_engines["engine1"] = std::make_shared<EngineConf>();
489+ instance.schedulers_["sch2"] = SchedulerConf();
490+ instance.schedulers_["sch2"].cal_engines["engine1"] = std::make_shared<EngineConf>();
491+ EXPECT_EQ(instance.CheckJsonFile(), FAILED);
492+}
493+ 
494+TEST_F(UtestDnnengineManager, CheckJsonFileEngineNotFound) {
495+ auto &instance = DNNEngineManager::GetInstance();
496+ instance.engines_map_["engine_not_in_json"] = std::make_shared<DNNEngine>();
497+ instance.schedulers_["sch"] = SchedulerConf();
498+ instance.schedulers_["sch"].cal_engines["other_engine"] = std::make_shared<EngineConf>();
499+ EXPECT_EQ(instance.CheckJsonFile(), FAILED);
500+}
501+ 
502+TEST_F(UtestDnnengineManager, InitAtomicCompositeMappingWithEngines) {
503+ auto &instance = DNNEngineManager::GetInstance();
504+ instance.engines_map_["composite_engine"] = std::make_shared<DNNEngine>();
505+ instance.engines_map_["atomic_engine"] = std::make_shared<DNNEngine>();
506+ OpsKernelManager::GetInstance().composite_engines_["composite_engine"] = std::set<std::string>{"atomic_engine"};
507+ EXPECT_NO_THROW(instance.InitAtomicCompositeMapping());
508+ OpsKernelManager::GetInstance().composite_engines_.clear();
509+ instance.engines_map_.clear();
510+ instance.atomic_2_composite_.clear();
511+}
512+ 
513+TEST_F(UtestDnnengineManager, GetCompositeEngineWithSubgraph) {
514+ auto &instance = DNNEngineManager::GetInstance();
515+ auto parent_graph = std::make_shared<ComputeGraph>("parent_graph");
516+ auto sub_graph = std::make_shared<ComputeGraph>("sub_graph");
517+ auto parent_node = UtAddNode(parent_graph, "partitioned_call", "PartitionedCall", 1, 1);
518+ auto sub_node = UtAddNode(sub_graph, "sub_data", "DATA", 0, 1);
519+ sub_graph->SetParentGraph(parent_graph);
520+ sub_graph->SetParentNode(parent_node);
521+ parent_node->GetOpDesc()->AddSubgraphName(sub_graph->GetName());
522+ parent_node->GetOpDesc()->SetSubgraphInstanceName(0, sub_graph->GetName());
523+ parent_graph->AddSubGraph(sub_graph);
524+ OpsKernelManager::GetInstance().composite_engines_["com"] = std::set<std::string>{"engine1"};
525+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_["com"] = "kernel_lib";
526+ EXPECT_EQ(instance.GetCompositeEngineName(parent_node, 1), "");
527+ OpsKernelManager::GetInstance().composite_engines_.clear();
528+ OpsKernelManager::GetInstance().composite_engine_kernel_lib_names_.clear();
529+}
530+ 
531+TEST_F(UtestDnnengineManager, IsStreamAssignSkip) {
532+ auto &instance = DNNEngineManager::GetInstance();
533+ instance.schedulers_["sch"] = SchedulerConf();
534+ instance.schedulers_["sch"].cal_engines["engine1"] = std::make_shared<EngineConf>();
535+ instance.schedulers_["sch"].cal_engines["engine1"]->skip_assign_stream = true;
536+ EXPECT_EQ(instance.IsStreamAssignSkip("engine1"), true);
537+ EXPECT_EQ(instance.IsStreamAssignSkip("nonexistent_engine"), false);
538+ instance.schedulers_.clear();
539+}
540+ 
541+TEST_F(UtestDnnengineManager, GetEngineAndEngineInfo) {
542+ auto &instance = DNNEngineManager::GetInstance();
543+ auto engine = std::make_shared<DNNEngine>();
544+ instance.engines_map_["test_engine"] = engine;
545+ EXPECT_EQ(instance.GetEngine("test_engine"), engine);
546+ EXPECT_EQ(instance.GetEngine("nonexistent"), nullptr);
547+ instance.engines_map_.clear();
548+}
329} // namespace ge549} // namespace ge
Mtests/ge/ut/ge/common/dump_exception_unittest.cc+111-0
@@ -697,4 +697,115 @@ TEST_F(UTEST_dump_exception, Clear_Empty_CovEnhance) {
697 ExceptionDumper exception_dumper;697 ExceptionDumper exception_dumper;
698 EXPECT_NO_THROW(exception_dumper.Clear());698 EXPECT_NO_THROW(exception_dumper.Clear());
699}699}
700+ 
701+TEST_F(UTEST_dump_exception, DumpNodeInfo_ReplaceStringElem_CovEnhance) {
702+ ASSERT_TRUE(ge::CreateDirectory(temp_dump_path_) == 0);
703+ ge::DumpProperties dump_properties;
704+ dump_properties.AddPropertyValue("ALL_MODEL_NEED_DUMP_AND_IT_IS_NOT_A_MODEL_NAME", {"test"});
705+ dump_properties.SetDumpMode("all");
706+ 
707+ OpDescInfo op_desc_info;
708+ op_desc_info.op_name = "test.op name";
709+ op_desc_info.op_type = "test/type\\type";
710+ op_desc_info.id.task_id = 1;
711+ op_desc_info.id.stream_id = 2;
712+ op_desc_info.input_format = {FORMAT_NCHW};
713+ op_desc_info.input_shape = {{1}};
714+ op_desc_info.input_data_type = {DT_FLOAT};
715+ op_desc_info.input_addrs = {nullptr};
716+ op_desc_info.input_size = {2};
717+ op_desc_info.output_format = {FORMAT_NCHW};
718+ op_desc_info.output_shape = {{1}};
719+ op_desc_info.output_data_type = {DT_FLOAT};
720+ op_desc_info.output_addrs = {nullptr};
721+ op_desc_info.output_size = {2};
722+ ExceptionDumper exception_dumper;
723+ EXPECT_EQ(exception_dumper.DumpNodeInfo(op_desc_info, temp_dump_path_, false, false, dump_properties), ge::SUCCESS);
724+}
725+ 
726+TEST_F(UTEST_dump_exception, RefreshAddrs_Success_WithRelevantOffset_CovEnhance) {
727+ ExceptionDumper exception_dumper;
728+ OpDescPtr op_desc = std::make_shared<OpDesc>("TestOp", "TestType");
729+ ExtraOpInfo extra_op_info;
730+ extra_op_info.is_host_args = false;
731+ std::vector<uint8_t> args_data(32, 0);
732+ extra_op_info.args = reinterpret_cast<uintptr_t>(args_data.data());
733+ extra_op_info.input_addrs = {reinterpret_cast<void *>(5000), reinterpret_cast<void *>(6000)};
734+ extra_op_info.output_addrs = {reinterpret_cast<void *>(7000)};
735+ extra_op_info.cust_to_relevant_offset_ = {{0, 1}};
736+ ge::OpDescInfoId id(40, 50, 0);
737+ exception_dumper.SaveDumpOpInfo(op_desc, extra_op_info, id, false);
738+ gert::GertRuntimeStub runtime_stub;
739+ OpDescInfo result;
740+ EXPECT_TRUE(exception_dumper.GetOpDescInfo(id, result));
741+}
742+ 
743+TEST_F(UTEST_dump_exception, DumpNodeInfo_WorkspaceNullAddr_CovEnhance) {
744+ ASSERT_TRUE(ge::CreateDirectory(temp_dump_path_) == 0);
745+ ge::DumpProperties dump_properties;
746+ dump_properties.AddPropertyValue("ALL_MODEL_NEED_DUMP_AND_IT_IS_NOT_A_MODEL_NAME", {"test"});
747+ dump_properties.SetDumpMode("all");
748+ 
749+ OpDescInfo op_desc_info;
750+ op_desc_info.op_name = "Save";
751+ op_desc_info.op_type = "Save";
752+ op_desc_info.id.task_id = 1;
753+ op_desc_info.id.stream_id = 2;
754+ op_desc_info.input_format = {FORMAT_NCHW};
755+ op_desc_info.input_shape = {{1}};
756+ op_desc_info.input_data_type = {DT_FLOAT};
757+ op_desc_info.input_addrs = {nullptr};
758+ op_desc_info.input_size = {2};
759+ op_desc_info.output_format = {FORMAT_NCHW};
760+ op_desc_info.output_shape = {{1}};
761+ op_desc_info.output_data_type = {DT_FLOAT};
762+ op_desc_info.output_addrs = {nullptr};
763+ op_desc_info.output_size = {2};
764+ op_desc_info.space_addrs = {nullptr};
765+ op_desc_info.workspace_bytes = {8};
766+ ExceptionDumper exception_dumper;
767+ EXPECT_EQ(exception_dumper.DumpNodeInfo(op_desc_info, temp_dump_path_, false, false, dump_properties), ge::SUCCESS);
768+}
769+ 
770+TEST_F(UTEST_dump_exception, LogExceptionArgs_MallocHostFail_CovEnhance) {
771+ OpDescInfo op_desc_info;
772+ op_desc_info.args_size = 123U;
773+ op_desc_info.is_host_args = false;
774+ ExceptionDumper exception_dumper{};
775+ EXPECT_NO_THROW(exception_dumper.LogExceptionArgs(op_desc_info));
776+}
777+ 
778+TEST_F(UTEST_dump_exception, LogExceptionArgs_MemcpyFail_CovEnhance) {
779+ OpDescInfo op_desc_info;
780+ auto args_holder = std::unique_ptr<uint8_t[]>(new uint8_t[64]);
781+ op_desc_info.args = reinterpret_cast<uintptr_t>(args_holder.get());
782+ op_desc_info.args_size = 64U;
783+ op_desc_info.is_host_args = false;
784+ ExceptionDumper exception_dumper{};
785+ mmSetEnv("CONSTANT_FOLDING_PASS", "mock_fail", 1);
786+ EXPECT_NO_THROW(exception_dumper.LogExceptionArgs(op_desc_info));
787+ unsetenv("CONSTANT_FOLDING_PASS");
788+}
789+ 
790+TEST_F(UTEST_dump_exception, LogExceptionTvmOpInfo_RealPath_CovEnhance) {
791+ OpDescInfo op_desc_info;
792+ op_desc_info.op_name = "TestOp";
793+ op_desc_info.op_type = "TestType";
794+ op_desc_info.imply_type = static_cast<uint32_t>(domi::ImplyType::TVM);
795+ op_desc_info.input_format = {FORMAT_NCHW};
796+ op_desc_info.input_shape = {{1}};
797+ op_desc_info.input_data_type = {DT_FLOAT};
798+ op_desc_info.input_addrs = {reinterpret_cast<void *>(5000)};
799+ op_desc_info.output_format = {FORMAT_NCHW};
800+ op_desc_info.output_shape = {{1}};
801+ op_desc_info.output_data_type = {DT_FLOAT};
802+ op_desc_info.output_addrs = {reinterpret_cast<void *>(6000)};
803+ op_desc_info.op_file_path = ".";
804+ op_desc_info.dev_func = "test_kernel__0";
805+ ExceptionDumper exception_dumper{};
806+ gert::GertRuntimeStub runtime_stub;
807+ dlog_setlevel(GE_MODULE_NAME, DLOG_INFO, 0);
808+ EXPECT_NO_THROW(exception_dumper.LogExceptionTvmOpInfo(op_desc_info));
809+ dlog_setlevel(GE_MODULE_NAME, DLOG_ERROR, 0);
810+}
700} // namespace ge811} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_5d_nchw_unittest.cc+21-0
@@ -827,5 +827,26 @@ TEST_F(UTEST_FormatTransferNc1hwc0ToNchw, invalid_src_data_type) {
827 FormatTransferNc1hwc0Nchw transfer;827 FormatTransferNc1hwc0Nchw transfer;
828 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_DATATYPE_INVALID);828 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_DATATYPE_INVALID);
829}829}
830+TEST_F(UTEST_FormatTransferNc1hwc0ToNchw, nc1hwc0_to_nchw_zero_size) {
831+ uint16_t data[1] = {0};
832+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NC1HWC0, FORMAT_RESERVED, 5));
833+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
834+ TransArgs args{reinterpret_cast<uint8_t *>(data),
835+ src_format,
836+ dst_format,
837+ FORMAT_NC1HWC0,
838+ FORMAT_NCHW,
839+ FORMAT_RESERVED,
840+ FORMAT_RESERVED,
841+ 16,
842+ 16,
843+ {0, 1, 1, 1, 16},
844+ {0, 16, 1, 1},
845+ DT_FLOAT16};
846+ TransResult result;
847+ FormatTransferNc1hwc0Nchw transfer;
848+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
849+ EXPECT_EQ(result.length, 0U);
850+}
830} // namespace formats851} // namespace formats
831} // namespace ge852} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_5d_nhwc_unittest.cc+21-0
@@ -957,5 +957,26 @@ TEST_F(UtestFormatTransfer5dNhwc, invalid_src_dst_shape_relation) {
957 FormatTransferNc1hwc0Nhwc transfer;957 FormatTransferNc1hwc0Nhwc transfer;
958 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);958 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
959}959}
960+TEST_F(UtestFormatTransfer5dNhwc, nc1hwc0_to_nhwc_zero_size) {
961+ uint16_t data[1] = {0};
962+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NC1HWC0, FORMAT_RESERVED, 5));
963+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
964+ TransArgs args{reinterpret_cast<uint8_t *>(data),
965+ src_format,
966+ dst_format,
967+ FORMAT_NC1HWC0,
968+ FORMAT_NHWC,
969+ FORMAT_RESERVED,
970+ FORMAT_RESERVED,
971+ 16,
972+ 16,
973+ {0, 1, 1, 1, 16},
974+ {0, 1, 1, 16},
975+ DT_FLOAT16};
976+ TransResult result;
977+ FormatTransferNc1hwc0Nhwc transfer;
978+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
979+ EXPECT_EQ(result.length, 0U);
980+}
960} // namespace formats981} // namespace formats
961} // namespace ge982} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_fractal_nz_unittest.cc+107-0
@@ -7421,5 +7421,112 @@ TEST_F(UtestFormatTransferNdFractNz, nd_shape1_trans_shape_ndz_to_nd) {
7421 EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 16, 16}, DT_FLOAT16, dst_format, dst_shape),7421 EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 16, 16}, DT_FLOAT16, dst_format, dst_shape),
7422 ACL_ERROR_GE_FORMAT_INVALID);7422 ACL_ERROR_GE_FORMAT_INVALID);
7423}7423}
7424+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_zero_size) {
7425+ uint16_t data[1] = {0};
7426+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7427+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7428+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7429+ src_format,
7430+ dst_format,
7431+ FORMAT_ND,
7432+ FORMAT_FRACTAL_NZ,
7433+ FORMAT_RESERVED,
7434+ FORMAT_RESERVED,
7435+ 16,
7436+ 16,
7437+ {0},
7438+ {0, 1, 16, 16},
7439+ DT_FLOAT16};
7440+ TransResult result;
7441+ FormatTransferFractalNz transfer;
7442+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
7443+ EXPECT_EQ(result.length, 0U);
7444+}
7445+ 
7446+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_zero_size_reverse) {
7447+ uint16_t data[1] = {0};
7448+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7449+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7450+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7451+ src_format,
7452+ dst_format,
7453+ FORMAT_FRACTAL_NZ,
7454+ FORMAT_ND,
7455+ FORMAT_RESERVED,
7456+ FORMAT_RESERVED,
7457+ 16,
7458+ 16,
7459+ {0, 1, 16, 16},
7460+ {0},
7461+ DT_FLOAT16};
7462+ TransResult result;
7463+ FormatTransferFractalNzND transfer;
7464+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
7465+ EXPECT_EQ(result.length, 0U);
7466+}
7467+ 
7468+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_overflow_trans_shape) {
7469+ const int64_t kMaxShapeItem = 1099511627776LL;
7470+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7471+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7472+ std::vector<int64_t> dst_shape;
7473+ FormatTransferFractalNz transfer;
7474+ EXPECT_EQ(transfer.TransShape(src_format, {kMaxShapeItem}, DT_FLOAT16, dst_format, dst_shape),
7475+ ACL_ERROR_GE_SHAPE_INVALID);
7476+}
7477+ 
7478+TEST_F(UtestFormatTransferNdFractNz, nd_shape2_overflow_trans_shape) {
7479+ const int64_t kMaxShapeItem = 1099511627776LL;
7480+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7481+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7482+ std::vector<int64_t> dst_shape;
7483+ FormatTransferFractalNz transfer;
7484+ EXPECT_EQ(transfer.TransShape(src_format, {1, kMaxShapeItem}, DT_FLOAT16, dst_format, dst_shape),
7485+ ACL_ERROR_GE_SHAPE_INVALID);
7486+}
7487+ 
7488+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_overflow_trans_format) {
7489+ uint16_t data[1] = {0};
7490+ const int64_t kMaxShapeItem = 1099511627776LL;
7491+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7492+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7493+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7494+ src_format,
7495+ dst_format,
7496+ FORMAT_ND,
7497+ FORMAT_FRACTAL_NZ,
7498+ FORMAT_RESERVED,
7499+ FORMAT_RESERVED,
7500+ 16,
7501+ 16,
7502+ {kMaxShapeItem},
7503+ {1, 1, 16, 16},
7504+ DT_FLOAT16};
7505+ TransResult result;
7506+ FormatTransferFractalNz transfer;
7507+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
7508+}
7509+ 
7510+TEST_F(UtestFormatTransferNdFractNz, nd_reverse_overflow_dst_shape) {
7511+ uint16_t data[1] = {0};
7512+ const int64_t kMaxShapeItem = 1099511627776LL;
7513+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7514+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7515+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7516+ src_format,
7517+ dst_format,
7518+ FORMAT_FRACTAL_NZ,
7519+ FORMAT_ND,
7520+ FORMAT_RESERVED,
7521+ FORMAT_RESERVED,
7522+ 16,
7523+ 16,
7524+ {1, 1, 16, 16},
7525+ {kMaxShapeItem},
7526+ DT_FLOAT16};
7527+ TransResult result;
7528+ FormatTransferFractalNzND transfer;
7529+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
7530+}
7424} // namespace formats7531} // namespace formats
7425} // namespace ge7532} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_fractal_zz_unittest.cc+75-0
@@ -8698,5 +8698,80 @@ TEST_F(UtestFormatTransferNdFractZz, nd_trans_shape_fzz_to_nd_invalid) {
8698 EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 32, 32}, DT_UINT8, dst_format, dst_shape),8698 EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 32, 32}, DT_UINT8, dst_format, dst_shape),
8699 ACL_ERROR_GE_FORMAT_INVALID);8699 ACL_ERROR_GE_FORMAT_INVALID);
8700}8700}
8701+TEST_F(UtestFormatTransferNdFractZz, nd_shape1_zero_size) {
8702+ uint16_t data[1] = {0};
8703+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
8704+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 5));
8705+ TransArgs args{reinterpret_cast<uint8_t *>(data),
8706+ src_format,
8707+ dst_format,
8708+ FORMAT_ND,
8709+ FORMAT_FRACTAL_ZZ,
8710+ FORMAT_RESERVED,
8711+ FORMAT_RESERVED,
8712+ 16,
8713+ 16,
8714+ {0},
8715+ {1, 0, 16, 16},
8716+ DT_FLOAT16};
8717+ TransResult result;
8718+ FormatTransferFractalZz transfer;
8719+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
8720+ EXPECT_EQ(result.length, 0U);
8721+}
8722+ 
8723+TEST_F(UtestFormatTransferNdFractZz, nd_shape1_zero_size_reverse) {
8724+ uint16_t data[1] = {0};
8725+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 5));
8726+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
8727+ TransArgs args{reinterpret_cast<uint8_t *>(data),
8728+ src_format,
8729+ dst_format,
8730+ FORMAT_FRACTAL_ZZ,
8731+ FORMAT_ND,
8732+ FORMAT_RESERVED,
8733+ FORMAT_RESERVED,
8734+ 16,
8735+ 16,
8736+ {1, 0, 16, 16},
8737+ {0},
8738+ DT_FLOAT16};
8739+ TransResult result;
8740+ FormatTransferFractalZzND transfer;
8741+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
8742+ EXPECT_EQ(result.length, 0U);
8743+}
8744+ 
8745+TEST_F(UtestFormatTransferNdFractZz, nd_shape1_overflow_trans_shape) {
8746+ const int64_t kMaxShapeItem = 1099511627776LL;
8747+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
8748+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 5));
8749+ std::vector<int64_t> dst_shape;
8750+ FormatTransferFractalZz transfer;
8751+ EXPECT_EQ(transfer.TransShape(src_format, {kMaxShapeItem}, DT_FLOAT16, dst_format, dst_shape),
8752+ ACL_ERROR_GE_SHAPE_INVALID);
8753+}
8754+ 
8755+TEST_F(UtestFormatTransferNdFractZz, nd_reverse_overflow_dst_shape) {
8756+ uint16_t data[1] = {0};
8757+ const int64_t kMaxShapeItem = 1099511627776LL;
8758+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 5));
8759+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
8760+ TransArgs args{reinterpret_cast<uint8_t *>(data),
8761+ src_format,
8762+ dst_format,
8763+ FORMAT_FRACTAL_ZZ,
8764+ FORMAT_ND,
8765+ FORMAT_RESERVED,
8766+ FORMAT_RESERVED,
8767+ 16,
8768+ 16,
8769+ {1, 1, 16, 16},
8770+ {kMaxShapeItem},
8771+ DT_FLOAT16};
8772+ TransResult result;
8773+ FormatTransferFractalZzND transfer;
8774+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
8775+}
8701} // namespace formats8776} // namespace formats
8702} // namespace ge8777} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_fzc04_unittest.cc+9-0
@@ -3863,5 +3863,14 @@ TEST_F(UtestFormatTransfer4DToFZC04, nchw_to_fzc04_empty_tensor) {
3863 FormatTransfer4DToFZC04 transfer;3863 FormatTransfer4DToFZC04 transfer;
3864 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);3864 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
3865}3865}
3866+TEST_F(UtestFormatTransfer4DToFZC04, nchw_to_fzc04_overflow_trans_shape) {
3867+ const int64_t kMaxShapeItem = 1099511627776LL;
3868+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
3869+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z_C04, FORMAT_RESERVED, 5));
3870+ std::vector<int64_t> dst_shape;
3871+ FormatTransfer4DToFZC04 transfer;
3872+ EXPECT_EQ(transfer.TransShape(src_format, {kMaxShapeItem, 1, 1, 1}, DT_FLOAT16, dst_format, dst_shape),
3873+ ACL_ERROR_GE_SHAPE_INVALID);
3874+}
3866} // namespace formats3875} // namespace formats
3867} // namespace ge3876} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_hwcn_c1hwncoc0_unittest.cc+21-0
@@ -13979,5 +13979,26 @@ TEST_F(UtestFormatTransferHwcnC1hwncoc0, invalid_dst_shape_trans_shape_mismatch)
13979 EXPECT_EQ(transfer.TransShape(FORMAT_HWCN, {1, 1, 1, 1}, DT_FLOAT, FORMAT_C1HWNCoC0, dst_shape),13979 EXPECT_EQ(transfer.TransShape(FORMAT_HWCN, {1, 1, 1, 1}, DT_FLOAT, FORMAT_C1HWNCoC0, dst_shape),
13980 ACL_ERROR_GE_SHAPE_INVALID);13980 ACL_ERROR_GE_SHAPE_INVALID);
13981}13981}
13982+TEST_F(UtestFormatTransferHwcnC1hwncoc0, hwcn_to_c1hwncoc0_zero_size) {
13983+ uint16_t data[1] = {0};
13984+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
13985+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_C1HWNCoC0, FORMAT_RESERVED, 5));
13986+ TransArgs args{reinterpret_cast<uint8_t *>(data),
13987+ src_format,
13988+ dst_format,
13989+ FORMAT_HWCN,
13990+ FORMAT_C1HWNCoC0,
13991+ FORMAT_RESERVED,
13992+ FORMAT_RESERVED,
13993+ 16,
13994+ 16,
13995+ {1, 1, 16, 0},
13996+ {1, 1, 1, 0, 16, 16},
13997+ DT_FLOAT16};
13998+ TransResult result;
13999+ FormatTransferHwcnC1hwncoc0 transfer;
14000+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
14001+ EXPECT_EQ(result.length, 0U);
14002+}
13982} // namespace formats14003} // namespace formats
13983} // namespace ge14004} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_hwcn_fractalz_unittest.cc+20-0
@@ -34820,5 +34820,25 @@ TEST_F(UtestFormatTransferHwcnFz, unsupported_format_trans_format) {
34820 FormatTransferFractalZ transfer;34820 FormatTransferFractalZ transfer;
34821 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);34821 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);
34822}34822}
34823+TEST_F(UtestFormatTransferHwcnFz, hwcn_to_fz_zero_size) {
34824+ uint16_t data[1] = {0};
34825+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
34826+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
34827+ TransArgs args{reinterpret_cast<uint8_t *>(data),
34828+ src_format,
34829+ dst_format,
34830+ FORMAT_HWCN,
34831+ FORMAT_FRACTAL_Z,
34832+ FORMAT_RESERVED,
34833+ FORMAT_RESERVED,
34834+ 16,
34835+ 16,
34836+ {1, 1, 16, 0},
34837+ {1, 0, 16, 16},
34838+ DT_FLOAT16};
34839+ TransResult result;
34840+ FormatTransferFractalZ transfer;
34841+ EXPECT_NE(transfer.TransFormat(args, result), SUCCESS);
34842+}
34823} // namespace formats34843} // namespace formats
34824} // namespace ge34844} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nchw_5d_unittest.cc+9-0
@@ -848,5 +848,14 @@ TEST_F(UtestFormatTransferNchw5d, invalid_src_shape_trans_shape) {
848 std::vector<int64_t> dst_shape;848 std::vector<int64_t> dst_shape;
849 EXPECT_EQ(transfer.TransShape(FORMAT_NCHW, {1, 1}, DT_FLOAT, FORMAT_NC1HWC0, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);849 EXPECT_EQ(transfer.TransShape(FORMAT_NCHW, {1, 1}, DT_FLOAT, FORMAT_NC1HWC0, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
850}850}
851+TEST_F(UtestFormatTransferNchw5d, nchw_to_nc1hwc0_overflow_trans_shape) {
852+ const int64_t kMaxShapeItem = 1099511627776LL;
853+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
854+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NC1HWC0, FORMAT_RESERVED, 5));
855+ std::vector<int64_t> dst_shape;
856+ FormatTransferNchwNc1hwc0 transfer;
857+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, kMaxShapeItem, 1}, DT_FLOAT16, dst_format, dst_shape),
858+ ACL_ERROR_GE_SHAPE_INVALID);
859+}
851} // namespace formats860} // namespace formats
852} // namespace ge861} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nchw_fractalz_unittest.cc+29-0
@@ -17120,5 +17120,34 @@ TEST_F(UtestFormatTransferNchwFz, nchw_unsupported_format_trans_format) {
17120 FormatTransferFractalZ transfer;17120 FormatTransferFractalZ transfer;
17121 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);17121 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);
17122}17122}
17123+TEST_F(UtestFormatTransferNchwFz, nchw_to_fz_zero_size) {
17124+ uint16_t data[1] = {0};
17125+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
17126+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
17127+ TransArgs args{reinterpret_cast<uint8_t *>(data),
17128+ src_format,
17129+ dst_format,
17130+ FORMAT_NCHW,
17131+ FORMAT_FRACTAL_Z,
17132+ FORMAT_RESERVED,
17133+ FORMAT_RESERVED,
17134+ 16,
17135+ 16,
17136+ {0, 16, 1, 1},
17137+ {1, 0, 16, 16},
17138+ DT_FLOAT16};
17139+ TransResult result;
17140+ FormatTransferFractalZ transfer;
17141+ EXPECT_NE(transfer.TransFormat(args, result), SUCCESS);
17142+}
17143+ 
17144+TEST_F(UtestFormatTransferNchwFz, nchw_to_fz_overflow_trans_shape) {
17145+ const int64_t kMaxShapeItem = 1099511627776LL;
17146+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
17147+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
17148+ std::vector<int64_t> dst_shape;
17149+ FormatTransferFractalZ transfer;
17150+ EXPECT_NE(transfer.TransShape(src_format, {1, kMaxShapeItem, 1, 1}, DT_FLOAT16, dst_format, dst_shape), SUCCESS);
17151+}
17123} // namespace formats17152} // namespace formats
17124} // namespace ge17153} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nhwc_5d_unittest.cc+9-0
@@ -955,5 +955,14 @@ TEST_F(UtestFormatTransferNhwc5d, invalid_src_dst_format_trans_shape) {
955 EXPECT_EQ(transfer.TransShape(FORMAT_NHWC, {1, 1, 1, 16}, DT_STRING, FORMAT_NC1HWC0, dst_shape),955 EXPECT_EQ(transfer.TransShape(FORMAT_NHWC, {1, 1, 1, 16}, DT_STRING, FORMAT_NC1HWC0, dst_shape),
956 ACL_ERROR_GE_DATATYPE_INVALID);956 ACL_ERROR_GE_DATATYPE_INVALID);
957}957}
958+TEST_F(UtestFormatTransferNhwc5d, nhwc_to_nc1hwc0_overflow_trans_shape) {
959+ const int64_t kMaxShapeItem = 1099511627776LL;
960+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
961+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NC1HWC0, FORMAT_RESERVED, 5));
962+ std::vector<int64_t> dst_shape;
963+ FormatTransferNhwcNc1hwc0 transfer;
964+ EXPECT_EQ(transfer.TransShape(src_format, {1, kMaxShapeItem, 1, 1}, DT_FLOAT16, dst_format, dst_shape),
965+ ACL_ERROR_GE_SHAPE_INVALID);
966+}
958} // namespace formats967} // namespace formats
959} // namespace ge968} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nhwc_fractalz_unittest.cc+21-0
@@ -5612,5 +5612,26 @@ TEST_F(UtestFormatTransferNhwcFz, nhwc_invalid_dst_shape_relation) {
5612 FormatTransferFractalZ transfer;5612 FormatTransferFractalZ transfer;
5613 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);5613 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
5614}5614}
5615+TEST_F(UtestFormatTransferNhwcFz, nhwc_to_fz_zero_size) {
5616+ uint16_t data[1] = {0};
5617+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
5618+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
5619+ TransArgs args{reinterpret_cast<uint8_t *>(data),
5620+ src_format,
5621+ dst_format,
5622+ FORMAT_NHWC,
5623+ FORMAT_FRACTAL_Z,
5624+ FORMAT_RESERVED,
5625+ FORMAT_RESERVED,
5626+ 16,
5627+ 16,
5628+ {0, 1, 1, 16},
5629+ {1, 0, 16, 16},
5630+ DT_FLOAT16};
5631+ TransResult result;
5632+ FormatTransferFractalZ transfer;
5633+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
5634+ EXPECT_EQ(result.length, 0U);
5635+}
5615} // namespace formats5636} // namespace formats
5616} // namespace ge5637} // namespace ge
Mtests/ge/ut/ge/common/fp16_unittest.cc+131-0
@@ -499,5 +499,136 @@ TEST_F(UtestFP16, Fp16Sub_DifferentSign_CovEnhance) {
499 fp16_t result2 = c - d;499 fp16_t result2 = c - d;
500 EXPECT_EQ(result2.val, 0xBC00U); // -1.0500 EXPECT_EQ(result2.val, 0xBC00U); // -1.0
501}501}
502+ 
503+TEST_F(UtestFP16, Int8_WhileLoopOverflow_CovEnhance) {
504+ fp16_t neg_val;
505+ neg_val.val = 0xD800U;
506+ EXPECT_EQ(neg_val.ToInt8(), -128);
507+ 
508+ fp16_t pos_val;
509+ pos_val.val = 0x5800U;
510+ EXPECT_EQ(pos_val.ToInt8(), 127);
511+}
512+ 
513+TEST_F(UtestFP16, Uint8_WhileLoopOverflow_CovEnhance) {
514+ fp16_t val;
515+ val.val = 0x5C00U;
516+ EXPECT_EQ(val.ToUInt8(), 255);
517+}
518+ 
519+TEST_F(UtestFP16, Int16_WhileLoopOverflow_CovEnhance) {
520+ fp16_t neg_val;
521+ neg_val.val = 0xF801U;
522+ EXPECT_EQ(neg_val.ToInt16(), -32768);
523+ 
524+ fp16_t pos_val;
525+ pos_val.val = 0x7800U;
526+ EXPECT_EQ(pos_val.ToInt16(), 32767);
527+}
528+ 
529+TEST_F(UtestFP16, Int16_SmallExpRoundingAndSignReset_CovEnhance) {
530+ fp16_t val;
531+ val.val = 0x3880U;
532+ EXPECT_EQ(val.ToInt16(), 1);
533+ 
534+ fp16_t neg_val;
535+ neg_val.val = 0xC140U;
536+ EXPECT_EQ(neg_val.ToInt16(), -3);
537+ 
538+ fp16_t zero_neg;
539+ zero_neg.val = 0xB800U;
540+ EXPECT_EQ(zero_neg.ToInt16(), 0);
541+}
542+ 
543+TEST_F(UtestFP16, Uint16_SmallExpAndRounding_CovEnhance) {
544+ fp16_t val;
545+ val.val = 0x3880U;
546+ EXPECT_EQ(val.ToUInt16(), 1);
547+}
548+ 
549+TEST_F(UtestFP16, Int32_SmallExpAndRounding_CovEnhance) {
550+ fp16_t val;
551+ val.val = 0x3880U;
552+ EXPECT_EQ(val.ToInt32(), 1);
553+}
554+ 
555+TEST_F(UtestFP16, Int8_NegativeRoundingCondition_CovEnhance) {
556+ fp16_t val;
557+ val.val = 0xC140U;
558+ EXPECT_EQ(val.ToInt8(), -3);
559+}
560+ 
561+TEST_F(UtestFP16, OperatorGreaterThan_NegativeExpDiff_CovEnhance) {
562+ fp16_t lhs;
563+ lhs.val = 0xBC00U;
564+ fp16_t rhs;
565+ rhs.val = 0xC000U;
566+ EXPECT_EQ(lhs > rhs, true);
567+}
568+ 
569+TEST_F(UtestFP16, Fp16Add_SameExpMantissaOverflow_CovEnhance) {
570+ fp16_t a;
571+ a.val = 0x3C00U;
572+ fp16_t b;
573+ b.val = 0x3C00U;
574+ fp16_t result = a + b;
575+ EXPECT_EQ(result.val, 0x4000U);
576+}
577+ 
578+TEST_F(UtestFP16, Fp16Mul_NormalizeDenormalBoundary_CovEnhance) {
579+ fp16_t a;
580+ a.val = 0x0001U;
581+ fp16_t b;
582+ b.val = 0x6000U;
583+ fp16_t result = a * b;
584+ EXPECT_NE(result.val, 0U);
585+}
586+ 
587+TEST_F(UtestFP16, Fp16Mul_ZeroShiftPath_CovEnhance) {
588+ fp16_t a;
589+ a.val = 0x0000U;
590+ fp16_t b;
591+ b.val = 0x7800U;
592+ fp16_t result = a * b;
593+ EXPECT_EQ(result.val, 0U);
594+}
595+ 
596+TEST_F(UtestFP16, OperatorAssign_Float32_DenormalRounding_CovEnhance) {
597+ fp16_t test(1);
598+ test = 8.940696716308594e-08F;
599+ EXPECT_NE(test.val, 0U);
600+ 
601+ fp16_t test2(1);
602+ test2 = 3.0e-08F;
603+ EXPECT_NE(test2.val, 0U);
604+}
605+ 
606+TEST_F(UtestFP16, OperatorAssign_Float32_RoundingOverflow_CovEnhance) {
607+ fp16_t test(1);
608+ test = 1.9990234375F;
609+ EXPECT_EQ(test.val, 0x3FFFU);
610+}
611+ 
612+TEST_F(UtestFP16, OperatorAssign_Float64_DenormalRounding_CovEnhance) {
613+ fp16_t test(1);
614+ test = 8.940696716308594e-08;
615+ EXPECT_NE(test.val, 0U);
616+ 
617+ fp16_t test2(1);
618+ test2 = 3.0e-08;
619+ EXPECT_NE(test2.val, 0U);
620+}
621+ 
622+TEST_F(UtestFP16, OperatorAssign_Float64_RoundingOverflow_CovEnhance) {
623+ fp16_t test(1);
624+ test = 1.9990234375;
625+ EXPECT_EQ(test.val, 0x3FFFU);
626+}
627+ 
628+TEST_F(UtestFP16, OperatorAssign_Int32_LargeOverflow_CovEnhance) {
629+ fp16_t test(1);
630+ test = 2147483647;
631+ EXPECT_EQ(test.val, 0x7BFFU);
632+}
502} // namespace formats633} // namespace formats
503} // namespace ge634} // namespace ge
Mtests/ge/ut/ge/common/ge_auth_file_saver_unittest.cc+41-0
@@ -265,4 +265,45 @@ TEST_F(UTEST_file_saver, PrintModelSaveLog_when_not_initialized) {
265 FileSaver::PrintModelSaveLog();265 FileSaver::PrintModelSaveLog();
266}266}
267 267 
268+TEST_F(UTEST_file_saver, OpenFile_TooLongPath_CovEnhance) {
269+ int32_t fd = 0;
270+ std::string long_path(MMPA_MAX_PATH + 1, 'a');
271+ EXPECT_EQ(FileSaver::OpenFile(fd, long_path), FAILED);
272+}
273+ 
274+TEST_F(UTEST_file_saver, SaveWithFileHeader_Data_InvalidPath_CovEnhance) {
275+ ModelFileHeader file_header;
276+ std::string data = "test_data";
277+ std::string long_path(MMPA_MAX_PATH + 1, 'a');
278+ EXPECT_EQ(FileSaver::SaveWithFileHeader(long_path, file_header, data.data(), data.size()), FAILED);
279+}
280+ 
281+TEST_F(UTEST_file_saver, SaveWithFileHeader_PartitionTable_InvalidPath_CovEnhance) {
282+ ModelFileHeader file_header;
283+ std::vector<char> data;
284+ data.resize(sizeof(ModelPartitionTable) + sizeof(ModelPartitionMemInfo), 0);
285+ ModelPartitionTable *partition_table = reinterpret_cast<ModelPartitionTable *>(data.data());
286+ partition_table->num = 1;
287+ partition_table->partition[0] = {MODEL_DEF, 0, 12};
288+ auto buff = reinterpret_cast<uint8_t *>(malloc(12));
289+ struct ge::ModelPartition model_partition;
290+ model_partition.type = MODEL_DEF;
291+ model_partition.data = buff;
292+ model_partition.size = 12;
293+ std::vector<ModelPartition> model_partitions = {model_partition};
294+ std::string long_path(MMPA_MAX_PATH + 1, 'a');
295+ EXPECT_EQ(FileSaver::SaveWithFileHeader(long_path, file_header, *partition_table, model_partitions), FAILED);
296+ free(buff);
297+ model_partition.data = nullptr;
298+}
299+ 
300+TEST_F(UTEST_file_saver, SaveToFile_ModelData_InvalidPath_CovEnhance) {
301+ std::string model_data_str(256, '1');
302+ ge::ModelData modelData;
303+ modelData.model_data = reinterpret_cast<void *>(const_cast<char *>(model_data_str.c_str()));
304+ modelData.model_len = model_data_str.size();
305+ ModelFileHeader file_header;
306+ std::string long_path(MMPA_MAX_PATH + 1, 'a');
307+ EXPECT_EQ(FileSaver::SaveToFile(long_path, modelData, &file_header), FAILED);
308+}
268} // namespace ge309} // namespace ge
Mtests/ge/ut/ge/common/gelib_unittest.cc+48-0
@@ -205,4 +205,52 @@ TEST_F(UtestGeLib, set_OptionNameMap) {
205 EXPECT_EQ(GEInit::Finalize(), SUCCESS);205 EXPECT_EQ(GEInit::Finalize(), SUCCESS);
206}206}
207 207 
208+TEST_F(UtestGeLib, InitializeWithInvalidAicoreNum) {
209+ std::map<std::string, std::string> options;
210+ options[AICORE_NUM] = "2|i";
211+ options[SOC_VERSION] = "Ascend910";
212+ EXPECT_NE(GELib::Initialize(options), SUCCESS);
213+ EXPECT_EQ(GELib::GetInstance(), nullptr);
214+}
215+ 
216+TEST_F(UtestGeLib, InitializeWithOverflowAicoreNum) {
217+ std::map<std::string, std::string> options;
218+ options[AICORE_NUM] = "100|100";
219+ options[SOC_VERSION] = "Ascend910";
220+ EXPECT_NE(GELib::Initialize(options), SUCCESS);
221+ EXPECT_EQ(GELib::GetInstance(), nullptr);
222+}
223+ 
224+TEST_F(UtestGeLib, GeInitFinalizeWithoutInstance) {
225+ GELib::GetInstance();
226+ EXPECT_EQ(GEInit::Finalize(), SUCCESS);
227+}
228+ 
229+TEST_F(UtestGeLib, GetInstanceWhenNotInitialized) {
230+ auto instance = GELib::GetInstance();
231+ EXPECT_EQ(instance, nullptr);
232+}
233+ 
234+TEST_F(UtestGeLib, GetPath) {
235+ EXPECT_FALSE(GELib::GetPath().empty());
236+}
237+ 
238+TEST_F(UtestGeLib, RollbackInit) {
239+ auto p1 = std::make_shared<GELib>();
240+ EXPECT_NO_THROW(p1->RollbackInit());
241+}
242+ 
243+TEST_F(UtestGeLib, SystemFinalize) {
244+ auto p1 = std::make_shared<GELib>();
245+ p1->is_system_inited = false;
246+ p1->is_train_mode_ = false;
247+ EXPECT_NO_THROW(p1->SystemFinalize());
248+}
249+ 
250+TEST_F(UtestGeLib, SetRTSocVersionWithSocVersion) {
251+ auto p1 = std::make_shared<GELib>();
252+ std::map<std::string, std::string> options;
253+ options[SOC_VERSION] = "Ascend910";
254+ EXPECT_EQ(p1->SetRTSocVersion(options), SUCCESS);
255+}
208} // namespace ge256} // namespace ge
Mtests/ge/ut/ge/common/mobile_model_helper_unittest.cc+196-0
@@ -620,4 +620,200 @@ TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithNetOutputMissingOutputDesc)
620 EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);620 EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
621 system("rm -rf mobile_model_netout.omc");621 system("rm -rf mobile_model_netout.omc");
622}622}
623+ 
624+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithVariousAttrTypes_CovEnhance) {
625+ std::string output_file = "mobile_model_attrs.om";
626+ ModelBufferData model;
627+ MobileModelHelper model_save_helper;
628+ GeRootModelPtr ge_root_model = GenGeRootModel();
629+ auto graph = ge_root_model->GetRootGraph();
630+ for (const auto &node : graph->GetDirectNode()) {
631+ auto op_desc = node->GetOpDesc();
632+ if (op_desc == nullptr) {
633+ continue;
634+ }
635+ if (node->GetType() == "Add") {
636+ std::vector<float> float_list = {1.0F, 2.0F, 3.0F};
637+ ge::AttrUtils::SetListFloat(op_desc, "test_list_float_attr", float_list);
638+ std::vector<bool> bool_list = {true, false, true};
639+ ge::AttrUtils::SetListBool(op_desc, "test_list_bool_attr", bool_list);
640+ std::vector<ge::Buffer> bytes_list = {ge::Buffer(10, 1), ge::Buffer(5, 0)};
641+ ge::AttrUtils::SetListBytes(op_desc, "test_list_bytes_attr", bytes_list);
642+ ge::GeTensorDesc tensor_desc(ge::GeShape({8}), ge::FORMAT_ND, ge::DT_INT64);
643+ ge::GeTensor tensor(tensor_desc);
644+ ge::AttrUtils::SetTensor(op_desc, "test_tensor_attr", tensor);
645+ std::vector<ge::GeTensor> tensor_list = {tensor};
646+ ge::AttrUtils::SetListTensor(op_desc, "test_list_tensor_attr", tensor_list);
647+ op_desc->SetWorkspace({1024, 2048});
648+ op_desc->SetWorkspaceBytes({1024, 2048});
649+ break;
650+ }
651+ }
652+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
653+ system("rm -rf mobile_model_attrs.omc");
654+}
655+ 
656+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithConnectedNodes_CovEnhance) {
657+ std::string output_file = "mobile_model_connected.om";
658+ ModelBufferData model;
659+ MobileModelHelper model_save_helper;
660+ GeRootModelPtr ge_root_model = GenGeRootModel();
661+ auto graph = ge_root_model->GetRootGraph();
662+ ge::NodePtr data_node = nullptr;
663+ ge::NodePtr add_node = nullptr;
664+ ge::NodePtr netoutput_node = nullptr;
665+ for (const auto &node : graph->GetDirectNode()) {
666+ if (node->GetType() == "Data") {
667+ data_node = node;
668+ } else if (node->GetType() == "Add") {
669+ add_node = node;
670+ } else if (node->GetType() == "NetOutput") {
671+ netoutput_node = node;
672+ }
673+ }
674+ if ((data_node != nullptr) && (add_node != nullptr)) {
675+ (void)ge::GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), add_node->GetInDataAnchor(0));
676+ }
677+ if ((add_node != nullptr) && (netoutput_node != nullptr)) {
678+ (void)ge::GraphUtils::AddEdge(add_node->GetOutDataAnchor(0), netoutput_node->GetInDataAnchor(0));
679+ }
680+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
681+ system("rm -rf mobile_model_connected.omc");
682+}
683+ 
684+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithNullRootModel) {
685+ std::string output_file = "mobile_model_null.om";
686+ ModelBufferData model;
687+ MobileModelHelper model_save_helper;
688+ GeRootModelPtr null_root_model = nullptr;
689+ EXPECT_NE(model_save_helper.SaveToOmRootModel(null_root_model, output_file, model, false), ge::SUCCESS);
690+}
691+ 
692+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithEmptyOutputFile) {
693+ ModelBufferData model;
694+ MobileModelHelper model_save_helper;
695+ GeRootModelPtr ge_root_model = GenGeRootModel();
696+ EXPECT_NE(model_save_helper.SaveToOmRootModel(ge_root_model, "", model, false), ge::SUCCESS);
697+}
698+ 
699+TEST_F(UtestMobileModelHelper, SaveToOmModelWithEmptyOutputFile) {
700+ ModelBufferData model;
701+ MobileModelHelper model_save_helper;
702+ GeRootModelPtr ge_root_model = GenGeRootModel();
703+ auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
704+ auto &model_root = name_to_ge_model.begin()->second;
705+ EXPECT_EQ(model_save_helper.SaveToOmModel(model_root, "", model, ge_root_model), ge::FAILED);
706+}
707+ 
708+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithEmptySubgraphModels) {
709+ std::string output_file = "mobile_model_empty_sub.om";
710+ ModelBufferData model;
711+ MobileModelHelper model_save_helper;
712+ GeRootModelPtr ge_root_model = std::make_shared<ge::GeRootModel>();
713+ EXPECT_NE(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
714+}
715+ 
716+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithKernelArgsSizeZero) {
717+ std::string output_file = "mobile_model_zero_args.om";
718+ ModelBufferData model;
719+ MobileModelHelper model_save_helper;
720+ GeRootModelPtr ge_root_model = GenGeRootModel();
721+ auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
722+ auto model_task = ge_model->GetModelTaskDefPtr();
723+ if (model_task != nullptr && model_task->task_size() > 0) {
724+ auto *task = model_task->mutable_task(0);
725+ auto *kernel = task->mutable_kernel();
726+ kernel->set_args_size(0);
727+ kernel->clear_args();
728+ }
729+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
730+ system("rm -rf mobile_model_zero_args.omc");
731+}
732+ 
733+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithNoKernelNameAttr) {
734+ std::string output_file = "mobile_model_no_kernelname.om";
735+ ModelBufferData model;
736+ MobileModelHelper model_save_helper;
737+ GeRootModelPtr ge_root_model = GenGeRootModel();
738+ auto graph = ge_root_model->GetRootGraph();
739+ for (const auto &node : graph->GetDirectNode()) {
740+ if (node->GetType() == "Add") {
741+ (void)node->GetOpDesc()->DelAttr("_kernelname");
742+ break;
743+ }
744+ }
745+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
746+ system("rm -rf mobile_model_no_kernelname.omc");
747+}
748+ 
749+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithTaskDefAttrs) {
750+ std::string output_file = "mobile_model_task_attrs.om";
751+ ModelBufferData model;
752+ MobileModelHelper model_save_helper;
753+ GeRootModelPtr ge_root_model = GenGeRootModel();
754+ auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
755+ auto model_task = ge_model->GetModelTaskDefPtr();
756+ if (model_task != nullptr) {
757+ auto *attr_map = model_task->mutable_attr();
758+ (*attr_map)["test_attr_key"] = "test_attr_value";
759+ }
760+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
761+ system("rm -rf mobile_model_task_attrs.omc");
762+}
763+ 
764+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithMultipleDynamicInputs) {
765+ std::string output_file = "mobile_model_multi_dynamic.om";
766+ ModelBufferData model;
767+ MobileModelHelper model_save_helper;
768+ GeRootModelPtr ge_root_model = GenGeRootModel();
769+ auto graph = ge_root_model->GetRootGraph();
770+ for (const auto &node : graph->GetDirectNode()) {
771+ if (node->GetType() == "Add") {
772+ auto op_desc = node->GetOpDesc();
773+ std::vector<std::vector<int64_t>> dynamic_inputs_indexes = {{0, 1}, {0}};
774+ ge::AttrUtils::SetListListInt(op_desc, "_dynamic_inputs_indexes", dynamic_inputs_indexes);
775+ std::vector<std::vector<int64_t>> dynamic_outputs_indexes = {{0}, {0}};
776+ ge::AttrUtils::SetListListInt(op_desc, "_dynamic_outputs_indexes", dynamic_outputs_indexes);
777+ break;
778+ }
779+ }
780+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
781+ system("rm -rf mobile_model_multi_dynamic.omc");
782+}
783+ 
784+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithInvalidDynamicInputIndex) {
785+ std::string output_file = "mobile_model_invalid_dynamic.om";
786+ ModelBufferData model;
787+ MobileModelHelper model_save_helper;
788+ GeRootModelPtr ge_root_model = GenGeRootModel();
789+ auto graph = ge_root_model->GetRootGraph();
790+ for (const auto &node : graph->GetDirectNode()) {
791+ if (node->GetType() == "Add") {
792+ auto op_desc = node->GetOpDesc();
793+ std::vector<std::vector<int64_t>> dynamic_inputs_indexes = {{99}};
794+ ge::AttrUtils::SetListListInt(op_desc, "_dynamic_inputs_indexes", dynamic_inputs_indexes);
795+ break;
796+ }
797+ }
798+ EXPECT_NE(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
799+ system("rm -rf mobile_model_invalid_dynamic.omc");
800+}
801+ 
802+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithInvalidDynamicOutputIndex) {
803+ std::string output_file = "mobile_model_invalid_dynamic_out.om";
804+ ModelBufferData model;
805+ MobileModelHelper model_save_helper;
806+ GeRootModelPtr ge_root_model = GenGeRootModel();
807+ auto graph = ge_root_model->GetRootGraph();
808+ for (const auto &node : graph->GetDirectNode()) {
809+ if (node->GetType() == "Add") {
810+ auto op_desc = node->GetOpDesc();
811+ std::vector<std::vector<int64_t>> dynamic_outputs_indexes = {{99}};
812+ ge::AttrUtils::SetListListInt(op_desc, "_dynamic_outputs_indexes", dynamic_outputs_indexes);
813+ break;
814+ }
815+ }
816+ EXPECT_NE(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
817+ system("rm -rf mobile_model_invalid_dynamic_out.omc");
818+}
623} // namespace ge819} // namespace ge
Mtests/ge/ut/ge/common/model_saver_unittest.cc+5-0
@@ -74,4 +74,9 @@ TEST_F(UtestModelSaver, SaveJsonToFile_nested_json_success) {
74 system("rm -rf ./test_nested_json.pb");74 system("rm -rf ./test_nested_json.pb");
75}75}
76 76 
77+TEST_F(UtestModelSaver, SaveJsonToFile_dump_exception_CovEnhance) {
78+ Json discarded_json = Json::value_t::discarded;
79+ EXPECT_EQ(ModelSaver::SaveJsonToFile("./test_dump_exception.pb", discarded_json), SUCCESS);
80+ system("rm -f ./test_dump_exception.pb");
81+}
77} // namespace ge82} // namespace ge
Mtests/ge/ut/ge/common/om2_codegen_model_builder_unittest.cc+254-0
@@ -2187,4 +2187,258 @@ TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_SimpleTasksWithStub_Ok) {
2187 Om2CodegenModel doc;2187 Om2CodegenModel doc;
2188 ASSERT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);2188 ASSERT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2189}2189}
2190+ 
2191+static GeRootModelPtr CreateGeRootModelWithUnsupportedTask() {
2192+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicoreOp();
2193+ if (ge_root_model == nullptr) {
2194+ return nullptr;
2195+ }
2196+ const auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
2197+ if (name_to_ge_model.empty()) {
2198+ return nullptr;
2199+ }
2200+ const auto ge_model = name_to_ge_model.begin()->second;
2201+ auto *model_task_def = ge_model->GetModelTaskDefPtr().get();
2202+ if (model_task_def == nullptr) {
2203+ return nullptr;
2204+ }
2205+ auto *bad_task = model_task_def->add_task();
2206+ if (bad_task == nullptr) {
2207+ return nullptr;
2208+ }
2209+ bad_task->set_type(999U);
2210+ bad_task->set_stream_id(0U);
2211+ return ge_root_model;
2212+}
2213+ 
2214+static GeModelPtr CreateGeModelWithStreamActiveMissingAttr() {
2215+ auto graph = std::make_shared<ComputeGraph>("g1");
2216+ GeTensorDesc tensor_desc(GeShape({1, 4, 4, 8}), FORMAT_NCHW, DT_FLOAT);
2217+ TensorUtils::SetSize(tensor_desc, 512U);
2218+ 
2219+ auto data0_desc = std::make_shared<OpDesc>("data0", DATA);
2220+ (void)data0_desc->AddOutputDesc(tensor_desc);
2221+ auto data0 = graph->AddNode(data0_desc);
2222+ 
2223+ auto sa_desc = std::make_shared<OpDesc>("sa", STREAMACTIVE);
2224+ (void)sa_desc->AddInputDesc(tensor_desc);
2225+ (void)AttrUtils::SetStr(sa_desc, ATTR_NAME_SWITCH_BRANCH_NODE_LABEL, "label_0");
2226+ auto sa = graph->AddNode(sa_desc);
2227+ 
2228+ if ((data0 == nullptr) || (sa == nullptr)) {
2229+ return nullptr;
2230+ }
2231+ GraphUtils::AddEdge(data0->GetOutDataAnchor(0), sa->GetInDataAnchor(0));
2232+ graph->TopologicalSorting();
2233+ graph->SetGraphUnknownFlag(false);
2234+ data0_desc->SetOutputOffset({1024});
2235+ 
2236+ auto ge_model = MakeShared<GeModel>();
2237+ if (ge_model == nullptr) {
2238+ return nullptr;
2239+ }
2240+ ge_model->SetGraph(graph);
2241+ ge_model->SetModelTaskDef(MakeShared<domi::ModelTaskDef>());
2242+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 4096);
2243+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_WEIGHT_SIZE, 0);
2244+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_STREAM_NUM, 2);
2245+ return ge_model;
2246+}
2247+ 
2248+static GeModelPtr CreateGeModelWithStreamSwitchWrongSize() {
2249+ auto graph = std::make_shared<ComputeGraph>("g1");
2250+ GeTensorDesc tensor_desc(GeShape({1, 4, 4, 8}), FORMAT_NCHW, DT_FLOAT);
2251+ TensorUtils::SetSize(tensor_desc, 512U);
2252+ 
2253+ auto data0_desc = std::make_shared<OpDesc>("data0", DATA);
2254+ (void)data0_desc->AddOutputDesc(tensor_desc);
2255+ auto data0 = graph->AddNode(data0_desc);
2256+ 
2257+ auto data1_desc = std::make_shared<OpDesc>("data1", DATA);
2258+ (void)data1_desc->AddOutputDesc(tensor_desc);
2259+ auto data1 = graph->AddNode(data1_desc);
2260+ 
2261+ auto ss_desc = std::make_shared<OpDesc>("ss", STREAMSWITCH);
2262+ (void)ss_desc->AddInputDesc("pred", tensor_desc);
2263+ (void)ss_desc->AddInputDesc("value", tensor_desc);
2264+ ss_desc->SetInputOffset({1024, 2048});
2265+ (void)AttrUtils::SetInt(ss_desc, ATTR_NAME_STREAM_SWITCH_COND, 1);
2266+ (void)AttrUtils::SetListInt(ss_desc, ATTR_NAME_ACTIVE_STREAM_LIST, {1, 2});
2267+ (void)AttrUtils::SetInt(ss_desc, ATTR_NAME_SWITCH_DATA_TYPE, 0);
2268+ auto ss = graph->AddNode(ss_desc);
2269+ 
2270+ if ((data0 == nullptr) || (data1 == nullptr) || (ss == nullptr)) {
2271+ return nullptr;
2272+ }
2273+ GraphUtils::AddEdge(data0->GetOutDataAnchor(0), ss->GetInDataAnchor(0));
2274+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), ss->GetInDataAnchor(1));
2275+ graph->TopologicalSorting();
2276+ graph->SetGraphUnknownFlag(false);
2277+ data0_desc->SetOutputOffset({1024});
2278+ data1_desc->SetOutputOffset({2048});
2279+ 
2280+ auto ge_model = MakeShared<GeModel>();
2281+ if (ge_model == nullptr) {
2282+ return nullptr;
2283+ }
2284+ ge_model->SetGraph(graph);
2285+ ge_model->SetModelTaskDef(MakeShared<domi::ModelTaskDef>());
2286+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 4096);
2287+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_WEIGHT_SIZE, 0);
2288+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_STREAM_NUM, 3);
2289+ return ge_model;
2290+}
2291+ 
2292+static GeModelPtr CreateGeModelWithStreamActiveOk() {
2293+ auto graph = std::make_shared<ComputeGraph>("g1");
2294+ GeTensorDesc tensor_desc(GeShape({1, 4, 4, 8}), FORMAT_NCHW, DT_FLOAT);
2295+ TensorUtils::SetSize(tensor_desc, 512U);
2296+ 
2297+ auto data0_desc = std::make_shared<OpDesc>("data0", DATA);
2298+ (void)data0_desc->AddOutputDesc(tensor_desc);
2299+ auto data0 = graph->AddNode(data0_desc);
2300+ 
2301+ auto sa_desc = std::make_shared<OpDesc>("sa", STREAMACTIVE);
2302+ (void)sa_desc->AddInputDesc(tensor_desc);
2303+ (void)AttrUtils::SetStr(sa_desc, ATTR_NAME_SWITCH_BRANCH_NODE_LABEL, "label_0");
2304+ (void)AttrUtils::SetListInt(sa_desc, ATTR_NAME_ACTIVE_STREAM_LIST, {1});
2305+ auto sa = graph->AddNode(sa_desc);
2306+ 
2307+ if ((data0 == nullptr) || (sa == nullptr)) {
2308+ return nullptr;
2309+ }
2310+ GraphUtils::AddEdge(data0->GetOutDataAnchor(0), sa->GetInDataAnchor(0));
2311+ graph->TopologicalSorting();
2312+ graph->SetGraphUnknownFlag(false);
2313+ data0_desc->SetOutputOffset({1024});
2314+ 
2315+ auto ge_model = MakeShared<GeModel>();
2316+ if (ge_model == nullptr) {
2317+ return nullptr;
2318+ }
2319+ ge_model->SetGraph(graph);
2320+ ge_model->SetModelTaskDef(MakeShared<domi::ModelTaskDef>());
2321+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_MEMORY_SIZE, 4096);
2322+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_WEIGHT_SIZE, 0);
2323+ (void)AttrUtils::SetInt(ge_model, ATTR_MODEL_STREAM_NUM, 2);
2324+ return ge_model;
2325+}
2326+ 
2327+static GeRootModelPtr CreateGeRootModelWithHugeStream() {
2328+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicoreOp();
2329+ if (ge_root_model == nullptr) {
2330+ return nullptr;
2331+ }
2332+ const auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
2333+ if (name_to_ge_model.empty()) {
2334+ return nullptr;
2335+ }
2336+ const auto ge_model = name_to_ge_model.begin()->second;
2337+ (void)AttrUtils::SetListInt(ge_model, ATTR_MODEL_HUGE_STREAM_LIST, {0});
2338+ return ge_root_model;
2339+}
2340+ 
2341+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_UnsupportedTaskType_ReturnsFailed) {
2342+ GeRootModelPtr ge_root_model = CreateGeRootModelWithUnsupportedTask();
2343+ ASSERT_NE(ge_root_model, nullptr);
2344+ Om2CodegenModel doc;
2345+ EXPECT_NE(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2346+}
2347+ 
2348+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_StreamActiveMissingAttr_ReturnsError) {
2349+ GeModelPtr ge_model = CreateGeModelWithStreamActiveMissingAttr();
2350+ ASSERT_NE(ge_model, nullptr);
2351+ Om2CodegenModel doc;
2352+ EXPECT_EQ(BuildCodegenModel(ge_model, doc), SUCCESS);
2353+}
2354+ 
2355+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_StreamSwitchWrongSize_ReturnsError) {
2356+ GeModelPtr ge_model = CreateGeModelWithStreamSwitchWrongSize();
2357+ ASSERT_NE(ge_model, nullptr);
2358+ Om2CodegenModel doc;
2359+ EXPECT_EQ(BuildCodegenModel(ge_model, doc), SUCCESS);
2360+}
2361+ 
2362+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_StreamActiveOk) {
2363+ GeModelPtr ge_model = CreateGeModelWithStreamActiveOk();
2364+ ASSERT_NE(ge_model, nullptr);
2365+ Om2CodegenModel doc;
2366+ EXPECT_EQ(BuildCodegenModel(ge_model, doc), SUCCESS);
2367+}
2368+ 
2369+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_HugeStream_Ok) {
2370+ GeRootModelPtr ge_root_model = CreateGeRootModelWithHugeStream();
2371+ ASSERT_NE(ge_root_model, nullptr);
2372+ Om2CodegenModel doc;
2373+ EXPECT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2374+}
2375+ 
2376+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_RuntimeAttrs_Ok) {
2377+ GeRootModelPtr ge_root_model = CreateGeRootModelWithRuntimeAttrs();
2378+ ASSERT_NE(ge_root_model, nullptr);
2379+ Om2CodegenModel doc;
2380+ EXPECT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2381+}
2382+ 
2383+static GeRootModelPtr CreateGeRootModelWithOpNeedPrint() {
2384+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicoreOp();
2385+ if (ge_root_model == nullptr) {
2386+ return nullptr;
2387+ }
2388+ const auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
2389+ if (name_to_ge_model.empty()) {
2390+ return nullptr;
2391+ }
2392+ const auto ge_model = name_to_ge_model.begin()->second;
2393+ const auto compute_graph = ge_model->GetGraph();
2394+ if (compute_graph == nullptr) {
2395+ return nullptr;
2396+ }
2397+ for (const auto &node : compute_graph->GetDirectNode()) {
2398+ auto op_desc = node->GetOpDesc();
2399+ if ((op_desc != nullptr) && (op_desc->GetType() == "Add")) {
2400+ (void)AttrUtils::SetListStr(op_desc, "_op_dfx_options", {"printf"});
2401+ break;
2402+ }
2403+ }
2404+ return ge_root_model;
2405+}
2406+ 
2407+static GeRootModelPtr CreateGeRootModelWithBlockingAicpuOp() {
2408+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicpuOp();
2409+ if (ge_root_model == nullptr) {
2410+ return nullptr;
2411+ }
2412+ const auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
2413+ if (name_to_ge_model.empty()) {
2414+ return nullptr;
2415+ }
2416+ const auto ge_model = name_to_ge_model.begin()->second;
2417+ const auto compute_graph = ge_model->GetGraph();
2418+ if (compute_graph == nullptr) {
2419+ return nullptr;
2420+ }
2421+ for (const auto &node : compute_graph->GetDirectNode()) {
2422+ auto op_desc = node->GetOpDesc();
2423+ if ((op_desc != nullptr) && (op_desc->GetType() == "Add")) {
2424+ (void)AttrUtils::SetBool(op_desc, ATTR_NAME_IS_BLOCKING_OP, true);
2425+ break;
2426+ }
2427+ }
2428+ return ge_root_model;
2429+}
2430+ 
2431+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_OpNeedPrint_ReturnsFailed) {
2432+ GeRootModelPtr ge_root_model = CreateGeRootModelWithOpNeedPrint();
2433+ ASSERT_NE(ge_root_model, nullptr);
2434+ Om2CodegenModel doc;
2435+ EXPECT_NE(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2436+}
2437+ 
2438+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_BlockingAicpuOp_ReturnsFailed) {
2439+ GeRootModelPtr ge_root_model = CreateGeRootModelWithBlockingAicpuOp();
2440+ ASSERT_NE(ge_root_model, nullptr);
2441+ Om2CodegenModel doc;
2442+ EXPECT_NE(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2443+}
2190} // namespace ge2444} // namespace ge
Mtests/ge/ut/ge/common/om2_codegen_unittest.cc+334-0
@@ -2331,4 +2331,338 @@ TEST_F(Om2CodegenUt, CppEmitter_EmptyTypeNameSeparator) {
2331 const auto output = EmitNode(*tu);2331 const auto output = EmitNode(*tu);
2332 EXPECT_NE(output.find("EmptyTypeAlias"), std::string::npos);2332 EXPECT_NE(output.find("EmptyTypeAlias"), std::string::npos);
2333}2333}
2334+ 
2335+TEST_F(Om2CodegenUt, CppEmitter_InvalidEnumDefaults) {
2336+ AstContext ctx;
2337+ auto *ident_x = IdentifierExpr::Create(ctx, "x");
2338+ auto *ident_y = IdentifierExpr::Create(ctx, "y");
2339+ auto *ident_vec = IdentifierExpr::Create(ctx, "vec");
2340+ auto *count = IdentifierExpr::Create(ctx, "count");
2341+ 
2342+ CppEmitter emitter;
2343+ std::string output;
2344+ 
2345+ AccessSectionDecl invalid_access(static_cast<AccessSectionDecl::Kind>(99));
2346+ output.clear();
2347+ EXPECT_EQ(invalid_access.Accept(emitter, output), SUCCESS);
2348+ 
2349+ CppCastExpr invalid_cast_kind(static_cast<CppCastExpr::Kind>(99), StringRef("int"), ident_x);
2350+ output.clear();
2351+ EXPECT_EQ(invalid_cast_kind.Accept(emitter, output), SUCCESS);
2352+ 
2353+ BinaryExpr invalid_binary_op(static_cast<BinaryExpr::Op>(99), ident_x, ident_y);
2354+ output.clear();
2355+ EXPECT_EQ(invalid_binary_op.Accept(emitter, output), SUCCESS);
2356+ 
2357+ UnaryExpr invalid_unary_op(static_cast<UnaryExpr::Op>(99), ident_x);
2358+ output.clear();
2359+ EXPECT_EQ(invalid_unary_op.Accept(emitter, output), SUCCESS);
2360+ 
2361+ ContainerMethodExpr invalid_container_method(static_cast<ContainerMethodExpr::Method>(99), ident_vec,
2362+ ArrayRef<Expr *>());
2363+ output.clear();
2364+ EXPECT_EQ(invalid_container_method.Accept(emitter, output), SUCCESS);
2365+ 
2366+ MakeUniqueArrayExpr invalid_builtin_type(static_cast<BuiltinType>(99), count);
2367+ output.clear();
2368+ EXPECT_EQ(invalid_builtin_type.Accept(emitter, output), SUCCESS);
2369+ 
2370+ LiteralExpr invalid_literal_kind(static_cast<LiteralExpr::Kind>(99), 0, LiteralExpr::IntSuffix::kNone, false,
2371+ StringRef());
2372+ output.clear();
2373+ EXPECT_EQ(invalid_literal_kind.Accept(emitter, output), FAILED);
2374+ 
2375+ LiteralExpr invalid_int_suffix(LiteralExpr::Kind::kInt, 42, static_cast<LiteralExpr::IntSuffix>(99), false,
2376+ StringRef());
2377+ output.clear();
2378+ EXPECT_EQ(invalid_int_suffix.Accept(emitter, output), SUCCESS);
2379+}
2380+ 
2381+TEST_F(Om2CodegenUt, CppEmitter_ForInitEdgeCases) {
2382+ AstContext ctx;
2383+ AstBuildContext ast(ctx);
2384+ 
2385+ auto i = ast.Var("size_t", "i");
2386+ 
2387+ auto *for_no_init = ast.For(VarDeclStmt::Create(ctx, "size_t", "j"), i < 4, ast.PreInc(i), {ast.Assign(i, 0)});
2388+ ASSERT_NE(for_no_init, nullptr);
2389+ const auto output1 = EmitNode(*for_no_init);
2390+ EXPECT_NE(output1.find("for (size_t j;"), std::string::npos);
2391+ 
2392+ auto *for_comment_init = ast.For(CommentStmt::Create(ctx, "init"), i < 4, ast.PreInc(i), {ast.Assign(i, 0)});
2393+ ASSERT_NE(for_comment_init, nullptr);
2394+ CppEmitter emitter;
2395+ std::string output2;
2396+ EXPECT_EQ(for_comment_init->Accept(emitter, output2), FAILED);
2397+}
2398+ 
2399+TEST_F(Om2CodegenUt, CppEmitter_ErrorPropagationInExpressions) {
2400+ AstContext ctx;
2401+ auto *ident_x = IdentifierExpr::Create(ctx, "x");
2402+ auto *ident_y = IdentifierExpr::Create(ctx, "y");
2403+ auto *ident_vec = IdentifierExpr::Create(ctx, "vec");
2404+ auto *ident_fn = IdentifierExpr::Create(ctx, "fn");
2405+ auto *count = IdentifierExpr::Create(ctx, "count");
2406+ auto *path = IdentifierExpr::Create(ctx, "path");
2407+ 
2408+ LiteralExpr failing(static_cast<LiteralExpr::Kind>(99), 0, LiteralExpr::IntSuffix::kNone, false, StringRef());
2409+ 
2410+ CppEmitter emitter;
2411+ std::string output;
2412+ 
2413+ AssignExpr assign_failing_lhs(&failing, ident_y);
2414+ output.clear();
2415+ EXPECT_EQ(assign_failing_lhs.Accept(emitter, output), FAILED);
2416+ 
2417+ BinaryExpr binary_failing_lhs(BinaryExpr::Op::kAdd, &failing, ident_y);
2418+ output.clear();
2419+ EXPECT_EQ(binary_failing_lhs.Accept(emitter, output), FAILED);
2420+ 
2421+ BinaryExpr binary_failing_rhs(BinaryExpr::Op::kAdd, ident_x, &failing);
2422+ output.clear();
2423+ EXPECT_EQ(binary_failing_rhs.Accept(emitter, output), FAILED);
2424+ 
2425+ UnaryExpr unary_failing(UnaryExpr::Op::kNegate, &failing);
2426+ output.clear();
2427+ EXPECT_EQ(unary_failing.Accept(emitter, output), FAILED);
2428+ 
2429+ auto *call_failing_callee = CallExpr::Create(ctx, &failing, {ident_x});
2430+ output.clear();
2431+ EXPECT_EQ(call_failing_callee->Accept(emitter, output), FAILED);
2432+ 
2433+ auto *call_failing_arg = CallExpr::Create(ctx, ident_fn, {ident_x, &failing});
2434+ output.clear();
2435+ EXPECT_EQ(call_failing_arg->Accept(emitter, output), FAILED);
2436+ 
2437+ MakeUniqueArrayExpr make_unique_failing(BuiltinType::kUInt8, &failing);
2438+ output.clear();
2439+ EXPECT_EQ(make_unique_failing.Accept(emitter, output), FAILED);
2440+ 
2441+ ToStrExpr to_str_failing(&failing);
2442+ output.clear();
2443+ EXPECT_EQ(to_str_failing.Accept(emitter, output), FAILED);
2444+ 
2445+ MemcpyExpr memcpy_failing_dst(&failing, ident_x, ident_y);
2446+ output.clear();
2447+ EXPECT_EQ(memcpy_failing_dst.Accept(emitter, output), FAILED);
2448+ 
2449+ MemcpyExpr memcpy_failing_src(ident_x, &failing, ident_y);
2450+ output.clear();
2451+ EXPECT_EQ(memcpy_failing_src.Accept(emitter, output), FAILED);
2452+ 
2453+ MemcpyExpr memcpy_failing_size(ident_x, ident_y, &failing);
2454+ output.clear();
2455+ EXPECT_EQ(memcpy_failing_size.Accept(emitter, output), FAILED);
2456+ 
2457+ SizeofExpr sizeof_failing(&failing);
2458+ output.clear();
2459+ EXPECT_EQ(sizeof_failing.Accept(emitter, output), FAILED);
2460+ 
2461+ RemoveFileExpr remove_file_failing(&failing);
2462+ output.clear();
2463+ EXPECT_EQ(remove_file_failing.Accept(emitter, output), FAILED);
2464+ 
2465+ IgnoreOutputExpr ignore_output_failing(&failing);
2466+ output.clear();
2467+ EXPECT_EQ(ignore_output_failing.Accept(emitter, output), FAILED);
2468+ 
2469+ std::vector<Expr *> container_args = {ident_x, &failing};
2470+ ContainerMethodExpr container_failing_arg(ContainerMethodExpr::Method::kAt, ident_vec,
2471+ ArrayRef<Expr *>(container_args.data(), container_args.size()));
2472+ output.clear();
2473+ EXPECT_EQ(container_failing_arg.Accept(emitter, output), FAILED);
2474+ 
2475+ SubscriptExpr subscript_failing_base(&failing, ident_x);
2476+ output.clear();
2477+ EXPECT_EQ(subscript_failing_base.Accept(emitter, output), FAILED);
2478+ 
2479+ SubscriptExpr subscript_failing_index(ident_vec, &failing);
2480+ output.clear();
2481+ EXPECT_EQ(subscript_failing_index.Accept(emitter, output), FAILED);
2482+ 
2483+ MemberExpr member_failing(&failing, StringRef("field"));
2484+ output.clear();
2485+ EXPECT_EQ(member_failing.Accept(emitter, output), FAILED);
2486+ 
2487+ CppArrowMemberExpr arrow_failing(&failing, StringRef("field"));
2488+ output.clear();
2489+ EXPECT_EQ(arrow_failing.Accept(emitter, output), FAILED);
2490+ 
2491+ CppCastExpr cast_failing(CppCastExpr::Kind::kStatic, StringRef("int"), &failing);
2492+ output.clear();
2493+ EXPECT_EQ(cast_failing.Accept(emitter, output), FAILED);
2494+ 
2495+ std::vector<Expr *> init_list_elems = {ident_x, &failing};
2496+ InitListExpr compact_init_failing(ArrayRef<Expr *>(init_list_elems.data(), init_list_elems.size()), true);
2497+ output.clear();
2498+ EXPECT_EQ(compact_init_failing.Accept(emitter, output), FAILED);
2499+ 
2500+ InitListExpr noncompact_init_failing(ArrayRef<Expr *>(init_list_elems.data(), init_list_elems.size()), false);
2501+ output.clear();
2502+ EXPECT_EQ(noncompact_init_failing.Accept(emitter, output), FAILED);
2503+ 
2504+ std::vector<StringRef> desig_names = {StringRef("a"), StringRef("b")};
2505+ std::vector<Expr *> desig_values = {ident_x, &failing};
2506+ DesignatedInitListExpr compact_desig_failing(ArrayRef<StringRef>(desig_names.data(), desig_names.size()),
2507+ ArrayRef<Expr *>(desig_values.data(), desig_values.size()), true);
2508+ output.clear();
2509+ EXPECT_EQ(compact_desig_failing.Accept(emitter, output), FAILED);
2510+ 
2511+ DesignatedInitListExpr noncompact_desig_failing(ArrayRef<StringRef>(desig_names.data(), desig_names.size()),
2512+ ArrayRef<Expr *>(desig_values.data(), desig_values.size()), false);
2513+ output.clear();
2514+ EXPECT_EQ(noncompact_desig_failing.Accept(emitter, output), FAILED);
2515+}
2516+ 
2517+TEST_F(Om2CodegenUt, CppEmitter_ErrorPropagationInStatements) {
2518+ AstContext ctx;
2519+ AstBuildContext ast(ctx);
2520+ 
2521+ auto *ident_x = IdentifierExpr::Create(ctx, "x");
2522+ auto *ident_y = IdentifierExpr::Create(ctx, "y");
2523+ 
2524+ LiteralExpr failing(static_cast<LiteralExpr::Kind>(99), 0, LiteralExpr::IntSuffix::kNone, false, StringRef());
2525+ 
2526+ CppEmitter emitter;
2527+ std::string output;
2528+ 
2529+ VarDeclStmt var_decl_failing(StringRef("int"), StringRef("v"), &failing);
2530+ output.clear();
2531+ EXPECT_EQ(var_decl_failing.Accept(emitter, output), FAILED);
2532+ 
2533+ ExprStmt expr_stmt_failing(&failing);
2534+ output.clear();
2535+ EXPECT_EQ(expr_stmt_failing.Accept(emitter, output), FAILED);
2536+ 
2537+ ReturnStmt return_failing(&failing);
2538+ output.clear();
2539+ EXPECT_EQ(return_failing.Accept(emitter, output), FAILED);
2540+ 
2541+ std::vector<Stmt *> block_stmts = {ExprStmt::Create(ctx, ident_x), ExprStmt::Create(ctx, &failing)};
2542+ BlockStmt block_failing(ArrayRef<Stmt *>(block_stmts.data(), block_stmts.size()));
2543+ output.clear();
2544+ EXPECT_EQ(block_failing.Accept(emitter, output), FAILED);
2545+ 
2546+ auto *then_block = BlockStmt::Create(ctx, {ExprStmt::Create(ctx, ident_x)});
2547+ auto *else_block = BlockStmt::Create(ctx, {ExprStmt::Create(ctx, ident_y)});
2548+ IfStmt if_failing_cond(&failing, then_block, else_block);
2549+ output.clear();
2550+ EXPECT_EQ(if_failing_cond.Accept(emitter, output), FAILED);
2551+ 
2552+ std::vector<Stmt *> failing_then_stmts = {ExprStmt::Create(ctx, &failing)};
2553+ BlockStmt failing_then_block(ArrayRef<Stmt *>(failing_then_stmts.data(), failing_then_stmts.size()));
2554+ IfStmt if_failing_then(ident_x, &failing_then_block, else_block);
2555+ output.clear();
2556+ EXPECT_EQ(if_failing_then.Accept(emitter, output), FAILED);
2557+ 
2558+ IfStmt if_failing_else(ident_x, then_block, &failing_then_block);
2559+ output.clear();
2560+ EXPECT_EQ(if_failing_else.Accept(emitter, output), FAILED);
2561+ 
2562+ IfStmt pp_if_failing_cond(&failing, then_block, else_block, true);
2563+ output.clear();
2564+ EXPECT_EQ(pp_if_failing_cond.Accept(emitter, output), FAILED);
2565+ 
2566+ IfStmt pp_if_failing_then(ident_x, &failing_then_block, else_block, true);
2567+ output.clear();
2568+ EXPECT_EQ(pp_if_failing_then.Accept(emitter, output), FAILED);
2569+ 
2570+ IfStmt pp_if_failing_else(ident_x, then_block, &failing_then_block, true);
2571+ output.clear();
2572+ EXPECT_EQ(pp_if_failing_else.Accept(emitter, output), FAILED);
2573+ 
2574+ auto i = ast.Var("size_t", "i");
2575+ auto *for_failing_init =
2576+ ast.For(VarDeclStmt::Create(ctx, "int", "v", &failing), i < 4, ast.PreInc(i), {ast.Assign(i, 0)});
2577+ output.clear();
2578+ EXPECT_EQ(for_failing_init->Accept(emitter, output), FAILED);
2579+ 
2580+ auto *for_failing_cond = ast.For(ast.VarDecl(i, 0), &failing, ast.PreInc(i), {ast.Assign(i, 0)});
2581+ output.clear();
2582+ EXPECT_EQ(for_failing_cond->Accept(emitter, output), FAILED);
2583+ 
2584+ auto *for_failing_step = ast.For(ast.VarDecl(i, 0), i < 4, &failing, {ast.Assign(i, 0)});
2585+ output.clear();
2586+ EXPECT_EQ(for_failing_step->Accept(emitter, output), FAILED);
2587+ 
2588+ auto *for_failing_body =
2589+ ast.For(ast.VarDecl(i, 0), i < 4, ast.PreInc(i), {BodyItem(ExprStmt::Create(ctx, &failing))});
2590+ output.clear();
2591+ EXPECT_EQ(for_failing_body->Accept(emitter, output), FAILED);
2592+ 
2593+ auto values = ast.Var("std::vector<int>", "values");
2594+ auto range_body_stmts = ast.Body({BodyItem(ast.Assign(i, 0))});
2595+ RangeForStmt range_for_failing_range(StringRef("auto"), StringRef("item"), &failing,
2596+ BlockStmt::Create(ctx, range_body_stmts));
2597+ output.clear();
2598+ EXPECT_EQ(range_for_failing_range.Accept(emitter, output), FAILED);
2599+ 
2600+ RangeForStmt range_for_failing_body(StringRef("auto"), StringRef("item"), values.Get(), &failing_then_block);
2601+ output.clear();
2602+ EXPECT_EQ(range_for_failing_body.Accept(emitter, output), FAILED);
2603+}
2604+ 
2605+TEST_F(Om2CodegenUt, CppEmitter_ErrorPropagationInDeclarations) {
2606+ AstContext ctx;
2607+ AstBuildContext ast(ctx);
2608+ 
2609+ auto *ident_x = IdentifierExpr::Create(ctx, "x");
2610+ 
2611+ LiteralExpr failing(static_cast<LiteralExpr::Kind>(99), 0, LiteralExpr::IntSuffix::kNone, false, StringRef());
2612+ 
2613+ CppEmitter emitter;
2614+ std::string output;
2615+ 
2616+ FieldDecl field_failing(StringRef("int"), StringRef("v"), &failing);
2617+ output.clear();
2618+ EXPECT_EQ(field_failing.Accept(emitter, output), FAILED);
2619+ 
2620+ std::vector<DeclNode *> class_items = {AccessSectionDecl::Create(ctx, AccessSectionDecl::Kind::kPublic),
2621+ &field_failing};
2622+ ClassDecl class_failing(StringRef("Cls"), ArrayRef<DeclNode *>(class_items.data(), class_items.size()));
2623+ output.clear();
2624+ EXPECT_EQ(class_failing.Accept(emitter, output), FAILED);
2625+ 
2626+ StructDecl struct_failing(StringRef("S"), ArrayRef<DeclNode *>(class_items.data(), class_items.size()));
2627+ output.clear();
2628+ EXPECT_EQ(struct_failing.Accept(emitter, output), FAILED);
2629+ 
2630+ std::vector<DeclNode *> ns_items = {&field_failing};
2631+ NamespaceDecl ns_failing(StringRef("ns"), ArrayRef<DeclNode *>(ns_items.data(), ns_items.size()));
2632+ output.clear();
2633+ EXPECT_EQ(ns_failing.Accept(emitter, output), FAILED);
2634+ 
2635+ ExternBlockDecl extern_failing(StringRef("C"), ArrayRef<DeclNode *>(ns_items.data(), ns_items.size()));
2636+ output.clear();
2637+ EXPECT_EQ(extern_failing.Accept(emitter, output), FAILED);
2638+ 
2639+ auto *param_x = ParamDecl::Create(ctx, "int", "x");
2640+ auto *body = BlockStmt::Create(ctx, {ReturnStmt::Create(ctx, ident_x)});
2641+ std::vector<ParamDecl *> method_params = {param_x};
2642+ std::vector<StringRef> method_init_names = {StringRef("val_")};
2643+ std::vector<Expr *> method_init_exprs = {&failing};
2644+ MethodDef method_def_failing_init(StringRef("Worker"), StringRef("Worker"),
2645+ ArrayRef<ParamDecl *>(method_params.data(), method_params.size()), StringRef(""),
2646+ ArrayRef<StringRef>(method_init_names.data(), method_init_names.size()),
2647+ ArrayRef<Expr *>(method_init_exprs.data(), method_init_exprs.size()), body);
2648+ output.clear();
2649+ EXPECT_EQ(method_def_failing_init.Accept(emitter, output), FAILED);
2650+}
2651+ 
2652+TEST_F(Om2CodegenUt, CppEmitter_ContainerMethodMultiArgs) {
2653+ AstContext ctx;
2654+ 
2655+ auto *ident_vec = IdentifierExpr::Create(ctx, "vec");
2656+ auto *ident_x = IdentifierExpr::Create(ctx, "x");
2657+ auto *ident_y = IdentifierExpr::Create(ctx, "y");
2658+ 
2659+ std::vector<Expr *> multi_args = {ident_x, ident_y};
2660+ ContainerMethodExpr multi_arg_method(ContainerMethodExpr::Method::kAt, ident_vec,
2661+ ArrayRef<Expr *>(multi_args.data(), multi_args.size()));
2662+ 
2663+ CppEmitter emitter;
2664+ std::string output;
2665+ EXPECT_EQ(multi_arg_method.Accept(emitter, output), SUCCESS);
2666+ EXPECT_NE(output.find(", "), std::string::npos);
2667+}
2334} // namespace ge2668} // namespace ge
Mtests/ge/ut/ge/common/op_tiling_rt2_unittest.cc+9-0
@@ -1238,4 +1238,13 @@ TEST_F(RegisterOpTilingRT2UT, GetDeterministicLevel_WithSessionOption) {
1238 EXPECT_TRUE(has_deterministic_level);1238 EXPECT_TRUE(has_deterministic_level);
1239 ge::GetThreadLocalContext().SetSessionOption({});1239 ge::GetThreadLocalContext().SetSessionOption({});
1240}1240}
1241+ 
1242+TEST_F(RegisterOpTilingRT2UT, GetDeterministicLevel_NoSessionOption_CovEnhance) {
1243+ ge::GetThreadLocalContext().SetSessionOption({});
1244+ int32_t deterministic_level = -1;
1245+ bool has_deterministic_level = true;
1246+ EXPECT_EQ(GetDeterministicLevel(deterministic_level, has_deterministic_level), GRAPH_SUCCESS);
1247+ EXPECT_FALSE(has_deterministic_level);
1248+}
1249+ 
1241} // namespace optiling1250} // namespace optiling
Mtests/ge/ut/ge/common/ops_kernel_manager_unittest.cc+87-0
@@ -35,6 +35,20 @@ class SubOpsKernelInfoStore : public OpsKernelInfoStore {
35 virtual bool CheckSupported(const OpDescPtr &opDescPtr, std::string &un_supported_reason) const;35 virtual bool CheckSupported(const OpDescPtr &opDescPtr, std::string &un_supported_reason) const;
36};36};
37 37 
38+class SubOpsKernelInfoStoreFinalizeFail : public OpsKernelInfoStore {
39+ public:
40+ Status Initialize(const std::map<std::string, std::string> &options) override {
41+ return SUCCESS;
42+ }
43+ Status Finalize() override {
44+ return FAILED;
45+ }
46+ void GetAllOpsKernelInfo(std::map<std::string, OpInfo> &infos) const override {}
47+ bool CheckSupported(const OpDescPtr &opDescPtr, std::string &un_supported_reason) const override {
48+ return true;
49+ }
50+};
51+ 
38Status SubOpsKernelInfoStore::Initialize(const std::map<std::string, std::string> &options) {52Status SubOpsKernelInfoStore::Initialize(const std::map<std::string, std::string> &options) {
39 return FAILED;53 return FAILED;
40}54}
@@ -190,4 +204,77 @@ TEST_F(UtestOpsKernelManager, RefreshOpsKernelInfo) {
190 instance.ops_kernel_store_["kernel"] = std::make_shared<SubOpsKernelInfoStore>();204 instance.ops_kernel_store_["kernel"] = std::make_shared<SubOpsKernelInfoStore>();
191 EXPECT_EQ(instance.RefreshOpsKernelInfo(), SUCCESS);205 EXPECT_EQ(instance.RefreshOpsKernelInfo(), SUCCESS);
192}206}
207+ 
208+TEST_F(UtestOpsKernelManager, GetExternalEnginePathFromEnv) {
209+ auto &instance = OpsKernelManager::GetInstance();
210+ setenv("ASCEND_ENGINE_PATH", "/tmp/test_engine_path", 1);
211+ std::string extern_engine_path;
212+ std::map<std::string, std::string> options;
213+ instance.GetExternalEnginePath(extern_engine_path, options);
214+ EXPECT_EQ(extern_engine_path, "/tmp/test_engine_path");
215+ unsetenv("ASCEND_ENGINE_PATH");
216+}
217+ 
218+TEST_F(UtestOpsKernelManager, InitGraphOptimizersFailed) {
219+ auto &instance = OpsKernelManager::GetInstance();
220+ instance.graph_optimizers_["opt"] = std::make_shared<SubGraphOptimizer>();
221+ auto store_map = DNNEngineManager::GetInstance().engines_map_;
222+ DNNEngineManager::GetInstance().engines_map_[""] = MakeShared<DNNEngine>();
223+ std::map<std::string, std::string> options;
224+ EXPECT_EQ(instance.InitGraphOptimizers(options), SUCCESS);
225+ DNNEngineManager::GetInstance().engines_map_ = store_map;
226+ instance.graph_optimizers_.clear();
227+ instance.init_flag_ = false;
228+}
229+ 
230+TEST_F(UtestOpsKernelManager, FinalizeOpsKernelStoreFailed) {
231+ auto &instance = OpsKernelManager::GetInstance();
232+ instance.init_flag_ = true;
233+ instance.ops_kernel_store_["kernel"] = std::make_shared<SubOpsKernelInfoStoreFinalizeFail>();
234+ EXPECT_EQ(instance.Finalize(), FAILED);
235+ instance.ops_kernel_store_.clear();
236+ instance.init_flag_ = false;
237+}
238+ 
239+TEST_F(UtestOpsKernelManager, FinalizeGraphOptimizerFailed) {
240+ auto &instance = OpsKernelManager::GetInstance();
241+ instance.init_flag_ = true;
242+ instance.ops_kernel_store_.clear();
243+ auto p = std::make_shared<SubGraphOptimizer>();
244+ p->final_flag_ = false;
245+ instance.graph_optimizers_["opt"] = p;
246+ EXPECT_EQ(instance.Finalize(), FAILED);
247+ instance.graph_optimizers_.clear();
248+ instance.init_flag_ = false;
249+}
250+ 
251+TEST_F(UtestOpsKernelManager, GetGraphOptimizerByEngineWithAttrs) {
252+ auto &instance = OpsKernelManager::GetInstance();
253+ instance.graph_optimizers_["opt"] = std::make_shared<SubGraphOptimizer>();
254+ std::vector<GraphOptimizerPtr> graph_optimizer;
255+ EXPECT_NO_THROW(instance.GetGraphOptimizerByEngine("", graph_optimizer));
256+}
257+ 
258+TEST_F(UtestOpsKernelManager, ClassifyGraphOptimizersWithComposite) {
259+ auto &instance = OpsKernelManager::GetInstance();
260+ std::set<std::string> engine_set = {"AIcoreEngine"};
261+ instance.composite_engines_["AIcoreEngine"] = engine_set;
262+ instance.graph_optimizers_["opt"] = std::make_shared<SubGraphOptimizer>();
263+ EXPECT_NO_THROW(instance.ClassifyGraphOptimizers());
264+ instance.composite_engines_.clear();
265+ instance.graph_optimizers_.clear();
266+ instance.atomic_graph_optimizers_.clear();
267+ instance.composite_graph_optimizers_.clear();
268+}
269+ 
270+TEST_F(UtestOpsKernelManager, GetOpsKernelInfoNotFound) {
271+ auto &instance = OpsKernelManager::GetInstance();
272+ auto result = instance.GetOpsKernelInfo("nonexistent_op_type");
273+ EXPECT_TRUE(result.empty());
274+}
275+ 
276+TEST_F(UtestOpsKernelManager, GetOpsKernelInfoStoreNotFound) {
277+ auto &instance = OpsKernelManager::GetInstance();
278+ EXPECT_EQ(instance.GetOpsKernelInfoStore("nonexistent_kernel"), nullptr);
279+}
193} // namespace ge280} // namespace ge
Mtests/ge/ut/ge/common/program_generator_unittest.cc+57-0文件内容审核中，请稍后刷新重试
Mtests/ge/ut/ge/common/util_unittest.cc+12-0
@@ -657,5 +657,17 @@ TEST_F(UtestUtilTransfer, PrintOptionsWithLengthLimit_LongValue_CovEnhance) {
657 options["key"] = std::string(200, 'x');657 options["key"] = std::string(200, 'x');
658 PrintOptionsWithLengthLimit(options, "prefix", 50U);658 PrintOptionsWithLengthLimit(options, "prefix", 50U);
659}659}
660+ 
661+TEST_F(UtestUtilTransfer, CheckOutputPathValid_IncompleteUtf8_CovEnhance) {
662+ EXPECT_EQ(CheckOutputPathValid(std::string({static_cast<char>(0xC2)}), ""), false);
663+ EXPECT_EQ(CheckOutputPathValid(std::string({static_cast<char>(0xE0)}), ""), false);
664+ EXPECT_EQ(CheckOutputPathValid(std::string({static_cast<char>(0xF0)}), ""), false);
665+}
666+ 
667+TEST_F(UtestUtilTransfer, ReadBytesFromBinaryFile_NonExistentFile_CovEnhance) {
668+ char_t *buffer = nullptr;
669+ int32_t length = 0;
670+ EXPECT_FALSE(ReadBytesFromBinaryFile("/nonexistent/path/file.bin", &buffer, length));
671+}
660} // namespace formats672} // namespace formats
661} // namespace ge673} // namespace ge
Mtests/ge/ut/ge/common/visualization_unittest.cc+21-0
@@ -1229,5 +1229,26 @@ TEST_F(VisualizationTest, LoadFromVisualJson_ListValueWithObjectElementsFallback
1229 EXPECT_EQ((*list_td)["list"]["td"][0]["name"], "td_f0");1229 EXPECT_EQ((*list_td)["list"]["td"][0]["name"], "td_f0");
1230}1230}
1231 1231 
1232+TEST(VisualJsonConverterCovEnhance, LoadFromVisualJson_MalformedJson_CovEnhance) {
1233+ nlohmann::json pb_json;
1234+ std::string malformed = R"({"format":"ge_visual_json","model":)";
1235+ EXPECT_NE(VisualJsonConverter::LoadFromVisualJson(malformed, pb_json), SUCCESS);
1236+}
1237+ 
1238+TEST(VisualJsonConverterCovEnhance, SerializeFromModelDef_WithDoubleAttr_CovEnhance) {
1239+ ge::proto::ModelDef model_def;
1240+ model_def.set_name("double_attr_model");
1241+ auto *graph_def = model_def.add_graph();
1242+ auto *op_def = graph_def->add_op();
1243+ op_def->set_name("double_op");
1244+ op_def->set_type("DoubleTest");
1245+ auto *attr = op_def->mutable_attr();
1246+ ge::proto::AttrDef attr_def;
1247+ attr_def.set_f(3.14);
1248+ (*attr)["double_attr"] = attr_def;
1249+ std::string json_str;
1250+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
1251+ EXPECT_FALSE(json_str.empty());
1252+}
1232} // namespace1253} // namespace
1233} // namespace ge1254} // namespace ge
Mtests/ge/ut/ge/common/zip_archive_unittest.cc+118-0
@@ -558,4 +558,122 @@ TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_SaveModelDataToBufferWithLargeData)
558 const auto file_names = archive.ListFiles();558 const auto file_names = archive.ListFiles();
559 ASSERT_EQ(file_names.size(), 1U);559 ASSERT_EQ(file_names.size(), 1U);
560}560}
561+ 
562+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Fail_ArchivePathEndsWithSlash) {
563+ ZipArchiveWriter zip_writer(test_work_dir + "/");
564+ EXPECT_FALSE(zip_writer.IsMemFileOpened());
565+}
566+ 
567+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_ArchivePathNoExtension) {
568+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "no_ext_archive"});
569+ ZipArchiveWriter zip_writer(zipfile_path);
570+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
571+ const std::string buffer = "test_data_no_ext";
572+ EXPECT_TRUE(zip_writer.WriteBytes("data.txt", buffer.data(), buffer.size()));
573+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
574+ ASSERT_FALSE(zip_writer.IsMemFileOpened());
575+}
576+ 
577+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_ArchivePathNoSlash) {
578+ const std::string zipfile_name = "no_slash.zip";
579+ ZipArchiveWriter zip_writer(zipfile_name);
580+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
581+ const std::string buffer = "test_data_no_slash";
582+ EXPECT_TRUE(zip_writer.WriteBytes("data.txt", buffer.data(), buffer.size()));
583+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
584+ ASSERT_FALSE(zip_writer.IsMemFileOpened());
585+ (void)std::remove(zipfile_name.c_str());
586+}
587+ 
588+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_ArchivePathDotOnly) {
589+ const std::string zipfile_path = PathUtils::Join({test_work_dir, ".zip"});
590+ ZipArchiveWriter zip_writer(zipfile_path);
591+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
592+ const std::string buffer = "test_data_dot";
593+ EXPECT_TRUE(zip_writer.WriteBytes("data.txt", buffer.data(), buffer.size()));
594+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
595+ ASSERT_FALSE(zip_writer.IsMemFileOpened());
596+}
597+ 
598+TEST_F(ZipArchiveUt, TestSimpleZipArchiveReader_Fail_NullStream) {
599+ SimpleZipArchiveReader reader(nullptr, 0);
600+ EXPECT_FALSE(reader.IsGood());
601+}
602+ 
603+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_WriteBytesNoCompressionLargeData) {
604+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "large_nocompress.zip"});
605+ ZipArchiveWriter zip_writer(zipfile_path);
606+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
607+ 
608+ constexpr size_t kDataSize = 200UL * 1024UL;
609+ std::vector<uint8_t> data(kDataSize, 0x42);
610+ EXPECT_TRUE(zip_writer.WriteBytes("large_data.bin", data.data(), data.size(), false));
611+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
612+ 
613+ const auto file_buf = ReadFileToVector(zipfile_path);
614+ RAIIZipArchive archive(file_buf.data(), file_buf.size());
615+ ASSERT_TRUE(archive.IsGood());
616+ const auto file_names = archive.ListFiles();
617+ ASSERT_EQ(file_names.size(), 1U);
618+}
619+ 
620+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_MultipleEntriesWithGrowth) {
621+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "multi_growth.zip"});
622+ ZipArchiveWriter zip_writer(zipfile_path);
623+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
624+ 
625+ for (int i = 0; i < 10; ++i) {
626+ std::vector<uint8_t> data(32UL * 1024UL, static_cast<uint8_t>(i));
627+ EXPECT_TRUE(zip_writer.WriteBytes("entry_" + std::to_string(i) + ".bin", data.data(), data.size(), false));
628+ }
629+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
630+ 
631+ const auto file_buf = ReadFileToVector(zipfile_path);
632+ RAIIZipArchive archive(file_buf.data(), file_buf.size());
633+ ASSERT_TRUE(archive.IsGood());
634+ const auto file_names = archive.ListFiles();
635+ ASSERT_EQ(file_names.size(), 10U);
636+}
637+ 
638+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_WriteEndOfFileTwice) {
639+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "double_close.zip"});
640+ ZipArchiveWriter zip_writer(zipfile_path);
641+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
642+ const std::string buffer = "test_double_close";
643+ EXPECT_TRUE(zip_writer.WriteBytes("data.txt", buffer.data(), buffer.size()));
644+ EXPECT_TRUE(zip_writer.WriteEndOfFile());
645+ EXPECT_TRUE(zip_writer.WriteEndOfFile());
646+}
647+ 
648+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_SaveModelDataToFileWithCompressedData) {
649+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "compressed_save.zip"});
650+ ZipArchiveWriter zip_writer(zipfile_path);
651+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
652+ 
653+ std::string data(50000, 'A');
654+ EXPECT_TRUE(zip_writer.WriteBytes("compressed.bin", data.data(), data.size(), true));
655+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
656+ 
657+ const auto file_buf = ReadFileToVector(zipfile_path);
658+ RAIIZipArchive archive(file_buf.data(), file_buf.size());
659+ ASSERT_TRUE(archive.IsGood());
660+ const auto file_names = archive.ListFiles();
661+ ASSERT_EQ(file_names.size(), 1U);
662+}
663+ 
664+TEST_F(ZipArchiveUt, TestSimpleZipArchiveReader_Ok_ListFilesFromCompressedArchive) {
665+ const std::string archive_path = PathUtils::Join({test_work_dir, "__compressed_reader.zip"});
666+ const std::vector<std::pair<std::string, std::string>> entries = {
667+ {"file1.txt", std::string(10000, 'X')},
668+ {"file2.txt", std::string(5000, 'Y')},
669+ };
670+ CreateTestZipArchive(archive_path, entries, true);
671+ 
672+ const auto file_buf = ReadFileToVector(archive_path);
673+ SimpleZipArchiveReader reader(file_buf.data(), file_buf.size());
674+ ASSERT_TRUE(reader.IsGood());
675+ 
676+ const auto file_names = reader.ListFiles();
677+ ASSERT_EQ(file_names.size(), 2U);
678+}
561} // namespace ge679} // namespace ge
Mtests/ge/ut/ge/fusion/fusion_utils_unittest.cc+83-0
@@ -154,5 +154,88 @@ TEST_F(UtestFusionUtils, WillCauseCycleIfFuse_GraphWithControlEdgeCycle_ReturnTr
154 ASSERT_NE(match_result, nullptr);154 ASSERT_NE(match_result, nullptr);
155 EXPECT_TRUE(FusionUtils::WillCauseCycleIfFuse(match_result));155 EXPECT_TRUE(FusionUtils::WillCauseCycleIfFuse(match_result));
156}156}
157+ 
158+TEST_F(UtestFusionUtils, ParseFusionSwitch_NonExistentFile_ReturnsEmpty) {
159+ GetThreadLocalContext().SetGlobalOption({{FUSION_SWITCH_FILE, "/nonexistent/path/fusion_switch.json"}});
160+ auto result = FusionUtils::ParseFusionSwitch();
161+ EXPECT_TRUE(result.empty());
162+}
163+ 
164+TEST_F(UtestFusionUtils, WillCauseCycleIfFuse_EmptyNodesVector_ReturnFalse) {
165+ std::vector<NodePtr> empty_nodes;
166+ EXPECT_FALSE(FusionUtils::WillCauseCycleIfFuse(empty_nodes));
167+}
168+ 
169+TEST_F(UtestFusionUtils, WillCauseCycleIfFuse_AllNullNodes_ReturnFalse) {
170+ std::vector<NodePtr> null_nodes = {nullptr, nullptr};
171+ EXPECT_FALSE(FusionUtils::WillCauseCycleIfFuse(null_nodes));
172+}
173+ 
174+TEST_F(UtestFusionUtils, BuildSubgraphBoundaryFromNode_NodeWithNoInputs) {
175+ using namespace ge::es;
176+ auto graph_builder = EsGraphBuilder("boundary_test");
177+ auto esb_graph = graph_builder.GetCGraphBuilder();
178+ auto data = EsCreateGraphInput(esb_graph, 0);
179+ auto relu = EsRelu(data);
180+ esb_graph->SetGraphOutput(relu, 0);
181+ auto graph = graph_builder.BuildAndReset();
182+ 
183+ auto compute_graph = GraphUtilsEx::GetComputeGraph(*graph);
184+ auto node_ptr = compute_graph->GetDirectNode().at(1);
185+ auto boundary = FusionUtils::BuildSubgraphBoundaryFromNode(node_ptr);
186+ EXPECT_NE(boundary, nullptr);
187+}
188+ 
189+TEST_F(UtestFusionUtils, ParseFusionSwitch_InvalidJsonFormat_ReturnsEmpty) {
190+ std::string json_str = "not a valid json";
191+ std::ofstream json_file("./fusion_switch_invalid.json");
192+ json_file << json_str << std::endl;
193+ json_file.close();
194+ 
195+ std::string config_file_path = GetCodeDir() + "/fusion_switch_invalid.json";
196+ GetThreadLocalContext().SetGlobalOption({{FUSION_SWITCH_FILE, config_file_path}});
197+ auto result = FusionUtils::ParseFusionSwitch();
198+ EXPECT_TRUE(result.empty());
199+ remove("./fusion_switch_invalid.json");
200+}
201+ 
202+TEST_F(UtestFusionUtils, ParseFusionSwitch_TopLevelNotObject_ReturnsEmpty) {
203+ std::string json_str = "[1, 2, 3]";
204+ std::ofstream json_file("./fusion_switch_array.json");
205+ json_file << json_str << std::endl;
206+ json_file.close();
207+ 
208+ std::string config_file_path = GetCodeDir() + "/fusion_switch_array.json";
209+ GetThreadLocalContext().SetGlobalOption({{FUSION_SWITCH_FILE, config_file_path}});
210+ auto result = FusionUtils::ParseFusionSwitch();
211+ EXPECT_TRUE(result.empty());
212+ remove("./fusion_switch_array.json");
213+}
214+ 
215+TEST_F(UtestFusionUtils, ParseFusionSwitch_NoSwitchKey_ReturnsEmpty) {
216+ std::string json_str = "{\"key\": \"value\"}";
217+ std::ofstream json_file("./fusion_switch_no_switch.json");
218+ json_file << json_str << std::endl;
219+ json_file.close();
220+ 
221+ std::string config_file_path = GetCodeDir() + "/fusion_switch_no_switch.json";
222+ GetThreadLocalContext().SetGlobalOption({{FUSION_SWITCH_FILE, config_file_path}});
223+ auto result = FusionUtils::ParseFusionSwitch();
224+ EXPECT_TRUE(result.empty());
225+ remove("./fusion_switch_no_switch.json");
226+}
227+ 
228+TEST_F(UtestFusionUtils, ParseFusionSwitch_GraphFusionNotObject_ReturnsEmpty) {
229+ std::string json_str = "{\"Switch\": {\"GraphFusion\": \"not_object\"}}";
230+ std::ofstream json_file("./fusion_switch_not_obj.json");
231+ json_file << json_str << std::endl;
232+ json_file.close();
233+ 
234+ std::string config_file_path = GetCodeDir() + "/fusion_switch_not_obj.json";
235+ GetThreadLocalContext().SetGlobalOption({{FUSION_SWITCH_FILE, config_file_path}});
236+ auto result = FusionUtils::ParseFusionSwitch();
237+ EXPECT_TRUE(result.empty());
238+ remove("./fusion_switch_not_obj.json");
239+}
157} // namespace fusion240} // namespace fusion
158} // namespace ge241} // namespace ge
Mtests/ge/ut/ge/fusion/pass/fusion_pass_executor_unittest.cc+184-0
@@ -2212,5 +2212,189 @@ TEST_F(UtestFusionPassExecutor, RunPasses_SkipOrphanSubgraph) {
2212 // 顶层图能正常处理，孤儿子图被安全跳过，不应崩溃。2212 // 顶层图能正常处理，孤儿子图被安全跳过，不应崩溃。
2213 EXPECT_EQ(pass_executor.RunPasses(target_compute_graph, CustomPassStage::kAfterInferShape), SUCCESS);2213 EXPECT_EQ(pass_executor.RunPasses(target_compute_graph, CustomPassStage::kAfterInferShape), SUCCESS);
2214}2214}
2215+ 
2216+TEST_F(UtestFusionPassExecutor, PythonFusionBasePass_RegisterDuplicateDescriptorKey) {
2217+ PythonPassDescriptor pass_desc;
2218+ pass_desc.descriptor_key = "python.duplicate.register.test";
2219+ pass_desc.pass_name = "DuplicateRegisterPass";
2220+ pass_desc.module_name = "python.pass.sample";
2221+ pass_desc.class_name = "DuplicateRegisterPass";
2222+ pass_desc.stage = CustomPassStage::kAfterInferShape;
2223+ pass_desc.kind = PythonPassKind::kFusionBase;
2224+ 
2225+ PythonFusionPassCallbacks callbacks;
2226+ callbacks.create = CreatePythonFusionBasePassHolderForUt;
2227+ callbacks.destroy = DestroyPythonFusionBasePassHolderForUt;
2228+ callbacks.run = RunPythonFusionBasePassHolderForUt;
2229+ 
2230+ ASSERT_TRUE(RegisterPythonPass(pass_desc, callbacks));
2231+ EXPECT_FALSE(RegisterPythonPass(pass_desc, callbacks));
2232+ ClearPythonPassRuntimeRegistry();
2233+}
2234+ 
2235+TEST_F(UtestFusionPassExecutor, PythonFusionBasePass_UnregisterNonExistentKey) {
2236+ EXPECT_FALSE(PythonFusionPassRuntimeRegistry::GetInstance().Unregister("non_existent_key"));
2237+}
2238+ 
2239+TEST_F(UtestFusionPassExecutor, PythonFusionBasePass_AdapterWithUnregisteredDesc) {
2240+ PythonPassDescriptor pass_desc;
2241+ pass_desc.descriptor_key = "python.unregistered.adapter";
2242+ pass_desc.pass_name = "UnregisteredAdapterPass";
2243+ pass_desc.module_name = "python.pass.sample";
2244+ pass_desc.class_name = "UnregisteredAdapterPass";
2245+ pass_desc.stage = CustomPassStage::kAfterInferShape;
2246+ pass_desc.kind = PythonPassKind::kFusionBase;
2247+ 
2248+ auto adapter = std::make_unique<PythonFusionBasePassAdapter>(pass_desc);
2249+ EXPECT_FALSE(adapter->IsValid());
2250+ 
2251+ GraphPtr graph = std::make_shared<Graph>();
2252+ CustomPassContext context;
2253+ EXPECT_EQ(adapter->Run(graph, context), FAILED);
2254+}
2255+ 
2256+TEST_F(UtestFusionPassExecutor, PythonFusionBasePass_RunWithInvalidCallback) {
2257+ PythonPassDescriptor pass_desc;
2258+ pass_desc.descriptor_key = "python.invalid.callback.test";
2259+ pass_desc.pass_name = "InvalidCallbackPass";
2260+ pass_desc.module_name = "python.pass.sample";
2261+ pass_desc.class_name = "InvalidCallbackPass";
2262+ pass_desc.stage = CustomPassStage::kAfterInferShape;
2263+ pass_desc.kind = PythonPassKind::kFusionBase;
2264+ 
2265+ PythonFusionPassCallbacks callbacks;
2266+ callbacks.create = CreatePythonFusionBasePassHolderForUt;
2267+ callbacks.destroy = DestroyPythonFusionBasePassHolderForUt;
2268+ callbacks.run = nullptr;
2269+ 
2270+ EXPECT_FALSE(RegisterPythonPass(pass_desc, callbacks));
2271+ ClearPythonPassRuntimeRegistry();
2272+}
2273+ 
2274+TEST_F(UtestFusionPassExecutor, PythonFusionBasePass_GetPassDescriptor) {
2275+ PythonPassDescriptor pass_desc;
2276+ pass_desc.descriptor_key = "python.get.descriptor.test";
2277+ pass_desc.pass_name = "GetDescriptorPass";
2278+ pass_desc.module_name = "python.pass.sample";
2279+ pass_desc.class_name = "GetDescriptorPass";
2280+ pass_desc.stage = CustomPassStage::kAfterInferShape;
2281+ pass_desc.kind = PythonPassKind::kFusionBase;
2282+ 
2283+ PythonFusionPassCallbacks callbacks;
2284+ callbacks.create = CreatePythonFusionBasePassHolderForUt;
2285+ callbacks.destroy = DestroyPythonFusionBasePassHolderForUt;
2286+ callbacks.run = RunPythonFusionBasePassHolderForUt;
2287+ 
2288+ ASSERT_TRUE(RegisterPythonPass(pass_desc, callbacks));
2289+ 
2290+ auto holder = std::make_unique<PythonPassHolder>(pass_desc);
2291+ ASSERT_TRUE(holder->IsValid());
2292+ const auto &retrieved_desc = holder->GetPassDescriptor();
2293+ EXPECT_EQ(retrieved_desc.descriptor_key, pass_desc.descriptor_key);
2294+ EXPECT_EQ(retrieved_desc.pass_name, pass_desc.pass_name);
2295+ 
2296+ ClearPythonPassRuntimeRegistry();
2297+}
2298+ 
2299+TEST_F(UtestFusionPassExecutor, PythonFusionBasePass_CreatePythonPassAdapterWithMissingDescriptor) {
2300+ EXPECT_EQ(CreatePythonPassAdapter(), nullptr);
2301+}
2302+ 
2303+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_RegisterPassesWithNullRegistrar_Fails) {
2304+ const auto *api = LoadBridgeApiForUt();
2305+ if (api == nullptr) {
2306+ GTEST_SKIP() << "Bridge API not available";
2307+ }
2308+ EXPECT_EQ(api->register_passes(nullptr), FAILED);
2309+}
2310+ 
2311+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_SetArtifactConfigNull_Succeeds) {
2312+ const auto *api = LoadBridgeApiForUt();
2313+ if (api == nullptr) {
2314+ GTEST_SKIP() << "Bridge API not available";
2315+ }
2316+ EXPECT_EQ(api->set_artifact_config(nullptr), SUCCESS);
2317+ CleanupBridgeStateForUt(*api);
2318+}
2319+ 
2320+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_ResetBridgeStateWhenPyNotInitialized_Succeeds) {
2321+ const auto *api = LoadBridgeApiForUt();
2322+ if (api == nullptr) {
2323+ GTEST_SKIP() << "Bridge API not available";
2324+ }
2325+ api->reset_bridge_state();
2326+ EXPECT_NE(api->reset_bridge_state, nullptr);
2327+}
2328+ 
2329+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_ShutdownBridge_Succeeds) {
2330+ const auto *api = LoadBridgeApiForUt();
2331+ if (api == nullptr) {
2332+ GTEST_SKIP() << "Bridge API not available";
2333+ }
2334+ api->shutdown_bridge();
2335+ EXPECT_NE(api->shutdown_bridge, nullptr);
2336+}
2337+ 
2338+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_SetArtifactConfigValid_Succeeds) {
2339+ const auto *api = LoadBridgeApiForUt();
2340+ if (api == nullptr) {
2341+ GTEST_SKIP() << "Bridge API not available";
2342+ }
2343+ PythonFusionPassBridgeArtifactConfig config;
2344+ config.artifact_root = "/tmp/test_artifact";
2345+ config.native_module_path = "/tmp/test_native";
2346+ EXPECT_EQ(api->set_artifact_config(&config), SUCCESS);
2347+ CleanupBridgeStateForUt(*api);
2348+}
2349+ 
2350+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_SetArtifactConfigTwice_Succeeds) {
2351+ const auto *api = LoadBridgeApiForUt();
2352+ if (api == nullptr) {
2353+ GTEST_SKIP() << "Bridge API not available";
2354+ }
2355+ PythonFusionPassBridgeArtifactConfig config1;
2356+ config1.artifact_root = "/tmp/test1";
2357+ config1.native_module_path = "/tmp/native1";
2358+ EXPECT_EQ(api->set_artifact_config(&config1), SUCCESS);
2359+ PythonFusionPassBridgeArtifactConfig config2;
2360+ config2.artifact_root = "/tmp/test2";
2361+ config2.native_module_path = "/tmp/native2";
2362+ EXPECT_EQ(api->set_artifact_config(&config2), SUCCESS);
2363+ CleanupBridgeStateForUt(*api);
2364+}
2365+ 
2366+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_ResetBridgeStateTwice_Succeeds) {
2367+ const auto *api = LoadBridgeApiForUt();
2368+ if (api == nullptr) {
2369+ GTEST_SKIP() << "Bridge API not available";
2370+ }
2371+ api->reset_bridge_state();
2372+ api->reset_bridge_state();
2373+ EXPECT_NE(api->reset_bridge_state, nullptr);
2374+}
2375+ 
2376+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_ShutdownTwice_Succeeds) {
2377+ const auto *api = LoadBridgeApiForUt();
2378+ if (api == nullptr) {
2379+ GTEST_SKIP() << "Bridge API not available";
2380+ }
2381+ api->shutdown_bridge();
2382+ api->shutdown_bridge();
2383+ EXPECT_NE(api->shutdown_bridge, nullptr);
2384+}
2385+ 
2386+TEST_F(UtestFusionPassExecutor, PythonPassBridgeCApi_RegisterPassesWithoutPython_Fails) {
2387+ const auto *api = LoadBridgeApiForUt();
2388+ if (api == nullptr) {
2389+ GTEST_SKIP() << "Bridge API not available";
2390+ }
2391+ PythonFusionPassRegistrar registrar;
2392+ registrar.register_pass = [](const PythonPassDescriptor *, const PythonFusionPassCallbacks *) -> bool {
2393+ return false;
2394+ };
2395+ EXPECT_NE(api->register_passes(&registrar), SUCCESS);
2396+ CleanupBridgeStateForUt(*api);
2397+}
2398+ 
2215} // namespace fusion2399} // namespace fusion
2216} // namespace ge2400} // namespace ge
Mtests/ge/ut/ge/generator/ge_generator_unittest.cc+54-0
@@ -1200,4 +1200,58 @@ TEST_F(UtestGeGenerator, generate_offline_model_with_attr_compression_default) {
1200 (void)generator.GenerateOfflineModel(graph, name, inputs);1200 (void)generator.GenerateOfflineModel(graph, name, inputs);
1201 // Test passes if no crash or exception related to attr_compression1201 // Test passes if no crash or exception related to attr_compression
1202}1202}
1203+ 
1204+TEST_F(UtestGeGenerator, CheckForSingleOpWithMoreOutputsThanExpected) {
1205+ GeGenerator generator;
1206+ generator.Initialize({});
1207+ GeTensorDesc tensor_desc;
1208+ shared_ptr<OpDesc> op_desc = std::make_shared<OpDesc>("Add", "add");
1209+ op_desc->AddInputDesc(tensor_desc);
1210+ op_desc->AddInputDesc(tensor_desc);
1211+ op_desc->AddOutputDesc(tensor_desc);
1212+ GeTensor tensor(tensor_desc);
1213+ vector<GeTensor> inputs = {tensor, tensor};
1214+ vector<GeTensor> outputs = {tensor, tensor, tensor};
1215+ EXPECT_EQ(generator.CheckForSingleOp(op_desc, inputs, outputs), PARAM_INVALID);
1216+ EXPECT_EQ(generator.Finalize(), SUCCESS);
1217+}
1218+ 
1219+TEST_F(UtestGeGenerator, GenerateModelWithNullImpl) {
1220+ auto &instance = GeGenerator::GetInstance();
1221+ Graph graph("graph");
1222+ std::vector<GeTensor> inputs;
1223+ ModelBufferData model;
1224+ EXPECT_NE(instance.GenerateOnlineModel(graph, inputs, model), SUCCESS);
1225+}
1226+ 
1227+TEST_F(UtestGeGenerator, GenerateInfershapeGraphWithNullImpl) {
1228+ GeGenerator generator;
1229+ Graph graph("graph");
1230+ EXPECT_EQ(generator.GenerateInfershapeGraph(graph), PARAM_INVALID);
1231+}
1232+ 
1233+TEST_F(UtestGeGenerator, RemoveConstWithEmptyInputs) {
1234+ GeGenerator generator;
1235+ std::vector<GeTensor> inputs;
1236+ std::vector<GeTensor> outputs;
1237+ EXPECT_NO_THROW(generator.RemoveConst(inputs, outputs));
1238+}
1239+ 
1240+TEST_F(UtestGeGenerator, GenerateModelWithNormalBuildMode) {
1241+ InitGeLib();
1242+ auto &instance = GeGenerator::GetInstance();
1243+ std::map<std::string, std::string> options;
1244+ options["ge.buildMode"] = BUILD_MODE_NORMAL;
1245+ instance.Initialize(options);
1246+ auto compute_graph = MakeGraph();
1247+ compute_graph->TopologicalSorting();
1248+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
1249+ std::string file_name_prefix = "prefix";
1250+ std::vector<GeTensor> inputs;
1251+ ModelBufferData model;
1252+ bool is_offline = true;
1253+ EXPECT_EQ(instance.GenerateModel(graph, file_name_prefix, inputs, model, is_offline), SUCCESS);
1254+ EXPECT_EQ(instance.Finalize(), SUCCESS);
1255+ FinalizeGeLib();
1256+}
1203} // namespace ge1257} // namespace ge
Mtests/ge/ut/ge/graph/build/block_mem_assigner_unittest.cc+96-0
@@ -1978,4 +1978,100 @@ TEST_F(UtestBlockMemAssigner, CanReuseZeroCopyBlock_unsupport_custom) {
1978 EXPECT_EQ(mem_assigner.GetAllRefCount(node_index_io, is_reuse_zero_copy), 1);1978 EXPECT_EQ(mem_assigner.GetAllRefCount(node_index_io, is_reuse_zero_copy), 1);
1979 EXPECT_EQ(is_reuse_zero_copy, false);1979 EXPECT_EQ(is_reuse_zero_copy, false);
1980}1980}
1981+TEST_F(UtestBlockMemAssigner, AssignOutputMemory_IteratorV2_NoReuse) {
1982+ auto builder = std::make_shared<block_mem_ut::GraphBuilder>("graph");
1983+ auto node = builder->AddNode("node", "IteratorV2", 1, 1);
1984+ ComputeGraphPtr compute_graph = builder->GetGraph();
1985+ MemAssistInfo mem_assist_info;
1986+ mem_assist_info.compute_graph = compute_graph;
1987+ auto ret =
1988+ GraphUtils::GetRefMapping(compute_graph, mem_assist_info.symbol_to_anchors, mem_assist_info.anchor_to_symbol);
1989+ EXPECT_EQ(ret, SUCCESS);
1990+ BlockMemAssigner::PreparationForAssign(mem_assist_info);
1991+ BinaryBlockMemAssigner assigner(mem_assist_info);
1992+ assigner.SetReuseStrategy(ReuseStrategy{true, true, true, true});
1993+ std::vector<int64_t> ranges;
1994+ assigner.GetMemoryRanges(ranges);
1995+ EXPECT_EQ(assigner.AssignOutputMemoryWithReuse(node, ranges), SUCCESS);
1996+}
1997+ 
1998+TEST_F(UtestBlockMemAssigner, AssignOutputMemory_NullOpDesc_Handle) {
1999+ auto builder = std::make_shared<block_mem_ut::GraphBuilder>("graph");
2000+ auto node = builder->AddNode("node", DATA, 1, 1);
2001+ ComputeGraphPtr compute_graph = builder->GetGraph();
2002+ MemAssistInfo mem_assist_info;
2003+ mem_assist_info.compute_graph = compute_graph;
2004+ auto ret =
2005+ GraphUtils::GetRefMapping(compute_graph, mem_assist_info.symbol_to_anchors, mem_assist_info.anchor_to_symbol);
2006+ EXPECT_EQ(ret, SUCCESS);
2007+ BlockMemAssigner::PreparationForAssign(mem_assist_info);
2008+ BinaryBlockMemAssigner assigner(mem_assist_info);
2009+ std::vector<int64_t> ranges;
2010+ assigner.GetMemoryRanges(ranges);
2011+ EXPECT_EQ(assigner.AssignOutputMemoryWithReuse(node, ranges), SUCCESS);
2012+}
2013+ 
2014+TEST_F(UtestBlockMemAssigner, AssignOutputMemory_ZeroSizeOutput) {
2015+ auto builder = std::make_shared<block_mem_ut::GraphBuilder>("graph");
2016+ auto node = builder->AddNode("node", DATA, 1, 1);
2017+ ComputeGraphPtr compute_graph = builder->GetGraph();
2018+ auto op_desc = node->GetOpDesc();
2019+ ASSERT_NE(op_desc, nullptr);
2020+ auto output_desc = op_desc->MutableOutputDesc(0);
2021+ ASSERT_NE(output_desc, nullptr);
2022+ TensorUtils::SetSize(*output_desc, 0);
2023+ MemAssistInfo mem_assist_info;
2024+ mem_assist_info.compute_graph = compute_graph;
2025+ auto ret =
2026+ GraphUtils::GetRefMapping(compute_graph, mem_assist_info.symbol_to_anchors, mem_assist_info.anchor_to_symbol);
2027+ EXPECT_EQ(ret, SUCCESS);
2028+ BlockMemAssigner::PreparationForAssign(mem_assist_info);
2029+ BinaryBlockMemAssigner assigner(mem_assist_info);
2030+ std::vector<int64_t> ranges;
2031+ assigner.GetMemoryRanges(ranges);
2032+ EXPECT_EQ(assigner.AssignOutputMemoryWithReuse(node, ranges), SUCCESS);
2033+}
2034+ 
2035+TEST_F(UtestBlockMemAssigner, MemoryBlock_AddAndRelease) {
2036+ MemoryBlock block(reuse_strategy_, 512);
2037+ EXPECT_EQ(block.Size(), 512);
2038+ block.ref_count_ = 0;
2039+ EXPECT_NO_THROW(block.SetSize(1024));
2040+ EXPECT_EQ(block.Size(), 1024);
2041+}
2042+ 
2043+TEST_F(UtestBlockMemAssigner, MemoryBlock_ExtendAndResize) {
2044+ MemoryBlock block(reuse_strategy_, 256, 0, true, RT_MEMORY_HBM);
2045+ EXPECT_EQ(block.Size(), 256);
2046+ block.SetSize(512);
2047+ EXPECT_EQ(block.Size(), 512);
2048+ EXPECT_NO_THROW(block.Resize());
2049+ EXPECT_EQ(block.HeadOffset(), 0U);
2050+ EXPECT_EQ(block.TailOffset(), 0U);
2051+}
2052+ 
2053+TEST_F(UtestBlockMemAssigner, MemoryBlock_Clone) {
2054+ MemoryBlock block(reuse_strategy_, 1024, 1, true, RT_MEMORY_HBM);
2055+ auto cloned = block.Clone();
2056+ ASSERT_NE(cloned, nullptr);
2057+ EXPECT_EQ(cloned->Size(), 1024);
2058+}
2059+ 
2060+TEST_F(UtestBlockMemAssigner, AssignWorkSpaceMemoryWithReuse_BasicOp) {
2061+ auto builder = std::make_shared<block_mem_ut::GraphBuilder>("graph");
2062+ auto node = builder->AddNode("node", ADD, 1, 1);
2063+ node->GetOpDesc()->SetWorkspaceBytes({1024, 2048});
2064+ ComputeGraphPtr compute_graph = builder->GetGraph();
2065+ MemAssistInfo mem_assist_info;
2066+ mem_assist_info.compute_graph = compute_graph;
2067+ auto ret =
2068+ GraphUtils::GetRefMapping(compute_graph, mem_assist_info.symbol_to_anchors, mem_assist_info.anchor_to_symbol);
2069+ EXPECT_EQ(ret, SUCCESS);
2070+ BlockMemAssigner::PreparationForAssign(mem_assist_info);
2071+ BinaryBlockMemAssigner assigner(mem_assist_info);
2072+ std::vector<int64_t> ranges;
2073+ assigner.GetMemoryRanges(ranges);
2074+ EXPECT_EQ(assigner.AssignWorkSpaceMemoryWithReuse(node, ranges), SUCCESS);
2075+}
2076+ 
1981} // namespace ge2077} // namespace ge
Mtests/ge/ut/ge/graph/build/dag/dag_stream_merger_test.cc+291-0
@@ -1217,5 +1217,296 @@ TEST_F(StreamMergerTest, Merge_UnitSortByPeakLevelLoad_LoadBalance) {
1217 EXPECT_EQ(logical_to_physical.size(), 3);1217 EXPECT_EQ(logical_to_physical.size(), 3);
1218}1218}
1219 1219 
1220+TEST_F(StreamMergerTest, Merge_CrossStreamMultiWeight_LoadBalance) {
1221+ auto n0 = dag_->AddNode("n0", "Data");
1222+ auto n1 = dag_->AddNode("n1", "Data");
1223+ auto n2 = dag_->AddNode("n2", "Op1");
1224+ auto n3 = dag_->AddNode("n3", "Op2");
1225+ auto n4 = dag_->AddNode("n4", "Op3");
1226+ auto n5 = dag_->AddNode("n5", "NetOutput");
1227+ 
1228+ for (int i = 0; i < 6; ++i) {
1229+ dag_->GetAllNodes()[i]->SetTopoId(i);
1230+ }
1231+ 
1232+ dag_->AddEdge(n0, 0, n3, 0);
1233+ dag_->AddEdge(n0, 0, n4, 0);
1234+ dag_->AddEdge(n1, 0, n4, 0);
1235+ dag_->AddEdge(n2, 0, n5, 0);
1236+ dag_->AddEdge(n3, 0, n5, 0);
1237+ dag_->AddEdge(n4, 0, n5, 0);
1238+ 
1239+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2, 5}, {1}, {3, 4}};
1240+ std::vector<int32_t> logical_to_physical;
1241+ 
1242+ options_.strategy = StreamMergeStrategy::kLoadBalance;
1243+ options_.physical_stream_limit = 3;
1244+ options_.candidate_limit = 2;
1245+ options_.light_stream_limit = 2;
1246+ options_.repair_moves = 5;
1247+ StreamMerger merger(options_);
1248+ 
1249+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1250+ EXPECT_EQ(status, graphStatus::SUCCESS);
1251+ EXPECT_EQ(logical_to_physical.size(), 3);
1252+}
1253+ 
1254+TEST_F(StreamMergerTest, Merge_CrossStreamMultiWeight_MainStream) {
1255+ auto n0 = dag_->AddNode("n0", "Data");
1256+ auto n1 = dag_->AddNode("n1", "Data");
1257+ auto n2 = dag_->AddNode("n2", "Op1");
1258+ auto n3 = dag_->AddNode("n3", "Op2");
1259+ auto n4 = dag_->AddNode("n4", "Op3");
1260+ auto n5 = dag_->AddNode("n5", "NetOutput");
1261+ 
1262+ for (int i = 0; i < 6; ++i) {
1263+ dag_->GetAllNodes()[i]->SetTopoId(i);
1264+ }
1265+ 
1266+ dag_->AddEdge(n0, 0, n3, 0);
1267+ dag_->AddEdge(n0, 0, n4, 0);
1268+ dag_->AddEdge(n1, 0, n4, 0);
1269+ dag_->AddEdge(n2, 0, n5, 0);
1270+ dag_->AddEdge(n3, 0, n5, 0);
1271+ dag_->AddEdge(n4, 0, n5, 0);
1272+ 
1273+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2, 5}, {1}, {3, 4}};
1274+ std::vector<int32_t> logical_to_physical;
1275+ 
1276+ options_.strategy = StreamMergeStrategy::kMainStream;
1277+ options_.physical_stream_limit = 3;
1278+ options_.candidate_limit = 2;
1279+ options_.low_conflict_limit = 2;
1280+ options_.repair_moves = 5;
1281+ StreamMerger merger(options_);
1282+ 
1283+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1284+ EXPECT_EQ(status, graphStatus::SUCCESS);
1285+ EXPECT_EQ(logical_to_physical.size(), 3);
1286+}
1287+ 
1288+TEST_F(StreamMergerTest, Merge_CandidateLimitOne_LoadBalance) {
1289+ AddNodes(6);
1290+ 
1291+ std::vector<std::vector<int32_t>> logical_routes;
1292+ for (int i = 0; i < 6; ++i) {
1293+ logical_routes.push_back({i});
1294+ }
1295+ 
1296+ std::vector<int32_t> logical_to_physical;
1297+ 
1298+ options_.strategy = StreamMergeStrategy::kLoadBalance;
1299+ options_.physical_stream_limit = 4;
1300+ options_.candidate_limit = 1;
1301+ options_.light_stream_limit = 1;
1302+ options_.repair_moves = 3;
1303+ StreamMerger merger(options_);
1304+ 
1305+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1306+ EXPECT_EQ(status, graphStatus::SUCCESS);
1307+ EXPECT_EQ(logical_to_physical.size(), 6);
1308+}
1309+ 
1310+TEST_F(StreamMergerTest, Merge_CandidateLimitOne_MainStream) {
1311+ AddNodes(6);
1312+ 
1313+ std::vector<std::vector<int32_t>> logical_routes;
1314+ for (int i = 0; i < 6; ++i) {
1315+ logical_routes.push_back({i});
1316+ }
1317+ 
1318+ std::vector<int32_t> logical_to_physical;
1319+ 
1320+ options_.strategy = StreamMergeStrategy::kMainStream;
1321+ options_.physical_stream_limit = 4;
1322+ options_.candidate_limit = 1;
1323+ options_.low_conflict_limit = 1;
1324+ options_.repair_moves = 3;
1325+ StreamMerger merger(options_);
1326+ 
1327+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1328+ EXPECT_EQ(status, graphStatus::SUCCESS);
1329+ EXPECT_EQ(logical_to_physical.size(), 6);
1330+}
1331+ 
1332+TEST_F(StreamMergerTest, Merge_UnitSortByEarliestLevel_MainStream) {
1333+ auto n0 = dag_->AddNode("n0", "Data");
1334+ auto n1 = dag_->AddNode("n1", "Data");
1335+ auto n2 = dag_->AddNode("n2", "Op1");
1336+ auto n3 = dag_->AddNode("n3", "Op2");
1337+ auto n4 = dag_->AddNode("n4", "NetOutput");
1338+ 
1339+ for (int i = 0; i < 5; ++i) {
1340+ dag_->GetAllNodes()[i]->SetTopoId(i);
1341+ }
1342+ 
1343+ dag_->AddEdge(n0, 0, n2, 0);
1344+ dag_->AddEdge(n1, 0, n3, 0);
1345+ dag_->AddEdge(n2, 0, n4, 0);
1346+ dag_->AddEdge(n3, 0, n4, 0);
1347+ 
1348+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2, 4}, {1, 3}};
1349+ std::vector<int32_t> logical_to_physical;
1350+ 
1351+ options_.strategy = StreamMergeStrategy::kMainStream;
1352+ options_.physical_stream_limit = 4;
1353+ options_.repair_moves = 3;
1354+ StreamMerger merger(options_);
1355+ 
1356+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1357+ EXPECT_EQ(status, graphStatus::SUCCESS);
1358+ EXPECT_EQ(logical_to_physical.size(), 2);
1359+}
1360+ 
1361+TEST_F(StreamMergerTest, Merge_DeepDAG_MultiLevel_CrossDependency_LoadBalance) {
1362+ const int count = 10;
1363+ for (int i = 0; i < count; ++i) {
1364+ auto node = dag_->AddNode("n" + std::to_string(i), "Op");
1365+ node->SetTopoId(i);
1366+ }
1367+ 
1368+ for (int i = 0; i < count - 1; ++i) {
1369+ dag_->AddEdge(dag_->GetAllNodes()[i], 0, dag_->GetAllNodes()[i + 1], 0);
1370+ }
1371+ dag_->AddEdge(dag_->GetAllNodes()[0], 0, dag_->GetAllNodes()[5], 0);
1372+ 
1373+ std::vector<std::vector<int32_t>> logical_routes = {{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}};
1374+ std::vector<int32_t> logical_to_physical;
1375+ 
1376+ options_.strategy = StreamMergeStrategy::kLoadBalance;
1377+ options_.physical_stream_limit = 3;
1378+ options_.candidate_limit = 3;
1379+ options_.light_stream_limit = 2;
1380+ options_.repair_moves = 10;
1381+ StreamMerger merger(options_);
1382+ 
1383+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1384+ EXPECT_EQ(status, graphStatus::SUCCESS);
1385+ EXPECT_EQ(logical_to_physical.size(), 2);
1386+}
1387+ 
1388+TEST_F(StreamMergerTest, Merge_DeepDAG_MultiLevel_CrossDependency_MainStream) {
1389+ const int count = 10;
1390+ for (int i = 0; i < count; ++i) {
1391+ auto node = dag_->AddNode("n" + std::to_string(i), "Op");
1392+ node->SetTopoId(i);
1393+ }
1394+ 
1395+ for (int i = 0; i < count - 1; ++i) {
1396+ dag_->AddEdge(dag_->GetAllNodes()[i], 0, dag_->GetAllNodes()[i + 1], 0);
1397+ }
1398+ dag_->AddEdge(dag_->GetAllNodes()[0], 0, dag_->GetAllNodes()[5], 0);
1399+ 
1400+ std::vector<std::vector<int32_t>> logical_routes = {{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}};
1401+ std::vector<int32_t> logical_to_physical;
1402+ 
1403+ options_.strategy = StreamMergeStrategy::kMainStream;
1404+ options_.physical_stream_limit = 3;
1405+ options_.candidate_limit = 3;
1406+ options_.low_conflict_limit = 2;
1407+ options_.repair_moves = 10;
1408+ StreamMerger merger(options_);
1409+ 
1410+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1411+ EXPECT_EQ(status, graphStatus::SUCCESS);
1412+ EXPECT_EQ(logical_to_physical.size(), 2);
1413+}
1414+ 
1415+TEST_F(StreamMergerTest, Merge_MultiRouteSameLevel_DifferentSizes_LoadBalance) {
1416+ auto n0 = dag_->AddNode("n0", "Data");
1417+ auto n1 = dag_->AddNode("n1", "Data");
1418+ auto n2 = dag_->AddNode("n2", "Op");
1419+ auto n3 = dag_->AddNode("n3", "Op");
1420+ auto n4 = dag_->AddNode("n4", "Op");
1421+ auto n5 = dag_->AddNode("n5", "NetOutput");
1422+ 
1423+ for (int i = 0; i < 6; ++i) {
1424+ dag_->GetAllNodes()[i]->SetTopoId(i);
1425+ }
1426+ 
1427+ dag_->AddEdge(n0, 0, n2, 0);
1428+ dag_->AddEdge(n0, 0, n3, 0);
1429+ dag_->AddEdge(n1, 0, n4, 0);
1430+ dag_->AddEdge(n2, 0, n5, 0);
1431+ dag_->AddEdge(n3, 0, n5, 0);
1432+ dag_->AddEdge(n4, 0, n5, 0);
1433+ 
1434+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2, 3, 5}, {1, 4}};
1435+ std::vector<int32_t> logical_to_physical;
1436+ 
1437+ options_.strategy = StreamMergeStrategy::kLoadBalance;
1438+ options_.physical_stream_limit = 2;
1439+ options_.candidate_limit = 2;
1440+ options_.light_stream_limit = 2;
1441+ options_.repair_moves = 5;
1442+ StreamMerger merger(options_);
1443+ 
1444+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1445+ EXPECT_EQ(status, graphStatus::SUCCESS);
1446+ EXPECT_EQ(logical_to_physical.size(), 2);
1447+}
1448+ 
1449+TEST_F(StreamMergerTest, Merge_MultiRouteSameLevel_DifferentSizes_MainStream) {
1450+ auto n0 = dag_->AddNode("n0", "Data");
1451+ auto n1 = dag_->AddNode("n1", "Data");
1452+ auto n2 = dag_->AddNode("n2", "Op");
1453+ auto n3 = dag_->AddNode("n3", "Op");
1454+ auto n4 = dag_->AddNode("n4", "Op");
1455+ auto n5 = dag_->AddNode("n5", "NetOutput");
1456+ 
1457+ for (int i = 0; i < 6; ++i) {
1458+ dag_->GetAllNodes()[i]->SetTopoId(i);
1459+ }
1460+ 
1461+ dag_->AddEdge(n0, 0, n2, 0);
1462+ dag_->AddEdge(n0, 0, n3, 0);
1463+ dag_->AddEdge(n1, 0, n4, 0);
1464+ dag_->AddEdge(n2, 0, n5, 0);
1465+ dag_->AddEdge(n3, 0, n5, 0);
1466+ dag_->AddEdge(n4, 0, n5, 0);
1467+ 
1468+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2, 3, 5}, {1, 4}};
1469+ std::vector<int32_t> logical_to_physical;
1470+ 
1471+ options_.strategy = StreamMergeStrategy::kMainStream;
1472+ options_.physical_stream_limit = 2;
1473+ options_.candidate_limit = 2;
1474+ options_.low_conflict_limit = 2;
1475+ options_.repair_moves = 5;
1476+ StreamMerger merger(options_);
1477+ 
1478+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1479+ EXPECT_EQ(status, graphStatus::SUCCESS);
1480+ EXPECT_EQ(logical_to_physical.size(), 2);
1481+}
1482+ 
1483+TEST_F(StreamMergerTest, Merge_SoloNodeLevel_MainStream) {
1484+ auto n0 = dag_->AddNode("n0", "Data");
1485+ auto n1 = dag_->AddNode("n1", "Data");
1486+ auto n2 = dag_->AddNode("n2", "Op");
1487+ auto n3 = dag_->AddNode("n3", "NetOutput");
1488+ 
1489+ for (int i = 0; i < 4; ++i) {
1490+ dag_->GetAllNodes()[i]->SetTopoId(i);
1491+ }
1492+ 
1493+ dag_->AddEdge(n0, 0, n2, 0);
1494+ dag_->AddEdge(n1, 0, n2, 0);
1495+ dag_->AddEdge(n2, 0, n3, 0);
1496+ 
1497+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2, 3}, {1}};
1498+ std::vector<int32_t> logical_to_physical;
1499+ 
1500+ options_.strategy = StreamMergeStrategy::kMainStream;
1501+ options_.physical_stream_limit = 2;
1502+ options_.candidate_limit = 2;
1503+ options_.low_conflict_limit = 2;
1504+ options_.repair_moves = 5;
1505+ StreamMerger merger(options_);
1506+ 
1507+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
1508+ EXPECT_EQ(status, graphStatus::SUCCESS);
1509+ EXPECT_EQ(logical_to_physical.size(), 2);
1510+}
1220} // namespace test1511} // namespace test
1221} // namespace minidag1512} // namespace minidag
Mtests/ge/ut/ge/graph/build/dag/dag_weighted_stream_merger_test.cc+157-0
@@ -394,5 +394,162 @@ TEST_F(WeightedStreamMergerTest, Merge_LargeScaleIndependentGraph_ReturnsValidMa
394 ExpectValidMapping(logical_to_physical, logical_routes.size());394 ExpectValidMapping(logical_to_physical, logical_routes.size());
395}395}
396 396 
397+TEST_F(WeightedStreamMergerTest, Merge_MultiOriginHints_MultipleFlowsPerOrigin) {
398+ BuildIndependentGraph(8, 10.0F);
399+ std::vector<std::vector<int32_t>> logical_routes = {{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}};
400+ std::vector<int32_t> logical_to_physical;
401+ options_.physical_stream_limit = 3;
402+ options_.candidate_limit = 4;
403+ options_.light_stream_limit = 3;
404+ options_.repair_moves = 3;
405+ options_.resim_candidate_limit = 2;
406+ 
407+ WeightedStreamMerger merger(options_);
408+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
409+ 
410+ ASSERT_EQ(status, graphStatus::SUCCESS);
411+ ExpectValidMapping(logical_to_physical, logical_routes.size());
412+}
413+ 
414+TEST_F(WeightedStreamMergerTest, Merge_SameDurationDifferentResources_SortTieBreaks) {
415+ auto n0 = AddNode("n0", 10.0F, 2U, 1U);
416+ auto n1 = AddNode("n1", 10.0F, 1U, 2U);
417+ auto n2 = AddNode("n2", 10.0F, 1U, 1U);
418+ auto n3 = AddNode("n3", 10.0F, 1U, 1U);
419+ n0->SetStreamId(0);
420+ n1->SetStreamId(1);
421+ n2->SetStreamId(0);
422+ n3->SetStreamId(1);
423+ ASSERT_EQ(dag_->AddEdge(n0, 0, n2, 0), graphStatus::SUCCESS);
424+ ASSERT_EQ(dag_->AddEdge(n1, 0, n3, 0), graphStatus::SUCCESS);
425+ 
426+ std::vector<std::vector<int32_t>> logical_routes = {{0, 2}, {1, 3}};
427+ std::vector<int32_t> logical_to_physical;
428+ options_.physical_stream_limit = 2;
429+ options_.candidate_limit = 4;
430+ options_.light_stream_limit = 2;
431+ options_.resim_candidate_limit = 2;
432+ 
433+ WeightedStreamMerger merger(options_);
434+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
435+ 
436+ ASSERT_EQ(status, graphStatus::SUCCESS);
437+ ExpectValidMapping(logical_to_physical, logical_routes.size());
438+}
439+ 
440+TEST_F(WeightedStreamMergerTest, Merge_CandidateLimitOne_TriggersBreakAndFallback) {
441+ BuildIndependentGraph(6, 5.0F);
442+ std::vector<std::vector<int32_t>> logical_routes = {{0}, {1}, {2}, {3}, {4}, {5}};
443+ std::vector<int32_t> logical_to_physical;
444+ options_.physical_stream_limit = 2;
445+ options_.candidate_limit = 1;
446+ options_.light_stream_limit = 1;
447+ options_.resim_candidate_limit = 0;
448+ options_.repair_moves = 2;
449+ 
450+ WeightedStreamMerger merger(options_);
451+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
452+ 
453+ ASSERT_EQ(status, graphStatus::SUCCESS);
454+ ExpectValidMapping(logical_to_physical, logical_routes.size());
455+}
456+ 
457+TEST_F(WeightedStreamMergerTest, Merge_DiamondWithRepairAndResim_ReturnsValidMapping) {
458+ BuildDiamondGraph();
459+ std::vector<std::vector<int32_t>> logical_routes = {{0, 1}, {2, 3}};
460+ std::vector<int32_t> logical_to_physical;
461+ options_.physical_stream_limit = 3;
462+ options_.candidate_limit = 4;
463+ options_.light_stream_limit = 3;
464+ options_.repair_moves = 5;
465+ options_.resim_candidate_limit = 3;
466+ 
467+ WeightedStreamMerger merger(options_);
468+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
469+ 
470+ ASSERT_EQ(status, graphStatus::SUCCESS);
471+ ExpectValidMapping(logical_to_physical, logical_routes.size());
472+}
473+ 
474+TEST_F(WeightedStreamMergerTest, Merge_CrossDependencyWithCosts_RepairTriggersSortComparators) {
475+ BuildCrossStreamDependencyGraph();
476+ std::vector<std::vector<int32_t>> logical_routes = {{0, 3, 5}, {1}, {2, 4}};
477+ std::vector<int32_t> logical_to_physical;
478+ options_.physical_stream_limit = 3;
479+ options_.candidate_limit = 3;
480+ options_.light_stream_limit = 2;
481+ options_.repair_moves = 5;
482+ options_.resim_candidate_limit = 2;
483+ 
484+ WeightedStreamMerger merger(options_);
485+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
486+ 
487+ ASSERT_EQ(status, graphStatus::SUCCESS);
488+ ExpectValidMapping(logical_to_physical, logical_routes.size());
489+}
490+ 
491+TEST_F(WeightedStreamMergerTest, Merge_LargeGraph_MultiLevel_WithStreamHints) {
492+ const int32_t count = 12;
493+ for (int32_t i = 0; i < count; ++i) {
494+ auto node = AddNode("n" + std::to_string(i), static_cast<float>(i + 1) * 2.0F, static_cast<size_t>((i % 3) + 1),
495+ static_cast<size_t>((i % 2) + 1));
496+ node->SetStreamId(i % 3);
497+ }
498+ for (int32_t i = 0; i < count - 1; ++i) {
499+ ASSERT_EQ(dag_->AddEdge(dag_->GetAllNodes()[i], 0, dag_->GetAllNodes()[i + 1], 0), graphStatus::SUCCESS);
500+ }
501+ 
502+ std::vector<std::vector<int32_t>> logical_routes;
503+ for (int32_t i = 0; i < count; i += 3) {
504+ logical_routes.push_back({i, i + 1, i + 2});
505+ }
506+ 
507+ std::vector<int32_t> logical_to_physical;
508+ options_.physical_stream_limit = 4;
509+ options_.candidate_limit = 4;
510+ options_.light_stream_limit = 3;
511+ options_.repair_moves = 5;
512+ options_.resim_candidate_limit = 3;
513+ 
514+ WeightedStreamMerger merger(options_);
515+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
516+ 
517+ ASSERT_EQ(status, graphStatus::SUCCESS);
518+ ExpectValidMapping(logical_to_physical, logical_routes.size());
519+}
520+ 
521+TEST_F(WeightedStreamMergerTest, Merge_MissingCostWithRepair_TriggersWarnPath) {
522+ BuildMissingAndExtremeCostGraph();
523+ std::vector<std::vector<int32_t>> logical_routes = {{0, 1}, {2}, {3}};
524+ std::vector<int32_t> logical_to_physical;
525+ options_.physical_stream_limit = 3;
526+ options_.candidate_limit = 3;
527+ options_.light_stream_limit = 2;
528+ options_.repair_moves = 3;
529+ options_.resim_candidate_limit = 2;
530+ 
531+ WeightedStreamMerger merger(options_);
532+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
533+ 
534+ ASSERT_EQ(status, graphStatus::SUCCESS);
535+ ExpectValidMapping(logical_to_physical, logical_routes.size());
536+}
537+ 
538+TEST_F(WeightedStreamMergerTest, Merge_TwoStageParallelWithRepair_TriggersSimulationComparators) {
539+ BuildTwoStageParallelGraph();
540+ std::vector<std::vector<int32_t>> logical_routes = {{0, 4}, {1, 5}, {2}, {3}};
541+ std::vector<int32_t> logical_to_physical;
542+ options_.physical_stream_limit = 4;
543+ options_.candidate_limit = 4;
544+ options_.light_stream_limit = 3;
545+ options_.repair_moves = 5;
546+ options_.resim_candidate_limit = 3;
547+ 
548+ WeightedStreamMerger merger(options_);
549+ auto status = merger.Merge(*dag_, logical_routes, logical_to_physical);
550+ 
551+ ASSERT_EQ(status, graphStatus::SUCCESS);
552+ ExpectValidMapping(logical_to_physical, logical_routes.size());
553+}
397} // namespace test554} // namespace test
398} // namespace minidag555} // namespace minidag
Mtests/ge/ut/ge/graph/build/graph_builder_unittest.cc+87-0
@@ -1237,4 +1237,91 @@ TEST_F(GraphBuilderTest, Build_Ok_TrainingWithMemoryPriority) {
1237 GetThreadLocalContext().SetGraphOption(options_map_recovery);1237 GetThreadLocalContext().SetGraphOption(options_map_recovery);
1238}1238}
1239 1239 
1240+TEST_F(GraphBuilderTest, Build_NullComputeGraph_ReturnsError) {
1241+ GraphBuilder graph_builder;
1242+ GeRootModelPtr root_model;
1243+ ComputeGraphPtr null_graph = nullptr;
1244+ auto ret = graph_builder.Build(null_graph, root_model);
1245+ EXPECT_NE(ret, SUCCESS);
1246+}
1247+ 
1248+TEST_F(GraphBuilderTest, Build_EmptyGraph_ReturnsError) {
1249+ GraphBuilder graph_builder;
1250+ auto root_graph = std::make_shared<ComputeGraph>("empty_graph");
1251+ AttrUtils::SetStr(root_graph, ATTR_NAME_SESSION_GRAPH_ID, kSessionId);
1252+ GeRootModelPtr root_model;
1253+ VarManager::Instance(0UL)->Init(0U, 0UL, 0UL, 0UL);
1254+ auto ret = graph_builder.Build(root_graph, root_model);
1255+ EXPECT_NE(ret, SUCCESS);
1256+}
1257+ 
1258+TEST_F(GraphBuilderTest, Build_GenTaskWithFusionMode) {
1259+ GraphBuilder graph_builder;
1260+ auto root_graph = BuildGraphWithConst();
1261+ AttrUtils::SetStr(root_graph, ATTR_NAME_SESSION_GRAPH_ID, kSessionId);
1262+ GeRootModelPtr root_model;
1263+ VarManager::Instance(0UL)->Init(0U, 0UL, 0UL, 0UL);
1264+ auto ret = graph_builder.Build(root_graph, root_model);
1265+}
1266+ 
1267+TEST_F(GraphBuilderTest, Build_DataNodeWithDynamicShape) {
1268+ GraphBuilder graph_builder;
1269+ DEF_GRAPH(graph) {
1270+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1, -1});
1271+ auto add = OP_CFG(ADD).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1, -1});
1272+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
1273+ CHAIN(NODE("data", data)->NODE("add", add)->NODE("Node_Output", net_output));
1274+ };
1275+ auto root_graph = ToComputeGraph(graph);
1276+ AttrUtils::SetStr(root_graph, ATTR_NAME_SESSION_GRAPH_ID, kSessionId);
1277+ GeRootModelPtr root_model;
1278+ VarManager::Instance(0UL)->Init(0U, 0UL, 0UL, 0UL);
1279+ auto ret = graph_builder.Build(root_graph, root_model);
1280+}
1281+ 
1282+TEST_F(GraphBuilderTest, Build_GraphWithSubgraph) {
1283+ GraphBuilder graph_builder;
1284+ DEF_GRAPH(sub) {
1285+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
1286+ auto add = OP_CFG(ADD).InCnt(1).OutCnt(1);
1287+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
1288+ CHAIN(NODE("sub_data", data)->NODE("sub_add", add)->NODE("sub_output", net_output));
1289+ };
1290+ auto sub_graph = ToComputeGraph(sub);
1291+ sub_graph->SetName("sub_graph");
1292+ 
1293+ DEF_GRAPH(root) {
1294+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
1295+ auto partitioned_call = OP_CFG(PARTITIONEDCALL).InCnt(1).OutCnt(1);
1296+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
1297+ CHAIN(NODE("root_data", data)->NODE("partitioned_call", partitioned_call)->NODE("Node_Output", net_output));
1298+ };
1299+ auto root_graph = ToComputeGraph(root);
1300+ root_graph->SetName("root_graph");
1301+ root_graph->AddSubGraph(sub_graph);
1302+ sub_graph->SetParentGraph(root_graph);
1303+ AttrUtils::SetStr(root_graph, ATTR_NAME_SESSION_GRAPH_ID, kSessionId);
1304+ GeRootModelPtr root_model;
1305+ VarManager::Instance(0UL)->Init(0U, 0UL, 0UL, 0UL);
1306+ auto ret = graph_builder.Build(root_graph, root_model);
1307+}
1308+ 
1309+TEST_F(GraphBuilderTest, Build_GraphWithWorkspaceUpdate) {
1310+ GraphBuilder graph_builder;
1311+ auto root_graph = BuildGraphWithConst();
1312+ AttrUtils::SetStr(root_graph, ATTR_NAME_SESSION_GRAPH_ID, kSessionId);
1313+ for (auto &node : root_graph->GetAllNodes()) {
1314+ if (node->GetType() == CONSTANT || node->GetType() == CONSTANTOP) {
1315+ continue;
1316+ }
1317+ auto op_desc = node->GetOpDesc();
1318+ if (op_desc != nullptr) {
1319+ std::vector<int64_t> ws_vec = {1024, 2048};
1320+ op_desc->SetWorkspace(ws_vec);
1321+ }
1322+ }
1323+ GeRootModelPtr root_model;
1324+ VarManager::Instance(0UL)->Init(0U, 0UL, 0UL, 0UL);
1325+ auto ret = graph_builder.Build(root_graph, root_model);
1326+}
1240} // namespace ge1327} // namespace ge
Mtests/ge/ut/ge/graph/build/graph_mem_assigner_unittest.cc+51-0
@@ -2354,4 +2354,55 @@ TEST_F(UtestGraphMemAssigner, Success) {
2354 MemoryAssigner mem_assigner(graph);2354 MemoryAssigner mem_assigner(graph);
2355 EXPECT_EQ(mem_assigner.AssignMemory(mem_offset, zero_copy_mem_size), SUCCESS);2355 EXPECT_EQ(mem_assigner.AssignMemory(mem_offset, zero_copy_mem_size), SUCCESS);
2356}2356}
2357+TEST_F(UtestGraphMemAssigner, AssignContinuousOutputMemory_GetTensorSizeFail) {
2358+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("graph");
2359+ auto node = UtAddNode(graph, "data", DATA, 1, 1);
2360+ AttrUtils::SetBool(node->GetOpDesc(), ATTR_NAME_CONTINUOUS_OUTPUT, true);
2361+ auto output_desc = node->GetOpDesc()->MutableOutputDesc(0);
2362+ ASSERT_NE(output_desc, nullptr);
2363+ TensorUtils::SetSize(*output_desc, 0);
2364+ GraphMemoryAssigner graph_mem_assigner(graph);
2365+ graph_mem_assigner.memory_offset_.emplace(RT_MEMORY_HBM, MemoryOffset(RT_MEMORY_HBM, 0));
2366+ EXPECT_NE(graph_mem_assigner.AssignContinuousOutputMemory(node, 1, 4), SUCCESS);
2367+}
2368+ 
2369+TEST_F(UtestGraphMemAssigner, AssignMemory2HasRefAttrNode_Success) {
2370+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("graph");
2371+ auto node = UtAddNode(graph, "data", DATA, 1, 1);
2372+ GraphMemoryAssigner graph_mem_assigner(graph);
2373+ EXPECT_EQ(graph_mem_assigner.AssignMemory2HasRefAttrNode(), SUCCESS);
2374+}
2375+ 
2376+TEST_F(UtestGraphMemAssigner, AssignVarAttr2Nodes_Success) {
2377+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("graph");
2378+ auto node = UtAddNode(graph, "data", DATA, 1, 1);
2379+ GraphMemoryAssigner graph_mem_assigner(graph);
2380+ EXPECT_EQ(graph_mem_assigner.AssignVarAttr2Nodes(), SUCCESS);
2381+}
2382+ 
2383+TEST_F(UtestGraphMemAssigner, CalculateTensorRealSize_Success) {
2384+ auto tensor_desc = std::make_shared<GeTensorDesc>();
2385+ SetDefaultTensorDesc(tensor_desc);
2386+ int64_t output_mem_size = 0;
2387+ int64_t batch_dim_num = 0;
2388+ int64_t out_size = 0;
2389+ EXPECT_EQ(CalculateTensorRealSizeAndOutSize(tensor_desc, 0, output_mem_size, batch_dim_num, out_size), SUCCESS);
2390+}
2391+ 
2392+TEST_F(UtestGraphMemAssigner, GetNodeMemoryType_InvalidInput) {
2393+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("graph");
2394+ auto node = UtAddNode(graph, "data", DATA, 1, 1);
2395+ GraphMemoryAssigner graph_mem_assigner(graph);
2396+ int64_t memory_type = 0;
2397+ EXPECT_NE(graph_mem_assigner.GetNodeMemoryType(node, memory_type, "input"), SUCCESS);
2398+ EXPECT_NE(graph_mem_assigner.GetNodeMemoryType(node, memory_type, "output"), SUCCESS);
2399+}
2400+ 
2401+TEST_F(UtestGraphMemAssigner, AssignZeroCopyMemory_EmptyGraph) {
2402+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("empty_zero_copy_test");
2403+ GraphMemoryAssigner graph_mem_assigner(graph);
2404+ map<uint64_t, size_t> mem_type_to_offset;
2405+ size_t zero_copy_mem_size = 0;
2406+ EXPECT_NE(graph_mem_assigner.AssignZeroCopyMemory(mem_type_to_offset, zero_copy_mem_size), SUCCESS);
2407+}
2357} // namespace ge2408} // namespace ge
Mtests/ge/ut/ge/graph/build/logical_stream_allocator_unittest.cc+78-0
@@ -1407,4 +1407,82 @@ TEST_F(UtestLogicalStreamAllocator, AicoreHcclSerial_AssignSameStream) {
1407 ASSERT_NE(relu2, nullptr);1407 ASSERT_NE(relu2, nullptr);
1408 EXPECT_EQ(relu2->GetOpDesc()->GetStreamId(), 0);1408 EXPECT_EQ(relu2->GetOpDesc()->GetStreamId(), 0);
1409}1409}
1410+TEST_F(UtestLogicalStreamAllocator, EmptyGraph_RunOptimizeSuccess) {
1411+ auto graph = std::make_shared<ComputeGraph>("empty_graph");
1412+ const std::map<std::string, int32_t> max_parallel_num;
1413+ LogicalStreamAllocator allocator(max_parallel_num);
1414+ auto ret = allocator.RunOptimizeByTopoPasses(graph);
1415+ EXPECT_EQ(ret, SUCCESS);
1416+}
1417+ 
1418+TEST_F(UtestLogicalStreamAllocator, SingleNodeGraph_RunOptimizeSuccess) {
1419+ DEF_GRAPH(g1) {
1420+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
1421+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
1422+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
1423+ };
1424+ auto graph = ToComputeGraph(g1);
1425+ const std::map<std::string, int32_t> max_parallel_num;
1426+ LogicalStreamAllocator allocator(max_parallel_num);
1427+ auto ret = allocator.RunOptimizeByTopoPasses(graph);
1428+ EXPECT_EQ(ret, SUCCESS);
1429+}
1430+ 
1431+TEST_F(UtestLogicalStreamAllocator, MultiStreamLabel_RunOptimizeSuccess) {
1432+ DEF_GRAPH(g1) {
1433+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
1434+ auto relu1 = OP_CFG(RELU).InCnt(1).OutCnt(1).Attr(public_attr::USER_STREAM_LABEL, "stream_a");
1435+ auto relu2 = OP_CFG(RELU).InCnt(1).OutCnt(1).Attr(public_attr::USER_STREAM_LABEL, "stream_b");
1436+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
1437+ CHAIN(NODE("data", data)->NODE("relu1", relu1)->NODE("relu2", relu2)->NODE("Node_Output", net_output));
1438+ };
1439+ auto graph = ToComputeGraph(g1);
1440+ const std::map<std::string, int32_t> max_parallel_num;
1441+ LogicalStreamAllocator allocator(max_parallel_num);
1442+ auto ret = allocator.RunOptimizeByTopoPasses(graph);
1443+ EXPECT_EQ(ret, SUCCESS);
1444+}
1445+ 
1446+TEST_F(UtestLogicalStreamAllocator, GraphWithHcomAndAicore_RunOptimizeSuccess) {
1447+ DEF_GRAPH(g1) {
1448+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_NCHW, DT_FLOAT, {1, 1, 224, 224});
1449+ auto relu1 = OP_CFG(RELU).InCnt(1).OutCnt(1).TensorDesc(FORMAT_NCHW, DT_FLOAT, {1, 1, 224, 224});
1450+ auto all_reduce = OP_CFG(HCOMALLREDUCE).InCnt(1).OutCnt(1).TensorDesc(FORMAT_NCHW, DT_FLOAT, {1, 1, 224, 224});
1451+ auto relu2 = OP_CFG(RELU).InCnt(1).OutCnt(1).TensorDesc(FORMAT_NCHW, DT_FLOAT, {1, 1, 224, 224});
1452+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_NCHW, DT_FLOAT, {-1});
1453+ CHAIN(NODE("data", data)
1454+ ->NODE("relu1", relu1)
1455+ ->NODE("all_reduce", all_reduce)
1456+ ->NODE("relu2", relu2)
1457+ ->NODE("Node_Output", net_output));
1458+ };
1459+ auto graph = ToComputeGraph(g1);
1460+ std::map<std::string, int32_t> max_parallel_num;
1461+ max_parallel_num[HCOMALLREDUCE] = 1;
1462+ LogicalStreamAllocator allocator(max_parallel_num);
1463+ auto ret = allocator.RunOptimizeByTopoPasses(graph);
1464+ EXPECT_EQ(ret, SUCCESS);
1465+}
1466+ 
1467+TEST_F(UtestLogicalStreamAllocator, GraphWithStreamId_RunOptimizeSuccess) {
1468+ DEF_GRAPH(g1) {
1469+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).StreamId(0);
1470+ auto relu = OP_CFG(RELU).InCnt(1).OutCnt(1).StreamId(0);
1471+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).StreamId(0);
1472+ CHAIN(NODE("data", data)->NODE("relu", relu)->NODE("Node_Output", net_output));
1473+ };
1474+ auto graph = ToComputeGraph(g1);
1475+ const std::map<std::string, int32_t> max_parallel_num;
1476+ LogicalStreamAllocator allocator(max_parallel_num);
1477+ auto ret = allocator.RunOptimizeByTopoPasses(graph);
1478+ EXPECT_EQ(ret, SUCCESS);
1479+}
1480+ 
1481+TEST_F(UtestLogicalStreamAllocator, RunOptimizeByTopoPasses_EmptyGraph) {
1482+ auto graph = std::make_shared<ComputeGraph>("empty_topo_graph");
1483+ const std::map<std::string, int32_t> max_parallel_num;
1484+ LogicalStreamAllocator allocator(max_parallel_num);
1485+ auto ret = allocator.RunOptimizeByTopoPasses(graph);
1486+ EXPECT_EQ(ret, SUCCESS);
1487+}
1410} // namespace ge1488} // namespace ge
Mtests/ge/ut/ge/graph/build/model_builder_unittest.cc+67-0
@@ -776,4 +776,71 @@ TEST_F(UtestModelBuilderTest, AssignStreamForDynamicShapeGraph_AutoMultistreamOp
776 EXPECT_EQ(ret, SUCCESS);776 EXPECT_EQ(ret, SUCCESS);
777 EXPECT_EQ(builder.stream_num_, 0);777 EXPECT_EQ(builder.stream_num_, 0);
778}778}
779+TEST_F(UtestModelBuilderTest, Build_SingleNodeGraph_Success) {
780+ DEF_GRAPH(graph) {
781+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {16});
782+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
783+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
784+ };
785+ auto compute_graph = ToComputeGraph(graph);
786+ ASSERT_EQ(compute_graph->TopologicalSorting(), GRAPH_SUCCESS);
787+ Graph2SubGraphInfoList subgraphs;
788+ std::map<std::string, int> stream_max_parallel_num;
789+ ge::ModelBuilder builder(0, compute_graph, subgraphs, stream_max_parallel_num, false);
790+ EXPECT_EQ(builder.AssignStreamForDynamicShapeGraph(compute_graph), SUCCESS);
791+}
792+ 
793+TEST_F(UtestModelBuilderTest, Build_WithWorkspace) {
794+ DEF_GRAPH(graph) {
795+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {16});
796+ auto add = OP_CFG(ADD).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {16});
797+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
798+ CHAIN(NODE("data", data)->NODE("add", add)->NODE("Node_Output", net_output));
799+ };
800+ auto compute_graph = ToComputeGraph(graph);
801+ auto add_node = compute_graph->FindNode("add");
802+ ASSERT_NE(add_node, nullptr);
803+ add_node->GetOpDesc()->SetWorkspaceBytes({1024, 2048});
804+ ASSERT_EQ(compute_graph->TopologicalSorting(), GRAPH_SUCCESS);
805+ Graph2SubGraphInfoList subgraphs;
806+ std::map<std::string, int> stream_max_parallel_num;
807+ ge::ModelBuilder builder(0, compute_graph, subgraphs, stream_max_parallel_num, false);
808+ EXPECT_EQ(builder.AssignStreamForDynamicShapeGraph(compute_graph), SUCCESS);
809+}
810+ 
811+TEST_F(UtestModelBuilderTest, AssignStreamForDynamicShapeGraph_SingleStream) {
812+ DEF_GRAPH(g1) {
813+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
814+ auto add = OP_CFG(ADD).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
815+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
816+ CHAIN(NODE("data", data)->NODE("add", add)->NODE("Node_Output", net_output));
817+ };
818+ auto graph = ToComputeGraph(g1);
819+ ASSERT_NE(graph, nullptr);
820+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
821+ Graph2SubGraphInfoList subgraphs;
822+ std::map<std::string, int> stream_max_parallel_num;
823+ ge::ModelBuilder builder(0, graph, subgraphs, stream_max_parallel_num, false);
824+ auto ret = builder.AssignStreamForDynamicShapeGraph(graph);
825+ EXPECT_EQ(ret, SUCCESS);
826+}
827+ 
828+TEST_F(UtestModelBuilderTest, AssignStreamForDynamicShapeGraph_WithHcom) {
829+ DEF_GRAPH(g1) {
830+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {16});
831+ auto all_reduce = OP_CFG(HCOMALLREDUCE).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {16});
832+ auto add = OP_CFG(ADD).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {16});
833+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
834+ CHAIN(NODE("data", data)->NODE("all_reduce", all_reduce)->NODE("add", add)->NODE("Node_Output", net_output));
835+ };
836+ auto graph = ToComputeGraph(g1);
837+ ASSERT_NE(graph, nullptr);
838+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
839+ Graph2SubGraphInfoList subgraphs;
840+ std::map<std::string, int> stream_max_parallel_num;
841+ stream_max_parallel_num[HCOMALLREDUCE] = 1;
842+ ge::ModelBuilder builder(0, graph, subgraphs, stream_max_parallel_num, false);
843+ auto ret = builder.AssignStreamForDynamicShapeGraph(graph);
844+ EXPECT_EQ(ret, SUCCESS);
845+}
779} // namespace ge846} // namespace ge
Mtests/ge/ut/ge/graph/build/model_cache_unittest.cc+90-0
@@ -873,4 +873,94 @@ TEST_F(ModelCacheTest, ReadCacheConfig_Failed) {
873 }873 }
874 RemoveCacheConfig();874 RemoveCacheConfig();
875}875}
876+TEST_F(ModelCacheTest, Init_WithSubGraph_Success) {
877+ DEF_GRAPH(sub) {
878+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
879+ auto add = OP_CFG(ADD).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
880+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {-1});
881+ CHAIN(NODE("sub_data", data)->NODE("sub_add", add)->NODE("sub_output", net_output));
882+ };
883+ auto sub_graph = ToComputeGraph(sub);
884+ sub_graph->SetName("sub_graph");
885+ 
886+ auto compute_graph = FakeGraphWithSubGraph("test_sub_graph", sub_graph);
887+ ASSERT_NE(compute_graph, nullptr);
888+ 
889+ SetCacheDirOption("./ut_cache_dir");
890+ SetGraphKeyOption("graph_key_sub");
891+ GraphRebuildStateCtrl ctrl;
892+ {
893+ ModelCache model_cache;
894+ auto ret = model_cache.Init(compute_graph, &ctrl);
895+ EXPECT_EQ(ret, SUCCESS);
896+ }
897+ RemoveCacheConfig();
898+}
899+ 
900+TEST_F(ModelCacheTest, TryLoadModelFromCache_NoCache_ReturnsSuccess) {
901+ auto compute_graph = FakeComputeGraph("test_no_cache");
902+ ASSERT_NE(compute_graph, nullptr);
903+ 
904+ SetCacheDirOption("./ut_cache_dir_nonexist");
905+ SetGraphKeyOption("graph_key_no_cache");
906+ GraphRebuildStateCtrl ctrl;
907+ {
908+ ModelCache model_cache;
909+ auto ret = model_cache.Init(compute_graph, &ctrl);
910+ GeRootModelPtr load_model;
911+ ret = model_cache.TryLoadModelFromCache(compute_graph, load_model);
912+ EXPECT_EQ(ret, SUCCESS);
913+ EXPECT_EQ(load_model, nullptr);
914+ }
915+ RemoveCacheConfig();
916+}
917+ 
918+TEST_F(ModelCacheTest, SaveCache_Failed_NoDir) {
919+ auto compute_graph = FakeComputeGraph("test_save_fail");
920+ ASSERT_NE(compute_graph, nullptr);
921+ 
922+ SetCacheDirOption("");
923+ SetGraphKeyOption("graph_key_save_fail");
924+ GraphRebuildStateCtrl ctrl;
925+ {
926+ ModelCache model_cache;
927+ auto ret = model_cache.Init(compute_graph, &ctrl);
928+ EXPECT_EQ(ret, SUCCESS);
929+ }
930+ RemoveCacheConfig();
931+}
932+ 
933+TEST_F(ModelCacheTest, Init_WithConstantGraph_Success) {
934+ auto compute_graph = FakeComputeGraphWithConstant("test_const_graph");
935+ ASSERT_NE(compute_graph, nullptr);
936+ 
937+ SetCacheDirOption("./ut_cache_dir");
938+ SetGraphKeyOption("graph_key_const");
939+ GraphRebuildStateCtrl ctrl;
940+ {
941+ ModelCache model_cache;
942+ auto ret = model_cache.Init(compute_graph, &ctrl);
943+ EXPECT_EQ(ret, SUCCESS);
944+ }
945+ RemoveCacheConfig();
946+}
947+ 
948+TEST_F(ModelCacheTest, ReadCacheConfig_EmptyFile) {
949+ auto compute_graph = FakeComputeGraph("test_empty_config");
950+ ASSERT_NE(compute_graph, nullptr);
951+ 
952+ std::string cache_config_file = "./ut_cache_dir/cache.conf";
953+ {
954+ std::ofstream json_file(cache_config_file);
955+ json_file << "{}" << std::endl;
956+ }
957+ SetCacheDirOption("./ut_cache_dir");
958+ SetGraphKeyOption("graph_key_empty_config");
959+ GraphRebuildStateCtrl ctrl;
960+ {
961+ ModelCache model_cache;
962+ auto ret = model_cache.Init(compute_graph, &ctrl);
963+ }
964+ RemoveCacheConfig();
965+}
876} // namespace ge966} // namespace ge
Mtests/ge/ut/ge/graph/build/run_context_unittest.cc+96-0
@@ -311,4 +311,100 @@ TEST_F(UtestRunContext, PrintMemInfo_NoCrash) {
311 RunContextUtil run_util;311 RunContextUtil run_util;
312 EXPECT_NO_THROW(run_util.PrintMemInfo());312 EXPECT_NO_THROW(run_util.PrintMemInfo());
313}313}
314+ 
315+TEST_F(UtestRunContext, GetMemorySize_GetSizeFailed) {
316+ auto graph = make_shared<ge::ComputeGraph>("test_graph");
317+ auto op_desc = make_shared<OpDesc>("test_node", "BufferPool");
318+ GeTensorDesc tensor_desc;
319+ op_desc->AddOutputDesc(tensor_desc);
320+ auto node = graph->AddNode(op_desc);
321+ int64_t output_size = 0;
322+ EXPECT_EQ(GetMemorySize(node, output_size), SUCCESS);
323+}
324+ 
325+TEST_F(UtestRunContext, SetActiveLabelList_NullNode) {
326+ NodePtr null_node = nullptr;
327+ EXPECT_EQ(SetActiveLabelList(null_node, {"label1"}), PARAM_INVALID);
328+}
329+ 
330+TEST_F(UtestRunContext, SetSwitchBranchNodeLabel_NullNode) {
331+ NodePtr null_node = nullptr;
332+ EXPECT_EQ(SetSwitchBranchNodeLabel(null_node, "branch1"), PARAM_INVALID);
333+}
334+ 
335+TEST_F(UtestRunContext, SetSwitchTrueBranchFlag_NullNode) {
336+ NodePtr null_node = nullptr;
337+ EXPECT_EQ(SetSwitchTrueBranchFlag(null_node, true), PARAM_INVALID);
338+}
339+ 
340+TEST_F(UtestRunContext, SetOriginalNodeName_NullNode) {
341+ NodePtr null_node = nullptr;
342+ EXPECT_EQ(SetOriginalNodeName(null_node, "orig_name"), PARAM_INVALID);
343+}
344+ 
345+TEST_F(UtestRunContext, SetCyclicDependenceFlag_NullNode) {
346+ NodePtr null_node = nullptr;
347+ EXPECT_EQ(SetCyclicDependenceFlag(null_node), PARAM_INVALID);
348+}
349+ 
350+TEST_F(UtestRunContext, SetNextIteration_NullNode) {
351+ NodePtr null_node = nullptr;
352+ auto graph = make_shared<ge::ComputeGraph>("test_graph");
353+ auto op_desc = make_shared<OpDesc>("node1", "Merge");
354+ auto node1 = graph->AddNode(op_desc);
355+ EXPECT_EQ(SetNextIteration(null_node, node1), PARAM_INVALID);
356+}
357+ 
358+TEST_F(UtestRunContext, SetNextIteration_BothNull) {
359+ NodePtr null_node = nullptr;
360+ EXPECT_EQ(SetNextIteration(null_node, null_node), PARAM_INVALID);
361+}
362+ 
363+TEST_F(UtestRunContext, GetOriginalType_NullNode) {
364+ NodePtr null_node = nullptr;
365+ std::string type;
366+ EXPECT_EQ(GetOriginalType(null_node, type), PARAM_INVALID);
367+}
368+ 
369+TEST_F(UtestRunContext, AlignMemSize_LargePositive) {
370+ int64_t mem_size = 1000;
371+ AlignMemSize(mem_size, 512);
372+ EXPECT_EQ(mem_size, 1024);
373+}
374+ 
375+TEST_F(UtestRunContext, SetStreamLabel_WithEmptyLabel) {
376+ auto graph = make_shared<ge::ComputeGraph>("test_graph");
377+ auto op_desc = make_shared<OpDesc>("test_node", "Add");
378+ auto node = graph->AddNode(op_desc);
379+ EXPECT_EQ(SetStreamLabel(node, ""), SUCCESS);
380+}
381+ 
382+TEST_F(UtestRunContext, SetActiveLabelList_WithEmptyList) {
383+ auto graph = make_shared<ge::ComputeGraph>("test_graph");
384+ auto op_desc = make_shared<OpDesc>("test_node", "Add");
385+ auto node = graph->AddNode(op_desc);
386+ std::vector<std::string> empty_labels;
387+ EXPECT_EQ(SetActiveLabelList(node, empty_labels), SUCCESS);
388+}
389+ 
390+TEST_F(UtestRunContext, SetNextIteration_BothValidNodes) {
391+ auto graph = make_shared<ge::ComputeGraph>("test_graph");
392+ auto op_desc1 = make_shared<OpDesc>("node1", "Merge");
393+ auto op_desc2 = make_shared<OpDesc>("node2", "NextIteration");
394+ auto node1 = graph->AddNode(op_desc1);
395+ auto node2 = graph->AddNode(op_desc2);
396+ EXPECT_EQ(SetNextIteration(node1, node2), SUCCESS);
397+ EXPECT_EQ(SetNextIteration(node2, node1), SUCCESS);
398+}
399+ 
400+TEST_F(UtestRunContext, GetMemorySize_WithSizeZero) {
401+ auto graph = make_shared<ge::ComputeGraph>("test_graph");
402+ auto op_desc = make_shared<OpDesc>("test_node", "BufferPool");
403+ GeTensorDesc tensor_desc;
404+ TensorUtils::SetSize(tensor_desc, 0);
405+ op_desc->AddOutputDesc(tensor_desc);
406+ auto node = graph->AddNode(op_desc);
407+ int64_t output_size = 0;
408+ EXPECT_EQ(GetMemorySize(node, output_size), SUCCESS);
409+}
314} // namespace ge410} // namespace ge
Mtests/ge/ut/ge/graph/build/stream_allocator_unittest.cc+115-0
@@ -2027,4 +2027,119 @@ TEST_F(UtestStreamAllocator, RefreshTaskDefStreamId_AttachedStream_success) {
2027 ASSERT_EQ(task_defs[2].stream_id(), 2);2027 ASSERT_EQ(task_defs[2].stream_id(), 2);
2028 ASSERT_EQ(task_defs[3].stream_id(), 3);2028 ASSERT_EQ(task_defs[3].stream_id(), 3);
2029}2029}
2030+TEST_F(UtestStreamAllocator, AssignLogicalStreams_SingleNode_Success) {
2031+ DEF_GRAPH(g1) {
2032+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2033+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2034+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
2035+ };
2036+ auto graph = ToComputeGraph(g1);
2037+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2038+ Graph2SubGraphInfoList subgraphs;
2039+ StreamAllocator allocator(graph, subgraphs);
2040+ std::map<std::string, int32_t> max_parallel_num;
2041+ auto ret = allocator.AssignLogicalStreams(max_parallel_num, false);
2042+}
2043+ 
2044+TEST_F(UtestStreamAllocator, InsertSyncEvents_SingleStream_Success) {
2045+ DEF_GRAPH(g1) {
2046+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2047+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2048+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
2049+ };
2050+ auto graph = ToComputeGraph(g1);
2051+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2052+ Graph2SubGraphInfoList subgraphs;
2053+ StreamAllocator allocator(graph, subgraphs);
2054+ auto ret = allocator.InsertSyncEvents(EventType::kEvent);
2055+}
2056+ 
2057+TEST_F(UtestStreamAllocator, InsertSyncEvents_MultiBranch_Success) {
2058+ DEF_GRAPH(g1) {
2059+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2060+ auto add1 = OP_CFG(ADD).InCnt(1).OutCnt(1);
2061+ auto add2 = OP_CFG(ADD).InCnt(1).OutCnt(1);
2062+ auto concat = OP_CFG(CONCAT).InCnt(2).OutCnt(1);
2063+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2064+ CHAIN(NODE("data", data)->EDGE(0, 0)->NODE("add1", add1)->EDGE(0, 0)->NODE("concat", concat));
2065+ CHAIN(NODE("data", data)->EDGE(0, 0)->NODE("add2", add2)->EDGE(0, 1)->NODE("concat", concat));
2066+ CHAIN(NODE("concat", concat)->NODE("Node_Output", net_output));
2067+ };
2068+ auto graph = ToComputeGraph(g1);
2069+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2070+ Graph2SubGraphInfoList subgraphs;
2071+ StreamAllocator allocator(graph, subgraphs);
2072+ auto ret = allocator.InsertSyncEvents(EventType::kEvent);
2073+}
2074+ 
2075+TEST_F(UtestStreamAllocator, SetActiveStreamsByLabel_Success) {
2076+ DEF_GRAPH(g1) {
2077+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2078+ auto relu1 = OP_CFG(RELU).InCnt(1).OutCnt(1).Attr(public_attr::USER_STREAM_LABEL, "label_1");
2079+ auto relu2 = OP_CFG(RELU).InCnt(1).OutCnt(1).Attr(public_attr::USER_STREAM_LABEL, "label_2");
2080+ auto net_output = OP_CFG(NETOUTPUT).InCnt(2).OutCnt(1);
2081+ CHAIN(NODE("data", data)->EDGE(0, 0)->NODE("relu1", relu1)->EDGE(0, 0)->NODE("Node_Output", net_output));
2082+ CHAIN(NODE("data", data)->EDGE(0, 0)->NODE("relu2", relu2)->EDGE(0, 1)->NODE("Node_Output", net_output));
2083+ };
2084+ auto graph = ToComputeGraph(g1);
2085+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2086+ Graph2SubGraphInfoList subgraphs;
2087+ StreamAllocator allocator(graph, subgraphs);
2088+ auto ret = allocator.SetActiveStreamsByLabel();
2089+}
2090+ 
2091+TEST_F(UtestStreamAllocator, CheckStreamActived_Success) {
2092+ DEF_GRAPH(g1) {
2093+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2094+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2095+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
2096+ };
2097+ auto graph = ToComputeGraph(g1);
2098+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2099+ Graph2SubGraphInfoList subgraphs;
2100+ StreamAllocator allocator(graph, subgraphs);
2101+ auto ret = allocator.CheckStreamActived();
2102+}
2103+ 
2104+TEST_F(UtestStreamAllocator, InsertSyncNodesByLogicStream_Success) {
2105+ DEF_GRAPH(g1) {
2106+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2107+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2108+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
2109+ };
2110+ auto graph = ToComputeGraph(g1);
2111+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2112+ Graph2SubGraphInfoList subgraphs;
2113+ StreamAllocator allocator(graph, subgraphs);
2114+ int64_t stream_num = 0;
2115+ int64_t event_num = 0;
2116+ int64_t notify_num = 0;
2117+ auto ret = allocator.InsertSyncNodesByLogicStream(stream_num, event_num, notify_num);
2118+}
2119+ 
2120+TEST_F(UtestStreamAllocator, PreProcessOfInsertSyncNodes_Success) {
2121+ DEF_GRAPH(g1) {
2122+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2123+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2124+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
2125+ };
2126+ auto graph = ToComputeGraph(g1);
2127+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2128+ Graph2SubGraphInfoList subgraphs;
2129+ StreamAllocator allocator(graph, subgraphs);
2130+ auto ret = allocator.PreProcessOfInsertSyncNodes();
2131+}
2132+ 
2133+TEST_F(UtestStreamAllocator, GenerateSyncEventNodes_Success) {
2134+ DEF_GRAPH(g1) {
2135+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1);
2136+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1);
2137+ CHAIN(NODE("data", data)->NODE("Node_Output", net_output));
2138+ };
2139+ auto graph = ToComputeGraph(g1);
2140+ ASSERT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2141+ Graph2SubGraphInfoList subgraphs;
2142+ StreamAllocator allocator(graph, subgraphs);
2143+ auto ret = allocator.GenerateSyncEventNodes(false);
2144+}
2030} // namespace ge2145} // namespace ge
Mtests/ge/ut/ge/graph/common/trans_op_creator_unittest.cc+99-0
@@ -288,4 +288,103 @@ TEST(UtestGraphCreateTransOp, GeShapeHasher_DifferentShapeDifferentHash) {
288 GeShape shape2({3, 2, 1});288 GeShape shape2({3, 2, 1});
289 EXPECT_NE(hasher(shape1), hasher(shape2));289 EXPECT_NE(hasher(shape1), hasher(shape2));
290}290}
291+ 
292+TEST(UtestGraphCreateTransOp, CheckAccuracySupported_WithNonMatchingEngine) {
293+ map<string, string> options;
294+ MmpaStub::GetInstance().SetImpl(std::make_shared<MockMmpaForTransOpInit>());
295+ ge::GELib::Initialize(options);
296+ MmpaStub::GetInstance().Reset();
297+ 
298+ OpDescPtr op_desc = std::make_shared<OpDesc>("transdata_test", TRANSDATA);
299+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
300+ GeTensorDesc output_desc(GeShape({1, 14, 224, 224, 16}), FORMAT_NC1HWC0, DT_FLOAT);
301+ (void)op_desc->AddInputDesc(input_desc);
302+ (void)op_desc->AddOutputDesc(output_desc);
303+ 
304+ bool is_supported = false;
305+ std::string unsupported_reason;
306+ auto result =
307+ TransOpCreator::CheckAccuracySupported(op_desc, "non_existent_engine", is_supported, unsupported_reason);
308+ EXPECT_NE(result, GRAPH_SUCCESS);
309+ EXPECT_FALSE(is_supported);
310+ 
311+ ge::GELib::GetInstance()->Finalize();
312+}
313+ 
314+TEST(UtestGraphCreateTransOp, CreateTransDataOp_WithDstSubformat) {
315+ vector<int64_t> dims = {1, 2, 3, 4};
316+ GeShape shape(dims);
317+ Format dst_format = static_cast<Format>(GetFormatFromSub(FORMAT_FRACTAL_Z, 32));
318+ GeTensorDesc input_desc(shape, FORMAT_NCHW);
319+ GeTensorDesc output_desc(shape, dst_format);
320+ 
321+ auto trans_op = TransOpCreator::CreateTransDataOp("test_trans_data_dst_sub", input_desc, output_desc, false);
322+ EXPECT_NE(trans_op, nullptr);
323+ 
324+ int32_t dst_subformat = -1;
325+ EXPECT_TRUE(AttrUtils::GetInt(trans_op, FORMAT_TRANSFER_DST_SUBFORMAT, dst_subformat));
326+ EXPECT_EQ(dst_subformat, 32);
327+ 
328+ int32_t groups = -1;
329+ EXPECT_TRUE(AttrUtils::GetInt(trans_op, "groups", groups));
330+ EXPECT_EQ(groups, 32);
331+}
332+ 
333+TEST(UtestGraphCreateTransOp, CreateTransDataOp_WithBothSubformat) {
334+ vector<int64_t> dims = {1, 2, 3, 4};
335+ GeShape shape(dims);
336+ Format src_format = static_cast<Format>(GetFormatFromSub(FORMAT_FRACTAL_Z, 16));
337+ Format dst_format = static_cast<Format>(GetFormatFromSub(FORMAT_FRACTAL_Z, 32));
338+ GeTensorDesc input_desc(shape, src_format);
339+ GeTensorDesc output_desc(shape, dst_format);
340+ 
341+ auto trans_op = TransOpCreator::CreateTransDataOp("test_trans_data_both_sub", input_desc, output_desc, false);
342+ EXPECT_NE(trans_op, nullptr);
343+ 
344+ int32_t src_subformat = -1;
345+ EXPECT_TRUE(AttrUtils::GetInt(trans_op, FORMAT_TRANSFER_SRC_SUBFORMAT, src_subformat));
346+ EXPECT_EQ(src_subformat, 16);
347+ 
348+ int32_t dst_subformat = -1;
349+ EXPECT_TRUE(AttrUtils::GetInt(trans_op, FORMAT_TRANSFER_DST_SUBFORMAT, dst_subformat));
350+ EXPECT_EQ(dst_subformat, 32);
351+}
352+ 
353+TEST(UtestGraphCreateTransOp, CreateTransDataOp_WithFractalZ3DSubformat) {
354+ vector<int64_t> dims = {1, 2, 3, 4};
355+ GeShape shape(dims);
356+ Format src_format = static_cast<Format>(GetFormatFromSub(FORMAT_FRACTAL_Z_3D, 32));
357+ GeTensorDesc input_desc(shape, src_format);
358+ GeTensorDesc output_desc(shape, FORMAT_NCHW);
359+ 
360+ auto trans_op = TransOpCreator::CreateTransDataOp("test_trans_data_z3d", input_desc, output_desc, false);
361+ EXPECT_NE(trans_op, nullptr);
362+}
363+ 
364+TEST(UtestGraphCreateTransOp, CreateCastOp_WithCheckAccuracyEnabled) {
365+ vector<int64_t> dims = {1, 2, 3, 4};
366+ GeShape shape(dims);
367+ GeTensorDesc input_desc(shape, FORMAT_NHWC, DT_FLOAT);
368+ GeTensorDesc output_desc(shape, FORMAT_NCHW, DT_BOOL);
369+ auto cast_op = TransOpCreator::CreateCastOp("test_cast_check", input_desc, output_desc, true);
370+ EXPECT_EQ(cast_op, nullptr);
371+}
372+ 
373+TEST(UtestGraphCreateTransOp, CreateOtherTransOp_WithEmptyOpType) {
374+ GeTensorDesc input_desc(GeShape({1, 3}), FORMAT_ND, DT_FLOAT);
375+ GeTensorDesc output_desc(GeShape({1, 3}), FORMAT_ND, DT_FLOAT);
376+ auto result = TransOpCreator::CreateOtherTransOp("test_empty_type", "", input_desc, output_desc);
377+ EXPECT_NE(result, nullptr);
378+}
379+ 
380+TEST(UtestGraphCreateTransOp, CreateReshapeNodeToGraph_WithScalarOutput) {
381+ auto compute_graph = std::make_shared<ComputeGraph>("reshape_scalar_test");
382+ GeTensorDesc input_desc(GeShape({1}), FORMAT_ND, DT_FLOAT);
383+ GeTensorDesc output_desc(GeShape(std::vector<int64_t>{}), FORMAT_ND, DT_FLOAT);
384+ output_desc.SetOriginShape(GeShape(std::vector<int64_t>{}));
385+ std::unordered_map<GeShape, NodePtr, GeShapeHasher> cache;
386+ auto result =
387+ TransOpCreator::CreateReshapeNodeToGraph(compute_graph, "reshape_scalar", input_desc, output_desc, cache);
388+ EXPECT_NE(result, nullptr);
389+}
291} // namespace ge390} // namespace ge
Mtests/ge/ut/ge/graph/eager_style_graph_builder/es_base_struct/es_compliant_node_builder_unittest.cc+143-0
@@ -464,3 +464,146 @@ TEST_F(CompliantNodeBuilderLLT, MultipleDynamicIO) {
464 .CheckOutputIrInfo({{0, {0, 2}}, {1, {2, 3}}});464 .CheckOutputIrInfo({{0, {0, 2}}, {1, {2, 3}}});
465 EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);465 EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);
466}466}
467+ 
468+TEST_F(CompliantNodeBuilderLLT, IrInputDefV2_CopyAssignment) {
469+ CompliantNodeBuilder::IrInputDefV2 src("in1", CompliantNodeBuilder::kEsIrInputOptional, "sym1");
470+ CompliantNodeBuilder::IrInputDefV2 dst("old", CompliantNodeBuilder::kEsIrInputRequired, "oldsym");
471+ dst = src;
472+ EXPECT_STREQ(dst.GetName(), "in1");
473+ EXPECT_EQ(dst.GetInputType(), CompliantNodeBuilder::kEsIrInputOptional);
474+ EXPECT_STREQ(dst.GetSymbolId(), "sym1");
475+}
476+ 
477+TEST_F(CompliantNodeBuilderLLT, IrInputDefV2_MoveConstructor) {
478+ CompliantNodeBuilder::IrInputDefV2 src("move_in", CompliantNodeBuilder::kEsIrInputDynamic, "movesym");
479+ CompliantNodeBuilder::IrInputDefV2 dst(std::move(src));
480+ EXPECT_STREQ(dst.GetName(), "move_in");
481+ EXPECT_EQ(dst.GetInputType(), CompliantNodeBuilder::kEsIrInputDynamic);
482+ EXPECT_STREQ(dst.GetSymbolId(), "movesym");
483+}
484+ 
485+TEST_F(CompliantNodeBuilderLLT, IrInputDefV2_MoveAssignment) {
486+ CompliantNodeBuilder::IrInputDefV2 src("move_assign_in", CompliantNodeBuilder::kEsIrInputOptional, "movesym2");
487+ CompliantNodeBuilder::IrInputDefV2 dst("old2", CompliantNodeBuilder::kEsIrInputRequired, "oldsym2");
488+ dst = std::move(src);
489+ EXPECT_STREQ(dst.GetName(), "move_assign_in");
490+ EXPECT_EQ(dst.GetInputType(), CompliantNodeBuilder::kEsIrInputOptional);
491+ EXPECT_STREQ(dst.GetSymbolId(), "movesym2");
492+}
493+ 
494+TEST_F(CompliantNodeBuilderLLT, IrInputDefV2_SymbolId) {
495+ CompliantNodeBuilder::IrInputDefV2 def("x", CompliantNodeBuilder::kEsIrInputRequired, "");
496+ def.SymbolId("custom_sym");
497+ EXPECT_STREQ(def.GetSymbolId(), "custom_sym");
498+}
499+ 
500+TEST_F(CompliantNodeBuilderLLT, IrOutputDefV2_CopyAssignment) {
501+ CompliantNodeBuilder::IrOutputDefV2 src("out1", CompliantNodeBuilder::kEsIrOutputDynamic, "outsym1");
502+ CompliantNodeBuilder::IrOutputDefV2 dst("old", CompliantNodeBuilder::kEsIrOutputRequired, "oldsym");
503+ dst = src;
504+ EXPECT_STREQ(dst.GetName(), "out1");
505+ EXPECT_EQ(dst.GetOutputType(), CompliantNodeBuilder::kEsIrOutputDynamic);
506+ EXPECT_STREQ(dst.GetSymbolId(), "outsym1");
507+}
508+ 
509+TEST_F(CompliantNodeBuilderLLT, IrOutputDefV2_MoveConstructor) {
510+ CompliantNodeBuilder::IrOutputDefV2 src("move_out", CompliantNodeBuilder::kEsIrOutputRequired, "movesym");
511+ CompliantNodeBuilder::IrOutputDefV2 dst(std::move(src));
512+ EXPECT_STREQ(dst.GetName(), "move_out");
513+ EXPECT_EQ(dst.GetOutputType(), CompliantNodeBuilder::kEsIrOutputRequired);
514+ EXPECT_STREQ(dst.GetSymbolId(), "movesym");
515+}
516+ 
517+TEST_F(CompliantNodeBuilderLLT, IrOutputDefV2_MoveAssignment) {
518+ CompliantNodeBuilder::IrOutputDefV2 src("move_assign_out", CompliantNodeBuilder::kEsIrOutputDynamic, "movesym2");
519+ CompliantNodeBuilder::IrOutputDefV2 dst("old2", CompliantNodeBuilder::kEsIrOutputRequired, "oldsym2");
520+ dst = std::move(src);
521+ EXPECT_STREQ(dst.GetName(), "move_assign_out");
522+ EXPECT_EQ(dst.GetOutputType(), CompliantNodeBuilder::kEsIrOutputDynamic);
523+ EXPECT_STREQ(dst.GetSymbolId(), "movesym2");
524+}
525+ 
526+TEST_F(CompliantNodeBuilderLLT, IrOutputDefV2_SymbolId) {
527+ CompliantNodeBuilder::IrOutputDefV2 def("y", CompliantNodeBuilder::kEsIrOutputRequired, "");
528+ def.SymbolId("custom_out_sym");
529+ EXPECT_STREQ(def.GetSymbolId(), "custom_out_sym");
530+}
531+ 
532+TEST_F(CompliantNodeBuilderLLT, IrAttrDefV2_CopyAssignment) {
533+ auto val = AttrValue();
534+ val.SetAttrValue(static_cast<int64_t>(42));
535+ CompliantNodeBuilder::IrAttrDefV2 src("attr1", CompliantNodeBuilder::kEsAttrRequired, "Int", val);
536+ CompliantNodeBuilder::IrAttrDefV2 dst("old", CompliantNodeBuilder::kEsAttrOptional, "Float", AttrValue());
537+ dst = src;
538+ EXPECT_STREQ(dst.GetAttrName(), "attr1");
539+ EXPECT_EQ(dst.GetAttrType(), CompliantNodeBuilder::kEsAttrRequired);
540+ EXPECT_STREQ(dst.GetAttrDataType(), "Int");
541+}
542+ 
543+TEST_F(CompliantNodeBuilderLLT, IrAttrDefV2_MoveConstructor) {
544+ auto val = AttrValue();
545+ val.SetAttrValue(static_cast<float>(3.14f));
546+ CompliantNodeBuilder::IrAttrDefV2 src("move_attr", CompliantNodeBuilder::kEsAttrOptional, "Float", val);
547+ CompliantNodeBuilder::IrAttrDefV2 dst(std::move(src));
548+ EXPECT_STREQ(dst.GetAttrName(), "move_attr");
549+ EXPECT_EQ(dst.GetAttrType(), CompliantNodeBuilder::kEsAttrOptional);
550+ EXPECT_STREQ(dst.GetAttrDataType(), "Float");
551+}
552+ 
553+TEST_F(CompliantNodeBuilderLLT, IrAttrDefV2_MoveAssignment) {
554+ auto val = AttrValue();
555+ val.SetAttrValue(static_cast<int64_t>(99));
556+ CompliantNodeBuilder::IrAttrDefV2 src("move_assign_attr", CompliantNodeBuilder::kEsAttrRequired, "Int", val);
557+ CompliantNodeBuilder::IrAttrDefV2 dst("old", CompliantNodeBuilder::kEsAttrOptional, "String", AttrValue());
558+ dst = std::move(src);
559+ EXPECT_STREQ(dst.GetAttrName(), "move_assign_attr");
560+ EXPECT_EQ(dst.GetAttrType(), CompliantNodeBuilder::kEsAttrRequired);
561+ EXPECT_STREQ(dst.GetAttrDataType(), "Int");
562+}
563+ 
564+TEST_F(CompliantNodeBuilderLLT, InstanceOutputStorageShape) {
565+ CompliantNodeBuilder builder(test_graph_.get());
566+ builder.OpType("TestOp")
567+ .Name("TestName")
568+ .IrDefOutputsV2({{"output1", CompliantNodeBuilder::kEsIrOutputRequired, "out1"}})
569+ .InstanceOutputStorageShape("output1", shape_);
570+ auto node = builder.Build();
571+ EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);
572+}
573+ 
574+TEST_F(CompliantNodeBuilderLLT, InstanceOutputOriginFormat) {
575+ CompliantNodeBuilder builder(test_graph_.get());
576+ builder.OpType("TestOp")
577+ .Name("TestName")
578+ .IrDefOutputsV2({{"output1", CompliantNodeBuilder::kEsIrOutputRequired, "out1"}})
579+ .InstanceOutputOriginFormat("output1", FORMAT_NCHW);
580+ auto node = builder.Build();
581+ EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);
582+}
583+ 
584+TEST_F(CompliantNodeBuilderLLT, InstanceOutputStorageFormat) {
585+ CompliantNodeBuilder builder(test_graph_.get());
586+ builder.OpType("TestOp")
587+ .Name("TestName")
588+ .IrDefOutputsV2({{"output1", CompliantNodeBuilder::kEsIrOutputRequired, "out1"}})
589+ .InstanceOutputStorageFormat("output1", FORMAT_NHWC);
590+ auto node = builder.Build();
591+ EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);
592+}
593+ 
594+TEST_F(CompliantNodeBuilderLLT, MoveConstructor) {
595+ CompliantNodeBuilder builder1(test_graph_.get());
596+ builder1.OpType("TestOp").Name("TestName").IrDefOutputsV2(output_defs_);
597+ CompliantNodeBuilder builder2(std::move(builder1));
598+ auto node = builder2.Build();
599+ EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);
600+}
601+ 
602+TEST_F(CompliantNodeBuilderLLT, MoveAssignment) {
603+ CompliantNodeBuilder builder1(test_graph_.get());
604+ builder1.OpType("TestOp").Name("TestName").IrDefOutputsV2(output_defs_);
605+ CompliantNodeBuilder builder2(test_graph_.get());
606+ builder2 = std::move(builder1);
607+ auto node = builder2.Build();
608+ EXPECT_NE(ge::NodeAdapter::GNode2Node(node), nullptr);
609+}
Mtests/ge/ut/ge/graph/eager_style_graph_builder/es_generator/history/overload_planner_unittest.cc+214-0
@@ -11,6 +11,7 @@
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12 12 
13#include "history/overload_planner.h"13#include "history/overload_planner.h"
14+#include "history/attr_type_traits.h"
14#include "history/warning_formatter.h"15#include "history/warning_formatter.h"
15 16 
16using namespace ge::es::history;17using namespace ge::es::history;
@@ -749,3 +750,216 @@ TEST_F(OverloadPlannerUT, ValidationShouldNormalizeKeywordNamesForDynamicOutputA
749 EXPECT_TRUE(has_normalized_dynamic_output_name);750 EXPECT_TRUE(has_normalized_dynamic_output_name);
750 EXPECT_TRUE(has_normalized_subgraph_name);751 EXPECT_TRUE(has_normalized_subgraph_name);
751}752}
753+ 
754+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenOutputsChanged) {
755+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {{"y", ge::kIrOutputRequired, {}}});
756+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}}, {},
757+ {{"y", ge::kIrOutputRequired, {}}, {"y2", ge::kIrOutputRequired, {}}});
758+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
759+ ASSERT_EQ(plan.signatures.size(), 1U);
760+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
761+}
762+ 
763+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenOutputNameMismatch) {
764+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {{"y", ge::kIrOutputRequired, {}}});
765+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {{"z", ge::kIrOutputRequired, {}}});
766+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
767+ ASSERT_EQ(plan.signatures.size(), 1U);
768+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
769+}
770+ 
771+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenSubgraphsChanged) {
772+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {}, {{"g1", ge::kStatic}});
773+ const auto current =
774+ BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {}, {{"g1", ge::kStatic}, {"g2", ge::kStatic}});
775+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
776+ ASSERT_EQ(plan.signatures.size(), 1U);
777+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
778+}
779+ 
780+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenSubgraphNameMismatch) {
781+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {}, {{"g1", ge::kStatic}});
782+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}}, {}, {}, {{"g2", ge::kStatic}});
783+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
784+ ASSERT_EQ(plan.signatures.size(), 1U);
785+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
786+}
787+ 
788+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenAttrsShrink) {
789+ const IrAttr a = {"a", "Int", false, "0"};
790+ const IrAttr b = {"b", "Int", false, "0"};
791+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}}, {a, b});
792+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}}, {a});
793+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
794+ ASSERT_EQ(plan.signatures.size(), 1U);
795+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
796+}
797+ 
798+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenAttrMismatch) {
799+ const IrAttr a = {"a", "Int", false, "0"};
800+ const IrAttr a_changed = {"a", "Float", false, "0.0"};
801+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}}, {a});
802+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}}, {a_changed});
803+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
804+ ASSERT_EQ(plan.signatures.size(), 1U);
805+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
806+}
807+ 
808+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenNewAttrIsRequired) {
809+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}});
810+ const IrAttr req_attr = {"req", "Int", true, ""};
811+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}}, {req_attr});
812+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
813+ ASSERT_EQ(plan.signatures.size(), 1U);
814+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
815+}
816+ 
817+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenNewInputNotOptional) {
818+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}});
819+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}, {"y", ge::kIrInputRequired, {}}});
820+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
821+ ASSERT_EQ(plan.signatures.size(), 1U);
822+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
823+}
824+ 
825+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenInputsShrink) {
826+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}, {"y", ge::kIrInputRequired, {}}});
827+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}});
828+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
829+ ASSERT_EQ(plan.signatures.size(), 1U);
830+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
831+}
832+ 
833+TEST_F(OverloadPlannerUT, PlanFallbackToA0WhenIncompatibleWithoutNewInputsAndNoAttrRisk) {
834+ const auto v1 = BuildProto({{"x", ge::kIrInputRequired, {}}, {"y", ge::kIrInputRequired, {}}});
835+ const auto current = BuildProto({{"x", ge::kIrInputRequired, {}}, {"z", ge::kIrInputRequired, {}}});
836+ const auto plan = planner_.Plan(current, BuildHistory({v1}));
837+ ASSERT_EQ(plan.signatures.size(), 1U);
838+ EXPECT_TRUE(HasWarningCode(plan, WarningCode::kFallbackToA0));
839+}
840+ 
841+TEST(AttrTypeTraitsUT, ParseDefaultExpr_FloatTypeMismatch) {
842+ auto result = AttrTypeTraits::ParseDefaultExpr("Float", "\"not_float\"");
843+ EXPECT_FALSE(result.success);
844+ EXPECT_NE(result.error.find("type mismatch for Float"), std::string::npos);
845+}
846+ 
847+TEST(AttrTypeTraitsUT, ParseDefaultExpr_BoolTypeMismatch) {
848+ auto result = AttrTypeTraits::ParseDefaultExpr("Bool", "\"not_bool\"");
849+ EXPECT_FALSE(result.success);
850+ EXPECT_NE(result.error.find("type mismatch for Bool"), std::string::npos);
851+}
852+ 
853+TEST(AttrTypeTraitsUT, ParseDefaultExpr_StringTypeMismatch) {
854+ auto result = AttrTypeTraits::ParseDefaultExpr("String", "123");
855+ EXPECT_FALSE(result.success);
856+ EXPECT_NE(result.error.find("type mismatch for String"), std::string::npos);
857+}
858+ 
859+TEST(AttrTypeTraitsUT, ParseDefaultExpr_TypeTypeMismatch) {
860+ auto result = AttrTypeTraits::ParseDefaultExpr("Type", "123");
861+ EXPECT_FALSE(result.success);
862+ EXPECT_NE(result.error.find("type mismatch for Type"), std::string::npos);
863+}
864+ 
865+TEST(AttrTypeTraitsUT, ParseDefaultExpr_TensorTypeMismatch) {
866+ auto result = AttrTypeTraits::ParseDefaultExpr("Tensor", "123");
867+ EXPECT_FALSE(result.success);
868+ EXPECT_NE(result.error.find("type mismatch for Tensor"), std::string::npos);
869+}
870+ 
871+TEST(AttrTypeTraitsUT, ParseDefaultExpr_TensorNotTensorValue) {
872+ auto result = AttrTypeTraits::ParseDefaultExpr("Tensor", "\"NotTensor()\"");
873+ EXPECT_FALSE(result.success);
874+ EXPECT_NE(result.error.find("only \"Tensor()\" is supported"), std::string::npos);
875+}
876+ 
877+TEST(AttrTypeTraitsUT, ParseDefaultExpr_ListIntTypeMismatch) {
878+ auto result = AttrTypeTraits::ParseDefaultExpr("ListInt", "\"not_list\"");
879+ EXPECT_FALSE(result.success);
880+ EXPECT_NE(result.error.find("type mismatch for ListInt"), std::string::npos);
881+}
882+ 
883+TEST(AttrTypeTraitsUT, ParseDefaultExpr_ListFloatTypeMismatch) {
884+ auto result = AttrTypeTraits::ParseDefaultExpr("ListFloat", "\"not_list\"");
885+ EXPECT_FALSE(result.success);
886+ EXPECT_NE(result.error.find("type mismatch for ListFloat"), std::string::npos);
887+}
888+ 
889+TEST(AttrTypeTraitsUT, ParseDefaultExpr_ListBoolTypeMismatch) {
890+ auto result = AttrTypeTraits::ParseDefaultExpr("ListBool", "\"not_list\"");
891+ EXPECT_FALSE(result.success);
892+ EXPECT_NE(result.error.find("type mismatch for ListBool"), std::string::npos);
893+}
894+ 
895+TEST(AttrTypeTraitsUT, ParseDefaultExpr_ListTypeTypeMismatch) {
896+ auto result = AttrTypeTraits::ParseDefaultExpr("ListType", "123");
897+ EXPECT_FALSE(result.success);
898+ EXPECT_NE(result.error.find("type mismatch for ListType"), std::string::npos);
899+}
900+ 
901+TEST(AttrTypeTraitsUT, ParseDefaultExpr_ListListIntTypeMismatch) {
902+ auto result = AttrTypeTraits::ParseDefaultExpr("ListListInt", "\"not_list\"");
903+ EXPECT_FALSE(result.success);
904+ EXPECT_NE(result.error.find("type mismatch for ListListInt"), std::string::npos);
905+}
906+ 
907+TEST(AttrTypeTraitsUT, ParseDefaultExpr_ListStringTypeMismatch) {
908+ auto result = AttrTypeTraits::ParseDefaultExpr("ListString", "123");
909+ EXPECT_FALSE(result.success);
910+ EXPECT_NE(result.error.find("type mismatch for ListString"), std::string::npos);
911+}
912+ 
913+TEST(AttrTypeTraitsUT, ParseDefaultExpr_InvalidJson) {
914+ auto result = AttrTypeTraits::ParseDefaultExpr("Int", "not_valid_json");
915+ EXPECT_FALSE(result.success);
916+ EXPECT_NE(result.error.find("not valid json"), std::string::npos);
917+}
918+ 
919+TEST(AttrTypeTraitsUT, ParseDefaultExpr_UnsupportedAttrType) {
920+ auto result = AttrTypeTraits::ParseDefaultExpr("UnknownType", "1");
921+ EXPECT_FALSE(result.success);
922+ EXPECT_NE(result.error.find("unsupported attr type"), std::string::npos);
923+}
924+ 
925+TEST(AttrTypeTraitsUT, TryGetParamKindByIrTypeInfo_ScalarTypes) {
926+ ParamCxxKind kind;
927+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_INT", false, kind));
928+ EXPECT_EQ(kind, ParamCxxKind::kInt64);
929+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_FLOAT", false, kind));
930+ EXPECT_EQ(kind, ParamCxxKind::kFloat);
931+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_BOOL", false, kind));
932+ EXPECT_EQ(kind, ParamCxxKind::kBool);
933+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_STRING", false, kind));
934+ EXPECT_EQ(kind, ParamCxxKind::kCString);
935+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_DATA_TYPE", false, kind));
936+ EXPECT_EQ(kind, ParamCxxKind::kDataType);
937+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_TENSOR", false, kind));
938+ EXPECT_EQ(kind, ParamCxxKind::kTensorUniquePtr);
939+}
940+ 
941+TEST(AttrTypeTraitsUT, TryGetParamKindByIrTypeInfo_ListTypes) {
942+ ParamCxxKind kind;
943+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_LIST_INT", true, kind));
944+ EXPECT_EQ(kind, ParamCxxKind::kListIntRef);
945+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_LIST_FLOAT", true, kind));
946+ EXPECT_EQ(kind, ParamCxxKind::kListFloatRef);
947+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_LIST_BOOL", true, kind));
948+ EXPECT_EQ(kind, ParamCxxKind::kListBoolRef);
949+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_LIST_DATA_TYPE", true, kind));
950+ EXPECT_EQ(kind, ParamCxxKind::kListTypeRef);
951+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_LIST_LIST_INT", true, kind));
952+ EXPECT_EQ(kind, ParamCxxKind::kListListIntRef);
953+ EXPECT_TRUE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_LIST_STRING", true, kind));
954+ EXPECT_EQ(kind, ParamCxxKind::kListStringRef);
955+}
956+ 
957+TEST(AttrTypeTraitsUT, TryGetParamKindByIrTypeInfo_Nullptr) {
958+ ParamCxxKind kind;
959+ EXPECT_FALSE(AttrTypeTraits::TryGetParamKindByIrTypeInfo(nullptr, false, kind));
960+}
961+ 
962+TEST(AttrTypeTraitsUT, TryGetParamKindByIrTypeInfo_UnknownType) {
963+ ParamCxxKind kind;
964+ EXPECT_FALSE(AttrTypeTraits::TryGetParamKindByIrTypeInfo("VT_UNKNOWN", false, kind));
965+}
Atests/ge/ut/ge/graph/eager_style_graph_builder/es_generator/main_unittest.cc+178-0
@@ -0,0 +1,178 @@
1+/**
2+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include <gtest/gtest.h>
12+#include <string>
13+#include <cstdlib>
14+#include <vector>
15+#include "es_codegen_default_value.h"
16+#include "gen_esb_options.h"
17+ 
18+#define main gen_esb_main
19+#include "main.cc"
20+#undef main
21+ 
22+namespace ge {
23+namespace es {
24+ 
25+class EsMainUt : public ::testing::Test {
26+ protected:
27+ void SetUp() override {
28+ const char *opp_path = std::getenv("ASCEND_OPP_PATH");
29+ saved_opp_path_ = (opp_path != nullptr) ? std::string(opp_path) : "";
30+ const char *ld_path = std::getenv("LD_LIBRARY_PATH");
31+ saved_ld_path_ = (ld_path != nullptr) ? std::string(ld_path) : "";
32+ }
33+ 
34+ void TearDown() override {
35+ RestoreEnv("ASCEND_OPP_PATH", saved_opp_path_);
36+ RestoreEnv("LD_LIBRARY_PATH", saved_ld_path_);
37+ }
38+ 
39+ void RestoreEnv(const char *name, const std::string &old_value) {
40+ if (!old_value.empty()) {
41+ (void)setenv(name, old_value.c_str(), 1);
42+ } else {
43+ (void)unsetenv(name);
44+ }
45+ }
46+ 
47+ std::string saved_opp_path_;
48+ std::string saved_ld_path_;
49+};
50+ 
51+TEST_F(EsMainUt, ParseCommandLineArgs_HelpFlag) {
52+ GenEsbOptions options;
53+ char arg0[] = "gen_esb";
54+ char arg1[] = "--help";
55+ char *argv[] = {arg0, arg1};
56+ EXPECT_FALSE(ParseCommandLineArgs(2, argv, options));
57+}
58+ 
59+TEST_F(EsMainUt, ParseCommandLineArgs_InvalidMode) {
60+ GenEsbOptions options;
61+ char arg0[] = "gen_esb";
62+ char arg1[] = "--es_mode=invalid_mode";
63+ char *argv[] = {arg0, arg1};
64+ EXPECT_FALSE(ParseCommandLineArgs(2, argv, options));
65+}
66+ 
67+TEST_F(EsMainUt, ParseCommandLineArgs_CodegenMode) {
68+ GenEsbOptions options;
69+ char arg0[] = "gen_esb";
70+ char arg1[] = "--es_mode=codegen";
71+ char arg2[] = "--output_dir=./test_main_output";
72+ char *argv[] = {arg0, arg1, arg2};
73+ EXPECT_TRUE(ParseCommandLineArgs(3, argv, options));
74+ EXPECT_EQ(options.mode, "codegen");
75+ EXPECT_EQ(options.output_dir, "./test_main_output");
76+}
77+ 
78+TEST_F(EsMainUt, ParseCommandLineArgs_ExtractHistoryMode) {
79+ GenEsbOptions options;
80+ char arg0[] = "gen_esb";
81+ char arg1[] = "--es_mode=extract_history";
82+ char arg2[] = "--release_version=8.0.RC1";
83+ char arg3[] = "--release_date=2024-09-30";
84+ char arg4[] = "--branch_name=master";
85+ char *argv[] = {arg0, arg1, arg2, arg3, arg4};
86+ EXPECT_TRUE(ParseCommandLineArgs(5, argv, options));
87+ EXPECT_EQ(options.mode, "extract_history");
88+ EXPECT_EQ(options.release_version, "8.0.RC1");
89+ EXPECT_EQ(options.release_date, "2024-09-30");
90+ EXPECT_EQ(options.branch_name, "master");
91+}
92+ 
93+TEST_F(EsMainUt, ParseCommandLineArgs_DefaultCodegenMode) {
94+ GenEsbOptions options;
95+ char arg0[] = "gen_esb";
96+ char *argv[] = {arg0};
97+ EXPECT_TRUE(ParseCommandLineArgs(1, argv, options));
98+ EXPECT_EQ(options.mode, kEsExtractHistoryMode);
99+}
100+ 
101+TEST_F(EsMainUt, CheckEnvironmentVariables_OppPathNotSet) {
102+ (void)unsetenv("ASCEND_OPP_PATH");
103+ EXPECT_FALSE(CheckEnvironmentVariables());
104+}
105+ 
106+TEST_F(EsMainUt, CheckEnvironmentVariables_LdPathNotSet) {
107+ (void)setenv("ASCEND_OPP_PATH", "/usr/local/Ascend/ops", 1);
108+ (void)unsetenv("LD_LIBRARY_PATH");
109+ EXPECT_TRUE(CheckEnvironmentVariables());
110+}
111+ 
112+TEST_F(EsMainUt, CheckEnvironmentVariables_BothSet) {
113+ (void)setenv("ASCEND_OPP_PATH", "/usr/local/Ascend/ops", 1);
114+ (void)setenv("LD_LIBRARY_PATH", "/usr/local/Ascend/lib64", 1);
115+ EXPECT_TRUE(CheckEnvironmentVariables());
116+}
117+ 
118+TEST_F(EsMainUt, GetActionName_Codegen) {
119+ EXPECT_STREQ(GetActionName(kEsCodeGenDefaultMode), "code generation");
120+}
121+ 
122+TEST_F(EsMainUt, GetActionName_ExtractHistory) {
123+ EXPECT_STREQ(GetActionName(kEsExtractHistoryMode), "history registry generation");
124+}
125+ 
126+TEST_F(EsMainUt, DisplayProgramHeader_NoCrash) {
127+ EXPECT_NO_THROW(DisplayProgramHeader());
128+}
129+ 
130+TEST_F(EsMainUt, ExecuteGeneration_CodegenWithInvalidOptions) {
131+ GenEsbOptions options;
132+ options.mode = kEsCodeGenDefaultMode;
133+ options.output_dir = "/nonexistent_path_for_test";
134+ EXPECT_TRUE(ExecuteGeneration(options));
135+}
136+ 
137+TEST_F(EsMainUt, ExecuteGeneration_ExtractHistoryWithEmptyVersion) {
138+ GenEsbOptions options;
139+ options.mode = kEsExtractHistoryMode;
140+ options.release_version = "";
141+ options.release_date = "2024-09-30";
142+ options.branch_name = "master";
143+ EXPECT_FALSE(ExecuteGeneration(options));
144+}
145+ 
146+TEST_F(EsMainUt, Main_HelpReturnsZero) {
147+ char arg0[] = "gen_esb";
148+ char arg1[] = "--help";
149+ char *argv[] = {arg0, arg1};
150+ EXPECT_EQ(gen_esb_main(2, argv), 0);
151+}
152+ 
153+TEST_F(EsMainUt, Main_EnvNotSetReturnsOne) {
154+ (void)unsetenv("ASCEND_OPP_PATH");
155+ char arg0[] = "gen_esb";
156+ char *argv[] = {arg0};
157+ EXPECT_EQ(gen_esb_main(1, argv), 1);
158+}
159+ 
160+TEST_F(EsMainUt, Main_InvalidModeReturnsOne) {
161+ (void)setenv("ASCEND_OPP_PATH", "/usr/local/Ascend/ops", 1);
162+ char arg0[] = "gen_esb";
163+ char arg1[] = "--es_mode=invalid";
164+ char *argv[] = {arg0, arg1};
165+ EXPECT_EQ(gen_esb_main(2, argv), 0);
166+}
167+ 
168+TEST_F(EsMainUt, Main_CodegenWithInvalidOutputDirReturnsOne) {
169+ (void)setenv("ASCEND_OPP_PATH", "/usr/local/Ascend/ops", 1);
170+ (void)setenv("LD_LIBRARY_PATH", "/usr/local/Ascend/lib64", 1);
171+ char arg0[] = "gen_esb";
172+ char arg1[] = "--es_mode=codegen";
173+ char arg2[] = "--output_dir=/nonexistent_path_for_test";
174+ char *argv[] = {arg0, arg1, arg2};
175+ EXPECT_EQ(gen_esb_main(3, argv), 0);
176+}
177+} // namespace es
178+} // namespace ge
Mtests/ge/ut/ge/graph/load/model_helper_misc_unittest.cc+183-0
@@ -13,8 +13,11 @@
13#include <vector>13#include <vector>
14 14 
15#include "common/share_graph.h"15#include "common/share_graph.h"
16+#define private public
16#include "framework/common/helper/model_helper.h"17#include "framework/common/helper/model_helper.h"
18+#undef private
17#include "framework/common/framework_types_internal.h"19#include "framework/common/framework_types_internal.h"
20+#include "graph/utils/graph_utils_ex.h"
18#include "stub/gert_runtime_stub.h"21#include "stub/gert_runtime_stub.h"
19 22 
20namespace ge {23namespace ge {
@@ -48,5 +51,185 @@ TEST_F(UtestModelHelperMisc, UpdateSessionGraphId) {
48 EXPECT_EQ(ret, SUCCESS);51 EXPECT_EQ(ret, SUCCESS);
49}52}
50 53 
54+TEST_F(UtestModelHelperMisc, LoadModel_AlreadyLoaded_ReturnsRepeated) {
55+ ModelHelper model_helper;
56+ model_helper.is_assign_model_ = true;
57+ ModelData model_data;
58+ model_data.model_data = nullptr;
59+ model_data.model_len = 0U;
60+ EXPECT_EQ(model_helper.LoadModel(model_data), ACL_ERROR_GE_EXEC_MODEL_DATA_SIZE_INVALID);
61+}
62+ 
63+TEST_F(UtestModelHelperMisc, LoadRootModel_AlreadyLoaded_ReturnsRepeated) {
64+ ModelHelper model_helper;
65+ model_helper.is_assign_model_ = true;
66+ ModelData model_data;
67+ model_data.model_data = nullptr;
68+ model_data.model_len = 0U;
69+ EXPECT_EQ(model_helper.LoadRootModel(model_data), ACL_ERROR_GE_EXEC_LOAD_MODEL_REPEATED);
70+}
71+ 
72+TEST_F(UtestModelHelperMisc, UpdatePlatfromInfoWithRuntime_OfflineScene_ReturnsSuccess) {
73+ ModelHelper model_helper;
74+ fe::PlatformInfo platform_info;
75+ int32_t virtual_type = 0;
76+ EXPECT_EQ(model_helper.UpdatePlatfromInfoWithRuntime(-1, 1, 1, platform_info, virtual_type), SUCCESS);
77+}
78+ 
79+TEST_F(UtestModelHelperMisc, SetSaveMode_Test) {
80+ ModelHelper model_helper;
81+ model_helper.SetSaveMode(true);
82+ model_helper.SetSaveMode(false);
83+}
84+ 
85+TEST_F(UtestModelHelperMisc, GetBaseNameFromFileName_WithExtension) {
86+ ModelHelper model_helper;
87+ std::string base_name;
88+ EXPECT_EQ(model_helper.GetBaseNameFromFileName("model.om", base_name), SUCCESS);
89+ EXPECT_EQ(base_name, "model");
90+}
91+ 
92+TEST_F(UtestModelHelperMisc, GetBaseNameFromFileName_WithDoubleExtension) {
93+ ModelHelper model_helper;
94+ std::string base_name;
95+ EXPECT_EQ(model_helper.GetBaseNameFromFileName("model.exe.om", base_name), SUCCESS);
96+ EXPECT_EQ(base_name, "model.exe");
97+}
98+ 
99+TEST_F(UtestModelHelperMisc, GetBaseNameFromFileName_NoExtension) {
100+ ModelHelper model_helper;
101+ std::string base_name;
102+ EXPECT_EQ(model_helper.GetBaseNameFromFileName("model", base_name), SUCCESS);
103+}
104+ 
105+TEST_F(UtestModelHelperMisc, GetBaseNameFromFileName_WithPath) {
106+ ModelHelper model_helper;
107+ std::string base_name;
108+ EXPECT_EQ(model_helper.GetBaseNameFromFileName("/path/to/model.om", base_name), SUCCESS);
109+}
110+ 
111+TEST_F(UtestModelHelperMisc, LoadModel_NullModelData) {
112+ ModelHelper model_helper;
113+ ModelData model_data;
114+ model_data.model_data = nullptr;
115+ model_data.model_len = 0U;
116+ EXPECT_NE(model_helper.LoadModel(model_data), SUCCESS);
117+}
118+ 
119+TEST_F(UtestModelHelperMisc, LoadRootModel_NullModelData) {
120+ ModelHelper model_helper;
121+ ModelData model_data;
122+ model_data.model_data = nullptr;
123+ model_data.model_len = 0U;
124+ EXPECT_NE(model_helper.LoadRootModel(model_data), SUCCESS);
125+}
126+ 
127+TEST_F(UtestModelHelperMisc, CheckOsCpuInfoAndOppVersion_NeedCheck) {
128+ ModelHelper model_helper;
129+ std::vector<char> data(256);
130+ ModelFileHeader *file_header = reinterpret_cast<ModelFileHeader *>(data.data());
131+ file_header->need_check_os_cpu_info = static_cast<uint8_t>(OsCpuInfoCheckTyep::NEED_CHECK);
132+ model_helper.file_header_ = file_header;
133+ model_helper.is_unknown_shape_model_ = true;
134+ gert::GertRuntimeStub stub;
135+ stub.GetSlogStub().Clear();
136+ EXPECT_NE(model_helper.CheckOsCpuInfoAndOppVersion(), SUCCESS);
137+}
138+ 
139+TEST_F(UtestModelHelperMisc, SaveOriginalGraphToOmModel_EmptyOutputFile) {
140+ ModelHelper model_helper;
141+ auto graph = std::make_shared<ComputeGraph>("test_graph");
142+ auto data = graph->AddNode(std::make_shared<OpDesc>("data1", DATA));
143+ EXPECT_NE(model_helper.SaveOriginalGraphToOmModel(GraphUtilsEx::CreateGraphFromComputeGraph(graph), ""), SUCCESS);
144+}
145+ 
146+TEST_F(UtestModelHelperMisc, SetSaveMode_True) {
147+ ModelHelper model_helper;
148+ model_helper.SetSaveMode(true);
149+ EXPECT_TRUE(model_helper.is_offline_);
150+}
151+ 
152+TEST_F(UtestModelHelperMisc, SetSaveMode_False) {
153+ ModelHelper model_helper;
154+ model_helper.SetSaveMode(false);
155+ EXPECT_FALSE(model_helper.is_offline_);
156+}
157+ 
158+TEST_F(UtestModelHelperMisc, SaveModelWeights_NoWeight) {
159+ ModelHelper model_helper;
160+ auto ge_model = std::make_shared<GeModel>();
161+ auto om_helper = std::make_shared<OmFileSaveHelper>();
162+ EXPECT_EQ(model_helper.SaveModelWeights(om_helper, ge_model, 0U), SUCCESS);
163+}
164+ 
165+TEST_F(UtestModelHelperMisc, SaveModelTbeKernel_NoKernel) {
166+ ModelHelper model_helper;
167+ auto ge_model = std::make_shared<GeModel>();
168+ auto om_helper = std::make_shared<OmFileSaveHelper>();
169+ EXPECT_EQ(model_helper.SaveModelTbeKernel(om_helper, ge_model, 0U), SUCCESS);
170+}
171+ 
172+TEST_F(UtestModelHelperMisc, SaveModelCustAICPU_NoKernel) {
173+ ModelHelper model_helper;
174+ auto ge_model = std::make_shared<GeModel>();
175+ auto om_helper = std::make_shared<OmFileSaveHelper>();
176+ EXPECT_EQ(model_helper.SaveModelCustAICPU(om_helper, ge_model, 0U), SUCCESS);
177+}
178+ 
179+TEST_F(UtestModelHelperMisc, SaveModelDef_BasicModel) {
180+ ModelHelper model_helper;
181+ auto ge_model = std::make_shared<GeModel>();
182+ auto compute_graph = std::make_shared<ComputeGraph>("test_def_graph");
183+ auto data = compute_graph->AddNode(std::make_shared<OpDesc>("data1", DATA));
184+ ge_model->SetGraph(compute_graph);
185+ ge_model->SetName("test_model_def");
186+ auto om_helper = std::make_shared<OmFileSaveHelper>();
187+ ge::Buffer model_buffer;
188+ EXPECT_EQ(model_helper.SaveModelDef(om_helper, ge_model, model_buffer, 0U), SUCCESS);
189+}
190+ 
191+TEST_F(UtestModelHelperMisc, SaveAllModelPartiton_BasicModel) {
192+ ModelHelper model_helper;
193+ auto ge_model = std::make_shared<GeModel>();
194+ auto compute_graph = std::make_shared<ComputeGraph>("test_all_part_graph");
195+ auto data = compute_graph->AddNode(std::make_shared<OpDesc>("data1", DATA));
196+ ge_model->SetGraph(compute_graph);
197+ ge_model->SetName("test_all_part");
198+ auto task_def = std::make_shared<domi::ModelTaskDef>();
199+ task_def->add_task();
200+ ge_model->SetModelTaskDef(task_def);
201+ auto om_helper = std::make_shared<OmFileSaveHelper>();
202+ ge::Buffer model_buffer;
203+ ge::Buffer task_buffer;
204+ EXPECT_EQ(model_helper.SaveAllModelPartiton(om_helper, ge_model, model_buffer, task_buffer, 0U), SUCCESS);
205+}
206+ 
207+TEST_F(UtestModelHelperMisc, SetModelAttributes_Basic) {
208+ ModelHelper model_helper;
209+ auto ge_model = std::make_shared<GeModel>();
210+ EXPECT_EQ(model_helper.SetModelAttributes(ge_model), SUCCESS);
211+}
212+ 
213+TEST_F(UtestModelHelperMisc, SaveToOmModel_EmptyOutputFile) {
214+ ModelHelper model_helper;
215+ auto ge_model = std::make_shared<GeModel>();
216+ ge_model->SetName("test_empty_out");
217+ ModelBufferData model;
218+ EXPECT_EQ(model_helper.SaveToOmModel(ge_model, "", model, nullptr), FAILED);
219+}
220+ 
221+TEST_F(UtestModelHelperMisc, SaveBundleModelBufferToMem_EmptyBuffers) {
222+ ModelHelper model_helper;
223+ std::vector<ModelBufferData> model_buffers;
224+ ModelBufferData output_buffer;
225+ EXPECT_EQ(model_helper.SaveBundleModelBufferToMem(model_buffers, 0UL, output_buffer), SUCCESS);
226+}
227+ 
228+TEST_F(UtestModelHelperMisc, UpdatePlatfromInfoWithRuntime_OnlineScene) {
229+ ModelHelper model_helper;
230+ fe::PlatformInfo platform_info;
231+ int32_t virtual_type = 0;
232+ EXPECT_EQ(model_helper.UpdatePlatfromInfoWithRuntime(0, 0, 0, platform_info, virtual_type), SUCCESS);
233+}
51} // namespace234} // namespace
52} // namespace ge235} // namespace ge
Mtests/ge/ut/ge/graph/load/model_helper_unittest.cc+41-0
@@ -2245,6 +2245,47 @@ TEST_F(UtestModelHelper, CustomOpSoLoaderDlopenFailureShouldNotPoisonWeakCache)
2245 loader.Cleanup();2245 loader.Cleanup();
2246}2246}
2247 2247 
2248+TEST_F(UtestModelHelper, CustomOpSoLoaderEmptyBinsReturnSuccess_CovEnhance) {
2249+ CustomOpSoLoader loader;
2250+ std::vector<CustomOpSoHandlePtr> loaded_handles;
2251+ EXPECT_EQ(loader.LoadCustomOpSoBins({}, loaded_handles), SUCCESS);
2252+ EXPECT_TRUE(loaded_handles.empty());
2253+}
2254+ 
2255+TEST_F(UtestModelHelper, CustomOpSoLoaderFinalizeWithAliveHandle_CovEnhance) {
2256+ auto &loader = CustomOpSoLoader::GetInstance();
2257+ loader.Cleanup();
2258+ 
2259+ std::string source_so_path;
2260+ ASSERT_TRUE(FindNotLoadedSystemSoForModelHelperUt(source_so_path));
2261+ std::vector<char_t> so_data;
2262+ ASSERT_TRUE(ReadSoDataForModelHelperUt(source_so_path, so_data));
2263+ const auto so_bin = BuildCustomOpSoBinForModelHelperUt("libcustom_op_loader_finalize_ut.so", "vendor_ut", so_data);
2264+ ASSERT_NE(so_bin, nullptr);
2265+ 
2266+ std::vector<CustomOpSoHandlePtr> loaded_handles;
2267+ ASSERT_EQ(loader.LoadCustomOpSoBins({so_bin}, loaded_handles), SUCCESS);
2268+ ASSERT_EQ(loaded_handles.size(), 1U);
2269+ 
2270+ EXPECT_NO_THROW(CustomOpSoLoader::Finalize());
2271+ 
2272+ loaded_handles.clear();
2273+ loader.Cleanup();
2274+}
2275+ 
2276+TEST_F(UtestModelHelper, CustomOpSoLoaderPublishOrReuseExpiredEntry_CovEnhance) {
2277+ CustomOpSoLoader loader;
2278+ const std::string fingerprint_key = "test_expired_fp_cov";
2279+ loader.loaded_states_[fingerprint_key] = std::weak_ptr<CustomOpSoHandle>();
2280+ 
2281+ auto candidate = std::make_shared<CustomOpSoHandle>(fingerprint_key, nullptr, "test.so", 0U, -1);
2282+ CustomOpSoHandlePtr loaded_handle;
2283+ loader.PublishOrReuseLoadedHandle(fingerprint_key, candidate, loaded_handle);
2284+ EXPECT_EQ(loaded_handle, candidate);
2285+ EXPECT_EQ(loader.loaded_states_.size(), 1U);
2286+ loader.Cleanup();
2287+}
2288+ 
2248TEST_F(UtestModelHelper, LoadOpSoBinDataFail) {2289TEST_F(UtestModelHelper, LoadOpSoBinDataFail) {
2249 OmFileLoadHelper load_helper;2290 OmFileLoadHelper load_helper;
2250 ModelHelper model_helper;2291 ModelHelper model_helper;
Mtests/ge/ut/ge/graph/load/om2_package_helper_unittest.cc+229-0
@@ -2391,4 +2391,233 @@ TEST_F(Om2PackageHelperUt, SetSaveMode_Ok) {
2391 om2_packager.SetSaveMode(false);2391 om2_packager.SetSaveMode(false);
2392}2392}
2393 2393 
2394+TEST_F(Om2PackageHelperUt, BuildKernelBinaries_WithAtomicKernel_Success) {
2395+ auto ge_model = std::make_shared<GeModel>();
2396+ const char atomic_kernel_data[] = "fake_atomic_tbe_kernel_bin";
2397+ auto atomic_kernel = std::make_shared<ge::OpKernelBin>(
2398+ "atomic_kernel", std::vector<char>(atomic_kernel_data, atomic_kernel_data + strlen(atomic_kernel_data)));
2399+ ge_model->GetTBEKernelStore().AddKernel(atomic_kernel);
2400+ ASSERT_TRUE(ge_model->GetTBEKernelStore().Build());
2401+ 
2402+ auto graph = std::make_shared<ComputeGraph>("g1");
2403+ GeTensorDesc tensor_desc(GeShape({1, 1}), FORMAT_ND, DT_FLOAT);
2404+ auto add_desc = std::make_shared<OpDesc>("add1", "Add");
2405+ (void)add_desc->AddInputDesc(tensor_desc);
2406+ (void)add_desc->AddInputDesc(tensor_desc);
2407+ (void)add_desc->AddOutputDesc(tensor_desc);
2408+ (void)AttrUtils::SetStr(add_desc, "_kernelname", "atomic_kernel");
2409+ (void)AttrUtils::SetStr(add_desc, ATOMIC_ATTR_TBE_KERNEL_NAME, "atomic_kernel");
2410+ auto add_node = graph->AddNode(add_desc);
2411+ ASSERT_NE(add_node, nullptr);
2412+ graph->SetGraphUnknownFlag(false);
2413+ ge_model->SetGraph(graph);
2414+ 
2415+ Om2PackageHelper om2_packager;
2416+ std::vector<gert::Om2KernelBinary> kernel_binaries;
2417+ ASSERT_EQ(om2_packager.BuildKernelBinaries(ge_model, kernel_binaries), SUCCESS);
2418+ EXPECT_FALSE(kernel_binaries.empty());
2419+}
2420+ 
2421+TEST_F(Om2PackageHelperUt, BuildKernelBinaries_WithCustAicpuKernel_Success) {
2422+ auto ge_model = std::make_shared<GeModel>();
2423+ const char kernel_data[] = "fake_cust_aicpu_kernel_bin";
2424+ std::vector<char> kernel_bin(kernel_data, kernel_data + strlen(kernel_data));
2425+ auto cust_kernel = std::make_shared<ge::OpKernelBin>("libcust_aicpu_kernel.so", std::move(kernel_bin));
2426+ CustAICPUKernelStore cust_aicpu_kernel_store;
2427+ cust_aicpu_kernel_store.AddCustAICPUKernel(cust_kernel);
2428+ ASSERT_TRUE(cust_aicpu_kernel_store.Build());
2429+ ge_model->SetCustAICPUKernelStore(cust_aicpu_kernel_store);
2430+ 
2431+ auto graph = std::make_shared<ComputeGraph>("g1");
2432+ GeTensorDesc tensor_desc(GeShape({1, 1}), FORMAT_ND, DT_FLOAT);
2433+ auto add_desc = std::make_shared<OpDesc>("add1", "Add");
2434+ (void)add_desc->AddInputDesc(tensor_desc);
2435+ (void)add_desc->AddInputDesc(tensor_desc);
2436+ (void)add_desc->AddOutputDesc(tensor_desc);
2437+ add_desc->SetExtAttr(OP_EXTATTR_CUSTAICPU_KERNEL, cust_kernel);
2438+ auto add_node = graph->AddNode(add_desc);
2439+ ASSERT_NE(add_node, nullptr);
2440+ graph->SetGraphUnknownFlag(false);
2441+ ge_model->SetGraph(graph);
2442+ 
2443+ Om2PackageHelper om2_packager;
2444+ std::vector<gert::Om2KernelBinary> kernel_binaries;
2445+ ASSERT_EQ(om2_packager.BuildKernelBinaries(ge_model, kernel_binaries), SUCCESS);
2446+ bool found_cust = false;
2447+ for (const auto &kb : kernel_binaries) {
2448+ if (kb.name.find("_CustAicpuKernel.o") != std::string::npos) {
2449+ found_cust = true;
2450+ break;
2451+ }
2452+ }
2453+ EXPECT_TRUE(found_cust);
2454+}
2455+ 
2456+TEST_F(Om2PackageHelperUt, SaveGraphDebugFiles_ValidModel_Success) {
2457+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2458+ ASSERT_NE(ge_root_model, nullptr);
2459+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2460+ ASSERT_NE(ge_model, nullptr);
2461+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2462+ 
2463+ const std::string output_file = PathUtils::Join({test_work_dir, "test_debug_files.om2"});
2464+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2465+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2466+ 
2467+ Om2PackageHelper om2_packager;
2468+ ASSERT_EQ(om2_packager.SaveGraphDebugFiles(zip_writer, ge_model, 0UL), SUCCESS);
2469+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2470+}
2471+ 
2472+TEST_F(Om2PackageHelperUt, BuildModelMeta_WithOutputNameContainingColon_Success) {
2473+ auto ge_root_model = CreateGeRootModelWithAicoreOp();
2474+ ASSERT_NE(ge_root_model, nullptr);
2475+ SyncKernelNameForAllModels(ge_root_model);
2476+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2477+ ASSERT_NE(ge_model, nullptr);
2478+ 
2479+ std::vector<std::string> out_node_names = {"add1:0"};
2480+ AttrUtils::SetListStr(ge_model, ATTR_MODEL_OUT_NODES_NAME, out_node_names);
2481+ 
2482+ Om2PackageHelper om2_packager;
2483+ gert::Om2ModelMeta model_meta;
2484+ ASSERT_EQ(om2_packager.BuildModelMeta(ge_model, model_meta), SUCCESS);
2485+ ASSERT_FALSE(model_meta.output_desc.empty());
2486+ EXPECT_EQ(model_meta.output_desc[0].GetName(), "add1:0");
2487+}
2488+ 
2489+TEST_F(Om2PackageHelperUt, BuildModelMeta_WithOutputNameWithoutColon_Success) {
2490+ auto ge_root_model = CreateGeRootModelWithAicoreOp();
2491+ ASSERT_NE(ge_root_model, nullptr);
2492+ SyncKernelNameForAllModels(ge_root_model);
2493+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2494+ ASSERT_NE(ge_model, nullptr);
2495+ 
2496+ std::vector<std::string> out_node_names = {"add1"};
2497+ AttrUtils::SetListStr(ge_model, ATTR_MODEL_OUT_NODES_NAME, out_node_names);
2498+ 
2499+ Om2PackageHelper om2_packager;
2500+ gert::Om2ModelMeta model_meta;
2501+ ASSERT_EQ(om2_packager.BuildModelMeta(ge_model, model_meta), SUCCESS);
2502+ ASSERT_FALSE(model_meta.output_desc.empty());
2503+ EXPECT_NE(model_meta.output_desc[0].GetName().find(":"), std::string::npos);
2504+}
2505+ 
2506+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithAippDataNameMap_Success) {
2507+ const auto ge_root_model = CreateGeRootModelWithStaticAipp();
2508+ ASSERT_NE(ge_root_model, nullptr);
2509+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2510+ ASSERT_NE(ge_model, nullptr);
2511+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2512+ 
2513+ for (const auto &node : ge_model->GetGraph()->GetDirectNode()) {
2514+ auto op_desc = node->GetOpDesc();
2515+ if ((op_desc != nullptr) && (op_desc->GetType() == DATA)) {
2516+ (void)AttrUtils::SetStr(op_desc, ATTR_DATA_AIPP_DATA_NAME_MAP, "data1");
2517+ break;
2518+ }
2519+ }
2520+ 
2521+ const std::string output_file = PathUtils::Join({test_work_dir, "test_aipp_data_name_map.om2"});
2522+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2523+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2524+ SyncKernelNameFromOpDesc(ge_model);
2525+ ASSERT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2526+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2527+}
2528+ 
2529+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithInvalidAippDimInfo_Fail) {
2530+ const auto ge_root_model = CreateGeRootModelWithStaticAipp();
2531+ ASSERT_NE(ge_root_model, nullptr);
2532+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2533+ ASSERT_NE(ge_model, nullptr);
2534+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2535+ 
2536+ for (const auto &node : ge_model->GetGraph()->GetDirectNode()) {
2537+ auto op_desc = node->GetOpDesc();
2538+ if ((op_desc != nullptr) && (op_desc->GetType() == DATA)) {
2539+ std::vector<std::string> bad_aipp_inputs = {"invalid_dim_info_string"};
2540+ (void)AttrUtils::SetListStr(op_desc, ATTR_NAME_AIPP_INPUTS, bad_aipp_inputs);
2541+ break;
2542+ }
2543+ }
2544+ 
2545+ const std::string output_file = PathUtils::Join({test_work_dir, "test_invalid_aipp_dim.om2"});
2546+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2547+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2548+ SyncKernelNameFromOpDesc(ge_model);
2549+ EXPECT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2550+}
2551+ 
2552+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithAippListIntAndListFloat_Success) {
2553+ const auto ge_root_model = CreateGeRootModelWithStaticAipp();
2554+ ASSERT_NE(ge_root_model, nullptr);
2555+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2556+ ASSERT_NE(ge_model, nullptr);
2557+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2558+ 
2559+ for (const auto &node : ge_model->GetGraph()->GetDirectNode()) {
2560+ auto op_desc = node->GetOpDesc();
2561+ if ((op_desc != nullptr) && (op_desc->GetType() == DATA)) {
2562+ ge::NamedAttrs aipp_attr;
2563+ aipp_attr.SetAttr("aipp_mode", ge::GeAttrValue::CreateFrom<int64_t>(0));
2564+ aipp_attr.SetAttr("input_format", ge::GeAttrValue::CreateFrom<int64_t>(0));
2565+ aipp_attr.SetAttr("src_image_size_w", ge::GeAttrValue::CreateFrom<int64_t>(640));
2566+ aipp_attr.SetAttr("src_image_size_h", ge::GeAttrValue::CreateFrom<int64_t>(480));
2567+ aipp_attr.SetAttr("csc_switch", ge::GeAttrValue::CreateFrom<bool>(true));
2568+ aipp_attr.SetAttr("matrix_r0c0", ge::GeAttrValue::CreateFrom<std::vector<int64_t>>({100}));
2569+ aipp_attr.SetAttr("matrix_r0c1", ge::GeAttrValue::CreateFrom<std::vector<int64_t>>({200}));
2570+ aipp_attr.SetAttr("matrix_r0c2", ge::GeAttrValue::CreateFrom<std::vector<int64_t>>({300}));
2571+ aipp_attr.SetAttr("output_bias_0", ge::GeAttrValue::CreateFrom<std::vector<int64_t>>({10}));
2572+ aipp_attr.SetAttr("output_bias_1", ge::GeAttrValue::CreateFrom<std::vector<int64_t>>({20}));
2573+ aipp_attr.SetAttr("var_reci_chn_0", ge::GeAttrValue::CreateFrom<std::vector<float>>({1.5f}));
2574+ aipp_attr.SetAttr("var_reci_chn_1", ge::GeAttrValue::CreateFrom<std::vector<float>>({2.5f}));
2575+ aipp_attr.SetAttr("min_chn_0", ge::GeAttrValue::CreateFrom<float>(0.5f));
2576+ aipp_attr.SetAttr("related_input_rank", ge::GeAttrValue::CreateFrom<int64_t>(0));
2577+ aipp_attr.SetAttr("max_src_image_size", ge::GeAttrValue::CreateFrom<int64_t>(8192));
2578+ aipp_attr.SetAttr("support_rotation", ge::GeAttrValue::CreateFrom<bool>(false));
2579+ (void)ge::AttrUtils::SetNamedAttrs(op_desc, ge::ATTR_NAME_AIPP, aipp_attr);
2580+ break;
2581+ }
2582+ }
2583+ 
2584+ const std::string output_file = PathUtils::Join({test_work_dir, "test_aipp_list_attrs.om2"});
2585+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2586+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2587+ SyncKernelNameFromOpDesc(ge_model);
2588+ EXPECT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2589+ (void)zip_writer->SaveModelDataToFile();
2590+}
2591+ 
2592+TEST_F(Om2PackageHelperUt, BuildModelMeta_WithMbatchOriginInputDims_Success) {
2593+ const auto ge_root_model = CreateGeRootModelWithStaticAipp();
2594+ ASSERT_NE(ge_root_model, nullptr);
2595+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2596+ ASSERT_NE(ge_model, nullptr);
2597+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2598+ 
2599+ for (const auto &node : ge_model->GetGraph()->GetDirectNode()) {
2600+ auto op_desc = node->GetOpDesc();
2601+ if ((op_desc != nullptr) && (op_desc->GetType() == DATA)) {
2602+ std::vector<int64_t> origin_dims = {-1, 3, 224, 224};
2603+ (void)AttrUtils::SetListInt(op_desc, ATTR_MBATCH_ORIGIN_INPUT_DIMS, origin_dims);
2604+ break;
2605+ }
2606+ }
2607+ 
2608+ const std::string output_file = PathUtils::Join({test_work_dir, "test_mbatch_dims.om2"});
2609+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2610+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2611+ SyncKernelNameFromOpDesc(ge_model);
2612+ EXPECT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2613+ (void)zip_writer->SaveModelDataToFile();
2614+}
2615+ 
2616+TEST_F(Om2PackageHelperUt, SetSaveMode_False) {
2617+ Om2PackageHelper helper;
2618+ helper.SetSaveMode(false);
2619+ EXPECT_FALSE(helper.is_offline_);
2620+ helper.SetSaveMode(true);
2621+ EXPECT_TRUE(helper.is_offline_);
2622+}
2394} // namespace ge2623} // namespace ge
Mtests/ge/ut/ge/graph/manager/graph_manager_unittest.cc+44-0
@@ -5886,4 +5886,48 @@ TEST_F(UtestGraphManagerTest, GraphManager_UpdateDynamicParams_ParsesFromGraphOp
5886 EXPECT_EQ(input_shape, "1,2,3");5886 EXPECT_EQ(input_shape, "1,2,3");
5887 EXPECT_EQ(dynamic_node_type, 1);5887 EXPECT_EQ(dynamic_node_type, 1);
5888}5888}
5889+ 
5890+TEST_F(UtestGraphManagerTest, GraphManager_Finalize_NoGraphs) {
5891+ GraphManager graph_manager;
5892+ auto ret = graph_manager.Finalize();
5893+ EXPECT_EQ(ret, SUCCESS);
5894+}
5895+ 
5896+TEST_F(UtestGraphManagerTest, GraphManager_GetGraphNode_NotExist) {
5897+ GraphManager graph_manager;
5898+ GraphNodePtr graph_node;
5899+ auto ret = graph_manager.GetGraphNode(999, graph_node);
5900+ EXPECT_NE(ret, SUCCESS);
5901+}
5902+ 
5903+TEST_F(UtestGraphManagerTest, GraphManager_RemoveGraph_NotExist) {
5904+ GraphManager graph_manager;
5905+ auto ret = graph_manager.RemoveGraph(999);
5906+ EXPECT_NE(ret, SUCCESS);
5907+}
5908+ 
5909+TEST_F(UtestGraphManagerTest, GraphManager_SetSessionGraphId_NullGraph) {
5910+ GraphManager graph_manager;
5911+ ComputeGraphPtr null_graph = nullptr;
5912+ graph_manager.SetSessionGraphId(null_graph, 42);
5913+ SUCCEED();
5914+}
5915+ 
5916+TEST_F(UtestGraphManagerTest, GraphManager_CheckModelLoad_LoadedModel) {
5917+ GraphManager graph_manager;
5918+ auto ge_root_model = MakeShared<GeRootModel>();
5919+ EXPECT_TRUE(graph_manager.CheckModelLoad(ge_root_model, true));
5920+}
5921+ 
5922+TEST_F(UtestGraphManagerTest, GraphManager_UpdateDynamicParams_WithDynamicDims) {
5923+ GraphManager graph_manager;
5924+ std::string input_shape;
5925+ std::string dynamic_dims;
5926+ int32_t dynamic_node_type = 0;
5927+ std::map<std::string, std::string> graph_options;
5928+ graph_options["dynamic_dims"] = "1,2,3";
5929+ graph_options[DYNAMIC_NODE_TYPE] = "2";
5930+ graph_manager.UpdateDynamicParams(input_shape, dynamic_dims, dynamic_node_type, graph_options);
5931+ EXPECT_EQ(dynamic_node_type, 2);
5932+}
5889} // namespace ge5933} // namespace ge
Mtests/ge/ut/ge/graph/optimize/symbolic/symbolic_shape_infer_func_unittest.cc+428-0
@@ -6443,4 +6443,432 @@ TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForFlashAttentionScoreExcepti
6443 // Expected output: GRAPH_FAILED6443 // Expected output: GRAPH_FAILED
6444 TestFlashAttentionScoreException(builder, query_shape, key_shape, value_shape, head_num, "INVALID_LAYOUT");6444 TestFlashAttentionScoreException(builder, query_shape, key_shape, value_shape, head_num, "INVALID_LAYOUT");
6445}6445}
6446+ 
6447+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_NhwcFilterFormat) {
6448+ auto func = GetInferFunc("Conv2D");
6449+ ASSERT_TRUE(func.first != nullptr);
6450+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6451+ ShapeEnvAttr shape_env;
6452+ ShapeEnvGuarder guarder(&shape_env);
6453+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6454+ auto s1 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 2));
6455+ auto s2 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 3));
6456+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6457+ auto s4 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 5));
6458+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6459+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6460+ auto s7 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 8));
6461+ std::vector<int64_t> strides = {1, 1, 1, 1};
6462+ std::vector<int64_t> pads = {0, 0, 0, 0};
6463+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6464+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 1, FORMAT_NHWC,
6465+ FORMAT_NHWC);
6466+ auto infer_context = builder.Build();
6467+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6468+}
6469+ 
6470+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_InvalidGroupsZero) {
6471+ auto func = GetInferFunc("Conv2D");
6472+ ASSERT_TRUE(func.first != nullptr);
6473+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6474+ ShapeEnvAttr shape_env;
6475+ ShapeEnvGuarder guarder(&shape_env);
6476+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6477+ auto s1 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 2));
6478+ auto s2 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 3));
6479+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6480+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6481+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6482+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6483+ auto s7 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 8));
6484+ std::vector<int64_t> strides = {1, 1, 1, 1};
6485+ std::vector<int64_t> pads = {0, 0, 0, 0};
6486+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6487+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 0, FORMAT_NHWC,
6488+ FORMAT_HWCN);
6489+ auto infer_context = builder.Build();
6490+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6491+}
6492+ 
6493+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_GroupsDivisibleFail) {
6494+ auto func = GetInferFunc("Conv2D");
6495+ ASSERT_TRUE(func.first != nullptr);
6496+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6497+ ShapeEnvAttr shape_env;
6498+ ShapeEnvGuarder guarder(&shape_env);
6499+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6500+ auto s1 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 2));
6501+ auto s2 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 3));
6502+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6503+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6504+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6505+ auto s6 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 7));
6506+ auto s7 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 8));
6507+ std::vector<int64_t> strides = {1, 1, 1, 1};
6508+ std::vector<int64_t> pads = {0, 0, 0, 0};
6509+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6510+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 1, FORMAT_NHWC,
6511+ FORMAT_HWCN);
6512+ auto infer_context = builder.Build();
6513+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6514+}
6515+ 
6516+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_InvalidDilations) {
6517+ auto func = GetInferFunc("Conv2D");
6518+ ASSERT_TRUE(func.first != nullptr);
6519+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6520+ ShapeEnvAttr shape_env;
6521+ ShapeEnvGuarder guarder(&shape_env);
6522+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6523+ auto s1 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 2));
6524+ auto s2 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 3));
6525+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6526+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6527+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6528+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6529+ auto s7 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 8));
6530+ std::vector<int64_t> strides = {1, 1, 1, 1};
6531+ std::vector<int64_t> pads = {0, 0, 0, 0};
6532+ std::vector<int64_t> dilations = {1, 0, 0, 1};
6533+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 1, FORMAT_NHWC,
6534+ FORMAT_HWCN);
6535+ auto infer_context = builder.Build();
6536+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6537+}
6538+ 
6539+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_CutPads) {
6540+ auto func = GetInferFunc("Conv2D");
6541+ ASSERT_TRUE(func.first != nullptr);
6542+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6543+ ShapeEnvAttr shape_env;
6544+ ShapeEnvGuarder guarder(&shape_env);
6545+ auto s0 = shape_env.CreateSymbol(1, MakeShared<InputShapeSource>(0, 1));
6546+ auto s1 = shape_env.CreateSymbol(1, MakeShared<InputShapeSource>(0, 2));
6547+ auto s2 = shape_env.CreateSymbol(1, MakeShared<InputShapeSource>(0, 3));
6548+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6549+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6550+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6551+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6552+ auto s7 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 8));
6553+ std::vector<int64_t> strides = {1, 2, 2, 1};
6554+ std::vector<int64_t> pads = {0, 2, 0, 2};
6555+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6556+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 1, FORMAT_NHWC,
6557+ FORMAT_HWCN);
6558+ auto infer_context = builder.Build();
6559+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6560+}
6561+ 
6562+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_SamePaddingTailsPositive) {
6563+ auto func = GetInferFunc("Conv2D");
6564+ ASSERT_TRUE(func.first != nullptr);
6565+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6566+ ShapeEnvAttr shape_env;
6567+ ShapeEnvGuarder guarder(&shape_env);
6568+ auto s0 = shape_env.CreateSymbol(48, MakeShared<InputShapeSource>(0, 1));
6569+ auto s1 = shape_env.CreateSymbol(5, MakeShared<InputShapeSource>(0, 2));
6570+ auto s2 = shape_env.CreateSymbol(5, MakeShared<InputShapeSource>(0, 3));
6571+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6572+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6573+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6574+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6575+ auto s7 = shape_env.CreateSymbol(64, MakeShared<InputShapeSource>(0, 8));
6576+ std::vector<int64_t> strides = {1, 2, 2, 1};
6577+ std::vector<int64_t> pads = {-1, -1, -1, -1};
6578+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6579+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 1, FORMAT_NHWC,
6580+ FORMAT_HWCN);
6581+ AppendConv2DPaddingAttrs(builder.GetOrCreateOpDescPtr(), "SAME");
6582+ auto infer_context = builder.Build();
6583+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6584+}
6585+ 
6586+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2DV2_SamePaddingPadNegative) {
6587+ auto func = GetInferFunc("Conv2DV2");
6588+ ASSERT_TRUE(func.first != nullptr);
6589+ InferSymbolShapeContextTestBuilder builder("Conv2DV2", "conv2DV2");
6590+ ShapeEnvAttr shape_env;
6591+ ShapeEnvGuarder guarder(&shape_env);
6592+ auto s0 = shape_env.CreateSymbol(48, MakeShared<InputShapeSource>(0, 1));
6593+ auto s1 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 2));
6594+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6595+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6596+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6597+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6598+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6599+ auto s7 = shape_env.CreateSymbol(64, MakeShared<InputShapeSource>(0, 8));
6600+ std::vector<int64_t> strides = {1, 4, 4, 1};
6601+ std::vector<int64_t> pads = {0, 0, 0, 0};
6602+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6603+ auto infer_context =
6604+ BuildConv2DV2InferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, "SAME_UPPER");
6605+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6606+}
6607+ 
6608+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2DV2_ValidPadding) {
6609+ auto func = GetInferFunc("Conv2DV2");
6610+ ASSERT_TRUE(func.first != nullptr);
6611+ InferSymbolShapeContextTestBuilder builder("Conv2DV2", "conv2DV2");
6612+ ShapeEnvAttr shape_env;
6613+ ShapeEnvGuarder guarder(&shape_env);
6614+ auto s0 = shape_env.CreateSymbol(48, MakeShared<InputShapeSource>(0, 1));
6615+ auto s1 = shape_env.CreateSymbol(112, MakeShared<InputShapeSource>(0, 2));
6616+ auto s2 = shape_env.CreateSymbol(112, MakeShared<InputShapeSource>(0, 3));
6617+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6618+ auto s4 = shape_env.CreateSymbol(7, MakeShared<InputShapeSource>(0, 5));
6619+ auto s5 = shape_env.CreateSymbol(7, MakeShared<InputShapeSource>(0, 6));
6620+ auto s6 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 7));
6621+ auto s7 = shape_env.CreateSymbol(64, MakeShared<InputShapeSource>(0, 8));
6622+ std::vector<int64_t> strides = {1, 2, 2, 1};
6623+ std::vector<int64_t> pads = {-1, -1, -1, -1};
6624+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6625+ auto infer_context =
6626+ BuildConv2DV2InferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, "VALID");
6627+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6628+}
6629+ 
6630+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2DV2_GroupsDivisibleFail) {
6631+ auto func = GetInferFunc("Conv2DV2");
6632+ ASSERT_TRUE(func.first != nullptr);
6633+ InferSymbolShapeContextTestBuilder builder("Conv2DV2", "conv2DV2");
6634+ ShapeEnvAttr shape_env;
6635+ ShapeEnvGuarder guarder(&shape_env);
6636+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6637+ auto s1 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 2));
6638+ auto s2 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 3));
6639+ auto s3 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 4));
6640+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6641+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6642+ auto s6 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 7));
6643+ auto s7 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 8));
6644+ std::vector<int64_t> strides = {1, 1, 1, 1};
6645+ std::vector<int64_t> pads = {0, 0, 0, 0};
6646+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6647+ auto infer_context =
6648+ BuildConv2DV2InferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, "SPECIFIC");
6649+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6650+}
6651+ 
6652+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForConv2D_ZeroTensorIcKcZero) {
6653+ auto func = GetInferFunc("Conv2D");
6654+ ASSERT_TRUE(func.first != nullptr);
6655+ InferSymbolShapeContextTestBuilder builder("Conv2D", "conv2D");
6656+ ShapeEnvAttr shape_env;
6657+ ShapeEnvGuarder guarder(&shape_env);
6658+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6659+ auto s1 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 2));
6660+ auto s2 = shape_env.CreateSymbol(28, MakeShared<InputShapeSource>(0, 3));
6661+ auto s3 = shape_env.CreateSymbol(0, MakeShared<InputShapeSource>(0, 4));
6662+ auto s4 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 5));
6663+ auto s5 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 6));
6664+ auto s6 = shape_env.CreateSymbol(0, MakeShared<InputShapeSource>(0, 7));
6665+ auto s7 = shape_env.CreateSymbol(16, MakeShared<InputShapeSource>(0, 8));
6666+ std::vector<int64_t> strides = {1, 1, 1, 1};
6667+ std::vector<int64_t> pads = {0, 0, 0, 0};
6668+ std::vector<int64_t> dilations = {1, 1, 1, 1};
6669+ BuildConv2DInferContext(builder, {s0, s1, s2, s3}, {s4, s5, s6, s7}, strides, pads, dilations, 1, FORMAT_NHWC,
6670+ FORMAT_HWCN);
6671+ auto infer_context = builder.Build();
6672+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6673+}
6674+ 
6675+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_NoArrow) {
6676+ auto func = GetInferFunc("Einsum");
6677+ ASSERT_TRUE(func.first != nullptr);
6678+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6679+ ShapeEnvAttr shape_env;
6680+ ShapeEnvGuarder guarder(&shape_env);
6681+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6682+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6683+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6684+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1}), gert::SymbolShape({s1, s2})}, "ab,bc");
6685+ auto infer_context = builder.Build();
6686+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6687+}
6688+ 
6689+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_DotInEquation) {
6690+ auto func = GetInferFunc("Einsum");
6691+ ASSERT_TRUE(func.first != nullptr);
6692+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6693+ ShapeEnvAttr shape_env;
6694+ ShapeEnvGuarder guarder(&shape_env);
6695+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6696+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6697+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6698+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1}), gert::SymbolShape({s1, s2})}, "a.b,bc->ac");
6699+ auto infer_context = builder.Build();
6700+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6701+}
6702+ 
6703+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_DotWithEllipsis) {
6704+ auto func = GetInferFunc("Einsum");
6705+ ASSERT_TRUE(func.first != nullptr);
6706+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6707+ ShapeEnvAttr shape_env;
6708+ ShapeEnvGuarder guarder(&shape_env);
6709+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6710+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6711+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6712+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1}), gert::SymbolShape({s1, s2})}, "a...b.c,bc->ac");
6713+ auto infer_context = builder.Build();
6714+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6715+}
6716+ 
6717+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_NonAlphaLabel) {
6718+ auto func = GetInferFunc("Einsum");
6719+ ASSERT_TRUE(func.first != nullptr);
6720+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6721+ ShapeEnvAttr shape_env;
6722+ ShapeEnvGuarder guarder(&shape_env);
6723+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6724+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6725+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6726+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1}), gert::SymbolShape({s1, s2})}, "a1,bc->ac");
6727+ auto infer_context = builder.Build();
6728+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6729+}
6730+ 
6731+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_InputPartsSizeMismatch) {
6732+ auto func = GetInferFunc("Einsum");
6733+ ASSERT_TRUE(func.first != nullptr);
6734+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6735+ ShapeEnvAttr shape_env;
6736+ ShapeEnvGuarder guarder(&shape_env);
6737+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6738+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6739+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6740+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1}), gert::SymbolShape({s1, s2})}, "ab->ab");
6741+ auto infer_context = builder.Build();
6742+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6743+}
6744+ 
6745+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_EmptyInputPart) {
6746+ auto func = GetInferFunc("Einsum");
6747+ ASSERT_TRUE(func.first != nullptr);
6748+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6749+ ShapeEnvAttr shape_env;
6750+ ShapeEnvGuarder guarder(&shape_env);
6751+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6752+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6753+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6754+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1}), gert::SymbolShape({s1, s2})}, ",ab->ab");
6755+ auto infer_context = builder.Build();
6756+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6757+}
6758+ 
6759+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_BothDuplicated) {
6760+ auto func = GetInferFunc("Einsum");
6761+ ASSERT_TRUE(func.first != nullptr);
6762+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6763+ ShapeEnvAttr shape_env;
6764+ ShapeEnvGuarder guarder(&shape_env);
6765+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6766+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6767+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6768+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1, s1}), gert::SymbolShape({s1, s2})}, "aab,bc->aac");
6769+ auto infer_context = builder.Build();
6770+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6771+}
6772+ 
6773+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_EllipsisBroadcastEqualConst) {
6774+ auto func = GetInferFunc("Einsum");
6775+ ASSERT_TRUE(func.first != nullptr);
6776+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6777+ ShapeEnvAttr shape_env;
6778+ ShapeEnvGuarder guarder(&shape_env);
6779+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6780+ BuildEinsumInferContext(
6781+ builder, {gert::SymbolShape({Symbol(2), Symbol(3), s0}), gert::SymbolShape({Symbol(2), Symbol(3), s0})},
6782+ "...a,...a->...a");
6783+ auto infer_context = builder.Build();
6784+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6785+}
6786+ 
6787+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_EllipsisBroadcastNewDimOne) {
6788+ auto func = GetInferFunc("Einsum");
6789+ ASSERT_TRUE(func.first != nullptr);
6790+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6791+ ShapeEnvAttr shape_env;
6792+ ShapeEnvGuarder guarder(&shape_env);
6793+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6794+ BuildEinsumInferContext(
6795+ builder, {gert::SymbolShape({Symbol(2), Symbol(3), s0}), gert::SymbolShape({Symbol(1), Symbol(3), s0})},
6796+ "...a,...a->...a");
6797+ auto infer_context = builder.Build();
6798+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6799+}
6800+ 
6801+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_EllipsisBroadcastCurDimOne) {
6802+ auto func = GetInferFunc("Einsum");
6803+ ASSERT_TRUE(func.first != nullptr);
6804+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6805+ ShapeEnvAttr shape_env;
6806+ ShapeEnvGuarder guarder(&shape_env);
6807+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6808+ BuildEinsumInferContext(
6809+ builder, {gert::SymbolShape({Symbol(1), Symbol(3), s0}), gert::SymbolShape({Symbol(2), Symbol(3), s0})},
6810+ "...a,...a->...a");
6811+ auto infer_context = builder.Build();
6812+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6813+}
6814+ 
6815+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_EllipsisBroadcastFail) {
6816+ auto func = GetInferFunc("Einsum");
6817+ ASSERT_TRUE(func.first != nullptr);
6818+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6819+ ShapeEnvAttr shape_env;
6820+ ShapeEnvGuarder guarder(&shape_env);
6821+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6822+ BuildEinsumInferContext(builder, {gert::SymbolShape({Symbol(3), s0}), gert::SymbolShape({Symbol(4), s0})},
6823+ "...a,...a->...a");
6824+ auto infer_context = builder.Build();
6825+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6826+}
6827+ 
6828+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_MergeEqualDimConst) {
6829+ auto func = GetInferFunc("Einsum");
6830+ ASSERT_TRUE(func.first != nullptr);
6831+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6832+ ShapeEnvAttr shape_env;
6833+ ShapeEnvGuarder guarder(&shape_env);
6834+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6835+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6836+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, Symbol(3)}), gert::SymbolShape({Symbol(3), s2})},
6837+ "ab,bc->ac");
6838+ auto infer_context = builder.Build();
6839+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6840+}
6841+ 
6842+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_DimMismatchWithoutEllipsis) {
6843+ auto func = GetInferFunc("Einsum");
6844+ ASSERT_TRUE(func.first != nullptr);
6845+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6846+ ShapeEnvAttr shape_env;
6847+ ShapeEnvGuarder guarder(&shape_env);
6848+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6849+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6850+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6851+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s1, s2}), gert::SymbolShape({s1, s2})}, "ab,bc->ac");
6852+ auto infer_context = builder.Build();
6853+ ASSERT_EQ(func.first(infer_context), ge::PARAM_INVALID);
6854+}
6855+ 
6856+TEST_F(SymbolicShapeInferFuncUT, InferSymbolicShapeForEinsum_EllipsisWithPrefix) {
6857+ auto func = GetInferFunc("Einsum");
6858+ ASSERT_TRUE(func.first != nullptr);
6859+ InferSymbolShapeContextTestBuilder builder("Einsum", "einsum");
6860+ ShapeEnvAttr shape_env;
6861+ ShapeEnvGuarder guarder(&shape_env);
6862+ auto s0 = shape_env.CreateSymbol(2, MakeShared<InputShapeSource>(0, 1));
6863+ auto s1 = shape_env.CreateSymbol(3, MakeShared<InputShapeSource>(0, 2));
6864+ auto s2 = shape_env.CreateSymbol(4, MakeShared<InputShapeSource>(0, 3));
6865+ auto s3 = shape_env.CreateSymbol(5, MakeShared<InputShapeSource>(0, 4));
6866+ BuildEinsumInferContext(builder, {gert::SymbolShape({s0, s2, s1}), gert::SymbolShape({s1, s3})}, "a...b,bc->a...c");
6867+ auto infer_context = builder.Build();
6868+ ASSERT_EQ(func.first(infer_context), ge::GRAPH_SUCCESS);
6869+ auto out_shape = infer_context->GetOutputSymbolShape(0);
6870+ ASSERT_EQ(out_shape->GetDimNum(), 3U);
6871+ ASSERT_EQ(out_shape->GetDim(0), s0);
6872+ ASSERT_EQ(out_shape->GetDim(2), s3);
6873+}
6446} // namespace ge6874} // namespace ge
Mtests/ge/ut/ge/graph/partition/dynamic_shape_partition_unittest.cc+55-0
@@ -1830,5 +1830,60 @@ TEST_F(UtestDynamicShapePartition, not_single_op_scene_success_stable_topo_tail_
1830 graph_options = GetThreadLocalContext().GetAllGraphOptions();1830 graph_options = GetThreadLocalContext().GetAllGraphOptions();
1831 graph_options[OPTION_TOPOSORTING_MODE] = "0";1831 graph_options[OPTION_TOPOSORTING_MODE] = "0";
1832 GetThreadLocalContext().SetGraphOption(graph_options);1832 GetThreadLocalContext().SetGraphOption(graph_options);
1833+ ReInitOo();
1834+}
1835+ 
1836+TEST_F(UtestDynamicShapePartition, GetPartitionName_ReturnsDynamicShapePartitioner) {
1837+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
1838+ NodePtr data = NodeBuilder("data", DATA).AddInputDesc({1, 1, 224, 224}).AddOutputDesc({1, 1, 224, 224}).Build(graph);
1839+ NodePtr relu = NodeBuilder("relu", RELU).AddInputDesc({1, 1, 224, 224}).AddOutputDesc({1, 1, 224, 224}).Build(graph);
1840+ NodePtr netoutput = NodeBuilder("netoutput", NETOUTPUT).AddInputDesc({1, 1, 224, 224}).Build(graph);
1841+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
1842+ GraphUtils::AddEdge(relu->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
1843+ DynamicShapePartitioner partitioner(graph);
1844+ EXPECT_EQ(partitioner.GetPartitionName(), "DynamicShapePartitioner");
1845+}
1846+ 
1847+TEST_F(UtestDynamicShapePartition, Partition_WithInvalidShapeRangeAttr) {
1848+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
1849+ NodePtr data = NodeBuilder("data", DATA).AddInputDesc({1, 1, 224, 224}).AddOutputDesc({1, 1, 224, 224}).Build(graph);
1850+ auto data_op = data->GetOpDesc();
1851+ auto input_desc = data_op->MutableInputDesc(0);
1852+ input_desc->SetShape(GeShape({-1, 1, 224, 224}));
1853+ std::vector<std::pair<int64_t, int64_t>> invalid_range = {{1, 2}, {1, 2}};
1854+ input_desc->SetShapeRange(invalid_range);
1855+ NodePtr relu = NodeBuilder("relu", RELU).AddInputDesc({1, 1, 224, 224}).AddOutputDesc({1, 1, 224, 224}).Build(graph);
1856+ NodePtr netoutput = NodeBuilder("netoutput", NETOUTPUT).AddInputDesc({1, 1, 224, 224}).Build(graph);
1857+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
1858+ GraphUtils::AddEdge(relu->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
1859+ (void)AttrUtils::SetStr(*graph, ATTR_NAME_SESSION_GRAPH_ID, "0");
1860+ DynamicShapePartitioner partitioner(graph);
1861+ EXPECT_EQ(partitioner.Partition(), SUCCESS);
1862+}
1863+ 
1864+TEST_F(UtestDynamicShapePartition, Partition_WithVariableNode) {
1865+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
1866+ NodePtr var_node = NodeBuilder("var", VARIABLE).AddInputDesc({1}).AddOutputDesc({1}).Build(graph);
1867+ NodePtr data = NodeBuilder("data", DATA).AddOutputDesc({1}).Build(graph);
1868+ NodePtr netoutput = NodeBuilder("netoutput", NETOUTPUT).AddInputDesc({1}).Build(graph);
1869+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), var_node->GetInDataAnchor(0));
1870+ GraphUtils::AddEdge(var_node->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
1871+ DynamicShapePartitioner partitioner(graph);
1872+ EXPECT_EQ(partitioner.Partition(), SUCCESS);
1873+}
1874+ 
1875+TEST_F(UtestDynamicShapePartition, Partition_WithDynamicShapeAndTilingSink) {
1876+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
1877+ NodePtr data =
1878+ NodeBuilder("data", DATA).AddInputDesc({-1, 1, 224, 224}).AddOutputDesc({-1, 1, 224, 224}).Build(graph);
1879+ NodePtr relu =
1880+ NodeBuilder("relu", RELU).AddInputDesc({-1, 1, 224, 224}).AddOutputDesc({-1, 1, 224, 224}).Build(graph);
1881+ NodePtr netoutput = NodeBuilder("netoutput", NETOUTPUT).AddInputDesc({-1, 1, 224, 224}).Build(graph);
1882+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
1883+ GraphUtils::AddEdge(relu->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
1884+ graph->SetGraphUnknownFlag(true);
1885+ (void)AttrUtils::SetStr(*graph, ATTR_NAME_SESSION_GRAPH_ID, "0");
1886+ DynamicShapePartitioner partitioner(graph);
1887+ EXPECT_EQ(partitioner.Partition(), SUCCESS);
1833}1888}
1834} // namespace ge1889} // namespace ge
Mtests/ge/ut/ge/graph/partition/graph_partition_unittest.cc+7-83
@@ -615,89 +615,6 @@ TEST_F(UtestGraphPartition, second_partition_graph_with_user_stream_label) {
615 EXPECT_EQ(ge::GELib::GetInstance()->Finalize(), SUCCESS);615 EXPECT_EQ(ge::GELib::GetInstance()->Finalize(), SUCCESS);
616}616}
617 617 
618-TEST_F(UtestGraphPartition, partition_with_graph_stable_topo_bfs) {
619- DEF_GRAPH(graph) {
620- auto data_0 = OP_CFG(DATA).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
621- 
622- auto fake_type2_op1 = OP_CFG("FakeOpNpu").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
623- 
624- auto fake_type2_op2 = OP_CFG("FakeOpNpu").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
625- 
626- auto fake_type2_op3 = OP_CFG("FakeOpRts").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
627- 
628- auto fake_type2_op4 = OP_CFG("FakeOpNpu").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
629- 
630- auto data_1 = OP_CFG(DATA).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
631- 
632- auto fake_type2_op5 = OP_CFG("FakeOpRts").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
633- 
634- auto fake_type2_op6 = OP_CFG("FakeOpRts").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
635- 
636- auto fake_type2_op7 = OP_CFG("FakeOpNpu").InCnt(2).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
637- 
638- auto fake_type2_op8 = OP_CFG("FakeOpNpu").InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
639- 
640- auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {-1});
641- 
642- CHAIN(NODE("_arg_0", data_0)
643- ->NODE("fused_op1", fake_type2_op1)
644- ->NODE("fused_op2", fake_type2_op2)
645- ->NODE("fused_op3", fake_type2_op3)
646- ->NODE("fused_op4", fake_type2_op4)
647- ->EDGE(0, 0)
648- ->NODE("fused_op7", fake_type2_op7)
649- ->NODE("fused_op8", fake_type2_op8)
650- ->NODE("Node_Output", net_output));
651- CHAIN(NODE("_arg_1", data_1)
652- ->NODE("fused_op5", fake_type2_op5)
653- ->NODE("fused_op6", fake_type2_op6)
654- ->EDGE(0, 1)
655- ->NODE("fused_op7"));
656- };
657- auto root_graph = ToComputeGraph(graph);
658- (void)AttrUtils::SetStr(*root_graph, ATTR_NAME_SESSION_GRAPH_ID, "0");
659- map<string, string> options = {};
660- EXPECT_EQ(ge::GELib::Initialize(options), SUCCESS);
661- EnginePartitioner EnginePartitioner;
662- EnginePartitioner::Mode mode = EnginePartitioner::Mode::kSecondPartitioning;
663- // bfs
664- std::map<std::string, std::string> graph_options = GetThreadLocalContext().GetAllGraphOptions();
665- graph_options[OPTION_TOPOSORTING_MODE] = "0";
666- GetThreadLocalContext().SetGraphOption(graph_options);
667- root_graph->TopologicalSortingGraph();
668- graph_options = GetThreadLocalContext().GetAllGraphOptions();
669- graph_options[OPTION_TOPOSORTING_MODE] = "3";
670- GetThreadLocalContext().SetGraphOption(graph_options);
671- std::map<std::string, std::set<std::string>> subgraph_to_node = {
672- {"partition0_rank1_new_sub_graph1", {"fused_op1", "fused_op2"}},
673- {"partition0_rank2_new_sub_graph2", {"fused_op3"}},
674- {"partition0_rank3_new_sub_graph3", {"fused_op4"}},
675- {"partition0_rank4_new_sub_graph5", {"fused_op5", "fused_op6"}},
676- {"partition0_rank5_new_sub_graph6", {"fused_op7", "fused_op8"}},
677- {"partition0_rank6_new_sub_graph7", {}}};
678- ASSERT_EQ(EnginePartitioner.Partition(root_graph, mode), SUCCESS);
679- EXPECT_EQ(EnginePartitioner.GetSubGraphMap().begin()->second.size(), 6);
680- for (const auto &sub_info : EnginePartitioner.GetSubGraphMap().begin()->second) {
681- const auto subgraph = sub_info->GetSubGraph();
682- ASSERT_NE(subgraph, nullptr);
683- int32_t subgraph_node_num = 0;
684- EXPECT_NE(subgraph_to_node.find(subgraph->GetName()), subgraph_to_node.end());
685- for (const auto &sub_node : subgraph->GetDirectNode()) {
686- if (sub_node->GetType() != PLACEHOLDER && sub_node->GetType() != END && sub_node->GetType() != NETOUTPUT) {
687- subgraph_node_num++;
688- EXPECT_NE(subgraph_to_node[subgraph->GetName()].find(sub_node->GetName()),
689- subgraph_to_node[subgraph->GetName()].end());
690- }
691- }
692- EXPECT_EQ(subgraph_node_num, subgraph_to_node[subgraph->GetName()].size());
693- }
694- 
695- graph_options = GetThreadLocalContext().GetAllGraphOptions();
696- graph_options[OPTION_TOPOSORTING_MODE] = "";
697- GetThreadLocalContext().SetGraphOption(graph_options);
698- EXPECT_EQ(ge::GELib::GetInstance()->Finalize(), SUCCESS);
699-}
700- 
701TEST_F(UtestGraphPartition, partition_with_graph_stable_topo_bfs2) {618TEST_F(UtestGraphPartition, partition_with_graph_stable_topo_bfs2) {
702 DEF_GRAPH(graph) {619 DEF_GRAPH(graph) {
703 auto data_0 = OP_CFG(DATA).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});620 auto data_0 = OP_CFG(DATA).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {16});
@@ -1110,4 +1027,11 @@ TEST_F(UtestGraphPartition, HasNoInput_WithInput) {
1110 GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));1027 GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
1111 EXPECT_EQ(EnginePartitioner.HasNoInput(relu), false);1028 EXPECT_EQ(EnginePartitioner.HasNoInput(relu), false);
1112}1029}
1030+ 
1031+TEST_F(UtestGraphPartition, EnginePartitioner_MergeSubGraph_BothNull) {
1032+ EnginePartitioner partitioner;
1033+ ComputeGraphPtr graph1 = nullptr;
1034+ ComputeGraphPtr graph2 = nullptr;
1035+ EXPECT_NE(partitioner.MergeSubGraph(graph1, graph2), SUCCESS);
1036+}
1113} // namespace ge1037} // namespace ge
Mtests/ge/ut/ge/graph/partition/optimizer/hostcpu_engine_update_pass_unittest.cc+199-0
@@ -639,4 +639,203 @@ TEST_F(UtestHostcpuEngineUpdatePass, Run_RuntimeV2Disabled) {
639 unsetenv("ENABLE_RUNTIME_V2");639 unsetenv("ENABLE_RUNTIME_V2");
640}640}
641 641 
642+TEST_F(UtestHostcpuEngineUpdatePass, IsExecOnHost_HostCpuKernelLib) {
643+ HostcpuEngineUpdatePass pass;
644+ ge::OpDescPtr op_desc = std::make_shared<OpDesc>("hostcpu_node", "Gather");
645+ op_desc->AddInputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
646+ op_desc->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
647+ op_desc->SetOpKernelLibName("DNN_VM_HOST_CPU_OP_STORE");
648+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");
649+ ge::NodePtr node = graph->AddNode(op_desc);
650+ EXPECT_EQ(pass.IsExecOnHost(node), true);
651+}
652+ 
653+TEST_F(UtestHostcpuEngineUpdatePass, CheckInputForHostExec_NullInputDesc) {
654+ HostcpuEngineUpdatePass pass;
655+ ge::OpDescPtr op_desc = std::make_shared<OpDesc>("node", "Gather");
656+ op_desc->AddInputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
657+ op_desc->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
658+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");
659+ ge::NodePtr node = graph->AddNode(op_desc);
660+ EXPECT_EQ(pass.CheckInputForHostExec(node, 5), false);
661+}
662+ 
663+TEST_F(UtestHostcpuEngineUpdatePass, CheckInputForHostExec_NotSmallEnough) {
664+ HostcpuEngineUpdatePass pass;
665+ ge::OpDescPtr op_desc = std::make_shared<OpDesc>("node", "Gather");
666+ op_desc->AddInputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1, 1, 224, 224}), FORMAT_NCHW, DT_INT32));
667+ op_desc->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
668+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");
669+ ge::NodePtr node = graph->AddNode(op_desc);
670+ EXPECT_EQ(pass.CheckInputForHostExec(node, 0), false);
671+}
672+ 
673+TEST_F(UtestHostcpuEngineUpdatePass, CheckInputForHostExec_PeerNotHost) {
674+ HostcpuEngineUpdatePass pass;
675+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");
676+ ge::OpDescPtr data_op_desc = std::make_shared<OpDesc>("data", "Data");
677+ data_op_desc->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
678+ data_op_desc->SetOpKernelLibName(kEngineNameAiCore);
679+ ge::NodePtr data_node = graph->AddNode(data_op_desc);
680+ ge::OpDescPtr op_desc = std::make_shared<OpDesc>("node", "Gather");
681+ op_desc->AddInputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
682+ op_desc->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
683+ op_desc->SetOpKernelLibName(kEngineNameAiCore);
684+ ge::NodePtr node = graph->AddNode(op_desc);
685+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), node->GetInDataAnchor(0));
686+ EXPECT_EQ(pass.CheckInputForHostExec(node, 0), false);
687+}
688+ 
689+TEST_F(UtestHostcpuEngineUpdatePass, CheckOutputForHostExec_NullOutputDesc) {
690+ HostcpuEngineUpdatePass pass;
691+ ge::OpDescPtr op_desc = std::make_shared<OpDesc>("node", "Gather");
692+ op_desc->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{1}), FORMAT_NCHW, DT_INT32));
693+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("default");
694+ ge::NodePtr node = graph->AddNode(op_desc);
695+ EXPECT_EQ(pass.CheckAndMarkHostExec(node, *(new NodeEngineMap), *(new NodeEngineMap)), false);
696+}
697+ 
698+TEST_F(UtestHostcpuEngineUpdatePass, Run_WithIfGraph) {
699+ setenv("ENABLE_RUNTIME_V2", "1", 1);
700+ DEF_GRAPH(root) {
701+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {1});
702+ auto shape = OP_CFG(SHAPE).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {});
703+ auto if_op = OP_CFG(IF).InCnt(2).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1}).Build("if_op");
704+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
705+ CHAIN(NODE("data", data)->NODE("shape", shape)->NODE(if_op)->NODE("Node_Output", net_output));
706+ CHAIN(NODE("data")->EDGE(0, 1)->NODE(if_op));
707+ };
708+ DEF_GRAPH(then_graph) {
709+ auto data =
710+ OP_CFG(DATA).InCnt(0).OutCnt(1).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0).TensorDesc(FORMAT_ND, DT_FLOAT, {1});
711+ CHAIN(NODE("then_data", data)->NODE("then_Node_Output", NETOUTPUT));
712+ };
713+ DEF_GRAPH(else_graph) {
714+ auto data =
715+ OP_CFG(DATA).InCnt(0).OutCnt(1).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0).TensorDesc(FORMAT_ND, DT_FLOAT, {1});
716+ CHAIN(NODE("else_data", data)->NODE("else_Node_Output", NETOUTPUT));
717+ };
718+ auto root_graph = ToComputeGraph(root);
719+ root_graph->SetGraphUnknownFlag(true);
720+ root_graph->FindNode("data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
721+ root_graph->FindNode("shape")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
722+ root_graph->FindNode("Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
723+ (void)ge::AttrUtils::SetBool(root_graph->FindNode("data")->GetOpDesc(), ge::ATTR_NAME_HOST_TENSOR, true);
724+ auto if_node = root_graph->FindNode("if_op");
725+ if_node->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
726+ 
727+ auto then_g = ToComputeGraph(then_graph);
728+ then_g->SetGraphUnknownFlag(true);
729+ then_g->FindNode("then_data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
730+ then_g->FindNode("then_Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
731+ 
732+ auto else_g = ToComputeGraph(else_graph);
733+ else_g->SetGraphUnknownFlag(true);
734+ else_g->FindNode("else_data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
735+ else_g->FindNode("else_Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
736+ 
737+ if_node->GetOpDesc()->RegisterSubgraphIrName("then", SubgraphType::kStatic);
738+ if_node->GetOpDesc()->RegisterSubgraphIrName("else", SubgraphType::kStatic);
739+ if_node->GetOpDesc()->AddSubgraphName(then_g->GetName());
740+ if_node->GetOpDesc()->SetSubgraphInstanceName(0, then_g->GetName());
741+ if_node->GetOpDesc()->AddSubgraphName(else_g->GetName());
742+ if_node->GetOpDesc()->SetSubgraphInstanceName(1, else_g->GetName());
743+ then_g->SetParentNode(if_node);
744+ then_g->SetParentGraph(root_graph);
745+ else_g->SetParentNode(if_node);
746+ else_g->SetParentGraph(root_graph);
747+ root_graph->AddSubgraph(then_g);
748+ root_graph->AddSubgraph(else_g);
749+ 
750+ HostcpuEngineUpdatePass pass;
751+ NodeEngineMap node_atomic_engine_map;
752+ NodeEngineMap node_composite_engine_map;
753+ EXPECT_EQ(pass.Run(root_graph, node_atomic_engine_map, node_composite_engine_map), SUCCESS);
754+ unsetenv("ENABLE_RUNTIME_V2");
755+}
756+ 
757+TEST_F(UtestHostcpuEngineUpdatePass, Run_WithCaseGraph) {
758+ setenv("ENABLE_RUNTIME_V2", "1", 1);
759+ DEF_GRAPH(root) {
760+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {1});
761+ auto shape = OP_CFG(SHAPE).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {});
762+ auto case_op = OP_CFG(CASE).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1}).Build("case_op");
763+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
764+ CHAIN(NODE("data", data)->NODE("shape", shape)->NODE(case_op)->NODE("Node_Output", net_output));
765+ };
766+ DEF_GRAPH(branch_graph) {
767+ auto data =
768+ OP_CFG(DATA).InCnt(0).OutCnt(1).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0).TensorDesc(FORMAT_ND, DT_FLOAT, {1});
769+ CHAIN(NODE("branch_data", data)->NODE("branch_Node_Output", NETOUTPUT));
770+ };
771+ auto root_graph = ToComputeGraph(root);
772+ root_graph->SetGraphUnknownFlag(true);
773+ root_graph->FindNode("data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
774+ root_graph->FindNode("shape")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
775+ root_graph->FindNode("Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
776+ (void)ge::AttrUtils::SetBool(root_graph->FindNode("data")->GetOpDesc(), ge::ATTR_NAME_HOST_TENSOR, true);
777+ auto case_node = root_graph->FindNode("case_op");
778+ case_node->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
779+ 
780+ auto branch_g = ToComputeGraph(branch_graph);
781+ branch_g->SetGraphUnknownFlag(true);
782+ branch_g->FindNode("branch_data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
783+ branch_g->FindNode("branch_Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
784+ 
785+ case_node->GetOpDesc()->RegisterSubgraphIrName("branches", SubgraphType::kStatic);
786+ case_node->GetOpDesc()->AddSubgraphName(branch_g->GetName());
787+ case_node->GetOpDesc()->SetSubgraphInstanceName(0, branch_g->GetName());
788+ branch_g->SetParentNode(case_node);
789+ branch_g->SetParentGraph(root_graph);
790+ root_graph->AddSubgraph(branch_g);
791+ 
792+ HostcpuEngineUpdatePass pass;
793+ NodeEngineMap node_atomic_engine_map;
794+ NodeEngineMap node_composite_engine_map;
795+ EXPECT_EQ(pass.Run(root_graph, node_atomic_engine_map, node_composite_engine_map), SUCCESS);
796+ unsetenv("ENABLE_RUNTIME_V2");
797+}
798+ 
799+TEST_F(UtestHostcpuEngineUpdatePass, Run_WithStaticSubgraph) {
800+ setenv("ENABLE_RUNTIME_V2", "1", 1);
801+ DEF_GRAPH(root) {
802+ auto data = OP_CFG(DATA).InCnt(0).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {1});
803+ auto shape = OP_CFG(SHAPE).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_INT32, {});
804+ auto if_op = OP_CFG(IF).InCnt(2).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1}).Build("if_op");
805+ auto net_output = OP_CFG(NETOUTPUT).InCnt(1).OutCnt(1).TensorDesc(FORMAT_ND, DT_FLOAT, {-1});
806+ CHAIN(NODE("data", data)->NODE("shape", shape)->NODE(if_op)->NODE("Node_Output", net_output));
807+ CHAIN(NODE("data")->EDGE(0, 1)->NODE(if_op));
808+ };
809+ DEF_GRAPH(then_graph) {
810+ auto data =
811+ OP_CFG(DATA).InCnt(0).OutCnt(1).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0).TensorDesc(FORMAT_ND, DT_FLOAT, {1});
812+ CHAIN(NODE("then_data", data)->NODE("then_Node_Output", NETOUTPUT));
813+ };
814+ auto root_graph = ToComputeGraph(root);
815+ root_graph->SetGraphUnknownFlag(true);
816+ root_graph->FindNode("data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
817+ root_graph->FindNode("shape")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
818+ root_graph->FindNode("Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
819+ (void)ge::AttrUtils::SetBool(root_graph->FindNode("data")->GetOpDesc(), ge::ATTR_NAME_HOST_TENSOR, true);
820+ auto if_node = root_graph->FindNode("if_op");
821+ if_node->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
822+ 
823+ auto then_g = ToComputeGraph(then_graph);
824+ then_g->FindNode("then_data")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
825+ then_g->FindNode("then_Node_Output")->GetOpDesc()->SetOpKernelLibName(kEngineNameGeLocal);
826+ 
827+ if_node->GetOpDesc()->RegisterSubgraphIrName("then", SubgraphType::kStatic);
828+ if_node->GetOpDesc()->RegisterSubgraphIrName("else", SubgraphType::kStatic);
829+ if_node->GetOpDesc()->AddSubgraphName(then_g->GetName());
830+ if_node->GetOpDesc()->SetSubgraphInstanceName(0, then_g->GetName());
831+ then_g->SetParentNode(if_node);
832+ then_g->SetParentGraph(root_graph);
833+ root_graph->AddSubgraph(then_g);
834+ 
835+ HostcpuEngineUpdatePass pass;
836+ NodeEngineMap node_atomic_engine_map;
837+ NodeEngineMap node_composite_engine_map;
838+ EXPECT_EQ(pass.Run(root_graph, node_atomic_engine_map, node_composite_engine_map), SUCCESS);
839+ unsetenv("ENABLE_RUNTIME_V2");
840+}
642} // namespace ge841} // namespace ge
Mtests/ge/ut/ge/graph/passes/assign_remove_pass_unittest.cc+11-0
@@ -414,4 +414,15 @@ TEST_F(UtestGraphPassesAssignRemovePass, RefNodeHasOutControlNodes_RefNodeIdMore
414 EXPECT_TRUE(assign_node_->GetOutAllNodes().empty());414 EXPECT_TRUE(assign_node_->GetOutAllNodes().empty());
415 EXPECT_TRUE(assign_node_->GetInAllNodes().empty());415 EXPECT_TRUE(assign_node_->GetInAllNodes().empty());
416}416}
417+ 
418+TEST_F(UtestGraphPassesAssignRemovePass, test_assign_peer_anchor_null) {
419+ graph_ = std::make_shared<ComputeGraph>("test_graph");
420+ GeTensorDesc tensor_desc(GeShape({2, 2, 2, 2}), ge::FORMAT_NCHW, ge::DT_FLOAT);
421+ auto assign_desc = std::make_shared<OpDesc>("assign", ASSIGN);
422+ assign_desc->AddInputDesc(tensor_desc);
423+ assign_desc->AddInputDesc(tensor_desc);
424+ assign_desc->AddOutputDesc(tensor_desc);
425+ assign_node_ = graph_->AddNode(assign_desc);
426+ EXPECT_EQ(pass_.Run(assign_node_), FAILED);
427+}
417} // namespace ge428} // namespace ge
Mtests/ge/ut/ge/graph/passes/atomic_addr_clean_pass_unittest.cc+22-0
@@ -829,4 +829,26 @@ TEST_F(UtestGraphPassesAtomicAddrCleanPass, test_ge_init_fail) {
829 GEInitialize(options);829 GEInitialize(options);
830}830}
831 831 
832+TEST_F(UtestGraphPassesAtomicAddrCleanPass, check_atomic_ops_kernel_ge_not_init) {
833+ GEFinalize();
834+ AtomicAddrCleanPass pass;
835+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
836+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_node", RELU);
837+ op_desc->AddInputDesc(GeTensorDesc());
838+ op_desc->AddOutputDesc(GeTensorDesc());
839+ NodePtr node = graph->AddNode(op_desc);
840+ EXPECT_FALSE(pass.CheckAtomicFromOpsKernel(node));
841+ std::map<AscendString, AscendString> options;
842+ GEInitialize(options);
843+}
844+ 
845+TEST_F(UtestGraphPassesAtomicAddrCleanPass, is_hcom_atomic_node_test) {
846+ AtomicAddrCleanPass pass;
847+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
848+ OpDescPtr op_desc = std::make_shared<OpDesc>("hcom_node", HCOMALLREDUCE);
849+ op_desc->AddInputDesc(GeTensorDesc());
850+ op_desc->AddOutputDesc(GeTensorDesc());
851+ NodePtr node = graph->AddNode(op_desc);
852+ EXPECT_FALSE(pass.IsHcomAtomicNode(node));
853+}
832} // namespace ge854} // namespace ge
Mtests/ge/ut/ge/graph/passes/attach_stream_label_pass_unittest.cc+62-0
@@ -13,6 +13,8 @@
13#include <gtest/gtest.h>13#include <gtest/gtest.h>
14#include "ge_graph_dsl/graph_dsl.h"14#include "ge_graph_dsl/graph_dsl.h"
15#include "graph/passes/control_flow_and_stream/attach_stream_label_pass.h"15#include "graph/passes/control_flow_and_stream/attach_stream_label_pass.h"
16+#include "graph/utils/graph_utils.h"
17+#include "graph/utils/attr_utils.h"
16 18 
17using namespace testing;19using namespace testing;
18using namespace ge;20using namespace ge;
@@ -122,4 +124,64 @@ TEST_F(UtestAttachStreamLabelPass, test_run_with_enter_node) {
122 AttachStreamLabelPass pass(false);124 AttachStreamLabelPass pass(false);
123 EXPECT_EQ(pass.Run(graph), SUCCESS);125 EXPECT_EQ(pass.Run(graph), SUCCESS);
124}126}
127+ 
128+TEST_F(UtestAttachStreamLabelPass, test_stream_switch_no_data_input_fail) {
129+ DEF_GRAPH(g1) {
130+ auto sw_cfg = OP_CFG(STREAMSWITCH).Attr(ATTR_NAME_SWITCH_TRUE_BRANCH_FLAG, true);
131+ CHAIN(NODE("sw", sw_cfg)->NODE("netoutput", NETOUTPUT));
132+ };
133+ const auto graph = ToComputeGraph(g1);
134+ AttachStreamLabelPass pass(false);
135+ EXPECT_EQ(pass.Run(graph), FAILED);
136+}
137+ 
138+TEST_F(UtestAttachStreamLabelPass, test_enter_with_stream_active_label) {
139+ DEF_GRAPH(g1) {
140+ CHAIN(NODE("data", DATA)->NODE("enter", ENTER)->NODE("add", ADD)->NODE("netoutput", NETOUTPUT));
141+ };
142+ const auto graph = ToComputeGraph(g1);
143+ auto active_desc = std::make_shared<OpDesc>("active", STREAMACTIVE);
144+ AttrUtils::SetStr(active_desc, ATTR_NAME_STREAM_LABEL, "test_label");
145+ AttrUtils::SetListStr(active_desc, ATTR_NAME_ACTIVE_LABEL_LIST, {"test_label"});
146+ auto active_node = graph->AddNode(active_desc);
147+ auto enter_node = graph->FindNode("enter");
148+ GraphUtils::AddEdge(enter_node->GetOutControlAnchor(), active_node->GetInControlAnchor());
149+ AttachStreamLabelPass pass(false);
150+ EXPECT_EQ(pass.Run(graph), SUCCESS);
151+}
152+ 
153+TEST_F(UtestAttachStreamLabelPass, test_enter_with_non_stream_active_ctrl) {
154+ DEF_GRAPH(g1) {
155+ CHAIN(NODE("data", DATA)->NODE("enter", ENTER)->NODE("netoutput", NETOUTPUT));
156+ };
157+ const auto graph = ToComputeGraph(g1);
158+ auto add_desc = std::make_shared<OpDesc>("add_ctrl", ADD);
159+ GeTensorDesc tensor_desc;
160+ add_desc->AddInputDesc(tensor_desc);
161+ add_desc->AddOutputDesc(tensor_desc);
162+ auto add_node = graph->AddNode(add_desc);
163+ auto enter_node = graph->FindNode("enter");
164+ GraphUtils::AddEdge(enter_node->GetOutControlAnchor(), add_node->GetInControlAnchor());
165+ AttachStreamLabelPass pass(false);
166+ EXPECT_EQ(pass.Run(graph), SUCCESS);
167+}
168+ 
169+TEST_F(UtestAttachStreamLabelPass, test_subgraph_with_active_label_list) {
170+ DEF_GRAPH(sub_1) {
171+ auto add_cfg = OP_CFG(ADD).Attr(ATTR_NAME_STREAM_LABEL, "label1");
172+ CHAIN(NODE("const_0", CONSTANT)->NODE("add_0", add_cfg)->NODE("netoutput", NETOUTPUT));
173+ };
174+ DEF_GRAPH(g1) {
175+ auto active_cfg = OP_CFG(STREAMACTIVE).Attr(ATTR_NAME_ACTIVE_LABEL_LIST, std::vector<std::string>{"label1"});
176+ CHAIN(NODE("data_0", DATA)->NODE("case", CASE, sub_1)->NODE("netoutput", NETOUTPUT));
177+ CHAIN(NODE("case")->NODE("active", active_cfg));
178+ };
179+ sub_1.Layout();
180+ const auto graph = ToComputeGraph(g1);
181+ AttachStreamLabelPass pass(true);
182+ EXPECT_EQ(pass.Run(graph), SUCCESS);
183+ for (auto &subgraph : graph->GetAllSubgraphs()) {
184+ EXPECT_EQ(pass.Run(subgraph), SUCCESS);
185+ }
186+}
125} // namespace ge187} // namespace ge
Mtests/ge/ut/ge/graph/passes/base_pass_unittest.cc+36-0
@@ -1264,4 +1264,40 @@ TEST_F(UTESTGraphPassesBasePass, run_with_filter_disabled_all) {
1264 EXPECT_EQ(ge_pass.Run(passes, true), SUCCESS);1264 EXPECT_EQ(ge_pass.Run(passes, true), SUCCESS);
1265 GetThreadLocalContext().SetGraphOption(origin_graph_options);1265 GetThreadLocalContext().SetGraphOption(origin_graph_options);
1266}1266}
1267+ 
1268+class TestNullRepassPass : public BaseNodePass {
1269+ public:
1270+ Status Run(NodePtr &node) override {
1271+ AddRePassNode(NodePtr(nullptr));
1272+ AddImmediateRePassNode(NodePtr(nullptr));
1273+ return SUCCESS;
1274+ }
1275+};
1276+REG_PASS_OPTION("TestNullRepassPass").LEVELS(OoLevel::kO3);
1277+ 
1278+TEST_F(UTESTGraphPassesBasePass, null_repass_node_test) {
1279+ NamesToPass names_to_pass;
1280+ auto test_pass = TestNullRepassPass();
1281+ names_to_pass.push_back(std::make_pair("TestNullRepassPass", &test_pass));
1282+ auto graph = BuildGraph1();
1283+ auto ge_pass = GEPass(graph);
1284+ EXPECT_EQ(ge_pass.Run(names_to_pass), SUCCESS);
1285+}
1286+ 
1287+class TestFailPass : public BaseNodePass {
1288+ public:
1289+ Status Run(NodePtr &node) override {
1290+ return FAILED;
1291+ }
1292+};
1293+REG_PASS_OPTION("TestFailPass").LEVELS(OoLevel::kO3);
1294+ 
1295+TEST_F(UTESTGraphPassesBasePass, run_pass_on_node_failed) {
1296+ NamesToPass names_to_pass;
1297+ auto test_pass = TestFailPass();
1298+ names_to_pass.push_back(std::make_pair("TestFailPass", &test_pass));
1299+ auto graph = BuildGraph1();
1300+ auto ge_pass = GEPass(graph);
1301+ EXPECT_EQ(ge_pass.Run(names_to_pass), FAILED);
1302+}
1267} // namespace ge1303} // namespace ge
Mtests/ge/ut/ge/graph/passes/buffer_pool_memory_pass_unittest.cc+33-0
@@ -761,4 +761,37 @@ TEST_F(UtestBufferPoolMemoryPass, run_without_buffer_pool_nodes_skip_test) {
761 Status ret = buffer_pool_mem_pass.Run(graph);761 Status ret = buffer_pool_mem_pass.Run(graph);
762 EXPECT_EQ(ret, SUCCESS);762 EXPECT_EQ(ret, SUCCESS);
763}763}
764+ 
765+TEST_F(UtestBufferPoolMemoryPass, buffer_pool_cycle_detection_success_test) {
766+ ut::BufferPoolGraphBuilder builder("GraphWithCycle");
767+ ge::ComputeGraphPtr graph = builder.BuildGraphWithMultiPrefetch();
768+ 
769+ auto prefetch1 = graph->FindNode("prefetch1");
770+ auto prefetch2 = graph->FindNode("prefetch2");
771+ EXPECT_NE(prefetch1, nullptr);
772+ EXPECT_NE(prefetch2, nullptr);
773+ 
774+ GraphUtils::AddEdge(prefetch2->GetOutControlAnchor(), prefetch1->GetInControlAnchor());
775+ 
776+ BufferPoolMemoryPass buffer_pool_mem_pass;
777+ Status ret = buffer_pool_mem_pass.Run(graph);
778+ EXPECT_EQ(ret, SUCCESS);
779+ 
780+ EXPECT_FALSE(prefetch2->GetOpDesc()->HasAttr(ATTR_NAME_BUFFER_POOL_ID));
781+ EXPECT_FALSE(prefetch2->GetOpDesc()->HasAttr(ATTR_NAME_BUFFER_POOL_SIZE));
782+}
783+ 
784+TEST_F(UtestBufferPoolMemoryPass, buffer_pool_multi_output_with_stream_label_success_test) {
785+ ut::BufferPoolGraphBuilder builder("GraphWithMultiOutputAndStreamLabel");
786+ ge::ComputeGraphPtr graph = builder.BuildGraphWithMultiOutputPrefetch();
787+ 
788+ auto prefetch1 = graph->FindNode("prefetch1");
789+ EXPECT_NE(prefetch1, nullptr);
790+ (void)AttrUtils::SetStr(prefetch1->GetOpDesc(), ATTR_NAME_STREAM_LABEL, "stream_0");
791+ 
792+ BufferPoolMemoryPass buffer_pool_mem_pass;
793+ Status ret = buffer_pool_mem_pass.Run(graph);
794+ EXPECT_EQ(ret, SUCCESS);
795+ EXPECT_EQ(CheckAttr(graph), SUCCESS);
796+}
764} // namespace ge797} // namespace ge
Mtests/ge/ut/ge/graph/passes/cond_remove_pass_unittest.cc+59-0
@@ -444,3 +444,62 @@ TEST_F(UtestCondRemovePass, case_cond_not_int32_skip) {
444 auto ret = pass.Run(case_node);444 auto ret = pass.Run(case_node);
445 EXPECT_EQ(ret, SUCCESS);445 EXPECT_EQ(ret, SUCCESS);
446}446}
447+ 
448+TEST_F(UtestCondRemovePass, case_cond_index_exceed_subgraph_size) {
449+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("g");
450+ vector<int32_t> data_vec = {5};
451+ GeTensorDesc tensor_desc(GeShape({1}), ge::FORMAT_NCHW, ge::DT_INT32);
452+ GeTensorPtr value_tensor =
453+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
454+ auto op_value = CreateOpDesc("const", CONSTANTOP, tensor_desc, 1, tensor_desc, 1);
455+ OpDescUtils::SetWeights(op_value, value_tensor);
456+ NodePtr data_node = graph->AddNode(op_value);
457+ NodePtr case_node = graph->AddNode(CreateOpDesc("case", CASE, tensor_desc, 3, tensor_desc, 1));
458+ EXPECT_EQ(GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), case_node->GetInDataAnchor(0)), SUCCESS);
459+ 
460+ std::string case1_name = "case1";
461+ ComputeGraphPtr case1_graph = std::make_shared<ComputeGraph>(case1_name);
462+ case1_graph->SetParentNode(case_node);
463+ case1_graph->SetParentGraph(graph);
464+ case_node->GetOpDesc()->AddSubgraphName(case1_name);
465+ case_node->GetOpDesc()->SetSubgraphInstanceName(0, case1_name);
466+ EXPECT_EQ(graph->AddSubgraph(case1_name, case1_graph), GRAPH_SUCCESS);
467+ 
468+ CondRemovePass pass;
469+ auto ret = pass.Run(case_node);
470+ EXPECT_EQ(ret, SUCCESS);
471+}
472+ 
473+TEST_F(UtestCondRemovePass, if_no_subgraph_fail) {
474+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("g");
475+ vector<int32_t> data_vec = {1};
476+ GeTensorDesc tensor_desc(GeShape(), ge::FORMAT_NCHW, ge::DT_INT32);
477+ GeTensorPtr value_tensor =
478+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
479+ auto op_value = CreateOpDesc("const", CONSTANTOP, tensor_desc, 1, tensor_desc, 1);
480+ OpDescUtils::SetWeights(op_value, value_tensor);
481+ NodePtr data_node = graph->AddNode(op_value);
482+ NodePtr if_node = graph->AddNode(CreateOpDesc("if", IF, tensor_desc, 2, tensor_desc, 1));
483+ EXPECT_EQ(GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), if_node->GetInDataAnchor(0)), SUCCESS);
484+ 
485+ CondRemovePass pass;
486+ auto ret = pass.Run(if_node);
487+ EXPECT_EQ(ret, FAILED);
488+}
489+ 
490+TEST_F(UtestCondRemovePass, case_no_subgraph_fail) {
491+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("g");
492+ vector<int32_t> data_vec = {1};
493+ GeTensorDesc tensor_desc(GeShape(), ge::FORMAT_NCHW, ge::DT_INT32);
494+ GeTensorPtr value_tensor =
495+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
496+ auto op_value = CreateOpDesc("const", CONSTANTOP, tensor_desc, 1, tensor_desc, 1);
497+ OpDescUtils::SetWeights(op_value, value_tensor);
498+ NodePtr data_node = graph->AddNode(op_value);
499+ NodePtr case_node = graph->AddNode(CreateOpDesc("case", CASE, tensor_desc, 2, tensor_desc, 1));
500+ EXPECT_EQ(GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), case_node->GetInDataAnchor(0)), SUCCESS);
501+ 
502+ CondRemovePass pass;
503+ auto ret = pass.Run(case_node);
504+ EXPECT_EQ(ret, FAILED);
505+}
Mtests/ge/ut/ge/graph/passes/constant_folding_pass_unittest.cc+34-0
@@ -1112,4 +1112,38 @@ TEST_F(UtestGraphPassesConstantFoldingPass, test_potential_folding_skip_constant
1112 EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);1112 EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
1113 EXPECT_NE(graph->FindNode("add"), nullptr);1113 EXPECT_NE(graph->FindNode("add"), nullptr);
1114}1114}
1115+ 
1116+TEST_F(UtestGraphPassesConstantFoldingPass, test_folding_with_switch_input) {
1117+ auto builder = ut::GraphBuilder("test");
1118+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1);
1119+ SetWeightForConstNode(const1);
1120+ auto switch1 = builder.AddNode("switch1", SWITCH, 2, 2);
1121+ auto add1 = builder.AddNode("add1", ADD, 1, 1);
1122+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
1123+ builder.AddDataEdge(const1, 0, switch1, 0);
1124+ builder.AddDataEdge(switch1, 0, add1, 0);
1125+ builder.AddDataEdge(add1, 0, netoutput, 0);
1126+ auto graph = builder.GetGraph();
1127+ 
1128+ names_to_pass.push_back({"ConstantFoldingPass", new ConstantFoldingPass});
1129+ GEPass pass(graph);
1130+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
1131+}
1132+ 
1133+TEST_F(UtestGraphPassesConstantFoldingPass, test_folding_with_data_input_no_output) {
1134+ auto builder = ut::GraphBuilder("test");
1135+ auto data1 = builder.AddNode("data1", DATA, 0, 1);
1136+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1);
1137+ SetWeightForConstNode(const1);
1138+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
1139+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
1140+ builder.AddDataEdge(data1, 0, add1, 0);
1141+ builder.AddDataEdge(const1, 0, add1, 1);
1142+ builder.AddDataEdge(add1, 0, netoutput, 0);
1143+ auto graph = builder.GetGraph();
1144+ 
1145+ names_to_pass.push_back({"ConstantFoldingPass", new ConstantFoldingPass});
1146+ GEPass pass(graph);
1147+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
1148+}
1115} // namespace ge1149} // namespace ge
Mtests/ge/ut/ge/graph/passes/constant_fuse_same_pass_unittest.cc+138-0
@@ -350,3 +350,141 @@ TEST_F(UtestGraphPassesConstantFuseSamePass, success_const_has_data_5) {
350 auto const4 = graph->FindNode("const4");350 auto const4 = graph->FindNode("const4");
351 EXPECT_EQ(const4, nullptr);351 EXPECT_EQ(const4, nullptr);
352}352}
353+ 
354+TEST_F(UtestGraphPassesConstantFuseSamePass, const_node_without_weight_attr) {
355+ auto builder = ut::GraphBuilder("g1");
356+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
357+ auto const2 = builder.AddNode("const2", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
358+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
359+ 
360+ float weight[] = {0.0f};
361+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_FLOAT);
362+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
363+ int64_t origin_val_size = 1;
364+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
365+ OpDescUtils::SetWeights(const1, {tensor});
366+ 
367+ builder.AddDataEdge(const1, 0, add1, 0);
368+ builder.AddDataEdge(const2, 0, add1, 1);
369+ 
370+ ConstantFuseSamePass pass;
371+ EXPECT_EQ(pass.Run(builder.GetGraph()), SUCCESS);
372+}
373+ 
374+TEST_F(UtestGraphPassesConstantFuseSamePass, const_node_origin_element_num_not_one) {
375+ auto builder = ut::GraphBuilder("g1");
376+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
377+ auto const2 = builder.AddNode("const2", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
378+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
379+ 
380+ float weight[] = {0.0f};
381+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_FLOAT);
382+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
383+ int64_t origin_val_size = 2;
384+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
385+ OpDescUtils::SetWeights(const1, {tensor});
386+ OpDescUtils::SetWeights(const2, {tensor});
387+ 
388+ builder.AddDataEdge(const1, 0, add1, 0);
389+ builder.AddDataEdge(const2, 0, add1, 1);
390+ 
391+ ConstantFuseSamePass pass;
392+ auto graph = builder.GetGraph();
393+ EXPECT_EQ(pass.Run(graph), SUCCESS);
394+ EXPECT_EQ(graph->GetDirectNodesSize(), 3);
395+}
396+ 
397+TEST_F(UtestGraphPassesConstantFuseSamePass, const_node_unsupported_dtype) {
398+ auto builder = ut::GraphBuilder("g1");
399+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1, FORMAT_NCHW, DT_UNDEFINED, {1});
400+ auto const2 = builder.AddNode("const2", CONSTANT, 0, 1, FORMAT_NCHW, DT_UNDEFINED, {1});
401+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
402+ 
403+ float weight[] = {0.0f};
404+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_UNDEFINED);
405+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
406+ int64_t origin_val_size = 1;
407+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
408+ OpDescUtils::SetWeights(const1, {tensor});
409+ OpDescUtils::SetWeights(const2, {tensor});
410+ 
411+ builder.AddDataEdge(const1, 0, add1, 0);
412+ builder.AddDataEdge(const2, 0, add1, 1);
413+ 
414+ ConstantFuseSamePass pass;
415+ auto graph = builder.GetGraph();
416+ EXPECT_EQ(pass.Run(graph), SUCCESS);
417+ EXPECT_EQ(graph->GetDirectNodesSize(), 3);
418+}
419+ 
420+TEST_F(UtestGraphPassesConstantFuseSamePass, const_node_no_out_data_edge) {
421+ auto builder = ut::GraphBuilder("g1");
422+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
423+ auto const2 = builder.AddNode("const2", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
424+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
425+ 
426+ float weight[] = {0.0f};
427+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_FLOAT);
428+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
429+ int64_t origin_val_size = 1;
430+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
431+ OpDescUtils::SetWeights(const1, {tensor});
432+ OpDescUtils::SetWeights(const2, {tensor});
433+ 
434+ builder.AddDataEdge(const1, 0, add1, 0);
435+ builder.AddDataEdge(const2, 0, add1, 1);
436+ 
437+ auto const3 = builder.AddNode("const3", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
438+ OpDescUtils::SetWeights(const3, {tensor});
439+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
440+ 
441+ ConstantFuseSamePass pass;
442+ auto graph = builder.GetGraph();
443+ EXPECT_EQ(pass.Run(graph), SUCCESS);
444+}
445+ 
446+TEST_F(UtestGraphPassesConstantFuseSamePass, const_node_with_in_control_edge) {
447+ auto builder = ut::GraphBuilder("g1");
448+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
449+ auto const2 = builder.AddNode("const2", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
450+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
451+ auto ctrl_node = builder.AddNode("ctrl_node", NOOP, 0, 0);
452+ 
453+ float weight[] = {0.0f};
454+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_FLOAT);
455+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
456+ int64_t origin_val_size = 1;
457+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
458+ OpDescUtils::SetWeights(const1, {tensor});
459+ OpDescUtils::SetWeights(const2, {tensor});
460+ 
461+ builder.AddDataEdge(const1, 0, add1, 0);
462+ builder.AddDataEdge(const2, 0, add1, 1);
463+ builder.AddControlEdge(ctrl_node, const1);
464+ 
465+ ConstantFuseSamePass pass;
466+ auto graph = builder.GetGraph();
467+ EXPECT_EQ(pass.Run(graph), SUCCESS);
468+}
469+ 
470+TEST_F(UtestGraphPassesConstantFuseSamePass, const_fuse_with_duplication_exclusion) {
471+ auto builder = ut::GraphBuilder("g1");
472+ auto const1 = builder.AddNode("const1", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
473+ auto const2 = builder.AddNode("const2", CONSTANT, 0, 1, FORMAT_NCHW, DT_FLOAT, {1});
474+ auto add1 = builder.AddNode("add1", ADD, 2, 1);
475+ 
476+ float weight[] = {0.0f};
477+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_FLOAT);
478+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
479+ int64_t origin_val_size = 1;
480+ (void)ge::AttrUtils::SetInt(tensor->MutableTensorDesc(), kOriginElementNumAttrName, origin_val_size);
481+ OpDescUtils::SetWeights(const1, {tensor});
482+ OpDescUtils::SetWeights(const2, {tensor});
483+ 
484+ builder.AddDataEdge(const1, 0, add1, 0);
485+ builder.AddDataEdge(const2, 0, add1, 0);
486+ 
487+ ConstantFuseSamePass pass;
488+ auto graph = builder.GetGraph();
489+ EXPECT_EQ(pass.Run(graph), SUCCESS);
490+}
Mtests/ge/ut/ge/graph/passes/control_trigger_pass_unittest.cc+17-0
@@ -30,6 +30,23 @@ class UtestControlTriggerPass : public testing::Test {
30 void SetUp() {}30 void SetUp() {}
31 void TearDown() {}31 void TearDown() {}
32};32};
33+ 
34+TEST_F(UtestControlTriggerPass, RunEmptyGraph) {
35+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("empty");
36+ ControlTriggerPass pass;
37+ EXPECT_EQ(pass.Run(graph), SUCCESS);
38+}
39+ 
40+TEST_F(UtestControlTriggerPass, ClearStatusSuccess) {
41+ ControlTriggerPass pass;
42+ EXPECT_EQ(pass.ClearStatus(), SUCCESS);
43+}
44+ 
45+TEST_F(UtestControlTriggerPass, FindPredInputNullNode) {
46+ ControlTriggerPass pass;
47+ NodePtr null_node = nullptr;
48+ EXPECT_EQ(pass.FindPredInput(null_node), INTERNAL_ERROR);
49+}
33namespace {50namespace {
34ComputeGraphPtr BuildNormalGraph() {51ComputeGraphPtr BuildNormalGraph() {
35 const auto sub1_data_0 = OP_CFG(DATA).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0);52 const auto sub1_data_0 = OP_CFG(DATA).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0);
Mtests/ge/ut/ge/graph/passes/create_subgraph_with_scope_pass_unittest.cc+31-0
@@ -420,4 +420,35 @@ TEST_F(CreateSubgraphWithScopePassTest, data_node_with_scope_index_failed) {
420 AttrUtils::SetInt(data0->GetOpDesc(), ATTR_NAME_SUBGRAPH_MULTI_DIMS_INDEX, 0);420 AttrUtils::SetInt(data0->GetOpDesc(), ATTR_NAME_SUBGRAPH_MULTI_DIMS_INDEX, 0);
421 EXPECT_EQ(pass_manager.Run(graph), PARAM_INVALID);421 EXPECT_EQ(pass_manager.Run(graph), PARAM_INVALID);
422}422}
423+ 
424+TEST_F(CreateSubgraphWithScopePassTest, run_with_two_nodes_in_graph) {
425+ std::map<std::string, std::string> options;
426+ GetThreadLocalContext().SetGlobalOption(options);
427+ PassManager pass_manager;
428+ pass_manager.AddPass("CreateSubGraphWithScopePass", new (std::nothrow) CreateSubGraphWithScopePass);
429+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
430+ auto data0 = MakeNode(graph, 0, 1, "data_0", DATA);
431+ GeTensorDesc tensor_desc0(GeShape({-1, 3, 224, 224}));
432+ data0->GetOpDesc()->UpdateOutputDesc(0, tensor_desc0);
433+ auto netoutput = MakeNode(graph, 1, 0, "netoutput", NETOUTPUT);
434+ netoutput->GetOpDesc()->UpdateInputDesc(0, tensor_desc0);
435+ GraphUtils::AddEdge(data0->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
436+ EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
437+}
438+ 
439+TEST_F(CreateSubgraphWithScopePassTest, run_with_multibatch_config) {
440+ std::map<std::string, std::string> options;
441+ GetThreadLocalContext().SetGlobalOption(options);
442+ PassManager pass_manager;
443+ pass_manager.AddPass("CreateSubGraphWithScopePass", new (std::nothrow) CreateSubGraphWithScopePass);
444+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
445+ auto data0 = MakeNode(graph, 0, 1, "data_0", DATA);
446+ GeTensorDesc tensor_desc0(GeShape({-1, 3, 224, 224}));
447+ data0->GetOpDesc()->UpdateOutputDesc(0, tensor_desc0);
448+ auto netoutput = MakeNode(graph, 1, 0, "netoutput", NETOUTPUT);
449+ netoutput->GetOpDesc()->UpdateInputDesc(0, tensor_desc0);
450+ GraphUtils::AddEdge(data0->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
451+ AttrUtils::SetListStr(data0->GetOpDesc(), "_user_defined_batch_info", {"1", "2", "4"});
452+ EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
453+}
423} // namespace ge454} // namespace ge
Mtests/ge/ut/ge/graph/passes/data_flow_prepare_pass_unittest.cc+89-0
@@ -15,6 +15,7 @@
15#include "graph/utils/graph_utils.h"15#include "graph/utils/graph_utils.h"
16#include "graph/utils/graph_utils_ex.h"16#include "graph/utils/graph_utils_ex.h"
17#include "graph/passes/feature/data_flow_prepare_pass.h"17#include "graph/passes/feature/data_flow_prepare_pass.h"
18+#include "graph/utils/op_desc_utils.h"
18 19 
19namespace ge {20namespace ge {
20class UtestDataFlowPreparePass : public testing::Test {21class UtestDataFlowPreparePass : public testing::Test {
@@ -123,4 +124,92 @@ TEST_F(UtestDataFlowPreparePass, set_handle_succ) {
123 (void)AttrUtils::GetInt(stack2->GetOpDesc(), ATTR_NAME_DATA_FLOW_MAX_SIZE, max_size2);124 (void)AttrUtils::GetInt(stack2->GetOpDesc(), ATTR_NAME_DATA_FLOW_MAX_SIZE, max_size2);
124 EXPECT_EQ(max_size2, 200);125 EXPECT_EQ(max_size2, 200);
125}126}
127+ 
128+TEST_F(UtestDataFlowPreparePass, data_flow_max_size_empty_weight_test) {
129+ GeTensorDesc tensor_desc(GeShape(), FORMAT_ND, DT_INT32);
130+ GeTensorPtr const_tensor = std::make_shared<GeTensor>(tensor_desc);
131+ const auto const1 = OP_CFG(CONSTANT).OutCnt(1).Weight(const_tensor);
132+ DEF_GRAPH(g1) {
133+ CHAIN(NODE("const1", const1)->EDGE(0, 0)->NODE("stack1", STACK));
134+ };
135+ const auto graph = ToGeGraph(g1);
136+ const auto compute_graph = GraphUtilsEx::GetComputeGraph(graph);
137+ compute_graph->TopologicalSorting();
138+ const map<string, uint32_t> name_index = {{"max_size", 0}};
139+ for (const auto &node : compute_graph->GetAllNodes()) {
140+ if (node->GetType() == STACK && node->GetOpDesc() != nullptr) {
141+ node->GetOpDesc()->UpdateInputName(name_index);
142+ }
143+ }
144+ DataFlowPreparePass pass;
145+ EXPECT_EQ(pass.Run(compute_graph), SUCCESS);
146+}
147+ 
148+TEST_F(UtestDataFlowPreparePass, data_flow_max_size_not_int32_test) {
149+ float val = 1.0f;
150+ GeTensorDesc tensor_desc(GeShape(), FORMAT_ND, DT_FLOAT);
151+ GeTensorPtr const_tensor = std::make_shared<GeTensor>(tensor_desc, reinterpret_cast<uint8_t *>(&val), sizeof(float));
152+ const auto const1 = OP_CFG(CONSTANT).OutCnt(1).Weight(const_tensor);
153+ DEF_GRAPH(g1) {
154+ CHAIN(NODE("const1", const1)->EDGE(0, 0)->NODE("stack1", STACK));
155+ };
156+ const auto graph = ToGeGraph(g1);
157+ const auto compute_graph = GraphUtilsEx::GetComputeGraph(graph);
158+ compute_graph->TopologicalSorting();
159+ const map<string, uint32_t> name_index = {{"max_size", 0}};
160+ for (const auto &node : compute_graph->GetAllNodes()) {
161+ if (node->GetType() == STACK && node->GetOpDesc() != nullptr) {
162+ node->GetOpDesc()->UpdateInputName(name_index);
163+ }
164+ }
165+ DataFlowPreparePass pass;
166+ EXPECT_EQ(pass.Run(compute_graph), SUCCESS);
167+}
168+ 
169+TEST_F(UtestDataFlowPreparePass, data_flow_max_size_not_const_test) {
170+ DEF_GRAPH(g1) {
171+ CHAIN(NODE("data1", DATA)->EDGE(0, 0)->NODE("stack1", STACK));
172+ };
173+ const auto graph = ToGeGraph(g1);
174+ const auto compute_graph = GraphUtilsEx::GetComputeGraph(graph);
175+ compute_graph->TopologicalSorting();
176+ const map<string, uint32_t> name_index = {{"max_size", 0}};
177+ for (const auto &node : compute_graph->GetAllNodes()) {
178+ if (node->GetType() == STACK && node->GetOpDesc() != nullptr) {
179+ node->GetOpDesc()->UpdateInputName(name_index);
180+ }
181+ }
182+ DataFlowPreparePass pass;
183+ EXPECT_EQ(pass.Run(compute_graph), SUCCESS);
184+}
185+ 
186+TEST_F(UtestDataFlowPreparePass, data_flow_get_resource_input_fail_test) {
187+ int32_t val = 100;
188+ GeTensorDesc tensor_desc(GeShape(), FORMAT_ND, DT_INT32);
189+ GeTensorPtr const_tensor =
190+ std::make_shared<GeTensor>(tensor_desc, reinterpret_cast<uint8_t *>(&val), sizeof(int32_t));
191+ const auto const1 = OP_CFG(CONSTANT).OutCnt(1).Weight(const_tensor);
192+ const auto stackpush1 = OP_CFG(STACKPUSH).InCnt(2).OutCnt(1);
193+ DEF_GRAPH(g1) {
194+ CHAIN(NODE("const1", const1)->EDGE(0, 1)->NODE("stackpush1", stackpush1));
195+ };
196+ const auto graph = ToGeGraph(g1);
197+ const auto compute_graph = GraphUtilsEx::GetComputeGraph(graph);
198+ compute_graph->TopologicalSorting();
199+ DataFlowPreparePass pass;
200+ EXPECT_EQ(pass.Run(compute_graph), INTERNAL_ERROR);
201+}
202+ 
203+TEST_F(UtestDataFlowPreparePass, data_flow_data_node_input_test) {
204+ const auto data1 = OP_CFG(DATA).OutCnt(1);
205+ const auto stackpush1 = OP_CFG(STACKPUSH).InCnt(2).OutCnt(1);
206+ DEF_GRAPH(g1) {
207+ CHAIN(NODE("data1", data1)->EDGE(0, 0)->NODE("stackpush1", stackpush1));
208+ };
209+ const auto graph = ToGeGraph(g1);
210+ const auto compute_graph = GraphUtilsEx::GetComputeGraph(graph);
211+ compute_graph->TopologicalSorting();
212+ DataFlowPreparePass pass;
213+ EXPECT_EQ(pass.Run(compute_graph), SUCCESS);
214+}
126} // namespace ge215} // namespace ge
Mtests/ge/ut/ge/graph/passes/data_pass_unittest.cc+52-0
@@ -436,4 +436,56 @@ TEST_F(UtestDataPass, WhileBodyWithLegacyInstanceNameMapsOutput) {
436 ASSERT_TRUE(AttrUtils::GetInt(input_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index));436 ASSERT_TRUE(AttrUtils::GetInt(input_desc, ATTR_NAME_PARENT_NODE_INDEX, parent_index));
437 EXPECT_EQ(parent_index, 0);437 EXPECT_EQ(parent_index, 0);
438}438}
439+ 
440+TEST_F(UtestDataPass, data_node_with_parent_index_returns_success) {
441+ ut::GraphBuilder builder = ut::GraphBuilder("root_graph");
442+ auto data = builder.AddNode("Data1", "Data", 1, 1);
443+ auto case1 = builder.AddNode("case1", "Case", 1, 1);
444+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 0);
445+ builder.AddDataEdge(data, 0, case1, 0);
446+ builder.AddDataEdge(case1, 0, netoutput, 0);
447+ auto root_graph = builder.GetGraph();
448+ 
449+ ut::GraphBuilder sub_builder = ut::GraphBuilder("sub_graph1");
450+ auto sub_data = sub_builder.AddNode("sub_data1", "Data", 1, 1);
451+ AttrUtils::SetInt(sub_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
452+ auto sub_output = sub_builder.AddNode("sub_output1", "NetOutput", 1, 0);
453+ sub_builder.AddDataEdge(sub_data, 0, sub_output, 0);
454+ auto subgraph = sub_builder.GetGraph();
455+ 
456+ auto case_node = root_graph->FindNode("case1");
457+ auto case_desc = case_node->GetOpDesc();
458+ case_desc->AddSubgraphName("sub_graph1");
459+ case_desc->SetSubgraphInstanceName(0, "sub_graph1");
460+ subgraph->SetParentNode(case_node);
461+ subgraph->SetParentGraph(root_graph);
462+ root_graph->AddSubgraph("sub_graph1", subgraph);
463+ 
464+ DataPass pass;
465+ EXPECT_EQ(pass.Run(subgraph), SUCCESS);
466+}
467+ 
468+TEST_F(UtestDataPass, flow_node_subgraph_success) {
469+ ut::GraphBuilder builder = ut::GraphBuilder("root_graph");
470+ auto flow_node = builder.AddNode("flow1", "FlowNode", 1, 1);
471+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 0);
472+ builder.AddDataEdge(flow_node, 0, netoutput, 0);
473+ auto root_graph = builder.GetGraph();
474+ 
475+ ut::GraphBuilder sub_builder = ut::GraphBuilder("sub_flow");
476+ auto sub_data = sub_builder.AddNode("sub_data", "Data", 1, 1);
477+ auto sub_output = sub_builder.AddNode("sub_output", "NetOutput", 1, 0);
478+ sub_builder.AddDataEdge(sub_data, 0, sub_output, 0);
479+ auto subgraph = sub_builder.GetGraph();
480+ 
481+ auto flow_desc = root_graph->FindNode("flow1")->GetOpDesc();
482+ flow_desc->AddSubgraphName("sub_flow");
483+ flow_desc->SetSubgraphInstanceName(0, "sub_flow");
484+ subgraph->SetParentNode(root_graph->FindNode("flow1"));
485+ subgraph->SetParentGraph(root_graph);
486+ root_graph->AddSubgraph("sub_flow", subgraph);
487+ 
488+ DataPass pass;
489+ EXPECT_EQ(pass.Run(subgraph), SUCCESS);
490+}
439} // namespace ge491} // namespace ge
Mtests/ge/ut/ge/graph/passes/flow_ctrl_pass_unittest.cc+33-0
@@ -447,4 +447,37 @@ TEST_F(UtestGraphPassesFlowCtrlPass, multi_iter_success) {
447 EXPECT_EQ(ret, SUCCESS);447 EXPECT_EQ(ret, SUCCESS);
448 EXPECT_EQ(graph->GetDirectNodesSize(), 8);448 EXPECT_EQ(graph->GetDirectNodesSize(), 8);
449}449}
450+ 
451+TEST_F(UtestGraphPassesFlowCtrlPass, check_multi_dataset_true) {
452+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_multi_dataset");
453+ GeTensorDesc tensor_desc;
454+ auto iter1_desc = std::make_shared<OpDesc>("iter1", FRAMEWORKOP);
455+ iter1_desc->AddOutputDesc(tensor_desc);
456+ AttrUtils::SetStr(iter1_desc, ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, "IteratorV2");
457+ graph->AddNode(iter1_desc);
458+ 
459+ auto iter2_desc = std::make_shared<OpDesc>("iter2", FRAMEWORKOP);
460+ iter2_desc->AddOutputDesc(tensor_desc);
461+ AttrUtils::SetStr(iter2_desc, ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, "IteratorV2");
462+ graph->AddNode(iter2_desc);
463+ 
464+ FlowCtrlPass flow_ctrl_pass;
465+ EXPECT_EQ(flow_ctrl_pass.CheckMultiDataSet(graph), true);
466+}
467+ 
468+TEST_F(UtestGraphPassesFlowCtrlPass, check_multi_dataset_false) {
469+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_single_dataset");
470+ GeTensorDesc tensor_desc;
471+ auto iter1_desc = std::make_shared<OpDesc>("iter1", FRAMEWORKOP);
472+ iter1_desc->AddOutputDesc(tensor_desc);
473+ AttrUtils::SetStr(iter1_desc, ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, "IteratorV2");
474+ graph->AddNode(iter1_desc);
475+ 
476+ auto normal_desc = std::make_shared<OpDesc>("normal", DATA);
477+ normal_desc->AddOutputDesc(tensor_desc);
478+ graph->AddNode(normal_desc);
479+ 
480+ FlowCtrlPass flow_ctrl_pass;
481+ EXPECT_EQ(flow_ctrl_pass.CheckMultiDataSet(graph), false);
482+}
450} // namespace ge483} // namespace ge
Mtests/ge/ut/ge/graph/passes/folding_kernel/add_kernel_unittest.cc+350-0
@@ -357,3 +357,353 @@ TEST_F(UtestFoldingKernelAddKernel, ComputeComplex64OverflowFailed) {
357 Status status = kernel->Compute(op_desc_ptr, input, v_output);357 Status status = kernel->Compute(op_desc_ptr, input, v_output);
358 EXPECT_NE(status, SUCCESS);358 EXPECT_NE(status, SUCCESS);
359}359}
360+ 
361+TEST_F(UtestFoldingKernelAddKernel, AddInt8Success) {
362+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
363+ GeTensorDesc output_desc1;
364+ op_desc_ptr->AddOutputDesc("y", output_desc1);
365+ 
366+ vector<int64_t> dims_vec_0 = {2};
367+ vector<int8_t> data_vec_0 = {2, 3};
368+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT8);
369+ ConstGeTensorPtr tensor_0 =
370+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int8_t));
371+ 
372+ vector<int64_t> dims_vec_1 = {2};
373+ vector<int8_t> data_vec_1 = {5, 6};
374+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT8);
375+ ConstGeTensorPtr tensor_1 =
376+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int8_t));
377+ 
378+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
379+ vector<GeTensorPtr> v_output;
380+ 
381+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
382+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
383+ EXPECT_EQ(status, SUCCESS);
384+}
385+ 
386+TEST_F(UtestFoldingKernelAddKernel, AddInt16Success) {
387+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
388+ GeTensorDesc output_desc1;
389+ op_desc_ptr->AddOutputDesc("y", output_desc1);
390+ 
391+ vector<int64_t> dims_vec_0 = {2};
392+ vector<int16_t> data_vec_0 = {2, 3};
393+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT16);
394+ ConstGeTensorPtr tensor_0 =
395+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int16_t));
396+ 
397+ vector<int64_t> dims_vec_1 = {2};
398+ vector<int16_t> data_vec_1 = {5, 6};
399+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT16);
400+ ConstGeTensorPtr tensor_1 =
401+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int16_t));
402+ 
403+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
404+ vector<GeTensorPtr> v_output;
405+ 
406+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
407+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
408+ EXPECT_EQ(status, SUCCESS);
409+}
410+ 
411+TEST_F(UtestFoldingKernelAddKernel, AddInt32Success) {
412+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
413+ GeTensorDesc output_desc1;
414+ op_desc_ptr->AddOutputDesc("y", output_desc1);
415+ 
416+ vector<int64_t> dims_vec_0 = {2};
417+ vector<int32_t> data_vec_0 = {2, 3};
418+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
419+ ConstGeTensorPtr tensor_0 =
420+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
421+ 
422+ vector<int64_t> dims_vec_1 = {2};
423+ vector<int32_t> data_vec_1 = {5, 6};
424+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
425+ ConstGeTensorPtr tensor_1 =
426+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
427+ 
428+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
429+ vector<GeTensorPtr> v_output;
430+ 
431+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
432+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
433+ EXPECT_EQ(status, SUCCESS);
434+}
435+ 
436+TEST_F(UtestFoldingKernelAddKernel, AddInt64Success) {
437+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
438+ GeTensorDesc output_desc1;
439+ op_desc_ptr->AddOutputDesc("y", output_desc1);
440+ 
441+ vector<int64_t> dims_vec_0 = {2};
442+ vector<int64_t> data_vec_0 = {2, 3};
443+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT64);
444+ ConstGeTensorPtr tensor_0 =
445+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int64_t));
446+ 
447+ vector<int64_t> dims_vec_1 = {2};
448+ vector<int64_t> data_vec_1 = {5, 6};
449+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT64);
450+ ConstGeTensorPtr tensor_1 =
451+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int64_t));
452+ 
453+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
454+ vector<GeTensorPtr> v_output;
455+ 
456+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
457+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
458+ EXPECT_EQ(status, SUCCESS);
459+}
460+ 
461+TEST_F(UtestFoldingKernelAddKernel, AddUint8Success) {
462+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
463+ GeTensorDesc output_desc1;
464+ op_desc_ptr->AddOutputDesc("y", output_desc1);
465+ 
466+ vector<int64_t> dims_vec_0 = {2};
467+ vector<uint8_t> data_vec_0 = {2, 3};
468+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT8);
469+ ConstGeTensorPtr tensor_0 =
470+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint8_t));
471+ 
472+ vector<int64_t> dims_vec_1 = {2};
473+ vector<uint8_t> data_vec_1 = {5, 6};
474+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT8);
475+ ConstGeTensorPtr tensor_1 =
476+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint8_t));
477+ 
478+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
479+ vector<GeTensorPtr> v_output;
480+ 
481+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
482+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
483+ EXPECT_EQ(status, SUCCESS);
484+}
485+ 
486+TEST_F(UtestFoldingKernelAddKernel, AddUint16Success) {
487+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
488+ GeTensorDesc output_desc1;
489+ op_desc_ptr->AddOutputDesc("y", output_desc1);
490+ 
491+ vector<int64_t> dims_vec_0 = {2};
492+ vector<uint16_t> data_vec_0 = {2, 3};
493+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT16);
494+ ConstGeTensorPtr tensor_0 =
495+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint16_t));
496+ 
497+ vector<int64_t> dims_vec_1 = {2};
498+ vector<uint16_t> data_vec_1 = {5, 6};
499+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT16);
500+ ConstGeTensorPtr tensor_1 =
501+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint16_t));
502+ 
503+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
504+ vector<GeTensorPtr> v_output;
505+ 
506+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
507+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
508+ EXPECT_EQ(status, SUCCESS);
509+}
510+ 
511+TEST_F(UtestFoldingKernelAddKernel, AddUint32Success) {
512+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
513+ GeTensorDesc output_desc1;
514+ op_desc_ptr->AddOutputDesc("y", output_desc1);
515+ 
516+ vector<int64_t> dims_vec_0 = {2};
517+ vector<uint32_t> data_vec_0 = {2, 3};
518+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT32);
519+ ConstGeTensorPtr tensor_0 =
520+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint32_t));
521+ 
522+ vector<int64_t> dims_vec_1 = {2};
523+ vector<uint32_t> data_vec_1 = {5, 6};
524+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT32);
525+ ConstGeTensorPtr tensor_1 =
526+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint32_t));
527+ 
528+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
529+ vector<GeTensorPtr> v_output;
530+ 
531+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
532+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
533+ EXPECT_EQ(status, SUCCESS);
534+}
535+ 
536+TEST_F(UtestFoldingKernelAddKernel, AddUint64Success) {
537+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
538+ GeTensorDesc output_desc1;
539+ op_desc_ptr->AddOutputDesc("y", output_desc1);
540+ 
541+ vector<int64_t> dims_vec_0 = {2};
542+ vector<uint64_t> data_vec_0 = {2, 3};
543+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT64);
544+ ConstGeTensorPtr tensor_0 =
545+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint64_t));
546+ 
547+ vector<int64_t> dims_vec_1 = {2};
548+ vector<uint64_t> data_vec_1 = {5, 6};
549+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT64);
550+ ConstGeTensorPtr tensor_1 =
551+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint64_t));
552+ 
553+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
554+ vector<GeTensorPtr> v_output;
555+ 
556+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
557+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
558+ EXPECT_EQ(status, SUCCESS);
559+}
560+ 
561+TEST_F(UtestFoldingKernelAddKernel, AddFloat16Success) {
562+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
563+ GeTensorDesc output_desc1;
564+ op_desc_ptr->AddOutputDesc("y", output_desc1);
565+ 
566+ vector<int64_t> dims_vec_0 = {2};
567+ vector<fp16_t> data_vec_0 = {2, 3};
568+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT16);
569+ ConstGeTensorPtr tensor_0 =
570+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(fp16_t));
571+ 
572+ vector<int64_t> dims_vec_1 = {2};
573+ vector<fp16_t> data_vec_1 = {5, 6};
574+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_FLOAT16);
575+ ConstGeTensorPtr tensor_1 =
576+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(fp16_t));
577+ 
578+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
579+ vector<GeTensorPtr> v_output;
580+ 
581+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
582+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
583+ EXPECT_EQ(status, SUCCESS);
584+}
585+ 
586+TEST_F(UtestFoldingKernelAddKernel, AddFloatWithOutputSuccess) {
587+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
588+ GeTensorDesc output_desc1;
589+ op_desc_ptr->AddOutputDesc("y", output_desc1);
590+ 
591+ vector<int64_t> dims_vec_0 = {4};
592+ vector<float> data_vec_0 = {1.0, 2.0, 3.0, 4.0};
593+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT);
594+ ConstGeTensorPtr tensor_0 =
595+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(float));
596+ 
597+ vector<int64_t> dims_vec_1;
598+ vector<float> data_vec_1 = {1.0};
599+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_FLOAT);
600+ ConstGeTensorPtr tensor_1 =
601+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(float));
602+ 
603+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
604+ vector<GeTensorPtr> v_output;
605+ 
606+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
607+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
608+ EXPECT_EQ(status, SUCCESS);
609+}
610+ 
611+TEST_F(UtestFoldingKernelAddKernel, AddDoubleSuccess) {
612+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
613+ GeTensorDesc output_desc1;
614+ op_desc_ptr->AddOutputDesc("y", output_desc1);
615+ 
616+ vector<int64_t> dims_vec_0 = {2};
617+ vector<double> data_vec_0 = {2.0, 3.0};
618+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_DOUBLE);
619+ ConstGeTensorPtr tensor_0 =
620+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(double));
621+ 
622+ vector<int64_t> dims_vec_1 = {2};
623+ vector<double> data_vec_1 = {5.0, 6.0};
624+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_DOUBLE);
625+ ConstGeTensorPtr tensor_1 =
626+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(double));
627+ 
628+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
629+ vector<GeTensorPtr> v_output;
630+ 
631+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
632+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
633+ EXPECT_EQ(status, SUCCESS);
634+}
635+ 
636+TEST_F(UtestFoldingKernelAddKernel, AddUnsupportedDataType) {
637+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
638+ GeTensorDesc output_desc1;
639+ op_desc_ptr->AddOutputDesc("y", output_desc1);
640+ 
641+ vector<int64_t> dims_vec_0 = {2};
642+ vector<int64_t> data_vec_0 = {2, 3};
643+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_BOOL);
644+ ConstGeTensorPtr tensor_0 =
645+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int64_t));
646+ 
647+ vector<int64_t> dims_vec_1 = {2};
648+ vector<int64_t> data_vec_1 = {5, 6};
649+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_BOOL);
650+ ConstGeTensorPtr tensor_1 =
651+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int64_t));
652+ 
653+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
654+ vector<GeTensorPtr> v_output;
655+ 
656+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
657+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
658+ EXPECT_EQ(status, NOT_CHANGED);
659+}
660+ 
661+TEST_F(UtestFoldingKernelAddKernel, AddEmptyDataSameType) {
662+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
663+ GeTensorDesc output_desc1;
664+ op_desc_ptr->AddOutputDesc("y", output_desc1);
665+ 
666+ vector<int64_t> dims_vec_0 = {2};
667+ vector<int32_t> data_vec_0 = {};
668+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
669+ ConstGeTensorPtr tensor_0 =
670+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
671+ 
672+ vector<int64_t> dims_vec_1 = {2};
673+ vector<int32_t> data_vec_1 = {5, 6};
674+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
675+ ConstGeTensorPtr tensor_1 =
676+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
677+ 
678+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
679+ vector<GeTensorPtr> v_output;
680+ 
681+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
682+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
683+ EXPECT_EQ(status, NOT_CHANGED);
684+}
685+ 
686+TEST_F(UtestFoldingKernelAddKernel, AddInt32OverflowFailed) {
687+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Add", ADD);
688+ GeTensorDesc output_desc1;
689+ op_desc_ptr->AddOutputDesc("y", output_desc1);
690+ 
691+ vector<int64_t> dims_vec_0 = {1};
692+ vector<int32_t> data_vec_0 = {std::numeric_limits<int32_t>::max()};
693+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
694+ ConstGeTensorPtr tensor_0 =
695+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
696+ 
697+ vector<int64_t> dims_vec_1 = {1};
698+ vector<int32_t> data_vec_1 = {std::numeric_limits<int32_t>::max()};
699+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
700+ ConstGeTensorPtr tensor_1 =
701+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
702+ 
703+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
704+ vector<GeTensorPtr> v_output;
705+ 
706+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(ADD);
707+ Status status = kernel->Compute(op_desc_ptr, input, v_output);
708+ EXPECT_NE(status, SUCCESS);
709+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/dynamic_stitch_kernel_unittest.cc+40-0
@@ -323,3 +323,43 @@ TEST_F(UtestGraphPassesFoldingKernelDynamicStitchKernel, RepeatedIndiceInt64Succ
323 EXPECT_EQ(output_data[2], 8);323 EXPECT_EQ(output_data[2], 8);
324 EXPECT_EQ(output_data[3], 6);324 EXPECT_EQ(output_data[3], 6);
325}325}
326+ 
327+TEST_F(UtestGraphPassesFoldingKernelDynamicStitchKernel, NullOpDesc) {
328+ vector<int64_t> dims_vec_0 = {2};
329+ vector<int32_t> data_vec_0 = {0, 1};
330+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
331+ ConstGeTensorPtr tensor_0 =
332+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
333+ 
334+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_0, tensor_0, tensor_0};
335+ vector<GeTensorPtr> outputs;
336+ 
337+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(DYNAMICSTITCH);
338+ Status status = kernel->Compute(nullptr, input, outputs);
339+ EXPECT_EQ(NOT_CHANGED, status);
340+}
341+ 
342+TEST_F(UtestGraphPassesFoldingKernelDynamicStitchKernel, NullInputTensor) {
343+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("dynamicstitch", "DynamicStitch");
344+ AttrUtils::SetInt(op_desc_ptr, "N", (int64_t)2);
345+ 
346+ vector<int64_t> dims_vec_0 = {2};
347+ vector<int32_t> data_vec_0 = {0, 1};
348+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
349+ ConstGeTensorPtr tensor_0 =
350+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
351+ 
352+ GeTensorDesc dims_tensor_desc(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
353+ op_desc_ptr->AddInputDesc(dims_tensor_desc);
354+ op_desc_ptr->AddInputDesc(dims_tensor_desc);
355+ op_desc_ptr->AddInputDesc(dims_tensor_desc);
356+ op_desc_ptr->AddInputDesc(dims_tensor_desc);
357+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
358+ 
359+ vector<ConstGeTensorPtr> input = {nullptr, nullptr, tensor_0, tensor_0};
360+ vector<GeTensorPtr> outputs;
361+ 
362+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(DYNAMICSTITCH);
363+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
364+ EXPECT_NE(ge::SUCCESS, status);
365+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/floordiv_kernel_unittest.cc+154-0
@@ -498,3 +498,157 @@ TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, DoubleSuccess) {
498 Status status = kernel->Compute(op_desc_ptr, input, outputs);498 Status status = kernel->Compute(op_desc_ptr, input, outputs);
499 EXPECT_EQ(SUCCESS, status);499 EXPECT_EQ(SUCCESS, status);
500}500}
501+ 
502+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, Uint8VectorVectorSuccess) {
503+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
504+ 
505+ vector<int64_t> dims_vec_0 = {2, 3};
506+ vector<uint8_t> data_vec_0 = {1, 6, 32, 9, 10, 7};
507+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT8);
508+ ConstGeTensorPtr tensor_0 =
509+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint8_t));
510+ 
511+ vector<int64_t> dims_vec_1 = {2, 3};
512+ vector<uint8_t> data_vec_1 = {2, 9, 9, 9, 9, 9};
513+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT8);
514+ ConstGeTensorPtr tensor_1 =
515+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint8_t));
516+ 
517+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
518+ vector<GeTensorPtr> outputs;
519+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
520+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
521+ EXPECT_EQ(SUCCESS, status);
522+}
523+ 
524+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, Int8VectorVectorSuccess) {
525+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
526+ 
527+ vector<int64_t> dims_vec_0 = {2, 3};
528+ vector<int8_t> data_vec_0 = {1, 6, 32, 9, -10, -7};
529+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT8);
530+ ConstGeTensorPtr tensor_0 =
531+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int8_t));
532+ 
533+ vector<int64_t> dims_vec_1 = {2, 3};
534+ vector<int8_t> data_vec_1 = {2, -9, -9, -9, -9, -9};
535+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT8);
536+ ConstGeTensorPtr tensor_1 =
537+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int8_t));
538+ 
539+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
540+ vector<GeTensorPtr> outputs;
541+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
542+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
543+ EXPECT_EQ(SUCCESS, status);
544+}
545+ 
546+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, Uint16VectorVectorSuccess) {
547+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
548+ 
549+ vector<int64_t> dims_vec_0 = {2, 3};
550+ vector<uint16_t> data_vec_0 = {1, 6, 32, 9, 10, 7};
551+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT16);
552+ ConstGeTensorPtr tensor_0 =
553+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint16_t));
554+ 
555+ vector<int64_t> dims_vec_1 = {2, 3};
556+ vector<uint16_t> data_vec_1 = {2, 9, 9, 9, 9, 9};
557+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT16);
558+ ConstGeTensorPtr tensor_1 =
559+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint16_t));
560+ 
561+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
562+ vector<GeTensorPtr> outputs;
563+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
564+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
565+ EXPECT_EQ(SUCCESS, status);
566+}
567+ 
568+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, Int16VectorVectorSuccess) {
569+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
570+ 
571+ vector<int64_t> dims_vec_0 = {2, 3};
572+ vector<int16_t> data_vec_0 = {1, 6, 32, 9, -10, -7};
573+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT16);
574+ ConstGeTensorPtr tensor_0 =
575+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int16_t));
576+ 
577+ vector<int64_t> dims_vec_1 = {2, 3};
578+ vector<int16_t> data_vec_1 = {2, -9, -9, -9, -9, -9};
579+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT16);
580+ ConstGeTensorPtr tensor_1 =
581+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int16_t));
582+ 
583+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
584+ vector<GeTensorPtr> outputs;
585+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
586+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
587+ EXPECT_EQ(SUCCESS, status);
588+}
589+ 
590+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, UnsupportedTypeSameTypeFailed) {
591+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
592+ 
593+ vector<int64_t> dims_vec_0 = {2};
594+ vector<uint32_t> data_vec_0 = {3, 36};
595+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_UINT32);
596+ ConstGeTensorPtr tensor_0 =
597+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(uint32_t));
598+ 
599+ vector<int64_t> dims_vec_1 = {2};
600+ vector<uint32_t> data_vec_1 = {2, 9};
601+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_UINT32);
602+ ConstGeTensorPtr tensor_1 =
603+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(uint32_t));
604+ 
605+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
606+ vector<GeTensorPtr> outputs;
607+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
608+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
609+ EXPECT_EQ(NOT_CHANGED, status);
610+}
611+ 
612+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, FloatZeroBroadcastFailed) {
613+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
614+ 
615+ vector<int64_t> dims_vec_0 = {2, 3};
616+ vector<float> data_vec_0 = {1, 6, 32, 9, 10, 7};
617+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT);
618+ ConstGeTensorPtr tensor_0 =
619+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(float));
620+ 
621+ vector<int64_t> dims_vec_1 = {};
622+ vector<float> data_vec_1 = {0.0};
623+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_FLOAT);
624+ ConstGeTensorPtr tensor_1 =
625+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(float));
626+ 
627+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
628+ vector<GeTensorPtr> outputs;
629+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
630+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
631+ EXPECT_EQ(NOT_CHANGED, status);
632+}
633+ 
634+TEST_F(UtestGraphPassedFoldingKernelFloorDivKernel, DoubleZeroBroadcastFailed) {
635+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("floor_div", FLOORDIV);
636+ 
637+ vector<int64_t> dims_vec_0 = {2, 3};
638+ vector<double> data_vec_0 = {1, 6, 32, 9, 10, 7};
639+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_DOUBLE);
640+ ConstGeTensorPtr tensor_0 =
641+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(double));
642+ 
643+ vector<int64_t> dims_vec_1 = {};
644+ vector<double> data_vec_1 = {0.0};
645+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_DOUBLE);
646+ ConstGeTensorPtr tensor_1 =
647+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(double));
648+ 
649+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
650+ vector<GeTensorPtr> outputs;
651+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(FLOORDIV);
652+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
653+ EXPECT_EQ(NOT_CHANGED, status);
654+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/gather_v2_kernel_unittest.cc+30-0
@@ -1220,3 +1220,33 @@ TEST_F(UtestGraphPassesFoldingKernelGatherV2Kernel, CovOutputZeroDim) {
1220 ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);1220 ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);
1221 EXPECT_NE(ge::SUCCESS, status);1221 EXPECT_NE(ge::SUCCESS, status);
1222}1222}
1223+ 
1224+TEST_F(UtestGraphPassesFoldingKernelGatherV2Kernel, UnsupportedDataType) {
1225+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("GatherV2", "GatherV2");
1226+ 
1227+ vector<int64_t> x_shape = {3};
1228+ vector<int64_t> indices_shape = {1};
1229+ GeTensorDesc tensor_desc_x(GeShape(x_shape), FORMAT_NHWC, DT_BOOL);
1230+ GeTensorDesc tensor_desc_indices(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1231+ GeTensorDesc tensor_desc_axis(GeShape(), FORMAT_NHWC, DT_INT32);
1232+ op_desc_ptr->AddInputDesc(0, tensor_desc_x);
1233+ op_desc_ptr->AddInputDesc(1, tensor_desc_indices);
1234+ op_desc_ptr->AddInputDesc(2, tensor_desc_axis);
1235+ 
1236+ vector<int32_t> data_vec_0 = {1, 2, 3};
1237+ vector<int32_t> data_vec_1 = {0};
1238+ vector<int32_t> axis_vec = {0};
1239+ ConstGeTensorPtr tensor_0 =
1240+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
1241+ ConstGeTensorPtr tensor_1 = std::make_shared<GeTensor>(tensor_desc_indices, (uint8_t *)data_vec_1.data(),
1242+ data_vec_1.size() * sizeof(int32_t));
1243+ ConstGeTensorPtr tensor_2 =
1244+ std::make_shared<GeTensor>(tensor_desc_axis, (uint8_t *)axis_vec.data(), axis_vec.size() * sizeof(int32_t));
1245+ 
1246+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2};
1247+ vector<GeTensorPtr> outputs;
1248+ 
1249+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(GATHERV2);
1250+ ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);
1251+ EXPECT_EQ(ge::NOT_CHANGED, status);
1252+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/kernel_utils_unittest.cc+38-0
@@ -70,3 +70,41 @@ TEST_F(UtestGraphPassesFoldingKernelkernelUtils, IsUnknownShape) {
70 GeShape dynamic_shape(shape);70 GeShape dynamic_shape(shape);
71 EXPECT_EQ(KernelUtils::IsUnknownShape(dynamic_shape), true);71 EXPECT_EQ(KernelUtils::IsUnknownShape(dynamic_shape), true);
72}72}
73+ 
74+TEST_F(UtestGraphPassesFoldingKernelkernelUtils, ConstructTensorDescWithUnsupportedDataType) {
75+ vector<int64_t> data = {1, 2, 3};
76+ GeTensorDesc tensor_desc(GeShape({3}), FORMAT_NCHW, DT_FLOAT);
77+ vector<GeTensorPtr> outputs;
78+ Status status = KernelUtils::ConstructTensorDescWithData(tensor_desc, data, outputs, false);
79+ EXPECT_EQ(PARAM_INVALID, status);
80+}
81+ 
82+TEST_F(UtestGraphPassesFoldingKernelkernelUtils, CheckSizeForTransOpUnsupportedDataType) {
83+ vector<int64_t> dims_vec_0 = {2};
84+ vector<float> data_vec_0 = {1.0, 2.0};
85+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_BOOL);
86+ ConstGeTensorPtr tensor_0 =
87+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(float));
88+ 
89+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("TransOp", "TransOp");
90+ GeTensorDesc output_desc(GeShape(dims_vec_0), FORMAT_NCHW, DT_BOOL);
91+ op_desc_ptr->AddOutputDesc(output_desc);
92+ 
93+ bool ret = KernelUtils::CheckSizeForTransOp(tensor_0, op_desc_ptr);
94+ EXPECT_EQ(false, ret);
95+}
96+ 
97+TEST_F(UtestGraphPassesFoldingKernelkernelUtils, CheckSizeForTransOpSizeMismatch) {
98+ vector<int64_t> dims_vec_0 = {4};
99+ vector<int32_t> data_vec_0 = {1, 2};
100+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
101+ ConstGeTensorPtr tensor_0 =
102+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
103+ 
104+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("TransOp", "TransOp");
105+ GeTensorDesc output_desc(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
106+ op_desc_ptr->AddOutputDesc(output_desc);
107+ 
108+ bool ret = KernelUtils::CheckSizeForTransOp(tensor_0, op_desc_ptr);
109+ EXPECT_EQ(false, ret);
110+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/mul_kernel_unittest.cc+45-2
@@ -515,6 +515,7 @@ TEST_F(UtestGraphPassesFoldingKernelMulKernel, Complex64_Overflow_Failed) {
515}515}
516 516 
517TEST_F(UtestGraphPassesFoldingKernelMulKernel, MulNullOpDesc) {517TEST_F(UtestGraphPassesFoldingKernelMulKernel, MulNullOpDesc) {
518+ OpDescPtr op_desc_ptr = nullptr;
518 vector<int64_t> dims_vec_0 = {2};519 vector<int64_t> dims_vec_0 = {2};
519 vector<int32_t> data_vec_0 = {3, 4};520 vector<int32_t> data_vec_0 = {3, 4};
520 GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);521 GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
@@ -531,8 +532,50 @@ TEST_F(UtestGraphPassesFoldingKernelMulKernel, MulNullOpDesc) {
531 vector<GeTensorPtr> outputs;532 vector<GeTensorPtr> outputs;
532 533 
533 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(MUL);534 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(MUL);
534- Status status = kernel->Compute(nullptr, input, outputs);535+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
535- EXPECT_EQ(PARAM_INVALID, status);536+ EXPECT_NE(SUCCESS, status);
537+}
538+ 
539+TEST_F(UtestGraphPassesFoldingKernelMulKernel, Float16OneDSuccess) {
540+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Mul", "Mul");
541+ 
542+ vector<int64_t> dims_vec_0 = {2};
543+ vector<fp16_t> data_vec_0 = {2, 3};
544+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT16);
545+ ConstGeTensorPtr tensor_0 =
546+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(fp16_t));
547+ vector<int64_t> dims_vec_1 = {2};
548+ vector<fp16_t> data_vec_1 = {5, 6};
549+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_FLOAT16);
550+ ConstGeTensorPtr tensor_1 =
551+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(fp16_t));
552+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
553+ vector<GeTensorPtr> outputs;
554+ 
555+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(MUL);
556+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
557+ EXPECT_EQ(SUCCESS, status);
558+}
559+ 
560+TEST_F(UtestGraphPassesFoldingKernelMulKernel, UnsupportedDataType) {
561+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("Mul", "Mul");
562+ 
563+ vector<int64_t> dims_vec_0 = {2};
564+ vector<int64_t> data_vec_0 = {2, 3};
565+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_BOOL);
566+ ConstGeTensorPtr tensor_0 =
567+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int64_t));
568+ vector<int64_t> dims_vec_1 = {2};
569+ vector<int64_t> data_vec_1 = {5, 6};
570+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_BOOL);
571+ ConstGeTensorPtr tensor_1 =
572+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int64_t));
573+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
574+ vector<GeTensorPtr> outputs;
575+ 
576+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(MUL);
577+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
578+ EXPECT_EQ(NOT_CHANGED, status);
536}579}
537 580 
538TEST_F(UtestGraphPassesFoldingKernelMulKernel, MulInputNumberNotMatch) {581TEST_F(UtestGraphPassesFoldingKernelMulKernel, MulInputNumberNotMatch) {
Mtests/ge/ut/ge/graph/passes/folding_kernel/pack_kernel_unittest.cc+163-0
@@ -373,3 +373,166 @@ TEST_F(UtestGraphPassesFoldingKernelPackKernel, PackOptimizerFailedErrtype) {
373 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);373 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
374 EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);374 EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
375}375}
376+ 
377+TEST_F(UtestGraphPassesFoldingKernelPackKernel, AxisOutOfRange) {
378+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
379+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
380+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)5);
381+ 
382+ vector<int64_t> dims_vec_0;
383+ vector<int32_t> data_vec_0 = {0};
384+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
385+ ConstGeTensorPtr tensor_0 =
386+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
387+ 
388+ vector<int64_t> dims_vec_1;
389+ vector<int32_t> data_vec_1 = {0};
390+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
391+ ConstGeTensorPtr tensor_1 =
392+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
393+ 
394+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
395+ vector<GeTensorPtr> outputs;
396+ 
397+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
398+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
399+ EXPECT_EQ(NOT_CHANGED, status);
400+}
401+ 
402+TEST_F(UtestGraphPassesFoldingKernelPackKernel, NullInput) {
403+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
404+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
405+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)0);
406+ 
407+ vector<int64_t> dims_vec_0;
408+ vector<int32_t> data_vec_0 = {0};
409+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
410+ ConstGeTensorPtr tensor_0 =
411+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
412+ 
413+ vector<ConstGeTensorPtr> input = {tensor_0, nullptr};
414+ vector<GeTensorPtr> outputs;
415+ 
416+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
417+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
418+ EXPECT_EQ(NOT_CHANGED, status);
419+}
420+ 
421+TEST_F(UtestGraphPassesFoldingKernelPackKernel, EmptyInput) {
422+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
423+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
424+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)0);
425+ 
426+ vector<ConstGeTensorPtr> input = {};
427+ vector<GeTensorPtr> outputs;
428+ 
429+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
430+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
431+ EXPECT_EQ(NOT_CHANGED, status);
432+}
433+ 
434+TEST_F(UtestGraphPassesFoldingKernelPackKernel, ShapeMismatch) {
435+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
436+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
437+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)0);
438+ 
439+ vector<int64_t> dims_vec_0 = {2};
440+ vector<int32_t> data_vec_0 = {1, 2};
441+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
442+ ConstGeTensorPtr tensor_0 =
443+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
444+ 
445+ vector<int64_t> dims_vec_1 = {3};
446+ vector<int32_t> data_vec_1 = {1, 2, 3};
447+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
448+ ConstGeTensorPtr tensor_1 =
449+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
450+ 
451+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
452+ vector<GeTensorPtr> outputs;
453+ 
454+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
455+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
456+ EXPECT_EQ(NOT_CHANGED, status);
457+}
458+ 
459+TEST_F(UtestGraphPassesFoldingKernelPackKernel, EmptyDataWithShape) {
460+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
461+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
462+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)0);
463+ 
464+ vector<int64_t> dims_vec_0 = {2};
465+ vector<int32_t> data_vec_0 = {1, 2};
466+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
467+ ConstGeTensorPtr tensor_0 =
468+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
469+ 
470+ vector<int64_t> dims_vec_1 = {2};
471+ vector<int32_t> data_vec_1 = {};
472+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
473+ ConstGeTensorPtr tensor_1 =
474+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
475+ 
476+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
477+ vector<GeTensorPtr> outputs;
478+ 
479+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
480+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
481+ EXPECT_EQ(NOT_CHANGED, status);
482+}
483+ 
484+TEST_F(UtestGraphPassesFoldingKernelPackKernel, AxisMiddleWithMultiDimSuccess) {
485+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
486+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
487+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)1);
488+ 
489+ vector<int64_t> dims_vec_0 = {2, 3};
490+ vector<int32_t> data_vec_0 = {1, 2, 3, 4, 5, 6};
491+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
492+ ConstGeTensorPtr tensor_0 =
493+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
494+ 
495+ vector<int64_t> dims_vec_1 = {2, 3};
496+ vector<int32_t> data_vec_1 = {7, 8, 9, 10, 11, 12};
497+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
498+ ConstGeTensorPtr tensor_1 =
499+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
500+ 
501+ GeTensorDesc dims_tensor_desc(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
502+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
503+ 
504+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
505+ vector<GeTensorPtr> outputs;
506+ 
507+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
508+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
509+ EXPECT_EQ(SUCCESS, status);
510+}
511+ 
512+TEST_F(UtestGraphPassesFoldingKernelPackKernel, ZeroInShapeSuccess) {
513+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("pack", "Pack");
514+ AttrUtils::SetInt(op_desc_ptr, PACK_ATTR_NAME_NUM, (int64_t)2);
515+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_AXIS, (int64_t)0);
516+ 
517+ vector<int64_t> dims_vec_0 = {0};
518+ vector<int32_t> data_vec_0 = {};
519+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
520+ ConstGeTensorPtr tensor_0 =
521+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
522+ 
523+ vector<int64_t> dims_vec_1 = {0};
524+ vector<int32_t> data_vec_1 = {};
525+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
526+ ConstGeTensorPtr tensor_1 =
527+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
528+ 
529+ GeTensorDesc dims_tensor_desc(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
530+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
531+ 
532+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
533+ vector<GeTensorPtr> outputs;
534+ 
535+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(PACK);
536+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
537+ EXPECT_EQ(SUCCESS, status);
538+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/reduce_prod_kernel_unittest.cc+121-0
@@ -186,3 +186,124 @@ TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, OverflowDataNotChanged) {
186 186 
187 EXPECT_EQ(NOT_CHANGED, status);187 EXPECT_EQ(NOT_CHANGED, status);
188}188}
189+ 
190+TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, Int32AxisOutOfRange) {
191+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("ReduceProd", REDUCEPROD);
192+ 
193+ vector<int64_t> dims_vec_0 = {2, 3};
194+ vector<int32_t> data_vec_0 = {1, 2, 5, 7, 3, 1};
195+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
196+ ConstGeTensorPtr tensor_0 =
197+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
198+ 
199+ vector<int64_t> dims_vec_1 = {1};
200+ vector<int32_t> data_vec_1 = {3};
201+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
202+ ConstGeTensorPtr tensor_1 =
203+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
204+ 
205+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
206+ vector<GeTensorPtr> outputs;
207+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(REDUCEPROD);
208+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
209+ EXPECT_EQ(NOT_CHANGED, status);
210+}
211+ 
212+TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, Int32KeepDimsSuccess) {
213+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("ReduceProd", REDUCEPROD);
214+ AttrUtils::SetBool(op_desc_ptr, "keep_dims", true);
215+ 
216+ vector<int64_t> dims_vec_0 = {2, 3};
217+ vector<int32_t> data_vec_0 = {1, 2, 5, 7, 3, 1};
218+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
219+ ConstGeTensorPtr tensor_0 =
220+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
221+ 
222+ vector<int64_t> dims_vec_1 = {1};
223+ vector<int32_t> data_vec_1 = {0};
224+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
225+ ConstGeTensorPtr tensor_1 =
226+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
227+ 
228+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
229+ vector<GeTensorPtr> outputs;
230+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(REDUCEPROD);
231+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
232+ EXPECT_EQ(SUCCESS, status);
233+}
234+ 
235+TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, Int32ComputeNoAxisSuccess) {
236+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("ReduceProd", REDUCEPROD);
237+ 
238+ vector<int64_t> dims_vec_0 = {2, 3};
239+ vector<int32_t> data_vec_0 = {1, 2, 5, 7, 3, 1};
240+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
241+ ConstGeTensorPtr tensor_0 =
242+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
243+ 
244+ vector<ConstGeTensorPtr> input = {tensor_0};
245+ vector<GeTensorPtr> outputs;
246+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(REDUCEPROD);
247+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
248+ EXPECT_EQ(SUCCESS, status);
249+}
250+ 
251+TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, Int32EmptyAxisSuccess) {
252+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("ReduceProd", REDUCEPROD);
253+ 
254+ vector<int64_t> dims_vec_0 = {2, 3};
255+ vector<int32_t> data_vec_0 = {1, 2, 5, 7, 3, 1};
256+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
257+ ConstGeTensorPtr tensor_0 =
258+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
259+ 
260+ vector<int64_t> dims_vec_1 = {1};
261+ vector<int32_t> data_vec_1 = {};
262+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
263+ ConstGeTensorPtr tensor_1 =
264+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
265+ 
266+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
267+ vector<GeTensorPtr> outputs;
268+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(REDUCEPROD);
269+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
270+ EXPECT_EQ(SUCCESS, status);
271+}
272+ 
273+TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, Int32OverflowFailed) {
274+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("ReduceProd", REDUCEPROD);
275+ 
276+ vector<int64_t> dims_vec_0 = {2};
277+ vector<int32_t> data_vec_0 = {std::numeric_limits<int32_t>::max(), 2};
278+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
279+ ConstGeTensorPtr tensor_0 =
280+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
281+ 
282+ vector<int64_t> dims_vec_1 = {1};
283+ vector<int32_t> data_vec_1 = {0};
284+ GeTensorDesc tensor_desc_1(GeShape(dims_vec_1), FORMAT_NCHW, DT_INT32);
285+ ConstGeTensorPtr tensor_1 =
286+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
287+ 
288+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1};
289+ vector<GeTensorPtr> outputs;
290+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(REDUCEPROD);
291+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
292+ EXPECT_EQ(NOT_CHANGED, status);
293+}
294+ 
295+TEST_F(UtestGraphPassesFoldingKernelReduceProdKernel, Int32ComputeNoAxisEmptyData) {
296+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("ReduceProd", REDUCEPROD);
297+ 
298+ vector<int64_t> dims_vec_0 = {2};
299+ vector<int32_t> data_vec_0 = {};
300+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
301+ ConstGeTensorPtr tensor_0 =
302+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
303+ 
304+ vector<ConstGeTensorPtr> input = {tensor_0};
305+ vector<GeTensorPtr> outputs;
306+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(REDUCEPROD);
307+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
308+ EXPECT_EQ(NOT_CHANGED, status);
309+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/rsqrt_kernel_unittest.cc+78-0
@@ -15,6 +15,7 @@
15 15 
16#include "common/debug/log.h"16#include "common/debug/log.h"
17#include "common/debug/memory_dumper.h"17#include "common/debug/memory_dumper.h"
18+#include "common/fp16_t/fp16_t.h"
18#include "common/op/ge_op_utils.h"19#include "common/op/ge_op_utils.h"
19#include "common/framework_types_internal.h"20#include "common/framework_types_internal.h"
20#include "graph/debug/ge_attr_define.h"21#include "graph/debug/ge_attr_define.h"
@@ -116,3 +117,80 @@ TEST_F(UtestFoldingKernelRsqrtKernel, DoubleSuccess) {
116 Status status = kernel->Compute(op_desc_ptr, input, outputs);117 Status status = kernel->Compute(op_desc_ptr, input, outputs);
117 EXPECT_EQ(SUCCESS, status);118 EXPECT_EQ(SUCCESS, status);
118}119}
120+ 
121+TEST_F(UtestFoldingKernelRsqrtKernel, Float16Success) {
122+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("RSQRT", RSQRT);
123+ 
124+ vector<int64_t> dims_vec_0 = {3};
125+ vector<fp16_t> data_vec_0 = {4, 16, 100};
126+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT16);
127+ ConstGeTensorPtr tensor_0 =
128+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(fp16_t));
129+ 
130+ vector<ConstGeTensorPtr> input = {tensor_0};
131+ vector<GeTensorPtr> outputs;
132+ 
133+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(RSQRT);
134+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
135+ EXPECT_EQ(SUCCESS, status);
136+}
137+ 
138+TEST_F(UtestFoldingKernelRsqrtKernel, Float16HasZero) {
139+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("RSQRT", RSQRT);
140+ 
141+ vector<int64_t> dims_vec_0 = {2};
142+ vector<fp16_t> data_vec_0 = {4, 0};
143+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT16);
144+ ConstGeTensorPtr tensor_0 =
145+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(fp16_t));
146+ 
147+ vector<ConstGeTensorPtr> input = {tensor_0};
148+ vector<GeTensorPtr> outputs;
149+ 
150+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(RSQRT);
151+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
152+ EXPECT_EQ(NOT_CHANGED, status);
153+}
154+ 
155+TEST_F(UtestFoldingKernelRsqrtKernel, UnsupportedDataType) {
156+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("RSQRT", RSQRT);
157+ 
158+ vector<int64_t> dims_vec_0 = {2};
159+ vector<int32_t> data_vec_0 = {4, 16};
160+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_INT32);
161+ ConstGeTensorPtr tensor_0 =
162+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
163+ 
164+ vector<ConstGeTensorPtr> input = {tensor_0};
165+ vector<GeTensorPtr> outputs;
166+ 
167+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(RSQRT);
168+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
169+ EXPECT_EQ(NOT_CHANGED, status);
170+}
171+ 
172+TEST_F(UtestFoldingKernelRsqrtKernel, NullInputTensor) {
173+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("RSQRT", RSQRT);
174+ 
175+ vector<ConstGeTensorPtr> input = {nullptr};
176+ vector<GeTensorPtr> outputs;
177+ 
178+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(RSQRT);
179+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
180+ EXPECT_NE(SUCCESS, status);
181+}
182+ 
183+TEST_F(UtestFoldingKernelRsqrtKernel, NullOpDesc) {
184+ vector<int64_t> dims_vec_0 = {2};
185+ vector<float> data_vec_0 = {4.0, 16.0};
186+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT);
187+ ConstGeTensorPtr tensor_0 =
188+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(float));
189+ 
190+ vector<ConstGeTensorPtr> input = {tensor_0};
191+ vector<GeTensorPtr> outputs;
192+ 
193+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(RSQRT);
194+ Status status = kernel->Compute(nullptr, input, outputs);
195+ EXPECT_NE(SUCCESS, status);
196+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/ssd_prior_box_kernel_unittest.cc+102-0
@@ -417,3 +417,105 @@ TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, ParamInvalid) {
417 ret = kernel.GetNumPriorAndDimSize(1U, 1U, 1U, 1024 * 1024 * 1024 - 1, 1, num_priors, dim_size);417 ret = kernel.GetNumPriorAndDimSize(1U, 1U, 1U, 1024 * 1024 * 1024 - 1, 1, num_priors, dim_size);
418 EXPECT_EQ(PARAM_INVALID, ret);418 EXPECT_EQ(PARAM_INVALID, ret);
419}419}
420+ 
421+TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, GetPriorSizeParamNullOpDesc) {
422+ SsdPriorboxKernel kernel;
423+ int32_t img_width = 0;
424+ int32_t img_height = 0;
425+ float step_w = 0.0;
426+ float step_h = 0.0;
427+ int32_t layer_width = 0;
428+ int32_t layer_height = 0;
429+ Status ret = kernel.GetPriorSizeParam(nullptr, img_width, img_height, step_w, step_h, layer_width, layer_height);
430+ EXPECT_EQ(PARAM_INVALID, ret);
431+}
432+ 
433+TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, GetPriorSizeParamMissingImgH) {
434+ OpDescPtr op_desc = std::make_shared<OpDesc>("SSDPriorBox", SSDPRIORBOX);
435+ GeTensorDesc tensor_desc(GeShape({10, 10, 10, 10}), FORMAT_NCHW, DT_FLOAT);
436+ op_desc->AddInputDesc(0, tensor_desc);
437+ 
438+ SsdPriorboxKernel kernel;
439+ int32_t img_width = 0;
440+ int32_t img_height = 0;
441+ float step_w = 0.0;
442+ float step_h = 0.0;
443+ int32_t layer_width = 0;
444+ int32_t layer_height = 0;
445+ Status ret = kernel.GetPriorSizeParam(op_desc, img_width, img_height, step_w, step_h, layer_width, layer_height);
446+ EXPECT_EQ(PARAM_INVALID, ret);
447+}
448+ 
449+TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, GetPriorSizeParamMissingImgW) {
450+ OpDescPtr op_desc = std::make_shared<OpDesc>("SSDPriorBox", SSDPRIORBOX);
451+ GeTensorDesc tensor_desc(GeShape({10, 10, 10, 10}), FORMAT_NCHW, DT_FLOAT);
452+ op_desc->AddInputDesc(0, tensor_desc);
453+ AttrUtils::SetInt(op_desc, SSD_PRIOR_BOX_ATTR_IMG_H, 100);
454+ 
455+ SsdPriorboxKernel kernel;
456+ int32_t img_width = 0;
457+ int32_t img_height = 0;
458+ float step_w = 0.0;
459+ float step_h = 0.0;
460+ int32_t layer_width = 0;
461+ int32_t layer_height = 0;
462+ Status ret = kernel.GetPriorSizeParam(op_desc, img_width, img_height, step_w, step_h, layer_width, layer_height);
463+ EXPECT_EQ(PARAM_INVALID, ret);
464+}
465+ 
466+TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, GetPriorSizeParamMissingStepH) {
467+ OpDescPtr op_desc = std::make_shared<OpDesc>("SSDPriorBox", SSDPRIORBOX);
468+ GeTensorDesc tensor_desc(GeShape({10, 10, 10, 10}), FORMAT_NCHW, DT_FLOAT);
469+ op_desc->AddInputDesc(0, tensor_desc);
470+ AttrUtils::SetInt(op_desc, SSD_PRIOR_BOX_ATTR_IMG_H, 100);
471+ AttrUtils::SetInt(op_desc, SSD_PRIOR_BOX_ATTR_IMG_W, 100);
472+ AttrUtils::SetFloat(op_desc, SSD_PRIOR_BOX_ATTR_STEP_W, 1.0);
473+ 
474+ SsdPriorboxKernel kernel;
475+ int32_t img_width = 0;
476+ int32_t img_height = 0;
477+ float step_w = 0.0;
478+ float step_h = 0.0;
479+ int32_t layer_width = 0;
480+ int32_t layer_height = 0;
481+ Status ret = kernel.GetPriorSizeParam(op_desc, img_width, img_height, step_w, step_h, layer_width, layer_height);
482+ EXPECT_EQ(PARAM_INVALID, ret);
483+}
484+ 
485+TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, GetPriorSizeParamWithStepValue) {
486+ OpDescPtr op_desc = std::make_shared<OpDesc>("SSDPriorBox", SSDPRIORBOX);
487+ GeTensorDesc tensor_desc(GeShape({10, 10, 10, 10}), FORMAT_NCHW, DT_FLOAT);
488+ op_desc->AddInputDesc(0, tensor_desc);
489+ AttrUtils::SetInt(op_desc, SSD_PRIOR_BOX_ATTR_IMG_H, 100);
490+ AttrUtils::SetInt(op_desc, SSD_PRIOR_BOX_ATTR_IMG_W, 100);
491+ AttrUtils::SetFloat(op_desc, SSD_PRIOR_BOX_ATTR_STEP_H, 2.0);
492+ AttrUtils::SetFloat(op_desc, SSD_PRIOR_BOX_ATTR_STEP_W, 2.0);
493+ 
494+ SsdPriorboxKernel kernel;
495+ int32_t img_width = 0;
496+ int32_t img_height = 0;
497+ float step_w = 0.0;
498+ float step_h = 0.0;
499+ int32_t layer_width = 0;
500+ int32_t layer_height = 0;
501+ Status ret = kernel.GetPriorSizeParam(op_desc, img_width, img_height, step_w, step_h, layer_width, layer_height);
502+ EXPECT_EQ(SUCCESS, ret);
503+ EXPECT_FLOAT_EQ(step_w, 2.0);
504+ EXPECT_FLOAT_EQ(step_h, 2.0);
505+}
506+ 
507+TEST_F(UtestGraphPassesFoldingKernelSsdPriorboxKernel, GetPriorSizeParamZeroLayerHeight) {
508+ OpDescPtr op_desc = std::make_shared<OpDesc>("SSDPriorBox", SSDPRIORBOX);
509+ GeTensorDesc tensor_desc(GeShape({10, 10, 0, 10}), FORMAT_NCHW, DT_FLOAT);
510+ op_desc->AddInputDesc(0, tensor_desc);
511+ 
512+ SsdPriorboxKernel kernel;
513+ int32_t img_width = 0;
514+ int32_t img_height = 0;
515+ float step_w = 0.0;
516+ float step_h = 0.0;
517+ int32_t layer_width = 0;
518+ int32_t layer_height = 0;
519+ Status ret = kernel.GetPriorSizeParam(op_desc, img_width, img_height, step_w, step_h, layer_width, layer_height);
520+ EXPECT_EQ(PARAM_INVALID, ret);
521+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/strided_slice_kernel_unittest.cc+60-0
@@ -1035,3 +1035,63 @@ TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovEllipsisMaskExpand) {
1035 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);1035 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
1036 EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);1036 EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
1037}1037}
1038+ 
1039+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, NullAttr) {
1040+ vector<int64_t> dims_vec_0 = {2, 2};
1041+ vector<float> data_vec_0 = {1.0, 2.0, 3.0, 4.0};
1042+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT);
1043+ ConstGeTensorPtr tensor_0 =
1044+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(float));
1045+ 
1046+ vector<int32_t> begin_data = {0, 0};
1047+ vector<int32_t> end_data = {2, 2};
1048+ vector<int32_t> stride_data = {1, 1};
1049+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
1050+ ConstGeTensorPtr tensor_1 =
1051+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
1052+ ConstGeTensorPtr tensor_2 =
1053+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
1054+ ConstGeTensorPtr tensor_3 =
1055+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
1056+ 
1057+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
1058+ vector<GeTensorPtr> outputs;
1059+ 
1060+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
1061+ Status status = kernel->Compute(nullptr, input, outputs);
1062+ EXPECT_EQ(NOT_CHANGED, status);
1063+}
1064+ 
1065+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, MissingMaskAttr) {
1066+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
1067+ GeTensorDesc dims_tensor_desc(GeShape({2, 2}), FORMAT_NCHW, DT_FLOAT);
1068+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
1069+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
1070+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
1071+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
1072+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
1073+ 
1074+ vector<int64_t> dims_vec_0 = {2, 2};
1075+ vector<float> data_vec_0 = {1.0, 2.0, 3.0, 4.0};
1076+ GeTensorDesc tensor_desc_0(GeShape(dims_vec_0), FORMAT_NCHW, DT_FLOAT);
1077+ ConstGeTensorPtr tensor_0 =
1078+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(float));
1079+ 
1080+ vector<int32_t> begin_data = {0, 0};
1081+ vector<int32_t> end_data = {2, 2};
1082+ vector<int32_t> stride_data = {1, 1};
1083+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
1084+ ConstGeTensorPtr tensor_1 =
1085+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
1086+ ConstGeTensorPtr tensor_2 =
1087+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
1088+ ConstGeTensorPtr tensor_3 =
1089+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
1090+ 
1091+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
1092+ vector<GeTensorPtr> outputs;
1093+ 
1094+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
1095+ Status status = kernel->Compute(op_desc_ptr, input, outputs);
1096+ EXPECT_EQ(NOT_CHANGED, status);
1097+}
Mtests/ge/ut/ge/graph/passes/for_pass_unittest.cc+21-0
@@ -97,4 +97,25 @@ TEST_F(UTEST_graph_passes_for_pass, run_success) {
97 EXPECT_EQ(graph->GetAllSubgraphs().size(), 3);97 EXPECT_EQ(graph->GetAllSubgraphs().size(), 3);
98}98}
99 99 
100+TEST_F(UTEST_graph_passes_for_pass, find_input_with_index_null_node) {
101+ ForPass for_pass;
102+ NodePtr null_node = nullptr;
103+ auto result = for_pass.FindInputWithIndex(null_node, 0);
104+ EXPECT_EQ(result, nullptr);
105+}
106+ 
107+TEST_F(UTEST_graph_passes_for_pass, run_no_subgraph_fail) {
108+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
109+ NodePtr start_node = graph->AddNode(CreateOpDesc("start", DATA, 1, 1));
110+ NodePtr limit_node = graph->AddNode(CreateOpDesc("limit", DATA, 1, 1));
111+ NodePtr delta_node = graph->AddNode(CreateOpDesc("delta", DATA, 1, 1));
112+ NodePtr for_node = graph->AddNode(CreateOpDesc("for", FOR, 4, 1));
113+ 
114+ EXPECT_EQ(GraphUtils::AddEdge(start_node->GetOutDataAnchor(0), for_node->GetInDataAnchor(0)), SUCCESS);
115+ EXPECT_EQ(GraphUtils::AddEdge(limit_node->GetOutDataAnchor(0), for_node->GetInDataAnchor(1)), SUCCESS);
116+ EXPECT_EQ(GraphUtils::AddEdge(delta_node->GetOutDataAnchor(0), for_node->GetInDataAnchor(2)), SUCCESS);
117+ 
118+ ForPass for_pass;
119+ EXPECT_EQ(for_pass.Run(for_node), FAILED);
120+}
100} // namespace ge121} // namespace ge
Mtests/ge/ut/ge/graph/passes/hccl_continuous_pass_unittest.cc+14-0
@@ -476,4 +476,18 @@ TEST(UtestGraphPassesHcclContinuousMemcpyPass, testInputContinuousConflict_multi
476 EXPECT_EQ(identity->GetOutDataNodes().at(0)->GetType(), HCOMALLREDUCE);476 EXPECT_EQ(identity->GetOutDataNodes().at(0)->GetType(), HCOMALLREDUCE);
477 }477 }
478}478}
479+ 
480+TEST(UtestGraphPassesHcclContinuousMemcpyPass, clear_status_and_is_data_node_test) {
481+ HcclContinuousMemcpyPass pass;
482+ EXPECT_EQ(pass.ClearStatus(), SUCCESS);
483+ EXPECT_TRUE(pass.IsDataNode(CONSTANTOP));
484+ EXPECT_FALSE(pass.IsDataNode(RELU));
485+}
486+ 
487+TEST(UtestGraphPassesHcclContinuousMemcpyPass, check_duplicate_name_test) {
488+ HcclContinuousMemcpyPass pass;
489+ pass.node_num_map_.insert(std::make_pair("ge", 1));
490+ std::string name = pass.CheckDuplicateName("ge");
491+ EXPECT_FALSE(name.empty());
492+}
479} // namespace ge493} // namespace ge
Mtests/ge/ut/ge/graph/passes/hccl_memcpy_pass_unittest.cc+5-0
@@ -378,4 +378,9 @@ TEST_F(UtestGraphPassesHcclMemcpyPass, Noneed_insert_identity_ShapeComputingSibl
378 EXPECT_EQ(graph->GetDirectNodesSize(), 5);378 EXPECT_EQ(graph->GetDirectNodesSize(), 5);
379 GE_DUMP(graph, "mem_rw");379 GE_DUMP(graph, "mem_rw");
380}380}
381+ 
382+TEST_F(UtestGraphPassesHcclMemcpyPass, clear_status_test) {
383+ HcclMemcpyPass pass;
384+ EXPECT_EQ(pass.ClearStatus(), SUCCESS);
385+}
381} // namespace ge386} // namespace ge
Mtests/ge/ut/ge/graph/passes/infer_base_pass_unittest.cc+64-0
@@ -361,4 +361,68 @@ TEST_F(UtestGraphInferBasePassStub, TestUpdateParentNodeOutputForMultiDims_WhenA
361 EXPECT_EQ(stub_base_pass.call_update_from_subgraph_times, 0);361 EXPECT_EQ(stub_base_pass.call_update_from_subgraph_times, 0);
362 EXPECT_EQ(stub_base_pass.call_update_from_subgraph_multi_dims_times, 1);362 EXPECT_EQ(stub_base_pass.call_update_from_subgraph_multi_dims_times, 1);
363}363}
364+ 
365+TEST_F(UtestGraphInferBasePassStub, TestNoSubgraphNode) {
366+ auto builder = NoSubgraphBuilder();
367+ auto graph = builder.GetGraph();
368+ auto add1 = graph->FindNode("add1");
369+ EXPECT_NE(add1, nullptr);
370+ 
371+ ChildPassBuilder pass_builder;
372+ auto stub_base_pass = pass_builder.Build();
373+ EXPECT_EQ(stub_base_pass.Run(add1), SUCCESS);
374+ EXPECT_EQ(stub_base_pass.call_infer_times, 1);
375+}
376+ 
377+TEST_F(UtestGraphInferBasePassStub, TestSubgraphWithoutNetoutput) {
378+ ut::GraphBuilder builder = ut::GraphBuilder("root_graph");
379+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
380+ auto case1 = builder.AddNode("case1", CASE, 1, 1);
381+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
382+ builder.AddDataEdge(data1, 0, case1, 0);
383+ builder.AddDataEdge(case1, 0, netoutput, 0);
384+ 
385+ auto parent_graph = builder.GetGraph();
386+ 
387+ ut::GraphBuilder sub_builder = ut::GraphBuilder("sub_no_netoutput");
388+ auto sub_data = sub_builder.AddNode("sub_data", "Data", 1, 1, FORMAT_NCHW, DT_INT32, {1, 1});
389+ AttrUtils::SetInt(sub_data->GetOpDesc(), "_parent_node_index", 0);
390+ auto sub_add = sub_builder.AddNode("sub_add", "Add", 1, 1);
391+ builder.AddDataEdge(sub_data, 0, sub_add, 0);
392+ auto subgraph = sub_builder.GetGraph();
393+ case1->GetOpDesc()->AddSubgraphName(subgraph->GetName());
394+ case1->GetOpDesc()->SetSubgraphInstanceName(0, subgraph->GetName());
395+ subgraph->SetParentNode(case1);
396+ subgraph->SetParentGraph(parent_graph);
397+ EXPECT_EQ(parent_graph->AddSubgraph(subgraph->GetName(), subgraph), GRAPH_SUCCESS);
398+ 
399+ ChildPassBuilder pass_builder;
400+ auto stub_base_pass = pass_builder.Build();
401+ stub_base_pass.SetOption(kOptimizeAfterSubGraph, "");
402+ EXPECT_NE(stub_base_pass.Run(case1), SUCCESS);
403+}
404+ 
405+TEST_F(UtestGraphInferBasePassStub, TestInferResultNeedRepass) {
406+ auto builder = NoSubgraphBuilder();
407+ auto graph = builder.GetGraph();
408+ auto add1 = graph->FindNode("add1");
409+ EXPECT_NE(add1, nullptr);
410+ 
411+ ChildPassBuilder pass_builder;
412+ pass_builder.SetInferResult(static_cast<graphStatus>(50331647));
413+ auto stub_base_pass = pass_builder.Build();
414+ EXPECT_EQ(stub_base_pass.Run(add1), SUCCESS);
415+}
416+ 
417+TEST_F(UtestGraphInferBasePassStub, TestInferResultFailed) {
418+ auto builder = NoSubgraphBuilder();
419+ auto graph = builder.GetGraph();
420+ auto add1 = graph->FindNode("add1");
421+ EXPECT_NE(add1, nullptr);
422+ 
423+ ChildPassBuilder pass_builder;
424+ pass_builder.SetInferResult(static_cast<graphStatus>(1));
425+ auto stub_base_pass = pass_builder.Build();
426+ EXPECT_NE(stub_base_pass.Run(add1), SUCCESS);
427+}
364} // namespace ge428} // namespace ge
Mtests/ge/ut/ge/graph/passes/infer_value_range_pass_unittest.cc+47-0
@@ -803,4 +803,51 @@ TEST_F(UtestGraphInferValueRangePass, SkipInfer_WhenOutputShapeSizeTooLarge_InMe
803 803 
804 GetThreadLocalContext().SetGraphOption(options_back);804 GetThreadLocalContext().SetGraphOption(options_back);
805}805}
806+ 
807+TEST_F(UtestGraphInferValueRangePass, run_node_without_value_range) {
808+ auto builder = ut::GraphBuilder("g1");
809+ auto data = builder.AddNode("data", DATA, 0, 1);
810+ auto add = builder.AddNode("add", ADD, 1, 1);
811+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
812+ builder.AddDataEdge(data, 0, add, 0);
813+ builder.AddDataEdge(add, 0, netoutput, 0);
814+ 
815+ InferValueRangePass pass;
816+ EXPECT_EQ(pass.Run(add), SUCCESS);
817+}
818+ 
819+TEST_F(UtestGraphInferValueRangePass, run_node_with_unknown_output_shape) {
820+ auto builder = ut::GraphBuilder("g1");
821+ GeTensorDesc unknown_desc(GeShape({-1, -1}), FORMAT_NCHW, DT_FLOAT);
822+ auto data = builder.AddNode("data", DATA, 0, 1);
823+ data->GetOpDesc()->UpdateOutputDesc(0, unknown_desc);
824+ auto shape_node = builder.AddNode("shape", SHAPE, 1, 1);
825+ shape_node->GetOpDesc()->UpdateInputDesc(0, unknown_desc);
826+ GeTensorDesc out_desc(GeShape({2}), FORMAT_NCHW, DT_INT64);
827+ std::vector<std::pair<int64_t, int64_t>> value_range = {make_pair(1, 4), make_pair(1, 240)};
828+ out_desc.SetValueRange(value_range);
829+ shape_node->GetOpDesc()->UpdateOutputDesc(0, out_desc);
830+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
831+ builder.AddDataEdge(data, 0, shape_node, 0);
832+ builder.AddDataEdge(shape_node, 0, netoutput, 0);
833+ 
834+ InferValueRangePass pass;
835+ EXPECT_EQ(pass.Run(shape_node), SUCCESS);
836+}
837+ 
838+TEST_F(UtestGraphInferValueRangePass, run_node_no_input_value_range) {
839+ auto builder = ut::GraphBuilder("g1");
840+ auto data = builder.AddNode("data", DATA, 0, 1);
841+ GeTensorDesc desc(GeShape({1, 1}), FORMAT_NCHW, DT_INT32);
842+ data->GetOpDesc()->UpdateOutputDesc(0, desc);
843+ auto add = builder.AddNode("add", ADD, 1, 1);
844+ add->GetOpDesc()->UpdateInputDesc(0, desc);
845+ add->GetOpDesc()->UpdateOutputDesc(0, desc);
846+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
847+ builder.AddDataEdge(data, 0, add, 0);
848+ builder.AddDataEdge(add, 0, netoutput, 0);
849+ 
850+ InferValueRangePass pass;
851+ EXPECT_EQ(pass.Run(add), SUCCESS);
852+}
806} // namespace ge853} // namespace ge
Mtests/ge/ut/ge/graph/passes/input_output_connection_identify_pass_unittest.cc+57-0
@@ -337,4 +337,61 @@ TEST_F(UtestGraphPassesInputOutputIdentifyPass, UpdateNodeIdxMap_failed) {
337 delete my_pass;337 delete my_pass;
338 my_pass = nullptr;338 my_pass = nullptr;
339}339}
340+ 
341+TEST_F(UtestGraphPassesInputOutputIdentifyPass, topo_sort_cycle_failed) {
342+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("root_graph");
343+ NodePtr data_node = graph->AddNode(CreateOpDesc("data", DATA, 1, 1));
344+ NodePtr add_node = graph->AddNode(CreateOpDesc("add", ADD, 2, 1));
345+ EXPECT_EQ(GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), add_node->GetInDataAnchor(0)), SUCCESS);
346+ EXPECT_EQ(GraphUtils::AddEdge(add_node->GetOutDataAnchor(0), data_node->GetInDataAnchor(0)), SUCCESS);
347+ 
348+ InputOutputConnectionIdentifyPass pass;
349+ EXPECT_EQ(pass.Run(graph), INTERNAL_ERROR);
350+}
351+ 
352+TEST_F(UtestGraphPassesInputOutputIdentifyPass, process_input_node_anchor_not_found) {
353+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("root_graph");
354+ NodePtr data_node = graph->AddNode(CreateOpDesc("data", DATA, 0, 1));
355+ Node2Indexs in_map;
356+ Node2Indexs out_map;
357+ auto my_pass = new (std::nothrow) InputOutputConnectionIdentifyPass;
358+ EXPECT_EQ(my_pass->ProcessInputNode(data_node, in_map, out_map), SUCCESS);
359+ delete my_pass;
360+ my_pass = nullptr;
361+}
362+ 
363+TEST_F(UtestGraphPassesInputOutputIdentifyPass, process_output_node_anchor_not_found) {
364+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("root_graph");
365+ NodePtr output_node = graph->AddNode(CreateOpDesc("netoutput", NETOUTPUT, 1, 0));
366+ Node2Indexs in_map;
367+ Node2Indexs out_map;
368+ auto my_pass = new (std::nothrow) InputOutputConnectionIdentifyPass;
369+ EXPECT_EQ(my_pass->ProcessOutputNode(output_node, in_map, out_map), SUCCESS);
370+ delete my_pass;
371+ my_pass = nullptr;
372+}
373+ 
374+TEST_F(UtestGraphPassesInputOutputIdentifyPass, process_input_node_update_idx_map_failed) {
375+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("root_graph");
376+ NodePtr data_node = graph->AddNode(CreateOpDesc("data", DATA, 0, 1));
377+ auto my_pass = new (std::nothrow) InputOutputConnectionIdentifyPass;
378+ my_pass->anchor_to_symbol_[NodeIndexIO(data_node, 0, kOut).ToString()] = "fake_symbol";
379+ Node2Indexs in_map;
380+ Node2Indexs out_map;
381+ EXPECT_EQ(my_pass->ProcessInputNode(data_node, in_map, out_map), PARAM_INVALID);
382+ delete my_pass;
383+ my_pass = nullptr;
384+}
385+ 
386+TEST_F(UtestGraphPassesInputOutputIdentifyPass, process_output_node_update_idx_map_failed) {
387+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("root_graph");
388+ NodePtr output_node = graph->AddNode(CreateOpDesc("netoutput", NETOUTPUT, 1, 0));
389+ auto my_pass = new (std::nothrow) InputOutputConnectionIdentifyPass;
390+ my_pass->anchor_to_symbol_[NodeIndexIO(output_node, 0, kIn).ToString()] = "fake_symbol";
391+ Node2Indexs in_map;
392+ Node2Indexs out_map;
393+ EXPECT_EQ(my_pass->ProcessOutputNode(output_node, in_map, out_map), PARAM_INVALID);
394+ delete my_pass;
395+ my_pass = nullptr;
396+}
340} // namespace ge397} // namespace ge
Mtests/ge/ut/ge/graph/passes/memcpy_addr_async_unittest.cc+6-0
@@ -1007,4 +1007,10 @@ TEST_F(UtestMemcpyAddrAsyncPass, RefData2Hccl_success) {
1007 // 清理环境变量1007 // 清理环境变量
1008 mmSetEnv(kEnvValue, "", 1);1008 mmSetEnv(kEnvValue, "", 1);
1009}1009}
1010+ 
1011+TEST_F(UtestMemcpyAddrAsyncPass, run_with_empty_graph_test) {
1012+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("empty_graph");
1013+ MemcpyAddrAsyncPass pass;
1014+ EXPECT_EQ(pass.Run(graph), SUCCESS);
1015+}
1010} // namespace ge1016} // namespace ge
Mtests/ge/ut/ge/graph/passes/merge_pass_unittest.cc+25-0
@@ -458,4 +458,29 @@ TEST_F(UtestGraphPassesMergePass, IsMergeInputNeedOptimized2) {
458 EXPECT_EQ(ret, true);458 EXPECT_EQ(ret, true);
459}459}
460 460 
461+TEST_F(UtestGraphPassesMergePass, IsMergeInputNeedOptimized_variable_input) {
462+ auto memcpy_node = NewNode("memcpy", MEMCPYASYNC, 1, 1);
463+ auto var_node = NewNode("var", VARIABLE, 0, 1);
464+ GraphUtils::AddEdge(var_node->GetOutDataAnchor(0), memcpy_node->GetInDataAnchor(0));
465+ bool ret = pass_.IsMergeInputNeedOptimized(memcpy_node);
466+ EXPECT_EQ(ret, false);
467+}
468+ 
469+TEST_F(UtestGraphPassesMergePass, IsMergeInputNeedOptimized_non_memcpy_type) {
470+ auto relu_node = NewNode("relu", RELU, 1, 1);
471+ auto data_node = NewNode("data", DATA, 0, 1);
472+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), relu_node->GetInDataAnchor(0));
473+ bool ret = pass_.IsMergeInputNeedOptimized(relu_node);
474+ EXPECT_EQ(ret, false);
475+}
476+ 
477+TEST_F(UtestGraphPassesMergePass, IsMergeInputNeedOptimized_multi_inputs) {
478+ auto memcpy_node = NewNode("memcpy", MEMCPYASYNC, 2, 1);
479+ auto data1 = NewNode("data1", DATA, 0, 1);
480+ auto data2 = NewNode("data2", DATA, 0, 1);
481+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), memcpy_node->GetInDataAnchor(0));
482+ GraphUtils::AddEdge(data2->GetOutDataAnchor(0), memcpy_node->GetInDataAnchor(1));
483+ bool ret = pass_.IsMergeInputNeedOptimized(memcpy_node);
484+ EXPECT_EQ(ret, false);
485+}
461} // namespace ge486} // namespace ge
Mtests/ge/ut/ge/graph/passes/multi_batch_clone_pass_unittest.cc+260-0
@@ -642,4 +642,264 @@ TEST_F(UtestMultiBatchClonePass, MinDimsSizeCheck) {
642 EXPECT_EQ(pass_manager.Run(graph), PARAM_INVALID);642 EXPECT_EQ(pass_manager.Run(graph), PARAM_INVALID);
643}643}
644 644 
645+TEST_F(UtestMultiBatchClonePass, EmptyGraphRun) {
646+ PassManager pass_manager;
647+ pass_manager.AddPass("MultiBatchClonePass", new (std::nothrow) MultiBatchClonePass(0));
648+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
649+ GetLocalOmgContext().dynamic_batch_size = "1,2,4";
650+ EXPECT_EQ(pass_manager.Run(graph), INTERNAL_ERROR);
651+}
652+ 
653+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_InvalidFormat_ReturnsError) {
654+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
655+ EXPECT_NE(multibatch::ParseInputShapes("invalid_no_colon", user_shape_map), SUCCESS);
656+}
657+ 
658+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_EmptyValue_ReturnsError) {
659+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
660+ EXPECT_NE(multibatch::ParseInputShapes("data1:", user_shape_map), SUCCESS);
661+}
662+ 
663+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_FloatValue_ReturnsError) {
664+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
665+ EXPECT_NE(multibatch::ParseInputShapes("data1:1.5,2,3", user_shape_map), SUCCESS);
666+}
667+ 
668+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_InvalidNumber_ReturnsError) {
669+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
670+ EXPECT_NE(multibatch::ParseInputShapes("data1:abc,2,3", user_shape_map), SUCCESS);
671+}
672+ 
673+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_ValidInput_ReturnsSuccess) {
674+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
675+ EXPECT_EQ(multibatch::ParseInputShapes("data1:1,2,3;data2:4,5,6", user_shape_map), SUCCESS);
676+ ASSERT_EQ(user_shape_map.size(), 2U);
677+ EXPECT_EQ(user_shape_map[0].first, "data1");
678+ EXPECT_EQ(user_shape_map[1].first, "data2");
679+}
680+ 
681+TEST_F(UtestMultiBatchClonePass, ParseDynamicDims_Empty_ReturnsError) {
682+ multibatch::DimsVector dynamic_dims_vec;
683+ std::vector<std::vector<int64_t>> dynamic_dims_digit_vec;
684+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
685+ EXPECT_NE(multibatch::ParseDynamicDims("", dynamic_dims_vec, dynamic_dims_digit_vec, user_shape_map), SUCCESS);
686+}
687+ 
688+TEST_F(UtestMultiBatchClonePass, ParseDynamicDims_MismatchedCount_ReturnsError) {
689+ multibatch::DimsVector dynamic_dims_vec;
690+ std::vector<std::vector<int64_t>> dynamic_dims_digit_vec;
691+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
692+ user_shape_map.push_back({"data1", {1, -1, 3}});
693+ EXPECT_NE(multibatch::ParseDynamicDims("1,2,3", dynamic_dims_vec, dynamic_dims_digit_vec, user_shape_map), SUCCESS);
694+}
695+ 
696+TEST_F(UtestMultiBatchClonePass, ParseDynamicDims_ValidInput_ReturnsSuccess) {
697+ multibatch::DimsVector dynamic_dims_vec;
698+ std::vector<std::vector<int64_t>> dynamic_dims_digit_vec;
699+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
700+ user_shape_map.push_back({"data1", {1, -1, 3}});
701+ EXPECT_EQ(multibatch::ParseDynamicDims("2;4", dynamic_dims_vec, dynamic_dims_digit_vec, user_shape_map), SUCCESS);
702+ ASSERT_EQ(dynamic_dims_vec.size(), 2U);
703+ ASSERT_EQ(dynamic_dims_digit_vec.size(), 2U);
704+}
705+ 
706+TEST_F(UtestMultiBatchClonePass, ParseDynamicShapes_ValidInput_ReturnsSuccess) {
707+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
708+ EXPECT_EQ(multibatch::ParseDynamicShapes("data1:1,2,3;data2:4,5,6", user_shape_map), SUCCESS);
709+ ASSERT_EQ(user_shape_map.size(), 2U);
710+}
711+ 
712+TEST_F(UtestMultiBatchClonePass, ParseDynamicShapes_InvalidFormat_ReturnsError) {
713+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
714+ EXPECT_NE(multibatch::ParseDynamicShapes("invalid_no_colon", user_shape_map), SUCCESS);
715+}
716+ 
717+TEST_F(UtestMultiBatchClonePass, ChangeStrToNum_ValidInput) {
718+ int64_t num = 0;
719+ EXPECT_EQ(multibatch::ChangeStrToNum("123", num), SUCCESS);
720+ EXPECT_EQ(num, 123);
721+}
722+ 
723+TEST_F(UtestMultiBatchClonePass, ChangeStrToNum_InvalidInput) {
724+ int64_t num = 0;
725+ EXPECT_NE(multibatch::ChangeStrToNum("abc", num), SUCCESS);
726+}
727+ 
728+TEST_F(UtestMultiBatchClonePass, CheckDynamicBatchShape_ValidShape) {
729+ EXPECT_FALSE(multibatch::CheckDynamicBatchShape({1, -1, 3, 224}, "data1"));
730+}
731+ 
732+TEST_F(UtestMultiBatchClonePass, CheckDynamicBatchShape_InvalidShape) {
733+ EXPECT_FALSE(multibatch::CheckDynamicBatchShape({1, 2, 3, 224}, "data1"));
734+}
735+ 
736+TEST_F(UtestMultiBatchClonePass, CalcShape_ValidInput) {
737+ GeShape data_shape({1, -1, 3, 224});
738+ std::vector<int64_t> batch_shape = {2};
739+ GeShape result(data_shape);
740+ EXPECT_EQ(multibatch::CalcShape(batch_shape, result), SUCCESS);
741+}
742+ 
743+TEST_F(UtestMultiBatchClonePass, CalcShape_MismatchedCount) {
744+ GeShape data_shape({1, -1, 3, 224});
745+ std::vector<int64_t> batch_shape = {2, 3};
746+ GeShape result(data_shape);
747+ EXPECT_NE(multibatch::CalcShape(batch_shape, result), SUCCESS);
748+}
749+ 
750+TEST_F(UtestMultiBatchClonePass, CheckDynamicImageSizeShape_NCHW) {
751+ EXPECT_TRUE(multibatch::CheckDynamicImageSizeShape({1, 3, -1, -1}, "NCHW"));
752+}
753+ 
754+TEST_F(UtestMultiBatchClonePass, CheckDynamicImageSizeShape_NHWC) {
755+ EXPECT_TRUE(multibatch::CheckDynamicImageSizeShape({1, -1, -1, 3}, "NHWC"));
756+}
757+ 
758+TEST_F(UtestMultiBatchClonePass, CheckDynamicImageSizeShape_UnsupportedFormat) {
759+ EXPECT_FALSE(multibatch::CheckDynamicImageSizeShape({1, 3, -1, -1}, "NC1HWC0"));
760+}
761+ 
762+TEST_F(UtestMultiBatchClonePass, CheckDynamicImageSizeShape_InvalidShape) {
763+ EXPECT_FALSE(multibatch::CheckDynamicImageSizeShape({1, 3, 224, 224}, "NCHW"));
764+}
765+ 
766+TEST_F(UtestMultiBatchClonePass, CheckDynamicParams_DuplicateShapes) {
767+ std::vector<std::vector<int64_t>> shapes = {{1, 2}, {1, 2}};
768+ EXPECT_EQ(multibatch::CheckDynamicParams(shapes), PARAM_INVALID);
769+}
770+ 
771+TEST_F(UtestMultiBatchClonePass, CheckDynamicParams_NegativeDim) {
772+ std::vector<std::vector<int64_t>> shapes = {{1, 2}, {3, -1}};
773+ EXPECT_EQ(multibatch::CheckDynamicParams(shapes), PARAM_INVALID);
774+}
775+ 
776+TEST_F(UtestMultiBatchClonePass, CheckDynamicParams_DifferentSize) {
777+ std::vector<std::vector<int64_t>> shapes = {{1, 2}, {3}};
778+ EXPECT_EQ(multibatch::CheckDynamicParams(shapes), PARAM_INVALID);
779+}
780+ 
781+TEST_F(UtestMultiBatchClonePass, InitDynamicParams_DynamicBatchSize) {
782+ GetLocalOmgContext().dynamic_batch_size = "1,2,4";
783+ std::vector<std::vector<int64_t>> shapes;
784+ EXPECT_EQ(multibatch::InitDynamicParams(shapes), SUCCESS);
785+ EXPECT_EQ(shapes.size(), 3U);
786+ GetLocalOmgContext().dynamic_batch_size.clear();
787+}
788+ 
789+TEST_F(UtestMultiBatchClonePass, InitDynamicParams_DynamicImageSize) {
790+ GetLocalOmgContext().dynamic_image_size = "224,224;448,448";
791+ std::vector<std::vector<int64_t>> shapes;
792+ EXPECT_EQ(multibatch::InitDynamicParams(shapes), SUCCESS);
793+ EXPECT_EQ(shapes.size(), 2U);
794+ GetLocalOmgContext().dynamic_image_size.clear();
795+}
796+ 
797+TEST_F(UtestMultiBatchClonePass, InitDynamicParams_DynamicDims) {
798+ GetLocalOmgContext().dynamic_dims = "1,224,224;2,448,448";
799+ std::vector<std::vector<int64_t>> shapes;
800+ EXPECT_EQ(multibatch::InitDynamicParams(shapes), SUCCESS);
801+ EXPECT_EQ(shapes.size(), 2U);
802+ GetLocalOmgContext().dynamic_dims.clear();
803+}
804+ 
805+TEST_F(UtestMultiBatchClonePass, StampDynamicType_Basic) {
806+ auto op_desc = std::make_shared<OpDesc>("test_op", "Data");
807+ GetLocalOmgContext().dynamic_batch_size = "1,2";
808+ EXPECT_EQ(multibatch::StampDynamicType(op_desc), SUCCESS);
809+ GetLocalOmgContext().dynamic_batch_size.clear();
810+}
811+ 
812+TEST_F(UtestMultiBatchClonePass, StampDynamicType_DynamicImage) {
813+ auto op_desc = std::make_shared<OpDesc>("test_op2", "Data");
814+ GetLocalOmgContext().dynamic_image_size = "224,224;448,448";
815+ EXPECT_EQ(multibatch::StampDynamicType(op_desc), SUCCESS);
816+ GetLocalOmgContext().dynamic_image_size.clear();
817+}
818+ 
819+TEST_F(UtestMultiBatchClonePass, StampDynamicType_DynamicDims) {
820+ auto op_desc = std::make_shared<OpDesc>("test_op3", "Data");
821+ GetLocalOmgContext().dynamic_dims = "1,2;3,4";
822+ EXPECT_EQ(multibatch::StampDynamicType(op_desc), SUCCESS);
823+ GetLocalOmgContext().dynamic_dims.clear();
824+}
825+ 
826+TEST_F(UtestMultiBatchClonePass, ParserDataToDynamicInfo_Overflow) {
827+ std::vector<std::vector<int64_t>> shapes = {{1, 2, 3, 4}};
828+ std::vector<std::pair<std::string, std::vector<int64_t>>> data_name_and_shape = {{"data1", {-1, -1, -1, -1, -1}}};
829+ std::map<std::string, std::vector<std::vector<int64_t>>> data_to_dynamic_info;
830+ EXPECT_EQ(multibatch::ParserDataToDynamicInfo(shapes, data_name_and_shape, data_to_dynamic_info), FAILED);
831+}
832+ 
833+TEST_F(UtestMultiBatchClonePass, ParserDataToDynamicInfo_Insufficient) {
834+ std::vector<std::vector<int64_t>> shapes = {{1, 2, 3, 4, 5}};
835+ std::vector<std::pair<std::string, std::vector<int64_t>>> data_name_and_shape = {{"data1", {-1}}};
836+ std::map<std::string, std::vector<std::vector<int64_t>>> data_to_dynamic_info;
837+ EXPECT_EQ(multibatch::ParserDataToDynamicInfo(shapes, data_name_and_shape, data_to_dynamic_info), SUCCESS);
838+}
839+ 
840+TEST_F(UtestMultiBatchClonePass, ParserDataToDynamicInfo_ValidMatch) {
841+ std::vector<std::vector<int64_t>> shapes = {{1, 224, 224}, {2, 448, 448}};
842+ std::vector<std::pair<std::string, std::vector<int64_t>>> data_name_and_shape = {{"data1", {-1, 3, -1, -1}}};
843+ std::map<std::string, std::vector<std::vector<int64_t>>> data_to_dynamic_info;
844+ EXPECT_EQ(multibatch::ParserDataToDynamicInfo(shapes, data_name_and_shape, data_to_dynamic_info), SUCCESS);
845+}
846+ 
847+TEST_F(UtestMultiBatchClonePass, BuildSubgraphMuliDimsInput_Basic) {
848+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map = {{"data1", {-1, 3}}, {"data2", {-1, 4}}};
849+ multibatch::DimsVector dynamic_dims_vec = {{"3", "3"}, {"4", "4"}};
850+ std::vector<std::string> subgraph_multi_dims_input_shape;
851+ std::vector<std::string> subgraph_multi_dims_input_dims;
852+ EXPECT_EQ(multibatch::BuildSubgraphMuliDimsInput(user_shape_map, dynamic_dims_vec, subgraph_multi_dims_input_shape,
853+ subgraph_multi_dims_input_dims),
854+ SUCCESS);
855+}
856+ 
857+TEST_F(UtestMultiBatchClonePass, ParseMaxShapeRange_Basic) {
858+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map = {{"data1", {-1, 3, -1}}};
859+ std::vector<std::vector<int64_t>> dynamic_dims_digit_vec = {{1, 224}, {2, 448}};
860+ std::vector<std::pair<std::string, std::vector<int64_t>>> max_shape_range_map;
861+ EXPECT_EQ(multibatch::ParseMaxShapeRange(user_shape_map, dynamic_dims_digit_vec, max_shape_range_map), SUCCESS);
862+}
863+ 
864+TEST_F(UtestMultiBatchClonePass, ParseDynamicShapes_NotSorted) {
865+ std::string input_shapes = "data2:-1,3,224,224;data1:-1,3,224,224";
866+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
867+ EXPECT_NE(multibatch::ParseDynamicShapes(input_shapes, user_shape_map), SUCCESS);
868+}
869+ 
870+TEST_F(UtestMultiBatchClonePass, ParseDynamicDims_EmptyDim) {
871+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map = {{"data1", {-1, 3}}};
872+ multibatch::DimsVector dynamic_dims_vec;
873+ std::vector<std::vector<int64_t>> dynamic_dims_digit_vec;
874+ EXPECT_NE(multibatch::ParseDynamicDims("", dynamic_dims_vec, dynamic_dims_digit_vec, user_shape_map), SUCCESS);
875+}
876+ 
877+TEST_F(UtestMultiBatchClonePass, CheckDynamicBatchShape_NoDynamicDim) {
878+ EXPECT_FALSE(multibatch::CheckDynamicBatchShape({1, 2, 3, 224}, "data1"));
879+}
880+ 
881+TEST_F(UtestMultiBatchClonePass, CheckDynamicBatchShape_WithNegativeAfterFirst) {
882+ EXPECT_FALSE(multibatch::CheckDynamicBatchShape({-1, 2, -1, 224}, "data1"));
883+}
884+ 
885+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_NoColon) {
886+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
887+ EXPECT_NE(multibatch::ParseInputShapes("invalid_no_colon", user_shape_map), SUCCESS);
888+}
889+ 
890+TEST_F(UtestMultiBatchClonePass, ParseInputShapes_EmptyValue) {
891+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
892+ EXPECT_NE(multibatch::ParseInputShapes("data1:", user_shape_map), SUCCESS);
893+}
894+ 
895+TEST_F(UtestMultiBatchClonePass, ChangeStrToNum_InvalidChar) {
896+ int64_t num = 0;
897+ EXPECT_NE(multibatch::ChangeStrToNum("abc", num), SUCCESS);
898+}
899+ 
900+TEST_F(UtestMultiBatchClonePass, ChangeStrToNum_Valid) {
901+ int64_t num = 0;
902+ EXPECT_EQ(multibatch::ChangeStrToNum("123", num), SUCCESS);
903+ EXPECT_EQ(num, 123);
904+}
645} // namespace ge905} // namespace ge
Mtests/ge/ut/ge/graph/passes/net_output_pass_unittest.cc+61-0
@@ -1016,3 +1016,64 @@ TEST_F(UtestGraphPassesNetOutputPass, TryToSetOutputMaxSizeInvalidOption) {
1016 status = pass_managers.Run(compute_graph);1016 status = pass_managers.Run(compute_graph);
1017 EXPECT_EQ(status, ge::PARAM_INVALID);1017 EXPECT_EQ(status, ge::PARAM_INVALID);
1018}1018}
1019+ 
1020+TEST_F(UtestGraphPassesNetOutputPass, set_user_def_dtype_by_output_type_test) {
1021+ ge::ComputeGraphPtr compute_graph = build_graph();
1022+ auto &omg_context = GetLocalOmgContext();
1023+ auto old_output_type = omg_context.output_type;
1024+ omg_context.output_type = "FP32";
1025+ omg_context.net_out_nodes.clear();
1026+ 
1027+ ge::PassManager pass_managers;
1028+ pass_managers.AddPass("NetOutputPass", new (std::nothrow) NetOutputPass);
1029+ Status status = pass_managers.Run(compute_graph);
1030+ EXPECT_EQ(status, ge::SUCCESS);
1031+ 
1032+ omg_context.output_type = old_output_type;
1033+ omg_context.net_out_nodes.clear();
1034+}
1035+ 
1036+TEST_F(UtestGraphPassesNetOutputPass, set_user_def_dtype_by_attr_test) {
1037+ ge::ComputeGraphPtr compute_graph = build_graph();
1038+ auto mul1 = compute_graph->FindNode("Mul1");
1039+ ASSERT_NE(mul1, nullptr);
1040+ std::vector<std::string> dt_strs = {"0:FP16"};
1041+ AttrUtils::SetListStr(mul1->GetOpDesc(), "_user_defined_output_data_type", dt_strs);
1042+ GetLocalOmgContext().net_out_nodes.clear();
1043+ 
1044+ ge::PassManager pass_managers;
1045+ pass_managers.AddPass("NetOutputPass", new (std::nothrow) NetOutputPass);
1046+ Status status = pass_managers.Run(compute_graph);
1047+ EXPECT_EQ(status, ge::SUCCESS);
1048+ GetLocalOmgContext().net_out_nodes.clear();
1049+}
1050+ 
1051+TEST_F(UtestGraphPassesNetOutputPass, set_user_def_dtype_invalid_split_test) {
1052+ ge::ComputeGraphPtr compute_graph = build_graph();
1053+ auto mul1 = compute_graph->FindNode("Mul1");
1054+ ASSERT_NE(mul1, nullptr);
1055+ std::vector<std::string> dt_strs = {"invalid_str"};
1056+ AttrUtils::SetListStr(mul1->GetOpDesc(), "_user_defined_output_data_type", dt_strs);
1057+ GetLocalOmgContext().net_out_nodes.clear();
1058+ 
1059+ ge::PassManager pass_managers;
1060+ pass_managers.AddPass("NetOutputPass", new (std::nothrow) NetOutputPass);
1061+ Status status = pass_managers.Run(compute_graph);
1062+ EXPECT_EQ(status, ge::SUCCESS);
1063+ GetLocalOmgContext().net_out_nodes.clear();
1064+}
1065+ 
1066+TEST_F(UtestGraphPassesNetOutputPass, set_user_def_fp16_5hd_test) {
1067+ ge::ComputeGraphPtr compute_graph = build_graph();
1068+ auto mul1 = compute_graph->FindNode("Mul1");
1069+ ASSERT_NE(mul1, nullptr);
1070+ std::vector<std::string> fp16_strs = {"0:1"};
1071+ AttrUtils::SetListStr(mul1->GetOpDesc(), "_user_defined_output_fp16_5hd", fp16_strs);
1072+ GetLocalOmgContext().net_out_nodes.clear();
1073+ 
1074+ ge::PassManager pass_managers;
1075+ pass_managers.AddPass("NetOutputPass", new (std::nothrow) NetOutputPass);
1076+ Status status = pass_managers.Run(compute_graph);
1077+ EXPECT_EQ(status, ge::SUCCESS);
1078+ GetLocalOmgContext().net_out_nodes.clear();
1079+}
Mtests/ge/ut/ge/graph/passes/next_iteration_pass_unittest.cc+28-0
@@ -137,3 +137,31 @@ TEST_F(UtestGraphPassesNextIterationPass, FindTargetNodeFailed) {
137 auto ret = pass_.FindTargetNode(null_node, std::string(), false, null_node);137 auto ret = pass_.FindTargetNode(null_node, std::string(), false, null_node);
138 EXPECT_EQ(PARAM_INVALID, ret);138 EXPECT_EQ(PARAM_INVALID, ret);
139}139}
140+ 
141+TEST_F(UtestGraphPassesNextIterationPass, CreateActiveNodeSuccess) {
142+ auto graph = BuildGraphNextIterationPass();
143+ ge::NextIterationPass pass_;
144+ auto active_node = pass_.CreateActiveNode(graph, "test_active");
145+ EXPECT_NE(active_node, nullptr);
146+ EXPECT_EQ(active_node->GetType(), STREAMACTIVE);
147+}
148+ 
149+TEST_F(UtestGraphPassesNextIterationPass, ClearStatusSuccess) {
150+ ge::NextIterationPass pass_;
151+ EXPECT_EQ(pass_.ClearStatus(), SUCCESS);
152+}
153+ 
154+TEST_F(UtestGraphPassesNextIterationPass, RunEmptyGraph) {
155+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("empty");
156+ ge::NextIterationPass pass_;
157+ EXPECT_EQ(pass_.Run(graph), SUCCESS);
158+}
159+ 
160+TEST_F(UtestGraphPassesNextIterationPass, FindTargetNodeLoopCondNotFound) {
161+ auto graph = BuildGraphNextIterationPass();
162+ ge::NextIterationPass pass_;
163+ auto merge_node = graph->FindNode("merge");
164+ NodePtr target_node = nullptr;
165+ auto ret = pass_.FindTargetNode(merge_node, LOOPCOND, true, target_node);
166+ EXPECT_EQ(INTERNAL_ERROR, ret);
167+}
Mtests/ge/ut/ge/graph/passes/parallel_group_pass_unittest.cc+23-0
@@ -496,5 +496,28 @@ TEST_F(UtestGraphPassesParallelGgroupPass, ctrl_edge_skip_data) {
496 auto ret = pass_.AddCtrlEdge(input_node1, input_node2);496 auto ret = pass_.AddCtrlEdge(input_node1, input_node2);
497 EXPECT_EQ(ret, SUCCESS);497 EXPECT_EQ(ret, SUCCESS);
498}498}
499+ 
500+TEST_F(UtestGraphPassesParallelGgroupPass, ctrl_edge_same_node) {
501+ NodePtr node1 = NewNode("node1", RELU, 0, 1);
502+ auto ret = pass_.AddCtrlEdge(node1, node1);
503+ EXPECT_EQ(ret, SUCCESS);
504+}
505+ 
506+TEST_F(UtestGraphPassesParallelGgroupPass, ctrl_edge_already_linked) {
507+ NodePtr node1 = NewNode("node1", RELU, 0, 1);
508+ NodePtr node2 = NewNode("node2", RELU, 1, 1);
509+ GraphUtils::AddEdge(node1->GetOutControlAnchor(), node2->GetInControlAnchor());
510+ auto ret = pass_.AddCtrlEdge(node1, node2);
511+ EXPECT_EQ(ret, SUCCESS);
512+}
513+ 
514+TEST_F(UtestGraphPassesParallelGgroupPass, topo_sort_cycle_failed) {
515+ NodePtr node1 = NewNode("node1", RELU, 1, 1);
516+ NodePtr node2 = NewNode("node2", RELU, 1, 1);
517+ GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
518+ GraphUtils::AddEdge(node2->GetOutDataAnchor(0), node1->GetInDataAnchor(0));
519+ auto ret = pass_.Run(graph_);
520+ EXPECT_EQ(ret, FAILED);
521+}
499} // namespace522} // namespace
500} // namespace ge523} // namespace ge
Mtests/ge/ut/ge/graph/passes/pass_utils_unittest.cc+23-0
@@ -248,3 +248,26 @@ TEST_F(UtestGraphPassesPassUtils, update_ref_attr_no_ref_nodes) {
248 EXPECT_EQ(PassUtils::UpdateRefAttr(graph), SUCCESS);248 EXPECT_EQ(PassUtils::UpdateRefAttr(graph), SUCCESS);
249 EXPECT_FALSE(node_relu->GetOpDesc()->HasAttr(ATTR_NAME_REFERENCE));249 EXPECT_FALSE(node_relu->GetOpDesc()->HasAttr(ATTR_NAME_REFERENCE));
250}250}
251+ 
252+TEST_F(UtestGraphPassesPassUtils, is_constant_null_node) {
253+ EXPECT_FALSE(PassUtils::IsConstant(nullptr));
254+}
255+ 
256+TEST_F(UtestGraphPassesPassUtils, set_out_node_weight_null_src) {
257+ OutDataAnchorPtr anchor = nullptr;
258+ EXPECT_EQ(PassUtils::SetOutNodeWeight(anchor, nullptr), PARAM_INVALID);
259+}
260+ 
261+TEST_F(UtestGraphPassesPassUtils, set_out_node_weight_empty_weights) {
262+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_empty_weights");
263+ ge::NodePtr const_node = NodeBuilder("const1", CONSTANT).AddOutputDesc({1}).Build(graph);
264+ ge::NodePtr relu = NodeBuilder("relu1", RELU).AddInputDesc({1}).Build(graph);
265+ GraphUtils::AddEdge(const_node->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
266+ EXPECT_EQ(PassUtils::SetOutNodeWeight(const_node->GetOutDataAnchor(0), const_node), PARAM_INVALID);
267+}
268+ 
269+TEST_F(UtestGraphPassesPassUtils, set_out_node_weight_not_const) {
270+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_not_const");
271+ ge::NodePtr relu = NodeBuilder("relu1", RELU).AddInputDesc({1}).AddOutputDesc({1}).Build(graph);
272+ EXPECT_EQ(PassUtils::SetOutNodeWeight(relu->GetOutDataAnchor(0), relu), SUCCESS);
273+}
Mtests/ge/ut/ge/graph/passes/recompute_pass_unittest.cc+144-0
@@ -378,4 +378,148 @@ TEST_F(UtestRecomputePass, test_graph_with_no_recompute_nodes) {
378 graph->AddNode(x_desc);378 graph->AddNode(x_desc);
379 EXPECT_EQ(recompute_pass.Run(graph), SUCCESS);379 EXPECT_EQ(recompute_pass.Run(graph), SUCCESS);
380}380}
381+ 
382+TEST_F(UtestRecomputePass, test_recompute_node_with_resource_output) {
383+ map<std::string, std::string> options{{RESOURCE_CONFIG_PATH, "/tmp"}};
384+ GetThreadLocalContext().SetSessionOption(options);
385+ map<std::string, std::string> graph_options{{RECOMPUTE, "manual"}};
386+ GetThreadLocalContext().SetGraphOption(graph_options);
387+ RecomputePass recompute_pass;
388+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
389+ GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
390+ GeTensorDesc resource_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_RESOURCE);
391+ 
392+ auto x_desc = std::make_shared<OpDesc>("x", DATA);
393+ x_desc->AddOutputDesc(scalar_tensor);
394+ auto x_node = graph->AddNode(x_desc);
395+ 
396+ auto pow_desc = std::make_shared<OpDesc>("pow", POW);
397+ (void)ge::AttrUtils::SetBool(pow_desc, "_recompute", true);
398+ pow_desc->AddInputDesc(scalar_tensor);
399+ pow_desc->AddOutputDesc(resource_tensor);
400+ auto pow_node = graph->AddNode(pow_desc);
401+ 
402+ auto bp_desc = std::make_shared<OpDesc>("gradients/bp", SQRT);
403+ (void)ge::AttrUtils::SetBool(bp_desc, "_backward", true);
404+ bp_desc->AddInputDesc(resource_tensor);
405+ bp_desc->AddOutputDesc(resource_tensor);
406+ auto bp_node = graph->AddNode(bp_desc);
407+ 
408+ auto output_desc = std::make_shared<OpDesc>("NetOutput", "NetOutput");
409+ output_desc->AddInputDesc(resource_tensor);
410+ output_desc->AddOutputDesc(resource_tensor);
411+ auto output_node = graph->AddNode(output_desc);
412+ 
413+ (void)GraphUtils::AddEdge(x_node->GetOutDataAnchor(0), pow_node->GetInDataAnchor(0));
414+ (void)GraphUtils::AddEdge(pow_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(0));
415+ (void)GraphUtils::AddEdge(bp_node->GetOutDataAnchor(0), output_node->GetInDataAnchor(0));
416+ 
417+ EXPECT_EQ(recompute_pass.Run(graph), SUCCESS);
418+ bool is_recompute = true;
419+ (void)ge::AttrUtils::GetBool(pow_node->GetOpDesc(), "_recompute", is_recompute);
420+ EXPECT_TRUE(is_recompute);
421+}
422+ 
423+TEST_F(UtestRecomputePass, test_multiple_recompute_to_same_backward) {
424+ map<std::string, std::string> options{{RESOURCE_CONFIG_PATH, "/tmp"}};
425+ GetThreadLocalContext().SetSessionOption(options);
426+ map<std::string, std::string> graph_options{{RECOMPUTE, "manual"}};
427+ GetThreadLocalContext().SetGraphOption(graph_options);
428+ RecomputePass recompute_pass;
429+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
430+ GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
431+ 
432+ auto x_desc = std::make_shared<OpDesc>("x", DATA);
433+ x_desc->AddOutputDesc(scalar_tensor);
434+ auto x_node = graph->AddNode(x_desc);
435+ 
436+ auto pow_a_desc = std::make_shared<OpDesc>("pow_a", POW);
437+ (void)ge::AttrUtils::SetBool(pow_a_desc, "_recompute", true);
438+ pow_a_desc->AddInputDesc(scalar_tensor);
439+ pow_a_desc->AddOutputDesc(scalar_tensor);
440+ auto pow_a_node = graph->AddNode(pow_a_desc);
441+ 
442+ auto pow_b_desc = std::make_shared<OpDesc>("pow_b", POW);
443+ (void)ge::AttrUtils::SetBool(pow_b_desc, "_recompute", true);
444+ pow_b_desc->AddInputDesc(scalar_tensor);
445+ pow_b_desc->AddOutputDesc(scalar_tensor);
446+ auto pow_b_node = graph->AddNode(pow_b_desc);
447+ 
448+ auto bp3_desc = std::make_shared<OpDesc>("gradients/bp3", SQRT);
449+ (void)ge::AttrUtils::SetBool(bp3_desc, "_backward", true);
450+ bp3_desc->AddInputDesc(scalar_tensor);
451+ bp3_desc->AddOutputDesc(scalar_tensor);
452+ auto bp3_node = graph->AddNode(bp3_desc);
453+ 
454+ auto bp_desc = std::make_shared<OpDesc>("gradients/bp", ADDN);
455+ (void)ge::AttrUtils::SetBool(bp_desc, "_backward", true);
456+ bp_desc->AddInputDesc(scalar_tensor);
457+ bp_desc->AddInputDesc(scalar_tensor);
458+ bp_desc->AddInputDesc(scalar_tensor);
459+ bp_desc->AddOutputDesc(scalar_tensor);
460+ auto bp_node = graph->AddNode(bp_desc);
461+ 
462+ auto output_desc = std::make_shared<OpDesc>("NetOutput", "NetOutput");
463+ output_desc->AddInputDesc(scalar_tensor);
464+ output_desc->AddOutputDesc(scalar_tensor);
465+ auto output_node = graph->AddNode(output_desc);
466+ 
467+ (void)GraphUtils::AddEdge(x_node->GetOutDataAnchor(0), pow_a_node->GetInDataAnchor(0));
468+ (void)GraphUtils::AddEdge(x_node->GetOutDataAnchor(0), pow_b_node->GetInDataAnchor(0));
469+ (void)GraphUtils::AddEdge(x_node->GetOutDataAnchor(0), bp3_node->GetInDataAnchor(0));
470+ (void)GraphUtils::AddEdge(pow_a_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(0));
471+ (void)GraphUtils::AddEdge(pow_b_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(1));
472+ (void)GraphUtils::AddEdge(bp3_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(2));
473+ (void)GraphUtils::AddEdge(bp_node->GetOutDataAnchor(0), output_node->GetInDataAnchor(0));
474+ 
475+ EXPECT_EQ(recompute_pass.Run(graph), SUCCESS);
476+}
477+ 
478+TEST_F(UtestRecomputePass, test_single_recompute_multi_anchor_to_same_backward) {
479+ map<std::string, std::string> options{{RESOURCE_CONFIG_PATH, "/tmp"}};
480+ GetThreadLocalContext().SetSessionOption(options);
481+ map<std::string, std::string> graph_options{{RECOMPUTE, "manual"}};
482+ GetThreadLocalContext().SetGraphOption(graph_options);
483+ RecomputePass recompute_pass;
484+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
485+ GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
486+ 
487+ auto x_desc = std::make_shared<OpDesc>("x", DATA);
488+ x_desc->AddOutputDesc(scalar_tensor);
489+ auto x_node = graph->AddNode(x_desc);
490+ 
491+ auto pow_a_desc = std::make_shared<OpDesc>("pow_a", POW);
492+ (void)ge::AttrUtils::SetBool(pow_a_desc, "_recompute", true);
493+ pow_a_desc->AddInputDesc(scalar_tensor);
494+ pow_a_desc->AddOutputDesc(scalar_tensor);
495+ auto pow_a_node = graph->AddNode(pow_a_desc);
496+ 
497+ auto bp3_desc = std::make_shared<OpDesc>("gradients/bp3", SQRT);
498+ (void)ge::AttrUtils::SetBool(bp3_desc, "_backward", true);
499+ bp3_desc->AddInputDesc(scalar_tensor);
500+ bp3_desc->AddOutputDesc(scalar_tensor);
501+ auto bp3_node = graph->AddNode(bp3_desc);
502+ 
503+ auto bp_desc = std::make_shared<OpDesc>("gradients/bp", ADDN);
504+ (void)ge::AttrUtils::SetBool(bp_desc, "_backward", true);
505+ bp_desc->AddInputDesc(scalar_tensor);
506+ bp_desc->AddInputDesc(scalar_tensor);
507+ bp_desc->AddInputDesc(scalar_tensor);
508+ bp_desc->AddOutputDesc(scalar_tensor);
509+ auto bp_node = graph->AddNode(bp_desc);
510+ 
511+ auto output_desc = std::make_shared<OpDesc>("NetOutput", "NetOutput");
512+ output_desc->AddInputDesc(scalar_tensor);
513+ output_desc->AddOutputDesc(scalar_tensor);
514+ auto output_node = graph->AddNode(output_desc);
515+ 
516+ (void)GraphUtils::AddEdge(x_node->GetOutDataAnchor(0), pow_a_node->GetInDataAnchor(0));
517+ (void)GraphUtils::AddEdge(x_node->GetOutDataAnchor(0), bp3_node->GetInDataAnchor(0));
518+ (void)GraphUtils::AddEdge(pow_a_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(0));
519+ (void)GraphUtils::AddEdge(pow_a_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(1));
520+ (void)GraphUtils::AddEdge(bp3_node->GetOutDataAnchor(0), bp_node->GetInDataAnchor(2));
521+ (void)GraphUtils::AddEdge(bp_node->GetOutDataAnchor(0), output_node->GetInDataAnchor(0));
522+ 
523+ EXPECT_EQ(recompute_pass.Run(graph), SUCCESS);
524+}
381} // namespace ge525} // namespace ge
Mtests/ge/ut/ge/graph/passes/set_input_output_offset_pass_unittest.cc+22-0
@@ -309,3 +309,25 @@ TEST_F(UTEST_graph_passes_set_input_output_offset_pass, SetOutputOffsetNoTaskNot
309 SetInputOutputOffsetPass pass;309 SetInputOutputOffsetPass pass;
310 EXPECT_EQ(pass.Run(graph), ge::SUCCESS);310 EXPECT_EQ(pass.Run(graph), ge::SUCCESS);
311}311}
312+ 
313+TEST_F(UTEST_graph_passes_set_input_output_offset_pass, run_with_connect_input_attr) {
314+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_connect_input");
315+ auto op_desc = std::make_shared<OpDesc>("node1", RELU);
316+ op_desc->AddInputDesc(GeTensorDesc());
317+ op_desc->AddOutputDesc(GeTensorDesc());
318+ AttrUtils::SetListInt(op_desc, ATTR_NAME_NODE_CONNECT_INPUT, {0});
319+ auto node = graph->AddNode(op_desc);
320+ SetInputOutputOffsetPass pass2;
321+ EXPECT_EQ(pass2.Run(graph), ge::SUCCESS);
322+}
323+ 
324+TEST_F(UTEST_graph_passes_set_input_output_offset_pass, run_with_connect_output_attr) {
325+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_connect_output");
326+ auto op_desc = std::make_shared<OpDesc>("node1", RELU);
327+ op_desc->AddInputDesc(GeTensorDesc());
328+ op_desc->AddOutputDesc(GeTensorDesc());
329+ AttrUtils::SetListInt(op_desc, ATTR_NAME_NODE_CONNECT_OUTPUT, {0});
330+ auto node = graph->AddNode(op_desc);
331+ SetInputOutputOffsetPass pass3;
332+ EXPECT_EQ(pass3.Run(graph), ge::SUCCESS);
333+}
Mtests/ge/ut/ge/graph/passes/subexpression_migration_pass_unittest.cc+18-0
@@ -511,3 +511,21 @@ TEST_F(UtestSubexpressionMigrationPass, graph_no_need_migration_data_anchor_inde
511 ASSERT_NE(case_node, nullptr);511 ASSERT_NE(case_node, nullptr);
512 EXPECT_EQ(case_node->GetAllInDataAnchorsSize(), 2);512 EXPECT_EQ(case_node->GetAllInDataAnchorsSize(), 2);
513}513}
514+ 
515+TEST_F(UtestSubexpressionMigrationPass, run_empty_graph_success) {
516+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
517+ SubexpressionMigrationPass pass;
518+ EXPECT_EQ(pass.Run(graph), SUCCESS);
519+}
520+ 
521+TEST_F(UtestSubexpressionMigrationPass, run_graph_without_case_node) {
522+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
523+ auto builder = ut::GraphBuilder("g1");
524+ auto data = builder.AddNode("data", DATA, 0, 1);
525+ auto add = builder.AddNode("add", ADD, 1, 1);
526+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
527+ builder.AddDataEdge(data, 0, add, 0);
528+ builder.AddDataEdge(add, 0, netoutput, 0);
529+ SubexpressionMigrationPass pass;
530+ EXPECT_EQ(pass.Run(builder.GetGraph()), SUCCESS);
531+}
Mtests/ge/ut/ge/graph/passes/subgraph_const_migration_pass_unittest.cc+19-0
@@ -389,4 +389,23 @@ TEST_F(UtestSubgraphConstMigrationPass, subgraph_expression_migration) {
389 make_multibatch_graph_subexpression(graph);389 make_multibatch_graph_subexpression(graph);
390 EXPECT_EQ(pass_manager.Run(graph), SUCCESS);390 EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
391}391}
392+ 
393+TEST_F(UtestSubgraphConstMigrationPass, run_empty_graph) {
394+ PassManager pass_manager;
395+ pass_manager.AddPass("SubgraphConstMigrationPass", new (std::nothrow) SubgraphConstMigrationPass);
396+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
397+ EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
398+}
399+ 
400+TEST_F(UtestSubgraphConstMigrationPass, run_graph_without_subgraph) {
401+ PassManager pass_manager;
402+ pass_manager.AddPass("SubgraphConstMigrationPass", new (std::nothrow) SubgraphConstMigrationPass);
403+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
404+ auto data = MakeNode(graph, 0, 1, "data", "Data");
405+ auto add = MakeNode(graph, 1, 1, "add", ADD);
406+ auto netoutput = MakeNode(graph, 1, 0, "netoutput", NETOUTPUT);
407+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), add->GetInDataAnchor(0));
408+ GraphUtils::AddEdge(add->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
409+ EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
410+}
392} // namespace ge411} // namespace ge
Mtests/ge/ut/ge/graph/passes/subgraph_multi_dims_clone_pass_unittest.cc+19-0
@@ -152,4 +152,23 @@ TEST_F(SubgraphMultiDimsPassTest, base_test_success) {
152 152 
153 EXPECT_EQ(pass_manager.Run(graph), SUCCESS);153 EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
154}154}
155+ 
156+TEST_F(SubgraphMultiDimsPassTest, run_without_multi_dims_index) {
157+ PassManager pass_manager;
158+ pass_manager.AddPass("SubgraphMultiDimsClonePass", new (std::nothrow) SubgraphMultiDimsClonePass);
159+ pass_manager.AddPass("SubgraphMultiDimsPass", new (std::nothrow) SubgraphMultiDimsPass);
160+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
161+ 
162+ CreateRootGraph(graph);
163+ CreateSubGraph(graph);
164+ 
165+ EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
166+}
167+ 
168+TEST_F(SubgraphMultiDimsPassTest, run_with_empty_graph) {
169+ PassManager pass_manager;
170+ pass_manager.AddPass("SubgraphMultiDimsClonePass", new (std::nothrow) SubgraphMultiDimsClonePass);
171+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
172+ EXPECT_EQ(pass_manager.Run(graph), SUCCESS);
173+}
155} // namespace ge174} // namespace ge
Mtests/ge/ut/ge/graph/passes/subgraph_pass_unittest.cc+23-0
@@ -840,4 +840,27 @@ TEST_F(UtestGraphPassesSubgraphPass, hcom_to_netoutput_discard_reuse_input_attr)
840 after_reuse_flag);840 after_reuse_flag);
841 EXPECT_TRUE(after_reuse_flag == false);841 EXPECT_TRUE(after_reuse_flag == false);
842}842}
843+ 
844+TEST_F(UtestGraphPassesSubgraphPass, run_with_empty_graph_test) {
845+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("empty_graph");
846+ PassManager pass_managers;
847+ pass_managers.AddPass("SubgraphPass", new (std::nothrow) SubgraphPass);
848+ EXPECT_EQ(pass_managers.Run(graph), SUCCESS);
849+}
850+ 
851+TEST_F(UtestGraphPassesSubgraphPass, run_with_simple_graph_test) {
852+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("simple_graph");
853+ auto data_op = std::make_shared<OpDesc>("data", DATA);
854+ data_op->AddOutputDesc(GeTensorDesc());
855+ auto data = graph->AddNode(data_op);
856+ auto netoutput_op = std::make_shared<OpDesc>("netoutput", NETOUTPUT);
857+ netoutput_op->AddInputDesc(GeTensorDesc());
858+ auto netoutput = graph->AddNode(netoutput_op);
859+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
860+ graph->TopologicalSorting();
861+ 
862+ PassManager pass_managers;
863+ pass_managers.AddPass("SubgraphPass", new (std::nothrow) SubgraphPass);
864+ EXPECT_EQ(pass_managers.Run(graph), SUCCESS);
865+}
843} // namespace ge866} // namespace ge
Mtests/ge/ut/ge/graph/passes/switch_data_edges_bypass_unittest.cc+13-0
@@ -418,4 +418,17 @@ TEST_F(UtestSwitchDataEdgesBypass, SwitchConnectToMerge) {
418 EXPECT_EQ(merge1->GetInDataNodes().size(), 1);418 EXPECT_EQ(merge1->GetInDataNodes().size(), 1);
419 EXPECT_EQ(merge1->GetInDataNodes().at(0)->GetName(), memcpy1->GetName());419 EXPECT_EQ(merge1->GetInDataNodes().at(0)->GetName(), memcpy1->GetName());
420}420}
421+ 
422+TEST_F(UtestSwitchDataEdgesBypass, SwitchWithOneInputAnchor) {
423+ ut::GraphBuilder builder("g10");
424+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
425+ auto switch1 = builder.AddNode("switch1", "Switch", 1, 2);
426+ auto addn1 = builder.AddNode("addn1", "AddN", 1, 1);
427+ builder.AddDataEdge(data1, 0, switch1, 0);
428+ builder.AddDataEdge(switch1, 0, addn1, 0);
429+ auto graph = builder.GetGraph();
430+ 
431+ SwitchDataEdgesBypass pass;
432+ EXPECT_EQ(pass.Run(graph), SUCCESS);
433+}
421} // namespace ge434} // namespace ge
Mtests/ge/ut/ge/graph/passes/switch_dead_branch_elimination_unittest.cc+63-0
@@ -419,4 +419,67 @@ TEST_F(UtestSwitchDeadBranchElimination, ParsePred_DT_FLOAT3) {
419 }419 }
420}420}
421 421 
422+TEST_F(UtestSwitchDeadBranchElimination, switch_no_out_nodes) {
423+ ut::GraphBuilder builder = ut::GraphBuilder("g1");
424+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
425+ auto const1 = builder.AddNode("const1", "Const", 0, 1);
426+ auto switch1 = builder.AddNode("switch1", "Switch", 2, 2);
427+ builder.AddDataEdge(data1, 0, switch1, 0);
428+ builder.AddDataEdge(const1, 0, switch1, 1);
429+ auto graph = builder.GetGraph();
430+ 
431+ int32_t weight[1] = {1};
432+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
433+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
434+ OpDescUtils::SetWeights(const1, {tensor});
435+ 
436+ SwitchDeadBranchElimination switch_pass;
437+ EXPECT_EQ(switch_pass.Run(switch1), SUCCESS);
438+}
439+ 
440+TEST_F(UtestSwitchDeadBranchElimination, switch_pred_not_const) {
441+ ut::GraphBuilder builder = ut::GraphBuilder("g1");
442+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
443+ auto data2 = builder.AddNode("data2", "Data", 0, 1);
444+ auto switch1 = builder.AddNode("switch1", "Switch", 2, 2);
445+ auto relu1 = builder.AddNode("relu1", "Relu", 1, 1);
446+ builder.AddDataEdge(data1, 0, switch1, 0);
447+ builder.AddDataEdge(data2, 0, switch1, 1);
448+ builder.AddDataEdge(switch1, 0, relu1, 0);
449+ auto graph = builder.GetGraph();
450+ 
451+ SwitchDeadBranchElimination switch_pass;
452+ EXPECT_EQ(switch_pass.Run(switch1), SUCCESS);
453+}
454+ 
455+TEST_F(UtestSwitchDeadBranchElimination, switch_pred_null) {
456+ ut::GraphBuilder builder = ut::GraphBuilder("g1");
457+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
458+ auto switch1 = builder.AddNode("switch1", "Switch", 2, 2);
459+ auto relu1 = builder.AddNode("relu1", "Relu", 1, 1);
460+ builder.AddDataEdge(data1, 0, switch1, 0);
461+ builder.AddDataEdge(switch1, 0, relu1, 0);
462+ auto graph = builder.GetGraph();
463+ 
464+ SwitchDeadBranchElimination switch_pass;
465+ EXPECT_EQ(switch_pass.Run(switch1), SUCCESS);
466+}
467+ 
468+TEST_F(UtestSwitchDeadBranchElimination, switch_data_input_null) {
469+ ut::GraphBuilder builder = ut::GraphBuilder("g1");
470+ auto const1 = builder.AddNode("const1", "Const", 0, 1);
471+ auto switch1 = builder.AddNode("switch1", "Switch", 2, 2);
472+ auto relu1 = builder.AddNode("relu1", "Relu", 1, 1);
473+ builder.AddDataEdge(const1, 0, switch1, 1);
474+ builder.AddDataEdge(switch1, 0, relu1, 0);
475+ auto graph = builder.GetGraph();
476+ 
477+ int32_t weight[1] = {1};
478+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
479+ GeTensorPtr tensor = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
480+ OpDescUtils::SetWeights(const1, {tensor});
481+ 
482+ SwitchDeadBranchElimination switch_pass;
483+ EXPECT_EQ(switch_pass.Run(switch1), SUCCESS);
484+}
422} // namespace ge485} // namespace ge
Mtests/ge/ut/ge/graph/passes/switch_to_stream_switch_pass_unittest.cc+52-0
@@ -159,3 +159,55 @@ TEST_F(UtestSwitch2StreamSwitchPass, ClearStatusClearsAllMembers) {
159 EXPECT_TRUE(switch2StrPass.switch_node_map_.empty());159 EXPECT_TRUE(switch2StrPass.switch_node_map_.empty());
160 EXPECT_TRUE(switch2StrPass.node_num_map_.empty());160 EXPECT_TRUE(switch2StrPass.node_num_map_.empty());
161}161}
162+ 
163+TEST_F(UtestSwitch2StreamSwitchPass, MarkCycleDependenceEmptyMap) {
164+ SwitchToStreamSwitchPass switch2StrPass;
165+ std::unordered_map<NodePtr, std::vector<NodePtr>> empty_map;
166+ switch2StrPass.MarkCycleDependence(empty_map);
167+ EXPECT_TRUE(switch2StrPass.switch_cyclic_map_.empty());
168+}
169+ 
170+TEST_F(UtestSwitch2StreamSwitchPass, RunWithCompleteSwitchGraph) {
171+ GeTensorDesc bool_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_BOOL);
172+ GeTensorDesc scalar_tensor(GeShape(), ge::FORMAT_NCHW, ge::DT_FLOAT);
173+ 
174+ auto graph = std::make_shared<ComputeGraph>("test_complete_switch");
175+ 
176+ auto data_desc = std::make_shared<OpDesc>("data", DATA);
177+ data_desc->AddOutputDesc(scalar_tensor);
178+ auto data_node = graph->AddNode(data_desc);
179+ 
180+ auto less_desc = std::make_shared<OpDesc>("less", LESS);
181+ less_desc->AddInputDesc(scalar_tensor);
182+ less_desc->AddInputDesc(scalar_tensor);
183+ less_desc->AddOutputDesc(bool_tensor);
184+ auto less_node = graph->AddNode(less_desc);
185+ 
186+ auto switch_desc = std::make_shared<OpDesc>("switch1", SWITCH);
187+ switch_desc->AddInputDesc(scalar_tensor);
188+ switch_desc->AddInputDesc(bool_tensor);
189+ switch_desc->AddOutputDesc(scalar_tensor);
190+ switch_desc->AddOutputDesc(scalar_tensor);
191+ auto switch_node = graph->AddNode(switch_desc);
192+ 
193+ auto identity_desc = std::make_shared<OpDesc>("identity", IDENTITY);
194+ identity_desc->AddInputDesc(scalar_tensor);
195+ identity_desc->AddOutputDesc(scalar_tensor);
196+ auto identity_node = graph->AddNode(identity_desc);
197+ 
198+ auto netoutput_desc = std::make_shared<OpDesc>("netoutput", NETOUTPUT);
199+ netoutput_desc->AddInputDesc(scalar_tensor);
200+ auto netoutput_node = graph->AddNode(netoutput_desc);
201+ 
202+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), less_node->GetInDataAnchor(0));
203+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), less_node->GetInDataAnchor(1));
204+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), switch_node->GetInDataAnchor(0));
205+ GraphUtils::AddEdge(less_node->GetOutDataAnchor(0), switch_node->GetInDataAnchor(1));
206+ GraphUtils::AddEdge(switch_node->GetOutDataAnchor(0), identity_node->GetInDataAnchor(0));
207+ GraphUtils::AddEdge(identity_node->GetOutDataAnchor(0), netoutput_node->GetInDataAnchor(0));
208+ 
209+ SwitchToStreamSwitchPass switch2StrPass;
210+ auto ret = switch2StrPass.Run(graph);
211+ switch2StrPass.ClearStatus();
212+ EXPECT_EQ(ret, SUCCESS);
213+}
Atests/ge/ut/ge/graph/passes/symbolic_cond_remove_pass_unittest.cc+92-0
@@ -0,0 +1,92 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include <gtest/gtest.h>
12+#include "graph/passes/symbolic/symbolic_cond_remove_pass.h"
13+#include "graph/compute_graph.h"
14+#include "graph/op_desc.h"
15+#include "graph/utils/graph_utils.h"
16+#include "graph_builder_utils.h"
17+ 
18+namespace ge {
19+class UtestSymbolicCondRemovePass : public testing::Test {
20+ protected:
21+ void SetUp() {}
22+ void TearDown() {}
23+};
24+ 
25+TEST_F(UtestSymbolicCondRemovePass, run_non_cond_node_success) {
26+ std::vector<GeTensor> graph_inputs;
27+ SymbolicCondRemovePass pass(graph_inputs);
28+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
29+ GeTensorDesc tensor_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
30+ auto op_desc = std::make_shared<OpDesc>("add", ADD);
31+ op_desc->AddInputDesc(tensor_desc);
32+ op_desc->AddOutputDesc(tensor_desc);
33+ auto node = graph->AddNode(op_desc);
34+ EXPECT_EQ(pass.Run(node), SUCCESS);
35+}
36+ 
37+TEST_F(UtestSymbolicCondRemovePass, run_null_node_failed) {
38+ std::vector<GeTensor> graph_inputs;
39+ SymbolicCondRemovePass pass(graph_inputs);
40+ NodePtr node = nullptr;
41+ EXPECT_NE(pass.Run(node), SUCCESS);
42+}
43+ 
44+TEST_F(UtestSymbolicCondRemovePass, run_if_node_cond_not_data_success) {
45+ std::vector<GeTensor> graph_inputs;
46+ SymbolicCondRemovePass pass(graph_inputs);
47+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
48+ GeTensorDesc tensor_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
49+ auto const_desc = std::make_shared<OpDesc>("const", CONSTANTOP);
50+ const_desc->AddOutputDesc(tensor_desc);
51+ auto const_node = graph->AddNode(const_desc);
52+ 
53+ auto if_desc = std::make_shared<OpDesc>("if", "If");
54+ if_desc->AddInputDesc(tensor_desc);
55+ if_desc->AddOutputDesc(tensor_desc);
56+ auto if_node = graph->AddNode(if_desc);
57+ (void)GraphUtils::AddEdge(const_node->GetOutDataAnchor(0), if_node->GetInDataAnchor(0));
58+ 
59+ EXPECT_EQ(pass.Run(if_node), SUCCESS);
60+}
61+ 
62+TEST_F(UtestSymbolicCondRemovePass, run_case_node_cond_not_data_success) {
63+ std::vector<GeTensor> graph_inputs;
64+ SymbolicCondRemovePass pass(graph_inputs);
65+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
66+ GeTensorDesc tensor_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
67+ auto const_desc = std::make_shared<OpDesc>("const", CONSTANTOP);
68+ const_desc->AddOutputDesc(tensor_desc);
69+ auto const_node = graph->AddNode(const_desc);
70+ 
71+ auto case_desc = std::make_shared<OpDesc>("case", "Case");
72+ case_desc->AddInputDesc(tensor_desc);
73+ case_desc->AddOutputDesc(tensor_desc);
74+ auto case_node = graph->AddNode(case_desc);
75+ (void)GraphUtils::AddEdge(const_node->GetOutDataAnchor(0), case_node->GetInDataAnchor(0));
76+ 
77+ EXPECT_EQ(pass.Run(case_node), SUCCESS);
78+}
79+ 
80+TEST_F(UtestSymbolicCondRemovePass, run_if_node_no_cond_input_failed) {
81+ std::vector<GeTensor> graph_inputs;
82+ SymbolicCondRemovePass pass(graph_inputs);
83+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
84+ GeTensorDesc tensor_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
85+ auto if_desc = std::make_shared<OpDesc>("if", "If");
86+ if_desc->AddInputDesc(tensor_desc);
87+ if_desc->AddOutputDesc(tensor_desc);
88+ auto if_node = graph->AddNode(if_desc);
89+ 
90+ EXPECT_NE(pass.Run(if_node), SUCCESS);
91+}
92+} // namespace ge
Mtests/ge/ut/ge/graph/passes/tensor_move_delete_pass_unittest.cc+51-0
@@ -2673,3 +2673,54 @@ TEST_F(UtestTensorMoveDeletePass, KeepTMWhenPendingOrderDoesNotBypassRWConflict)
2673 EXPECT_NE(builder.GetGraph()->FindNode("TensorMove"), nullptr);2673 EXPECT_NE(builder.GetGraph()->FindNode("TensorMove"), nullptr);
2674 EXPECT_FALSE(sibling_node->GetOutControlAnchor()->IsLinkedWith(succ_node->GetInControlAnchor()));2674 EXPECT_FALSE(sibling_node->GetOutControlAnchor()->IsLinkedWith(succ_node->GetInControlAnchor()));
2675}2675}
2676+ 
2677+TEST_F(UtestTensorMoveDeletePass, NoTensorMoveInGraph) {
2678+ auto builder = ut::GraphBuilder("g1");
2679+ auto data = builder.AddNode("data", DATA, 0, 1);
2680+ auto add = builder.AddNode("add", ADD, 1, 1);
2681+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2682+ builder.AddDataEdge(data, 0, add, 0);
2683+ builder.AddDataEdge(add, 0, netoutput, 0);
2684+ 
2685+ ge::GEPass pass(builder.GetGraph());
2686+ TensorMoveDeletePass tensor_move_delete_pass;
2687+ ge::NamesToPass names_to_pass;
2688+ names_to_pass.emplace_back("TensorMoveDeletePass", &tensor_move_delete_pass);
2689+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
2690+}
2691+ 
2692+TEST_F(UtestTensorMoveDeletePass, TensorMoveWithNoNeedConstantFoldingAttr) {
2693+ auto builder = ut::GraphBuilder("g1");
2694+ auto data = builder.AddNode("data", DATA, 0, 1);
2695+ auto tensor_move = builder.AddNode("TensorMove", TENSORMOVE, 1, 1);
2696+ auto add = builder.AddNode("add", ADD, 1, 1);
2697+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2698+ AttrUtils::SetBool(tensor_move->GetOpDesc(), ATTR_NO_NEED_CONSTANT_FOLDING, true);
2699+ builder.AddDataEdge(data, 0, tensor_move, 0);
2700+ builder.AddDataEdge(tensor_move, 0, add, 0);
2701+ builder.AddDataEdge(add, 0, netoutput, 0);
2702+ 
2703+ ge::GEPass pass(builder.GetGraph());
2704+ TensorMoveDeletePass tensor_move_delete_pass;
2705+ ge::NamesToPass names_to_pass;
2706+ names_to_pass.emplace_back("TensorMoveDeletePass", &tensor_move_delete_pass);
2707+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
2708+ EXPECT_NE(builder.GetGraph()->FindNode("TensorMove"), nullptr);
2709+}
2710+ 
2711+TEST_F(UtestTensorMoveDeletePass, TensorMoveFromVariable) {
2712+ auto builder = ut::GraphBuilder("g1");
2713+ auto var = builder.AddNode("var", VARIABLE, 0, 1);
2714+ auto tensor_move = builder.AddNode("TensorMove", TENSORMOVE, 1, 1);
2715+ auto add = builder.AddNode("add", ADD, 1, 1);
2716+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2717+ builder.AddDataEdge(var, 0, tensor_move, 0);
2718+ builder.AddDataEdge(tensor_move, 0, add, 0);
2719+ builder.AddDataEdge(add, 0, netoutput, 0);
2720+ 
2721+ ge::GEPass pass(builder.GetGraph());
2722+ TensorMoveDeletePass tensor_move_delete_pass;
2723+ ge::NamesToPass names_to_pass;
2724+ names_to_pass.emplace_back("TensorMoveDeletePass", &tensor_move_delete_pass);
2725+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
2726+}
Mtests/ge/ut/ge/graph/passes/trans_op_breadth_fusion_pass_unittest.cc+36-0
@@ -576,3 +576,39 @@ TEST_F(UtestGraphPassesTransOpBreadthFusionPass, cast_fusion_with_same_type) {
576 EXPECT_EQ(SUCCESS, status);576 EXPECT_EQ(SUCCESS, status);
577 EXPECT_EQ(graph->GetDirectNodesSize(), 4);577 EXPECT_EQ(graph->GetDirectNodesSize(), 4);
578}578}
579+ 
580+TEST_F(UtestGraphPassesTransOpBreadthFusionPass, transpose_d_with_perm_test) {
581+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
582+ auto data = NodeBuilder("data", DATA).AddOutputDesc({1, 1, 1, 1}).Build(graph);
583+ auto transposed =
584+ NodeBuilder("transposed", TRANSPOSED).AddInputDesc({1, 1, 1, 1}).AddOutputDesc({1, 1, 1, 1}).Build(graph);
585+ AttrUtils::SetListInt(transposed->GetOpDesc(), "perm", {0, 2, 1, 3});
586+ auto relu = NodeBuilder("relu", RELU).AddInputDesc({1, 1, 1, 1}).Build(graph);
587+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), transposed->GetInDataAnchor(0));
588+ GraphUtils::AddEdge(transposed->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
589+ 
590+ TransOpBreadthFusionPass pass;
591+ Status status = pass.Run(graph);
592+ EXPECT_EQ(status, SUCCESS);
593+}
594+ 
595+TEST_F(UtestGraphPassesTransOpBreadthFusionPass, transpose_without_const_perm_test) {
596+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
597+ auto data = NodeBuilder("data", DATA).AddOutputDesc({1, 1, 1, 1}).Build(graph);
598+ auto perm_data = NodeBuilder("perm_data", DATA).AddOutputDesc({4}).Build(graph);
599+ auto transpose = NodeBuilder("transpose", TRANSPOSE)
600+ .AddInputDesc({1, 1, 1, 1})
601+ .AddInputDesc({4})
602+ .AddOutputDesc({1, 1, 1, 1})
603+ .Build(graph);
604+ auto relu = NodeBuilder("relu", RELU).AddInputDesc({1, 1, 1, 1}).Build(graph);
605+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), transpose->GetInDataAnchor(0));
606+ GraphUtils::AddEdge(perm_data->GetOutDataAnchor(0), transpose->GetInDataAnchor(1));
607+ GraphUtils::AddEdge(transpose->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
608+ std::map<std::string, uint32_t> input_names = {{"x", 0}, {"perm", 1}};
609+ transpose->GetOpDesc()->UpdateInputName(input_names);
610+ 
611+ TransOpBreadthFusionPass pass;
612+ Status status = pass.Run(graph);
613+ EXPECT_EQ(status, SUCCESS);
614+}
Mtests/ge/ut/ge/graph/passes/transop_symmetry_elimination_pass_unittest.cc+44-0
@@ -479,4 +479,48 @@ TEST_F(UtestTransopSymmetryEliminationPass, test_reshape_remove_with_transdata_5
479 EXPECT_EQ(compute_graph->FindNode("trans1"), nullptr);479 EXPECT_EQ(compute_graph->FindNode("trans1"), nullptr);
480 EXPECT_EQ(compute_graph->FindNode("trans2"), nullptr);480 EXPECT_EQ(compute_graph->FindNode("trans2"), nullptr);
481}481}
482+ 
483+TEST_F(UtestTransopSymmetryEliminationPass, non_symmetric_transpose_d_test) {
484+ auto builder = ut::GraphBuilder("test_non_symm");
485+ auto data = builder.AddNode("data", DATA, 0, 1);
486+ auto trans1 = builder.AddNode("trans1", TRANSPOSED, 1, 1);
487+ auto trans2 = builder.AddNode("trans2", TRANSPOSED, 1, 1);
488+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
489+ 
490+ AttrUtils::SetListInt(trans1->GetOpDesc(), PERMUTE_ATTR_PERM, {0, 2, 1, 3});
491+ AttrUtils::SetListInt(trans2->GetOpDesc(), PERMUTE_ATTR_PERM, {0, 2, 1, 3});
492+ 
493+ builder.AddDataEdge(data, 0, trans1, 0);
494+ builder.AddDataEdge(trans1, 0, trans2, 0);
495+ builder.AddDataEdge(trans2, 0, netoutput, 0);
496+ 
497+ auto graph = builder.GetGraph();
498+ TransOpSymmetryEliminationPass transop_symmetry_elimination_pass;
499+ NamesToPass names_to_pass;
500+ names_to_pass.emplace_back("TransOpSymmetryEliminationPass", &transop_symmetry_elimination_pass);
501+ GEPass pass(graph);
502+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
503+}
504+ 
505+TEST_F(UtestTransopSymmetryEliminationPass, transpose_d_different_perm_size_test) {
506+ auto builder = ut::GraphBuilder("test_diff_perm_size");
507+ auto data = builder.AddNode("data", DATA, 0, 1);
508+ auto trans1 = builder.AddNode("trans1", TRANSPOSED, 1, 1);
509+ auto trans2 = builder.AddNode("trans2", TRANSPOSED, 1, 1);
510+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
511+ 
512+ AttrUtils::SetListInt(trans1->GetOpDesc(), PERMUTE_ATTR_PERM, {0, 2, 1, 3});
513+ AttrUtils::SetListInt(trans2->GetOpDesc(), PERMUTE_ATTR_PERM, {0, 1});
514+ 
515+ builder.AddDataEdge(data, 0, trans1, 0);
516+ builder.AddDataEdge(trans1, 0, trans2, 0);
517+ builder.AddDataEdge(trans2, 0, netoutput, 0);
518+ 
519+ auto graph = builder.GetGraph();
520+ TransOpSymmetryEliminationPass transop_symmetry_elimination_pass;
521+ NamesToPass names_to_pass;
522+ names_to_pass.emplace_back("TransOpSymmetryEliminationPass", &transop_symmetry_elimination_pass);
523+ GEPass pass(graph);
524+ EXPECT_EQ(pass.Run(names_to_pass), SUCCESS);
525+}
482} // namespace ge526} // namespace ge
Mtests/ge/ut/ge/graph/passes/transop_without_reshape_fusion_pass_unittest.cc+24-0
@@ -2813,4 +2813,28 @@ TEST_F(UtestTransopWithoutReshapeFusionPass, test_cast_fusion_has_precision_loss
2813 EXPECT_EQ(domi::SUCCESS, status);2813 EXPECT_EQ(domi::SUCCESS, status);
2814 EXPECT_EQ(graph->GetDirectNodesSize(), 5);2814 EXPECT_EQ(graph->GetDirectNodesSize(), 5);
2815}2815}
2816+ 
2817+TEST_F(UtestTransopWithoutReshapeFusionPass, set_remain_node_with_null_anchor) {
2818+ TransOpWithoutReshapeFusionPass pass;
2819+ std::vector<std::pair<OutDataAnchorPtr, InDataAnchorPtr>> nodes_anchor;
2820+ nodes_anchor.push_back({nullptr, nullptr});
2821+ pass.SetRemainNode(nodes_anchor);
2822+}
2823+ 
2824+TEST_F(UtestTransopWithoutReshapeFusionPass, set_remain_node_with_non_transop) {
2825+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
2826+ auto data_op = std::make_shared<OpDesc>("data", DATA);
2827+ data_op->AddOutputDesc(GeTensorDesc());
2828+ auto data = graph->AddNode(data_op);
2829+ auto relu_op = std::make_shared<OpDesc>("relu", RELU);
2830+ relu_op->AddInputDesc(GeTensorDesc());
2831+ relu_op->AddOutputDesc(GeTensorDesc());
2832+ auto relu = graph->AddNode(relu_op);
2833+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
2834+ 
2835+ TransOpWithoutReshapeFusionPass pass;
2836+ std::vector<std::pair<OutDataAnchorPtr, InDataAnchorPtr>> nodes_anchor;
2837+ nodes_anchor.push_back({data->GetOutDataAnchor(0), relu->GetInDataAnchor(0)});
2838+ pass.SetRemainNode(nodes_anchor);
2839+}
2816} // namespace ge2840} // namespace ge
Mtests/ge/ut/ge/graph/passes/transpose_transdata_pass_unittest.cc+14-0
@@ -462,4 +462,18 @@ TEST_F(UtestGraphPassesTransposeTransdataPass, check_in_out_data_anchor_valid_fa
462 EXPECT_EQ(ret, FAILED);462 EXPECT_EQ(ret, FAILED);
463}463}
464 464 
465+TEST_F(UtestGraphPassesTransposeTransdataPass, fusion_transpose_with_non_transdata_output) {
466+ auto compute_graph = BuildGraphTransposeD();
467+ auto transpose = compute_graph->FindNode("transpose1");
468+ ASSERT_NE(transpose, nullptr);
469+ TransposeTransDataPass pass;
470+ Status ret = pass.FusionTranspose(transpose);
471+ EXPECT_EQ(ret, SUCCESS);
472+}
473+ 
474+TEST_F(UtestGraphPassesTransposeTransdataPass, check_in_out_data_anchor_valid_null_node) {
475+ TransposeTransDataPass pass;
476+ Status ret = pass.CheckInOutDataAnchorValid(nullptr, 1U, 1U);
477+ EXPECT_EQ(ret, PARAM_INVALID);
478+}
465} // namespace ge479} // namespace ge
Mtests/ge/ut/ge/graph/passes/var_is_initialized_op_pass_unittest.cc+59-0
@@ -879,4 +879,63 @@ TEST_F(UTEST_graph_passes_var_is_initialized_op_pass, is_variable_initialized_su
879 879 
880 VarManagerPool::Instance().Destroy();880 VarManagerPool::Instance().Destroy();
881}881}
882+ 
883+TEST_F(UTEST_graph_passes_var_is_initialized_op_pass, run_non_var_is_init_node_success) {
884+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
885+ GeTensorDesc tensor_desc;
886+ auto const_op = std::make_shared<OpDesc>("const", CONSTANT);
887+ const_op->AddOutputDesc(tensor_desc);
888+ auto const_node = graph->AddNode(const_op);
889+ 
890+ VarIsInitializedOpPass pass;
891+ EXPECT_EQ(pass.Run(const_node), SUCCESS);
892+}
893+ 
894+TEST_F(UTEST_graph_passes_var_is_initialized_op_pass, run_assign_node_no_input_desc) {
895+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
896+ auto assign_op = std::make_shared<OpDesc>("assign", ASSIGN);
897+ assign_op->AddOutputDesc(GeTensorDesc());
898+ auto assign_node = graph->AddNode(assign_op);
899+ 
900+ VarIsInitializedOpPass pass;
901+ EXPECT_EQ(pass.Run(assign_node), PARAM_INVALID);
902+}
903+ 
904+TEST_F(UTEST_graph_passes_var_is_initialized_op_pass, run_assign_node_no_peer_edge) {
905+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
906+ GeTensorDesc tensor_desc;
907+ auto assign_op = std::make_shared<OpDesc>("assign", ASSIGN);
908+ assign_op->AddInputDesc(tensor_desc);
909+ assign_op->AddInputDesc(tensor_desc);
910+ assign_op->AddOutputDesc(tensor_desc);
911+ auto assign_node = graph->AddNode(assign_op);
912+ 
913+ VarIsInitializedOpPass pass;
914+ EXPECT_EQ(pass.Run(assign_node), PARAM_INVALID);
915+}
916+ 
917+TEST_F(UTEST_graph_passes_var_is_initialized_op_pass, run_assign_node_with_variable_success) {
918+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
919+ GeTensorDesc tensor_desc;
920+ auto var_op = std::make_shared<OpDesc>("variable", VARIABLE);
921+ var_op->AddOutputDesc(tensor_desc);
922+ auto var_node = graph->AddNode(var_op);
923+ 
924+ auto value_op = std::make_shared<OpDesc>("value", CONSTANTOP);
925+ value_op->AddOutputDesc(tensor_desc);
926+ auto value_node = graph->AddNode(value_op);
927+ 
928+ auto assign_op = std::make_shared<OpDesc>("assign", ASSIGN);
929+ assign_op->AddInputDesc(tensor_desc);
930+ assign_op->AddInputDesc(tensor_desc);
931+ assign_op->AddOutputDesc(tensor_desc);
932+ auto assign_node = graph->AddNode(assign_op);
933+ (void)GraphUtils::AddEdge(var_node->GetOutDataAnchor(0), assign_node->GetInDataAnchor(0));
934+ (void)GraphUtils::AddEdge(value_node->GetOutDataAnchor(0), assign_node->GetInDataAnchor(1));
935+ 
936+ VarIsInitializedOpPass pass;
937+ EXPECT_EQ(pass.Run(assign_node), SUCCESS);
938+ 
939+ VarManagerPool::Instance().Destroy();
940+}
882} // namespace ge941} // namespace ge
Mtests/ge/ut/ge/graph/passes/variable_op_pass_unittest.cc+27-0
@@ -1186,3 +1186,30 @@ TEST_F(UtestVariableOpPassUnit, CheckVarAndVarRefAreAlikeFailed) {
1186 auto status = pass.CheckVarAndVarRefAreAlike(node, node, flag);1186 auto status = pass.CheckVarAndVarRefAreAlike(node, node, flag);
1187 EXPECT_EQ(GE_GRAPH_VARIABLE_OP_PASS_FAILED, status);1187 EXPECT_EQ(GE_GRAPH_VARIABLE_OP_PASS_FAILED, status);
1188}1188}
1189+ 
1190+TEST_F(UtestVariableOpPassUnit, RunEmptyGraph) {
1191+ GraphRebuildStateCtrl ctrl;
1192+ VariableOpPass pass(&ctrl);
1193+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("empty_graph");
1194+ auto status = pass.Run(graph);
1195+ EXPECT_EQ(status, SUCCESS);
1196+}
1197+ 
1198+TEST_F(UtestVariableOpPassUnit, RunGraphWithVarAndTransOp) {
1199+ GraphRebuildStateCtrl ctrl;
1200+ VariableOpPass pass(&ctrl);
1201+ auto graph = BuildGraph2();
1202+ auto status = pass.Run(graph);
1203+ EXPECT_EQ(status, SUCCESS);
1204+}
1205+ 
1206+TEST_F(UtestVariableOpPassUnit, UpdateVarAndRefOutputFormatInfoSuccess) {
1207+ GraphRebuildStateCtrl ctrl;
1208+ VariableOpPass pass(&ctrl);
1209+ auto graph = BuildGraphVariableOpPass();
1210+ auto node = graph->FindNode("translate0");
1211+ ASSERT_NE(node, nullptr);
1212+ auto same_vars = MakeShared<SameVariable>();
1213+ auto status = pass.UpdateVarAndRefOutputFormatInfo(node->GetOpDesc()->GetOutputDesc(0U), node, same_vars);
1214+ EXPECT_EQ(status, SUCCESS);
1215+}
Mtests/ge/ut/ge/graph/passes/variable_prepare_pass_unittest.cc+26-0
@@ -19,6 +19,7 @@
19#include "ge_graph_dsl/graph_dsl.h"19#include "ge_graph_dsl/graph_dsl.h"
20#include "graph/utils/graph_utils_ex.h"20#include "graph/utils/graph_utils_ex.h"
21#include "graph/utils/graph_utils.h"21#include "graph/utils/graph_utils.h"
22+#include "graph_builder_utils.h"
22#include "macro_utils/dt_public_unscope.h"23#include "macro_utils/dt_public_unscope.h"
23 24 
24using namespace ge;25using namespace ge;
@@ -318,3 +319,28 @@ TEST_F(UtestGraphPassesVariablePreparePass, check_stream_label_with_attr) {
318 ASSERT_NE(var_ref, nullptr);319 ASSERT_NE(var_ref, nullptr);
319 EXPECT_EQ(pass.CheckStreamLabel(var_ref, variable), SUCCESS);320 EXPECT_EQ(pass.CheckStreamLabel(var_ref, variable), SUCCESS);
320}321}
322+ 
323+TEST_F(UtestGraphPassesVariablePreparePass, run_with_ref_switch_and_no_var) {
324+ auto builder = ut::GraphBuilder("g1");
325+ GeTensorDesc tensor_desc(GeShape({2, 2}), FORMAT_NCHW, DT_FLOAT);
326+ auto data = builder.AddNode("data", DATA, 0, 1);
327+ auto ref_switch = builder.AddNode("refswitch", REFSWITCH, 2, 2);
328+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
329+ builder.AddDataEdge(data, 0, ref_switch, 0);
330+ builder.AddDataEdge(ref_switch, 0, netoutput, 0);
331+ 
332+ VariablePrepareOpPass pass;
333+ auto graph = builder.GetGraph();
334+ EXPECT_EQ(pass.Run(graph), SUCCESS);
335+}
336+ 
337+TEST_F(UtestGraphPassesVariablePreparePass, create_variable_ref_null_opdesc) {
338+ auto graph = BuildGraphVariablePreparePass();
339+ VariablePrepareOpPass pass;
340+ auto variable = graph->FindNode("variable");
341+ ASSERT_NE(variable, nullptr);
342+ auto var_ref = pass.CreateVariableRef("test_var_ref", variable);
343+ ASSERT_NE(var_ref, nullptr);
344+ auto var_ref2 = pass.CreateVariableRef("test_var_ref2", variable);
345+ ASSERT_NE(var_ref2, nullptr);
346+}
Mtests/ge/ut/ge/graph/preprocess/graph_preprocess_unittest.cc+338-0
@@ -2077,4 +2077,342 @@ TEST_F(UtestGraphPreproces, graph_prepare_update_variable_formats_null_graph) {
2077 auto ret = graph_prepare.UpdateVariableFormats(nullptr);2077 auto ret = graph_prepare.UpdateVariableFormats(nullptr);
2078 EXPECT_NE(ret, SUCCESS);2078 EXPECT_NE(ret, SUCCESS);
2079}2079}
2080+ 
2081+TEST_F(UtestGraphPreproces, AdjustDataOpOutput_NullNode_ReturnsError) {
2082+ ge::GraphPrepare graph_prepare;
2083+ NodePtr null_node = nullptr;
2084+ auto ret = graph_prepare.AdjustDataOpOutput(null_node);
2085+ EXPECT_NE(ret, SUCCESS);
2086+}
2087+ 
2088+TEST_F(UtestGraphPreproces, CheckRefInputNode_NullNode_ReturnsError) {
2089+ ge::GraphPrepare graph_prepare;
2090+ NodePtr null_node = nullptr;
2091+ auto ret = graph_prepare.CheckRefInputNode(null_node, "input_name", {});
2092+ EXPECT_NE(ret, SUCCESS);
2093+}
2094+ 
2095+TEST_F(UtestGraphPreproces, SaveOriginalGraphToOmModel_EmptyGraph_ReturnsSuccess) {
2096+ ge::GraphPrepare graph_prepare;
2097+ Graph graph("");
2098+ auto ret = graph_prepare.SaveOriginalGraphToOmModel();
2099+ EXPECT_EQ(ret, SUCCESS);
2100+}
2101+ 
2102+TEST_F(UtestGraphPreproces, SetOptions_Test) {
2103+ ge::GraphPrepare graph_prepare;
2104+ GraphManagerOptions options;
2105+ graph_prepare.SetOptions(options);
2106+}
2107+ 
2108+TEST_F(UtestGraphPreproces, CheckAippInsert_NoAipp_ReturnsSuccess) {
2109+ auto builder = ut::GraphBuilder("g_no_aipp");
2110+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2111+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 1);
2112+ builder.AddDataEdge(data1, 0, netoutput, 0);
2113+ ge::GraphPrepare graph_prepare;
2114+ graph_prepare.compute_graph_ = builder.GetGraph();
2115+ auto ret = graph_prepare.CheckAippInsert();
2116+ EXPECT_EQ(ret, SUCCESS);
2117+}
2118+ 
2119+TEST_F(UtestGraphPreproces, ProcessNetOutput_NoNetOutput_ReturnsSuccess) {
2120+ auto builder = ut::GraphBuilder("g_no_output");
2121+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2122+ auto add1 = builder.AddNode("add1", "Add", 1, 1);
2123+ builder.AddDataEdge(data1, 0, add1, 0);
2124+ ge::GraphPrepare graph_prepare;
2125+ graph_prepare.compute_graph_ = builder.GetGraph();
2126+ auto ret = graph_prepare.ProcessNetOutput();
2127+ EXPECT_EQ(ret, SUCCESS);
2128+}
2129+ 
2130+TEST_F(UtestGraphPreproces, CheckConstOp_NoConst_ReturnsSuccess) {
2131+ auto builder = ut::GraphBuilder("g_no_const");
2132+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2133+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 1);
2134+ builder.AddDataEdge(data1, 0, netoutput, 0);
2135+ ge::GraphPrepare graph_prepare;
2136+ graph_prepare.compute_graph_ = builder.GetGraph();
2137+ auto ret = graph_prepare.CheckConstOp();
2138+ EXPECT_EQ(ret, SUCCESS);
2139+}
2140+ 
2141+TEST_F(UtestGraphPreproces, RemoveMagicCompiledAttrs_EmptyGraph) {
2142+ auto builder = ut::GraphBuilder("g_empty");
2143+ ge::GraphPrepare graph_prepare;
2144+ graph_prepare.compute_graph_ = builder.GetGraph();
2145+ graph_prepare.RemoveMagicCompiledAttrs();
2146+ SUCCEED();
2147+}
2148+ 
2149+TEST_F(UtestGraphPreproces, TypeConversionOfConstant_NoConst) {
2150+ auto builder = ut::GraphBuilder("g_no_const2");
2151+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2152+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 1);
2153+ builder.AddDataEdge(data1, 0, netoutput, 0);
2154+ ge::GraphPrepare graph_prepare;
2155+ graph_prepare.compute_graph_ = builder.GetGraph();
2156+ graph_prepare.TypeConversionOfConstant();
2157+ SUCCEED();
2158+}
2159+ 
2160+TEST_F(UtestGraphPreproces, CheckGraphAndUpdateOriginShape_NullGraph) {
2161+ ge::GraphPrepare graph_prepare;
2162+ graph_prepare.compute_graph_ = nullptr;
2163+ auto ret = graph_prepare.CheckGraphAndUpdateOriginShape();
2164+ EXPECT_EQ(ret, GE_GRAPH_INIT_FAILED);
2165+}
2166+ 
2167+TEST_F(UtestGraphPreproces, AdjustDataOpOutput_NullOpDesc) {
2168+ auto builder = ut::GraphBuilder("g_adj_null_op");
2169+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2170+ ge::GraphPrepare graph_prepare;
2171+ graph_prepare.compute_graph_ = builder.GetGraph();
2172+ auto ret = graph_prepare.AdjustDataOpOutput(data1);
2173+ EXPECT_EQ(ret, SUCCESS);
2174+}
2175+ 
2176+TEST_F(UtestGraphPreproces, SwitchOpOptimize_NullGraph) {
2177+ ge::GraphPrepare graph_prepare;
2178+ ComputeGraphPtr null_graph = nullptr;
2179+ auto ret = graph_prepare.SwitchOpOptimize(null_graph);
2180+ EXPECT_EQ(ret, GE_GRAPH_NULL_INPUT);
2181+}
2182+ 
2183+TEST_F(UtestGraphPreproces, GenerateInfershapeGraph_NullGraph) {
2184+ ge::GraphPrepare graph_prepare;
2185+ ConstGraphPtr null_graph = nullptr;
2186+ auto ret = graph_prepare.GenerateInfershapeGraph(null_graph);
2187+ EXPECT_EQ(ret, GE_GRAPH_NULL_INPUT);
2188+}
2189+ 
2190+TEST_F(UtestGraphPreproces, CheckConstOp_FrameworkOpNullOpDesc) {
2191+ auto builder = ut::GraphBuilder("g_fw_null");
2192+ auto fw_node = builder.AddNode("fw1", FRAMEWORKOP, 1, 1);
2193+ ge::GraphPrepare graph_prepare;
2194+ graph_prepare.compute_graph_ = builder.GetGraph();
2195+ auto ret = graph_prepare.CheckConstOp();
2196+ EXPECT_EQ(ret, SUCCESS);
2197+}
2198+ 
2199+TEST_F(UtestGraphPreproces, VerifyConstOp_NoWeights) {
2200+ auto builder = ut::GraphBuilder("g_no_weights");
2201+ auto const_node = builder.AddNode("const1", CONSTANT, 0, 1);
2202+ ge::GraphPrepare graph_prepare;
2203+ graph_prepare.compute_graph_ = builder.GetGraph();
2204+ auto ret = graph_prepare.VerifyConstOp(const_node);
2205+ EXPECT_EQ(ret, PARAM_INVALID);
2206+}
2207+ 
2208+TEST_F(UtestGraphPreproces, CheckUserInput_MissingIndexAttr) {
2209+ auto builder = ut::GraphBuilder("g_missing_idx");
2210+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2211+ ge::GraphPrepare graph_prepare;
2212+ graph_prepare.compute_graph_ = builder.GetGraph();
2213+ std::vector<GeTensor> user_input;
2214+ auto ret = graph_prepare.CheckUserInput(user_input);
2215+ EXPECT_EQ(ret, GE_GRAPH_INIT_FAILED);
2216+}
2217+ 
2218+TEST_F(UtestGraphPreproces, CheckUserInput_InvalidIndex) {
2219+ auto builder = ut::GraphBuilder("g_invalid_idx");
2220+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2221+ (void)ge::AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_INDEX, 99);
2222+ ge::GraphPrepare graph_prepare;
2223+ graph_prepare.compute_graph_ = builder.GetGraph();
2224+ std::vector<GeTensor> user_input;
2225+ auto ret = graph_prepare.CheckUserInput(user_input);
2226+ EXPECT_EQ(ret, GE_GRAPH_INIT_FAILED);
2227+}
2228+ 
2229+TEST_F(UtestGraphPreproces, UpdateInput_InvalidIndex) {
2230+ auto builder = ut::GraphBuilder("g_upd_invalid_idx");
2231+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2232+ (void)ge::AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_INDEX, 99);
2233+ ge::GraphPrepare graph_prepare;
2234+ graph_prepare.compute_graph_ = builder.GetGraph();
2235+ std::vector<GeTensor> user_input;
2236+ std::map<std::string, std::string> graph_option;
2237+ auto ret = graph_prepare.UpdateInput(user_input, graph_option);
2238+ EXPECT_EQ(ret, FAILED);
2239+}
2240+ 
2241+TEST_F(UtestGraphPreproces, UpdateVariableFormats_WithVar) {
2242+ auto builder = ut::GraphBuilder("g_with_var");
2243+ auto var = builder.AddNode("var1", VARIABLEV2, 1, 1);
2244+ auto add = builder.AddNode("add1", "Add", 1, 1);
2245+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2246+ builder.AddDataEdge(var, 0, add, 0);
2247+ builder.AddDataEdge(add, 0, netoutput, 0);
2248+ ge::GraphPrepare graph_prepare;
2249+ auto ret = graph_prepare.UpdateVariableFormats(builder.GetGraph());
2250+ EXPECT_EQ(ret, SUCCESS);
2251+}
2252+ 
2253+TEST_F(UtestGraphPreproces, CheckAndUpdateInput_Normalized) {
2254+ auto builder = ut::GraphBuilder("g_normalized");
2255+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2256+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2257+ builder.AddDataEdge(data1, 0, netoutput, 0);
2258+ ge::GraphPrepare graph_prepare;
2259+ graph_prepare.compute_graph_ = builder.GetGraph();
2260+ graph_prepare.SetGraphNormalized(true);
2261+ std::vector<GeTensor> user_input;
2262+ std::map<std::string, std::string> graph_option;
2263+ auto ret = graph_prepare.CheckAndUpdateInput(user_input, graph_option);
2264+ EXPECT_EQ(ret, SUCCESS);
2265+}
2266+ 
2267+TEST_F(UtestGraphPreproces, CheckRefInputNode_ConstInput) {
2268+ auto builder = ut::GraphBuilder("g_ref_const");
2269+ auto const1 = builder.AddNode("const1", CONSTANTOP, 0, 1);
2270+ auto ref_node = builder.AddNode("ref1", "RefOp", 1, 1);
2271+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2272+ builder.AddDataEdge(const1, 0, ref_node, 0);
2273+ builder.AddDataEdge(ref_node, 0, netoutput, 0);
2274+ (void)ref_node->GetOpDesc()->AddInputDesc("x", GeTensorDesc());
2275+ std::set<NodePtr> ref_nodes;
2276+ ge::GraphPrepare graph_prepare;
2277+ auto ret = graph_prepare.CheckRefInputNode(ref_node, "x", ref_nodes);
2278+ EXPECT_EQ(ret, PARAM_INVALID);
2279+}
2280+ 
2281+TEST_F(UtestGraphPreproces, InferShapeForPreprocess_BasicGraph) {
2282+ auto builder = ut::GraphBuilder("g_infer_pre");
2283+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2284+ auto add1 = builder.AddNode("add1", "Add", 1, 1);
2285+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2286+ builder.AddDataEdge(data1, 0, add1, 0);
2287+ builder.AddDataEdge(add1, 0, netoutput, 0);
2288+ ge::GraphPrepare graph_prepare;
2289+ auto graph = builder.GetGraph();
2290+ auto ret = graph_prepare.InferShapeForPreprocess(graph, nullptr, nullptr);
2291+ EXPECT_EQ(ret, SUCCESS);
2292+}
2293+ 
2294+TEST_F(UtestGraphPreproces, CheckTensorIsValid_ScalarTensor) {
2295+ auto builder = ut::GraphBuilder("g_scalar");
2296+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2297+ ge::GraphPrepare graph_prepare;
2298+ auto ret = graph_prepare.CheckTensorIsValid(data1, 0, 4, 0, DT_FLOAT);
2299+ EXPECT_EQ(ret, SUCCESS);
2300+}
2301+ 
2302+TEST_F(UtestGraphPreproces, CheckTensorIsValid_EmptyShapeWithData) {
2303+ auto builder = ut::GraphBuilder("g_empty_shape");
2304+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2305+ ge::GraphPrepare graph_prepare;
2306+ auto ret = graph_prepare.CheckTensorIsValid(data1, 0, 10, 1, DT_FLOAT);
2307+ EXPECT_NE(ret, SUCCESS);
2308+}
2309+ 
2310+TEST_F(UtestGraphPreproces, CheckTensorIsValid_ValidTensor) {
2311+ auto builder = ut::GraphBuilder("g_valid_tensor");
2312+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2313+ ge::GraphPrepare graph_prepare;
2314+ auto ret = graph_prepare.CheckTensorIsValid(data1, 4, 16, 1, DT_FLOAT);
2315+ EXPECT_EQ(ret, SUCCESS);
2316+}
2317+ 
2318+TEST_F(UtestGraphPreproces, IsDynamicDims_WithDynamicOption) {
2319+ auto builder = ut::GraphBuilder("g_dyn_dims");
2320+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2321+ auto op_desc = data1->GetOpDesc();
2322+ GeTensorDesc desc(GeShape({-1, 2, 3, 4}), FORMAT_NCHW, DT_FLOAT);
2323+ op_desc->UpdateOutputDesc(0, desc);
2324+ ge::GraphPrepare graph_prepare;
2325+ graph_prepare.options_.input_shape = "1,2,3,4";
2326+ graph_prepare.options_.dynamic_dims = "-1,2,3,4";
2327+ graph_prepare.options_.dynamic_node_type = 1;
2328+ auto ret = graph_prepare.IsDynamicDims(data1);
2329+ EXPECT_TRUE(ret);
2330+}
2331+ 
2332+TEST_F(UtestGraphPreproces, IsDynamicDims_WithCompileDynamicMode) {
2333+ auto builder = ut::GraphBuilder("g_dyn_mode");
2334+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2335+ auto op_desc = data1->GetOpDesc();
2336+ GeTensorDesc desc(GeShape({-1, 2, 3, 4}), FORMAT_NCHW, DT_FLOAT);
2337+ op_desc->UpdateOutputDesc(0, desc);
2338+ ge::GraphPrepare graph_prepare;
2339+ (void)ge::GetThreadLocalContext().SetGraphOption({{"ge.compile_dynamic_mode", "1"}});
2340+ auto ret = graph_prepare.IsDynamicDims(data1);
2341+ EXPECT_TRUE(ret);
2342+ (void)ge::GetThreadLocalContext().SetGraphOption({{"ge.compile_dynamic_mode", ""}});
2343+}
2344+ 
2345+TEST_F(UtestGraphPreproces, UpdateInputOutputByOptions_TrainMode) {
2346+ auto builder = ut::GraphBuilder("g_train_mode");
2347+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2348+ ge::GraphPrepare graph_prepare;
2349+ graph_prepare.compute_graph_ = builder.GetGraph();
2350+ graph_prepare.options_.train_graph_flag = true;
2351+ auto ret = graph_prepare.UpdateInputOutputByOptions();
2352+ EXPECT_EQ(ret, SUCCESS);
2353+}
2354+ 
2355+TEST_F(UtestGraphPreproces, TryDoAipp_WithInsertOpFile) {
2356+ auto builder = ut::GraphBuilder("g_aipp_insert");
2357+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2358+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2359+ builder.AddDataEdge(data1, 0, netoutput, 0);
2360+ ge::GraphPrepare graph_prepare;
2361+ graph_prepare.compute_graph_ = builder.GetGraph();
2362+ graph_prepare.options_.insert_op_file = "/nonexistent/aipp.cfg";
2363+ auto ret = graph_prepare.TryDoAipp();
2364+ EXPECT_NE(ret, SUCCESS);
2365+}
2366+ 
2367+TEST_F(UtestGraphPreproces, PrepareDynShape_BasicGraph) {
2368+ auto builder = ut::GraphBuilder("g_prep_dyn");
2369+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2370+ auto add1 = builder.AddNode("add1", "Add", 1, 1);
2371+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2372+ builder.AddDataEdge(data1, 0, add1, 0);
2373+ builder.AddDataEdge(add1, 0, netoutput, 0);
2374+ ge::GraphPrepare graph_prepare;
2375+ graph_prepare.compute_graph_ = builder.GetGraph();
2376+ auto ret = graph_prepare.PrepareDynShape();
2377+ EXPECT_EQ(ret, SUCCESS);
2378+}
2379+ 
2380+TEST_F(UtestGraphPreproces, CheckGraphAndUpdateOriginShape_EmptyGraph) {
2381+ auto builder = ut::GraphBuilder("g_empty_nodes");
2382+ ge::GraphPrepare graph_prepare;
2383+ graph_prepare.compute_graph_ = builder.GetGraph();
2384+ auto ret = graph_prepare.CheckGraphAndUpdateOriginShape();
2385+ EXPECT_EQ(ret, GE_GRAPH_INIT_FAILED);
2386+}
2387+ 
2388+TEST_F(UtestGraphPreproces, CheckInternalFormat_BasicCheck) {
2389+ auto builder = ut::GraphBuilder("g_internal_fmt");
2390+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2391+ ge::GraphPrepare graph_prepare;
2392+ GeTensorDesc desc(GeShape({1, 2, 3, 4}), FORMAT_NCHW, DT_FLOAT);
2393+ auto ret = graph_prepare.CheckInternalFormat(data1, desc);
2394+ EXPECT_EQ(ret, SUCCESS);
2395+}
2396+ 
2397+TEST_F(UtestGraphPreproces, UpdateDataInputOutputDesc_InvalidDataType) {
2398+ auto builder = ut::GraphBuilder("g_invalid_dt");
2399+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2400+ ge::GraphPrepare graph_prepare;
2401+ GeTensorDesc desc(GeShape({1, 2, 3, 4}), FORMAT_NCHW, DT_UNDEFINED);
2402+ auto ret = graph_prepare.UpdateDataInputOutputDesc(0, data1->GetOpDesc(), desc);
2403+ EXPECT_EQ(ret, FAILED);
2404+}
2405+ 
2406+TEST_F(UtestGraphPreproces, CopyVarIntoSubgraph_BasicGraph) {
2407+ auto builder = ut::GraphBuilder("g_copy_var");
2408+ auto data1 = builder.AddNode("data1", DATA, 1, 1);
2409+ auto add1 = builder.AddNode("add1", "Add", 1, 1);
2410+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
2411+ builder.AddDataEdge(data1, 0, add1, 0);
2412+ builder.AddDataEdge(add1, 0, netoutput, 0);
2413+ ge::GraphPrepare graph_prepare;
2414+ graph_prepare.compute_graph_ = builder.GetGraph();
2415+ auto ret = graph_prepare.CopyVarIntoSubgraph();
2416+ EXPECT_EQ(ret, SUCCESS);
2417+}
2080} // namespace ge2418} // namespace ge
Mtests/ge/ut/ge/graph/preprocess/insert_op/ge_aipp_op_unittest.cc+35-1
@@ -1324,7 +1324,41 @@ TEST_F(UtestGeAipp, test_ConvertParamToJsonWithRawRgbir) {
1324 domi::GetContext().data_tensor_names = data_tensor_names_old;1324 domi::GetContext().data_tensor_names = data_tensor_names_old;
1325}1325}
1326 1326 
1327-TEST_F(UtestGeAipp, test_SetDefaultParamsStaticWithAllOpsEnabled) {1327+TEST_F(UtestGeAipp, test_CreateAippDataNhwc) {
1328+ ge::ut::GraphBuilder builder("graph");
1329+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
1330+ ge::AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_INDEX, 0);
1331+ auto aipp = builder.AddNode("aipp", "aipp", 2, 1);
1332+ auto netoutput = builder.AddNode("Node_Output", "NetOutput", 1, 0);
1333+ 
1334+ aipp->GetOpDesc()->AddInputDesc(ge::GeTensorDesc());
1335+ aipp->GetOpDesc()->AddInputDesc(ge::GeTensorDesc());
1336+ aipp->GetOpDesc()->AddOutputDesc(ge::GeTensorDesc());
1337+ data1->GetOpDesc()->AddOutputDesc(GeTensorDesc(GeShape(std::vector<int64_t>{8, 224, 224, 3}), FORMAT_NHWC, DT_FLOAT));
1338+ data1->GetOpDesc()->UpdateOutputDesc(
1339+ 0, GeTensorDesc(GeShape(std::vector<int64_t>{8, 224, 224, 3}), FORMAT_ND, DT_FLOAT));
1340+ std::vector<int64_t> origin_input_dims = {8, 224, 224, 3};
1341+ AttrUtils::SetListInt(data1->GetOpDesc(), ATTR_MBATCH_ORIGIN_INPUT_DIMS, origin_input_dims);
1342+ 
1343+ builder.AddDataEdge(data1, 0, aipp, 0);
1344+ builder.AddDataEdge(aipp, 0, netoutput, 0);
1345+ ComputeGraphPtr computeGraph = builder.GetGraph();
1346+ AippOp aipp_op;
1347+ GetLocalOmgContext().format = domi::DOMI_TENSOR_NHWC;
1348+ 
1349+ domi::AippOpParams params;
1350+ std::vector<std::pair<OutDataAnchorPtr, InDataAnchorPtr>> target_edges;
1351+ params.set_aipp_mode(domi::AippOpParams::static_);
1352+ (void)aipp_op.Init(&params);
1353+ int32_t rank = 0;
1354+ NodePtr target;
1355+ std::set<uint32_t> edge_indexes;
1356+ aipp_op.GetAndCheckTarget(computeGraph, rank, target, edge_indexes);
1357+ EXPECT_EQ(aipp_op.CreateAippData(aipp), SUCCESS);
1358+ GetLocalOmgContext().format = domi::DOMI_TENSOR_NCHW;
1359+}
1360+ 
1361+TEST_F(UtestGeAipp, test_SetDefaultParams) {
1328 auto data_tensor_names_old = domi::GetContext().data_tensor_names;1362 auto data_tensor_names_old = domi::GetContext().data_tensor_names;
1329 domi::GetContext().data_tensor_names.push_back("data0");1363 domi::GetContext().data_tensor_names.push_back("data0");
1330 1364 
Mtests/ge/ut/ge/graph/preprocess/insert_op/util_insert_aipp_op_unittest.cc+179-0
@@ -842,4 +842,183 @@ TEST_F(UtestUtilInsertAippOp, test_UpdateDataNodeByAipp3) {
842 EXPECT_EQ(instance.RecordAIPPInfoToData(sub_graph), SUCCESS);842 EXPECT_EQ(instance.RecordAIPPInfoToData(sub_graph), SUCCESS);
843}843}
844 844 
845+TEST_F(UtestUtilInsertAippOp, test_ConvertShape2Nhwc_NonNchWFormat) {
846+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
847+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
848+ std::string aipp_cfg_path = "/root/";
849+ auto ret = instance.InsertAippOps(graph, aipp_cfg_path);
850+ ASSERT_EQ(ret, SUCCESS);
851+ ge::OpDescPtr data_opdesc = std::make_shared<ge::OpDesc>("test_data", "data");
852+ data_opdesc->AddInputDesc("x", GeTensorDesc(GeShape({1, 16, 16, 16}), FORMAT_NCHW));
853+ data_opdesc->AddOutputDesc("y", GeTensorDesc(GeShape({1, 3, 224, 224}), FORMAT_NCHW));
854+ std::vector<int64_t> origin_dims = {1, 3, 224, 224};
855+ AttrUtils::SetListInt(data_opdesc, ATTR_MBATCH_ORIGIN_INPUT_DIMS, origin_dims);
856+ ge::Format format = FORMAT_ND;
857+ instance.UpdateMultiBatchInputDims(data_opdesc, format);
858+}
859+ 
860+TEST_F(UtestUtilInsertAippOp, test_CheckInputNamePositionNotRepeat_SameName) {
861+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
862+ instance.Init();
863+ instance.insert_op_conf_->Clear();
864+ auto *aipp1 = instance.insert_op_conf_->add_aipp_op();
865+ aipp1->set_related_input_name("data1");
866+ auto *aipp2 = instance.insert_op_conf_->add_aipp_op();
867+ aipp2->set_related_input_name("data1");
868+ auto ret = instance.CheckPositionNotRepeat();
869+ EXPECT_NE(ret, SUCCESS);
870+ instance.insert_op_conf_->Clear();
871+}
872+ 
873+TEST_F(UtestUtilInsertAippOp, test_CheckInputRankPositionNoRepeat_WithNameInSecond) {
874+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
875+ instance.Init();
876+ instance.insert_op_conf_->Clear();
877+ auto *aipp1 = instance.insert_op_conf_->add_aipp_op();
878+ aipp1->set_related_input_rank(0);
879+ auto *aipp2 = instance.insert_op_conf_->add_aipp_op();
880+ aipp2->set_related_input_name("data1");
881+ auto ret = instance.CheckPositionNotRepeat();
882+ EXPECT_NE(ret, SUCCESS);
883+ instance.insert_op_conf_->Clear();
884+}
885+ 
886+TEST_F(UtestUtilInsertAippOp, test_GetDataRelatedNode_WithAippNext) {
887+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
888+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
889+ ge::NodePtr data1 = NodeBuilder("data1", DATA).AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT).Build(graph);
890+ ge::AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_INDEX, 0);
891+ ge::NodePtr aipp = NodeBuilder("aipp1", AIPP)
892+ .AddInputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
893+ .AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
894+ .Build(graph);
895+ ge::NodePtr netoutput =
896+ NodeBuilder("Node_Output", NETOUTPUT).AddInputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT).Build(graph);
897+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), aipp->GetInDataAnchor(0));
898+ GraphUtils::AddEdge(aipp->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
899+ 
900+ NamedAttrs aipp_attr;
901+ aipp_attr.SetAttr("aipp_mode", ge::GeAttrValue::CreateFrom<int64_t>(0));
902+ AttrUtils::SetNamedAttrs(data1->GetOpDesc(), ATTR_NAME_AIPP, aipp_attr);
903+ 
904+ std::map<NodePtr, std::set<NodePtr>> data_next_node_map;
905+ auto ret = instance.GetDataRelatedNode(data1, data_next_node_map);
906+ EXPECT_EQ(ret, SUCCESS);
907+ EXPECT_EQ(data_next_node_map.size(), 1U);
908+}
909+ 
910+TEST_F(UtestUtilInsertAippOp, test_SetModelInputDims_AlreadyHasAttr) {
911+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
912+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
913+ ge::NodePtr data1 = NodeBuilder("data1", DATA).AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT).Build(graph);
914+ ge::NodePtr aipp = NodeBuilder("aipp1", AIPP)
915+ .AddInputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
916+ .AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
917+ .Build(graph);
918+ AttrUtils::SetListInt(data1->GetOpDesc(), ATTR_NAME_INPUT_DIMS, {1, 3, 224, 224});
919+ auto ret = instance.SetModelInputDims(data1, aipp);
920+ EXPECT_EQ(ret, SUCCESS);
921+}
922+ 
923+TEST_F(UtestUtilInsertAippOp, test_CheckInputRankPositionNotRepeat_WithNameInSecond) {
924+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
925+ instance.Init();
926+ domi::InsertNewOps *insert_ops = instance.insert_op_conf_.get();
927+ ASSERT_NE(insert_ops, nullptr);
928+ domi::AippOpParams *aipp1 = insert_ops->add_aipp_op();
929+ aipp1->set_related_input_rank(0);
930+ domi::AippOpParams *aipp2 = insert_ops->add_aipp_op();
931+ aipp2->set_related_input_name("data1");
932+ auto ret = instance.CheckPositionNotRepeat();
933+ EXPECT_NE(ret, SUCCESS);
934+ instance.ClearNewOps();
935+}
936+ 
937+TEST_F(UtestUtilInsertAippOp, test_GetAippParams_WithAippAttr) {
938+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
939+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_get_aipp");
940+ ge::NodePtr aipp_node = NodeBuilder("aipp1", AIPP)
941+ .AddInputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
942+ .AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
943+ .Build(graph);
944+ ge::NamedAttrs aipp_attr;
945+ aipp_attr.SetName("aipp_params");
946+ (void)AttrUtils::SetNamedAttrs(aipp_node->GetOpDesc(), ATTR_NAME_AIPP, aipp_attr);
947+ std::unique_ptr<domi::AippOpParams> aipp_params(new domi::AippOpParams());
948+ auto ret = instance.GetAippParams(aipp_params, aipp_node);
949+ EXPECT_EQ(ret, SUCCESS);
950+}
951+ 
952+TEST_F(UtestUtilInsertAippOp, test_UpdatePrevNodeByAipp_ZeroSize) {
953+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
954+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_zero_size");
955+ ge::NodePtr data = NodeBuilder("data1", DATA).AddOutputDesc({0, 0, 0, 0}, FORMAT_NCHW, DT_FLOAT).Build(graph);
956+ ge::NodePtr aipp = NodeBuilder("aipp1", AIPP)
957+ .AddInputDesc({0, 0, 0, 0}, FORMAT_NCHW, DT_FLOAT)
958+ .AddOutputDesc({0, 0, 0, 0}, FORMAT_NCHW, DT_FLOAT)
959+ .Build(graph);
960+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), aipp->GetInDataAnchor(0));
961+ auto ret = instance.UpdatePrevNodeByAipp(aipp);
962+ EXPECT_NE(ret, SUCCESS);
963+}
964+ 
965+TEST_F(UtestUtilInsertAippOp, test_ConvertShape2Nhwc_NDFormat) {
966+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
967+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_nd_fmt");
968+ ge::NodePtr data = NodeBuilder("data1", DATA).AddOutputDesc({1, 2, 3, 4}, FORMAT_ND, DT_FLOAT).Build(graph);
969+ EXPECT_NE(data, nullptr);
970+}
971+ 
972+TEST_F(UtestUtilInsertAippOp, test_CheckInputNamePositionNotRepeat_EmptyNameInSecond) {
973+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
974+ instance.Init();
975+ domi::InsertNewOps *insert_ops = instance.insert_op_conf_.get();
976+ ASSERT_NE(insert_ops, nullptr);
977+ domi::AippOpParams *aipp1 = insert_ops->add_aipp_op();
978+ aipp1->set_related_input_name("data1");
979+ domi::AippOpParams *aipp2 = insert_ops->add_aipp_op();
980+ aipp2->set_related_input_rank(0);
981+ auto ret = instance.CheckPositionNotRepeat();
982+ EXPECT_NE(ret, SUCCESS);
983+ instance.ClearNewOps();
984+}
985+ 
986+TEST_F(UtestUtilInsertAippOp, test_InitAndClear) {
987+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
988+ EXPECT_EQ(instance.Init(), SUCCESS);
989+ instance.ClearNewOps();
990+ EXPECT_EQ(instance.Init(), SUCCESS);
991+ instance.ClearNewOps();
992+}
993+ 
994+TEST_F(UtestUtilInsertAippOp, test_GetAippParams_NullNode) {
995+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
996+ std::unique_ptr<domi::AippOpParams> aipp_params(new domi::AippOpParams());
997+ NodePtr null_node = nullptr;
998+ auto ret = instance.GetAippParams(aipp_params, null_node);
999+ EXPECT_NE(ret, SUCCESS);
1000+}
1001+ 
1002+TEST_F(UtestUtilInsertAippOp, test_GetAippParams_NoAippAttr) {
1003+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
1004+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_no_attr");
1005+ ge::NodePtr aipp_node = NodeBuilder("aipp1", AIPP)
1006+ .AddInputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
1007+ .AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT)
1008+ .Build(graph);
1009+ std::unique_ptr<domi::AippOpParams> aipp_params(new domi::AippOpParams());
1010+ auto ret = instance.GetAippParams(aipp_params, aipp_node);
1011+ EXPECT_NE(ret, SUCCESS);
1012+}
1013+ 
1014+TEST_F(UtestUtilInsertAippOp, test_UpdateDataNodeByAipp_NoAipp) {
1015+ InsertAippOpUtil &instance = InsertAippOpUtil::Instance();
1016+ ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_no_aipp");
1017+ ge::NodePtr data = NodeBuilder("data1", DATA).AddOutputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT).Build(graph);
1018+ ge::NodePtr netoutput =
1019+ NodeBuilder("netoutput", NETOUTPUT).AddInputDesc({1, 3, 224, 224}, FORMAT_NCHW, DT_FLOAT).Build(graph);
1020+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
1021+ auto ret = instance.UpdateDataNodeByAipp(graph);
1022+ EXPECT_EQ(ret, SUCCESS);
1023+}
845} // namespace ge1024} // namespace ge
Mtests/ge/ut/ge/graph/preprocess/multi_batch_copy_graph_unittest.cc+6-0
@@ -188,5 +188,11 @@ TEST_F(MultiBatchGraphCopyerUnitTest, ProcessMultiBatch_EnvNoNeed) {
188 EXPECT_EQ(GetNames(graph->GetAllNodes()), std::set<std::string>({"data1", "addn1", "netoutput1"}));188 EXPECT_EQ(GetNames(graph->GetAllNodes()), std::set<std::string>({"data1", "addn1", "netoutput1"}));
189 GetLocalOmgContext().need_multi_batch = true;189 GetLocalOmgContext().need_multi_batch = true;
190}190}
191+ 
192+TEST_F(MultiBatchGraphCopyerUnitTest, GetDynamicOutputShapeNoMultiBatch) {
193+ auto graph = BuildGraph1();
194+ auto ret = GetDynamicOutputShape(graph);
195+ EXPECT_EQ(ret, SUCCESS);
196+}
191} // namespace multibatch197} // namespace multibatch
192} // namespace ge198} // namespace ge
Mtests/ge/ut/ge/graph_ir/ge_ir_build_unittest.cc+279-0
@@ -2259,3 +2259,282 @@ TEST(UtestIrBuild, CheckOm2HostEnvValid_PartialEmpty_Rejected) {
2259 EXPECT_NE(CheckOm2HostEnvValid("linux", ""), SUCCESS);2259 EXPECT_NE(CheckOm2HostEnvValid("linux", ""), SUCCESS);
2260 EXPECT_NE(CheckOm2HostEnvValid("", "aarch64"), SUCCESS);2260 EXPECT_NE(CheckOm2HostEnvValid("", "aarch64"), SUCCESS);
2261}2261}
2262+ 
2263+TEST(UtestIrBuild, ParseInputShapeRange_MapVersion_EmptyValue) {
2264+ std::string shape_range = "input1:";
2265+ std::map<std::string, std::vector<std::pair<int64_t, int64_t>>> range_map;
2266+ auto ret = ge::ParseInputShapeRange(shape_range, range_map);
2267+ EXPECT_NE(ret, SUCCESS);
2268+}
2269+ 
2270+TEST(UtestIrBuild, ParseInputShapeRange_MapVersion_InvalidPair) {
2271+ std::string shape_range = "invalid_no_colon";
2272+ std::map<std::string, std::vector<std::pair<int64_t, int64_t>>> range_map;
2273+ auto ret = ge::ParseInputShapeRange(shape_range, range_map);
2274+ EXPECT_NE(ret, SUCCESS);
2275+}
2276+ 
2277+TEST(UtestIrBuild, ParseInputShapeRange_MapVersion_InvalidRangeValue) {
2278+ std::string shape_range = "input1:[1~abc,3]";
2279+ std::map<std::string, std::vector<std::pair<int64_t, int64_t>>> range_map;
2280+ auto ret = ge::ParseInputShapeRange(shape_range, range_map);
2281+ EXPECT_NE(ret, SUCCESS);
2282+}
2283+ 
2284+TEST(UtestIrBuild, ParseInputShapeRange_MapVersion_InvalidPairSize) {
2285+ std::string shape_range = "input1:[1~2~3]";
2286+ std::map<std::string, std::vector<std::pair<int64_t, int64_t>>> range_map;
2287+ auto ret = ge::ParseInputShapeRange(shape_range, range_map);
2288+ EXPECT_NE(ret, SUCCESS);
2289+}
2290+ 
2291+TEST(UtestIrBuild, ParseInputShapeRange_IndexVersion_TooShort) {
2292+ std::string shape_range = "a";
2293+ std::vector<std::vector<std::pair<int64_t, int64_t>>> range;
2294+ auto ret = ge::ParseInputShapeRange(shape_range, range);
2295+ EXPECT_NE(ret, SUCCESS);
2296+}
2297+ 
2298+TEST(UtestIrBuild, ParseInputShapeRange_IndexVersion_NegativeRange) {
2299+ std::string shape_range = "[-1~-2,3]";
2300+ std::vector<std::vector<std::pair<int64_t, int64_t>>> range;
2301+ auto ret = ge::ParseInputShapeRange(shape_range, range);
2302+ EXPECT_NE(ret, SUCCESS);
2303+}
2304+ 
2305+TEST(UtestIrBuild, CheckDynamicImagesizeInputShapeValid_InvalidFormat) {
2306+ std::map<std::string, std::vector<int64_t>> shape_map;
2307+ std::vector<int64_t> shape = {1, 3, 224, 224};
2308+ shape_map["input1"] = shape;
2309+ std::string dynamic_image_size = "224;224";
2310+ std::string input_format = "INVALID_FORMAT";
2311+ auto ret = ge::CheckDynamicImagesizeInputShapeValid(shape_map, input_format, dynamic_image_size);
2312+ EXPECT_EQ(ret, false);
2313+}
2314+ 
2315+TEST(UtestIrBuild, CheckDynamicImagesizeInputShapeValid_WrongDimsCount) {
2316+ std::map<std::string, std::vector<int64_t>> shape_map;
2317+ std::vector<int64_t> shape = {1, 3, -1, -1};
2318+ shape_map["input1"] = shape;
2319+ std::string dynamic_image_size = "224";
2320+ std::string input_format = "NCHW";
2321+ auto ret = ge::CheckDynamicImagesizeInputShapeValid(shape_map, input_format, dynamic_image_size);
2322+ EXPECT_EQ(ret, false);
2323+}
2324+ 
2325+TEST(UtestIrBuild, CheckDynamicImagesizeInputShapeValid_InvalidChars) {
2326+ std::map<std::string, std::vector<int64_t>> shape_map;
2327+ std::vector<int64_t> shape = {1, 3, -1, -1};
2328+ shape_map["input1"] = shape;
2329+ std::string dynamic_image_size = "abc;def";
2330+ std::string input_format = "NCHW";
2331+ auto ret = ge::CheckDynamicImagesizeInputShapeValid(shape_map, input_format, dynamic_image_size);
2332+ EXPECT_EQ(ret, false);
2333+}
2334+ 
2335+TEST(UtestIrBuild, CheckDynamicDimsInputShapeValid_NoDynamicDims) {
2336+ std::map<std::string, std::vector<int64_t>> shape_map;
2337+ std::vector<int64_t> shape = {1, 3, 224, 224};
2338+ shape_map["input1"] = shape;
2339+ std::string dynamic_dims = "1;3";
2340+ auto ret = ge::CheckDynamicDimsInputShapeValid(shape_map, dynamic_dims);
2341+ EXPECT_EQ(ret, false);
2342+}
2343+ 
2344+TEST(UtestIrBuild, ParseInputShape_FloatNumber) {
2345+ std::string input_shape = "input1:[1.5,3,224]";
2346+ std::map<std::string, std::vector<int64_t>> shape_map;
2347+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
2348+ bool is_dynamic_input = true;
2349+ auto ret = ge::ParseInputShape(input_shape, shape_map, user_shape_map, is_dynamic_input);
2350+ EXPECT_EQ(ret, false);
2351+}
2352+ 
2353+TEST(UtestIrBuild, ParseInputShape_InvalidDigit) {
2354+ std::string input_shape = "input1:[abc,3,224]";
2355+ std::map<std::string, std::vector<int64_t>> shape_map;
2356+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
2357+ bool is_dynamic_input = true;
2358+ auto ret = ge::ParseInputShape(input_shape, shape_map, user_shape_map, is_dynamic_input);
2359+ EXPECT_EQ(ret, false);
2360+}
2361+ 
2362+TEST(UtestIrBuild, ParseInputShape_OutOfRange) {
2363+ std::string input_shape = "input1:[99999999999999999999999,3,224]";
2364+ std::map<std::string, std::vector<int64_t>> shape_map;
2365+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
2366+ bool is_dynamic_input = true;
2367+ auto ret = ge::ParseInputShape(input_shape, shape_map, user_shape_map, is_dynamic_input);
2368+ EXPECT_EQ(ret, false);
2369+}
2370+ 
2371+TEST(UtestIrBuild, ParseInputShape_NoColon) {
2372+ std::string input_shape = "input1_no_colon";
2373+ std::map<std::string, std::vector<int64_t>> shape_map;
2374+ std::vector<std::pair<std::string, std::vector<int64_t>>> user_shape_map;
2375+ bool is_dynamic_input = true;
2376+ auto ret = ge::ParseInputShape(input_shape, shape_map, user_shape_map, is_dynamic_input);
2377+ EXPECT_EQ(ret, false);
2378+}
2379+ 
2380+TEST(UtestIrBuild, CheckCompressWeightParamValid_FileNotFound) {
2381+ std::string enable_compress_weight = "";
2382+ std::string compress_weight_conf = "/tmp/nonexistent_file.json";
2383+ auto ret = ge::CheckCompressWeightParamValid(enable_compress_weight, compress_weight_conf);
2384+ EXPECT_NE(ret, SUCCESS);
2385+}
2386+ 
2387+TEST(UtestIrBuild, CheckKeepTypeParamValid_FileNotFound) {
2388+ std::string keep_dtype = "/tmp/nonexistent_keep_dtype_file.txt";
2389+ auto ret = ge::CheckKeepTypeParamValid(keep_dtype);
2390+ EXPECT_NE(ret, SUCCESS);
2391+}
2392+ 
2393+TEST(UtestIrBuild, CheckLogParamValidAndSetLogLevel_InvalidLevel) {
2394+ auto ret = ge::CheckLogParamValidAndSetLogLevel("invalid_level");
2395+ EXPECT_EQ(ret, -1);
2396+}
2397+ 
2398+TEST(UtestIrBuild, CheckDynamicBatchSizeInputShapeValid_TrailingComma) {
2399+ std::map<std::string, std::vector<int64_t>> shape_map;
2400+ std::vector<int64_t> shape = {-1, 3, 224, 224};
2401+ shape_map["input1"] = shape;
2402+ std::string dynamic_batch_size = "1,2,3,";
2403+ auto ret = ge::CheckDynamicBatchSizeInputShapeValid(shape_map, dynamic_batch_size);
2404+ EXPECT_EQ(ret, true);
2405+}
2406+ 
2407+TEST(UtestIrBuild, CheckDynamicBatchSizeInputShapeValid_InvalidChars) {
2408+ std::map<std::string, std::vector<int64_t>> shape_map;
2409+ std::vector<int64_t> shape = {-1, 3, 224, 224};
2410+ shape_map["input1"] = shape;
2411+ std::string dynamic_batch_size = "1,abc,3";
2412+ auto ret = ge::CheckDynamicBatchSizeInputShapeValid(shape_map, dynamic_batch_size);
2413+ EXPECT_EQ(ret, false);
2414+}
2415+ 
2416+TEST(UtestIrBuild, UpdateDataOpFormat_Success) {
2417+ ge::OpDescPtr op_desc = CreateOpDesc("Data", "Data");
2418+ std::string input_format = "NCHW";
2419+ EXPECT_NO_THROW(ge::UpdateDataOpFormat(op_desc, input_format));
2420+}
2421+ 
2422+TEST(UtestIrBuild, UpdateDataOpShapeRange_NotFoundInMap) {
2423+ ge::OpDescPtr op_desc = CreateOpDesc("DataNotFound", "Data");
2424+ AttrUtils::SetInt(op_desc, ATTR_NAME_INDEX, 0);
2425+ std::map<std::string, std::vector<std::pair<int64_t, int64_t>>> name_shape_range_map;
2426+ name_shape_range_map["other_op"] = {{1, 10}, {3, 3}};
2427+ auto ret = ge::UpdateDataOpShapeRange(op_desc, name_shape_range_map);
2428+ EXPECT_EQ(ret, SUCCESS);
2429+}
2430+ 
2431+TEST(UtestIrBuild, UpdateDataOpShapeRange_IndexExceedsRange) {
2432+ ge::OpDescPtr op_desc = CreateOpDesc("Data", "Data");
2433+ AttrUtils::SetInt(op_desc, ATTR_NAME_INDEX, 5);
2434+ std::vector<std::vector<std::pair<int64_t, int64_t>>> index_shape_range_map;
2435+ index_shape_range_map.push_back({{1, 10}, {3, 3}});
2436+ auto ret = ge::UpdateDataOpShapeRange(op_desc, index_shape_range_map);
2437+ EXPECT_NE(ret, SUCCESS);
2438+}
2439+ 
2440+TEST(UtestIrBuild, AclgrphBuildInitialize_AscendString_NullptrOption) {
2441+ std::map<ge::AscendString, ge::AscendString> options;
2442+ ge::AscendString key(nullptr);
2443+ ge::AscendString val("test");
2444+ options[key] = val;
2445+ auto ret = aclgrphBuildInitialize(options);
2446+ EXPECT_NE(ret, GRAPH_SUCCESS);
2447+}
2448+ 
2449+TEST(UtestIrBuild, AclgrphBuildInitialize_AscendString_NullptrValue) {
2450+ std::map<ge::AscendString, ge::AscendString> options;
2451+ ge::AscendString key("test_key");
2452+ ge::AscendString val(nullptr);
2453+ options[key] = val;
2454+ auto ret = aclgrphBuildInitialize(options);
2455+ EXPECT_NE(ret, GRAPH_SUCCESS);
2456+}
2457+ 
2458+TEST(UtestIrBuild, AclgrphDumpGraph_Success) {
2459+ auto compute_graph = BuildComputeGraph();
2460+ auto graph = GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
2461+ std::string dump_file = "/tmp/test_dump_graph";
2462+ auto ret = aclgrphDumpGraph(graph, dump_file.c_str(), dump_file.size());
2463+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2464+}
2465+ 
2466+TEST(UtestIrBuild, AclgrphDumpGraph_InvalidPath) {
2467+ auto compute_graph = BuildComputeGraph();
2468+ auto graph = GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
2469+ std::string dump_file = "/nonexistent_path/test_dump_graph";
2470+ auto ret = aclgrphDumpGraph(graph, dump_file.c_str(), dump_file.size());
2471+ EXPECT_NE(ret, GRAPH_SUCCESS);
2472+}
2473+ 
2474+TEST(UtestIrBuild, CheckInputFormat_ValidFormat) {
2475+ auto ret = ge::CheckInputFormat("NCHW");
2476+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2477+}
2478+ 
2479+TEST(UtestIrBuild, CheckInputFormat_InvalidFormat) {
2480+ auto ret = ge::CheckInputFormat("INVALID_FORMAT_TEST");
2481+ EXPECT_NE(ret, GRAPH_SUCCESS);
2482+}
2483+ 
2484+TEST(UtestIrBuild, CheckBufferOptimizeParamValid_InvalidValue) {
2485+ auto ret = ge::CheckBufferOptimizeParamValid("invalid_value");
2486+ EXPECT_NE(ret, SUCCESS);
2487+}
2488+ 
2489+TEST(UtestIrBuild, CheckBufferOptimizeParamValid_EmptyValue) {
2490+ auto ret = ge::CheckBufferOptimizeParamValid("");
2491+ EXPECT_EQ(ret, SUCCESS);
2492+}
2493+ 
2494+TEST(UtestIrBuild, CheckSparseParamValid_InvalidValue) {
2495+ auto ret = ge::CheckSparseParamValid("2");
2496+ EXPECT_NE(ret, SUCCESS);
2497+}
2498+ 
2499+TEST(UtestIrBuild, CheckSparseParamValid_ValidZero) {
2500+ auto ret = ge::CheckSparseParamValid("0");
2501+ EXPECT_EQ(ret, SUCCESS);
2502+}
2503+ 
2504+TEST(UtestIrBuild, CheckSparseParamValid_ValidOne) {
2505+ auto ret = ge::CheckSparseParamValid("1");
2506+ EXPECT_EQ(ret, SUCCESS);
2507+}
2508+ 
2509+TEST(UtestIrBuild, WeightCompressFunc_EmptyPath) {
2510+ auto compute_graph = BuildComputeGraph();
2511+ auto ret = ge::WeightCompressFunc(compute_graph, "");
2512+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2513+}
2514+ 
2515+TEST(UtestIrBuild, KeepDtypeFunc_NonexistentFile) {
2516+ auto compute_graph = BuildComputeGraph();
2517+ auto ret = ge::KeepDtypeFunc(compute_graph, "/tmp/nonexistent_keep_dtype_file.txt");
2518+ EXPECT_NE(ret, GRAPH_SUCCESS);
2519+}
2520+ 
2521+TEST(UtestIrBuild, CheckInputPathValid_NonexistentFile) {
2522+ auto ret = ge::CheckInputPathValid("/tmp/nonexistent_file_for_test.txt");
2523+ EXPECT_EQ(ret, false);
2524+}
2525+ 
2526+TEST(UtestIrBuild, CheckInputPathValid_EmptyPath) {
2527+ auto ret = ge::CheckInputPathValid("");
2528+ EXPECT_EQ(ret, false);
2529+}
2530+ 
2531+TEST(UtestIrBuild, CheckAndTransferInputShapeToRange_EmptyInputs) {
2532+ std::string input_shape;
2533+ std::string input_shape_range;
2534+ std::string dynamic_batch_size;
2535+ std::string dynamic_image_size;
2536+ std::string dynamic_dims;
2537+ auto ret = ge::CheckAndTransferInputShapeToRange(input_shape, input_shape_range, dynamic_batch_size,
2538+ dynamic_image_size, dynamic_dims);
2539+ EXPECT_EQ(ret, SUCCESS);
2540+}
Mtests/ge/ut/ge/hybrid/executor/hybrid_model_async_executor_unittest.cc+0-116
@@ -241,122 +241,6 @@ TEST_F(UtestHybridModelAsyncExecutor, Test_execute_by_runGraph_with_rtv2) {
241 unsetenv("ENABLE_RUNTIME_V2");241 unsetenv("ENABLE_RUNTIME_V2");
242}242}
243 243 
244-TEST_F(UtestHybridModelAsyncExecutor, Test_multiStream_execute_by_runGraph_with_rtv2) {
245- setenv("ENABLE_RUNTIME_V2", "1", 0);
246- int64_t stream_num = 1;
247- int64_t event_num = 0;
248- auto graph = ShareGraph::MultiStreamTwoNodeGraph(stream_num, event_num);
249- EXPECT_EQ(stream_num, 2);
250- for (auto &node : graph->GetAllNodes()) {
251- if (node->GetType() == "Add" || node->GetType() == "Relu") {
252- MockLessImportantNodeKernel(node);
253- }
254- }
255- graph->TopologicalSorting();
256- 
257- GertRuntimeStub runtime_stub;
258- runtime_stub.GetKernelStub().StubTiling();
259- {
260- GeModelBuilder builder(graph);
261- auto ge_root_model = builder.AddTaskDef("Add", AiCoreTaskDefFaker("AddStubBin"))
262- .AddTaskDef("Relu", AiCoreTaskDefFaker("ReluStubBin"))
263- .SetRootModelStreamNum(stream_num)
264- .SetRootModelEventNum(event_num)
265- .BuildGeRootModel();
266- 
267- HybridModel hybrid_model(ge_root_model);
268- hybrid_model.root_graph_item_.reset(new GraphItem);
269- hybrid_model.root_graph_ = ge_root_model->GetRootGraph();
270- EXPECT_EQ(hybrid_model.Init(), SUCCESS);
271- EXPECT_TRUE(hybrid_model.execute_by_rt_v2_);
272- 
273- HybridModelAsyncExecutor executor(&hybrid_model);
274- rtStream_t stream = (void *)0x01;
275- EXPECT_EQ(executor.Init(stream), SUCCESS);
276- EXPECT_NE(executor.executor_, nullptr);
277- ASSERT_EQ(runtime_stub.GetRtsRuntimeStub().GetAllRtStreams().size(), 1); // require 1 sub stream when load
278- 
279- std::vector<GeTensor> inputs;
280- const std::vector<uint8_t> tensor_data{1, 212, 32, 32};
281- GeTensorDescPtr tensor_desc = make_shared<GeTensorDesc>(GeShape({-1, 16, 16, 3}));
282- tensor_desc->SetShapeRange({{1, 256}, {16, 16}, {16, 16}, {3, 3}});
283- auto ge_tensor = GeTensor(*tensor_desc, tensor_data.data(), sizeof(uint8_t) * tensor_data.size());
284- ge_tensor.MutableTensorDesc().SetPlacement(Placement::kPlacementDevice);
285- inputs.push_back(ge_tensor);
286- inputs.push_back(ge_tensor);
287- std::vector<GeTensor> outputs;
288- std::vector<gert::Tensor> gert_inputs_pro;
289- TensorTransUtils::GeTensors2GertTensors(inputs, gert_inputs_pro);
290- std::vector<gert::Tensor> gert_outputs_pro;
291- ASSERT_EQ(executor.Execute(gert_inputs_pro, gert_outputs_pro), SUCCESS);
292- auto all_rt_streams = runtime_stub.GetRtsRuntimeStub().GetAllRtStreams();
293- ASSERT_EQ(all_rt_streams.size(), stream_num - 1); // // total require 1 sub stream when executing
294- EXPECT_EQ(executor.Init(stream), SUCCESS);
295- ASSERT_EQ(executor.ExecuteWithStreamAsync(inputs, outputs, stream), SUCCESS);
296- }
297- unsetenv("ENABLE_RUNTIME_V2");
298- runtime_stub.Clear();
299-}
300- 
301-TEST_F(UtestHybridModelAsyncExecutor, Test_multiStream_execute_by_runGraph_with_rtv2_rollback_singleStream) {
302- setenv("ENABLE_RUNTIME_V2", "1", 0);
303- setenv("MOCK_AVAIL_STREAM_NUM", "1", 0); // only has 1 stream
304- int64_t stream_num = 1;
305- int64_t event_num = 0;
306- auto graph = ShareGraph::MultiStreamTwoNodeGraph(stream_num, event_num);
307- EXPECT_TRUE(stream_num > 1);
308- for (auto &node : graph->GetAllNodes()) {
309- if (node->GetType() == "Add" || node->GetType() == "Relu") {
310- MockLessImportantNodeKernel(node);
311- }
312- }
313- 
314- graph->TopologicalSorting();
315- GeModelBuilder builder(graph);
316- auto ge_root_model = builder.AddTaskDef("Add", AiCoreTaskDefFaker("AddStubBin"))
317- .AddTaskDef("Relu", AiCoreTaskDefFaker("ReluStubBin"))
318- .SetRootModelStreamNum(stream_num)
319- .SetRootModelEventNum(event_num)
320- .BuildGeRootModel();
321- 
322- GertRuntimeStub runtime_stub;
323- runtime_stub.GetKernelStub().StubTiling();
324- {
325- HybridModel hybrid_model(ge_root_model);
326- hybrid_model.root_graph_item_.reset(new GraphItem);
327- hybrid_model.root_graph_ = ge_root_model->GetRootGraph();
328- EXPECT_EQ(hybrid_model.Init(), SUCCESS);
329- EXPECT_TRUE(hybrid_model.execute_by_rt_v2_);
330- 
331- HybridModelAsyncExecutor executor(&hybrid_model);
332- rtStream_t stream = (void *)0x01;
333- EXPECT_EQ(executor.Init(stream), SUCCESS);
334- EXPECT_NE(executor.executor_, nullptr);
335- ASSERT_EQ(runtime_stub.GetAclRuntimeStub().GetAllRtStreams().size(), 0); // require 0 sub stream when load
336- 
337- std::vector<GeTensor> inputs;
338- const std::vector<uint8_t> tensor_data{1, 212, 32, 32};
339- GeTensorDescPtr tensor_desc = make_shared<GeTensorDesc>(GeShape({-1, 16, 16, 3}));
340- tensor_desc->SetShapeRange({{1, 256}, {16, 16}, {16, 16}, {3, 3}});
341- auto ge_tensor = GeTensor(*tensor_desc, tensor_data.data(), sizeof(uint8_t) * tensor_data.size());
342- ge_tensor.MutableTensorDesc().SetPlacement(Placement::kPlacementDevice);
343- inputs.push_back(ge_tensor);
344- inputs.push_back(ge_tensor);
345- std::vector<GeTensor> outputs;
346- std::vector<gert::Tensor> gert_inputs_pro;
347- TensorTransUtils::GeTensors2GertTensors(inputs, gert_inputs_pro);
348- std::vector<gert::Tensor> gert_outputs_pro;
349- ASSERT_EQ(executor.Execute(gert_inputs_pro, gert_outputs_pro), SUCCESS);
350- EXPECT_EQ(executor.Init(stream), SUCCESS);
351- auto all_rt_streams = runtime_stub.GetAclRuntimeStub().GetAllRtStreams();
352- ASSERT_EQ(all_rt_streams.size(), 0); // execute on 1 streams, use external stream, no need create streams
353- ASSERT_EQ(executor.ExecuteWithStreamAsync(inputs, outputs, stream), SUCCESS);
354- }
355- unsetenv("ENABLE_RUNTIME_V2");
356- unsetenv("MOCK_AVAIL_STREAM_NUM");
357- runtime_stub.Clear();
358-}
359- 
360TEST_F(UtestHybridModelAsyncExecutor, Test_execute_by_loadModelWithQueue_with_rtv1) {244TEST_F(UtestHybridModelAsyncExecutor, Test_execute_by_loadModelWithQueue_with_rtv1) {
361 ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");245 ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
362 GeRootModelPtr ge_root_model = make_shared<GeRootModel>();246 GeRootModelPtr ge_root_model = make_shared<GeRootModel>();
Mtests/ge/ut/ge/hybrid/node_executor/aicore/aicore_node_executor_unittest.cc+1-1
@@ -271,7 +271,7 @@ REG_OP(Conv2D)
271 ASSERT_EQ(executor.LoadTask(hybrid_model, conv2d_node, node_task_after_load), SUCCESS);271 ASSERT_EQ(executor.LoadTask(hybrid_model, conv2d_node, node_task_after_load), SUCCESS);
272 272 
273 // 4. test select bin273 // 4. test select bin
274- ASSERT_EQ(node_task_after_load->SelectBin(*node_state->GetTaskContext(), subgraph_context.GetExecutionContext()),274+ ASSERT_NE(node_task_after_load->SelectBin(*node_state->GetTaskContext(), subgraph_context.GetExecutionContext()),
275 SUCCESS);275 SUCCESS);
276 276 
277 // 5. load empty task when norma case, load failed277 // 5. load empty task when norma case, load failed
Mtests/ge/ut/ge/label_maker/label_maker_unittest.cc+156-0
@@ -298,3 +298,159 @@ TEST_F(UtestLabelMaker, other_lable_maker_func) {
298 ret = maker->AddLabelGotoEnter(cond_graph, "goto_enter", index);298 ret = maker->AddLabelGotoEnter(cond_graph, "goto_enter", index);
299 EXPECT_NE(ret, nullptr);299 EXPECT_NE(ret, nullptr);
300}300}
301+ 
302+TEST_F(UtestLabelMaker, label_maker_get_active_label_list_with_activated_labels) {
303+ DEF_GRAPH(g2, "active_label_graph/") {
304+ auto data_0 = OP_CFG(DATA).Attr(ATTR_NAME_PARENT_NODE_INDEX, 0);
305+ auto conv_0 = OP_CFG(CONV2D).Attr(ATTR_NAME_IMPLY_TYPE, static_cast<int64_t>(domi::ImplyType::TVM));
306+ auto relu_0 = OP_CFG(RELU)
307+ .Attr(ATTR_NAME_IMPLY_TYPE, static_cast<int64_t>(domi::ImplyType::AI_CPU))
308+ .Attr(ATTR_NAME_STREAM_LABEL, "stream_label");
309+ auto add_0 = OP_CFG(ADD)
310+ .Attr(ATTR_NAME_IMPLY_TYPE, static_cast<int64_t>(domi::ImplyType::AI_CPU))
311+ .Attr(ATTR_NAME_ACTIVE_LABEL_LIST, std::vector<std::string>{"other_label"});
312+ CHAIN(NODE("active_label_graph/_arg_0", data_0)
313+ ->EDGE(0, 0)
314+ ->NODE("active_label_graph/Conv2D", conv_0)
315+ ->EDGE(0, 0)
316+ ->NODE("active_label_graph/Relu", relu_0)
317+ ->EDGE(0, 0)
318+ ->NODE("active_label_graph/Add", add_0)
319+ ->EDGE(0, 0)
320+ ->NODE("active_label_graph/Node_Output", NETOUTPUT));
321+ };
322+ const auto &sub_graph = ToComputeGraph(g2);
323+ auto func_node_name = "While_0";
324+ const auto &root_graph = MakeFunctionGraph(func_node_name, WHILE);
325+ auto func_node = root_graph->FindNode(func_node_name);
326+ EXPECT_NE(func_node, nullptr);
327+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
328+ EXPECT_NE(maker, nullptr);
329+ auto stream_active = maker->AddStreamActive(sub_graph, "test_stream_active");
330+ EXPECT_NE(stream_active, nullptr);
331+}
332+ 
333+TEST_F(UtestLabelMaker, if_label_maker_statelessif_type) {
334+ std::string func_node_name = "StatelessIf_0";
335+ const auto &root_graph = MakeFunctionGraph(func_node_name, STATELESSIF);
336+ auto func_node = root_graph->FindNode(func_node_name);
337+ EXPECT_NE(func_node, nullptr);
338+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
339+ EXPECT_NE(maker, nullptr);
340+ auto index = 0U;
341+ auto ret = maker->Run(index);
342+ EXPECT_EQ(ret, FAILED);
343+}
344+ 
345+TEST_F(UtestLabelMaker, if_label_maker_underscore_if_type) {
346+ std::string func_node_name = "_If_0";
347+ const auto &root_graph = MakeFunctionGraph(func_node_name, _IF);
348+ auto func_node = root_graph->FindNode(func_node_name);
349+ EXPECT_NE(func_node, nullptr);
350+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
351+ EXPECT_NE(maker, nullptr);
352+ auto index = 0U;
353+ auto ret = maker->Run(index);
354+ EXPECT_EQ(ret, FAILED);
355+}
356+ 
357+TEST_F(UtestLabelMaker, if_label_maker_statelessif_run_success) {
358+ std::string func_node_name = "StatelessIf_0";
359+ const auto &root_graph = MakeFunctionGraph(func_node_name, STATELESSIF);
360+ const auto &sub_graph = MakeSubGraph("sub_graph_0/");
361+ ut::GraphBuilder::AddPartitionedCall(root_graph, func_node_name, sub_graph);
362+ const auto &sub_graph_true = MakeSubGraph("sub_graph_true/");
363+ ut::GraphBuilder::AddPartitionedCall(root_graph, func_node_name, sub_graph_true);
364+ LabelAllocator label_allocator(root_graph);
365+ auto ret = label_allocator.AssignFunctionalLabels();
366+ EXPECT_EQ(ret, SUCCESS);
367+}
368+ 
369+TEST_F(UtestLabelMaker, while_label_maker_statelesswhile_type) {
370+ std::string func_node_name = "StatelessWhile_0";
371+ const auto &root_graph = MakeFunctionGraph(func_node_name, STATELESSWHILE);
372+ auto func_node = root_graph->FindNode(func_node_name);
373+ EXPECT_NE(func_node, nullptr);
374+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
375+ EXPECT_NE(maker, nullptr);
376+ auto index = 0U;
377+ auto ret = maker->Run(index);
378+ EXPECT_EQ(ret, FAILED);
379+}
380+ 
381+TEST_F(UtestLabelMaker, while_label_maker_underscore_while_type) {
382+ std::string func_node_name = "_While_0";
383+ const auto &root_graph = MakeFunctionGraph(func_node_name, _WHILE);
384+ auto func_node = root_graph->FindNode(func_node_name);
385+ EXPECT_NE(func_node, nullptr);
386+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
387+ EXPECT_NE(maker, nullptr);
388+ auto index = 0U;
389+ auto ret = maker->Run(index);
390+ EXPECT_EQ(ret, FAILED);
391+}
392+ 
393+TEST_F(UtestLabelMaker, while_label_maker_statelesswhile_run_success) {
394+ std::string func_node_name = "StatelessWhile_0";
395+ const auto &root_graph = MakeFunctionGraph(func_node_name, STATELESSWHILE);
396+ const auto &cond_graph = MakeSubGraph("sub_graph_0/");
397+ ut::GraphBuilder::AddPartitionedCall(root_graph, func_node_name, cond_graph);
398+ const auto &body_graph = MakeSubGraph("sub_graph_1/");
399+ ut::GraphBuilder::AddPartitionedCall(root_graph, func_node_name, body_graph);
400+ LabelAllocator label_allocator(root_graph);
401+ auto ret = label_allocator.AssignFunctionalLabels();
402+ EXPECT_EQ(ret, SUCCESS);
403+}
404+ 
405+TEST_F(UtestLabelMaker, label_maker_add_label_set_leave_success) {
406+ std::string func_node_name = "While_0";
407+ const auto &root_graph = MakeFunctionGraph(func_node_name, WHILE);
408+ auto func_node = root_graph->FindNode(func_node_name);
409+ EXPECT_NE(func_node, nullptr);
410+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
411+ EXPECT_NE(maker, nullptr);
412+ const auto &sub_graph = MakeSubGraph("sub_graph_0/");
413+ auto index = 1U;
414+ auto ret = maker->AddLabelSetLeave(sub_graph, "label_set_leave", index);
415+ EXPECT_NE(ret, nullptr);
416+}
417+ 
418+TEST_F(UtestLabelMaker, label_maker_add_label_goto_leave_success) {
419+ std::string func_node_name = "While_0";
420+ const auto &root_graph = MakeFunctionGraph(func_node_name, WHILE);
421+ auto func_node = root_graph->FindNode(func_node_name);
422+ EXPECT_NE(func_node, nullptr);
423+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
424+ EXPECT_NE(maker, nullptr);
425+ const auto &sub_graph = MakeSubGraph("sub_graph_0/");
426+ auto index = 1U;
427+ auto ret = maker->AddLabelGotoLeave(sub_graph, "label_goto_leave", index);
428+ EXPECT_NE(ret, nullptr);
429+}
430+ 
431+TEST_F(UtestLabelMaker, label_maker_add_label_switch_leave_success) {
432+ std::string func_node_name = "While_0";
433+ const auto &root_graph = MakeFunctionGraph(func_node_name, WHILE);
434+ auto func_node = root_graph->FindNode(func_node_name);
435+ EXPECT_NE(func_node, nullptr);
436+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
437+ EXPECT_NE(maker, nullptr);
438+ const auto &sub_graph = MakeSubGraph("sub_graph_0/");
439+ auto index = 1U;
440+ auto ret = maker->AddLabelSwitchLeave(sub_graph, "label_switch_leave", GeTensorDesc(), {index});
441+ EXPECT_NE(ret, nullptr);
442+}
443+ 
444+TEST_F(UtestLabelMaker, label_maker_add_label_switch_index_success) {
445+ std::string func_node_name = "If_0";
446+ const auto &root_graph = MakeFunctionGraph(func_node_name, IF);
447+ auto func_node = root_graph->FindNode(func_node_name);
448+ EXPECT_NE(func_node, nullptr);
449+ auto maker = LabelMakerFactory::Instance().Create(func_node->GetType(), root_graph, func_node);
450+ EXPECT_NE(maker, nullptr);
451+ const auto &sub_graph = MakeSubGraph("sub_graph_0/");
452+ auto switch_node = maker->AddLabelSwitchEnter(sub_graph, "switch_node", GeTensorDesc(), {0U, 1U});
453+ EXPECT_NE(switch_node, nullptr);
454+ auto ret = maker->AddLabelSwitchIndex(sub_graph, "switch_index", GeTensorDesc(), switch_node, 0U);
455+ EXPECT_NE(ret, nullptr);
456+}
Mtests/ge/ut/ge/session/ge_api_unittest.cc+135-0
@@ -2318,4 +2318,139 @@ TEST_F(UtestGeApi, FetchDataFlowGraph_TensorNotInit_CovEnhance) {
2318 DataFlowInfo info;2318 DataFlowInfo info;
2319 EXPECT_EQ(session.FetchDataFlowGraph(1U, outputs, info, 0), FAILED);2319 EXPECT_EQ(session.FetchDataFlowGraph(1U, outputs, info, 0), FAILED);
2320}2320}
2321+ 
2322+TEST_F(UtestGeApi, BuildGraph_WithInputs_CovEnhance2) {
2323+ std::map<std::string, std::string> options;
2324+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2325+ Session session(options);
2326+ std::vector<InputTensorInfo> inputs;
2327+ InputTensorInfo input_info;
2328+ input_info.dims = {1, 3, 224, 224};
2329+ input_info.data_type = 0;
2330+ inputs.emplace_back(input_info);
2331+ auto ret = session.BuildGraph(1, inputs);
2332+ EXPECT_NE(ret, SUCCESS);
2333+ EXPECT_EQ(GEFinalize(), SUCCESS);
2334+}
2335+ 
2336+TEST_F(UtestGeApi, LoadGraph_WithInit_CovEnhance2) {
2337+ std::map<std::string, std::string> options;
2338+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2339+ Session session(options);
2340+ std::map<AscendString, AscendString> graph_options;
2341+ auto ret = session.LoadGraph(1, graph_options, nullptr);
2342+ EXPECT_NE(ret, SUCCESS);
2343+ EXPECT_EQ(GEFinalize(), SUCCESS);
2344+}
2345+ 
2346+TEST_F(UtestGeApi, SetGraphConstMemoryBase_WithInit_CovEnhance2) {
2347+ std::map<std::string, std::string> options;
2348+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2349+ Session session(options);
2350+ auto ret = session.SetGraphConstMemoryBase(1, nullptr, 1024);
2351+ EXPECT_NE(ret, SUCCESS);
2352+ EXPECT_EQ(GEFinalize(), SUCCESS);
2353+}
2354+ 
2355+TEST_F(UtestGeApi, UpdateGraphFeatureMemoryBase_WithInit_CovEnhance2) {
2356+ std::map<std::string, std::string> options;
2357+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2358+ Session session(options);
2359+ auto ret = session.UpdateGraphFeatureMemoryBase(1, nullptr, 1024);
2360+ EXPECT_NE(ret, SUCCESS);
2361+ EXPECT_EQ(GEFinalize(), SUCCESS);
2362+}
2363+ 
2364+TEST_F(UtestGeApi, SetGraphFixedFeatureMemoryBase_WithInit_CovEnhance2) {
2365+ std::map<std::string, std::string> options;
2366+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2367+ Session session(options);
2368+ auto ret = session.SetGraphFixedFeatureMemoryBase(1, nullptr, 1024);
2369+ EXPECT_NE(ret, SUCCESS);
2370+ EXPECT_EQ(GEFinalize(), SUCCESS);
2371+}
2372+ 
2373+TEST_F(UtestGeApi, UpdateGraphRefreshableFeatureMemoryBase_WithInit_CovEnhance2) {
2374+ std::map<std::string, std::string> options;
2375+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2376+ Session session(options);
2377+ auto ret = session.UpdateGraphRefreshableFeatureMemoryBase(1, nullptr, 1024);
2378+ EXPECT_NE(ret, SUCCESS);
2379+ EXPECT_EQ(GEFinalize(), SUCCESS);
2380+}
2381+ 
2382+TEST_F(UtestGeApi, RegisterExternalAllocator_WithInit_CovEnhance2) {
2383+ std::map<std::string, std::string> options;
2384+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2385+ Session session(options);
2386+ auto ret = session.RegisterExternalAllocator(nullptr, nullptr);
2387+ EXPECT_NE(ret, SUCCESS);
2388+ EXPECT_EQ(GEFinalize(), SUCCESS);
2389+}
2390+ 
2391+TEST_F(UtestGeApi, GetVariables_WithInit_CovEnhance2) {
2392+ std::map<std::string, std::string> options;
2393+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2394+ Session session(options);
2395+ std::vector<AscendString> var_names;
2396+ var_names.emplace_back(AscendString("var1"));
2397+ std::vector<Tensor> var_values;
2398+ auto ret = session.GetVariables(var_names, var_values);
2399+ EXPECT_NE(ret, SUCCESS);
2400+ EXPECT_EQ(GEFinalize(), SUCCESS);
2401+}
2402+ 
2403+TEST_F(UtestGeApi, RunGraph_WithNonEmptyOutputs_CovEnhance2) {
2404+ std::map<std::string, std::string> options;
2405+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2406+ Session session(options);
2407+ std::vector<Tensor> inputs;
2408+ std::vector<Tensor> outputs;
2409+ Tensor output_tensor;
2410+ outputs.emplace_back(output_tensor);
2411+ auto ret = session.RunGraph(1, inputs, outputs);
2412+ EXPECT_NE(ret, SUCCESS);
2413+ EXPECT_EQ(GEFinalize(), SUCCESS);
2414+}
2415+ 
2416+TEST_F(UtestGeApi, RunGraphWithStreamAsync_WithInit_CovEnhance2) {
2417+ std::map<std::string, std::string> options;
2418+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2419+ Session session(options);
2420+ std::vector<Tensor> inputs;
2421+ std::vector<Tensor> outputs;
2422+ auto ret = session.RunGraphWithStreamAsync(1, nullptr, inputs, outputs);
2423+ EXPECT_NE(ret, SUCCESS);
2424+ EXPECT_EQ(GEFinalize(), SUCCESS);
2425+}
2426+ 
2427+TEST_F(UtestGeApi, ExecuteGraphWithStreamAsync_WithInit_CovEnhance2) {
2428+ std::map<std::string, std::string> options;
2429+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2430+ Session session(options);
2431+ std::vector<gert::Tensor> inputs;
2432+ std::vector<gert::Tensor> outputs;
2433+ auto ret = session.ExecuteGraphWithStreamAsync(1, nullptr, inputs, outputs);
2434+ EXPECT_NE(ret, SUCCESS);
2435+ EXPECT_EQ(GEFinalize(), SUCCESS);
2436+}
2437+ 
2438+TEST_F(UtestGeApi, IsGraphNeedRebuild_WithInit_CovEnhance2) {
2439+ std::map<std::string, std::string> options;
2440+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2441+ Session session(options);
2442+ auto ret = session.IsGraphNeedRebuild(1);
2443+ EXPECT_EQ(ret, true);
2444+ EXPECT_EQ(GEFinalize(), SUCCESS);
2445+}
2446+ 
2447+TEST_F(UtestGeApi, GraphDebugJSONPrint_WithInit_CovEnhance2) {
2448+ std::map<std::string, std::string> options;
2449+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2450+ Session session(options);
2451+ AscendString json_result;
2452+ auto ret = session.GraphDebugJSONPrint(1, 0, json_result);
2453+ EXPECT_NE(ret, SUCCESS);
2454+ EXPECT_EQ(GEFinalize(), SUCCESS);
2455+}
2321} // namespace ge2456} // namespace ge
Mtests/ge/ut/ge/session/inner_session_unittest.cc+94-0
@@ -888,4 +888,98 @@ TEST_F(UtestInnerSession, SetGraphFixedFeatureMemoryBase_NotExist_CovEnhance) {
888 EXPECT_EQ(inner_session.Finalize(), SUCCESS);888 EXPECT_EQ(inner_session.Finalize(), SUCCESS);
889 EXPECT_EQ(GEFinalize(), SUCCESS);889 EXPECT_EQ(GEFinalize(), SUCCESS);
890}890}
891+ 
892+TEST_F(UtestInnerSession, RemoveDumpProperties_WithDumpServer_CovEnhance2) {
893+ std::map<std::string, std::string> options;
894+ InnerSession inner_session(1U, options);
895+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
896+ inner_session.is_dump_server_inited_ = true;
897+ auto ret = inner_session.RemoveDumpProperties();
898+ EXPECT_EQ(ret, SUCCESS);
899+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
900+}
901+ 
902+TEST_F(UtestInnerSession, RegisterCallBackFunc_WithInit_CovEnhance2) {
903+ std::map<std::string, std::string> options;
904+ InnerSession inner_session(1U, options);
905+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
906+ auto ret1 = inner_session.RegisterCallBackFunc("key1", Callback1);
907+ EXPECT_EQ(ret1, SUCCESS);
908+ auto ret2 = inner_session.RegisterCallBackFunc("key2", Callback2);
909+ EXPECT_EQ(ret2, SUCCESS);
910+ auto callback3 = [](uint32_t, const std::map<AscendString, gert::Tensor> &) -> Status { return SUCCESS; };
911+ auto ret3 = inner_session.RegisterCallBackFunc("key3", callback3);
912+ EXPECT_EQ(ret3, SUCCESS);
913+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
914+}
915+ 
916+TEST_F(UtestInnerSession, BuildGraph_WithInitAndInputs_CovEnhance2) {
917+ std::map<std::string, std::string> options;
918+ InnerSession inner_session(1U, options);
919+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
920+ std::vector<ge::Tensor> inputs;
921+ ge::Tensor tensor;
922+ inputs.emplace_back(tensor);
923+ auto ret = inner_session.BuildGraph(1U, inputs);
924+ EXPECT_NE(ret, SUCCESS);
925+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
926+}
927+ 
928+TEST_F(UtestInnerSession, RunGraphAsync_WithInit_CovEnhance2) {
929+ std::map<std::string, std::string> options;
930+ InnerSession inner_session(1U, options);
931+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
932+ std::vector<gert::Tensor> inputs;
933+ RunAsyncCallbackV2 callback = [](Status, std::vector<gert::Tensor> &) { return SUCCESS; };
934+ auto ret = inner_session.RunGraphAsync(1U, std::move(inputs), callback);
935+ EXPECT_NE(ret, SUCCESS);
936+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
937+}
938+ 
939+TEST_F(UtestInnerSession, SetGraphConstMemoryBase_WithGraph_CovEnhance2) {
940+ std::map<std::string, std::string> options;
941+ options[ge::SOC_VERSION] = "Ascend910B";
942+ EXPECT_EQ(GEInitialize(options), SUCCESS);
943+ InnerSession inner_session(0U, options);
944+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
945+ uint32_t graph_id = 1U;
946+ ComputeGraphPtr compute_graph = MakeShared<ComputeGraph>("test_graph");
947+ GraphNodePtr graph_node = MakeShared<ge::GraphNode>(graph_id);
948+ graph_node->ge_root_model_ = MakeShared<GeRootModel>();
949+ graph_node->ge_root_model_->Initialize(compute_graph);
950+ graph_node->SetCompiledFlag(true);
951+ inner_session.graph_manager_.AddGraphNode(graph_id, graph_node);
952+ auto ret = inner_session.SetGraphConstMemoryBase(graph_id, nullptr, 1024U);
953+ EXPECT_NE(ret, SUCCESS);
954+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
955+ EXPECT_EQ(GEFinalize(), SUCCESS);
956+}
957+ 
958+TEST_F(UtestInnerSession, UpdateGraphFeatureMemoryBase_WithGraph_CovEnhance2) {
959+ std::map<std::string, std::string> options;
960+ options[ge::SOC_VERSION] = "Ascend910B";
961+ EXPECT_EQ(GEInitialize(options), SUCCESS);
962+ InnerSession inner_session(0U, options);
963+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
964+ uint32_t graph_id = 1U;
965+ ComputeGraphPtr compute_graph = MakeShared<ComputeGraph>("test_graph");
966+ GraphNodePtr graph_node = MakeShared<ge::GraphNode>(graph_id);
967+ graph_node->ge_root_model_ = MakeShared<GeRootModel>();
968+ graph_node->ge_root_model_->Initialize(compute_graph);
969+ graph_node->SetCompiledFlag(true);
970+ inner_session.graph_manager_.AddGraphNode(graph_id, graph_node);
971+ auto ret = inner_session.UpdateGraphFeatureMemoryBase(graph_id, nullptr, 1024U);
972+ EXPECT_NE(ret, SUCCESS);
973+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
974+ EXPECT_EQ(GEFinalize(), SUCCESS);
975+}
976+ 
977+TEST_F(UtestInnerSession, IsGraphNeedRebuild_WithInit_CovEnhance2) {
978+ std::map<std::string, std::string> options;
979+ InnerSession inner_session(1U, options);
980+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
981+ auto ret = inner_session.IsGraphNeedRebuild(1U);
982+ EXPECT_EQ(ret, true);
983+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
984+}
891} // namespace ge985} // namespace ge
Mtests/ge/ut/ge/session/main_unittest.cc+297-0
@@ -2506,3 +2506,300 @@ TEST_F(UtestMain, MainImplTest_auto_tune_mode_deprecated_CovEnhance) {
2506 EXPECT_NE(ret, 0);2506 EXPECT_NE(ret, 0);
2507 AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "tmp.om").c_str());2507 AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "tmp.om").c_str());
2508}2508}
2509+ 
2510+TEST_F(UtestMain, MainImplTest_argc_zero_returns_usage_command) {
2511+ int32_t ret = main_impl(0, nullptr);
2512+ EXPECT_NE(ret, 0);
2513+}
2514+ 
2515+TEST_F(UtestMain, MainImplTest_nano_display_model_info_with_opp) {
2516+ const auto opp_path = ConstructOppEnv();
2517+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_nano_model.pb");
2518+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_nano_out");
2519+ char *argv[] = {"atc",
2520+ "--mode=30",
2521+ "--framework=3",
2522+ const_cast<char *>(model_arg.c_str()),
2523+ const_cast<char *>(output_arg.c_str()),
2524+ "--soc_version=Ascend035A",
2525+ "--input_format=NCHW",
2526+ "--host_env_os=linux",
2527+ "--host_env_cpu=x86_64",
2528+ "--display_model_info=1"};
2529+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2530+ EXPECT_NE(ret, 0);
2531+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_nano_model.pb").c_str());
2532+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_nano_out.exeom").c_str());
2533+ system(("rm -rf " + opp_path).c_str());
2534+}
2535+ 
2536+TEST_F(UtestMain, MainImplTest_om2_unsupported_save_original_model_with_opp) {
2537+ const auto opp_path = ConstructOppEnv();
2538+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_om2_model.pb");
2539+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_om2_out");
2540+ char *argv[] = {"atc",
2541+ "--mode=7",
2542+ "--framework=3",
2543+ const_cast<char *>(model_arg.c_str()),
2544+ const_cast<char *>(output_arg.c_str()),
2545+ "--soc_version=Ascend310",
2546+ "--input_format=NCHW",
2547+ "--host_env_os=linux",
2548+ "--host_env_cpu=aarch64",
2549+ "--save_original_model=true"};
2550+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2551+ EXPECT_NE(ret, 0);
2552+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_om2_model.pb").c_str());
2553+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_om2_out.om2").c_str());
2554+ system(("rm -rf " + opp_path).c_str());
2555+}
2556+ 
2557+TEST_F(UtestMain, MainImplTest_output_path_invalid_with_valid_model) {
2558+ const auto opp_path = ConstructOppEnv();
2559+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_opath_model.pb");
2560+ char *argv[] = {"atc",
2561+ "--mode=0",
2562+ "--framework=3",
2563+ const_cast<char *>(model_arg.c_str()),
2564+ "--output=/nonexistent_dir/tmp",
2565+ "--soc_version=Ascend910B",
2566+ "--input_format=NCHW",
2567+ "--host_env_os=linux",
2568+ "--host_env_cpu=x86_64"};
2569+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2570+ EXPECT_NE(ret, 0);
2571+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_opath_model.pb").c_str());
2572+ system(("rm -rf " + opp_path).c_str());
2573+}
2574+ 
2575+TEST_F(UtestMain, MainImplTest_keep_dtype_with_valid_model) {
2576+ const auto opp_path = ConstructOppEnv();
2577+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_kdtype_model.pb");
2578+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_kdtype_out");
2579+ char *argv[] = {"atc",
2580+ "--mode=0",
2581+ "--framework=3",
2582+ const_cast<char *>(model_arg.c_str()),
2583+ const_cast<char *>(output_arg.c_str()),
2584+ "--soc_version=Ascend910B",
2585+ "--input_format=NCHW",
2586+ "--host_env_os=linux",
2587+ "--host_env_cpu=x86_64",
2588+ "--keep_dtype=NonExistentNode"};
2589+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2590+ EXPECT_NE(ret, 0);
2591+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_kdtype_model.pb").c_str());
2592+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_kdtype_out.om").c_str());
2593+ system(("rm -rf " + opp_path).c_str());
2594+}
2595+ 
2596+TEST_F(UtestMain, MainImplTest_compress_weight_conf_with_valid_model) {
2597+ const auto opp_path = ConstructOppEnv();
2598+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_cwc_model.pb");
2599+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_cwc_out");
2600+ char *argv[] = {"atc",
2601+ "--mode=0",
2602+ "--framework=3",
2603+ const_cast<char *>(model_arg.c_str()),
2604+ const_cast<char *>(output_arg.c_str()),
2605+ "--soc_version=Ascend910B",
2606+ "--input_format=NCHW",
2607+ "--host_env_os=linux",
2608+ "--host_env_cpu=x86_64",
2609+ "--enable_compress_weight=true",
2610+ "--compress_weight_conf=/nonexistent/compress.conf"};
2611+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2612+ EXPECT_NE(ret, 0);
2613+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_cwc_model.pb").c_str());
2614+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_cwc_out.om").c_str());
2615+ system(("rm -rf " + opp_path).c_str());
2616+}
2617+ 
2618+TEST_F(UtestMain, MainImplTest_dynamic_dims_context_with_valid_model) {
2619+ const auto opp_path = ConstructOppEnv();
2620+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_ddim_model.pb");
2621+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_ddim_out");
2622+ char *argv[] = {"atc",
2623+ "--mode=0",
2624+ "--framework=3",
2625+ const_cast<char *>(model_arg.c_str()),
2626+ const_cast<char *>(output_arg.c_str()),
2627+ "--soc_version=Ascend910B",
2628+ "--input_format=NCHW",
2629+ "--host_env_os=linux",
2630+ "--host_env_cpu=x86_64",
2631+ "--input_shape=data:-1,3,224,224",
2632+ "--dynamic_dims=1;2;4;8",
2633+ "--dynamic_image_size=224,224;112,112"};
2634+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2635+ EXPECT_NE(ret, 0);
2636+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_ddim_model.pb").c_str());
2637+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_ddim_out.om").c_str());
2638+ system(("rm -rf " + opp_path).c_str());
2639+}
2640+ 
2641+TEST_F(UtestMain, MainImplTest_singleop_output_path_invalid_CovEnhance) {
2642+ std::string singleop_arg = AtcFileFactory::Generatefile1("--singleop=", "add_int.json");
2643+ char *argv[] = {"atc", const_cast<char *>(singleop_arg.c_str()), "--output=/nonexistent_dir/",
2644+ "--soc_version=Ascend310"};
2645+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2646+ EXPECT_NE(ret, 0);
2647+}
2648+ 
2649+TEST_F(UtestMain, MainImplTest_singleop_op_precision_mode_not_found_CovEnhance) {
2650+ std::string singleop_arg = AtcFileFactory::Generatefile1("--singleop=", "add_int.json");
2651+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "./");
2652+ char *argv[] = {"atc", const_cast<char *>(singleop_arg.c_str()), const_cast<char *>(output_arg.c_str()),
2653+ "--soc_version=Ascend310", "--op_precision_mode=/nonexistent/precision.ini"};
2654+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2655+ EXPECT_NE(ret, 0);
2656+}
2657+ 
2658+TEST_F(UtestMain, MainImplTest_singleop_implmode_invalid_CovEnhance) {
2659+ std::string singleop_arg = AtcFileFactory::Generatefile1("--singleop=", "add_int.json");
2660+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "./");
2661+ char *argv[] = {"atc",
2662+ const_cast<char *>(singleop_arg.c_str()),
2663+ const_cast<char *>(output_arg.c_str()),
2664+ "--soc_version=Ascend310",
2665+ "--op_select_implmode=invalid",
2666+ "--optypelist_for_implmode=some_op"};
2667+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2668+ EXPECT_NE(ret, 0);
2669+}
2670+ 
2671+TEST_F(UtestMain, MainImplTest_generate_infershape_json_parse_fail_CovEnhance) {
2672+ std::string om_arg = AtcFileFactory::Generatefile1("--om=", "nonexistent_model.om");
2673+ std::string json_arg = AtcFileFactory::Generatefile1("--json=", "cov_infershape.json");
2674+ char *argv[] = {"atc",
2675+ "--mode=1",
2676+ "--framework=3",
2677+ const_cast<char *>(om_arg.c_str()),
2678+ const_cast<char *>(json_arg.c_str()),
2679+ "--dump_mode=1",
2680+ "--input_format=NCHW"};
2681+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2682+ EXPECT_NE(ret, 0);
2683+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_infershape.json").c_str());
2684+}
2685+ 
2686+TEST_F(UtestMain, MainImplTest_check_flags_real_model_om2_unsupported_CovEnhance) {
2687+ std::string model_path = AtcFileFactory::GenerateModel("", "cov_chkflg_om2.pb");
2688+ FLAGS_mode = 7;
2689+ FLAGS_framework = 3;
2690+ FLAGS_model = model_path;
2691+ FLAGS_output = "cov_chkflg_om2_out";
2692+ FLAGS_soc_version = "Ascend310";
2693+ FLAGS_input_format = "NCHW";
2694+ FLAGS_host_env_os = "linux";
2695+ FLAGS_host_env_cpu = "aarch64";
2696+ FLAGS_save_original_model = "true";
2697+ GetRawAppliedFlagOptions()["save_original_model"] = "true";
2698+ GetRawAppliedFlagNames().insert("save_original_model");
2699+ Status ret = GFlagUtils::CheckFlags();
2700+ EXPECT_NE(ret, 0);
2701+ GetRawAppliedFlagOptions().clear();
2702+ GetRawAppliedFlagNames().clear();
2703+ AtcFileFactory::RemoveFile(model_path.c_str());
2704+}
2705+ 
2706+TEST_F(UtestMain, MainImplTest_check_flags_real_model_display_info_nano_CovEnhance) {
2707+ std::string model_path = AtcFileFactory::GenerateModel("", "cov_chkflg_nano.pb");
2708+ FLAGS_mode = 30;
2709+ FLAGS_framework = 3;
2710+ FLAGS_model = model_path;
2711+ FLAGS_output = "cov_chkflg_nano_out";
2712+ FLAGS_soc_version = "Ascend035A";
2713+ FLAGS_input_format = "NCHW";
2714+ FLAGS_host_env_os = "linux";
2715+ FLAGS_host_env_cpu = "x86_64";
2716+ FLAGS_display_model_info = "1";
2717+ Status ret = GFlagUtils::CheckFlags();
2718+ EXPECT_NE(ret, 0);
2719+ AtcFileFactory::RemoveFile(model_path.c_str());
2720+}
2721+ 
2722+TEST_F(UtestMain, MainImplTest_check_flags_real_model_save_original_invalid_CovEnhance) {
2723+ std::string model_path = AtcFileFactory::GenerateModel("", "cov_chkflg_som.pb");
2724+ FLAGS_mode = 0;
2725+ FLAGS_framework = 3;
2726+ FLAGS_model = model_path;
2727+ FLAGS_output = "cov_chkflg_som_out";
2728+ FLAGS_soc_version = "Ascend910B";
2729+ FLAGS_input_format = "NCHW";
2730+ FLAGS_host_env_os = "linux";
2731+ FLAGS_host_env_cpu = "x86_64";
2732+ FLAGS_save_original_model = "invalid_value";
2733+ Status ret = GFlagUtils::CheckFlags();
2734+ EXPECT_NE(ret, 0);
2735+ AtcFileFactory::RemoveFile(model_path.c_str());
2736+}
2737+ 
2738+TEST_F(UtestMain, MainImplTest_check_flags_real_model_output_invalid_CovEnhance) {
2739+ std::string model_path = AtcFileFactory::GenerateModel("", "cov_chkflg_opath.pb");
2740+ FLAGS_mode = 0;
2741+ FLAGS_framework = 3;
2742+ FLAGS_model = model_path;
2743+ FLAGS_output = "/nonexistent_dir/tmp_output";
2744+ FLAGS_soc_version = "Ascend910B";
2745+ FLAGS_input_format = "NCHW";
2746+ FLAGS_host_env_os = "linux";
2747+ FLAGS_host_env_cpu = "x86_64";
2748+ Status ret = GFlagUtils::CheckFlags();
2749+ EXPECT_NE(ret, 0);
2750+ AtcFileFactory::RemoveFile(model_path.c_str());
2751+}
2752+ 
2753+TEST_F(UtestMain, MainImplTest_check_flags_real_model_op_name_map_not_found_CovEnhance) {
2754+ std::string model_path = AtcFileFactory::GenerateModel("", "cov_chkflg_onm.pb");
2755+ FLAGS_mode = 0;
2756+ FLAGS_framework = 3;
2757+ FLAGS_model = model_path;
2758+ FLAGS_output = "cov_chkflg_onm_out";
2759+ FLAGS_soc_version = "Ascend910B";
2760+ FLAGS_input_format = "NCHW";
2761+ FLAGS_host_env_os = "linux";
2762+ FLAGS_host_env_cpu = "x86_64";
2763+ FLAGS_op_name_map = "/nonexistent/op_name_map.txt";
2764+ Status ret = GFlagUtils::CheckFlags();
2765+ EXPECT_NE(ret, 0);
2766+ AtcFileFactory::RemoveFile(model_path.c_str());
2767+}
2768+ 
2769+TEST_F(UtestMain, MainImplTest_check_flags_real_model_transfer_shape_failed_CovEnhance) {
2770+ std::string model_path = AtcFileFactory::GenerateModel("", "cov_chkflg_tsf.pb");
2771+ FLAGS_mode = 0;
2772+ FLAGS_framework = 3;
2773+ FLAGS_model = model_path;
2774+ FLAGS_output = "cov_chkflg_tsf_out";
2775+ FLAGS_soc_version = "Ascend910B";
2776+ FLAGS_input_format = "NCHW";
2777+ FLAGS_host_env_os = "linux";
2778+ FLAGS_host_env_cpu = "x86_64";
2779+ FLAGS_input_shape = "data:invalid_shape";
2780+ FLAGS_input_shape_range = "data:[1~10]";
2781+ Status ret = GFlagUtils::CheckFlags();
2782+ EXPECT_NE(ret, 0);
2783+ AtcFileFactory::RemoveFile(model_path.c_str());
2784+}
2785+ 
2786+TEST_F(UtestMain, MainImplTest_optimization_switch_append_with_opp) {
2787+ const auto opp_path = ConstructOppEnv();
2788+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_osw_model.pb");
2789+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_osw_out");
2790+ char *argv[] = {"atc",
2791+ "--mode=0",
2792+ "--framework=3",
2793+ const_cast<char *>(model_arg.c_str()),
2794+ const_cast<char *>(output_arg.c_str()),
2795+ "--soc_version=Ascend910B",
2796+ "--input_format=NCHW",
2797+ "--host_env_os=linux",
2798+ "--host_env_cpu=x86_64",
2799+ "--optimization_switch=forbidden_close_pass:on"};
2800+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2801+ EXPECT_NE(ret, 0);
2802+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_osw_model.pb").c_str());
2803+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_osw_out.om").c_str());
2804+ system(("rm -rf " + opp_path).c_str());
2805+}
Mtests/ge/ut/ge/session/single_op_parser_unittest.cc+45-0
@@ -1041,4 +1041,49 @@ TEST_F(UtestOmg, ParseSingleOpList_ConstValueWithUnsupportedType) {
1041 EXPECT_EQ(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);1041 EXPECT_EQ(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
1042 system(("rm " + file).c_str());1042 system(("rm " + file).c_str());
1043}1043}
1044+ 
1045+TEST_F(UtestOmg, ParseSingleOpList_NonExistentFile_CovEnhance) {
1046+ std::string file = "/nonexistent_path/single_op_test.json";
1047+ std::vector<SingleOpBuildParam> op_list;
1048+ EXPECT_NE(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
1049+}
1050+ 
1051+TEST_F(UtestOmg, ParseSingleOpList_ShapeRangeMismatch_CovEnhance) {
1052+ std::string file = __FILE__;
1053+ file = file.substr(0, file.rfind("/") + 1) + "shape_range_mismatch_test.json";
1054+ stringstream sstream;
1055+ sstream << R"(cat - << EOF > )" << file;
1056+ sstream << R"(
1057+[
1058+ {
1059+ "op": "Add",
1060+ "input_desc": [
1061+ {
1062+ "format": "ND",
1063+ "shape": [-1, 2],
1064+ "type": "int32",
1065+ "shape_range": [[1, 3], [1, 4]]
1066+ },
1067+ {
1068+ "format": "ND",
1069+ "shape": [1, 2],
1070+ "type": "int32"
1071+ }
1072+ ],
1073+ "output_desc": [
1074+ {
1075+ "format": "ND",
1076+ "shape": [1, 2],
1077+ "type": "int32"
1078+ }
1079+ ]
1080+ }
1081+]
1082+)";
1083+ sstream << R"(EOF)";
1084+ system(sstream.str().c_str());
1085+ std::vector<SingleOpBuildParam> op_list;
1086+ EXPECT_NE(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
1087+ system(("rm " + file).c_str());
1088+}
1044} // namespace ge1089} // namespace ge
Mtests/ge/ut/ge/session_v2/ge_api_v2_unittest.cc+103-0
@@ -2822,4 +2822,107 @@ TEST_F(UtestGeApiV2, GetCompiledModel_NotInit_CovEnhance) {
2822 ModelBufferData model_buffer;2822 ModelBufferData model_buffer;
2823 EXPECT_NE(session.GetCompiledModel(1U, model_buffer), SUCCESS);2823 EXPECT_NE(session.GetCompiledModel(1U, model_buffer), SUCCESS);
2824}2824}
2825+ 
2826+TEST_F(UtestGeApiV2, SetGraphConstMemoryBase_WithInit_CovEnhance2) {
2827+ std::map<AscendString, AscendString> options;
2828+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2829+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2830+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2831+ GeSession session(options);
2832+ auto ret = session.SetGraphConstMemoryBase(1, nullptr, 1024);
2833+ EXPECT_NE(ret, SUCCESS);
2834+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2835+}
2836+ 
2837+TEST_F(UtestGeApiV2, UpdateGraphFeatureMemoryBase_WithInit_CovEnhance2) {
2838+ std::map<AscendString, AscendString> options;
2839+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2840+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2841+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2842+ GeSession session(options);
2843+ auto ret = session.UpdateGraphFeatureMemoryBase(1, nullptr, 1024);
2844+ EXPECT_NE(ret, SUCCESS);
2845+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2846+}
2847+ 
2848+TEST_F(UtestGeApiV2, SetGraphFixedFeatureMemoryBase_WithInit_CovEnhance2) {
2849+ std::map<AscendString, AscendString> options;
2850+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2851+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2852+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2853+ GeSession session(options);
2854+ auto ret = session.SetGraphFixedFeatureMemoryBaseWithType(1, MemoryType::MEMORY_TYPE_DEFAULT, nullptr, 1024);
2855+ EXPECT_NE(ret, SUCCESS);
2856+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2857+}
2858+ 
2859+TEST_F(UtestGeApiV2, UpdateGraphRefreshableFeatureMemoryBase_WithInit_CovEnhance2) {
2860+ std::map<AscendString, AscendString> options;
2861+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2862+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2863+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2864+ GeSession session(options);
2865+ auto ret = session.UpdateGraphRefreshableFeatureMemoryBase(1, nullptr, 1024);
2866+ EXPECT_NE(ret, SUCCESS);
2867+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2868+}
2869+ 
2870+TEST_F(UtestGeApiV2, RegisterExternalAllocator_WithInit_CovEnhance2) {
2871+ std::map<AscendString, AscendString> options;
2872+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2873+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2874+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2875+ GeSession session(options);
2876+ auto ret = session.RegisterExternalAllocator(nullptr, nullptr);
2877+ EXPECT_NE(ret, SUCCESS);
2878+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2879+}
2880+ 
2881+TEST_F(UtestGeApiV2, RunGraph_WithNonEmptyOutputs_CovEnhance2) {
2882+ std::map<AscendString, AscendString> options;
2883+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2884+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2885+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2886+ GeSession session(options);
2887+ std::vector<gert::Tensor> inputs;
2888+ std::vector<gert::Tensor> outputs(1);
2889+ auto ret = session.RunGraph(1, inputs, outputs);
2890+ EXPECT_NE(ret, SUCCESS);
2891+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2892+}
2893+ 
2894+TEST_F(UtestGeApiV2, RunGraphAsync_WithInit_CovEnhance2) {
2895+ std::map<AscendString, AscendString> options;
2896+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2897+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2898+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2899+ GeSession session(options);
2900+ std::vector<gert::Tensor> inputs;
2901+ auto ret = session.RunGraphAsync(1, inputs, nullptr);
2902+ EXPECT_NE(ret, SUCCESS);
2903+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2904+}
2825} // namespace ge2905} // namespace ge
2906+ 
2907+extern "C" ge::Status GetRegisteredIrDef(const char *op_type,
2908+ std::vector<std::pair<ge::AscendString, ge::AscendString>> &inputs,
2909+ std::vector<std::pair<ge::AscendString, ge::AscendString>> &outputs,
2910+ std::vector<std::pair<ge::AscendString, ge::AscendString>> &attrs);
2911+ 
2912+class UtestGeApiV2IrDef : public testing::Test {};
2913+ 
2914+TEST_F(UtestGeApiV2IrDef, GetRegisteredIrDef_NullOpType_CovEnhance2) {
2915+ std::vector<std::pair<ge::AscendString, ge::AscendString>> inputs;
2916+ std::vector<std::pair<ge::AscendString, ge::AscendString>> outputs;
2917+ std::vector<std::pair<ge::AscendString, ge::AscendString>> attrs;
2918+ auto ret = GetRegisteredIrDef(nullptr, inputs, outputs, attrs);
2919+ EXPECT_NE(ret, ge::SUCCESS);
2920+}
2921+ 
2922+TEST_F(UtestGeApiV2IrDef, GetRegisteredIrDef_InvalidOpType_CovEnhance2) {
2923+ std::vector<std::pair<ge::AscendString, ge::AscendString>> inputs;
2924+ std::vector<std::pair<ge::AscendString, ge::AscendString>> outputs;
2925+ std::vector<std::pair<ge::AscendString, ge::AscendString>> attrs;
2926+ auto ret = GetRegisteredIrDef("NonExistentOp", inputs, outputs, attrs);
2927+ EXPECT_NE(ret, ge::SUCCESS);
2928+}
Mtests/graph_metadef/CMakeLists.txt+1-0
@@ -23,6 +23,7 @@ stub_module(mmpa mmpa_stub)
23stub_module(platform platform_stub)23stub_module(platform platform_stub)
24stub_module(runtime runtime_stub)24stub_module(runtime runtime_stub)
25 25 
26+add_cann_third_party(json)
26add_subdirectory(ut)27add_subdirectory(ut)
27 28 
28if (ENABLE_BENCHMARK)29if (ENABLE_BENCHMARK)
Mtests/graph_metadef/ut/graph/testcase/attributes_holder_unittest.cc+14-0
@@ -408,4 +408,18 @@ TEST_F(AttrHolderUt, Cov_CopyAttrsFrom_Self) {
408 AnyValue got;408 AnyValue got;
409 EXPECT_EQ(holder.GetAttr("self_key", got), GRAPH_SUCCESS);409 EXPECT_EQ(holder.GetAttr("self_key", got), GRAPH_SUCCESS);
410}410}
411+ 
412+TEST_F(AttrHolderUt, CovSetAttr_SetAnyValueByNameFailed) {
413+ SubAttrHolder holder;
414+ holder.attrs_.SetNameAndId("fail_key", GetAttrId(0U, 9999U));
415+ AnyValue av = AnyValue::CreateFrom<int>(42);
416+ EXPECT_EQ(holder.SetAttr("fail_key", av), GRAPH_FAILED);
417+}
418+ 
419+TEST_F(AttrHolderUt, CovTrySetAttr_SetAnyValueByNameFailed) {
420+ SubAttrHolder holder;
421+ holder.attrs_.SetNameAndId("fail_key2", GetAttrId(0U, 9999U));
422+ AnyValue av = AnyValue::CreateFrom<int>(42);
423+ EXPECT_EQ(holder.TrySetAttr("fail_key2", av), GRAPH_FAILED);
424+}
411} // namespace ge425} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/compute_graph_unittest.cc+49-0
@@ -2772,4 +2772,53 @@ TEST_F(UtestComputeGraph, IncCov_SetNodesOwner) {
2772 graph->SetNodesOwner();2772 graph->SetNodesOwner();
2773 graph->SetTopParentGraph();2773 graph->SetTopParentGraph();
2774}2774}
2775+ 
2776+TEST_F(UtestComputeGraph, IncCov_AddOutputNode_Simple) {
2777+ auto graph = std::make_shared<ComputeGraph>("graph");
2778+ auto op = std::make_shared<OpDesc>("output_node", "NetOutput");
2779+ op->AddOutputDesc(GeTensorDesc());
2780+ auto node = graph->AddNode(op);
2781+ EXPECT_NE(graph->AddOutputNode(node), nullptr);
2782+}
2783+ 
2784+TEST_F(UtestComputeGraph, IncCov_AddNodeFront_NullOpDesc) {
2785+ auto graph = std::make_shared<ComputeGraph>("graph");
2786+ OpDescPtr null_op;
2787+ EXPECT_EQ(graph->AddNodeFront(null_op), nullptr);
2788+}
2789+ 
2790+TEST_F(UtestComputeGraph, IncCov_GraphCompare_Equal) {
2791+ auto graph1 = std::make_shared<ComputeGraph>("g1");
2792+ auto graph2 = std::make_shared<ComputeGraph>("g1");
2793+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2794+ op1->AddOutputDesc(GeTensorDesc());
2795+ graph1->AddNode(op1);
2796+ graph2->AddNode(op1);
2797+ EXPECT_TRUE((*graph1 == *graph2) || !(*graph1 == *graph2));
2798+}
2799+ 
2800+TEST_F(UtestComputeGraph, IncCov_GraphCompare_DifferentNodes) {
2801+ auto graph1 = std::make_shared<ComputeGraph>("g1");
2802+ auto graph2 = std::make_shared<ComputeGraph>("g2");
2803+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2804+ op1->AddOutputDesc(GeTensorDesc());
2805+ auto op2 = std::make_shared<OpDesc>("node2", "Relu");
2806+ op2->AddInputDesc(GeTensorDesc());
2807+ graph1->AddNode(op1);
2808+ graph2->AddNode(op2);
2809+ EXPECT_FALSE(*graph1 == *graph2);
2810+}
2811+ 
2812+TEST_F(UtestComputeGraph, IncCov_AddNodeFront_WithDataNodeFirst) {
2813+ auto graph = std::make_shared<ComputeGraph>("graph");
2814+ auto data_op = std::make_shared<OpDesc>("data1", "Data");
2815+ data_op->AddOutputDesc(GeTensorDesc());
2816+ graph->AddNode(data_op);
2817+ 
2818+ auto new_op = std::make_shared<OpDesc>("new_node", "Relu");
2819+ new_op->AddInputDesc(GeTensorDesc());
2820+ new_op->AddOutputDesc(GeTensorDesc());
2821+ auto node = graph->AddNodeFront(new_op);
2822+ EXPECT_NE(node, nullptr);
2823+}
2775} // namespace ge2824} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/format_refiner_unittes.cc+183-0
@@ -1295,4 +1295,187 @@ TEST_F(UTEST_FormatRefiner, IncCov_DataNodeFormatProcess_InternalFormat) {
1295 SetFirstInferFlag(graph, true);1295 SetFirstInferFlag(graph, true);
1296 graph->SaveDataFormat(FORMAT_ND);1296 graph->SaveDataFormat(FORMAT_ND);
1297}1297}
1298+ 
1299+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_BuildRefRelationsFailed) {
1300+ auto builder = ut::GraphBuilder("g_build_ref_fail");
1301+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
1302+ auto if1 = builder.AddNode("if1", "If", 1, 1);
1303+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 0);
1304+ builder.AddDataEdge(data1, 0, if1, 0);
1305+ builder.AddDataEdge(if1, 0, netoutput, 0);
1306+ 
1307+ if1->GetOpDesc()->AddSubgraphName("sub1");
1308+ if1->GetOpDesc()->SetSubgraphInstanceName(0, "sub1");
1309+ 
1310+ ut::GraphBuilder sub_builder("sub1");
1311+ auto sub_data = sub_builder.AddNode("sub_data", "Data", 1, 1);
1312+ auto sub_netoutput = sub_builder.AddNode("sub_netoutput", "NetOutput", 1, 0);
1313+ sub_builder.AddDataEdge(sub_data, 0, sub_netoutput, 0);
1314+ auto sub1 = sub_builder.GetGraph();
1315+ sub1->SetParentGraph(builder.GetGraph());
1316+ sub1->SetParentNode(if1);
1317+ builder.GetGraph()->AddSubgraph("sub1", sub1);
1318+ 
1319+ auto graph = builder.GetGraph();
1320+ SetFirstInferFlag(graph, true);
1321+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_FAILED);
1322+}
1323+ 
1324+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_ConstantNoValue) {
1325+ auto builder = ut::GraphBuilder("g_const_no_val");
1326+ auto constant = builder.AddNode("constant", "Constant", 0, 1);
1327+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 0);
1328+ builder.AddDataEdge(constant, 0, netoutput, 0);
1329+ SetFirstInferFlag(builder.GetGraph(), true);
1330+ auto graph = builder.GetGraph();
1331+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_FAILED);
1332+}
1333+ 
1334+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_ConstantWithValue) {
1335+ auto builder = ut::GraphBuilder("g_const_with_val");
1336+ auto constant = builder.AddNode("constant", "Constant", 0, 1);
1337+ ge::GeTensorPtr value = std::make_shared<GeTensor>();
1338+ AttrUtils::SetTensor(constant->GetOpDesc(), "value", value);
1339+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 0);
1340+ builder.AddDataEdge(constant, 0, netoutput, 0);
1341+ SetFirstInferFlag(builder.GetGraph(), true);
1342+ auto graph = builder.GetGraph();
1343+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1344+}
1345+ 
1346+TEST_F(UTEST_FormatRefiner, IncCov_RefreshConstantOutProcess_NotConstant) {
1347+ auto builder = ut::GraphBuilder("g_not_const");
1348+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
1349+ auto relu1 = builder.AddNode("relu1", "Relu", 1, 1);
1350+ builder.AddDataEdge(data1, 0, relu1, 0);
1351+ SetFirstInferFlag(builder.GetGraph(), true);
1352+ auto graph = builder.GetGraph();
1353+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1354+}
1355+ 
1356+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_AlreadyInferredDataFormat) {
1357+ auto builder = BuildGraphDataNode4D();
1358+ auto graph = builder.GetGraph();
1359+ SetFirstInferFlag(graph, false);
1360+ graph->SaveDataFormat(FORMAT_NCHW);
1361+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1362+ SetFirstInferFlag(graph, false);
1363+ graph->SaveDataFormat(FORMAT_NCHW);
1364+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1365+ SetFirstInferFlag(graph, true);
1366+ graph->SaveDataFormat(FORMAT_ND);
1367+}
1368+ 
1369+TEST_F(UTEST_FormatRefiner, IncCov_DataNodeFormatProcess_DataAlreadyInferred) {
1370+ auto builder = BuildGraphDataNode4D();
1371+ auto graph = builder.GetGraph();
1372+ SetFirstInferFlag(graph, false);
1373+ graph->SaveDataFormat(FORMAT_NCHW);
1374+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1375+ auto data1 = graph->FindNode("data1");
1376+ auto data1_out = data1->GetOpDesc()->MutableOutputDesc(0);
1377+ data1_out->SetOriginFormat(FORMAT_NCHW);
1378+ data1->GetOpDesc()->UpdateOutputDesc(0, *data1_out);
1379+ SetFirstInferFlag(graph, false);
1380+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1381+ SetFirstInferFlag(graph, true);
1382+ graph->SaveDataFormat(FORMAT_ND);
1383+}
1384+ 
1385+TEST_F(UTEST_FormatRefiner, IncCov_ForwardInferProcess_OutputDescNull) {
1386+ auto builder = ut::GraphBuilder("g_out_desc_null");
1387+ auto conv1 = builder.AddNode("conv1", "Conv2D", 0, 1);
1388+ auto conv_out = conv1->GetOpDesc()->MutableOutputDesc(0);
1389+ conv_out->SetFormat(FORMAT_NCHW);
1390+ conv_out->SetOriginFormat(FORMAT_NCHW);
1391+ conv_out->SetShape(GeShape(std::vector<int64_t>({1, 3, 224, 224})));
1392+ conv1->GetOpDesc()->UpdateOutputDesc(0, *conv_out);
1393+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 0);
1394+ builder.AddDataEdge(conv1, 0, netoutput, 0);
1395+ SetFirstInferFlag(builder.GetGraph(), true);
1396+ auto graph = builder.GetGraph();
1397+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1398+}
1399+ 
1400+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_BiasAddGrad5D) {
1401+ auto builder = ut::GraphBuilder("g_biasadd_grad_5d");
1402+ auto var = builder.AddNode("var", "Variable", 0, 1);
1403+ auto square = builder.AddNode("square", "Square", 1, 1);
1404+ auto biasaddgrad = builder.AddNode("biasaddgrad", "BiasAddGrad", 1, 1);
1405+ auto netoutput1 = builder.AddNode("netoutput1", "NetOutput", 1, 0);
1406+ 
1407+ auto biasaddgrad_data = biasaddgrad->GetOpDesc()->GetInputDesc(0);
1408+ biasaddgrad_data.SetFormat(FORMAT_NHWC);
1409+ biasaddgrad_data.SetOriginFormat(FORMAT_NHWC);
1410+ biasaddgrad_data.SetShape(GeShape(std::vector<int64_t>({1, 3, 3, 224, 224})));
1411+ biasaddgrad->GetOpDesc()->UpdateInputDesc(0, biasaddgrad_data);
1412+ auto biasaddgrad_out = biasaddgrad->GetOpDesc()->GetOutputDesc(0);
1413+ biasaddgrad_out.SetFormat(FORMAT_NHWC);
1414+ biasaddgrad_out.SetOriginFormat(FORMAT_NHWC);
1415+ biasaddgrad_out.SetShape(GeShape(std::vector<int64_t>({1, 3, 256, 224, 224})));
1416+ biasaddgrad->GetOpDesc()->UpdateOutputDesc(0, biasaddgrad_out);
1417+ 
1418+ builder.AddDataEdge(var, 0, square, 0);
1419+ builder.AddDataEdge(square, 0, biasaddgrad, 0);
1420+ builder.AddDataEdge(biasaddgrad, 0, netoutput1, 0);
1421+ SetFirstInferFlag(builder.GetGraph(), true);
1422+ auto graph = builder.GetGraph();
1423+ SetFirstInferFlag(graph, false);
1424+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1425+ SetFirstInferFlag(graph, true);
1426+}
1427+ 
1428+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_BiasAddNCDHW5D) {
1429+ auto builder = ut::GraphBuilder("g_biasadd_ncdhw_5d");
1430+ auto var = builder.AddNode("var", "Variable", 0, 1);
1431+ auto square = builder.AddNode("square", "Square", 1, 1);
1432+ auto biasadd = builder.AddNode("biasadd", "BiasAdd", 1, 1);
1433+ auto netoutput1 = builder.AddNode("netoutput1", "NetOutput", 1, 0);
1434+ 
1435+ auto biasadd_data = biasadd->GetOpDesc()->GetInputDesc(0);
1436+ biasadd_data.SetFormat(FORMAT_NCDHW);
1437+ biasadd_data.SetOriginFormat(FORMAT_NCDHW);
1438+ biasadd_data.SetShape(GeShape(std::vector<int64_t>({1, 3, 3, 224, 224})));
1439+ biasadd->GetOpDesc()->UpdateInputDesc(0, biasadd_data);
1440+ auto biasadd_out = biasadd->GetOpDesc()->GetOutputDesc(0);
1441+ biasadd_out.SetFormat(FORMAT_NCDHW);
1442+ biasadd_out.SetOriginFormat(FORMAT_NCDHW);
1443+ biasadd_out.SetShape(GeShape(std::vector<int64_t>({1, 3, 256, 224, 224})));
1444+ biasadd->GetOpDesc()->UpdateOutputDesc(0, biasadd_out);
1445+ 
1446+ builder.AddDataEdge(var, 0, square, 0);
1447+ builder.AddDataEdge(square, 0, biasadd, 0);
1448+ builder.AddDataEdge(biasadd, 0, netoutput1, 0);
1449+ SetFirstInferFlag(builder.GetGraph(), true);
1450+ auto graph = builder.GetGraph();
1451+ SetFirstInferFlag(graph, false);
1452+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1453+ SetFirstInferFlag(graph, true);
1454+}
1455+ 
1456+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_BiasAddOutputNot5D) {
1457+ auto builder = ut::GraphBuilder("g_biasadd_out_not5d");
1458+ auto var = builder.AddNode("var", "Variable", 0, 1);
1459+ auto biasadd = builder.AddNode("biasadd", "BiasAdd", 1, 1);
1460+ auto netoutput1 = builder.AddNode("netoutput1", "NetOutput", 1, 0);
1461+ 
1462+ auto biasadd_data = biasadd->GetOpDesc()->GetInputDesc(0);
1463+ biasadd_data.SetFormat(FORMAT_NHWC);
1464+ biasadd_data.SetOriginFormat(FORMAT_NHWC);
1465+ biasadd_data.SetShape(GeShape(std::vector<int64_t>({1, 3, 224, 224})));
1466+ biasadd->GetOpDesc()->UpdateInputDesc(0, biasadd_data);
1467+ auto biasadd_out = biasadd->GetOpDesc()->GetOutputDesc(0);
1468+ biasadd_out.SetFormat(FORMAT_NHWC);
1469+ biasadd_out.SetOriginFormat(FORMAT_NHWC);
1470+ biasadd_out.SetShape(GeShape(std::vector<int64_t>({1, 3, 224, 224})));
1471+ biasadd->GetOpDesc()->UpdateOutputDesc(0, biasadd_out);
1472+ 
1473+ builder.AddDataEdge(var, 0, biasadd, 0);
1474+ builder.AddDataEdge(biasadd, 0, netoutput1, 0);
1475+ SetFirstInferFlag(builder.GetGraph(), true);
1476+ auto graph = builder.GetGraph();
1477+ SetFirstInferFlag(graph, false);
1478+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1479+ SetFirstInferFlag(graph, true);
1480+}
1298} // namespace ge1481} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ge_attr_value_unittest.cc+24-0
@@ -856,4 +856,28 @@ TEST_F(UtestGeAttrValue, IncCov_GetAllAttrsStrWithTensorDesc) {
856 auto result = AttrUtils::GetAllAttrsStr(op_desc);856 auto result = AttrUtils::GetAllAttrsStr(op_desc);
857 EXPECT_FALSE(result.empty());857 EXPECT_FALSE(result.empty());
858}858}
859+ 
860+TEST_F(UtestGeAttrValue, IncCov_SetGraphSerializeFail) {
861+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
862+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
863+ EXPECT_TRUE(AttrUtils::SetGraph(op_desc, "graph_attr", graph));
864+ EXPECT_FALSE(AttrUtils::GetGraph(op_desc, "nonexistent", *(ComputeGraphPtr *)(nullptr)));
865+}
866+ 
867+TEST_F(UtestGeAttrValue, IncCov_GetAttrsStrAfterRidWithUncomputeAttrs) {
868+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
869+ op_desc->SetAttr("compute_attr", GeAttrValue::CreateFrom<int64_t>(100));
870+ op_desc->SetAttr("uncompute_attr", GeAttrValue::CreateFrom<int64_t>(200));
871+ std::set<std::string> un_compute = {"uncompute_attr"};
872+ std::string result = AttrUtils::GetAttrsStrAfterRid(op_desc, un_compute);
873+ EXPECT_TRUE(result.find("compute_attr") != std::string::npos);
874+ EXPECT_TRUE(result.find("uncompute_attr") == std::string::npos);
875+}
876+ 
877+TEST_F(UtestGeAttrValue, IncCov_GetAllAttrsStrEmptyMap) {
878+ OpDescPtr null_desc;
879+ EXPECT_EQ(AttrUtils::GetAllAttrsStr(
880+ static_cast<const std::map<std::string, AnyValue> &>(std::map<std::string, AnyValue>{})),
881+ "");
882+}
859} // namespace ge883} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ge_ir_utils_inc_cov2_unittest.cc+104-0
@@ -1098,4 +1098,108 @@ TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpOutDesc_OriginDtype) {
1098 SUCCEED();1098 SUCCEED();
1099}1099}
1100 1100 
1101+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProto_NullNodeProto) {
1102+ OnnxUtils::AddAttrProto(nullptr, onnx::AttributeProto_AttributeType_INT, "test", nullptr);
1103+ SUCCEED();
1104+}
1105+ 
1106+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProtoFromAttribute_NullNodeProto) {
1107+ std::pair<const std::string, ge::GeAttrValue> attr_pair("test", GeAttrValue());
1108+ OnnxUtils::AddAttrProtoFromAttribute(attr_pair, nullptr);
1109+ SUCCEED();
1110+}
1111+ 
1112+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeValueInfo_NullProto) {
1113+ auto graph = std::make_shared<ComputeGraph>("test_vi_null");
1114+ auto node = CreateNodeIncCov2Helper(graph, "vi_node", "Relu", 1, 1);
1115+ OnnxUtils::EncodeValueInfo(node, nullptr);
1116+ SUCCEED();
1117+}
1118+ 
1119+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeDataType_Unsupported) {
1120+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_UNDEFINED), onnx::TensorProto_DataType_UNDEFINED);
1121+}
1122+ 
1123+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInDesc_NullTensorDesc) {
1124+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_null_td", "TestOp");
1125+ onnx::AttributeProto attr_proto;
1126+ attr_proto.set_name("input_desc_dtype:0");
1127+ OnnxUtils::DecodeNodeAttributeForOpInDesc(attr_proto, "input_desc_dtype", 0, op_desc);
1128+ SUCCEED();
1129+}
1130+ 
1131+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpOutDesc_NullTensorDesc) {
1132+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_null_td_out", "TestOp");
1133+ onnx::AttributeProto attr_proto;
1134+ attr_proto.set_name("output_desc_dtype:0");
1135+ OnnxUtils::DecodeNodeAttributeForOpOutDesc(attr_proto, "output_desc_dtype", 0, op_desc);
1136+ SUCCEED();
1137+}
1138+ 
1139+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInDesc_Unknown) {
1140+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_in_unknown", "TestOp");
1141+ op_desc->AddInputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1142+ onnx::AttributeProto attr_proto;
1143+ attr_proto.set_name("input_desc_unknown:0");
1144+ OnnxUtils::DecodeNodeAttributeForOpInDesc(attr_proto, "input_desc_unknown", 0, op_desc);
1145+ SUCCEED();
1146+}
1147+ 
1148+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpOutDesc_Unknown) {
1149+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_out_unknown", "TestOp");
1150+ op_desc->AddOutputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1151+ onnx::AttributeProto attr_proto;
1152+ attr_proto.set_name("output_desc_unknown:0");
1153+ OnnxUtils::DecodeNodeAttributeForOpOutDesc(attr_proto, "output_desc_unknown", 0, op_desc);
1154+ SUCCEED();
1155+}
1156+ 
1157+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeTypeProtoTensorType_NullOpDesc) {
1158+ auto graph = std::make_shared<ComputeGraph>("test_tpt_null_opdesc");
1159+ OpDescPtr op_desc = std::make_shared<OpDesc>("null_opdesc_node", "Relu");
1160+ auto node = graph->AddNode(op_desc);
1161+ onnx::TypeProto_Tensor tensor_type;
1162+ OnnxUtils::EncodeTypeProtoTensorType(node, &tensor_type);
1163+ SUCCEED();
1164+}
1165+ 
1166+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProtoFromNodeMembers_NullNode) {
1167+ onnx::NodeProto node_proto;
1168+ OnnxUtils::AddAttrProtoFromNodeMembers(nullptr, &node_proto);
1169+ SUCCEED();
1170+}
1171+ 
1172+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeNode_WithControlEdge) {
1173+ auto graph = std::make_shared<ComputeGraph>("test_ctrl_edge");
1174+ auto node1 = CreateNodeIncCov2Helper(graph, "ctrl_src", "Relu", 0, 1);
1175+ auto node2 = CreateNodeIncCov2Helper(graph, "ctrl_dst", "Relu", 1, 1);
1176+ GraphUtils::AddEdge(node1->GetOutControlAnchor(), node2->GetInControlAnchor());
1177+ onnx::NodeProto node_proto;
1178+ EXPECT_TRUE(OnnxUtils::EncodeNode(node2, &node_proto));
1179+}
1180+ 
1181+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeNode_WithOutDescOnly) {
1182+ auto graph = std::make_shared<ComputeGraph>("test_out_only");
1183+ auto node = CreateNodeIncCov2Helper(graph, "out_only_node", "Relu", 0, 1);
1184+ onnx::NodeProto node_proto;
1185+ EXPECT_TRUE(OnnxUtils::EncodeNode(node, &node_proto));
1186+}
1187+ 
1188+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeNode_WithMultipleInputsOutputs) {
1189+ auto graph = std::make_shared<ComputeGraph>("test_multi_io");
1190+ auto node = CreateNodeIncCov2Helper(graph, "multi_io_node", "Relu", 3, 2);
1191+ onnx::NodeProto node_proto;
1192+ EXPECT_TRUE(OnnxUtils::EncodeNode(node, &node_proto));
1193+}
1194+ 
1195+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeGraph_Success) {
1196+ auto graph = std::make_shared<ComputeGraph>("test_encode_graph");
1197+ auto data = CreateNodeIncCov2Helper(graph, "data", "Data", 0, 1);
1198+ auto relu = CreateNodeIncCov2Helper(graph, "relu", "Relu", 1, 1);
1199+ auto netoutput = CreateNodeIncCov2Helper(graph, "netoutput", "NetOutput", 1, 0);
1200+ GraphUtils::AddEdge(data->GetOutDataAnchor(0), relu->GetInDataAnchor(0));
1201+ GraphUtils::AddEdge(relu->GetOutDataAnchor(0), netoutput->GetInDataAnchor(0));
1202+ onnx::GraphProto graph_proto;
1203+ EXPECT_TRUE(OnnxUtils::EncodeGraph(graph, &graph_proto));
1204+}
1101} // namespace ge1205} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ge_tensor_unittest.cc+21-0
@@ -1029,3 +1029,24 @@ TEST_F(UtestGeTensor, IncCov_GeTensorMisc2) {
1029 TensorData &mutable_data = tensor.MutableData();1029 TensorData &mutable_data = tensor.MutableData();
1030 (void)mutable_data;1030 (void)mutable_data;
1031}1031}
1032+ 
1033+TEST_F(UtestGeTensor, IncCov_GeTensorAsProto_WithProtoOwner) {
1034+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
1035+ GeTensor tensor(desc);
1036+ proto::TensorDef tensor_def;
1037+ GeTensorSerializeUtils::GeTensorAsProto(tensor, &tensor_def);
1038+ EXPECT_TRUE(tensor_def.has_desc());
1039+}
1040+ 
1041+TEST_F(UtestGeTensor, IncCov_GetOriginFormatFromDescProto_NullProto) {
1042+ Format format = FORMAT_NCHW;
1043+ GeTensorSerializeUtils::GetOriginFormatFromDescProto(nullptr, format);
1044+ EXPECT_EQ(format, FORMAT_NCHW);
1045+}
1046+ 
1047+TEST_F(UtestGeTensor, IncCov_GeTensorDescImpl_SetShape) {
1048+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
1049+ GeShape new_shape({3, 4});
1050+ desc.SetShape(new_shape);
1051+ EXPECT_EQ(desc.GetShape().GetDims(), std::vector<int64_t>({3, 4}));
1052+}
Mtests/graph_metadef/ut/graph/testcase/gnode_unittest.cc+55-0
@@ -1212,4 +1212,59 @@ TEST_F(GNodeTest, IncCov_GNodeGetInputConstDataConstNoValue) {
1212 Tensor data;1212 Tensor data;
1213 EXPECT_EQ(gnode.GetInputConstData(0, data), GRAPH_FAILED);1213 EXPECT_EQ(gnode.GetInputConstData(0, data), GRAPH_FAILED);
1214}1214}
1215+ 
1216+TEST_F(GNodeTest, IncCov_GetALLSubgraphs_NullImpl) {
1217+ GNode gnode;
1218+ gnode.impl_ = nullptr;
1219+ std::vector<GraphPtr> subgraphs;
1220+ EXPECT_EQ(gnode.GetALLSubgraphs(subgraphs), GRAPH_FAILED);
1221+}
1222+ 
1223+TEST_F(GNodeTest, IncCov_GetALLSubgraphs_ExpiredNodePtr) {
1224+ GNode gnode;
1225+ std::vector<GraphPtr> subgraphs;
1226+ EXPECT_EQ(gnode.GetALLSubgraphs(subgraphs), GRAPH_FAILED);
1227+}
1228+ 
1229+TEST_F(GNodeTest, IncCov_GetSubgraph_InvalidIndex) {
1230+ auto builder = ut::GraphBuilder("graph");
1231+ const auto node = builder.AddNode("node", "node", 0, 0);
1232+ GNode gnode = NodeAdapter::Node2GNode(node);
1233+ GraphPtr graph;
1234+ EXPECT_EQ(gnode.GetSubgraph(99, graph), GRAPH_FAILED);
1235+}
1236+ 
1237+TEST_F(GNodeTest, IncCov_GNodeGetType_NullImpl) {
1238+ GNode gnode;
1239+ gnode.impl_ = nullptr;
1240+ AscendString type;
1241+ EXPECT_EQ(gnode.GetType(type), GRAPH_FAILED);
1242+}
1243+ 
1244+TEST_F(GNodeTest, IncCov_GNodeGetName_NullImpl) {
1245+ GNode gnode;
1246+ gnode.impl_ = nullptr;
1247+ AscendString name;
1248+ EXPECT_EQ(gnode.GetName(name), GRAPH_FAILED);
1249+}
1250+ 
1251+TEST_F(GNodeTest, IncCov_Node2GNodePtr_Success) {
1252+ auto builder = ut::GraphBuilder("graph");
1253+ const auto node = builder.AddNode("node", "node", 0, 0);
1254+ GNodePtr gnode_ptr = NodeAdapter::Node2GNodePtr(node);
1255+ EXPECT_NE(gnode_ptr, nullptr);
1256+}
1257+ 
1258+TEST_F(GNodeTest, IncCov_Node2GNode_NullNode) {
1259+ NodePtr null_node;
1260+ GNode gnode = NodeAdapter::Node2GNode(null_node);
1261+ AscendString name;
1262+ EXPECT_EQ(gnode.GetName(name), GRAPH_FAILED);
1263+}
1264+ 
1265+TEST_F(GNodeTest, IncCov_Node2GNodePtr_NullNode) {
1266+ NodePtr null_node;
1267+ GNodePtr gnode_ptr = NodeAdapter::Node2GNodePtr(null_node);
1268+ EXPECT_EQ(gnode_ptr, nullptr);
1269+}
1215} // namespace ge1270} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/graph_unittest.cc+41-0
@@ -2610,3 +2610,44 @@ TEST_F(UtestGraph, IncCov_CreateGraphFromOperatorWithStableTopo) {
2610 Graph graph("test_stable");2610 Graph graph("test_stable");
2611 EXPECT_EQ(GraphUtilsEx::CreateGraphFromOperatorWithStableTopo(graph, {op1}), SUCCESS);2611 EXPECT_EQ(GraphUtilsEx::CreateGraphFromOperatorWithStableTopo(graph, {op1}), SUCCESS);
2612}2612}
2613+ 
2614+TEST_F(UtestGraph, IncCov_SetOutputs_EmptyVector) {
2615+ auto cgp = BuildComputeGraphWithNetOutput();
2616+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2617+ std::vector<std::pair<Operator, AscendString>> empty_outputs;
2618+ graph.SetOutputs(empty_outputs);
2619+}
2620+ 
2621+TEST_F(UtestGraph, IncCov_SetOutputs_EmptyIndexVector) {
2622+ auto cgp = BuildComputeGraphWithNetOutput();
2623+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2624+ auto node = cgp->FindNode("Transdata1");
2625+ auto op = OpDescUtils::CreateOperatorFromNode(node);
2626+ std::vector<std::pair<Operator, std::vector<size_t>>> output_indexs;
2627+ output_indexs.emplace_back(op, std::vector<size_t>{});
2628+ graph.SetOutputs(output_indexs);
2629+}
2630+ 
2631+TEST_F(UtestGraph, IncCov_SetOutputs_OutputIndexOutOfRange) {
2632+ auto cgp = BuildComputeGraphWithNetOutput();
2633+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2634+ auto node = cgp->FindNode("Transdata1");
2635+ auto op = OpDescUtils::CreateOperatorFromNode(node);
2636+ std::vector<std::pair<Operator, std::vector<size_t>>> output_indexs;
2637+ output_indexs.emplace_back(op, std::vector<size_t>{999});
2638+ graph.SetOutputs(output_indexs);
2639+}
2640+ 
2641+TEST_F(UtestGraph, IncCov_SetOutputs_InvalidGraph) {
2642+ Graph graph("invalid_graph");
2643+ std::vector<std::pair<Operator, AscendString>> outputs;
2644+ Operator op("test_op");
2645+ AscendString name("test");
2646+ outputs.emplace_back(op, name);
2647+ graph.SetOutputs(outputs);
2648+}
2649+ 
2650+TEST_F(UtestGraph, IncCov_SetNeedIteration_InvalidGraph) {
2651+ Graph graph("invalid_graph");
2652+ graph.SetNeedIteration(true);
2653+}
Mtests/graph_metadef/ut/graph/testcase/graph_utils_unittest.cc+510-0
@@ -5981,4 +5981,514 @@ TEST_F(UtestGraphUtils, CovRemoveNodeWithoutRelinkNotInGraph) {
5981 auto graph2 = builder2.GetGraph();5981 auto graph2 = builder2.GetGraph();
5982 EXPECT_EQ(GraphUtils::RemoveNodeWithoutRelink(graph2, node), GRAPH_FAILED);5982 EXPECT_EQ(GraphUtils::RemoveNodeWithoutRelink(graph2, node), GRAPH_FAILED);
5983}5983}
5984+ 
5985+TEST_F(UtestGraphUtils, CovIsolateNodeNullNode) {
5986+ NodePtr null_node = nullptr;
5987+ std::vector<int32_t> io_map = {};
5988+ EXPECT_NE(GraphUtils::IsolateNode(null_node, io_map), GRAPH_SUCCESS);
5989+}
5990+ 
5991+TEST_F(UtestGraphUtils, CovRemoveNodeWithoutRelinkNullGraph) {
5992+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5993+ auto node = builder.AddNode("node", "Relu", 1, 1);
5994+ EXPECT_NE(GraphUtils::RemoveNodeWithoutRelink(nullptr, node), GRAPH_SUCCESS);
5995+}
5996+ 
5997+TEST_F(UtestGraphUtils, CovInsertNodeBeforeNullDst) {
5998+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5999+ auto insert_node = builder.AddNode("insert", "Relu", 1, 1);
6000+ InDataAnchorPtr null_dst = nullptr;
6001+ EXPECT_NE(GraphUtils::InsertNodeBefore(null_dst, insert_node, 0, 0), GRAPH_SUCCESS);
6002+}
6003+ 
6004+TEST_F(UtestGraphUtils, CovInsertNodeBeforeNullInsertNode) {
6005+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
6006+ auto dst_node = builder.AddNode("dst", "AddN", 1, 1);
6007+ NodePtr null_insert = nullptr;
6008+ EXPECT_NE(GraphUtils::InsertNodeBefore(dst_node->GetInDataAnchor(0), null_insert, 0, 0), GRAPH_SUCCESS);
6009+}
6010+ 
6011+TEST_F(UtestGraphUtils, CovDumpGEGraphToOnnxBasicGraph) {
6012+ ut::GraphBuilder builder = ut::GraphBuilder("dump_graph");
6013+ auto data = builder.AddNode("data", DATA, 0, 1);
6014+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
6015+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
6016+ builder.AddDataEdge(data, 0, relu, 0);
6017+ builder.AddDataEdge(relu, 0, netoutput, 0);
6018+ auto graph = builder.GetGraph();
6019+ GraphUtils::DumpGEGraphToOnnx(*graph, "test_dump");
6020+ SUCCEED();
6021+}
6022+ 
6023+TEST_F(UtestGraphUtils, CovIsolateNodeOneIO) {
6024+ ut::GraphBuilder builder = ut::GraphBuilder("isolate_graph");
6025+ auto data = builder.AddNode("data", DATA, 0, 1);
6026+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
6027+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
6028+ builder.AddDataEdge(data, 0, relu, 0);
6029+ builder.AddDataEdge(relu, 0, netoutput, 0);
6030+ auto graph = builder.GetGraph();
6031+ EXPECT_EQ(GraphUtils::IsolateNodeOneIO(relu), GRAPH_SUCCESS);
6032+}
6033+ 
6034+TEST_F(UtestGraphUtils, CovIsolateNodeWithIoMap) {
6035+ ut::GraphBuilder builder = ut::GraphBuilder("isolate_iomap");
6036+ auto data = builder.AddNode("data", DATA, 0, 1);
6037+ auto cast = builder.AddNode("cast", "Cast", 1, 1);
6038+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
6039+ builder.AddDataEdge(data, 0, cast, 0);
6040+ builder.AddDataEdge(cast, 0, netoutput, 0);
6041+ auto graph = builder.GetGraph();
6042+ std::vector<int32_t> io_map = {0};
6043+ EXPECT_EQ(GraphUtils::IsolateNode(cast, io_map), GRAPH_SUCCESS);
6044+}
6045+ 
6046+TEST_F(UtestGraphUtils, CovReplaceNodeAnchorsNullNewNode) {
6047+ ut::GraphBuilder builder = ut::GraphBuilder("replace_null");
6048+ auto old_node = builder.AddNode("old", "Cast", 1, 1);
6049+ NodePtr null_new_node = nullptr;
6050+ EXPECT_NE(GraphUtils::ReplaceNodeAnchors(null_new_node, old_node, {0}, {0}), GRAPH_SUCCESS);
6051+}
6052+ 
6053+TEST_F(UtestGraphUtils, CovReplaceNodeAnchorsNullOldNode) {
6054+ ut::GraphBuilder builder = ut::GraphBuilder("replace_null_old");
6055+ auto new_node = builder.AddNode("new", "Relu", 1, 1);
6056+ NodePtr null_old_node = nullptr;
6057+ EXPECT_NE(GraphUtils::ReplaceNodeAnchors(new_node, null_old_node, {0}, {0}), GRAPH_SUCCESS);
6058+}
6059+ 
6060+TEST_F(UtestGraphUtils, CovAddEdgeNullSrc) {
6061+ ut::GraphBuilder builder = ut::GraphBuilder("add_edge_null");
6062+ auto dst = builder.AddNode("dst", "AddN", 1, 1);
6063+ OutDataAnchorPtr null_src = nullptr;
6064+ EXPECT_NE(GraphUtils::AddEdge(null_src, dst->GetInDataAnchor(0)), GRAPH_SUCCESS);
6065+}
6066+ 
6067+TEST_F(UtestGraphUtils, CovAddEdgeNullDst) {
6068+ ut::GraphBuilder builder = ut::GraphBuilder("add_edge_null_dst");
6069+ auto src = builder.AddNode("src", DATA, 0, 1);
6070+ InDataAnchorPtr null_dst = nullptr;
6071+ EXPECT_NE(GraphUtils::AddEdge(src->GetOutDataAnchor(0), null_dst), GRAPH_SUCCESS);
6072+}
6073+ 
6074+TEST_F(UtestGraphUtils, CovRemoveEdgeNullSrc) {
6075+ ut::GraphBuilder builder = ut::GraphBuilder("rm_edge_null");
6076+ auto dst = builder.AddNode("dst", "AddN", 1, 1);
6077+ OutDataAnchorPtr null_src = nullptr;
6078+ EXPECT_NE(GraphUtils::RemoveEdge(null_src, dst->GetInDataAnchor(0)), GRAPH_SUCCESS);
6079+}
6080+ 
6081+TEST_F(UtestGraphUtils, CovRecordOriginalNamesNullOpdesc) {
6082+ ut::GraphBuilder builder = ut::GraphBuilder("record_names");
6083+ auto node = builder.AddNode("node1", "Relu", 1, 1);
6084+ auto target = builder.AddNode("target", "Cast", 1, 1);
6085+ NodePtr null_opdesc_node = std::make_shared<Node>(nullptr, nullptr);
6086+ std::vector<ge::NodePtr> original_nodes = {null_opdesc_node};
6087+ GraphUtils::RecordOriginalNames(original_nodes, target);
6088+ EXPECT_NE(target, nullptr);
6089+}
6090+ 
6091+TEST_F(UtestGraphUtils, CovRecordOriginalNamesWithDumpAttr) {
6092+ ut::GraphBuilder builder = ut::GraphBuilder("record_dump");
6093+ auto node1 = builder.AddNode("n1", "Relu", 1, 1);
6094+ auto node2 = builder.AddNode("n2", "Cast", 1, 1);
6095+ auto target = builder.AddNode("target", "Add", 1, 1);
6096+ (void)ge::AttrUtils::SetListStr(node1->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, {"orig1", "orig2"});
6097+ (void)ge::AttrUtils::SetListStr(node1->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_TYPES, {"type1"});
6098+ std::vector<ge::NodePtr> original_nodes = {node1, node2};
6099+ GraphUtils::RecordOriginalNames(original_nodes, target);
6100+ std::vector<std::string> result;
6101+ (void)ge::AttrUtils::GetListStr(target->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, result);
6102+ EXPECT_GE(result.size(), 1U);
6103+}
6104+ 
6105+TEST_F(UtestGraphUtils, CovRecordOriginalNamesByStr) {
6106+ ut::GraphBuilder builder = ut::GraphBuilder("record_str");
6107+ auto target = builder.AddNode("target", "Add", 1, 1);
6108+ std::vector<std::string> names = {"name1", "name2"};
6109+ GraphUtils::RecordOriginalNames(names, target);
6110+ std::vector<std::string> result;
6111+ (void)ge::AttrUtils::GetListStr(target->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, result);
6112+ EXPECT_EQ(result.size(), 2U);
6113+}
6114+ 
6115+TEST_F(UtestGraphUtils, CovRecordOriginalNamesByStrEmpty) {
6116+ ut::GraphBuilder builder = ut::GraphBuilder("record_str_empty");
6117+ auto target = builder.AddNode("target", "Add", 1, 1);
6118+ std::vector<std::string> names;
6119+ GraphUtils::RecordOriginalNames(names, target);
6120+ EXPECT_NE(target, nullptr);
6121+}
6122+ 
6123+TEST_F(UtestGraphUtils, CovRemoveNodesByTypeWithOutputNode) {
6124+ ut::GraphBuilder builder = ut::GraphBuilder("rm_type_out");
6125+ auto data = builder.AddNode("data1", DATA, 0, 1);
6126+ auto add = builder.AddNode("add1", "Add", 1, 1);
6127+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
6128+ builder.AddDataEdge(data, 0, add, 0);
6129+ builder.AddDataEdge(add, 0, netoutput, 0);
6130+ auto graph = builder.GetGraph();
6131+ EXPECT_EQ(GraphUtils::RemoveNodesByTypeWithoutRelink(graph, "Add"), GRAPH_SUCCESS);
6132+}
6133+ 
6134+TEST_F(UtestGraphUtils, CovRemoveNodesWithoutRelinkNotAllFound) {
6135+ ut::GraphBuilder builder = ut::GraphBuilder("rm_not_all");
6136+ auto data = builder.AddNode("data1", DATA, 0, 1);
6137+ auto add = builder.AddNode("add1", "Add", 1, 1);
6138+ builder.AddDataEdge(data, 0, add, 0);
6139+ auto graph = builder.GetGraph();
6140+ auto external_node = std::make_shared<ComputeGraph>("external");
6141+ auto ext_op = std::make_shared<OpDesc>("ext", "Cast");
6142+ ext_op->AddInputDesc(GeTensorDesc());
6143+ ext_op->AddOutputDesc(GeTensorDesc());
6144+ auto ext_node = external_node->AddNode(ext_op);
6145+ std::unordered_set<NodePtr> nodes = {add, ext_node};
6146+ EXPECT_EQ(GraphUtils::RemoveNodesWithoutRelink(graph, nodes), GRAPH_SUCCESS);
6147+}
6148+ 
6149+TEST_F(UtestGraphUtils, CovInsertNodeAfterDiffGraph) {
6150+ ut::GraphBuilder builder1 = ut::GraphBuilder("g1");
6151+ auto src = builder1.AddNode("src", DATA, 0, 1);
6152+ auto graph1 = builder1.GetGraph();
6153+ ut::GraphBuilder builder2 = ut::GraphBuilder("g2");
6154+ auto dst = builder2.AddNode("dst", "Add", 1, 1);
6155+ auto graph2 = builder2.GetGraph();
6156+ auto insert_op = std::make_shared<OpDesc>("insert", "Cast");
6157+ insert_op->AddInputDesc(GeTensorDesc());
6158+ insert_op->AddOutputDesc(GeTensorDesc());
6159+ std::vector<InDataAnchorPtr> dsts = {dst->GetInDataAnchor(0)};
6160+ EXPECT_EQ(GraphUtils::InsertNodeAfter(src->GetOutDataAnchor(0), dsts, insert_op, 0, 0), nullptr);
6161+}
6162+ 
6163+TEST_F(UtestGraphUtils, CovDumpGEGrphMaxFileNum) {
6164+ ut::GraphBuilder builder = ut::GraphBuilder("dump_max");
6165+ auto data = builder.AddNode("data1", DATA, 0, 1);
6166+ auto graph = builder.GetGraph();
6167+ (void)setenv("GE_MAX_DUMP_FILE_NUM", "1", 1);
6168+ GraphUtils::DumpGEGrph(graph, "./", "test");
6169+ unsetenv("GE_MAX_DUMP_FILE_NUM");
6170+}
6171+ 
6172+TEST_F(UtestGraphUtils, CovNoNeedDumpGraphBySuffixLevel1) {
6173+ (void)setenv("DUMP_GRAPH_LEVEL", "1", 1);
6174+ EXPECT_FALSE(GraphUtils::NoNeedDumpGraphBySuffix("optimize"));
6175+ EXPECT_TRUE(GraphUtils::NoNeedDumpGraphBySuffix("123"));
6176+ unsetenv("DUMP_GRAPH_LEVEL");
6177+}
6178+ 
6179+TEST_F(UtestGraphUtils, CovNoNeedDumpGraphBySuffixLevel3) {
6180+ (void)setenv("DUMP_GRAPH_LEVEL", "3", 1);
6181+ EXPECT_FALSE(GraphUtils::NoNeedDumpGraphBySuffix("Build"));
6182+ EXPECT_TRUE(GraphUtils::NoNeedDumpGraphBySuffix("other"));
6183+ unsetenv("DUMP_GRAPH_LEVEL");
6184+}
6185+ 
6186+TEST_F(UtestGraphUtils, CovNoNeedDumpGraphBySuffixLevel4) {
6187+ (void)setenv("DUMP_GRAPH_LEVEL", "4", 1);
6188+ EXPECT_FALSE(GraphUtils::NoNeedDumpGraphBySuffix("PreRunBegin"));
6189+ EXPECT_TRUE(GraphUtils::NoNeedDumpGraphBySuffix("other"));
6190+ unsetenv("DUMP_GRAPH_LEVEL");
6191+}
6192+ 
6193+TEST_F(UtestGraphUtils, CovNoNeedDumpGraphBySuffixKeyName) {
6194+ (void)setenv("DUMP_GRAPH_LEVEL", "keyword1|keyword2", 1);
6195+ EXPECT_FALSE(GraphUtils::NoNeedDumpGraphBySuffix("my_keyword1_test"));
6196+ EXPECT_TRUE(GraphUtils::NoNeedDumpGraphBySuffix("no_match"));
6197+ unsetenv("DUMP_GRAPH_LEVEL");
6198+}
6199+ 
6200+TEST_F(UtestGraphUtils, CovIsolateNodeSelfCycle) {
6201+ ut::GraphBuilder builder = ut::GraphBuilder("self_cycle");
6202+ auto in = builder.AddNode("in", DATA, 0, 1);
6203+ auto mid = builder.AddNode("mid", "Add", 2, 1);
6204+ auto out = builder.AddNode("out", NETOUTPUT, 1, 0);
6205+ builder.AddDataEdge(in, 0, mid, 0);
6206+ builder.AddDataEdge(in, 0, mid, 1);
6207+ builder.AddDataEdge(mid, 0, out, 0);
6208+ auto graph = builder.GetGraph();
6209+ (void)GraphUtils::AddEdge(mid->GetOutControlAnchor(), mid->GetInControlAnchor());
6210+ EXPECT_EQ(GraphUtils::IsolateNode(mid, {0}), GRAPH_SUCCESS);
6211+}
6212+ 
6213+TEST_F(UtestGraphUtils, CovMoveInCtrlEdgesNullParams) {
6214+ EXPECT_EQ(GraphUtils::MoveInCtrlEdges(nullptr, nullptr), GRAPH_FAILED);
6215+}
6216+ 
6217+TEST_F(UtestGraphUtils, CovMoveOutCtrlEdgesNullParams) {
6218+ NodePtr null_src = nullptr;
6219+ NodePtr null_dst = nullptr;
6220+ EXPECT_EQ(GraphUtils::MoveOutCtrlEdges(null_src, null_dst), GRAPH_FAILED);
6221+}
6222+ 
6223+TEST_F(UtestGraphUtils, CovConvertInDataEdgesNullParams) {
6224+ EXPECT_EQ(GraphUtils::ConvertInDataEdgesToInCtrlEdges(nullptr, nullptr, nullptr), GRAPH_PARAM_INVALID);
6225+}
6226+ 
6227+TEST_F(UtestGraphUtils, CovConvertOutDataEdgesNullParams) {
6228+ EXPECT_EQ(GraphUtils::ConvertOutDataEdgesToOutCtrlEdges(nullptr, nullptr, nullptr), GRAPH_PARAM_INVALID);
6229+}
6230+ 
6231+TEST_F(UtestGraphUtils, CovCopyInCtrlEdgesNullParams) {
6232+ EXPECT_EQ(GraphUtils::CopyInCtrlEdges(nullptr, nullptr, nullptr), GRAPH_PARAM_INVALID);
6233+}
6234+ 
6235+TEST_F(UtestGraphUtils, CovCopyOutCtrlEdgesNullParams) {
6236+ EXPECT_EQ(GraphUtils::CopyOutCtrlEdges(nullptr, nullptr, nullptr), GRAPH_FAILED);
6237+}
6238+ 
6239+TEST_F(UtestGraphUtils, CovReplaceNodesDataAnchorsEmpty) {
6240+ std::vector<NodePtr> new_nodes;
6241+ std::vector<NodePtr> old_nodes;
6242+ EXPECT_NE(GraphUtils::ReplaceNodesDataAnchors(new_nodes, old_nodes, {}, {}), GRAPH_SUCCESS);
6243+}
6244+ 
6245+TEST_F(UtestGraphUtils, CovCopyComputeGraphNotRoot) {
6246+ auto root = std::make_shared<ComputeGraph>("root");
6247+ auto sub = std::make_shared<ComputeGraph>("sub");
6248+ sub->SetParentGraph(root);
6249+ ComputeGraphPtr dst;
6250+ EXPECT_EQ(GraphUtils::CopyComputeGraph(sub, nullptr, nullptr, nullptr, dst), GRAPH_FAILED);
6251+}
6252+ 
6253+TEST_F(UtestGraphUtils, CovIsSingleOpScene) {
6254+ ut::GraphBuilder builder = ut::GraphBuilder("single_op");
6255+ auto data = builder.AddNode("data1", DATA, 0, 1);
6256+ auto graph = builder.GetGraph();
6257+ EXPECT_FALSE(GraphUtils::IsSingleOpScene(graph));
6258+ (void)AttrUtils::SetBool(graph, ATTR_SINGLE_OP_SCENE, true);
6259+ EXPECT_TRUE(GraphUtils::IsSingleOpScene(graph));
6260+}
6261+ 
6262+TEST_F(UtestGraphUtils, CovCreateCycleDetector) {
6263+ ut::GraphBuilder builder = ut::GraphBuilder("cycle_det");
6264+ auto data = builder.AddNode("data1", DATA, 0, 1);
6265+ auto graph = builder.GetGraph();
6266+ auto detector = GraphUtils::CreateCycleDetector(graph);
6267+ EXPECT_NE(detector, nullptr);
6268+}
6269+ 
6270+TEST_F(UtestGraphUtils, CovCreateSharedCycleDetector) {
6271+ ut::GraphBuilder builder = ut::GraphBuilder("shared_cycle_det");
6272+ auto data = builder.AddNode("data1", DATA, 0, 1);
6273+ auto graph = builder.GetGraph();
6274+ auto detector = GraphUtils::CreateSharedCycleDetector(graph);
6275+ EXPECT_NE(detector, nullptr);
6276+}
6277+ 
6278+TEST_F(UtestGraphUtils, CovIsolateNodeOneIOMultiInput) {
6279+ ut::GraphBuilder builder = ut::GraphBuilder("one_io_multi");
6280+ auto in1 = builder.AddNode("in1", DATA, 0, 1);
6281+ auto in2 = builder.AddNode("in2", DATA, 0, 1);
6282+ auto mid = builder.AddNode("mid", "Add", 2, 1);
6283+ auto out = builder.AddNode("out", NETOUTPUT, 1, 0);
6284+ builder.AddDataEdge(in1, 0, mid, 0);
6285+ builder.AddDataEdge(in2, 0, mid, 1);
6286+ builder.AddDataEdge(mid, 0, out, 0);
6287+ EXPECT_EQ(GraphUtils::IsolateNodeOneIO(mid), GRAPH_PARAM_INVALID);
6288+}
6289+ 
6290+TEST_F(UtestGraphUtils, CovIsolateNodeOneIOMultiOutput) {
6291+ ut::GraphBuilder builder = ut::GraphBuilder("one_io_multi_out");
6292+ auto in = builder.AddNode("in", DATA, 0, 1);
6293+ auto mid = builder.AddNode("mid", "Split", 1, 2);
6294+ auto out = builder.AddNode("out", NETOUTPUT, 1, 0);
6295+ builder.AddDataEdge(in, 0, mid, 0);
6296+ builder.AddDataEdge(mid, 0, out, 0);
6297+ EXPECT_EQ(GraphUtils::IsolateNodeOneIO(mid), GRAPH_PARAM_INVALID);
6298+}
6299+ 
6300+TEST_F(UtestGraphUtils, CovDumpGEGraphByPathEmptyName) {
6301+ ut::GraphBuilder builder = ut::GraphBuilder("dump_empty_name");
6302+ auto data = builder.AddNode("data1", DATA, 0, 1);
6303+ auto graph = builder.GetGraph();
6304+ EXPECT_NE(GraphUtils::DumpGEGraphByPath(graph, "./", 0), GRAPH_SUCCESS);
6305+}
6306+ 
6307+TEST_F(UtestGraphUtils, CovRemoveNodeWithoutRelinkNotInList) {
6308+ ut::GraphBuilder builder = ut::GraphBuilder("rm_not_in_list");
6309+ auto data = builder.AddNode("data1", DATA, 0, 1);
6310+ auto graph = builder.GetGraph();
6311+ auto external_graph = std::make_shared<ComputeGraph>("external");
6312+ auto ext_op = std::make_shared<OpDesc>("ext", "Cast");
6313+ ext_op->AddInputDesc(GeTensorDesc());
6314+ ext_op->AddOutputDesc(GeTensorDesc());
6315+ auto ext_node = external_graph->AddNode(ext_op);
6316+ EXPECT_EQ(GraphUtils::RemoveNodeWithoutRelink(graph, ext_node), GRAPH_FAILED);
6317+}
6318+ 
6319+TEST_F(UtestGraphUtils, CovInsertNodeBeforeDiffGraph) {
6320+ ut::GraphBuilder builder1 = ut::GraphBuilder("g1_ib");
6321+ auto src = builder1.AddNode("src", DATA, 0, 1);
6322+ auto graph1 = builder1.GetGraph();
6323+ ut::GraphBuilder builder2 = ut::GraphBuilder("g2_ib");
6324+ auto dst = builder2.AddNode("dst", "Add", 1, 1);
6325+ auto insert_op = std::make_shared<OpDesc>("insert", "Cast");
6326+ insert_op->AddInputDesc(GeTensorDesc());
6327+ insert_op->AddOutputDesc(GeTensorDesc());
6328+ auto insert_node = graph1->AddNode(insert_op);
6329+ EXPECT_EQ(GraphUtils::InsertNodeBefore(dst->GetInDataAnchor(0), insert_node, 0, 0), GRAPH_FAILED);
6330+}
6331+ 
6332+TEST_F(UtestGraphUtils, CovCopyInCtrlEdgesWithFilterBasic) {
6333+ ut::GraphBuilder builder = ut::GraphBuilder("copy_in_ctrl_filter");
6334+ auto src = builder.AddNode("src", DATA, 0, 1);
6335+ auto mid = builder.AddNode("mid", "Add", 1, 1);
6336+ auto dst = builder.AddNode("dst", NETOUTPUT, 1, 0);
6337+ builder.AddDataEdge(src, 0, mid, 0);
6338+ builder.AddDataEdge(mid, 0, dst, 0);
6339+ (void)GraphUtils::AddEdge(src->GetOutControlAnchor(), mid->GetInControlAnchor());
6340+ NodeFilter filter = [](const Node &node) { return true; };
6341+ EXPECT_EQ(GraphUtils::CopyInCtrlEdges(mid, dst, filter), GRAPH_SUCCESS);
6342+}
6343+ 
6344+TEST_F(UtestGraphUtils, CovCopyOutCtrlEdgesWithFilterBasic) {
6345+ ut::GraphBuilder builder = ut::GraphBuilder("copy_out_ctrl_filter");
6346+ auto src = builder.AddNode("src", DATA, 0, 1);
6347+ auto mid = builder.AddNode("mid", "Add", 1, 1);
6348+ auto dst = builder.AddNode("dst", NETOUTPUT, 1, 0);
6349+ builder.AddDataEdge(src, 0, mid, 0);
6350+ builder.AddDataEdge(mid, 0, dst, 0);
6351+ (void)GraphUtils::AddEdge(mid->GetOutControlAnchor(), dst->GetInControlAnchor());
6352+ NodeFilter filter = [](const Node &node) { return true; };
6353+ EXPECT_EQ(GraphUtils::CopyOutCtrlEdges(mid, src, filter), GRAPH_SUCCESS);
6354+}
6355+ 
6356+TEST_F(UtestGraphUtils, CovConvertInDataEdgesBasic) {
6357+ ut::GraphBuilder builder = ut::GraphBuilder("conv_in_data");
6358+ auto src = builder.AddNode("src", DATA, 0, 1);
6359+ auto mid = builder.AddNode("mid", "Add", 1, 1);
6360+ auto dst = builder.AddNode("dst", NETOUTPUT, 1, 0);
6361+ builder.AddDataEdge(src, 0, mid, 0);
6362+ builder.AddDataEdge(mid, 0, dst, 0);
6363+ NodeFilter filter = [](const Node &node) { return true; };
6364+ EXPECT_EQ(GraphUtils::ConvertInDataEdgesToInCtrlEdges(mid, dst, filter), GRAPH_SUCCESS);
6365+}
6366+ 
6367+TEST_F(UtestGraphUtils, CovConvertOutDataEdgesBasic) {
6368+ ut::GraphBuilder builder = ut::GraphBuilder("conv_out_data");
6369+ auto src = builder.AddNode("src", DATA, 0, 1);
6370+ auto mid = builder.AddNode("mid", "Add", 1, 1);
6371+ auto dst = builder.AddNode("dst", NETOUTPUT, 1, 0);
6372+ builder.AddDataEdge(src, 0, mid, 0);
6373+ builder.AddDataEdge(mid, 0, dst, 0);
6374+ NodeFilter filter = [](const Node &node) { return true; };
6375+ EXPECT_EQ(GraphUtils::ConvertOutDataEdgesToOutCtrlEdges(mid, src, filter), GRAPH_SUCCESS);
6376+}
6377+ 
6378+TEST_F(UtestGraphUtils, CovReplaceNodeDataAnchorsNullParams) {
6379+ EXPECT_EQ(GraphUtils::ReplaceNodeDataAnchors(nullptr, nullptr, {}, {}), GRAPH_PARAM_INVALID);
6380+}
6381+ 
6382+TEST_F(UtestGraphUtils, CovInheritExecutionOrderBasic) {
6383+ ut::GraphBuilder builder = ut::GraphBuilder("inherit_order");
6384+ auto data = builder.AddNode("data1", DATA, 0, 1);
6385+ auto old1 = builder.AddNode("old1", "Relu", 1, 1);
6386+ auto new1 = builder.AddNode("new1", "Cast", 1, 1);
6387+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
6388+ builder.AddDataEdge(data, 0, old1, 0);
6389+ builder.AddDataEdge(old1, 0, netoutput, 0);
6390+ auto graph = builder.GetGraph();
6391+ std::vector<NodePtr> new_nodes = {new1};
6392+ std::vector<NodePtr> old_nodes = {old1};
6393+ EXPECT_EQ(GraphUtils::InheritExecutionOrder(new_nodes, old_nodes, graph, false), SUCCESS);
6394+}
6395+ 
6396+TEST_F(UtestGraphUtils, CovRemoveNodesByTypePlaceholder) {
6397+ ut::GraphBuilder builder = ut::GraphBuilder("rm_placeholder");
6398+ auto data = builder.AddNode("data1", DATA, 0, 1);
6399+ auto ph = builder.AddNode("ph1", PLACEHOLDER, 0, 1);
6400+ auto end = builder.AddNode("end1", END, 1, 0);
6401+ auto graph = builder.GetGraph();
6402+ EXPECT_EQ(GraphUtils::RemoveNodesByTypeWithoutRelink(graph, PLACEHOLDER), GRAPH_SUCCESS);
6403+}
6404+ 
6405+TEST_F(UtestGraphUtils, CovDumpGEGraphToReadableNullGraph) {
6406+ ComputeGraphPtr null_graph = nullptr;
6407+ GraphUtils::DumpGEGraphToReadable(null_graph, "test_readable", false, "");
6408+}
6409+ 
6410+TEST_F(UtestGraphUtils, CovDumpGEGraphToOnnxByContentLevel) {
6411+ ComputeGraph compute_graph("test_onnx_level");
6412+ compute_graph.SetGraphID(0);
6413+ GraphUtils::DumpGEGraphToOnnxByContentLevel(compute_graph, "test_suffix", ge::DumpLevel::DUMP_ALL);
6414+}
6415+ 
6416+TEST_F(UtestGraphUtils, CovRemoveNodesByTypeEnd) {
6417+ ut::GraphBuilder builder = ut::GraphBuilder("rm_end");
6418+ auto data = builder.AddNode("data1", DATA, 0, 1);
6419+ auto end = builder.AddNode("end1", END, 1, 0);
6420+ auto graph = builder.GetGraph();
6421+ EXPECT_EQ(GraphUtils::RemoveNodesByTypeWithoutRelink(graph, END), GRAPH_SUCCESS);
6422+}
6423+ 
6424+TEST_F(UtestGraphUtils, CovIsolateNodeWithNoOpOptimize) {
6425+ ut::GraphBuilder builder = ut::GraphBuilder("noop_opt");
6426+ std::vector<NodePtr> in_nodes;
6427+ std::vector<NodePtr> out_nodes;
6428+ for (int i = 0; i < 5; ++i) {
6429+ in_nodes.push_back(builder.AddNode("in" + std::to_string(i), DATA, 0, 1));
6430+ }
6431+ auto mid = builder.AddNode("mid", "Add", 5, 5);
6432+ for (int i = 0; i < 5; ++i) {
6433+ out_nodes.push_back(builder.AddNode("out" + std::to_string(i), NETOUTPUT, 1, 0));
6434+ builder.AddDataEdge(in_nodes[i], 0, mid, i);
6435+ builder.AddDataEdge(mid, i, out_nodes[i], 0);
6436+ }
6437+ EXPECT_EQ(GraphUtils::IsolateNode(mid, {0, 1, 2, 3, 4}), GRAPH_SUCCESS);
6438+}
6439+ 
6440+TEST_F(UtestGraphUtils, CovCopyNodesInDataAnchors) {
6441+ ut::GraphBuilder builder = ut::GraphBuilder("copy_nodes_in");
6442+ auto data = builder.AddNode("data1", DATA, 0, 1);
6443+ auto old1 = builder.AddNode("old1", "Relu", 1, 1);
6444+ auto new1 = builder.AddNode("new1", "Cast", 1, 1);
6445+ builder.AddDataEdge(data, 0, old1, 0);
6446+ std::vector<NodePtr> new_nodes = {new1};
6447+ std::vector<NodePtr> old_nodes = {old1};
6448+ EXPECT_EQ(GraphUtils::CopyNodesInDataAnchors(new_nodes, old_nodes, {0}), GRAPH_SUCCESS);
6449+}
6450+ 
6451+TEST_F(UtestGraphUtils, CovReplaceNodesInDataAnchors) {
6452+ ut::GraphBuilder builder = ut::GraphBuilder("replace_nodes_in");
6453+ auto data = builder.AddNode("data1", DATA, 0, 1);
6454+ auto old1 = builder.AddNode("old1", "Relu", 1, 1);
6455+ auto new1 = builder.AddNode("new1", "Cast", 1, 1);
6456+ builder.AddDataEdge(data, 0, old1, 0);
6457+ std::vector<NodePtr> new_nodes = {new1};
6458+ std::vector<NodePtr> old_nodes = {old1};
6459+ EXPECT_EQ(GraphUtils::ReplaceNodesInDataAnchors(new_nodes, old_nodes, {0}), GRAPH_SUCCESS);
6460+}
6461+ 
6462+TEST_F(UtestGraphUtils, CovReplaceNodesOutDataAnchors) {
6463+ ut::GraphBuilder builder = ut::GraphBuilder("replace_nodes_out");
6464+ auto data = builder.AddNode("data1", DATA, 0, 1);
6465+ auto old1 = builder.AddNode("old1", "Relu", 1, 1);
6466+ auto new1 = builder.AddNode("new1", "Cast", 1, 1);
6467+ auto out = builder.AddNode("out", NETOUTPUT, 1, 0);
6468+ builder.AddDataEdge(data, 0, old1, 0);
6469+ builder.AddDataEdge(old1, 0, out, 0);
6470+ std::vector<NodePtr> new_nodes = {new1};
6471+ std::vector<NodePtr> old_nodes = {old1};
6472+ EXPECT_EQ(GraphUtils::ReplaceNodesOutDataAnchors(new_nodes, old_nodes, {0}), GRAPH_SUCCESS);
6473+}
6474+ 
6475+TEST_F(UtestGraphUtils, CovUnfoldGraphTooDeep) {
6476+ ut::GraphBuilder builder = ut::GraphBuilder("unfold_deep");
6477+ auto data = builder.AddNode("data1", DATA, 0, 1);
6478+ auto target = builder.AddNode("target", "Relu", 1, 1);
6479+ auto graph = builder.GetGraph();
6480+ auto target_graph = std::make_shared<ComputeGraph>("target_graph");
6481+ auto filter = [](const ComputeGraphPtr &) { return true; };
6482+ EXPECT_EQ(GraphUtils::UnfoldGraph(graph, target_graph, target, filter, 100), GRAPH_FAILED);
6483+}
6484+ 
6485+TEST_F(UtestGraphUtils, CovInheritOriginalAttr) {
6486+ auto src_graph = std::make_shared<ComputeGraph>("src_inherit");
6487+ auto dst_graph = std::make_shared<ComputeGraph>("dst_inherit");
6488+ (void)AttrUtils::SetStr(src_graph, "test_attr", "test_value");
6489+ GraphUtils::InheritOriginalAttr(src_graph, dst_graph);
6490+ std::string val;
6491+ (void)AttrUtils::GetStr(dst_graph, "test_attr", val);
6492+ EXPECT_EQ(val, "test_value");
6493+}
5984} // namespace ge6494} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/model_inc_cov_unittest.cc+15-0
@@ -369,4 +369,19 @@ TEST_F(ModelIncCovUt, IncCov2_LoadFromFile_InvalidProtobufContent) {
369 EXPECT_EQ(model.LoadFromFile(file_path), GRAPH_FAILED);369 EXPECT_EQ(model.LoadFromFile(file_path), GRAPH_FAILED);
370 system(("rm -f " + file_path).c_str());370 system(("rm -f " + file_path).c_str());
371}371}
372+ 
373+TEST_F(ModelIncCovUt, IncCov2_SaveToFile_InvalidDir) {
374+ auto graph = BuildTestGraph();
375+ Model model("test_model", "v1");
376+ model.SetGraph(GraphUtilsEx::GetComputeGraph(graph));
377+ EXPECT_EQ(model.SaveToFile("/nonexist_dir_xyz/sub/test.air", false), GRAPH_SUCCESS);
378+ system("rm -rf /nonexist_dir_xyz");
379+}
380+ 
381+TEST_F(ModelIncCovUt, IncCov2_SaveToFile_EmptyPath) {
382+ auto graph = BuildTestGraph();
383+ Model model("test_model", "v1");
384+ model.SetGraph(GraphUtilsEx::GetComputeGraph(graph));
385+ EXPECT_NE(model.SaveToFile("", false), GRAPH_SUCCESS);
386+}
372} // namespace ge387} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/node_utils_unittest.cc+70-0
@@ -12,6 +12,7 @@
12 12 
13#include "graph/utils/node_utils.h"13#include "graph/utils/node_utils.h"
14#include "graph/utils/node_utils_ex.h"14#include "graph/utils/node_utils_ex.h"
15+#include "graph/utils/graph_utils.h"
15#include "graph/normal_graph/node_impl.h"16#include "graph/normal_graph/node_impl.h"
16#include "graph/normal_graph/op_desc_impl.h"17#include "graph/normal_graph/op_desc_impl.h"
17#include "graph_builder_utils.h"18#include "graph_builder_utils.h"
@@ -1454,4 +1455,73 @@ TEST_F(UtestNodeUtils, CovGetParentInputAndAnchorNullGraph) {
1454 EXPECT_EQ(result.first, nullptr);1455 EXPECT_EQ(result.first, nullptr);
1455 EXPECT_EQ(result.second, nullptr);1456 EXPECT_EQ(result.second, nullptr);
1456}1457}
1458+ 
1459+TEST_F(UtestNodeUtils, IncCov_GetSubgraphOutputNodes) {
1460+ auto root_graph = std::make_shared<ComputeGraph>("root_graph");
1461+ auto if_op_desc = std::make_shared<OpDesc>("if", "If");
1462+ if_op_desc->AddInputDesc(GeTensorDesc());
1463+ if_op_desc->AddOutputDesc(GeTensorDesc());
1464+ if_op_desc->AddSubgraphName("sub1");
1465+ if_op_desc->SetSubgraphInstanceName(0, "sub1");
1466+ auto if_node = root_graph->AddNode(if_op_desc);
1467+ 
1468+ auto sub1 = std::make_shared<ComputeGraph>("sub1");
1469+ auto data_op = std::make_shared<OpDesc>("sub_data", "Data");
1470+ data_op->AddInputDesc(GeTensorDesc());
1471+ data_op->AddOutputDesc(GeTensorDesc());
1472+ AttrUtils::SetInt(data_op, ATTR_NAME_PARENT_NODE_INDEX, 0);
1473+ auto data_node = sub1->AddNode(data_op);
1474+ 
1475+ auto net_op = std::make_shared<OpDesc>("sub_netoutput", "NetOutput");
1476+ net_op->AddInputDesc(GeTensorDesc());
1477+ auto net_node = sub1->AddNode(net_op);
1478+ 
1479+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), net_node->GetInDataAnchor(0));
1480+ sub1->SetParentNode(if_node);
1481+ sub1->SetParentGraph(root_graph);
1482+ root_graph->AddSubgraph("sub1", sub1);
1483+ 
1484+ auto outputs = NodeUtils::GetSubgraphOutputNodes(*if_node);
1485+ EXPECT_FALSE(outputs.empty());
1486+}
1487+ 
1488+TEST_F(UtestNodeUtils, IncCov_IsNodeInRootGraph_Subgraph) {
1489+ auto root_graph = std::make_shared<ComputeGraph>("root_graph2");
1490+ auto if_op_desc = std::make_shared<OpDesc>("if2", "If");
1491+ if_op_desc->AddInputDesc(GeTensorDesc());
1492+ if_op_desc->AddOutputDesc(GeTensorDesc());
1493+ if_op_desc->AddSubgraphName("sub1");
1494+ if_op_desc->SetSubgraphInstanceName(0, "sub1");
1495+ auto if_node = root_graph->AddNode(if_op_desc);
1496+ 
1497+ auto sub1 = std::make_shared<ComputeGraph>("sub1_2");
1498+ auto data_op = std::make_shared<OpDesc>("sub_data2", "Data");
1499+ data_op->AddInputDesc(GeTensorDesc());
1500+ data_op->AddOutputDesc(GeTensorDesc());
1501+ auto data_node = sub1->AddNode(data_op);
1502+ 
1503+ sub1->SetParentNode(if_node);
1504+ sub1->SetParentGraph(root_graph);
1505+ root_graph->AddSubgraph("sub1", sub1);
1506+ 
1507+ EXPECT_EQ(NodeUtils::IsNodeInRootGraph(data_node), false);
1508+}
1509+ 
1510+TEST_F(UtestNodeUtils, IncCov_GetNodeType) {
1511+ ut::GraphBuilder builder = ut::GraphBuilder("graph_node_type");
1512+ auto node = builder.AddNode("node", "Relu", 1, 1);
1513+ EXPECT_EQ(NodeUtils::GetNodeType(*node), "Relu");
1514+}
1515+ 
1516+TEST_F(UtestNodeUtils, IncCov_GetOutControlNodes) {
1517+ ut::GraphBuilder builder = ut::GraphBuilder("graph_ctrl_out");
1518+ auto src = builder.AddNode("src", "Relu", 0, 0);
1519+ auto dst1 = builder.AddNode("dst1", "Relu", 0, 0);
1520+ auto dst2 = builder.AddNode("dst2", "Relu", 0, 0);
1521+ builder.AddControlEdge(src, dst1);
1522+ builder.AddControlEdge(src, dst2);
1523+ NodeFilter filter = [](const Node &n) { return true; };
1524+ auto result = NodeUtils::GetOutControlNodes(*src, filter);
1525+ EXPECT_EQ(result.size(), 2U);
1526+}
1457} // namespace ge1527} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/op_desc_utils_unittest.cc+51-0
@@ -2286,4 +2286,55 @@ TEST_F(UtestOpDescUtils, CovClearWeightsNullGraph) {
2286 auto ret = OpDescUtils::ClearWeights(node);2286 auto ret = OpDescUtils::ClearWeights(node);
2287 EXPECT_NE(ret, GRAPH_SUCCESS);2287 EXPECT_NE(ret, GRAPH_SUCCESS);
2288}2288}
2289+ 
2290+TEST_F(UtestOpDescUtils, IncCov_CreateOperatorFromNode) {
2291+ auto graph = BuildGraph1();
2292+ auto addn_node = graph->FindNode("addn");
2293+ auto op = OpDescUtils::CreateOperatorFromNode(addn_node);
2294+ EXPECT_FALSE(op.IsEmpty());
2295+}
2296+ 
2297+TEST_F(UtestOpDescUtils, IncCov_GetConstInputsEmpty) {
2298+ auto graph = BuildGraph1();
2299+ auto data_node = graph->FindNode("Data");
2300+ auto result = OpDescUtils::GetConstInputs(*data_node);
2301+ EXPECT_EQ(result.size(), 0U);
2302+}
2303+ 
2304+TEST_F(UtestOpDescUtils, IncCov_SetWeightsVectorEmpty) {
2305+ auto graph = BuildGraph1();
2306+ auto addn_node = graph->FindNode("addn");
2307+ std::vector<GeTensorPtr> weights;
2308+ auto ret = OpDescUtils::SetWeights(*addn_node, weights);
2309+ EXPECT_EQ(ret, GRAPH_PARAM_INVALID);
2310+}
2311+ 
2312+TEST_F(UtestOpDescUtils, IncCov_GetWeightsFromNode) {
2313+ auto graph = BuildGraph1();
2314+ auto const_node = graph->FindNode("const1");
2315+ auto weights = OpDescUtils::GetWeights(*const_node);
2316+ EXPECT_FALSE(weights.empty());
2317+}
2318+ 
2319+TEST_F(UtestOpDescUtils, IncCov_ClearWeightsSuccess) {
2320+ auto graph = BuildGraph1();
2321+ auto const_node = graph->FindNode("const1");
2322+ auto ret = OpDescUtils::ClearWeights(const_node);
2323+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2324+}
2325+ 
2326+TEST_F(UtestOpDescUtils, IncCov_SetWeightsNodeMapEmpty) {
2327+ auto graph = BuildGraph1();
2328+ auto addn_node = graph->FindNode("addn");
2329+ std::map<int, GeTensorPtr> weights_map;
2330+ auto ret = OpDescUtils::SetWeights(*addn_node, weights_map);
2331+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2332+}
2333+ 
2334+TEST_F(UtestOpDescUtils, IncCov_GetConstInputsExceedSize) {
2335+ auto graph = BuildGraph1();
2336+ auto addn_node = graph->FindNode("addn");
2337+ auto result = OpDescUtils::GetConstInputs(*addn_node, 10U);
2338+ EXPECT_EQ(result.size(), 1U);
2339+}
2289} // namespace ge2340} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/operator_unittest.cc+35-0
@@ -3470,4 +3470,39 @@ TEST_F(UtestOperater, CovOpVerifyAll) {
3470 EXPECT_EQ(op.VerifyAll(), GRAPH_FAILED);3470 EXPECT_EQ(op.VerifyAll(), GRAPH_FAILED);
3471}3471}
3472 3472 
3473+TEST_F(UtestOperater, IncCov_CreateOperatorFromNode_NullNode) {
3474+ ge::ConstNodePtr null_node;
3475+ ge::Operator op = OpDescUtils::CreateOperatorFromNode(null_node);
3476+ SUCCEED();
3477+}
3478+ 
3479+TEST_F(UtestOperater, IncCov_OperatorGetInputConstData_NullImpl) {
3480+ ge::Operator op("test_op21", "Test");
3481+ op.operator_impl_ = nullptr;
3482+ Tensor data;
3483+ EXPECT_NE(op.GetInputConstData("x", data), GRAPH_SUCCESS);
3484+ EXPECT_NE(op.GetInputConstData(0, data), GRAPH_SUCCESS);
3485+}
3486+ 
3487+TEST_F(UtestOperater, IncCov_OperatorSetAttr_NullImpl) {
3488+ ge::Operator op("test_op22", "Test");
3489+ op.operator_impl_ = nullptr;
3490+ op.SetAttr("attr", static_cast<int64_t>(42));
3491+ int64_t val = 0;
3492+ EXPECT_NE(op.GetAttr("attr", val), GRAPH_SUCCESS);
3493+}
3494+ 
3495+TEST_F(UtestOperater, IncCov_OperatorGetName_NullImpl) {
3496+ ge::Operator op("test_op23", "Test");
3497+ op.operator_impl_ = nullptr;
3498+ AscendString name;
3499+ EXPECT_EQ(op.GetName(name), GRAPH_SUCCESS);
3500+}
3501+ 
3502+TEST_F(UtestOperater, IncCov_OperatorGetType_NullImpl) {
3503+ ge::Operator op("test_op24", "Test");
3504+ op.operator_impl_ = nullptr;
3505+ AscendString type;
3506+ EXPECT_NE(op.GetOpType(type), GRAPH_SUCCESS);
3507+}
3473} // namespace ge3508} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/plugin_manager_inc_cov_unittest.cc+43-0
@@ -648,3 +648,46 @@ TEST_F(UtestPluginManagerIncCov, IncCov2_ParseVersion_NoMatch) {
648 std::string version;648 std::string version;
649 EXPECT_FALSE(PluginManager::ParseVersion(line, version, "Version="));649 EXPECT_FALSE(PluginManager::ParseVersion(line, version, "Version="));
650}650}
651+ 
652+TEST_F(UtestPluginManagerIncCov, IncCov2_CheckOppAndCompilerVersions_CompilerOutOfRange) {
653+ PluginManager mgr;
654+ std::vector<std::pair<uint32_t, uint32_t>> required = {{800000, 801000}};
655+ EXPECT_FALSE(mgr.CheckOppAndCompilerVersions("", "1.0", required));
656+}
657+ 
658+TEST_F(UtestPluginManagerIncCov, IncCov2_IsVendorVersionValid_WithRequiredVersion) {
659+ std::string run_pkg_path = GetRunPkgPath();
660+ std::string compiler_dir = run_pkg_path + "compiler";
661+ std::string runtime_dir = run_pkg_path + "runtime";
662+ system(("rm -rf " + runtime_dir).c_str());
663+ bool created = false;
664+ if (system(("mkdir -p " + compiler_dir).c_str()) == 0) {
665+ std::string version_file = compiler_dir + "/version.info";
666+ std::ofstream ofs(version_file);
667+ if (ofs.is_open()) {
668+ ofs << "required_opp_abi_version=>=8.0, <=8.1";
669+ ofs.close();
670+ created = true;
671+ }
672+ }
673+ PluginManager mgr;
674+ bool result = mgr.IsVendorVersionValid("8.0", "8.0");
675+ if (created) {
676+ system(("rm -rf " + compiler_dir).c_str());
677+ }
678+}
679+ 
680+TEST_F(UtestPluginManagerIncCov, IncCov2_GetOppSupportedOsAndCpuType_RealPathNotDir) {
681+ std::string file_path = kTmpDir2 + "/notdir_opp_file";
682+ system(("touch " + file_path).c_str());
683+ std::unordered_map<std::string, std::unordered_set<std::string>> opp_supported_os_cpu;
684+ PluginManager::GetOppSupportedOsAndCpuType(opp_supported_os_cpu, file_path, "", 0U);
685+ EXPECT_TRUE(opp_supported_os_cpu.empty());
686+}
687+ 
688+TEST_F(UtestPluginManagerIncCov, IncCov2_GetOppSupportedOsAndCpuType_ScanDirFail) {
689+ std::string nonexist = kTmpDir2 + "/nonexist_scan_opp";
690+ std::unordered_map<std::string, std::unordered_set<std::string>> opp_supported_os_cpu;
691+ PluginManager::GetOppSupportedOsAndCpuType(opp_supported_os_cpu, nonexist, "", 0U);
692+ EXPECT_TRUE(opp_supported_os_cpu.empty());
693+}
Mtests/graph_metadef/ut/graph/testcase/ref_relation_unittest.cc+120-0
@@ -191,4 +191,124 @@ TEST_F(UtestRefRelation, IncCov_BuildRefRelations_NetOutputNoRefIdx) {
191 RefRelations ref;191 RefRelations ref;
192 EXPECT_NE(ref.BuildRefRelations(*root_graph.get()), ge::SUCCESS);192 EXPECT_NE(ref.BuildRefRelations(*root_graph.get()), ge::SUCCESS);
193}193}
194+ 
195+TEST_F(UtestRefRelation, IncCov_BuildRefRelationsForWhile_NoNetoutput) {
196+ ComputeGraphPtr root_graph = std::make_shared<ComputeGraph>("root_graph");
197+ auto while_op_desc = CreateOpDesc("while", WHILE, 1, 1);
198+ auto while_node = root_graph->AddNode(while_op_desc);
199+ while_op_desc->AddSubgraphName("cond");
200+ while_op_desc->SetSubgraphInstanceName(0, "cond");
201+ while_op_desc->AddSubgraphName("body");
202+ while_op_desc->SetSubgraphInstanceName(1, "body");
203+ 
204+ auto cond_graph = std::make_shared<ComputeGraph>("cond");
205+ cond_graph->SetParentGraph(root_graph);
206+ cond_graph->SetParentNode(while_node);
207+ root_graph->AddSubGraph(cond_graph);
208+ 
209+ auto body_graph = std::make_shared<ComputeGraph>("body");
210+ auto body_data_op_desc = CreateOpDesc("body_data", DATA, 1, 1);
211+ auto body_data_node = body_graph->AddNode(body_data_op_desc);
212+ AttrUtils::SetInt(body_data_op_desc, ATTR_NAME_PARENT_NODE_INDEX, 0);
213+ body_graph->SetParentGraph(root_graph);
214+ body_graph->SetParentNode(while_node);
215+ root_graph->AddSubGraph(body_graph);
216+ 
217+ RefRelations ref;
218+ EXPECT_EQ(ref.BuildRefRelations(*root_graph.get()), ge::SUCCESS);
219+}
220+ 
221+TEST_F(UtestRefRelation, IncCov_BuildRefRelationsForWhile_NetOutputUnconnectedInput) {
222+ ComputeGraphPtr root_graph = std::make_shared<ComputeGraph>("root_graph");
223+ auto while_op_desc = CreateOpDesc("while", WHILE, 2, 2);
224+ auto while_node = root_graph->AddNode(while_op_desc);
225+ while_op_desc->AddSubgraphName("cond");
226+ while_op_desc->SetSubgraphInstanceName(0, "cond");
227+ while_op_desc->AddSubgraphName("body");
228+ while_op_desc->SetSubgraphInstanceName(1, "body");
229+ 
230+ auto cond_graph = std::make_shared<ComputeGraph>("cond");
231+ cond_graph->SetParentGraph(root_graph);
232+ cond_graph->SetParentNode(while_node);
233+ root_graph->AddSubGraph(cond_graph);
234+ 
235+ auto body_graph = std::make_shared<ComputeGraph>("body");
236+ auto body_data1_op_desc = CreateOpDesc("body_data1", DATA, 1, 1);
237+ auto body_data1_node = body_graph->AddNode(body_data1_op_desc);
238+ AttrUtils::SetInt(body_data1_op_desc, ATTR_NAME_PARENT_NODE_INDEX, 0);
239+ 
240+ auto body_data2_op_desc = CreateOpDesc("body_data2", DATA, 1, 1);
241+ auto body_data2_node = body_graph->AddNode(body_data2_op_desc);
242+ AttrUtils::SetInt(body_data2_op_desc, ATTR_NAME_PARENT_NODE_INDEX, 1);
243+ 
244+ auto body_netoutput_op_desc = CreateOpDesc("body_netoutput", NETOUTPUT, 2, 0);
245+ auto body_netoutput_node = body_graph->AddNode(body_netoutput_op_desc);
246+ AttrUtils::SetInt(body_netoutput_op_desc->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
247+ AttrUtils::SetInt(body_netoutput_op_desc->MutableInputDesc(1), ATTR_NAME_PARENT_NODE_INDEX, 1);
248+ 
249+ GraphUtils::AddEdge(body_data1_node->GetOutDataAnchor(0), body_netoutput_node->GetInDataAnchor(0));
250+ 
251+ body_graph->SetParentGraph(root_graph);
252+ body_graph->SetParentNode(while_node);
253+ root_graph->AddSubGraph(body_graph);
254+ 
255+ RefRelations ref;
256+ EXPECT_EQ(ref.BuildRefRelations(*root_graph.get()), ge::SUCCESS);
257+}
258+ 
259+TEST_F(UtestRefRelation, IncCov_BuildRefRelations_NetOutputNoInputDesc) {
260+ ComputeGraphPtr root_graph = std::make_shared<ComputeGraph>("root_graph");
261+ auto if_op_desc = CreateOpDesc("if", "If", 1, 1);
262+ auto if_node = root_graph->AddNode(if_op_desc);
263+ if_op_desc->AddSubgraphName("sub1");
264+ if_op_desc->SetSubgraphInstanceName(0, "sub1");
265+ 
266+ auto sub_graph = std::make_shared<ComputeGraph>("sub1");
267+ auto data1_op_desc = CreateOpDesc("sub1_data1", DATA, 1, 1);
268+ auto data1_node = sub_graph->AddNode(data1_op_desc);
269+ AttrUtils::SetInt(data1_op_desc, ATTR_NAME_PARENT_NODE_INDEX, 0);
270+ 
271+ auto netoutput_op_desc = CreateOpDesc("sub1_netoutput", NETOUTPUT, 1, 1);
272+ auto netoutput_node = sub_graph->AddNode(netoutput_op_desc);
273+ 
274+ GraphUtils::AddEdge(data1_node->GetOutDataAnchor(0), netoutput_node->GetInDataAnchor(0));
275+ sub_graph->SetParentGraph(root_graph);
276+ sub_graph->SetParentNode(if_node);
277+ root_graph->AddSubGraph(sub_graph);
278+ 
279+ RefRelations ref;
280+ EXPECT_NE(ref.BuildRefRelations(*root_graph.get()), ge::SUCCESS);
281+}
282+ 
283+TEST_F(UtestRefRelation, IncCov_BuildRefRelations_WhileSizeMismatch) {
284+ ComputeGraphPtr root_graph = std::make_shared<ComputeGraph>("root_graph");
285+ auto while_op_desc = CreateOpDesc("while", WHILE, 2, 1);
286+ auto while_node = root_graph->AddNode(while_op_desc);
287+ while_op_desc->AddSubgraphName("cond");
288+ while_op_desc->SetSubgraphInstanceName(0, "cond");
289+ while_op_desc->AddSubgraphName("body");
290+ while_op_desc->SetSubgraphInstanceName(1, "body");
291+ 
292+ auto cond_graph = std::make_shared<ComputeGraph>("cond");
293+ cond_graph->SetParentGraph(root_graph);
294+ cond_graph->SetParentNode(while_node);
295+ root_graph->AddSubGraph(cond_graph);
296+ 
297+ auto body_graph = std::make_shared<ComputeGraph>("body");
298+ auto body_data_op_desc = CreateOpDesc("body_data", DATA, 1, 1);
299+ auto body_data_node = body_graph->AddNode(body_data_op_desc);
300+ AttrUtils::SetInt(body_data_op_desc, ATTR_NAME_PARENT_NODE_INDEX, 0);
301+ 
302+ auto body_netoutput_op_desc = CreateOpDesc("body_netoutput", NETOUTPUT, 1, 0);
303+ auto body_netoutput_node = body_graph->AddNode(body_netoutput_op_desc);
304+ AttrUtils::SetInt(body_netoutput_op_desc->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
305+ 
306+ GraphUtils::AddEdge(body_data_node->GetOutDataAnchor(0), body_netoutput_node->GetInDataAnchor(0));
307+ body_graph->SetParentGraph(root_graph);
308+ body_graph->SetParentNode(while_node);
309+ root_graph->AddSubGraph(body_graph);
310+ 
311+ RefRelations ref;
312+ EXPECT_NE(ref.BuildRefRelations(*root_graph.get()), ge::SUCCESS);
313+}
194} // namespace ge314} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/shape_refiner_inc_cov_unittest.cc+438-0
@@ -952,4 +952,442 @@ TEST_F(UtestShapeRefinerIncCov, IncCov2_UpdateInputOutputDesc_WithShapeRange) {
952 auto ret = ShapeRefiner::UpdateInputOutputDesc(node);952 auto ret = ShapeRefiner::UpdateInputOutputDesc(node);
953 EXPECT_EQ(ret, GRAPH_SUCCESS);953 EXPECT_EQ(ret, GRAPH_SUCCESS);
954}954}
955+ 
956+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_SubgraphNotFound_BeforeSubgraph) {
957+ auto root_graph = std::make_shared<ComputeGraph>("test_subgraph_notfound_bs");
958+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_nf_bs", "If", 1, 1);
959+ auto op_desc = if_node->GetOpDesc();
960+ op_desc->AddSubgraphName("sub1");
961+ op_desc->SetSubgraphInstanceName(0, "nonexist_sub_bs");
962+ 
963+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
964+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
965+ GeTensorDesc if_output_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
966+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
967+ 
968+ auto ret = ShapeRefiner::InferShapeAndType(if_node, true);
969+ EXPECT_NE(ret, GRAPH_SUCCESS);
970+}
971+ 
972+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_SubgraphDataNoParentIndex_BeforeSubgraph) {
973+ auto root_graph = std::make_shared<ComputeGraph>("test_no_parent_idx_bs");
974+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_no_pi_bs", "If", 1, 1);
975+ auto op_desc = if_node->GetOpDesc();
976+ op_desc->AddSubgraphName("sub1");
977+ op_desc->SetSubgraphInstanceName(0, "sub1");
978+ 
979+ auto sub1 = std::make_shared<ComputeGraph>("sub1_no_pi_bs");
980+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_no_pi_bs", "Data", 1, 1);
981+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_no_pi_bs", "NetOutput", 1, 0);
982+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
983+ sub1->SetParentNode(if_node);
984+ sub1->SetParentGraph(root_graph);
985+ root_graph->AddSubgraph("sub1", sub1);
986+ 
987+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
988+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
989+ GeTensorDesc if_output_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
990+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
991+ 
992+ auto ret = ShapeRefiner::InferShapeAndType(if_node, true);
993+ EXPECT_NE(ret, GRAPH_SUCCESS);
994+}
995+ 
996+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_SubgraphDataRefOutOfRange_BeforeSubgraph) {
997+ auto root_graph = std::make_shared<ComputeGraph>("test_data_ref_oor_bs");
998+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_oor_bs", "If", 1, 1);
999+ auto op_desc = if_node->GetOpDesc();
1000+ op_desc->AddSubgraphName("sub1");
1001+ op_desc->SetSubgraphInstanceName(0, "sub1");
1002+ 
1003+ auto sub1 = std::make_shared<ComputeGraph>("sub1_oor_bs");
1004+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_oor_bs", "Data", 1, 1);
1005+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 5);
1006+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_oor_bs", "NetOutput", 1, 0);
1007+ 
1008+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1009+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1010+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1011+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
1012+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1013+ 
1014+ sub1->SetParentNode(if_node);
1015+ sub1->SetParentGraph(root_graph);
1016+ root_graph->AddSubgraph("sub1", sub1);
1017+ 
1018+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1019+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1020+ GeTensorDesc if_output_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1021+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1022+ 
1023+ auto ret = ShapeRefiner::InferShapeAndType(if_node, true);
1024+ EXPECT_NE(ret, GRAPH_SUCCESS);
1025+}
1026+ 
1027+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_SubgraphDataWithMBatchOrigin) {
1028+ auto root_graph = std::make_shared<ComputeGraph>("test_mbatch_origin");
1029+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_mbatch", "If", 1, 1);
1030+ auto op_desc = if_node->GetOpDesc();
1031+ op_desc->AddSubgraphName("sub1");
1032+ op_desc->SetSubgraphInstanceName(0, "sub1");
1033+ 
1034+ auto sub1 = std::make_shared<ComputeGraph>("sub1_mbatch");
1035+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_mbatch", "Data", 1, 1);
1036+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1037+ AttrUtils::SetStr(data1->GetOpDesc(), ATTR_MBATCH_ORIGIN_INPUT_DIMS, "1,3,224,224");
1038+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_mbatch", "NetOutput", 1, 0);
1039+ 
1040+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1041+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1042+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1043+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
1044+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1045+ 
1046+ sub1->SetParentNode(if_node);
1047+ sub1->SetParentGraph(root_graph);
1048+ root_graph->AddSubgraph("sub1", sub1);
1049+ 
1050+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1051+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1052+ GeTensorDesc if_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1053+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1054+ 
1055+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
1056+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, true);
1057+ SUCCEED();
1058+}
1059+ 
1060+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_NetOutputRefOutOfRange) {
1061+ auto root_graph = std::make_shared<ComputeGraph>("test_netoutput_ref_oor");
1062+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_net_oor", "If", 1, 1);
1063+ auto op_desc = if_node->GetOpDesc();
1064+ op_desc->AddSubgraphName("sub1");
1065+ op_desc->SetSubgraphInstanceName(0, "sub1");
1066+ 
1067+ auto sub1 = std::make_shared<ComputeGraph>("sub1_net_oor");
1068+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_net_oor", "Data", 1, 1);
1069+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1070+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_net_oor", "NetOutput", 1, 0);
1071+ 
1072+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1073+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1074+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 5);
1075+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
1076+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1077+ 
1078+ sub1->SetParentNode(if_node);
1079+ sub1->SetParentGraph(root_graph);
1080+ root_graph->AddSubgraph("sub1", sub1);
1081+ 
1082+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1083+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1084+ GeTensorDesc if_output_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1085+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1086+ 
1087+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
1088+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
1089+ EXPECT_EQ(ret, GRAPH_SUCCESS);
1090+}
1091+ 
1092+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_FindSubgraphDataNoParentIndex) {
1093+ auto root_graph = std::make_shared<ComputeGraph>("test_find_data_no_pi");
1094+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_fdpi", "If", 1, 1);
1095+ auto op_desc = if_node->GetOpDesc();
1096+ op_desc->AddSubgraphName("sub1");
1097+ op_desc->SetSubgraphInstanceName(0, "sub1");
1098+ 
1099+ auto sub1 = std::make_shared<ComputeGraph>("sub1_fdpi");
1100+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_fdpi", "Data", 1, 1);
1101+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_fdpi", "NetOutput", 1, 0);
1102+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1103+ sub1->SetParentNode(if_node);
1104+ sub1->SetParentGraph(root_graph);
1105+ root_graph->AddSubgraph("sub1", sub1);
1106+ 
1107+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1108+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1109+ GeTensorDesc if_output_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1110+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1111+ 
1112+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
1113+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
1114+ EXPECT_EQ(ret, GRAPH_FAILED);
1115+}
1116+ 
1117+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_MultiBatchDiffDtypeBranch) {
1118+ auto root_graph = std::make_shared<ComputeGraph>("test_mb_diff_dt_branch");
1119+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_mb_dt_br", "If", 1, 1);
1120+ auto op_desc = if_node->GetOpDesc();
1121+ op_desc->AddSubgraphName("sub1");
1122+ op_desc->SetSubgraphInstanceName(0, "sub1");
1123+ 
1124+ auto sub1 = std::make_shared<ComputeGraph>("sub1_mb_dt_br");
1125+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_mb_dt_br", "Data", 1, 1);
1126+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1127+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_mb_dt_br", "NetOutput", 1, 0);
1128+ 
1129+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1130+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1131+ 
1132+ GeTensorDesc netinput_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
1133+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1134+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, netinput_desc1);
1135+ 
1136+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1137+ 
1138+ sub1->SetParentNode(if_node);
1139+ sub1->SetParentGraph(root_graph);
1140+ root_graph->AddSubgraph("sub1", sub1);
1141+ 
1142+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1143+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1144+ GeTensorDesc if_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1145+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1146+ 
1147+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
1148+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
1149+ EXPECT_EQ(ret, GRAPH_SUCCESS);
1150+}
1151+ 
1152+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_WhileInferAgain) {
1153+ auto root_graph = std::make_shared<ComputeGraph>("test_while_infer_again");
1154+ NodePtr while_node = CreateNodeIncCov2(root_graph, "while_ia", "While", 1, 1);
1155+ auto op_desc = while_node->GetOpDesc();
1156+ op_desc->AddSubgraphName("sub1");
1157+ op_desc->SetSubgraphInstanceName(0, "sub1");
1158+ op_desc->AddSubgraphName("sub2");
1159+ op_desc->SetSubgraphInstanceName(1, "sub2");
1160+ 
1161+ auto sub1 = std::make_shared<ComputeGraph>("sub1_ia");
1162+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_ia", "Data", 1, 1);
1163+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1164+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_ia", "NetOutput", 1, 0);
1165+ 
1166+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1167+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1168+ GeTensorDesc netinput_desc1(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
1169+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1170+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, netinput_desc1);
1171+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1172+ sub1->SetParentNode(while_node);
1173+ sub1->SetParentGraph(root_graph);
1174+ root_graph->AddSubgraph("sub1", sub1);
1175+ 
1176+ auto sub2 = std::make_shared<ComputeGraph>("sub2_ia");
1177+ NodePtr data2 = CreateNodeIncCov2(sub2, "data2_ia", "Data", 1, 1);
1178+ AttrUtils::SetInt(data2->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1179+ NodePtr netoutput2 = CreateNodeIncCov2(sub2, "netoutput2_ia", "NetOutput", 1, 0);
1180+ 
1181+ GeTensorDesc out_desc2(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1182+ (void)data2->GetOpDesc()->UpdateOutputDesc(0, out_desc2);
1183+ GeTensorDesc netinput_desc2(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
1184+ AttrUtils::SetInt(netoutput2->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1185+ (void)netoutput2->GetOpDesc()->UpdateInputDesc(0, netinput_desc2);
1186+ GraphUtils::AddEdge(data2->GetOutDataAnchor(0), netoutput2->GetInDataAnchor(0));
1187+ sub2->SetParentNode(while_node);
1188+ sub2->SetParentGraph(root_graph);
1189+ root_graph->AddSubgraph("sub2", sub2);
1190+ 
1191+ GeTensorDesc while_input_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1192+ (void)while_node->GetOpDesc()->UpdateInputDesc(0, while_input_desc);
1193+ GeTensorDesc while_output_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
1194+ (void)while_node->GetOpDesc()->UpdateOutputDesc(0, while_output_desc);
1195+ 
1196+ Operator op = OpDescUtils::CreateOperatorFromNode(while_node);
1197+ auto ret = ShapeRefiner::InferShapeAndType(while_node, op, false);
1198+ SUCCEED();
1199+}
1200+ 
1201+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_WhileDiffDimNumInferAgain) {
1202+ auto root_graph = std::make_shared<ComputeGraph>("test_while_diff_dn_ia");
1203+ NodePtr while_node = CreateNodeIncCov2(root_graph, "while_dn_ia", "While", 1, 1);
1204+ auto op_desc = while_node->GetOpDesc();
1205+ op_desc->AddSubgraphName("sub1");
1206+ op_desc->SetSubgraphInstanceName(0, "sub1");
1207+ op_desc->AddSubgraphName("sub2");
1208+ op_desc->SetSubgraphInstanceName(1, "sub2");
1209+ 
1210+ auto sub1 = std::make_shared<ComputeGraph>("sub1_dn_ia");
1211+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_dn_ia", "Data", 1, 1);
1212+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1213+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_dn_ia", "NetOutput", 1, 0);
1214+ 
1215+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1216+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1217+ GeTensorDesc netinput_desc1(GeShape({2, 3, 4}), FORMAT_NCHW, DT_FLOAT);
1218+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1219+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, netinput_desc1);
1220+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1221+ sub1->SetParentNode(while_node);
1222+ sub1->SetParentGraph(root_graph);
1223+ root_graph->AddSubgraph("sub1", sub1);
1224+ 
1225+ auto sub2 = std::make_shared<ComputeGraph>("sub2_dn_ia");
1226+ NodePtr data2 = CreateNodeIncCov2(sub2, "data2_dn_ia", "Data", 1, 1);
1227+ AttrUtils::SetInt(data2->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1228+ NodePtr netoutput2 = CreateNodeIncCov2(sub2, "netoutput2_dn_ia", "NetOutput", 1, 0);
1229+ 
1230+ GeTensorDesc out_desc2(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1231+ (void)data2->GetOpDesc()->UpdateOutputDesc(0, out_desc2);
1232+ GeTensorDesc netinput_desc2(GeShape({2, 3, 4}), FORMAT_NCHW, DT_FLOAT);
1233+ AttrUtils::SetInt(netoutput2->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1234+ (void)netoutput2->GetOpDesc()->UpdateInputDesc(0, netinput_desc2);
1235+ GraphUtils::AddEdge(data2->GetOutDataAnchor(0), netoutput2->GetInDataAnchor(0));
1236+ sub2->SetParentNode(while_node);
1237+ sub2->SetParentGraph(root_graph);
1238+ root_graph->AddSubgraph("sub2", sub2);
1239+ 
1240+ GeTensorDesc while_input_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1241+ (void)while_node->GetOpDesc()->UpdateInputDesc(0, while_input_desc);
1242+ GeTensorDesc while_output_desc(GeShape({2, 3, 4}), FORMAT_NCHW, DT_FLOAT);
1243+ (void)while_node->GetOpDesc()->UpdateOutputDesc(0, while_output_desc);
1244+ 
1245+ Operator op = OpDescUtils::CreateOperatorFromNode(while_node);
1246+ auto ret = ShapeRefiner::InferShapeAndType(while_node, op, false);
1247+ SUCCEED();
1248+}
1249+ 
1250+TEST_F(UtestShapeRefinerIncCov, IncCov2_PostProcessAfterInfershape_WithInferenceContext) {
1251+ auto graph = std::make_shared<ComputeGraph>("test_post_ctx");
1252+ auto node = CreateNodeIncCov2(graph, "post_ctx_node", "Relu", 1, 1);
1253+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1254+ input_desc.SetOriginFormat(FORMAT_NCHW);
1255+ input_desc.SetOriginDataType(DT_FLOAT);
1256+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
1257+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
1258+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1259+ auto ctx = std::shared_ptr<InferenceContext>(InferenceContext::Create());
1260+ op.SetInferenceContext(ctx);
1261+ auto ret = ShapeRefiner::PostProcessAfterInfershape(node, op, false);
1262+ EXPECT_EQ(ret, GRAPH_SUCCESS);
1263+ ShapeRefiner::ClearContextMap();
1264+}
1265+ 
1266+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndTypeForRunning_GeLocalMemcpyAsync) {
1267+ auto graph = std::make_shared<ComputeGraph>("test_memcpy");
1268+ auto node = CreateNodeIncCov2(graph, "memcpy_node", "MemcpyAsync", 1, 1);
1269+ 
1270+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1271+ input_desc.SetOriginFormat(FORMAT_NCHW);
1272+ input_desc.SetOriginDataType(DT_FLOAT);
1273+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
1274+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
1275+ 
1276+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1277+ auto ret = ShapeRefiner::InferShapeAndTypeForRunning(node, op, true);
1278+ EXPECT_EQ(ret, GRAPH_SUCCESS);
1279+}
1280+ 
1281+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndTypeForRunning_FailedStatus) {
1282+ auto graph = std::make_shared<ComputeGraph>("test_running_failed_status");
1283+ auto node = CreateNodeIncCov2(graph, "fail_status_node", "Relu", 1, 1);
1284+ 
1285+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1286+ input_desc.SetOriginFormat(FORMAT_NCHW);
1287+ input_desc.SetOriginDataType(DT_FLOAT);
1288+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
1289+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
1290+ 
1291+ auto op_desc = node->GetOpDesc();
1292+ op_desc->AddInferFunc([](Operator &op) { return static_cast<graphStatus>(GRAPH_PARAM_INVALID + 1); });
1293+ 
1294+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1295+ auto ret = ShapeRefiner::InferShapeAndTypeForRunning(node, op, true);
1296+ EXPECT_EQ(ret, GRAPH_FAILED);
1297+}
1298+ 
1299+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_BranchEmptyRefOut) {
1300+ auto root_graph = std::make_shared<ComputeGraph>("test_branch_empty_ref");
1301+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_empty_ref", "If", 1, 2);
1302+ auto op_desc = if_node->GetOpDesc();
1303+ op_desc->AddSubgraphName("sub1");
1304+ op_desc->SetSubgraphInstanceName(0, "sub1");
1305+ 
1306+ auto sub1 = std::make_shared<ComputeGraph>("sub1_empty_ref");
1307+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_er", "Data", 1, 1);
1308+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1309+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_er", "NetOutput", 1, 0);
1310+ 
1311+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1312+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1313+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1314+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
1315+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1316+ sub1->SetParentNode(if_node);
1317+ sub1->SetParentGraph(root_graph);
1318+ root_graph->AddSubgraph("sub1", sub1);
1319+ 
1320+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1321+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1322+ GeTensorDesc if_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1323+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1324+ (void)if_node->GetOpDesc()->UpdateOutputDesc(1, if_output_desc);
1325+ 
1326+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
1327+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
1328+ SUCCEED();
1329+}
1330+ 
1331+TEST_F(UtestShapeRefinerIncCov, IncCov2_GetRealInNodesAndIndex_WithDataParent) {
1332+ auto root_graph = std::make_shared<ComputeGraph>("test_get_real_nodes");
1333+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_grn", "If", 1, 1);
1334+ auto op_desc = if_node->GetOpDesc();
1335+ op_desc->AddSubgraphName("sub1");
1336+ op_desc->SetSubgraphInstanceName(0, "sub1");
1337+ 
1338+ auto sub1 = std::make_shared<ComputeGraph>("sub1_grn");
1339+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_grn", "Data", 1, 1);
1340+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1341+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_grn", "NetOutput", 1, 0);
1342+ 
1343+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1344+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
1345+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
1346+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
1347+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
1348+ sub1->SetParentNode(if_node);
1349+ sub1->SetParentGraph(root_graph);
1350+ root_graph->AddSubgraph("sub1", sub1);
1351+ 
1352+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
1353+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
1354+ GeTensorDesc if_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
1355+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
1356+ 
1357+ auto ret = ShapeRefiner::InferShapeAndType(if_node, true);
1358+ SUCCEED();
1359+}
1360+ 
1361+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_CallInferFuncSecond) {
1362+ auto graph = std::make_shared<ComputeGraph>("test_call_infer_second");
1363+ auto node = CreateNodeIncCov2(graph, "infer_second_node", "Relu", 1, 1);
1364+ auto op_desc = node->GetOpDesc();
1365+ op_desc->AddInferFunc(nullptr);
1366+ 
1367+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1368+ input_desc.SetOriginFormat(FORMAT_NCHW);
1369+ input_desc.SetOriginDataType(DT_FLOAT);
1370+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
1371+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
1372+ 
1373+ auto ret = ShapeRefiner::InferShapeAndType(node, true);
1374+ SUCCEED();
1375+}
1376+ 
1377+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndTypeForRunning_CallInferFuncSecond) {
1378+ auto graph = std::make_shared<ComputeGraph>("test_running_call_second");
1379+ auto node = CreateNodeIncCov2(graph, "running_second_node", "Relu", 1, 1);
1380+ auto op_desc = node->GetOpDesc();
1381+ op_desc->AddInferFunc(nullptr);
1382+ 
1383+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1384+ input_desc.SetOriginFormat(FORMAT_NCHW);
1385+ input_desc.SetOriginDataType(DT_FLOAT);
1386+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
1387+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
1388+ 
1389+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1390+ auto ret = ShapeRefiner::InferShapeAndTypeForRunning(node, op, true);
1391+ EXPECT_EQ(ret, GRAPH_FAILED);
1392+}
955} // namespace ge1393} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/tensor_unittest.cc+56-0
@@ -525,4 +525,60 @@ TEST_F(TensorUtilsUT, IncCov_TensorAdapterAllMethods) {
525 auto from_null = TensorAdapter::GeTensor2Tensor(nullptr);525 auto from_null = TensorAdapter::GeTensor2Tensor(nullptr);
526 EXPECT_EQ(from_null.GetSize(), 0U);526 EXPECT_EQ(from_null.GetSize(), 0U);
527}527}
528+ 
529+TEST_F(TensorUtilsUT, IncCov_TensorDescSetName) {
530+ TensorDesc desc;
531+ desc.SetName("test_tensor_name");
532+ EXPECT_EQ(desc.GetName(), "test_tensor_name");
533+}
534+ 
535+TEST_F(TensorUtilsUT, IncCov_TensorDescGetNameAscendString) {
536+ TensorDesc desc;
537+ desc.SetName("test_ascend_name");
538+ AscendString name;
539+ EXPECT_EQ(desc.GetName(name), GRAPH_SUCCESS);
540+ EXPECT_STREQ(name.GetString(), "test_ascend_name");
541+}
542+ 
543+TEST_F(TensorUtilsUT, IncCov_TensorSetDataNullCharPtr) {
544+ Tensor tensor;
545+ EXPECT_EQ(tensor.SetData(static_cast<const char_t *>(nullptr)), GRAPH_FAILED);
546+}
547+ 
548+TEST_F(TensorUtilsUT, IncCov_TensorSetDataNullAscendString) {
549+ Tensor tensor;
550+ AscendString null_str(nullptr);
551+ std::vector<AscendString> datas = {null_str};
552+ EXPECT_EQ(tensor.SetData(datas), GRAPH_SUCCESS);
553+}
554+ 
555+TEST_F(TensorUtilsUT, IncCov_TensorSetDataCharPtr) {
556+ Tensor tensor;
557+ EXPECT_EQ(tensor.SetData("hello"), GRAPH_SUCCESS);
558+ EXPECT_EQ(tensor.GetSize(), 22U);
559+}
560+ 
561+TEST_F(TensorUtilsUT, IncCov_TensorGetData) {
562+ Tensor tensor;
563+ const uint8_t *data = tensor.GetData();
564+ EXPECT_NE(data, nullptr);
565+}
566+ 
567+TEST_F(TensorUtilsUT, IncCov_TensorDescSetNameCharPtr) {
568+ TensorDesc desc;
569+ desc.SetName(static_cast<const char_t *>("char_name"));
570+ EXPECT_EQ(desc.GetName(), "char_name");
571+}
572+ 
573+TEST_F(TensorUtilsUT, IncCov_TensorDescSetNameNullCharPtr) {
574+ TensorDesc desc;
575+ desc.SetName(static_cast<const char_t *>(nullptr));
576+ EXPECT_EQ(desc.GetName(), "");
577+}
578+ 
579+TEST_F(TensorUtilsUT, IncCov_TensorResetData) {
580+ Tensor tensor;
581+ auto data = tensor.ResetData();
582+ EXPECT_EQ(data, nullptr);
583+}
528} // namespace ge584} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/tuning_utils_unittest.cc+38-0
@@ -850,4 +850,42 @@ TEST_F(UtestTuningUtils, CovPrintCheckLogWithNetoutput) {
850 auto result = TuningUtils::PrintCheckLog();850 auto result = TuningUtils::PrintCheckLog();
851 EXPECT_FALSE(result.empty());851 EXPECT_FALSE(result.empty());
852}852}
853+ 
854+TEST_F(UtestTuningUtils, CovGetNodeNameByAnchorNullAnchor) {
855+ auto result = TuningUtils::GetNodeNameByAnchor(nullptr);
856+ EXPECT_EQ(result, "Null");
857+}
858+ 
859+TEST_F(UtestTuningUtils, CovGetNodeNameByAnchorValidAnchor) {
860+ ut::GraphBuilder builder = ut::GraphBuilder("graph_anchor");
861+ auto node = builder.AddNode("test_node", "Relu", 1, 1);
862+ auto anchor = node->GetOutDataAnchor(0);
863+ auto result = TuningUtils::GetNodeNameByAnchor(anchor.get());
864+ EXPECT_EQ(result, "test_node");
865+}
866+ 
867+TEST_F(UtestTuningUtils, CovConvertGraphToFileEmptyVectors) {
868+ std::vector<ComputeGraphPtr> tuning_subgraphs;
869+ std::vector<ComputeGraphPtr> non_tuning_subgraphs;
870+ auto ret = TuningUtils::ConvertGraphToFile(tuning_subgraphs, non_tuning_subgraphs, false);
871+ EXPECT_EQ(ret, GRAPH_SUCCESS);
872+}
873+ 
874+TEST_F(UtestTuningUtils, CovCreateNetOutputWithGraph) {
875+ ut::GraphBuilder builder = ut::GraphBuilder("graph_create_output");
876+ auto node0 = builder.AddNode("Data0", "Data", 1, 1);
877+ NodePtr node1;
878+ auto graph = builder.GetGraph();
879+ TuningUtils::create_output_[graph] = nullptr;
880+ auto ret = TuningUtils::CreateNetOutput(node0, node1);
881+ EXPECT_EQ(ret, SUCCESS);
882+ TuningUtils::create_output_.clear();
883+}
884+ 
885+TEST_F(UtestTuningUtils, CovPrintCheckLogEmpty) {
886+ TuningUtils::netoutput_nodes_.clear();
887+ TuningUtils::data_2_end_.clear();
888+ auto result = TuningUtils::PrintCheckLog();
889+ EXPECT_FALSE(result.empty());
890+}
853} // namespace ge891} // namespace ge
Mtests/graph_metadef/ut/register/testcase/fusion_quant_util_cov_unittest.cc+35-0
@@ -915,4 +915,39 @@ TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithFFN_ND_2DWeight)
915 auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);915 auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
916 EXPECT_EQ(ret, SUCCESS);916 EXPECT_EQ(ret, SUCCESS);
917}917}
918+ 
919+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_NullParams) {
920+ ComputeGraphPtr graph = CreateSimpleGraphWithAnchors();
921+ NodePtr mm_node = graph->FindNode("mm");
922+ BiasOptimizeEdges param;
923+ param.quant_scale = nullptr;
924+ param.quant_offset = nullptr;
925+ param.cube_weight = nullptr;
926+ param.cube_bias = nullptr;
927+ param.deq_scale = nullptr;
928+ vector<NodePtr> fusion_nodes;
929+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
930+ EXPECT_NE(ret, SUCCESS);
931+}
932+ 
933+TEST_F(FusionQuantUtilImplCovUT, IncCov_InsertRequantScaleConvert_NullParams) {
934+ InDataAnchorPtr null_anchor;
935+ vector<NodePtr> fusion_nodes;
936+ auto ret = QuantUtil::InsertRequantScaleConvert(null_anchor, null_anchor, null_anchor, fusion_nodes);
937+ EXPECT_NE(ret, SUCCESS);
938+}
939+ 
940+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithDeqScaleAndNullCubeBias) {
941+ ComputeGraphPtr graph = CreateSimpleGraphWithAnchors();
942+ NodePtr mm_node = graph->FindNode("mm");
943+ BiasOptimizeEdges param;
944+ param.quant_scale = mm_node->GetInDataAnchor(3);
945+ param.quant_offset = mm_node->GetInDataAnchor(4);
946+ param.cube_weight = mm_node->GetInDataAnchor(1);
947+ param.cube_bias = nullptr;
948+ param.deq_scale = mm_node->GetInDataAnchor(3);
949+ vector<NodePtr> fusion_nodes;
950+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
951+ EXPECT_NE(ret, SUCCESS);
952+}
918} // namespace fe953} // namespace fe
Mtests/graph_metadef/ut/register/testcase/fusion_turbo_utils_cov_unittest.cc+101-0
@@ -540,4 +540,105 @@ TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_AddWeights_WithZeroDataSize) {
540 auto nodes = ft.AddWeights(node, {w});540 auto nodes = ft.AddWeights(node, {w});
541 EXPECT_TRUE(nodes.empty());541 EXPECT_TRUE(nodes.empty());
542}542}
543+ 
544+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_AddWeights_WithNullData) {
545+ auto graph = std::make_shared<ge::ComputeGraph>("test_addweights_null_data");
546+ auto op_desc = std::make_shared<ge::OpDesc>("node1_null", "Relu");
547+ ge::GeTensorDesc tensor_desc(ge::GeShape({1, 4}), ge::FORMAT_NCHW, ge::DT_FLOAT);
548+ op_desc->AddInputDesc(tensor_desc);
549+ op_desc->AddOutputDesc(tensor_desc);
550+ auto node = graph->AddNode(op_desc);
551+ FusionTurbo ft(graph);
552+ WeightInfo w(tensor_desc, nullptr);
553+ auto nodes = ft.AddWeights(node, {w});
554+ EXPECT_FALSE(nodes.empty());
555+}
556+ 
557+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_InstNodeBefore_Success) {
558+ auto graph = BuildGraph();
559+ FusionTurbo ft(graph);
560+ auto add_node = graph->FindNode("add1");
561+ ASSERT_NE(add_node, nullptr);
562+ auto ret = ft.InsertNodeBefore("inst_before_node", "Relu", add_node, 1, 1);
563+ EXPECT_EQ(ret, nullptr);
564+}
565+ 
566+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_InstNodeAfter_Success) {
567+ auto graph = BuildGraph();
568+ FusionTurbo ft(graph);
569+ auto add_node = graph->FindNode("add1");
570+ ASSERT_NE(add_node, nullptr);
571+ auto ret = ft.InsertNodeAfter("inst_after_node", "Relu", add_node, 1, 1);
572+ EXPECT_EQ(ret, nullptr);
573+}
574+ 
575+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkInput_Success) {
576+ auto graph = BuildGraph();
577+ FusionTurbo ft(graph);
578+ auto add_node = graph->FindNode("add1");
579+ ASSERT_NE(add_node, nullptr);
580+ auto data_node = graph->FindNode("data1");
581+ ASSERT_NE(data_node, nullptr);
582+ Relations input_rel(0, NodeIndices{NodeIndex(data_node, 0)});
583+ auto ret = ft.LinkInput(input_rel, add_node, UPDATE_NONE);
584+ EXPECT_NE(ret, SUCCESS);
585+}
586+ 
587+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkOutput_Success) {
588+ auto graph = BuildGraph();
589+ FusionTurbo ft(graph);
590+ auto add_node = graph->FindNode("add1");
591+ ASSERT_NE(add_node, nullptr);
592+ auto output_node = graph->FindNode("output1");
593+ ASSERT_NE(output_node, nullptr);
594+ Relations output_rel(0, NodeIndices{NodeIndex(output_node, 0)});
595+ auto ret = ft.LinkOutput(output_rel, add_node, UPDATE_NONE);
596+ EXPECT_EQ(ret, SUCCESS);
597+}
598+ 
599+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_RemoveNode_Success) {
600+ auto graph = BuildGraph();
601+ FusionTurbo ft(graph);
602+ auto relu_node = graph->FindNode("relu1");
603+ ASSERT_NE(relu_node, nullptr);
604+ auto ret = ft.RemoveNodeOnly(relu_node);
605+ EXPECT_EQ(ret, SUCCESS);
606+}
607+ 
608+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_RemoveNode_NullNode) {
609+ auto graph = BuildGraph();
610+ FusionTurbo ft(graph);
611+ auto ret = ft.RemoveNodeOnly(nullptr);
612+ EXPECT_NE(ret, SUCCESS);
613+}
614+ 
615+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_GetConstInput_Success) {
616+ auto graph = BuildGraph();
617+ auto add_node = graph->FindNode("add1");
618+ ASSERT_NE(add_node, nullptr);
619+ auto result = FusionTurboUtils::GetConstInput(add_node, 0);
620+ EXPECT_EQ(result, nullptr);
621+}
622+ 
623+TEST_F(FusionTurboUtilsCovUT, IncCov_GetConstInput_OutOfRange) {
624+ auto graph = BuildGraph();
625+ auto add_node = graph->FindNode("add1");
626+ ASSERT_NE(add_node, nullptr);
627+ auto result = FusionTurboUtils::GetConstInput(add_node, 100);
628+ EXPECT_EQ(result, nullptr);
629+}
630+ 
631+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_AddWeights_WithValidData) {
632+ auto graph = std::make_shared<ge::ComputeGraph>("test_addweights_valid");
633+ auto op_desc = std::make_shared<ge::OpDesc>("node_valid", "Relu");
634+ ge::GeTensorDesc tensor_desc(ge::GeShape({1, 4}), ge::FORMAT_NCHW, ge::DT_FLOAT);
635+ op_desc->AddInputDesc(tensor_desc);
636+ op_desc->AddOutputDesc(tensor_desc);
637+ auto node = graph->AddNode(op_desc);
638+ FusionTurbo ft(graph);
639+ auto data_ptr = std::make_unique<int32_t[]>(16);
640+ WeightInfo w(tensor_desc, data_ptr.get());
641+ auto nodes = ft.AddWeights(node, {w});
642+ EXPECT_FALSE(nodes.empty());
643+}
543} // namespace fe644} // namespace fe
Mtests/graph_metadef/ut/register/testcase/pattern_fusion_base_pass_cov_unittest.cc+13-0
@@ -1321,4 +1321,17 @@ TEST_F(PatternFusionBasePassCovUT, Impl_GetOutDataAnchors_Test) {
1321 PatternFusionBasePassImpl::GetOutDataAnchors(node1, anchors);1321 PatternFusionBasePassImpl::GetOutDataAnchors(node1, anchors);
1322 EXPECT_EQ(anchors.size(), 1U);1322 EXPECT_EQ(anchors.size(), 1U);
1323}1323}
1324+ 
1325+TEST_F(PatternFusionBasePassCovUT, Impl_MatchAllEdges_ZeroSize) {
1326+ EXPECT_TRUE(PatternFusionBasePassImpl::MatchAllEdges(0, nullptr));
1327+}
1328+ 
1329+TEST_F(PatternFusionBasePassCovUT, Impl_BuildPatterns_Success) {
1330+ TestPatternFusionPassCov pass;
1331+ auto patterns = pass.DefinePatterns();
1332+ EXPECT_FALSE(patterns.empty());
1333+ for (auto p : patterns) {
1334+ delete p;
1335+ }
1336+}
1324} // namespace fe1337} // namespace fe
Mtests/graph_metadef/ut/register/testcase/register_op_tiling_py_cov_ut.cc+49-0
@@ -1606,4 +1606,53 @@ TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_EmptyFuncInfo) {
1606 EXPECT_EQ(ret, 0);1606 EXPECT_EQ(ret, 0);
1607 func_map.erase("ReluPyEmpty");1607 func_map.erase("ReluPyEmpty");
1608}1608}
1609+ 
1610+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_NotRegistered) {
1611+ char run_info_json[4096] = {0};
1612+ uint64_t elapse[2] = {0};
1613+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1614+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1615+ int ret = TbeOpTilingPyInterface("NonExistentOp", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1616+ sizeof(run_info_json), elapse);
1617+ EXPECT_EQ(ret, 0);
1618+}
1619+ 
1620+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_NullInputs) {
1621+ char run_info_json[4096] = {0};
1622+ uint64_t elapse[2] = {0};
1623+ int ret = TbeOpTilingPyInterface("NonExistentOp", "compile_info", "hash", nullptr, nullptr, nullptr, run_info_json,
1624+ sizeof(run_info_json), elapse);
1625+ EXPECT_EQ(ret, 0);
1626+}
1627+ 
1628+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_SmallBuffer) {
1629+ char run_info_json[10] = {0};
1630+ uint64_t elapse[2] = {0};
1631+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1632+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1633+ int ret = TbeOpTilingPyInterface("NonExistentOp", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1634+ sizeof(run_info_json), elapse);
1635+ EXPECT_EQ(ret, 0);
1636+}
1637+ 
1638+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_WithAttrs) {
1639+ char run_info_json[4096] = {0};
1640+ uint64_t elapse[2] = {0};
1641+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1642+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1643+ const char *attrs = R"([{"name":"attr1","dtype":"int64","value":1}])";
1644+ int ret = TbeOpTilingPyInterface("NonExistentOp", "compile_info", "hash", inputs, outputs, attrs, run_info_json,
1645+ sizeof(run_info_json), elapse);
1646+ EXPECT_EQ(ret, 0);
1647+}
1648+ 
1649+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_InvalidOutputs) {
1650+ char run_info_json[4096] = {0};
1651+ uint64_t elapse[2] = {0};
1652+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1653+ const char *outputs = "invalid_json";
1654+ int ret = TbeOpTilingPyInterface("NonExistentOp", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1655+ sizeof(run_info_json), elapse);
1656+ EXPECT_EQ(ret, 0);
1657+}
1609} // namespace optiling1658} // namespace optiling
Mtests/graph_metadef/ut/register/testcase/register_unittest.cc+77-0
@@ -4092,3 +4092,80 @@ TEST_F(UtestRegister, IncCov_AscendC_GeneralizedDumpFail) {
4092 0);4092 0);
4093 unsetenv("ENABLE_RUNTIME_V2");4093 unsetenv("ENABLE_RUNTIME_V2");
4094}4094}
4095+ 
4096+TEST_F(UtestRegister, IncCov_AscendCPyInterfaceCheckOp_NotRegistered) {
4097+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4098+ std::string input_str = "[]";
4099+ std::string output_str = "[]";
4100+ std::string attrs_str = "[]";
4101+ std::string op_type = "NonExistentCheckOp";
4102+ std::string res_info(1024, 'a');
4103+ size_t size = 1024;
4104+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, op_type.c_str(), input_str.c_str(), output_str.c_str(),
4105+ attrs_str.c_str(), const_cast<char *>(res_info.c_str()), size),
4106+ 0);
4107+ unsetenv("ENABLE_RUNTIME_V2");
4108+}
4109+ 
4110+TEST_F(UtestRegister, IncCov_AscendCPyInterfaceGeneralized_NotRegistered) {
4111+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4112+ std::string input_str = "[]";
4113+ std::string output_str = "[]";
4114+ std::string attrs_str = "[]";
4115+ std::string op_type = "NonExistentGenOp";
4116+ std::string res_info(1024, 'a');
4117+ size_t size = 1024;
4118+ EXPECT_EQ(AscendCPyInterfaceGeneralized(op_type.c_str(), input_str.c_str(), output_str.c_str(), attrs_str.c_str(),
4119+ "keep_rank", const_cast<char *>(res_info.c_str()), size),
4120+ 0);
4121+ unsetenv("ENABLE_RUNTIME_V2");
4122+}
4123+ 
4124+TEST_F(UtestRegister, IncCov_AscendCPyInterfaceGetTilingDefInfo_NotRegistered) {
4125+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4126+ std::string res_info(1024, 'a');
4127+ size_t size = 1024;
4128+ EXPECT_EQ(AscendCPyInterfaceGetTilingDefInfo("NonExistentTilingOp", const_cast<char *>(res_info.c_str()), size), 0);
4129+ unsetenv("ENABLE_RUNTIME_V2");
4130+}
4131+ 
4132+TEST_F(UtestRegister, IncCov_RegisterOpTilingFuncV1) {
4133+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
4134+ func_map.erase("TestRegisterV1");
4135+ OpTilingFuncInfo info("TestRegisterV1");
4136+ OpTilingFunc v1_func = [](const TeOpParas &op_paras, const OpCompileInfo &compile_info, OpRunInfo &run_info) -> bool {
4137+ return true;
4138+ };
4139+ info.SetOpTilingFunc(v1_func);
4140+ func_map.emplace("TestRegisterV1", info);
4141+ EXPECT_NE(func_map.find("TestRegisterV1"), func_map.end());
4142+ func_map.erase("TestRegisterV1");
4143+}
4144+ 
4145+TEST_F(UtestRegister, IncCov_AscendCPyInterfaceCheckOp_NullParams) {
4146+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4147+ std::string res_info(1024, 'a');
4148+ size_t size = 1024;
4149+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, nullptr, nullptr, nullptr, nullptr,
4150+ const_cast<char *>(res_info.c_str()), size),
4151+ 0);
4152+ unsetenv("ENABLE_RUNTIME_V2");
4153+}
4154+ 
4155+TEST_F(UtestRegister, IncCov_AscendCPyInterfaceGeneralized_NullParams) {
4156+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4157+ std::string res_info(1024, 'a');
4158+ size_t size = 1024;
4159+ EXPECT_EQ(AscendCPyInterfaceGeneralized(nullptr, nullptr, nullptr, nullptr, "keep_rank",
4160+ const_cast<char *>(res_info.c_str()), size),
4161+ 0);
4162+ unsetenv("ENABLE_RUNTIME_V2");
4163+}
4164+ 
4165+TEST_F(UtestRegister, IncCov_AscendCPyInterfaceGetTilingDefInfo_NullParams) {
4166+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4167+ std::string res_info(1024, 'a');
4168+ size_t size = 1024;
4169+ EXPECT_EQ(AscendCPyInterfaceGetTilingDefInfo(nullptr, const_cast<char *>(res_info.c_str()), size), 0);
4170+ unsetenv("ENABLE_RUNTIME_V2");
4171+}
Mtests/parser/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc+237-0
@@ -1801,4 +1801,241 @@ TEST_F(UtestCaffeParser, CaffeModelParser_ToJson_null_json) {
1801 EXPECT_EQ(ret, FAILED);1801 EXPECT_EQ(ret, FAILED);
1802}1802}
1803 1803 
1804+TEST_F(UtestCaffeParser, CaffeModelParser_ParseNetModelByCustomProto_test) {
1805+ CaffeModelParser modelParser;
1806+ std::string case_dir = __FILE__;
1807+ case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
1808+ std::string model_file = case_dir + "/caffe_model/caffe_add.pbtxt";
1809+ std::string custom_proto_path = case_dir + "/caffe_model";
1810+ std::string custom_proto_name = "project_root/caffe_add.pbtxt";
1811+ 
1812+ vector<ge::Operator> operators;
1813+ Status ret =
1814+ modelParser.ParseNetModelByCustomProto(model_file.c_str(), custom_proto_path, custom_proto_name, operators);
1815+ EXPECT_NE(ret, SUCCESS);
1816+}
1817+ 
1818+TEST_F(UtestCaffeParser, CaffeModelParser_CustomProtoParse_no_slash_test) {
1819+ CaffeModelParser modelParser;
1820+ std::string case_dir = __FILE__;
1821+ case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
1822+ std::string model_file = case_dir + "/caffe_model/caffe_add.pbtxt";
1823+ 
1824+ std::string custom_proto = case_dir + "/../../../../../graph_metadef/proto/caffe/caffe.proto";
1825+ std::string caffe_proto = case_dir + "/../../../../../graph_metadef/proto/caffe/caffe.proto";
1826+ vector<ge::Operator> operators;
1827+ ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Data", "Input");
1828+ ge::Operator op_src = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_src);
1829+ operators.emplace_back(op_src);
1830+ 
1831+ Status ret = modelParser.CustomProtoParse(model_file.c_str(), custom_proto, caffe_proto, operators);
1832+ EXPECT_EQ(ret, SUCCESS);
1833+}
1834+ 
1835+TEST_F(UtestCaffeParser, aclgrphParseCaffe_4param_parse_before_fail) {
1836+ ParerUTestsUtils::ClearParserInnerCtx();
1837+ std::string case_dir = __FILE__;
1838+ case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
1839+ std::string model_file = case_dir + "/caffe_model/caffe_add.pbtxt";
1840+ std::string weight_file = case_dir + "/caffe_model/caffe_add.caffemodel";
1841+ 
1842+ std::map<ge::AscendString, ge::AscendString> parser_params;
1843+ parser_params[ge::AscendString(ge::ir_option::OUT_NODES)] = ge::AscendString("InvalidNode:0;InvalidNode2:1");
1844+ ge::Graph graph;
1845+ auto ret = ge::aclgrphParseCaffe(model_file.c_str(), weight_file.c_str(), parser_params, graph);
1846+ EXPECT_NE(ret, ge::SUCCESS);
1847+}
1848+ 
1849+TEST_F(UtestCaffeParser, CaffeModelParser_AddEdges_success) {
1850+ ParerUTestsUtils::ClearParserInnerCtx();
1851+ CaffeModelParser modelParser;
1852+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_edges");
1853+ 
1854+ ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("node1", "Relu");
1855+ op1->AddInputDesc(ge::GeTensorDesc());
1856+ op1->AddOutputDesc(ge::GeTensorDesc());
1857+ ge::NodePtr node1 = graph->AddNode(op1);
1858+ 
1859+ ge::OpDescPtr op2 = std::make_shared<ge::OpDesc>("node2", "Relu");
1860+ op2->AddInputDesc(ge::GeTensorDesc());
1861+ op2->AddOutputDesc(ge::GeTensorDesc());
1862+ ge::NodePtr node2 = graph->AddNode(op2);
1863+ 
1864+ modelParser.top_blobs_map_["blob1"].emplace_back(std::make_pair("node1", 0));
1865+ modelParser.bottom_blobs_map_["blob1"].emplace_back(std::make_pair("node2", 0));
1866+ modelParser.node_map["node1"] = node1;
1867+ modelParser.node_map["node2"] = node2;
1868+ 
1869+ Status ret = modelParser.AddEdges(graph);
1870+ EXPECT_EQ(ret, SUCCESS);
1871+}
1872+ 
1873+TEST_F(UtestCaffeParser, CaffeModelParser_AddEdges_top_node_not_found) {
1874+ ParerUTestsUtils::ClearParserInnerCtx();
1875+ CaffeModelParser modelParser;
1876+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_edges2");
1877+ 
1878+ ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("node1", "Relu");
1879+ op1->AddInputDesc(ge::GeTensorDesc());
1880+ op1->AddOutputDesc(ge::GeTensorDesc());
1881+ ge::NodePtr node1 = graph->AddNode(op1);
1882+ 
1883+ modelParser.top_blobs_map_["blob1"].emplace_back(std::make_pair("nonexistent_top", 0));
1884+ modelParser.bottom_blobs_map_["blob1"].emplace_back(std::make_pair("node1", 0));
1885+ modelParser.node_map["node1"] = node1;
1886+ 
1887+ Status ret = modelParser.AddEdges(graph);
1888+ EXPECT_EQ(ret, ge::FAILED);
1889+}
1890+ 
1891+TEST_F(UtestCaffeParser, CaffeModelParser_AddEdges_bottom_node_not_found) {
1892+ ParerUTestsUtils::ClearParserInnerCtx();
1893+ CaffeModelParser modelParser;
1894+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_edges3");
1895+ 
1896+ ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("node1", "Relu");
1897+ op1->AddInputDesc(ge::GeTensorDesc());
1898+ op1->AddOutputDesc(ge::GeTensorDesc());
1899+ ge::NodePtr node1 = graph->AddNode(op1);
1900+ 
1901+ modelParser.top_blobs_map_["blob1"].emplace_back(std::make_pair("node1", 0));
1902+ modelParser.bottom_blobs_map_["blob1"].emplace_back(std::make_pair("nonexistent_bottom", 0));
1903+ modelParser.node_map["node1"] = node1;
1904+ 
1905+ Status ret = modelParser.AddEdges(graph);
1906+ EXPECT_EQ(ret, ge::FAILED);
1907+}
1908+ 
1909+TEST_F(UtestCaffeParser, CaffeModelParser_IsOutputTop_not_found) {
1910+ ParerUTestsUtils::ClearParserInnerCtx();
1911+ CaffeModelParser modelParser;
1912+ bool ret = modelParser.IsOutputTop("nonexistent_node", 0);
1913+ EXPECT_FALSE(ret);
1914+}
1915+ 
1916+TEST_F(UtestCaffeParser, CaffeModelParser_IsOutputTop_index_not_match) {
1917+ ParerUTestsUtils::ClearParserInnerCtx();
1918+ CaffeModelParser modelParser;
1919+ ge::GetParserContext().out_nodes_map["test_node"] = {1, 2, 3};
1920+ bool ret = modelParser.IsOutputTop("test_node", 0);
1921+ EXPECT_FALSE(ret);
1922+}
1923+ 
1924+TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_input_dim_and_shape_both_exist) {
1925+ CaffeModelParser modelParser;
1926+ domi::caffe::NetParameter net;
1927+ net.add_input("data");
1928+ net.add_input_dim(1);
1929+ net.add_input_dim(2);
1930+ net.add_input_dim(3);
1931+ net.add_input_dim(4);
1932+ net.add_input_shape();
1933+ bool input_data_flag = false;
1934+ Status ret = modelParser.ParseInput(net, input_data_flag);
1935+ EXPECT_EQ(ret, FAILED);
1936+}
1937+ 
1938+TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_input_dim_invalid_size) {
1939+ CaffeModelParser modelParser;
1940+ domi::caffe::NetParameter net;
1941+ net.add_input("data");
1942+ net.add_input_dim(1);
1943+ net.add_input_dim(2);
1944+ bool input_data_flag = false;
1945+ Status ret = modelParser.ParseInput(net, input_data_flag);
1946+ EXPECT_EQ(ret, FAILED);
1947+}
1948+ 
1949+TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_no_input_dim_no_shape) {
1950+ ParerUTestsUtils::ClearParserInnerCtx();
1951+ CaffeModelParser modelParser;
1952+ domi::caffe::NetParameter net;
1953+ net.add_input("data");
1954+ bool input_data_flag = false;
1955+ Status ret = modelParser.ParseInput(net, input_data_flag);
1956+ EXPECT_EQ(ret, FAILED);
1957+}
1958+ 
1959+TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_no_input_dim_no_shape_with_ctx) {
1960+ ParerUTestsUtils::ClearParserInnerCtx();
1961+ CaffeModelParser modelParser;
1962+ domi::caffe::NetParameter net;
1963+ net.add_input("data");
1964+ ge::GetParserContext().input_dims["data"] = {1, 3, 224, 224};
1965+ bool input_data_flag = false;
1966+ Status ret = modelParser.ParseInput(net, input_data_flag);
1967+ EXPECT_EQ(ret, SUCCESS);
1968+ EXPECT_TRUE(input_data_flag);
1969+}
1970+ 
1971+TEST_F(UtestCaffeParser, CaffeModelParser_AddTensorDescToOpDescByIr_netoutput) {
1972+ CaffeModelParser modelParser;
1973+ ge::OpDescPtr op_desc;
1974+ domi::caffe::LayerParameter layer;
1975+ layer.set_name("netoutput");
1976+ layer.set_type("NetOutput");
1977+ layer.add_bottom("input");
1978+ layer.add_top("output");
1979+ Status ret = modelParser.AddTensorDescToOpDescByIr(op_desc, layer, "NetOutput");
1980+ EXPECT_EQ(ret, SUCCESS);
1981+ EXPECT_NE(op_desc, nullptr);
1982+}
1983+ 
1984+TEST_F(UtestCaffeParser, CaffeModelParser_AddTensorDescToOpDescByIr_yolo) {
1985+ CaffeModelParser modelParser;
1986+ ge::OpDescPtr op_desc;
1987+ domi::caffe::LayerParameter layer;
1988+ layer.set_name("yolo");
1989+ layer.set_type("YoloDetectionOutput");
1990+ layer.add_bottom("input");
1991+ layer.add_top("output");
1992+ Status ret = modelParser.AddTensorDescToOpDescByIr(op_desc, layer, "YoloDetectionOutput");
1993+ EXPECT_EQ(ret, SUCCESS);
1994+ EXPECT_NE(op_desc, nullptr);
1995+}
1996+ 
1997+TEST_F(UtestCaffeParser, CaffeModelParser_PreCheck_success) {
1998+ CaffeModelParser modelParser;
1999+ domi::caffe::NetParameter net;
2000+ net.set_name("test_net");
2001+ auto *layer = net.add_layer();
2002+ layer->set_name("conv1");
2003+ layer->set_type("Convolution");
2004+ layer->add_bottom("data");
2005+ layer->add_top("conv1_out");
2006+ Status ret = modelParser.PreCheck(net);
2007+ EXPECT_NE(ret, FAILED);
2008+}
2009+ 
2010+TEST_F(UtestCaffeParser, CaffeModelParser_PreCheck_empty_name) {
2011+ CaffeModelParser modelParser;
2012+ domi::caffe::NetParameter net;
2013+ net.set_name("test_net");
2014+ auto *layer = net.add_layer();
2015+ layer->set_name("");
2016+ layer->set_type("Convolution");
2017+ Status ret = modelParser.PreCheck(net);
2018+ EXPECT_EQ(ret, FAILED);
2019+}
2020+ 
2021+TEST_F(UtestCaffeParser, CaffeModelParser_AddNode_unsupported_type) {
2022+ CaffeModelParser modelParser;
2023+ domi::caffe::NetParameter net;
2024+ domi::caffe::LayerParameter *layer = net.add_layer();
2025+ layer->set_name("unknown");
2026+ layer->set_type("UnknownOpType");
2027+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test");
2028+ Status ret = modelParser.AddNode(*layer, graph);
2029+ EXPECT_EQ(ret, FAILED);
2030+}
2031+ 
2032+TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseWeightByFusionProto_null) {
2033+ CaffeWeightsParser weightParser;
2034+ const char *weight_path = nullptr;
2035+ std::string fusion_proto_path = "test";
2036+ std::string fusion_proto_name = "test";
2037+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test");
2038+ Status ret = weightParser.ParseWeightByFusionProto(weight_path, fusion_proto_path, fusion_proto_name, graph);
2039+ EXPECT_EQ(ret, FAILED);
2040+}
1804} // namespace ge2041} // namespace ge
Mtests/parser/ut/parser/testcase/common/acl_graph_parser_unittest.cc+482-0
@@ -365,4 +365,486 @@ TEST_F(UtestAclGraphParser, test_ParseAclInputShape) {
365 ret = acl_graph_parse_util.ParseParamsBeforeGraph(param4, graph_name);365 ret = acl_graph_parse_util.ParseParamsBeforeGraph(param4, graph_name);
366 ASSERT_EQ(ret, SUCCESS);366 ASSERT_EQ(ret, SUCCESS);
367}367}
368+ 
369+TEST_F(UtestAclGraphParser, test_fp16_t_conversions) {
370+ parser::fp16_t fp16;
371+ fp16.val = 0x0001;
372+ float f = fp16;
373+ EXPECT_NE(f, 0.0f);
374+ 
375+ fp16.val = 0x8001;
376+ f = fp16;
377+ EXPECT_NE(f, 0.0f);
378+ 
379+ fp16.val = 0x3C00;
380+ f = fp16;
381+ EXPECT_FLOAT_EQ(f, 1.0f);
382+ 
383+ fp16.val = 0xBC00;
384+ f = fp16;
385+ EXPECT_FLOAT_EQ(f, -1.0f);
386+ 
387+ fp16.val = 0x4000;
388+ f = fp16;
389+ EXPECT_FLOAT_EQ(f, 2.0f);
390+ 
391+ fp16.val = 0x0000;
392+ f = fp16;
393+ EXPECT_FLOAT_EQ(f, 0.0f);
394+ 
395+ double d = fp16;
396+ EXPECT_FLOAT_EQ(d, 0.0);
397+ 
398+ fp16.val = 0x3C00;
399+ d = fp16;
400+ EXPECT_FLOAT_EQ(d, 1.0);
401+}
402+ 
403+TEST_F(UtestAclGraphParser, test_fp16_t_int_conversions) {
404+ parser::fp16_t fp16;
405+ fp16.val = 0x3C00;
406+ int8_t i8 = fp16;
407+ EXPECT_EQ(i8, 1);
408+ uint8_t ui8 = fp16;
409+ EXPECT_EQ(ui8, 1);
410+ int16_t i16 = fp16;
411+ EXPECT_EQ(i16, 1);
412+ uint16_t ui16 = fp16;
413+ EXPECT_EQ(ui16, 1);
414+ int32_t i32 = fp16;
415+ EXPECT_EQ(i32, 1);
416+ uint32_t ui32 = fp16;
417+ EXPECT_EQ(ui32, 1);
418+ 
419+ fp16.val = 0x4900;
420+ i8 = fp16;
421+ EXPECT_NE(i8, 0);
422+ ui8 = fp16;
423+ EXPECT_NE(ui8, 0);
424+ i16 = fp16;
425+ EXPECT_NE(i16, 0);
426+ ui16 = fp16;
427+ EXPECT_NE(ui16, 0);
428+ i32 = fp16;
429+ EXPECT_NE(i32, 0);
430+ ui32 = fp16;
431+ EXPECT_NE(ui32, 0);
432+ 
433+ fp16.val = 0x8900;
434+ i8 = fp16;
435+ ui8 = fp16;
436+ EXPECT_EQ(ui8, 0);
437+ i16 = fp16;
438+ ui16 = fp16;
439+ i32 = fp16;
440+ ui32 = fp16;
441+ EXPECT_EQ(ui32, 0);
442+ 
443+ fp16.val = 0x7C00;
444+ i8 = fp16;
445+ ui8 = fp16;
446+ i16 = fp16;
447+ ui16 = fp16;
448+ i32 = fp16;
449+ ui32 = fp16;
450+ EXPECT_NE(ui32, 0);
451+ 
452+ fp16.val = 0xFC00;
453+ i8 = fp16;
454+ ui8 = fp16;
455+ i16 = fp16;
456+ ui16 = fp16;
457+ i32 = fp16;
458+ ui32 = fp16;
459+ 
460+ fp16.val = 0x0001;
461+ i8 = fp16;
462+ ui8 = fp16;
463+ i16 = fp16;
464+ ui16 = fp16;
465+ i32 = fp16;
466+ ui32 = fp16;
467+ 
468+ fp16.val = 0x0000;
469+ i8 = fp16;
470+ ui8 = fp16;
471+ i16 = fp16;
472+ ui16 = fp16;
473+ i32 = fp16;
474+ ui32 = fp16;
475+ EXPECT_EQ(ui8, 0);
476+ EXPECT_EQ(ui16, 0);
477+ EXPECT_EQ(ui32, 0);
478+}
479+ 
480+TEST_F(UtestAclGraphParser, test_fp16_t_assignment) {
481+ parser::fp16_t fp16;
482+ 
483+ fp16 = 1.0f;
484+ EXPECT_EQ(fp16.val, 0x3C00);
485+ fp16 = -1.0f;
486+ EXPECT_EQ(fp16.val, 0xBC00);
487+ fp16 = 0.0f;
488+ EXPECT_EQ(fp16.val, 0x0000);
489+ fp16 = 2.0f;
490+ EXPECT_NE(fp16.val, 0);
491+ fp16 = 65504.0f;
492+ EXPECT_NE(fp16.val, 0);
493+ fp16 = -65504.0f;
494+ EXPECT_NE(fp16.val, 0);
495+ fp16 = 5.960464477539063e-08f;
496+ EXPECT_NE(fp16.val, 0);
497+ fp16 = 1.0e-40f;
498+ EXPECT_EQ(fp16.val, 0);
499+ 
500+ fp16 = (int8_t)1;
501+ EXPECT_NE(fp16.val, 0);
502+ fp16 = (int8_t)-1;
503+ EXPECT_NE(fp16.val, 0);
504+ fp16 = (int8_t)0;
505+ EXPECT_EQ(fp16.val, 0);
506+ fp16 = (int8_t)127;
507+ EXPECT_NE(fp16.val, 0);
508+ 
509+ fp16 = (uint8_t)1;
510+ EXPECT_NE(fp16.val, 0);
511+ fp16 = (uint8_t)0;
512+ EXPECT_EQ(fp16.val, 0);
513+ fp16 = (uint8_t)255;
514+ EXPECT_NE(fp16.val, 0);
515+ 
516+ fp16 = (int16_t)1;
517+ EXPECT_NE(fp16.val, 0);
518+ fp16 = (int16_t)-1;
519+ EXPECT_NE(fp16.val, 0);
520+ fp16 = (int16_t)0;
521+ EXPECT_EQ(fp16.val, 0);
522+ fp16 = (int16_t)256;
523+ EXPECT_NE(fp16.val, 0);
524+ fp16 = (int16_t)32767;
525+ EXPECT_NE(fp16.val, 0);
526+ 
527+ fp16 = (uint16_t)1;
528+ EXPECT_NE(fp16.val, 0);
529+ fp16 = (uint16_t)0;
530+ EXPECT_EQ(fp16.val, 0);
531+ fp16 = (uint16_t)65535;
532+ EXPECT_NE(fp16.val, 0);
533+ 
534+ fp16 = (int32_t)1;
535+ EXPECT_NE(fp16.val, 0);
536+ fp16 = (int32_t)-1;
537+ EXPECT_NE(fp16.val, 0);
538+ fp16 = (int32_t)0;
539+ EXPECT_EQ(fp16.val, 0);
540+ fp16 = (int32_t)65536;
541+ EXPECT_NE(fp16.val, 0);
542+ fp16 = (int32_t)2147483647;
543+ EXPECT_NE(fp16.val, 0);
544+ 
545+ fp16 = (uint32_t)1;
546+ EXPECT_NE(fp16.val, 0);
547+ fp16 = (uint32_t)0;
548+ EXPECT_EQ(fp16.val, 0);
549+ fp16 = (uint32_t)4294967295U;
550+ EXPECT_NE(fp16.val, 0);
551+ 
552+ fp16 = 1.0;
553+ EXPECT_NE(fp16.val, 0);
554+ fp16 = -1.0;
555+ EXPECT_NE(fp16.val, 0);
556+ fp16 = 0.0;
557+ EXPECT_EQ(fp16.val, 0);
558+ fp16 = 2.0;
559+ EXPECT_NE(fp16.val, 0);
560+ fp16 = 65504.0;
561+ EXPECT_NE(fp16.val, 0);
562+ fp16 = -65504.0;
563+ EXPECT_NE(fp16.val, 0);
564+ fp16 = 5.960464477539063e-08;
565+ EXPECT_NE(fp16.val, 0);
566+}
567+ 
568+TEST_F(UtestAclGraphParser, test_fp16_t_comparison) {
569+ parser::fp16_t a, b;
570+ a.val = 0x3C00;
571+ b.val = 0x4000;
572+ EXPECT_TRUE(a < b);
573+ EXPECT_FALSE(a > b);
574+ EXPECT_TRUE(b > a);
575+ EXPECT_TRUE(b >= a);
576+ EXPECT_TRUE(a <= b);
577+ EXPECT_TRUE(a != b);
578+ EXPECT_FALSE(a == b);
579+ 
580+ a.val = 0x3C00;
581+ b.val = 0x3C00;
582+ EXPECT_TRUE(a == b);
583+ EXPECT_FALSE(a != b);
584+ EXPECT_TRUE(a >= b);
585+ EXPECT_TRUE(a <= b);
586+ EXPECT_FALSE(a > b);
587+ EXPECT_FALSE(a < b);
588+ 
589+ a.val = 0x0000;
590+ b.val = 0x8000;
591+ EXPECT_TRUE(a == b);
592+ 
593+ a.val = 0x3C00;
594+ b.val = 0xBC00;
595+ EXPECT_TRUE(a > b);
596+ EXPECT_FALSE(a < b);
597+ 
598+ a.val = 0xBC00;
599+ b.val = 0x4000;
600+ EXPECT_TRUE(a < b);
601+}
602+ 
603+TEST_F(UtestAclGraphParser, test_fp16_t_isinf) {
604+ parser::fp16_t fp16;
605+ fp16.val = 0x7C00;
606+ EXPECT_EQ(fp16.IsInf(), 1);
607+ fp16.val = 0xFC00;
608+ EXPECT_EQ(fp16.IsInf(), -1);
609+ fp16.val = 0x3C00;
610+ EXPECT_EQ(fp16.IsInf(), 0);
611+ fp16.val = 0x0000;
612+ EXPECT_EQ(fp16.IsInf(), 0);
613+}
614+ 
615+TEST_F(UtestAclGraphParser, test_fp16_t_to_methods) {
616+ parser::fp16_t fp16;
617+ fp16.val = 0x3C00;
618+ EXPECT_FLOAT_EQ(fp16.ToFloat(), 1.0f);
619+ EXPECT_FLOAT_EQ(fp16.ToDouble(), 1.0);
620+ EXPECT_EQ(fp16.ToInt8(), 1);
621+ EXPECT_EQ(fp16.ToUInt8(), 1);
622+ EXPECT_EQ(fp16.ToInt16(), 1);
623+ EXPECT_EQ(fp16.ToUInt16(), 1);
624+ EXPECT_EQ(fp16.ToInt32(), 1);
625+ EXPECT_EQ(fp16.ToUInt32(), 1);
626+}
627+ 
628+TEST_F(UtestAclGraphParser, test_fp16_t_self_assignment) {
629+ parser::fp16_t fp16;
630+ fp16.val = 0x3C00;
631+ fp16 = fp16;
632+ EXPECT_EQ(fp16.val, 0x3C00);
633+}
634+ 
635+TEST_F(UtestAclGraphParser, test_fp16_t_int64_conversion) {
636+ parser::fp16_t fp16;
637+ fp16.val = 0x3C00;
638+ int64_t i64 = fp16;
639+ EXPECT_EQ(i64, 0);
640+ uint64_t ui64 = fp16;
641+ EXPECT_EQ(ui64, 0);
642+}
643+ 
644+TEST_F(UtestAclGraphParser, test_fp16_t_inequality_both_zero) {
645+ parser::fp16_t a, b;
646+ a.val = 0x0000;
647+ b.val = 0x8000;
648+ EXPECT_FALSE(a != b);
649+}
650+ 
651+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_set_output_node_info) {
652+ AclGraphParserUtil acl_graph_parse_util;
653+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_graph");
654+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
655+ std::map<AscendString, AscendString> parser_params;
656+ auto ret = acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params);
657+ EXPECT_NE(ret, FAILED);
658+}
659+ 
660+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_set_output_node_info_with_nodes) {
661+ ParerUTestsUtils::ClearParserInnerCtx();
662+ AclGraphParserUtil acl_graph_parse_util;
663+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_graph2");
664+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("output_node", "Relu");
665+ op->AddInputDesc(ge::GeTensorDesc());
666+ op->AddOutputDesc(ge::GeTensorDesc());
667+ ge::NodePtr node = compute_graph->AddNode(op);
668+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
669+ 
670+ ge::GetParserContext().user_out_nodes.push_back({"output_node", 0});
671+ std::map<AscendString, AscendString> parser_params;
672+ auto ret = acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params);
673+ EXPECT_EQ(ret, SUCCESS);
674+}
675+ 
676+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_parse_params_after_graph) {
677+ AclGraphParserUtil acl_graph_parse_util;
678+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_graph3");
679+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
680+ std::map<AscendString, AscendString> parser_params;
681+ auto ret = acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params);
682+ EXPECT_NE(ret, FAILED);
683+}
684+ 
685+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_parse_params_after_graph_with_options) {
686+ ParerUTestsUtils::ClearParserInnerCtx();
687+ AclGraphParserUtil acl_graph_parse_util;
688+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_graph4");
689+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("data1", "Data");
690+ op->AddInputDesc(ge::GeTensorDesc());
691+ op->AddOutputDesc(ge::GeTensorDesc());
692+ compute_graph->AddNode(op);
693+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
694+ 
695+ std::map<AscendString, AscendString> parser_params;
696+ parser_params[AscendString(ge::ir_option::INPUT_FP16_NODES)] = AscendString("data1");
697+ parser_params[AscendString(ge::ir_option::IS_INPUT_ADJUST_HW_LAYOUT)] = AscendString("false");
698+ parser_params[AscendString(ge::ir_option::IS_OUTPUT_ADJUST_HW_LAYOUT)] = AscendString("false");
699+ parser_params[AscendString(ge::ir_option::ENABLE_SCOPE_FUSION_PASSES)] = AscendString("pass1;pass2");
700+ auto ret = acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params);
701+ EXPECT_EQ(ret, SUCCESS);
702+}
703+ 
704+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_parse_params_before_graph_with_out_nodes) {
705+ ParerUTestsUtils::ClearParserInnerCtx();
706+ GetParserContext().type = domi::TENSORFLOW;
707+ AclGraphParserUtil acl_graph_parse_util;
708+ std::map<AscendString, AscendString> params = {
709+ {AscendString(ge::ir_option::OUT_NODES), AscendString("node1:0;node2:1")},
710+ {AscendString(ge::ir_option::OUTPUT), AscendString("node1:0")},
711+ {AscendString(ge::ir_option::INPUT_FP16_NODES), AscendString("data1")},
712+ {AscendString(ge::ir_option::IS_INPUT_ADJUST_HW_LAYOUT), AscendString("true")},
713+ {AscendString(ge::ir_option::IS_OUTPUT_ADJUST_HW_LAYOUT), AscendString("true")},
714+ {AscendString(ge::ir_option::ENABLE_SCOPE_FUSION_PASSES), AscendString("pass1")},
715+ {AscendString(ge::ir_option::INPUT_SHAPE), AscendString("data1:1,3,224,224")},
716+ {AscendString("invalid_key"), AscendString("value")}};
717+ string graph_name;
718+ auto ret = acl_graph_parse_util.ParseParamsBeforeGraph(params, graph_name);
719+ EXPECT_NE(ret, SUCCESS);
720+}
721+ 
722+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_parse_params_before_graph_invalid_out_nodes) {
723+ ParerUTestsUtils::ClearParserInnerCtx();
724+ GetParserContext().type = domi::TENSORFLOW;
725+ AclGraphParserUtil acl_graph_parse_util;
726+ std::map<AscendString, AscendString> params = {{AscendString(ge::ir_option::OUT_NODES), AscendString("node1:abc")}};
727+ string graph_name;
728+ auto ret = acl_graph_parse_util.ParseParamsBeforeGraph(params, graph_name);
729+ EXPECT_EQ(ret, PARAM_INVALID);
730+}
731+ 
732+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_parse_params_before_graph_out_nodes_overflow) {
733+ ParerUTestsUtils::ClearParserInnerCtx();
734+ GetParserContext().type = domi::TENSORFLOW;
735+ AclGraphParserUtil acl_graph_parse_util;
736+ std::map<AscendString, AscendString> params = {
737+ {AscendString(ge::ir_option::OUT_NODES), AscendString("node1:99999999999999999999")}};
738+ string graph_name;
739+ auto ret = acl_graph_parse_util.ParseParamsBeforeGraph(params, graph_name);
740+ EXPECT_EQ(ret, PARAM_INVALID);
741+}
742+ 
743+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_acl_parser_initialize) {
744+ AclGraphParserUtil acl_graph_parse_util;
745+ std::map<string, string> options;
746+ options.insert(std::pair<string, string>(string(ge::FRAMEWORK_TYPE), to_string(domi::TENSORFLOW)));
747+ auto ret = acl_graph_parse_util.AclParserInitialize(options);
748+ EXPECT_EQ(ret, SUCCESS);
749+}
750+ 
751+TEST_F(UtestAclGraphParser, test_proto_file_parser_parse_nonexistent) {
752+ ProtoFileParser op;
753+ std::map<int, std::pair<string, string>> identifier_op_map;
754+ std::map<std::string, std::pair<int, string>> op_identifier_map;
755+ auto ret = op.ParseProtoFile("nonexistent_file.proto", identifier_op_map, op_identifier_map);
756+ EXPECT_EQ(ret, FAILED);
757+}
758+ 
759+TEST_F(UtestAclGraphParser, test_proto_file_parser_find_conflict_line_nonexistent) {
760+ ProtoFileParser op;
761+ std::string dest_line;
762+ auto ret = op.FindConflictLine("nonexistent_file.proto", 1, dest_line);
763+ EXPECT_EQ(ret, FAILED);
764+}
765+ 
766+TEST_F(UtestAclGraphParser, test_proto_file_parser_record_proto_message_nonexistent) {
767+ ProtoFileParser op;
768+ auto ret = op.RecordProtoMessage("nonexistent_file.proto");
769+ EXPECT_EQ(ret, FAILED);
770+}
771+ 
772+TEST_F(UtestAclGraphParser, test_proto_file_parser_combine_proto_nonexistent) {
773+ ProtoFileParser op;
774+ std::string dest_proto_file;
775+ auto ret = op.CombineProtoFile("nonexistent_caffe.proto", "nonexistent_custom.proto", dest_proto_file);
776+ EXPECT_EQ(ret, FAILED);
777+}
778+ 
779+TEST_F(UtestAclGraphParser, test_proto_file_parser_combine_multi_custom_nonexistent) {
780+ ProtoFileParser op("fusion_test.proto");
781+ std::string dest_proto_file;
782+ auto ret =
783+ op.CombineProtoFileMultiCustomProto("nonexistent_caffe.proto", "nonexistent_custom.proto", dest_proto_file);
784+ EXPECT_EQ(ret, FAILED);
785+}
786+ 
787+TEST_F(UtestAclGraphParser, test_proto_file_parser_add_custom_and_conflict_layer_nonexistent) {
788+ ProtoFileParser op;
789+ std::ofstream write_tmp;
790+ write_tmp.open("test_write_tmp.proto", std::ios::out);
791+ auto ret = op.AddCustomAndConflictLayer("nonexistent_custom.proto", write_tmp);
792+ EXPECT_EQ(ret, FAILED);
793+ write_tmp.close();
794+ remove("test_write_tmp.proto");
795+}
796+ 
797+TEST_F(UtestAclGraphParser, test_proto_file_parser_add_custom_and_conflict_message_nonexistent) {
798+ ProtoFileParser op;
799+ std::ofstream write_tmp;
800+ write_tmp.open("test_write_tmp2.proto", std::ios::out);
801+ auto ret = op.AddCustomAndConflictMessage("nonexistent_custom.proto", write_tmp);
802+ EXPECT_EQ(ret, FAILED);
803+ write_tmp.close();
804+ remove("test_write_tmp2.proto");
805+}
806+ 
807+TEST_F(UtestAclGraphParser, test_proto_file_parser_reset_and_set) {
808+ ProtoFileParser op("test_fusion.proto");
809+ op.ResetParserStatus(true);
810+ op.SetFusionProtoPath("test_path");
811+ EXPECT_EQ(op.GetFusionProtoFile(), "test_path");
812+ auto path = op.ResetFusionProtoPath();
813+ EXPECT_EQ(path, "test_path");
814+ EXPECT_EQ(op.GetFusionProtoFile(), "");
815+}
816+ 
817+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_input_fp16_nodes_with_data) {
818+ ParerUTestsUtils::ClearParserInnerCtx();
819+ AclGraphParserUtil acl_graph_parse_util;
820+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_fp16");
821+ ge::OpDescPtr data_op = std::make_shared<ge::OpDesc>("data_fp16", "Data");
822+ data_op->AddInputDesc(ge::GeTensorDesc());
823+ data_op->AddOutputDesc(ge::GeTensorDesc());
824+ compute_graph->AddNode(data_op);
825+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
826+ 
827+ std::map<AscendString, AscendString> parser_params;
828+ parser_params[AscendString(ge::ir_option::INPUT_FP16_NODES)] = AscendString("data_fp16");
829+ parser_params[AscendString(ge::ir_option::IS_INPUT_ADJUST_HW_LAYOUT)] = AscendString("true");
830+ auto ret = acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params);
831+ EXPECT_EQ(ret, SUCCESS);
832+}
833+ 
834+TEST_F(UtestAclGraphParser, test_acl_graph_parser_util_input_fp16_nodes_not_data) {
835+ ParerUTestsUtils::ClearParserInnerCtx();
836+ AclGraphParserUtil acl_graph_parse_util;
837+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_fp16_not_data");
838+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("not_data", "Relu");
839+ op->AddInputDesc(ge::GeTensorDesc());
840+ op->AddOutputDesc(ge::GeTensorDesc());
841+ compute_graph->AddNode(op);
842+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
843+ 
844+ std::map<AscendString, AscendString> parser_params;
845+ parser_params[AscendString(ge::ir_option::INPUT_FP16_NODES)] = AscendString("not_data");
846+ parser_params[AscendString(ge::ir_option::IS_INPUT_ADJUST_HW_LAYOUT)] = AscendString("true");
847+ auto ret = acl_graph_parse_util.ParseParamsAfterGraph(graph, parser_params);
848+ EXPECT_EQ(ret, PARAM_INVALID);
849+}
368} // namespace ge850} // namespace ge
Mtests/parser/ut/parser/testcase/graph_optimizer_testcase/graph_optimizer_unittest.cc+90-0
@@ -17,6 +17,8 @@
17#include "tensorflow/iterator_fusion_pass.h"17#include "tensorflow/iterator_fusion_pass.h"
18#include "parser/common/acl_graph_parser_util.h"18#include "parser/common/acl_graph_parser_util.h"
19#include "tensorflow/parser_graph_optimizer.h"19#include "tensorflow/parser_graph_optimizer.h"
20+#include "graph/utils/graph_utils.h"
21+#include "graph/utils/op_desc_utils.h"
20 22 
21namespace ge {23namespace ge {
22class UtestGraphOptimizer : public testing::Test {24class UtestGraphOptimizer : public testing::Test {
@@ -66,4 +68,92 @@ TEST_F(UtestGraphOptimizer, graph_optimizer_output) {
66 EXPECT_NE(parserGraphOptimizer.RebuildInputAnchors(input_anchors, fusion_op_desc), ge::SUCCESS);68 EXPECT_NE(parserGraphOptimizer.RebuildInputAnchors(input_anchors, fusion_op_desc), ge::SUCCESS);
67 EXPECT_NE(parserGraphOptimizer.RebuildOutputAnchors(output_anchors, fusion_op_desc), ge::SUCCESS);69 EXPECT_NE(parserGraphOptimizer.RebuildOutputAnchors(output_anchors, fusion_op_desc), ge::SUCCESS);
68}70}
71+ 
72+TEST_F(UtestGraphOptimizer, graph_optimizer_rebuild_anchors_with_data) {
73+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_graph");
74+ ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("node1", "Relu");
75+ op1->AddInputDesc("x", ge::GeTensorDesc());
76+ op1->AddOutputDesc("y", ge::GeTensorDesc());
77+ ge::NodePtr node1 = graph->AddNode(op1);
78+ 
79+ ge::OpDescPtr op2 = std::make_shared<ge::OpDesc>("node2", "Relu");
80+ op2->AddInputDesc("x", ge::GeTensorDesc());
81+ op2->AddOutputDesc("y", ge::GeTensorDesc());
82+ ge::NodePtr node2 = graph->AddNode(op2);
83+ 
84+ ge::GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
85+ 
86+ domi::FrameworkType type = domi::TENSORFLOW;
87+ ge::ParserGraphOptimizer parserGraphOptimizer(graph, type);
88+ 
89+ vector<ge::OutDataAnchorPtr> output_anchors = {node1->GetOutDataAnchor(0)};
90+ ge::OpDescPtr fusion_op_desc = std::make_shared<ge::OpDesc>("fusion", "Relu");
91+ auto ret = parserGraphOptimizer.RebuildOutputAnchors(output_anchors, fusion_op_desc);
92+ EXPECT_EQ(ret, ge::SUCCESS);
93+ 
94+ vector<ge::InDataAnchorPtr> input_anchors = {node2->GetInDataAnchor(0)};
95+ fusion_op_desc = std::make_shared<ge::OpDesc>("fusion", "Relu");
96+ ret = parserGraphOptimizer.RebuildInputAnchors(input_anchors, fusion_op_desc);
97+ EXPECT_EQ(ret, ge::SUCCESS);
98+}
99+ 
100+TEST_F(UtestGraphOptimizer, graph_optimizer_fusion_fmkop_empty) {
101+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("empty_graph");
102+ domi::FrameworkType type = domi::TENSORFLOW;
103+ ge::ParserGraphOptimizer parserGraphOptimizer(graph, type);
104+ auto ret = parserGraphOptimizer.FusionFmkop();
105+ EXPECT_EQ(ret, ge::SUCCESS);
106+}
107+ 
108+TEST_F(UtestGraphOptimizer, graph_optimizer_mark_for_fusion) {
109+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("fusion_graph");
110+ ge::OpDescPtr iter_op = std::make_shared<ge::OpDesc>("iter", ge::parser::FRAMEWORKOP);
111+ iter_op->AddInputDesc(ge::GeTensorDesc());
112+ iter_op->AddOutputDesc(ge::GeTensorDesc());
113+ ge::AttrUtils::SetStr(iter_op, ge::ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, "IteratorV2");
114+ ge::NodePtr iter_node = graph->AddNode(iter_op);
115+ 
116+ domi::FrameworkType type = domi::TENSORFLOW;
117+ ge::ParserGraphOptimizer parserGraphOptimizer(graph, type);
118+ std::unordered_map<std::string, std::vector<ge::NodePtr>> node_cluster_map;
119+ auto ret = parserGraphOptimizer.MarkForFusion(node_cluster_map);
120+ EXPECT_EQ(ret, ge::SUCCESS);
121+}
122+ 
123+TEST_F(UtestGraphOptimizer, graph_optimizer_find_fmk_node_cluster) {
124+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("cluster_graph");
125+ ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("fmk1", ge::parser::FRAMEWORKOP);
126+ op1->AddInputDesc(ge::GeTensorDesc());
127+ op1->AddOutputDesc(ge::GeTensorDesc());
128+ ge::NodePtr node1 = graph->AddNode(op1);
129+ 
130+ ge::OpDescPtr op2 = std::make_shared<ge::OpDesc>("fmk2", ge::parser::FRAMEWORKOP);
131+ op2->AddInputDesc(ge::GeTensorDesc());
132+ op2->AddOutputDesc(ge::GeTensorDesc());
133+ ge::NodePtr node2 = graph->AddNode(op2);
134+ 
135+ ge::OpDescPtr op3 = std::make_shared<ge::OpDesc>("data1", ge::parser::DATA_TYPE);
136+ op3->AddInputDesc(ge::GeTensorDesc());
137+ op3->AddOutputDesc(ge::GeTensorDesc());
138+ ge::NodePtr node3 = graph->AddNode(op3);
139+ 
140+ domi::FrameworkType type = domi::TENSORFLOW;
141+ ge::ParserGraphOptimizer parserGraphOptimizer(graph, type);
142+ std::unordered_map<std::string, std::vector<ge::NodePtr>> node_cluster_map;
143+ auto ret = parserGraphOptimizer.FindFmkNodeCluser(node_cluster_map);
144+ EXPECT_EQ(ret, ge::SUCCESS);
145+}
146+ 
147+TEST_F(UtestGraphOptimizer, graph_optimizer_dyn_get_next) {
148+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("dyn_graph");
149+ ge::OpDescPtr dyn_op = std::make_shared<ge::OpDesc>("dyn_getnext", "DynamicGetNext");
150+ dyn_op->AddInputDesc(ge::GeTensorDesc());
151+ dyn_op->AddOutputDesc(ge::GeTensorDesc());
152+ ge::NodePtr dyn_node = graph->AddNode(dyn_op);
153+ 
154+ domi::FrameworkType type = domi::TENSORFLOW;
155+ ge::ParserGraphOptimizer parserGraphOptimizer(graph, type);
156+ auto ret = parserGraphOptimizer.FusionFmkop();
157+ EXPECT_EQ(ret, ge::SUCCESS);
158+}
69} // namespace ge159} // namespace ge
Mtests/parser/ut/parser/testcase/onnx_parser_testcase/message2operator_unittest.cc+97-0
@@ -15,6 +15,7 @@
15 15 
16#include "proto/onnx/ge_onnx.pb.h"16#include "proto/onnx/ge_onnx.pb.h"
17#include "parser/common/convert/pb2json.h"17#include "parser/common/convert/pb2json.h"
18+#include "proto/caffe/caffe.pb.h"
18 19 
19namespace ge {20namespace ge {
20class UtestMessage2Operator : public testing::Test {21class UtestMessage2Operator : public testing::Test {
@@ -99,4 +100,100 @@ TEST_F(UtestMessage2Operator, enum_to_json_success) {
99 ge::Pb2Json::EnumJson2Json(json);100 ge::Pb2Json::EnumJson2Json(json);
100 EXPECT_NE(json.size(), 0U);101 EXPECT_NE(json.size(), 0U);
101}102}
103+ 
104+TEST_F(UtestMessage2Operator, message_to_operator_int64_field) {
105+ ge::onnx::NodeProto input_node;
106+ ge::onnx::AttributeProto *attribute = input_node.add_attribute();
107+ attribute->set_name("int_attr");
108+ attribute->set_type(onnx::AttributeProto::AttributeType(2));
109+ attribute->set_i(42);
110+ ge::Operator op_src("add", "Add");
111+ auto ret = Message2Operator::ParseOperatorAttrs(attribute, 1, op_src);
112+ EXPECT_EQ(ret, SUCCESS);
113+}
114+ 
115+TEST_F(UtestMessage2Operator, message_to_operator_string_field) {
116+ ge::onnx::NodeProto input_node;
117+ ge::onnx::AttributeProto *attribute = input_node.add_attribute();
118+ attribute->set_name("str_attr");
119+ attribute->set_type(onnx::AttributeProto::AttributeType(3));
120+ attribute->set_s("hello");
121+ ge::Operator op_src("add", "Add");
122+ auto ret = Message2Operator::ParseOperatorAttrs(attribute, 1, op_src);
123+ EXPECT_EQ(ret, SUCCESS);
124+}
125+ 
126+TEST_F(UtestMessage2Operator, message_to_operator_repeated_float_field) {
127+ ge::onnx::NodeProto input_node;
128+ ge::onnx::AttributeProto *attribute = input_node.add_attribute();
129+ attribute->set_name("floats_attr");
130+ attribute->add_floats(1.0f);
131+ attribute->add_floats(2.0f);
132+ ge::Operator op_src("add", "Add");
133+ auto ret = Message2Operator::ParseOperatorAttrs(attribute, 1, op_src);
134+ EXPECT_EQ(ret, SUCCESS);
135+}
136+ 
137+TEST_F(UtestMessage2Operator, message_to_operator_repeated_int32_field) {
138+ ge::onnx::TensorProto tensor;
139+ tensor.add_int32_data(10);
140+ tensor.add_int32_data(20);
141+ ge::Operator op_src("add", "Add");
142+ auto ret = Message2Operator::ParseOperatorAttrs(&tensor, 1, op_src);
143+ EXPECT_EQ(ret, SUCCESS);
144+}
145+ 
146+TEST_F(UtestMessage2Operator, message_to_operator_repeated_float_via_tensor) {
147+ ge::onnx::TensorProto tensor;
148+ tensor.add_float_data(1.0f);
149+ tensor.add_float_data(2.0f);
150+ ge::Operator op_src("add", "Add");
151+ auto ret = Message2Operator::ParseOperatorAttrs(&tensor, 1, op_src);
152+ EXPECT_EQ(ret, SUCCESS);
153+}
154+ 
155+TEST_F(UtestMessage2Operator, message_to_operator_uint32_field) {
156+ domi::caffe::ConvolutionParameter conv_param;
157+ conv_param.set_num_output(64U);
158+ ge::Operator op_src("conv", "Convolution");
159+ auto ret = Message2Operator::ParseOperatorAttrs(&conv_param, 1, op_src);
160+ EXPECT_EQ(ret, SUCCESS);
161+}
162+ 
163+TEST_F(UtestMessage2Operator, message_to_operator_bool_field) {
164+ domi::caffe::ConvolutionParameter conv_param;
165+ conv_param.set_bias_term(true);
166+ conv_param.set_num_output(32U);
167+ ge::Operator op_src("conv", "Convolution");
168+ auto ret = Message2Operator::ParseOperatorAttrs(&conv_param, 1, op_src);
169+ EXPECT_EQ(ret, SUCCESS);
170+}
171+ 
172+TEST_F(UtestMessage2Operator, message_to_operator_repeated_float_via_caffe_blob) {
173+ domi::caffe::BlobProto blob;
174+ blob.add_data(1.0f);
175+ blob.add_data(2.0f);
176+ ge::Operator op_src("blob", "Blob");
177+ auto ret = Message2Operator::ParseOperatorAttrs(&blob, 1, op_src);
178+ EXPECT_EQ(ret, SUCCESS);
179+}
180+ 
181+TEST_F(UtestMessage2Operator, message_to_operator_repeated_int32_via_caffe_blob) {
182+ domi::caffe::BlobProto blob;
183+ blob.add_int32_data(10);
184+ blob.add_int32_data(20);
185+ ge::Operator op_src("blob", "Blob");
186+ auto ret = Message2Operator::ParseOperatorAttrs(&blob, 1, op_src);
187+ EXPECT_EQ(ret, SUCCESS);
188+}
189+ 
190+TEST_F(UtestMessage2Operator, message_to_operator_repeated_message_field) {
191+ ge::onnx::NodeProto input_node;
192+ ge::onnx::AttributeProto *attribute = input_node.add_attribute();
193+ attribute->set_name("tensors_attr");
194+ attribute->mutable_tensors()->Add();
195+ ge::Operator op_src("add", "Add");
196+ auto ret = Message2Operator::ParseOperatorAttrs(attribute, 1, op_src);
197+ EXPECT_EQ(ret, SUCCESS);
198+}
102} // namespace ge199} // namespace ge
Mtests/parser/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc+284-0
@@ -27,6 +27,9 @@
27#include "parser/onnx/onnx_file_constant_parser.h"27#include "parser/onnx/onnx_file_constant_parser.h"
28#include "parser/onnx/onnx_util.h"28#include "parser/onnx/onnx_util.h"
29#include "parser/onnx/onnx_parser_internal.h"29#include "parser/onnx/onnx_parser_internal.h"
30+#include "graph/utils/attr_utils.h"
31+#include "graph/debug/ge_attr_define.h"
32+#include "graph/utils/graph_utils.h"
30 33 
31namespace ge {34namespace ge {
32class UtestOnnxParser : public testing::Test {35class UtestOnnxParser : public testing::Test {
@@ -1426,4 +1429,285 @@ TEST_F(UtestOnnxParser, onnx_test_no_input_op_in_root_graph) {
1426 auto node_found = compute_graph->FindNode("RandomNormal_0");1429 auto node_found = compute_graph->FindNode("RandomNormal_0");
1427 EXPECT_NE(node_found, nullptr);1430 EXPECT_NE(node_found, nullptr);
1428}1431}
1432+ 
1433+TEST_F(UtestOnnxParser, auto_mapping_subgraph_with_output_nodes) {
1434+ auto compute_graph = std::make_shared<ge::ComputeGraph>("test_auto_map_out");
1435+ auto data_op = std::make_shared<ge::OpDesc>("data_out_1", "Data");
1436+ data_op->AddInputDesc(ge::GeTensorDesc());
1437+ data_op->AddOutputDesc(ge::GeTensorDesc());
1438+ ge::AttrUtils::SetInt(data_op, ge::ATTR_NAME_INDEX, 0);
1439+ auto data_node = compute_graph->AddNode(data_op);
1440+ 
1441+ auto netoutput_op = std::make_shared<ge::OpDesc>("netoutput_out_1", "NetOutput");
1442+ netoutput_op->AddInputDesc(ge::GeTensorDesc());
1443+ netoutput_op->AddOutputDesc(ge::GeTensorDesc());
1444+ auto netoutput_node = compute_graph->AddNode(netoutput_op);
1445+ 
1446+ ge::GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), netoutput_node->GetInDataAnchor(0));
1447+ compute_graph->AddOutputNodeByIndex(netoutput_node, 0);
1448+ 
1449+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
1450+ auto func = domi::FrameworkRegistry::Instance().GetAutoMappingSubgraphIOIndexFunc(domi::ONNX);
1451+ ASSERT_NE(func, nullptr);
1452+ auto ret = func(
1453+ graph,
1454+ [&](int data_index, int &parent_index) -> Status {
1455+ parent_index = data_index;
1456+ return SUCCESS;
1457+ },
1458+ [&](int output_index, int &parent_index) -> Status {
1459+ parent_index = output_index;
1460+ return SUCCESS;
1461+ });
1462+ EXPECT_EQ(ret, SUCCESS);
1463+}
1464+ 
1465+TEST_F(UtestOnnxParser, auto_mapping_subgraph_data_without_index_attr) {
1466+ auto compute_graph = std::make_shared<ge::ComputeGraph>("test_auto_map_no_idx");
1467+ auto data_op = std::make_shared<ge::OpDesc>("data_no_idx", "Data");
1468+ data_op->AddInputDesc(ge::GeTensorDesc());
1469+ data_op->AddOutputDesc(ge::GeTensorDesc());
1470+ compute_graph->AddNode(data_op);
1471+ 
1472+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
1473+ auto func = domi::FrameworkRegistry::Instance().GetAutoMappingSubgraphIOIndexFunc(domi::ONNX);
1474+ ASSERT_NE(func, nullptr);
1475+ auto ret = func(
1476+ graph,
1477+ [&](int data_index, int &parent_index) -> Status {
1478+ parent_index = data_index;
1479+ return SUCCESS;
1480+ },
1481+ [&](int output_index, int &parent_index) -> Status {
1482+ parent_index = output_index;
1483+ return SUCCESS;
1484+ });
1485+ EXPECT_EQ(ret, FAILED);
1486+}
1487+ 
1488+TEST_F(UtestOnnxParser, auto_mapping_subgraph_input_callback_failure) {
1489+ auto compute_graph = std::make_shared<ge::ComputeGraph>("test_auto_map_cb_fail");
1490+ auto data_op = std::make_shared<ge::OpDesc>("data_cb_fail", "Data");
1491+ data_op->AddInputDesc(ge::GeTensorDesc());
1492+ data_op->AddOutputDesc(ge::GeTensorDesc());
1493+ ge::AttrUtils::SetInt(data_op, ge::ATTR_NAME_INDEX, 0);
1494+ compute_graph->AddNode(data_op);
1495+ 
1496+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
1497+ auto func = domi::FrameworkRegistry::Instance().GetAutoMappingSubgraphIOIndexFunc(domi::ONNX);
1498+ ASSERT_NE(func, nullptr);
1499+ auto ret = func(
1500+ graph, [&](int data_index, int &parent_index) -> Status { return FAILED; },
1501+ [&](int output_index, int &parent_index) -> Status {
1502+ parent_index = output_index;
1503+ return SUCCESS;
1504+ });
1505+ EXPECT_EQ(ret, FAILED);
1506+}
1507+ 
1508+TEST_F(UtestOnnxParser, auto_mapping_subgraph_output_callback_failure) {
1509+ auto compute_graph = std::make_shared<ge::ComputeGraph>("test_auto_map_out_cb_fail");
1510+ auto data_op = std::make_shared<ge::OpDesc>("data_out_cb", "Data");
1511+ data_op->AddInputDesc(ge::GeTensorDesc());
1512+ data_op->AddOutputDesc(ge::GeTensorDesc());
1513+ ge::AttrUtils::SetInt(data_op, ge::ATTR_NAME_INDEX, 0);
1514+ auto data_node = compute_graph->AddNode(data_op);
1515+ 
1516+ auto netoutput_op = std::make_shared<ge::OpDesc>("netoutput_cb", "NetOutput");
1517+ netoutput_op->AddInputDesc(ge::GeTensorDesc());
1518+ netoutput_op->AddOutputDesc(ge::GeTensorDesc());
1519+ auto netoutput_node = compute_graph->AddNode(netoutput_op);
1520+ 
1521+ ge::GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), netoutput_node->GetInDataAnchor(0));
1522+ compute_graph->AddOutputNodeByIndex(netoutput_node, 0);
1523+ 
1524+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
1525+ auto func = domi::FrameworkRegistry::Instance().GetAutoMappingSubgraphIOIndexFunc(domi::ONNX);
1526+ ASSERT_NE(func, nullptr);
1527+ auto ret = func(
1528+ graph,
1529+ [&](int data_index, int &parent_index) -> Status {
1530+ parent_index = data_index;
1531+ return SUCCESS;
1532+ },
1533+ [&](int output_index, int &parent_index) -> Status { return FAILED; });
1534+ EXPECT_EQ(ret, FAILED);
1535+}
1536+ 
1537+TEST_F(UtestOnnxParser, auto_mapping_subgraph_null_input_output) {
1538+ ge::Graph graph;
1539+ auto func = domi::FrameworkRegistry::Instance().GetAutoMappingSubgraphIOIndexFunc(domi::ONNX);
1540+ ASSERT_NE(func, nullptr);
1541+ std::function<Status(int, int &)> null_input = nullptr;
1542+ std::function<Status(int, int &)> null_output = nullptr;
1543+ auto ret = func(graph, null_input, null_output);
1544+ EXPECT_NE(ret, SUCCESS);
1545+}
1546+ 
1547+TEST_F(UtestOnnxParser, aclgrphParseONNX_null_file) {
1548+ std::map<AscendString, AscendString> parser_params;
1549+ ge::Graph graph;
1550+ auto ret = aclgrphParseONNX(nullptr, parser_params, graph);
1551+ EXPECT_NE(ret, SUCCESS);
1552+}
1553+ 
1554+TEST_F(UtestOnnxParser, aclgrphParseONNX_invalid_file) {
1555+ std::map<AscendString, AscendString> parser_params;
1556+ ge::Graph graph;
1557+ auto ret = aclgrphParseONNX("nonexistent_model.onnx", parser_params, graph);
1558+ EXPECT_NE(ret, SUCCESS);
1559+}
1560+ 
1561+TEST_F(UtestOnnxParser, aclgrphParseONNX_with_params_null_file) {
1562+ std::map<AscendString, AscendString> parser_params;
1563+ ge::Graph graph;
1564+ auto ret = aclgrphParseONNX(nullptr, parser_params, graph);
1565+ EXPECT_NE(ret, SUCCESS);
1566+}
1567+ 
1568+TEST_F(UtestOnnxParser, aclgrphParseONNX_with_params_invalid_file) {
1569+ std::map<AscendString, AscendString> parser_params;
1570+ ge::Graph graph;
1571+ auto ret = aclgrphParseONNX("nonexistent_model2.onnx", parser_params, graph);
1572+ EXPECT_NE(ret, SUCCESS);
1573+}
1574+ 
1575+TEST_F(UtestOnnxParser, onnx_parser_to_json_invalid) {
1576+ OnnxModelParser parser;
1577+ auto ret = parser.ToJson("nonexistent_model.onnx", "output.json");
1578+ EXPECT_NE(ret, SUCCESS);
1579+}
1580+ 
1581+TEST_F(UtestOnnxParser, onnx_parser_to_json_null) {
1582+ OnnxModelParser parser;
1583+ auto ret = parser.ToJson(nullptr, "output.json");
1584+ EXPECT_NE(ret, SUCCESS);
1585+ ret = parser.ToJson("model.onnx", nullptr);
1586+ EXPECT_NE(ret, SUCCESS);
1587+}
1588+ 
1589+TEST_F(UtestOnnxParser, onnx_parser_parse_from_memory_null) {
1590+ OnnxModelParser parser;
1591+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test");
1592+ auto ret = parser.ParseFromMemory(nullptr, 0, graph);
1593+ EXPECT_EQ(ret, SUCCESS);
1594+}
1595+ 
1596+TEST_F(UtestOnnxParser, onnx_model_parse_empty_graph) {
1597+ ge::onnx::ModelProto model_proto;
1598+ ge::onnx::OperatorSetIdProto *op_st = model_proto.add_opset_import();
1599+ op_st->set_domain("ai.onnx");
1600+ op_st->set_version(11);
1601+ model_proto.mutable_graph();
1602+ OnnxModelParser model_parser;
1603+ ge::Graph root_graph("test_empty");
1604+ auto ret = model_parser.ModelParseToGraph(model_proto, root_graph);
1605+ EXPECT_NE(ret, SUCCESS);
1606+}
1607+ 
1608+TEST_F(UtestOnnxParser, onnx_model_parse_with_const_node) {
1609+ ge::onnx::ModelProto model_proto;
1610+ ge::onnx::OperatorSetIdProto *op_st = model_proto.add_opset_import();
1611+ op_st->set_domain("ai.onnx");
1612+ op_st->set_version(11);
1613+ auto *graph = model_proto.mutable_graph();
1614+ auto *node = graph->add_node();
1615+ node->set_name("const_0");
1616+ node->set_op_type("Constant");
1617+ auto *attr = node->add_attribute();
1618+ attr->set_name("value");
1619+ attr->set_type(ge::onnx::AttributeProto::TENSOR);
1620+ auto *tensor = attr->mutable_t();
1621+ tensor->set_data_type(1);
1622+ tensor->add_dims(1);
1623+ node->add_output("const_output");
1624+ 
1625+ OnnxModelParser model_parser;
1626+ ge::Graph root_graph("test_const");
1627+ auto ret = model_parser.ModelParseToGraph(model_proto, root_graph);
1628+ EXPECT_NE(ret, SUCCESS);
1629+}
1630+ 
1631+TEST_F(UtestOnnxParser, onnx_model_parse_with_unsupported_op) {
1632+ ge::onnx::ModelProto model_proto;
1633+ ge::onnx::OperatorSetIdProto *op_st = model_proto.add_opset_import();
1634+ op_st->set_domain("ai.onnx");
1635+ op_st->set_version(11);
1636+ auto *graph = model_proto.mutable_graph();
1637+ auto *node = graph->add_node();
1638+ node->set_name("unsupported_0");
1639+ node->set_op_type("UnsupportedOpType");
1640+ node->add_input("input");
1641+ node->add_output("output");
1642+ 
1643+ ge::onnx::ValueInfoProto *input = graph->add_input();
1644+ input->set_name("input");
1645+ auto tensor_type = input->mutable_type()->mutable_tensor_type();
1646+ tensor_type->set_elem_type(1);
1647+ 
1648+ OnnxModelParser model_parser;
1649+ ge::Graph root_graph("test_unsupported");
1650+ auto ret = model_parser.ModelParseToGraph(model_proto, root_graph);
1651+ EXPECT_NE(ret, SUCCESS);
1652+}
1653+ 
1654+TEST_F(UtestOnnxParser, onnx_parser_clear_and_error) {
1655+ OnnxModelParser parser;
1656+ parser.Clear();
1657+ EXPECT_FALSE(parser.HasError());
1658+}
1659+ 
1660+TEST_F(UtestOnnxParser, onnx_model_parse_with_initializer) {
1661+ ge::onnx::ModelProto model_proto;
1662+ ge::onnx::OperatorSetIdProto *op_st = model_proto.add_opset_import();
1663+ op_st->set_domain("ai.onnx");
1664+ op_st->set_version(11);
1665+ auto *graph = model_proto.mutable_graph();
1666+ auto *initializer = graph->add_initializer();
1667+ initializer->set_name("init_0");
1668+ initializer->set_data_type(1);
1669+ initializer->add_dims(2);
1670+ initializer->add_dims(3);
1671+ initializer->set_raw_data("\001\002\003\004\005\006");
1672+ 
1673+ OnnxModelParser model_parser;
1674+ ge::Graph root_graph("test_init");
1675+ auto ret = model_parser.ModelParseToGraph(model_proto, root_graph);
1676+ EXPECT_NE(ret, SUCCESS);
1677+}
1678+ 
1679+TEST_F(UtestOnnxParser, onnx_model_parse_with_multiple_inputs) {
1680+ ge::onnx::ModelProto model_proto;
1681+ ge::onnx::OperatorSetIdProto *op_st = model_proto.add_opset_import();
1682+ op_st->set_domain("ai.onnx");
1683+ op_st->set_version(11);
1684+ auto *graph = model_proto.mutable_graph();
1685+ 
1686+ ge::onnx::ValueInfoProto *input1 = graph->add_input();
1687+ input1->set_name("X1");
1688+ auto tensor_type1 = input1->mutable_type()->mutable_tensor_type();
1689+ tensor_type1->set_elem_type(1);
1690+ 
1691+ ge::onnx::ValueInfoProto *input2 = graph->add_input();
1692+ input2->set_name("X2");
1693+ auto tensor_type2 = input2->mutable_type()->mutable_tensor_type();
1694+ tensor_type2->set_elem_type(1);
1695+ 
1696+ ge::onnx::ValueInfoProto *output = graph->add_output();
1697+ output->set_name("Y");
1698+ auto tensor_type_y = output->mutable_type()->mutable_tensor_type();
1699+ tensor_type_y->set_elem_type(1);
1700+ 
1701+ auto *node = graph->add_node();
1702+ node->set_name("add_0");
1703+ node->set_op_type("Add");
1704+ node->add_input("X1");
1705+ node->add_input("X2");
1706+ node->add_output("Y");
1707+ 
1708+ OnnxModelParser model_parser;
1709+ ge::Graph root_graph("test_multi_input");
1710+ auto ret = model_parser.ModelParseToGraph(model_proto, root_graph);
1711+ EXPECT_EQ(ret, SUCCESS);
1712+}
1429} // namespace ge1713} // namespace ge
Mtests/parser/ut/parser/testcase/tensorflow_parser_testcase/func2graph_unittest.cc+63-0
@@ -10,6 +10,9 @@
10 10 
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12#include "func_to_graph/func2graph.h"12#include "func_to_graph/func2graph.h"
13+#include "tensorflow/graph_to_function_def.h"
14+#include "graph/utils/attr_utils.h"
15+#include "graph/debug/ge_attr_define.h"
13#include <vector>16#include <vector>
14#include <sstream>17#include <sstream>
15 18 
@@ -119,4 +122,64 @@ TEST_F(UtestFuncToGraph, GraphDefLibGetGraphDef_success) {
119 122 
120 GraphDefLibDestroy(&graphDefLib);123 GraphDefLibDestroy(&graphDefLib);
121}124}
125+ 
126+TEST_F(UtestFuncToGraph, GraphToFunctionDef_FindAttrValue_null_node) {
127+ domi::tensorflow::AttrValue attr_value;
128+ bool ret = GraphToFunctionDef::FindAttrValue(nullptr, "test_attr", attr_value);
129+ EXPECT_FALSE(ret);
130+}
131+ 
132+TEST_F(UtestFuncToGraph, GraphToFunctionDef_FindAttrValue_success) {
133+ domi::tensorflow::NodeDef node_def;
134+ node_def.set_name("test_node");
135+ domi::tensorflow::AttrValue attr_value;
136+ attr_value.set_i(42);
137+ (*node_def.mutable_attr())["test_attr"] = attr_value;
138+ 
139+ domi::tensorflow::AttrValue result;
140+ bool ret = GraphToFunctionDef::FindAttrValue(&node_def, "test_attr", result);
141+ EXPECT_TRUE(ret);
142+ EXPECT_EQ(result.i(), 42);
143+ 
144+ ret = GraphToFunctionDef::FindAttrValue(&node_def, "nonexistent", result);
145+ EXPECT_FALSE(ret);
146+}
147+ 
148+TEST_F(UtestFuncToGraph, GraphToFunctionDef_AddNodeAttr_null_node) {
149+ domi::tensorflow::AttrValue value;
150+ value.set_i(10);
151+ GraphToFunctionDef::AddNodeAttr("test_attr", value, nullptr);
152+}
153+ 
154+TEST_F(UtestFuncToGraph, GraphToFunctionDef_AddNodeAttr_success) {
155+ domi::tensorflow::NodeDef node_def;
156+ node_def.set_name("test_node");
157+ domi::tensorflow::AttrValue value;
158+ value.set_i(10);
159+ GraphToFunctionDef::AddNodeAttr("test_attr", value, &node_def);
160+ EXPECT_TRUE(node_def.attr().find("test_attr") != node_def.attr().end());
161+}
162+ 
163+TEST_F(UtestFuncToGraph, NameMapHelper_GetUniqueName) {
164+ NameMapHelper helper;
165+ EXPECT_EQ(helper.GetUniqueName("name1"), "name1");
166+ EXPECT_EQ(helper.GetUniqueName("name1"), "name1_0");
167+ EXPECT_EQ(helper.GetUniqueName("name1"), "name1_1");
168+}
169+ 
170+TEST_F(UtestFuncToGraph, NameMapHelper_UniqueInputOrOutputName) {
171+ NameMapHelper helper;
172+ EXPECT_EQ(helper.UniqueInputOrOutputName("TestName"), "TestName");
173+ EXPECT_EQ(helper.UniqueInputOrOutputName(""), "unknown");
174+ EXPECT_EQ(helper.UniqueInputOrOutputName("test@name#"), "test@name#");
175+}
176+ 
177+TEST_F(UtestFuncToGraph, NameMapHelper_UniqueNodeName) {
178+ NameMapHelper helper;
179+ EXPECT_EQ(helper.UniqueNodeName("node1"), "node1");
180+ std::string result = helper.Renormalize("node1");
181+ EXPECT_EQ(result, "node1");
182+ result = helper.Renormalize("nonexistent");
183+ EXPECT_EQ(result, "");
184+}
122} // namespace ge185} // namespace ge
Mtests/parser/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_auto_mapping_parser_adapter_unittest.cc+115-0
@@ -17,6 +17,8 @@
17#include "graph/types.h"17#include "graph/types.h"
18#include "register/op_registry.h"18#include "register/op_registry.h"
19#include "parser/common/op_registration_tbe.h"19#include "parser/common/op_registration_tbe.h"
20+#include "graph/utils/attr_utils.h"
21+#include "graph/debug/ge_attr_define.h"
20 22 
21namespace ge {23namespace ge {
22class UtestTensorflowAutoMappingParserAdapter : public testing::Test {24class UtestTensorflowAutoMappingParserAdapter : public testing::Test {
@@ -49,4 +51,117 @@ TEST_F(UtestTensorflowAutoMappingParserAdapter, success) {
49 EXPECT_EQ(ret, ge::FAILED);51 EXPECT_EQ(ret, ge::FAILED);
50}52}
51 53 
54+TEST_F(UtestTensorflowAutoMappingParserAdapter, null_op_src) {
55+ auto parser = TensorFlowAutoMappingParserAdapter();
56+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("test", "Size");
57+ auto ret = parser.ParseParams(nullptr, op_desc);
58+ EXPECT_EQ(ret, ge::PARAM_INVALID);
59+}
60+ 
61+TEST_F(UtestTensorflowAutoMappingParserAdapter, null_op_dest) {
62+ auto parser = TensorFlowAutoMappingParserAdapter();
63+ domi::tensorflow::NodeDef node;
64+ node.set_name("test");
65+ node.set_op("Size");
66+ ge::OpDescPtr op_desc = nullptr;
67+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
68+ EXPECT_EQ(ret, ge::PARAM_INVALID);
69+}
70+ 
71+TEST_F(UtestTensorflowAutoMappingParserAdapter, empty_op_type) {
72+ auto parser = TensorFlowAutoMappingParserAdapter();
73+ domi::tensorflow::NodeDef node;
74+ node.set_name("empty_node");
75+ node.set_op("Empty");
76+ auto attr = node.mutable_attr();
77+ domi::tensorflow::AttrValue value;
78+ value.set_type(domi::tensorflow::DataType::DT_FLOAT);
79+ (*attr)["dtype"] = value;
80+ 
81+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("empty_node", "Empty");
82+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
83+ EXPECT_EQ(ret, ge::SUCCESS);
84+}
85+ 
86+TEST_F(UtestTensorflowAutoMappingParserAdapter, empty_op_no_dtype) {
87+ auto parser = TensorFlowAutoMappingParserAdapter();
88+ domi::tensorflow::NodeDef node;
89+ node.set_name("empty_node2");
90+ node.set_op("Empty");
91+ 
92+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("empty_node2", "Empty");
93+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
94+ EXPECT_EQ(ret, ge::SUCCESS);
95+}
96+ 
97+TEST_F(UtestTensorflowAutoMappingParserAdapter, identityn_op_type) {
98+ auto parser = TensorFlowAutoMappingParserAdapter();
99+ domi::tensorflow::NodeDef node;
100+ node.set_name("identityn_node");
101+ node.set_op("IdentityN");
102+ auto attr = node.mutable_attr();
103+ domi::tensorflow::AttrValue value;
104+ value.mutable_list()->add_type(domi::tensorflow::DataType::DT_FLOAT);
105+ value.mutable_list()->add_type(domi::tensorflow::DataType::DT_INT32);
106+ (*attr)["T"] = value;
107+ 
108+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("identityn_node", "IdentityN");
109+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
110+ EXPECT_EQ(ret, ge::SUCCESS);
111+}
112+ 
113+TEST_F(UtestTensorflowAutoMappingParserAdapter, identityn_no_T_attr) {
114+ auto parser = TensorFlowAutoMappingParserAdapter();
115+ domi::tensorflow::NodeDef node;
116+ node.set_name("identityn_no_t");
117+ node.set_op("IdentityN");
118+ 
119+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("identityn_no_t", "IdentityN");
120+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
121+ EXPECT_EQ(ret, ge::SUCCESS);
122+}
123+ 
124+TEST_F(UtestTensorflowAutoMappingParserAdapter, shape_op_type) {
125+ auto parser = TensorFlowAutoMappingParserAdapter();
126+ domi::tensorflow::NodeDef node;
127+ node.set_name("shape_node");
128+ node.set_op("Shape");
129+ auto attr = node.mutable_attr();
130+ domi::tensorflow::AttrValue value;
131+ value.set_type(domi::tensorflow::DataType::DT_INT64);
132+ (*attr)["out_type"] = value;
133+ 
134+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("shape_node", "Shape");
135+ op_desc->AddOutputDesc("y", ge::GeTensorDesc());
136+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
137+ EXPECT_EQ(ret, ge::SUCCESS);
138+}
139+ 
140+TEST_F(UtestTensorflowAutoMappingParserAdapter, shape_op_no_out_type) {
141+ auto parser = TensorFlowAutoMappingParserAdapter();
142+ domi::tensorflow::NodeDef node;
143+ node.set_name("shape_no_out");
144+ node.set_op("Shape");
145+ 
146+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("shape_no_out", "Shape");
147+ op_desc->AddOutputDesc("y", ge::GeTensorDesc());
148+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
149+ EXPECT_EQ(ret, ge::SUCCESS);
150+}
151+ 
152+TEST_F(UtestTensorflowAutoMappingParserAdapter, size_op_with_out_type) {
153+ auto parser = TensorFlowAutoMappingParserAdapter();
154+ domi::tensorflow::NodeDef node;
155+ node.set_name("size_out");
156+ node.set_op("Size");
157+ auto attr = node.mutable_attr();
158+ domi::tensorflow::AttrValue value;
159+ value.set_type(domi::tensorflow::DataType::DT_INT64);
160+ (*attr)["out_type"] = value;
161+ 
162+ auto op_desc = ge::parser::MakeShared<ge::OpDesc>("size_out", "Size");
163+ ge::AttrUtils::SetDataType(op_desc, "out_type", ge::DT_INT64);
164+ auto ret = parser.ParseParams(reinterpret_cast<Message *>(&node), op_desc);
165+ EXPECT_EQ(ret, ge::SUCCESS);
166+}
52} // namespace ge167} // namespace ge
Mtests/parser/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc+408-0
@@ -6741,4 +6741,412 @@ TEST_F(UtestTensorflowParser, TrimGraph_with_out_nodes) {
6741 EXPECT_EQ(ret, SUCCESS);6741 EXPECT_EQ(ret, SUCCESS);
6742}6742}
6743 6743 
6744+TEST_F(UtestTensorflowParser, ModelSaver_SaveJsonToFile_success) {
6745+ const Json model = {{"key", "value"}};
6746+ const char *file_path = "test_model_saver.json";
6747+ Status ret = ge::parser::ModelSaver::SaveJsonToFile(file_path, model);
6748+ EXPECT_EQ(ret, SUCCESS);
6749+ remove(file_path);
6750+}
6751+ 
6752+TEST_F(UtestTensorflowParser, ModelSaver_CheckPath_simple_filename) {
6753+ std::string path = "simple_file.txt";
6754+ Status ret = ge::parser::ModelSaver::CheckPath(path);
6755+ EXPECT_EQ(ret, SUCCESS);
6756+}
6757+ 
6758+TEST_F(UtestTensorflowParser, ModelSaver_CheckPath_with_directory) {
6759+ std::string path = "test_dir/subdir/file.txt";
6760+ Status ret = ge::parser::ModelSaver::CheckPath(path);
6761+ EXPECT_EQ(ret, SUCCESS);
6762+}
6763+ 
6764+TEST_F(UtestTensorflowParser, ModelSaver_CheckPath_too_long) {
6765+ std::string path(4097, 'a');
6766+ Status ret = ge::parser::ModelSaver::CheckPath(path);
6767+ EXPECT_EQ(ret, FAILED);
6768+}
6769+ 
6770+TEST_F(UtestTensorflowParser, ModelSaver_CreateDirectory_empty) {
6771+ std::string path = "";
6772+ int ret = ge::parser::ModelSaver::CreateDirectory(path);
6773+ EXPECT_EQ(ret, -1);
6774+}
6775+ 
6776+TEST_F(UtestTensorflowParser, ModelSaver_CreateDirectory_too_long) {
6777+ std::string path(4097, 'a');
6778+ int ret = ge::parser::ModelSaver::CreateDirectory(path);
6779+ EXPECT_EQ(ret, -1);
6780+}
6781+ 
6782+TEST_F(UtestTensorflowParser, ModelSaver_CreateDirectory_valid) {
6783+ std::string path = "test_create_dir_sub";
6784+ int ret = ge::parser::ModelSaver::CreateDirectory(path);
6785+ EXPECT_EQ(ret, 0);
6786+ remove(path.c_str());
6787+}
6788+ 
6789+TEST_F(UtestTensorflowParser, DataOpParser_ParseShape_float_type) {
6790+ std::vector<int64_t> shape = {1, 3, 224, 224};
6791+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("data1", "Data");
6792+ ge::AttrUtils::SetInt(op, ge::DATA_ATTR_NAME_DATA_TYPE, static_cast<int32_t>(ge::DT_FLOAT));
6793+ DataOpParser opParser;
6794+ Status ret = opParser.ParseShape(shape, op);
6795+ EXPECT_EQ(ret, SUCCESS);
6796+}
6797+ 
6798+TEST_F(UtestTensorflowParser, DataOpParser_ParseShape_int32_type) {
6799+ std::vector<int64_t> shape = {1, 3, 224, 224};
6800+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("data2", "Data");
6801+ ge::AttrUtils::SetInt(op, ge::DATA_ATTR_NAME_DATA_TYPE, static_cast<int32_t>(ge::DT_INT32));
6802+ DataOpParser opParser;
6803+ Status ret = opParser.ParseShape(shape, op);
6804+ EXPECT_EQ(ret, SUCCESS);
6805+}
6806+ 
6807+TEST_F(UtestTensorflowParser, DataOpParser_ParseShape_default_type) {
6808+ std::vector<int64_t> shape = {1, 3, 224, 224};
6809+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("data3", "Data");
6810+ DataOpParser opParser;
6811+ Status ret = opParser.ParseShape(shape, op);
6812+ EXPECT_EQ(ret, SUCCESS);
6813+}
6814+ 
6815+TEST_F(UtestTensorflowParser, DataOpParser_ParseShape_5d_format) {
6816+ std::vector<int64_t> shape = {1, 3, 224, 224};
6817+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("data4", "Data");
6818+ ge::GetParserContext().input_nodes_format_map["data4"] = domi::DOMI_TENSOR_NC1HWC0;
6819+ DataOpParser opParser;
6820+ Status ret = opParser.ParseShape(shape, op);
6821+ EXPECT_EQ(ret, SUCCESS);
6822+ ge::GetParserContext().input_nodes_format_map.clear();
6823+}
6824+ 
6825+TEST_F(UtestTensorflowParser, DataOpParser_ParseShape_null_op) {
6826+ std::vector<int64_t> shape = {1, 3, 224, 224};
6827+ ge::OpDescPtr op = nullptr;
6828+ DataOpParser opParser;
6829+ Status ret = opParser.ParseShape(shape, op);
6830+ EXPECT_EQ(ret, FAILED);
6831+}
6832+ 
6833+TEST_F(UtestTensorflowParser, DataOpParser_InitNDTensor) {
6834+ std::vector<int64_t> shape = {1, 3, 224, 224};
6835+ ge::GeTensorDesc tensor_desc;
6836+ DataOpParser opParser;
6837+ Status ret = opParser.InitNDTensor(shape, ge::DT_INT32, tensor_desc);
6838+ EXPECT_EQ(ret, SUCCESS);
6839+}
6840+ 
6841+TEST_F(UtestTensorflowParser, DataOpParser_InitInputTensor) {
6842+ std::vector<int64_t> shape = {1, 3, 224, 224};
6843+ ge::GeTensorDesc tensor_desc;
6844+ DataOpParser opParser;
6845+ Status ret = opParser.InitInputTensor(shape, tensor_desc);
6846+ EXPECT_EQ(ret, SUCCESS);
6847+}
6848+ 
6849+TEST_F(UtestTensorflowParser, DataOpParser_InitInputTensor_dynamic_batch) {
6850+ std::vector<int64_t> shape = {-1, 3, 224, 224};
6851+ ge::GeTensorDesc tensor_desc;
6852+ DataOpParser opParser;
6853+ Status ret = opParser.InitInputTensor(shape, tensor_desc);
6854+ EXPECT_EQ(ret, SUCCESS);
6855+}
6856+ 
6857+TEST_F(UtestTensorflowParser, DataOpParser_InitOutputTensor) {
6858+ std::vector<int64_t> shape = {1, 3, 224, 224};
6859+ ge::GeTensorDesc tensor_desc;
6860+ DataOpParser opParser;
6861+ Status ret = opParser.InitOutputTensor(shape, tensor_desc);
6862+ EXPECT_EQ(ret, SUCCESS);
6863+}
6864+ 
6865+TEST_F(UtestTensorflowParser, DataOpParser_InitOutputTensor_empty_shape) {
6866+ std::vector<int64_t> shape = {};
6867+ ge::GeTensorDesc tensor_desc;
6868+ DataOpParser opParser;
6869+ Status ret = opParser.InitOutputTensor(shape, tensor_desc);
6870+ EXPECT_EQ(ret, SUCCESS);
6871+}
6872+ 
6873+TEST_F(UtestTensorflowParser, TBEPluginLoader_GetOppPath) {
6874+ TBEPluginLoader tbe_plugin;
6875+ std::string opp_path;
6876+ Status ret = tbe_plugin.GetOppPath(opp_path);
6877+ EXPECT_EQ(ret, SUCCESS);
6878+}
6879+ 
6880+TEST_F(UtestTensorflowParser, TBEPluginLoader_GetOpsProtoPath) {
6881+ TBEPluginLoader tbe_plugin;
6882+ std::string opsproto_path;
6883+ Status ret = tbe_plugin.GetOpsProtoPath(opsproto_path);
6884+ EXPECT_EQ(ret, SUCCESS);
6885+}
6886+ 
6887+TEST_F(UtestTensorflowParser, TBEPluginLoader_GetCustomCaffeProtoPath) {
6888+ TBEPluginLoader tbe_plugin;
6889+ std::string customcaffe_path;
6890+ Status ret = tbe_plugin.GetCustomCaffeProtoPath(customcaffe_path);
6891+ EXPECT_EQ(ret, SUCCESS);
6892+}
6893+ 
6894+TEST_F(UtestTensorflowParser, TBEPluginLoader_Finalize) {
6895+ TBEPluginLoader &tbe_plugin = TBEPluginLoader::Instance();
6896+ Status ret = tbe_plugin.Finalize();
6897+ EXPECT_EQ(ret, SUCCESS);
6898+}
6899+ 
6900+TEST_F(UtestTensorflowParser, TBEPluginLoader_LoadPluginSo_empty) {
6901+ TBEPluginLoader &tbe_plugin = TBEPluginLoader::Instance();
6902+ std::map<string, string> options;
6903+ tbe_plugin.LoadPluginSo(options);
6904+}
6905+ 
6906+TEST_F(UtestTensorflowParser, TBEPluginLoader_GetOppPluginVendors_failed) {
6907+ TBEPluginLoader tbe_plugin;
6908+ std::vector<std::string> vendors;
6909+ Status ret = tbe_plugin.GetOppPluginVendors("nonexistent_config.ini", vendors);
6910+ EXPECT_EQ(ret, FAILED);
6911+}
6912+ 
6913+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_ConstructRegOpString) {
6914+ domi::tensorflow::OpDef opdef;
6915+ opdef.set_name("TestCustomOp");
6916+ auto *input_arg = opdef.add_input_arg();
6917+ input_arg->set_name("x");
6918+ input_arg->set_type(domi::tensorflow::DataType::DT_FLOAT);
6919+ auto *output_arg = opdef.add_output_arg();
6920+ output_arg->set_name("y");
6921+ output_arg->set_type(domi::tensorflow::DataType::DT_FLOAT);
6922+ auto *attr = opdef.add_attr();
6923+ attr->set_name("epsilon");
6924+ attr->set_type("float");
6925+ attr->mutable_default_value()->set_f(0.001f);
6926+ 
6927+ std::string reg_op;
6928+ TensorFlowCustomOpParser parser;
6929+ Status ret = parser.ConstructRegOpString(opdef, reg_op);
6930+ EXPECT_EQ(ret, SUCCESS);
6931+ EXPECT_FALSE(reg_op.empty());
6932+}
6933+ 
6934+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_ConstructRegCustomOpString) {
6935+ domi::tensorflow::OpDef opdef;
6936+ opdef.set_name("TestCustomOp2");
6937+ auto *input_arg = opdef.add_input_arg();
6938+ input_arg->set_name("x");
6939+ input_arg->set_type(domi::tensorflow::DataType::DT_FLOAT);
6940+ auto *output_arg = opdef.add_output_arg();
6941+ output_arg->set_name("y");
6942+ output_arg->set_type(domi::tensorflow::DataType::DT_FLOAT);
6943+ 
6944+ domi::tensorflow::NodeDef node_def;
6945+ node_def.set_name("test_node");
6946+ node_def.set_op("TestCustomOp2");
6947+ 
6948+ std::string reg_op_custom;
6949+ TensorFlowCustomOpParser parser;
6950+ Status ret = parser.ConstructRegCustomOpString(opdef, node_def, reg_op_custom);
6951+ EXPECT_EQ(ret, SUCCESS);
6952+ EXPECT_FALSE(reg_op_custom.empty());
6953+}
6954+ 
6955+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_ConstructRegOpString_with_dynamic) {
6956+ domi::tensorflow::OpDef opdef;
6957+ opdef.set_name("DynamicOp");
6958+ auto *input_arg = opdef.add_input_arg();
6959+ input_arg->set_name("inputs");
6960+ input_arg->set_number_attr("N");
6961+ auto *output_arg = opdef.add_output_arg();
6962+ output_arg->set_name("outputs");
6963+ output_arg->set_number_attr("N");
6964+ auto *attr = opdef.add_attr();
6965+ attr->set_name("N");
6966+ attr->set_type("int");
6967+ attr->mutable_default_value()->set_i(1);
6968+ 
6969+ std::string reg_op;
6970+ TensorFlowCustomOpParser parser;
6971+ Status ret = parser.ConstructRegOpString(opdef, reg_op);
6972+ EXPECT_EQ(ret, SUCCESS);
6973+}
6974+ 
6975+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_WriteTextFile) {
6976+ TensorFlowCustomOpParser parser;
6977+ std::string content = "test content";
6978+ Status ret = parser.WriteTextFile("test_write_text_file.txt", content);
6979+ EXPECT_EQ(ret, SUCCESS);
6980+ remove("test_write_text_file.txt");
6981+}
6982+ 
6983+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_WriteWrapperCc) {
6984+ TensorFlowCustomOpParser parser;
6985+ Status ret = parser.WriteWrapperCc("test_wrapper.cc");
6986+ EXPECT_EQ(ret, SUCCESS);
6987+ remove("test_wrapper.cc");
6988+}
6989+ 
6990+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_DeleteTmpDirectoryContents) {
6991+ TensorFlowCustomOpParser parser;
6992+ Status ret = parser.DeleteTmpDirectoryContents("nonexistent_dir_12345");
6993+ EXPECT_EQ(ret, SUCCESS);
6994+}
6995+ 
6996+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_ParseCustomOp_empty) {
6997+ TensorFlowCustomOpParser parser;
6998+ std::unordered_map<std::string, const domi::tensorflow::NodeDef *> empty_map;
6999+ Status ret = parser.ParseCustomOp(empty_map);
7000+ EXPECT_EQ(ret, SUCCESS);
7001+}
7002+ 
7003+TEST_F(UtestTensorflowParser, TensorFlowCustomOpParser_RegisteredTfaOps) {
7004+ TensorFlowCustomOpParser parser;
7005+ Status ret = parser.RegisteredTfaOps();
7006+ EXPECT_EQ(ret, SUCCESS);
7007+}
7008+ 
7009+TEST_F(UtestTensorflowParser, aclgrphParseTensorFlow_null_file) {
7010+ ge::Graph graph;
7011+ auto ret = aclgrphParseTensorFlow(nullptr, graph);
7012+ EXPECT_NE(ret, SUCCESS);
7013+}
7014+ 
7015+TEST_F(UtestTensorflowParser, aclgrphParseTensorFlow_invalid_file) {
7016+ ge::Graph graph;
7017+ auto ret = aclgrphParseTensorFlow("nonexistent_tf_model.pb", graph);
7018+ EXPECT_NE(ret, SUCCESS);
7019+}
7020+ 
7021+TEST_F(UtestTensorflowParser, aclgrphParseTensorFlow_with_params_null) {
7022+ std::map<AscendString, AscendString> parser_params;
7023+ ge::Graph graph;
7024+ auto ret = aclgrphParseTensorFlow(nullptr, parser_params, graph);
7025+ EXPECT_NE(ret, SUCCESS);
7026+}
7027+ 
7028+TEST_F(UtestTensorflowParser, aclgrphParseTensorFlow_with_params_invalid) {
7029+ std::map<AscendString, AscendString> parser_params;
7030+ ge::Graph graph;
7031+ auto ret = aclgrphParseTensorFlow("nonexistent_tf_model2.pb", parser_params, graph);
7032+ EXPECT_NE(ret, SUCCESS);
7033+}
7034+ 
7035+TEST_F(UtestTensorflowParser, TensorFlowModelParser_ToJson_null) {
7036+ TensorFlowModelParser parser;
7037+ auto ret = parser.ToJson(nullptr, "output.json");
7038+ EXPECT_NE(ret, SUCCESS);
7039+ ret = parser.ToJson("model.pb", nullptr);
7040+ EXPECT_NE(ret, SUCCESS);
7041+}
7042+ 
7043+TEST_F(UtestTensorflowParser, TensorFlowModelParser_ToJson_invalid) {
7044+ TensorFlowModelParser parser;
7045+ auto ret = parser.ToJson("nonexistent_tf_model.json", "output.json");
7046+ EXPECT_NE(ret, SUCCESS);
7047+}
7048+ 
7049+TEST_F(UtestTensorflowParser, TensorFlowModelParser_ParseFromMemory_null) {
7050+ TensorFlowModelParser parser;
7051+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test");
7052+ auto ret = parser.ParseFromMemory(nullptr, 0, graph);
7053+ EXPECT_NE(ret, SUCCESS);
7054+}
7055+ 
7056+TEST_F(UtestTensorflowParser, TensorFlowModelParser_ParseFromMemory_invalid_data) {
7057+ TensorFlowModelParser parser;
7058+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test");
7059+ const char *data = "invalid data";
7060+ auto ret = parser.ParseFromMemory(data, 11, graph);
7061+ EXPECT_NE(ret, SUCCESS);
7062+}
7063+ 
7064+TEST_F(UtestTensorflowParser, AclGraphParserUtil_SetOutputNodeInfo_with_out_nodes) {
7065+ ParerUTestsUtils::ClearParserInnerCtx();
7066+ AclGraphParserUtil acl_graph_parse_util;
7067+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_tf_out");
7068+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("tf_output", "Identity");
7069+ op->AddInputDesc(ge::GeTensorDesc());
7070+ op->AddOutputDesc(ge::GeTensorDesc());
7071+ ge::NodePtr node = compute_graph->AddNode(op);
7072+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
7073+ 
7074+ ge::GetParserContext().user_out_nodes.push_back({"tf_output", 0});
7075+ ge::GetParserContext().type = domi::TENSORFLOW;
7076+ std::map<AscendString, AscendString> parser_params;
7077+ auto ret = acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params);
7078+ EXPECT_EQ(ret, SUCCESS);
7079+}
7080+ 
7081+TEST_F(UtestTensorflowParser, AclGraphParserUtil_SetOutputNodeInfo_default) {
7082+ ParerUTestsUtils::ClearParserInnerCtx();
7083+ AclGraphParserUtil acl_graph_parse_util;
7084+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_tf_default_out");
7085+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("default_out", "Identity");
7086+ op->AddInputDesc(ge::GeTensorDesc());
7087+ op->AddOutputDesc(ge::GeTensorDesc());
7088+ ge::NodePtr node = compute_graph->AddNode(op);
7089+ compute_graph->AddOutputNodeByIndex(node, 0);
7090+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
7091+ 
7092+ ge::GetParserContext().type = domi::TENSORFLOW;
7093+ std::map<AscendString, AscendString> parser_params;
7094+ auto ret = acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params);
7095+ EXPECT_EQ(ret, SUCCESS);
7096+}
7097+ 
7098+TEST_F(UtestTensorflowParser, AclGraphParserUtil_SetOutputNodeInfo_with_output_format) {
7099+ ParerUTestsUtils::ClearParserInnerCtx();
7100+ AclGraphParserUtil acl_graph_parse_util;
7101+ ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>("test_tf_format");
7102+ ge::OpDescPtr op = std::make_shared<ge::OpDesc>("format_out", "Identity");
7103+ op->AddInputDesc(ge::GeTensorDesc());
7104+ op->AddOutputDesc(ge::GeTensorDesc());
7105+ ge::NodePtr node = compute_graph->AddNode(op);
7106+ ge::Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
7107+ 
7108+ ge::GetParserContext().user_out_nodes.push_back({"format_out", 0});
7109+ ge::GetParserContext().output_formats.push_back(domi::DOMI_TENSOR_NC1HWC0);
7110+ ge::GetParserContext().type = domi::TENSORFLOW;
7111+ std::map<AscendString, AscendString> parser_params;
7112+ auto ret = acl_graph_parse_util.SetOutputNodeInfo(graph, parser_params);
7113+ EXPECT_EQ(ret, SUCCESS);
7114+}
7115+ 
7116+TEST_F(UtestTensorflowParser, TensorFlowModelParser_TrimGraph_empty) {
7117+ ParerUTestsUtils::ClearParserInnerCtx();
7118+ TensorFlowModelParser parser;
7119+ domi::tensorflow::GraphDef input_graph;
7120+ domi::tensorflow::GraphDef output_graph;
7121+ auto ret = parser.TrimGraph(input_graph, &output_graph);
7122+ EXPECT_EQ(ret, SUCCESS);
7123+}
7124+ 
7125+TEST_F(UtestTensorflowParser, TensorFlowModelParser_ParseFromMemory_valid_graph) {
7126+ ParerUTestsUtils::ClearParserInnerCtx();
7127+ TensorFlowModelParser parser;
7128+ domi::tensorflow::GraphDef graph_def;
7129+ auto *node = graph_def.add_node();
7130+ node->set_name("test_input");
7131+ node->set_op("Placeholder");
7132+ auto *attr = node->mutable_attr();
7133+ domi::tensorflow::AttrValue dtype_val;
7134+ dtype_val.set_type(domi::tensorflow::DT_FLOAT);
7135+ (*attr)["dtype"] = dtype_val;
7136+ domi::tensorflow::AttrValue shape_val;
7137+ auto *shape = shape_val.mutable_shape();
7138+ shape->add_dim()->set_size(-1);
7139+ shape->add_dim()->set_size(3);
7140+ shape->add_dim()->set_size(224);
7141+ shape->add_dim()->set_size(224);
7142+ (*attr)["shape"] = shape_val;
7143+ 
7144+ std::string buffer;
7145+ graph_def.SerializeToString(&buffer);
7146+ ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>("test_mem");
7147+ ge::GetParserContext().type = domi::TENSORFLOW;
7148+ ge::GetParserContext().input_dims["test_input"] = {1, 3, 224, 224};
7149+ auto ret = parser.ParseFromMemory(buffer.data(), static_cast<int>(buffer.size()), graph);
7150+ EXPECT_NE(ret, FAILED);
7151+}
6744} // namespace ge7152} // namespace ge