Star678
456
代码
代码
Issues27
Pull Requests105
Actions
项目讨论
Wiki
分析
Star678
456
已合并
feat: 增补UT覆盖率 #4220
likun104创建于 7月31日
feat: 增补UT覆盖率 #4220
已合并
likun104创建于 7月31日
从likun104/gebr_update_coverage_03合入到cann/gedevelop
共 89 个文件变更+12896-13
Mtests/depends/mmpa/src/mmpa_stub.cc+6-0
@@ -514,6 +514,12 @@ VOID *mmDlsym(VOID *handle, const CHAR *funcName) {
514 return (void *)&MockIsEnableMdeTopoSort;514 return (void *)&MockIsEnableMdeTopoSort;
515 }515 }
516 516 
517+ if ((handle == libcce_name.data()) || (handle == libopmaster_rt2_name.data()) ||
518+ (handle == libopmaster_error_rt2_name.data()) || (handle == libmdat_name.data()) ||
519+ (handle == libruntime_name.data())) {
520+ return nullptr;
521+ }
522+ 
517 if (reinterpret_cast<uintptr_t>(handle) < 0x8000 && handle != nullptr) {523 if (reinterpret_cast<uintptr_t>(handle) < 0x8000 && handle != nullptr) {
518 return nullptr;524 return nullptr;
519 }525 }
Mtests/ge/ut/ge/CMakeLists.txt+1-0
@@ -747,6 +747,7 @@ target_link_libraries(ut_libge_multiparts_utest
747 ge_runner747 ge_runner
748 udf_compiler748 udf_compiler
749 ge_runner_v2749 ge_runner_v2
750+ dflow_runner
750 engine751 engine
751 json752 json
752 minizip_static753 minizip_static
Mtests/ge/ut/ge/common/dataslice_unittest.cc+237-0
@@ -796,4 +796,241 @@ TEST_F(DataSlice, Cov_DataSliceElementwiseImpl_NullOpDesc) {
796 auto ret = impl.InferAxisSlice(op_proxy, axis_type_info, out_data_slice, in_data_slice);796 auto ret = impl.InferAxisSlice(op_proxy, axis_type_info, out_data_slice, in_data_slice);
797 EXPECT_NE(ret, SUCCESS);797 EXPECT_NE(ret, SUCCESS);
798}798}
799+ 
800+TEST_F(DataSlice, Cov_TransAxis_NDC1HWC0) {
801+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4, 5, 16}), FORMAT_NDC1HWC0);
802+ tensor->SetOriginFormat(FORMAT_NCHW);
803+ tensor->SetOriginShape(GeShape({1, 2, 3, 4, 5}));
804+ auto result = DataSliceAdapter::TransAxis(tensor, 0);
805+ EXPECT_FALSE(result.empty());
806+}
807+ 
808+TEST_F(DataSlice, Cov_TransAxis_5DSet) {
809+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4, 5}), FORMAT_NCDHW);
810+ tensor->SetOriginFormat(FORMAT_NCHW);
811+ tensor->SetOriginShape(GeShape({1, 2, 3, 4, 5}));
812+ auto result = DataSliceAdapter::TransAxis(tensor, 0);
813+ EXPECT_FALSE(result.empty());
814+}
815+ 
816+TEST_F(DataSlice, Cov_TransAxis_UnsupportedFormat) {
817+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2}), FORMAT_ND);
818+ tensor->SetOriginFormat(FORMAT_NCHW);
819+ tensor->SetOriginShape(GeShape({1, 2, 3, 4}));
820+ auto result = DataSliceAdapter::TransAxis(tensor, 0);
821+ EXPECT_TRUE(result.empty());
822+}
823+ 
824+TEST_F(DataSlice, Cov_TransAxisForSplit_CheckRankFail) {
825+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4, 5, 6}), FORMAT_NC1HWC0);
826+ tensor->SetOriginFormat(FORMAT_NCHW);
827+ tensor->SetOriginShape(GeShape({1, 2, 3, 4, 5, 6, 7, 8}));
828+ auto result = DataSliceAdapter::TransAxisForSplit(tensor, 0, 4U);
829+ EXPECT_TRUE(result.empty());
830+}
831+ 
832+TEST_F(DataSlice, Cov_TransAxisForSplit_FormatNotFound) {
833+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4}), FORMAT_NC1HWC0);
834+ tensor->SetOriginFormat(FORMAT_RESERVED);
835+ tensor->SetOriginShape(GeShape({1, 2, 3, 4}));
836+ auto result = DataSliceAdapter::TransAxisForSplit(tensor, 0, 4U);
837+ EXPECT_TRUE(result.empty());
838+}
839+ 
840+TEST_F(DataSlice, Cov_TransAxisForNoSplit_RankNotEqualDimNum) {
841+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4, 5}), FORMAT_NCHW);
842+ tensor->SetOriginFormat(FORMAT_NCHW);
843+ tensor->SetOriginShape(GeShape({1, 2, 3, 4, 5}));
844+ auto result = DataSliceAdapter::TransAxisForNoSplit(tensor, 0, 4U);
845+ EXPECT_TRUE(result.empty());
846+}
847+ 
848+TEST_F(DataSlice, Cov_TransAxisForNoSplit_OriFormatNotFound) {
849+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4}), FORMAT_NCHW);
850+ tensor->SetOriginFormat(FORMAT_RESERVED);
851+ tensor->SetOriginShape(GeShape({1, 2, 3, 4}));
852+ auto result = DataSliceAdapter::TransAxisForNoSplit(tensor, 0, 4U);
853+ EXPECT_TRUE(result.empty());
854+}
855+ 
856+TEST_F(DataSlice, Cov_TransAxisForNoSplit_AxisOutOfRange) {
857+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4}), FORMAT_NCHW);
858+ tensor->SetOriginFormat(FORMAT_NCHW);
859+ tensor->SetOriginShape(GeShape({1, 2, 3, 4}));
860+ auto result = DataSliceAdapter::TransAxisForNoSplit(tensor, 10, 4U);
861+ EXPECT_TRUE(result.empty());
862+}
863+ 
864+TEST_F(DataSlice, Cov_TransAxisForNoSplit_FormatNotFound) {
865+ auto tensor = std::make_shared<GeTensorDesc>(GeShape({1, 2, 3, 4}), FORMAT_RESERVED);
866+ tensor->SetOriginFormat(FORMAT_NCHW);
867+ tensor->SetOriginShape(GeShape({1, 2, 3, 4}));
868+ auto result = DataSliceAdapter::TransAxisForNoSplit(tensor, 0, 4U);
869+ EXPECT_TRUE(result.empty());
870+}
871+ 
872+TEST_F(DataSlice, Cov_FixAxisTypeInfoToOne_DiffOutputSize) {
873+ AxisTypeInfo axis_type_info;
874+ axis_type_info.SetAxisType(AxisType::REDUCESUM);
875+ axis_type_info.SetRelateInputs({{0, {0}}});
876+ axis_type_info.SetRelateOutputs({{0, {0, 1}}, {1, {0}}});
877+ EXPECT_EQ(DataSliceAdapter::FixAxisTypeInfoToOne(axis_type_info), FAILED);
878+}
879+ 
880+TEST_F(DataSlice, Cov_FixAxisTypeInfoToOne_ReduceEmpty) {
881+ AxisTypeInfo axis_type_info;
882+ axis_type_info.SetAxisType(AxisType::REDUCESUM);
883+ axis_type_info.SetRelateInputs({{0, {0}}});
884+ axis_type_info.SetRelateOutputs({{0, {}}, {1, {0}}});
885+ EXPECT_EQ(DataSliceAdapter::FixAxisTypeInfoToOne(axis_type_info), SUCCESS);
886+}
887+ 
888+TEST_F(DataSlice, Cov_TransAxisForInputTensor_NullTensor) {
889+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
890+ op_desc->AddInputDesc("input", GeTensorDesc());
891+ AxisTypeInfo axis_type_info;
892+ axis_type_info.SetRelateInputs({{5, {0}}});
893+ EXPECT_EQ(DataSliceAdapter::TransAxisForInputTensor(op_desc, "element_type", axis_type_info), FAILED);
894+}
895+ 
896+TEST_F(DataSlice, Cov_TransAxisForOutputTensor_NullTensor) {
897+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
898+ op_desc->AddOutputDesc("output", GeTensorDesc());
899+ AxisTypeInfo axis_type_info;
900+ axis_type_info.SetRelateOutputs({{5, {0}}});
901+ EXPECT_EQ(DataSliceAdapter::TransAxisForOutputTensor(op_desc, "element_type", axis_type_info), FAILED);
902+}
903+ 
904+TEST_F(DataSlice, Cov_TransAxisByType_ValidateFail) {
905+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
906+ AxisTypeInfo axis_type_info;
907+ EXPECT_EQ(DataSliceAdapter::TransAxisByType(AxisType::ELEMENTWISE, op_desc, axis_type_info), FAILED);
908+}
909+ 
910+TEST_F(DataSlice, Cov_GetAxisTypeForTransAxis_MultiType) {
911+ AxisTypeInfo axis_type_info1;
912+ axis_type_info1.SetAxisTypes({AxisType::ELEMENTWISE, AxisType::REDUCESUM, AxisType::REDUCEMAX});
913+ EXPECT_EQ(DataSliceAdapter::GetAxisTypeForTransAxis(axis_type_info1), AxisType::UNSPLIT);
914+ AxisTypeInfo axis_type_info2;
915+ axis_type_info2.SetAxisTypes({AxisType::ELEMENTWISE, AxisType::REDUCESUM});
916+ EXPECT_EQ(DataSliceAdapter::GetAxisTypeForTransAxis(axis_type_info2), AxisType::SLIDINGWINDOW);
917+}
918+ 
919+TEST_F(DataSlice, Cov_GetAxisTypeForTransSlice_MultiType) {
920+ AxisTypeInfo axis_type_info;
921+ axis_type_info.SetAxisTypes({AxisType::ELEMENTWISE, AxisType::REDUCESUM, AxisType::REDUCEMAX});
922+ EXPECT_EQ(DataSliceAdapter::GetAxisTypeForTransSlice(axis_type_info), AxisType::UNSPLIT);
923+}
924+ 
925+TEST_F(DataSlice, Cov_TransSliceInfo_UnsupportedType) {
926+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
927+ AxisTypeInfo axis_type_info;
928+ axis_type_info.SetAxisTypes({AxisType::UNSPLIT});
929+ DataSliceAdapter::DataSliceType slice_info;
930+ DataSliceAdapter::DataSliceType out_slice;
931+ EXPECT_EQ(DataSliceAdapter::TransSliceInfo(op_desc, axis_type_info, TransType::CUR_TO_ORI, slice_info, out_slice),
932+ FAILED);
933+}
934+ 
935+TEST_F(DataSlice, Cov_TransSliceInfo_SlidingWindow) {
936+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
937+ AxisTypeInfo axis_type_info;
938+ axis_type_info.SetAxisTypes({AxisType::SLIDINGWINDOW});
939+ DataSliceAdapter::DataSliceType slice_info = {{{0, 10}}};
940+ DataSliceAdapter::DataSliceType out_slice;
941+ EXPECT_EQ(DataSliceAdapter::TransSliceInfo(op_desc, axis_type_info, TransType::CUR_TO_ORI, slice_info, out_slice),
942+ SUCCESS);
943+ EXPECT_EQ(out_slice.size(), 1U);
944+}
945+ 
946+TEST_F(DataSlice, Cov_TransSliceInfoToOri_EmptyOriOutputs) {
947+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
948+ AxisTypeInfo axis_type_info;
949+ DataSliceAdapter::DataSliceType slice_info = {{{0, 10}}};
950+ DataSliceAdapter::DataSliceType out_slice;
951+ EXPECT_EQ(DataSliceAdapter::TransSliceInfoToOriForElement(op_desc, axis_type_info, slice_info, out_slice), FAILED);
952+}
953+ 
954+TEST_F(DataSlice, Cov_TransSliceInfoToCur_EmptyOriInputs) {
955+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
956+ AxisTypeInfo axis_type_info;
957+ DataSliceAdapter::DataSliceType slice_info = {{{0, 10}}};
958+ DataSliceAdapter::DataSliceType out_slice;
959+ EXPECT_EQ(DataSliceAdapter::TransSliceInfoToCurForElement(op_desc, axis_type_info, slice_info, out_slice), FAILED);
960+}
961+ 
962+TEST_F(DataSlice, Cov_ValidateRelateInputOutput_False) {
963+ AxisTypeInfo axis_type_info;
964+ EXPECT_FALSE(DataSliceAdapter::ValidateRelateInputOutput(axis_type_info));
965+}
966+ 
967+TEST_F(DataSlice, Cov_SetInputSlice_TensorIdxOutOfRange) {
968+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
969+ op_desc->AddOutputDesc("output", GeTensorDesc());
970+ op_desc->AddInputDesc("input", GeTensorDesc());
971+ AxisTypeInfo axis_type_info;
972+ axis_type_info.SetAxisType(AxisType::ELEMENTWISE);
973+ axis_type_info.SetRelateInputs({{0, {0}}, {1, {0}}, {2, {0}}, {5, {0}}});
974+ axis_type_info.SetRelateOutputs({{0, {0}}});
975+ Status ret = DataSliceHelper::InferAxisSlice(op_desc, axis_type_info);
976+ EXPECT_EQ(ret, SUCCESS);
977+}
978+ 
979+TEST_F(DataSlice, Cov_GetSliceInfo_NoAxisSliceFunc) {
980+ OpDescPtr op_desc = std::make_shared<OpDesc>("UnknownOp", "UnknownOpType");
981+ op_desc->AddOutputDesc("output", GeTensorDesc());
982+ op_desc->AddInputDesc("input", GeTensorDesc());
983+ std::vector<AxisTypeInfo> axis_type_info;
984+ Status ret = DataSliceHelper::GetSliceInfo(op_desc, axis_type_info);
985+ EXPECT_EQ(ret, FAILED);
986+}
987+ 
988+TEST_F(DataSlice, Cov_GetDavinciSliceInfo_NoAxisSliceFunc) {
989+ ComputeGraphPtr test_graph = std::make_shared<ComputeGraph>("test_graph");
990+ OpDescPtr op_desc = std::make_shared<OpDesc>("UnknownOp2", "UnknownOpType2");
991+ op_desc->AddOutputDesc("output", GeTensorDesc());
992+ op_desc->AddInputDesc("input", GeTensorDesc());
993+ NodePtr node = test_graph->AddNode(op_desc);
994+ std::vector<AxisTypeInfo> axis_type_info;
995+ Status ret = DataSliceHelper::GetDavinciSliceInfo(node, axis_type_info);
996+ EXPECT_EQ(ret, FAILED);
997+}
998+ 
999+TEST_F(DataSlice, Cov_GetDavinciSliceInfo_GetAxisSliceFail) {
1000+ ComputeGraphPtr test_graph = std::make_shared<ComputeGraph>("test_graph");
1001+ OpDescPtr op_desc = std::make_shared<OpDesc>("Softmax", "Softmax");
1002+ GeTensorDesc output_desc(GeShape({10, 20}), FORMAT_NCHW);
1003+ output_desc.SetOriginShape(GeShape({10, 20}));
1004+ output_desc.SetOriginFormat(FORMAT_NCHW);
1005+ op_desc->AddOutputDesc("output", output_desc);
1006+ GeTensorDesc input_desc(GeShape({10, 20}), FORMAT_NCHW);
1007+ input_desc.SetOriginShape(GeShape({10, 20}));
1008+ input_desc.SetOriginFormat(FORMAT_NCHW);
1009+ op_desc->AddInputDesc("input", input_desc);
1010+ NodePtr node = test_graph->AddNode(op_desc);
1011+ std::vector<AxisTypeInfo> axis_type_info;
1012+ Status ret = DataSliceHelper::GetDavinciSliceInfo(node, axis_type_info);
1013+ EXPECT_EQ(ret, FAILED);
1014+}
1015+ 
1016+TEST_F(DataSlice, Cov_InferDavinciSpecialOpSlice_GetOriOutputFail) {
1017+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
1018+ GeTensorDesc output_desc(GeShape({10, 20}), FORMAT_NCHW);
1019+ output_desc.SetOriginShape(GeShape({10, 20}));
1020+ output_desc.SetOriginFormat(FORMAT_NCHW);
1021+ op_desc->AddOutputDesc("output", output_desc);
1022+ GeTensorDesc input_desc(GeShape({10, 20}), FORMAT_NCHW);
1023+ input_desc.SetOriginShape(GeShape({10, 20}));
1024+ input_desc.SetOriginFormat(FORMAT_NCHW);
1025+ op_desc->AddInputDesc("input", input_desc);
1026+ AxisTypeInfo axis_type_info;
1027+ axis_type_info.SetAxisTypes({AxisType::UNSPLIT});
1028+ axis_type_info.SetAxisType(AxisType::UNSPLIT);
1029+ axis_type_info.SetRelateInputs({{0, {0}}});
1030+ axis_type_info.SetRelateOutputs({{0, {0}}});
1031+ axis_type_info.SetOriRelateInputs({{0, {0}}});
1032+ axis_type_info.SetOriRelateOutputs({{0, {0}}});
1033+ Status ret = DataSliceHelper::InferDavinciAxisSlice(op_desc, axis_type_info);
1034+ EXPECT_EQ(ret, FAILED);
1035+}
799} // namespace ge1036} // namespace ge
Mtests/ge/ut/ge/common/datatype_transfer_unittest.cc+15-0
@@ -9,6 +9,7 @@
9 */9 */
10 10 
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12+#include <climits>
12 13 
13#include "common/datatype_transfer/datatype_transfer.h"14#include "common/datatype_transfer/datatype_transfer.h"
14#include "common/fp16_t/fp16_t.h"15#include "common/fp16_t/fp16_t.h"
@@ -432,5 +433,19 @@ TEST_F(UtestDataTypeTransfer, TransDataType_ZeroSize) {
432 EXPECT_EQ(transfer.TransDataType(args, result), SUCCESS);433 EXPECT_EQ(transfer.TransDataType(args, result), SUCCESS);
433 EXPECT_EQ(result.length, 0U);434 EXPECT_EQ(result.length, 0U);
434}435}
436+ 
437+TEST_F(UtestDataTypeTransfer, TransTensorDataType_NullDataWithSize_CovEnhance) {
438+ CastArgs args{nullptr, 10, DT_FLOAT, DT_FLOAT16};
439+ TransResult result;
440+ EXPECT_EQ(TransTensorDataType(args, result), ACL_ERROR_GE_PARAM_INVALID);
441+}
442+ 
443+TEST_F(UtestDataTypeTransfer, TransDataType_OverflowSrcSize_CovEnhance) {
444+ int32_t data[4] = {1, 2, 3, 4};
445+ CastArgs args{reinterpret_cast<uint8_t *>(data), SIZE_MAX, DT_INT32, DT_FLOAT};
446+ TransResult result;
447+ DataTypeTransfer transfer;
448+ EXPECT_EQ(transfer.TransDataType(args, result), ACL_ERROR_GE_PARAM_INVALID);
449+}
435} // namespace formats450} // namespace formats
436} // namespace ge451} // namespace ge
Mtests/ge/ut/ge/common/dump_exception_unittest.cc+215-0
@@ -27,6 +27,7 @@
27#include "depends/profiler/src/dump_stub.h"27#include "depends/profiler/src/dump_stub.h"
28#include "common/dump/dump_manager.h"28#include "common/dump/dump_manager.h"
29#include "common/dump/adump_opinfo_builder.h"29#include "common/dump/adump_opinfo_builder.h"
30+#include "mmpa/mmpa_api.h"
30 31 
31namespace ge {32namespace ge {
32class UTEST_dump_exception : public testing::Test {33class UTEST_dump_exception : public testing::Test {
@@ -482,4 +483,218 @@ TEST_F(UTEST_dump_exception, DumpDevMem_size_zero) {
482 const auto ret = ExceptionDumper::DumpDevMem("test_file", nullptr, 0);483 const auto ret = ExceptionDumper::DumpDevMem("test_file", nullptr, 0);
483 EXPECT_EQ(ret, ge::SUCCESS);484 EXPECT_EQ(ret, ge::SUCCESS);
484}485}
486+ 
487+TEST_F(UTEST_dump_exception, LogExceptionTvmOpInfo_NonTvm_CovEnhance) {
488+ OpDescInfo op_desc_info;
489+ op_desc_info.imply_type = 0U;
490+ ExceptionDumper exception_dumper{};
491+ gert::GertRuntimeStub runtime_stub;
492+ dlog_setlevel(GE_MODULE_NAME, DLOG_INFO, 0);
493+ exception_dumper.LogExceptionTvmOpInfo(op_desc_info);
494+ EXPECT_TRUE(CheckLogExpected(runtime_stub.GetSlogStub().GetLogs(), "not tvm"));
495+ dlog_setlevel(GE_MODULE_NAME, DLOG_ERROR, 0);
496+}
497+ 
498+TEST_F(UTEST_dump_exception, LogExceptionTvmOpInfo_InputMismatch_CovEnhance) {
499+ OpDescInfo op_desc_info;
500+ op_desc_info.imply_type = static_cast<uint32_t>(domi::ImplyType::TVM);
501+ op_desc_info.input_format = {FORMAT_NCHW, FORMAT_NCHW};
502+ op_desc_info.input_shape = {{1}};
503+ op_desc_info.input_data_type = {DT_FLOAT};
504+ ExceptionDumper exception_dumper{};
505+ gert::GertRuntimeStub runtime_stub;
506+ dlog_setlevel(GE_MODULE_NAME, DLOG_INFO, 0);
507+ exception_dumper.LogExceptionTvmOpInfo(op_desc_info);
508+ EXPECT_TRUE(CheckLogExpected(runtime_stub.GetSlogStub().GetLogs(), "not equal, skip log op info"));
509+ dlog_setlevel(GE_MODULE_NAME, DLOG_ERROR, 0);
510+}
511+ 
512+TEST_F(UTEST_dump_exception, LogExceptionTvmOpInfo_OutputMismatch_CovEnhance) {
513+ OpDescInfo op_desc_info;
514+ op_desc_info.imply_type = static_cast<uint32_t>(domi::ImplyType::TVM);
515+ op_desc_info.input_format = {FORMAT_NCHW};
516+ op_desc_info.input_shape = {{1}};
517+ op_desc_info.input_data_type = {DT_FLOAT};
518+ op_desc_info.output_format = {FORMAT_NCHW, FORMAT_NCHW};
519+ op_desc_info.output_shape = {{1}};
520+ op_desc_info.output_data_type = {DT_FLOAT};
521+ ExceptionDumper exception_dumper{};
522+ gert::GertRuntimeStub runtime_stub;
523+ dlog_setlevel(GE_MODULE_NAME, DLOG_INFO, 0);
524+ exception_dumper.LogExceptionTvmOpInfo(op_desc_info);
525+ EXPECT_TRUE(CheckLogExpected(runtime_stub.GetSlogStub().GetLogs(), "not equal, skip log op info"));
526+ dlog_setlevel(GE_MODULE_NAME, DLOG_ERROR, 0);
527+}
528+ 
529+TEST_F(UTEST_dump_exception, LogExceptionTvmOpInfo_TvmSuccess_CovEnhance) {
530+ OpDescInfo op_desc_info;
531+ op_desc_info.op_name = "TestOp";
532+ op_desc_info.op_type = "TestType";
533+ op_desc_info.imply_type = static_cast<uint32_t>(domi::ImplyType::TVM);
534+ op_desc_info.input_format = {FORMAT_NCHW};
535+ op_desc_info.input_shape = {{1}};
536+ op_desc_info.input_data_type = {DT_FLOAT};
537+ op_desc_info.input_addrs = {reinterpret_cast<void *>(5000)};
538+ op_desc_info.output_format = {FORMAT_NCHW};
539+ op_desc_info.output_shape = {{1}};
540+ op_desc_info.output_data_type = {DT_FLOAT};
541+ op_desc_info.output_addrs = {reinterpret_cast<void *>(6000)};
542+ ExceptionDumper exception_dumper{};
543+ gert::GertRuntimeStub runtime_stub;
544+ dlog_setlevel(GE_MODULE_NAME, DLOG_INFO, 0);
545+ exception_dumper.LogExceptionTvmOpInfo(op_desc_info);
546+ EXPECT_TRUE(CheckLogExpected(runtime_stub.GetSlogStub().GetLogs(), "[AIC_INFO] node_name:"));
547+ dlog_setlevel(GE_MODULE_NAME, DLOG_ERROR, 0);
548+}
549+ 
550+TEST_F(UTEST_dump_exception, LogExceptionArgs_HostArgs_CovEnhance) {
551+ OpDescInfo op_desc_info;
552+ op_desc_info.args_before_execute = "test_args";
553+ op_desc_info.args = reinterpret_cast<uintptr_t>(nullptr);
554+ op_desc_info.is_host_args = true;
555+ ExceptionDumper exception_dumper{};
556+ gert::GertRuntimeStub runtime_stub;
557+ dlog_setlevel(GE_MODULE_NAME, DLOG_INFO, 0);
558+ exception_dumper.LogExceptionArgs(op_desc_info);
559+ EXPECT_TRUE(CheckLogExpected(runtime_stub.GetSlogStub().GetLogs(), "[AIC_INFO] test_args"));
560+ dlog_setlevel(GE_MODULE_NAME, DLOG_ERROR, 0);
561+}
562+ 
563+TEST_F(UTEST_dump_exception, GetOpDescInfo_ZeroArgs_CovEnhance) {
564+ ExceptionDumper exception_dumper;
565+ OpDescPtr op_desc = std::make_shared<OpDesc>("TestOp", "TestType");
566+ ExtraOpInfo extra_op_info;
567+ ge::OpDescInfoId id(10, 20, 0);
568+ exception_dumper.SaveDumpOpInfo(op_desc, extra_op_info, id, false);
569+ OpDescInfo result;
570+ EXPECT_TRUE(exception_dumper.GetOpDescInfo(id, result));
571+ EXPECT_EQ(result.op_name, "TestOp");
572+}
573+ 
574+TEST_F(UTEST_dump_exception, GetOpDescInfo_HostArgs_CovEnhance) {
575+ ExceptionDumper exception_dumper;
576+ OpDescPtr op_desc = std::make_shared<OpDesc>("TestOp2", "TestType2");
577+ ExtraOpInfo extra_op_info;
578+ extra_op_info.is_host_args = true;
579+ extra_op_info.args = 1000U;
580+ ge::OpDescInfoId id(20, 30, 0);
581+ exception_dumper.SaveDumpOpInfo(op_desc, extra_op_info, id, false);
582+ OpDescInfo result;
583+ EXPECT_TRUE(exception_dumper.GetOpDescInfo(id, result));
584+ EXPECT_EQ(result.op_name, "TestOp2");
585+}
586+ 
587+TEST_F(UTEST_dump_exception, GetOpDescInfo_NotFound_CovEnhance) {
588+ ExceptionDumper exception_dumper;
589+ OpDescPtr op_desc = std::make_shared<OpDesc>("TestOp3", "TestType3");
590+ ExtraOpInfo extra_op_info;
591+ ge::OpDescInfoId id(30, 40, 0);
592+ exception_dumper.SaveDumpOpInfo(op_desc, extra_op_info, id, false);
593+ OpDescInfo result;
594+ ge::OpDescInfoId wrong_id(999, 999, 0);
595+ EXPECT_FALSE(exception_dumper.GetOpDescInfo(wrong_id, result));
596+}
597+ 
598+TEST_F(UTEST_dump_exception, DumpNodeInfo_FftsPlus_CovEnhance) {
599+ ASSERT_TRUE(ge::CreateDirectory(temp_dump_path_) == 0);
600+ ge::DumpProperties dump_properties;
601+ dump_properties.AddPropertyValue("ALL_MODEL_NEED_DUMP_AND_IT_IS_NOT_A_MODEL_NAME", {"test"});
602+ dump_properties.SetDumpMode("all");
603+ 
604+ OpDescInfo op_desc_info;
605+ op_desc_info.op_name = "Save";
606+ op_desc_info.op_type = "Save";
607+ op_desc_info.id.task_id = 1;
608+ op_desc_info.id.stream_id = 2;
609+ op_desc_info.id.context_id = 1;
610+ op_desc_info.id.thread_id = 1;
611+ op_desc_info.input_format = {FORMAT_NCHW};
612+ op_desc_info.input_shape = {{1}};
613+ op_desc_info.input_data_type = {DT_FLOAT};
614+ op_desc_info.input_addrs = {nullptr};
615+ op_desc_info.input_size = {2};
616+ op_desc_info.output_format = {FORMAT_NCHW};
617+ op_desc_info.output_shape = {{1}};
618+ op_desc_info.output_data_type = {DT_FLOAT};
619+ op_desc_info.output_addrs = {nullptr};
620+ op_desc_info.output_size = {2};
621+ ExceptionDumper exception_dumper;
622+ EXPECT_EQ(exception_dumper.DumpNodeInfo(op_desc_info, temp_dump_path_, false, true, dump_properties), ge::SUCCESS);
623+}
624+ 
625+TEST_F(UTEST_dump_exception, DumpDevMem_MallocHostFail_CovEnhance) {
626+ auto ret = ExceptionDumper::DumpDevMem("test_file", reinterpret_cast<const void *>(5000), 123U);
627+ EXPECT_NE(ret, ge::SUCCESS);
628+}
629+ 
630+TEST_F(UTEST_dump_exception, DumpDevMem_MemcpyFail_CovEnhance) {
631+ mmSetEnv("CONSTANT_FOLDING_PASS", "mock_fail", 1);
632+ auto ret = ExceptionDumper::DumpDevMem("test_file", reinterpret_cast<const void *>(5000), 64U);
633+ EXPECT_NE(ret, ge::SUCCESS);
634+ unsetenv("CONSTANT_FOLDING_PASS");
635+}
636+ 
637+TEST_F(UTEST_dump_exception, DumpExceptionInput_WithException_CovEnhance) {
638+ ge::DumpProperties dump_properties;
639+ dump_properties.AddPropertyValue("ALL_MODEL_NEED_DUMP_AND_IT_IS_NOT_A_MODEL_NAME", {"test"});
640+ dump_properties.SetDumpMode("all");
641+ 
642+ OpDescInfo op_desc_info;
643+ op_desc_info.op_name = "Save";
644+ op_desc_info.op_type = "Save";
645+ op_desc_info.id.task_id = 1;
646+ op_desc_info.input_addrs = {nullptr};
647+ op_desc_info.input_size = {2};
648+ ExceptionDumper exception_dumper;
649+ EXPECT_EQ(exception_dumper.DumpExceptionInput(op_desc_info, "/", true, dump_properties), ge::SUCCESS);
650+}
651+ 
652+TEST_F(UTEST_dump_exception, DumpExceptionOutput_WithException_CovEnhance) {
653+ ge::DumpProperties dump_properties;
654+ dump_properties.AddPropertyValue("ALL_MODEL_NEED_DUMP_AND_IT_IS_NOT_A_MODEL_NAME", {"test"});
655+ dump_properties.SetDumpMode("all");
656+ 
657+ OpDescInfo op_desc_info;
658+ op_desc_info.op_name = "Save";
659+ op_desc_info.op_type = "Save";
660+ op_desc_info.id.task_id = 1;
661+ op_desc_info.output_addrs = {nullptr};
662+ op_desc_info.output_size = {2};
663+ ExceptionDumper exception_dumper;
664+ EXPECT_EQ(exception_dumper.DumpExceptionOutput(op_desc_info, "/", true, dump_properties), ge::SUCCESS);
665+}
666+ 
667+TEST_F(UTEST_dump_exception, SaveDumpOpInfo_WithExtraSizes_CovEnhance) {
668+ OpDescPtr op_desc = std::make_shared<OpDesc>("GatherV2", "GatherV2");
669+ GeTensorDesc tensor(GeShape(), FORMAT_NCHW, DT_FLOAT);
670+ TensorUtils::SetSize(tensor, 512);
671+ op_desc->AddInputDesc(tensor);
672+ op_desc->AddOutputDesc(tensor);
673+ ExtraOpInfo extra_op_info;
674+ extra_op_info.input_sizes = {256};
675+ extra_op_info.output_sizes = {256};
676+ ExceptionDumper exception_dumper;
677+ ge::OpDescInfoId id(1, 233, 0);
678+ EXPECT_NO_THROW(exception_dumper.SaveDumpOpInfo(op_desc, extra_op_info, id, false));
679+}
680+ 
681+TEST_F(UTEST_dump_exception, DumpExceptionWorkspace_WithException_CovEnhance) {
682+ ge::DumpProperties dump_properties;
683+ dump_properties.AddPropertyValue("ALL_MODEL", {"test"});
684+ dump_properties.SetDumpMode("all");
685+ 
686+ OpDescInfo op_desc_info;
687+ op_desc_info.op_name = "Save";
688+ op_desc_info.op_type = "Save";
689+ op_desc_info.id.task_id = 1;
690+ op_desc_info.space_addrs = {nullptr};
691+ op_desc_info.workspace_bytes = {8};
692+ ExceptionDumper exception_dumper;
693+ EXPECT_EQ(exception_dumper.DumpExceptionWorkspace(op_desc_info, "/", true, dump_properties), ge::SUCCESS);
694+}
695+ 
696+TEST_F(UTEST_dump_exception, Clear_Empty_CovEnhance) {
697+ ExceptionDumper exception_dumper;
698+ EXPECT_NO_THROW(exception_dumper.Clear());
699+}
485} // namespace ge700} // namespace ge
Mtests/ge/ut/ge/common/dump_op_unittest.cc+98-0
@@ -1001,4 +1001,102 @@ TEST_F(UTEST_dump_op, dump_input_tensor_size_fail) {
1001 EXPECT_NE(ret, ge::SUCCESS);1001 EXPECT_NE(ret, ge::SUCCESS);
1002 g_acl_stub_mock.clear();1002 g_acl_stub_mock.clear();
1003}1003}
1004+ 
1005+TEST_F(UTEST_dump_op, proto_malloc_memcpy_fail_CovEnhance) {
1006+ DumpOp dump_op;
1007+ DumpProperties dump_properties;
1008+ OpDescPtr op_desc = std::make_shared<OpDesc>("GatherV2", "GatherV2");
1009+ GeTensorDesc tensor(GeShape({1, 2, 3}), FORMAT_NCHW, DT_FLOAT);
1010+ op_desc->AddInputDesc(tensor);
1011+ op_desc->AddOutputDesc(tensor);
1012+ std::set<std::string> temp;
1013+ dump_properties.model_dump_properties_map_.emplace("model1", temp);
1014+ dump_properties.enable_dump_ = "1";
1015+ dump_properties.dump_mode_ = "output";
1016+ dump_op.SetDynamicModelInfo("model1", "model2", 1);
1017+ std::vector<uintptr_t> input_addrs = {0};
1018+ std::vector<uintptr_t> output_addrs = {0x1000};
1019+ dump_op.SetDumpInfo(dump_properties, op_desc, input_addrs, output_addrs, nullptr);
1020+ g_acl_stub_mock = "aclrtMemcpy";
1021+ auto ret = dump_op.LaunchDumpOp(false);
1022+ EXPECT_NE(ret, ge::SUCCESS);
1023+ g_acl_stub_mock.clear();
1024+}
1025+ 
1026+TEST_F(UTEST_dump_op, launch_dump_all_output_fail_CovEnhance) {
1027+ DumpOp dump_op;
1028+ DumpProperties dump_properties;
1029+ OpDescPtr op_desc = std::make_shared<OpDesc>("conv", "conv");
1030+ GeTensorDesc tensor(GeShape({1, -1}), FORMAT_NCHW, DT_FLOAT);
1031+ op_desc->AddOutputDesc(tensor);
1032+ std::set<std::string> temp;
1033+ dump_properties.model_dump_properties_map_.emplace("model1", temp);
1034+ dump_properties.enable_dump_ = "1";
1035+ dump_properties.dump_mode_ = "all";
1036+ dump_op.SetDynamicModelInfo("model1", "model2", 1);
1037+ std::vector<uintptr_t> output_addrs = {0x1000};
1038+ dump_op.SetDumpInfo(dump_properties, op_desc, {}, output_addrs, nullptr);
1039+ auto ret = dump_op.LaunchDumpOp(false);
1040+ EXPECT_NE(ret, ge::SUCCESS);
1041+}
1042+ 
1043+TEST_F(UTEST_dump_op, launch_dump_all_input_fail_CovEnhance) {
1044+ DumpOp dump_op;
1045+ DumpProperties dump_properties;
1046+ OpDescPtr op_desc = std::make_shared<OpDesc>("conv", "conv");
1047+ GeTensorDesc out_tensor(GeShape({1, 2, 3}), FORMAT_NCHW, DT_FLOAT);
1048+ op_desc->AddOutputDesc(out_tensor);
1049+ GeTensorDesc in_tensor(GeShape({INT64_MAX, 2}), FORMAT_NCHW, DT_FLOAT);
1050+ op_desc->AddInputDesc(in_tensor);
1051+ std::set<std::string> temp;
1052+ dump_properties.model_dump_properties_map_.emplace("model1", temp);
1053+ dump_properties.enable_dump_ = "1";
1054+ dump_properties.dump_mode_ = "all";
1055+ dump_op.SetDynamicModelInfo("model1", "model2", 1);
1056+ int dummy = 0;
1057+ std::vector<uintptr_t> input_addrs = {reinterpret_cast<uintptr_t>(&dummy)};
1058+ std::vector<uintptr_t> output_addrs = {0x1000};
1059+ dump_op.SetDumpInfo(dump_properties, op_desc, input_addrs, output_addrs, nullptr);
1060+ auto ret = dump_op.LaunchDumpOp(false);
1061+ EXPECT_NE(ret, ge::SUCCESS);
1062+}
1063+ 
1064+TEST_F(UTEST_dump_op, update_addrs_output_fail_CovEnhance) {
1065+ DumpOp dump_op;
1066+ DumpProperties dump_properties;
1067+ OpDescPtr op_desc = std::make_shared<OpDesc>("conv", "conv");
1068+ GeTensorDesc tensor(GeShape({1, -1}), FORMAT_NCHW, DT_FLOAT);
1069+ op_desc->AddOutputDesc(tensor);
1070+ std::set<std::string> temp;
1071+ dump_properties.model_dump_properties_map_.emplace("model1", temp);
1072+ dump_properties.enable_dump_ = "1";
1073+ dump_properties.dump_mode_ = "output";
1074+ dump_op.SetDynamicModelInfo("model1", "model2", 1);
1075+ std::vector<uintptr_t> output_addrs = {0x1000};
1076+ dump_op.SetDumpInfo(dump_properties, op_desc, {}, output_addrs, nullptr);
1077+ toolkit::aicpu::dump::Task task;
1078+ dump_op.op_mapping_info_.mutable_task()->Add(std::move(task));
1079+ auto ret = dump_op.UpdateAddrs({}, output_addrs);
1080+ EXPECT_NE(ret, ge::SUCCESS);
1081+}
1082+ 
1083+TEST_F(UTEST_dump_op, update_addrs_input_fail_CovEnhance) {
1084+ DumpOp dump_op;
1085+ DumpProperties dump_properties;
1086+ OpDescPtr op_desc = std::make_shared<OpDesc>("conv", "conv");
1087+ GeTensorDesc in_tensor(GeShape({INT64_MAX, 2}), FORMAT_NCHW, DT_FLOAT);
1088+ op_desc->AddInputDesc(in_tensor);
1089+ std::set<std::string> temp;
1090+ dump_properties.model_dump_properties_map_.emplace("model1", temp);
1091+ dump_properties.enable_dump_ = "1";
1092+ dump_properties.dump_mode_ = "input";
1093+ dump_op.SetDynamicModelInfo("model1", "model2", 1);
1094+ int dummy = 0;
1095+ std::vector<uintptr_t> input_addrs = {reinterpret_cast<uintptr_t>(&dummy)};
1096+ dump_op.SetDumpInfo(dump_properties, op_desc, input_addrs, {}, nullptr);
1097+ toolkit::aicpu::dump::Task task;
1098+ dump_op.op_mapping_info_.mutable_task()->Add(std::move(task));
1099+ auto ret = dump_op.UpdateAddrs(input_addrs, {});
1100+ EXPECT_NE(ret, ge::SUCCESS);
1101+}
1004} // namespace ge1102} // namespace ge
Mtests/ge/ut/ge/common/file_constant_unittest.cc+127-0
@@ -11,6 +11,7 @@
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12#include <memory>12#include <memory>
13#include <fstream>13#include <fstream>
14+#include <limits>
14 15 
15#include "macro_utils/dt_public_scope.h"16#include "macro_utils/dt_public_scope.h"
16#include "common/file_constant_utils/file_constant_utils.h"17#include "common/file_constant_utils/file_constant_utils.h"
@@ -897,5 +898,131 @@ TEST_F(UtestFileConstantUtilTransfer, ChangeFilePathAttr_EmptyAndNoTmpDir) {
897 EXPECT_EQ(ret, SUCCESS);898 EXPECT_EQ(ret, SUCCESS);
898 (void)mmRmdir("om_path");899 (void)mmRmdir("om_path");
899}900}
901+ 
902+TEST_F(UtestFileConstantUtilTransfer, SaveWeightToOneFile_AllExist_CovEnhance) {
903+ ConstNodeWeightHashList list;
904+ auto graph = std::make_shared<ComputeGraph>("test_graph");
905+ auto op_desc = std::make_shared<OpDesc>("const1", "Const");
906+ auto node = graph->AddNode(op_desc);
907+ GeTensorPtr tensor = std::make_shared<GeTensor>();
908+ std::vector<uint8_t> data(4, 1);
909+ tensor->SetData(data);
910+ list.emplace_back(node, std::make_pair(tensor, "hash1"));
911+ 
912+ FileConstantMeta meta;
913+ meta.hash_to_weight_file["hash1"] = "/tmp/weight1";
914+ 
915+ std::string weight_dir = "./test_all_exist_dir";
916+ ASSERT_TRUE(CreateDirectory(weight_dir) == 0);
917+ auto ret = FileConstantUtils::SaveWeightToOneFileWithReuse(list, weight_dir, meta);
918+ EXPECT_EQ(ret, SUCCESS);
919+ (void)mmRmdir(weight_dir.c_str());
920+}
921+ 
922+TEST_F(UtestFileConstantUtilTransfer, SaveWeightToOneFile_OpenFail_CovEnhance) {
923+ ConstNodeWeightHashList list;
924+ auto graph = std::make_shared<ComputeGraph>("test_graph");
925+ auto op_desc = std::make_shared<OpDesc>("const1", "Const");
926+ auto node = graph->AddNode(op_desc);
927+ GeTensorPtr tensor = std::make_shared<GeTensor>();
928+ std::vector<uint8_t> data(4, 1);
929+ tensor->SetData(data);
930+ list.emplace_back(node, std::make_pair(tensor, "hash1"));
931+ 
932+ FileConstantMeta meta;
933+ std::string weight_dir = "/nonexistent_dir/no_such_path";
934+ auto ret = FileConstantUtils::SaveWeightToOneFileWithReuse(list, weight_dir, meta);
935+ EXPECT_EQ(ret, FAILED);
936+}
937+ 
938+TEST_F(UtestFileConstantUtilTransfer, WriteWeightWithPadding_WriteFail_CovEnhance) {
939+ std::ofstream ofs;
940+ uint8_t data[] = {1, 2, 3, 4};
941+ size_t offset = 0;
942+ auto ret = FileConstantUtils::WriteWeightWithPadding(ofs, data, sizeof(data), offset);
943+ EXPECT_EQ(ret, FAILED);
944+}
945+ 
946+TEST_F(UtestFileConstantUtilTransfer, WriteWeightWithPadding_WithPadding_CovEnhance) {
947+ std::string file_name = "test_padding_write.bin";
948+ std::ofstream ofs(file_name, std::ios::binary);
949+ ASSERT_TRUE(ofs.is_open());
950+ uint8_t data[] = {1, 2, 3, 4};
951+ size_t offset = 0;
952+ auto ret = FileConstantUtils::WriteWeightWithPadding(ofs, data, sizeof(data), offset);
953+ EXPECT_EQ(ret, SUCCESS);
954+ EXPECT_EQ(offset, 512U);
955+ ofs.close();
956+ (void)remove(file_name.c_str());
957+}
958+ 
959+TEST_F(UtestFileConstantUtilTransfer, WriteWeightWithPadding_OffsetOverflow_CovEnhance) {
960+ std::string file_name = "test_overflow_write.bin";
961+ std::ofstream ofs(file_name, std::ios::binary);
962+ ASSERT_TRUE(ofs.is_open());
963+ uint8_t data[] = {1, 2, 3, 4};
964+ size_t offset = std::numeric_limits<size_t>::max() - 10;
965+ auto ret = FileConstantUtils::WriteWeightWithPadding(ofs, data, sizeof(data), offset);
966+ EXPECT_EQ(ret, FAILED);
967+ ofs.close();
968+ (void)remove(file_name.c_str());
969+}
970+ 
971+TEST_F(UtestFileConstantUtilTransfer, ChangeFilePathAttr_NoTmpDir_CovEnhance) {
972+ std::string file_name = "test_no_tmp_dir_file.bin";
973+ std::ofstream ofs(file_name, std::ios::binary);
974+ ofs << "test";
975+ ofs.close();
976+ 
977+ auto builder = ut::GraphBuilder("graph_no_tmp");
978+ auto file_const = builder.AddNode("fc_notmp", FILECONSTANT, 0, 1, FORMAT_ND, DT_FLOAT, {3});
979+ OpDescPtr op_desc = file_const->GetOpDesc();
980+ EXPECT_TRUE(AttrUtils::SetStr(op_desc, ATTR_NAME_LOCATION, file_name));
981+ 
982+ auto netoutput = builder.AddNode("out_notmp", "NetOutput", 1, 0);
983+ builder.AddDataEdge(file_const, 0, netoutput, 0);
984+ auto graph = builder.GetGraph();
985+ 
986+ std::string om_path = "om_path_no_tmp/test.om";
987+ auto ret = FileConstantUtils::ChangeFilePath(graph, om_path);
988+ EXPECT_EQ(ret, SUCCESS);
989+ (void)remove(file_name.c_str());
990+ (void)mmRmdir("om_path_no_tmp");
991+}
992+ 
993+TEST_F(UtestFileConstantUtilTransfer, ReadJsonFile_InvalidJson_CovEnhance) {
994+ ExternalWeightManagerPool::Instance().Destroy();
995+ GetContext().SetSessionId(0U);
996+ 
997+ std::string weight_dir = "./test_invalid_json/weight";
998+ ASSERT_TRUE(CreateDirectory(weight_dir) == 0);
999+ std::string meta_path = weight_dir + "/meta.json";
1000+ std::ofstream meta_ofs(meta_path);
1001+ meta_ofs << "{invalid json content";
1002+ meta_ofs.close();
1003+ 
1004+ const auto &external_weight_manager = ExternalWeightManagerPool::Instance().GetManager(GetContext().SessionId());
1005+ ASSERT_NE(external_weight_manager, nullptr);
1006+ external_weight_manager->SetWeightPath(weight_dir);
1007+ 
1008+ ge::ut::GraphBuilder builder("graph_invalid_json");
1009+ auto const1 = builder.AddNode("const_invalid", "Const", 0, 1);
1010+ ge::GeTensorPtr tensor = std::make_shared<GeTensor>();
1011+ std::vector<uint8_t> value(4 * sizeof(float));
1012+ std::vector<int64_t> shape{4};
1013+ tensor->MutableTensorDesc().SetShape(GeShape(shape));
1014+ tensor->SetData(value);
1015+ tensor->MutableTensorDesc().SetDataType(DT_FLOAT);
1016+ ConstantUtils::SetWeight(const1->GetOpDesc(), 0, tensor);
1017+ AttrUtils::SetStr(const1->GetOpDesc(), ATTR_NAME_WEIGHT_SHA256, "hash_invalid");
1018+ 
1019+ auto ret = FileConstantUtils::ConvertConstToFileConst(builder.GetGraph());
1020+ EXPECT_NE(ret, SUCCESS);
1021+ 
1022+ (void)remove(meta_path.c_str());
1023+ (void)mmRmdir(weight_dir.c_str());
1024+ (void)mmRmdir("./test_invalid_json");
1025+ ExternalWeightManagerPool::Instance().Destroy();
1026+}
900} // namespace fileconstant1027} // namespace fileconstant
901} // namespace ge1028} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_fractal_nz_unittest.cc+90-0
@@ -7331,5 +7331,95 @@ TEST_F(UtestFormatTransferNdFractNz, invalid_src_dst_shape_relation) {
7331 FormatTransferFractalNzND transfer;7331 FormatTransferFractalNzND transfer;
7332 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);7332 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
7333}7333}
7334+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_fp16_success) {
7335+ uint16_t data[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
7336+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7337+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7338+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7339+ src_format,
7340+ dst_format,
7341+ FORMAT_ND,
7342+ FORMAT_FRACTAL_NZ,
7343+ FORMAT_RESERVED,
7344+ FORMAT_RESERVED,
7345+ 16,
7346+ 16,
7347+ {16},
7348+ {1, 1, 16, 16},
7349+ DT_FLOAT16};
7350+ TransResult result;
7351+ FormatTransferFractalNz transfer;
7352+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
7353+ std::vector<int64_t> expect_shape;
7354+ EXPECT_EQ(transfer.TransShape(src_format, {16}, DT_FLOAT16, dst_format, expect_shape), SUCCESS);
7355+}
7356+ 
7357+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_fp16_reverse_success) {
7358+ uint16_t data[1 * 1 * 16 * 16] = {0};
7359+ data[0] = 1;
7360+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7361+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7362+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7363+ src_format,
7364+ dst_format,
7365+ FORMAT_FRACTAL_NZ,
7366+ FORMAT_ND,
7367+ FORMAT_RESERVED,
7368+ FORMAT_RESERVED,
7369+ 16,
7370+ 16,
7371+ {1, 1, 16, 16},
7372+ {16},
7373+ DT_FLOAT16};
7374+ TransResult result;
7375+ FormatTransferFractalNzND transfer;
7376+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
7377+}
7378+ 
7379+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_invalid_data_type) {
7380+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7381+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7382+ std::vector<int64_t> dst_shape;
7383+ FormatTransferFractalNz transfer;
7384+ EXPECT_EQ(transfer.TransShape(src_format, {16}, DT_STRING, dst_format, dst_shape), ACL_ERROR_GE_DATATYPE_INVALID);
7385+}
7386+ 
7387+TEST_F(UtestFormatTransferNdFractNz, nd_invalid_format_trans_shape) {
7388+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7389+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7390+ std::vector<int64_t> dst_shape;
7391+ FormatTransferFractalNz transfer;
7392+ EXPECT_EQ(transfer.TransShape(FORMAT_RESERVED, {16}, DT_FLOAT16, dst_format, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
7393+}
7394+ 
7395+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_reverse_invalid_data_type) {
7396+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7397+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7398+ uint16_t data[1] = {0};
7399+ TransArgs args{reinterpret_cast<uint8_t *>(data),
7400+ src_format,
7401+ dst_format,
7402+ FORMAT_FRACTAL_NZ,
7403+ FORMAT_ND,
7404+ FORMAT_RESERVED,
7405+ FORMAT_RESERVED,
7406+ 16,
7407+ 16,
7408+ {1, 1, 16, 16},
7409+ {16},
7410+ DT_STRING};
7411+ TransResult result;
7412+ FormatTransferFractalNzND transfer;
7413+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_DATATYPE_INVALID);
7414+}
7415+ 
7416+TEST_F(UtestFormatTransferNdFractNz, nd_shape1_trans_shape_ndz_to_nd) {
7417+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_NZ, FORMAT_RESERVED, 5));
7418+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
7419+ std::vector<int64_t> dst_shape;
7420+ FormatTransferFractalNzND transfer;
7421+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 16, 16}, DT_FLOAT16, dst_format, dst_shape),
7422+ ACL_ERROR_GE_FORMAT_INVALID);
7423+}
7334} // namespace formats7424} // namespace formats
7335} // namespace ge7425} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_fractal_zz_unittest.cc+57-0
@@ -8641,5 +8641,62 @@ TEST_F(UtestFormatTransferNdFractZz, invalid_src_dst_shape_relation) {
8641 FormatTransferFractalZzND transfer;8641 FormatTransferFractalZzND transfer;
8642 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);8642 EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
8643}8643}
8644+TEST_F(UtestFormatTransferNdFractZz, invalid_data_type_trans_shape) {
8645+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 6));
8646+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 6));
8647+ std::vector<int64_t> dst_shape;
8648+ FormatTransferFractalZz transfer;
8649+ EXPECT_EQ(transfer.TransShape(src_format, {32}, DT_STRING, dst_format, dst_shape), ACL_ERROR_GE_DATATYPE_INVALID);
8650+}
8651+ 
8652+TEST_F(UtestFormatTransferNdFractZz, invalid_format_trans_shape) {
8653+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 6));
8654+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 6));
8655+ std::vector<int64_t> dst_shape;
8656+ FormatTransferFractalZz transfer;
8657+ EXPECT_EQ(transfer.TransShape(FORMAT_RESERVED, {32}, DT_UINT8, dst_format, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
8658+}
8659+ 
8660+TEST_F(UtestFormatTransferNdFractZz, invalid_data_type_trans_format) {
8661+ uint8_t data[32] = {0};
8662+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 6));
8663+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 6));
8664+ TransArgs args{data, src_format, dst_format, FORMAT_ND, FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, FORMAT_RESERVED,
8665+ 32, 32, {32}, {1, 1, 32, 32}, DT_STRING};
8666+ TransResult result;
8667+ FormatTransferFractalZz transfer;
8668+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_DATATYPE_INVALID);
8669+}
8670+ 
8671+TEST_F(UtestFormatTransferNdFractZz, invalid_data_type_nd_trans_format) {
8672+ uint8_t data[1 * 1 * 32 * 32] = {0};
8673+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 6));
8674+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 6));
8675+ TransArgs args{data, src_format, dst_format, FORMAT_FRACTAL_ZZ, FORMAT_ND, FORMAT_RESERVED, FORMAT_RESERVED, 32,
8676+ 32, {1, 1, 32, 32}, {32}, DT_STRING};
8677+ TransResult result;
8678+ FormatTransferFractalZzND transfer;
8679+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_DATATYPE_INVALID);
8680+}
8681+ 
8682+TEST_F(UtestFormatTransferNdFractZz, nd_shape1_reverse_invalid_dst_shape_relation) {
8683+ uint8_t data[1 * 1 * 32 * 32] = {0};
8684+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 6));
8685+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 6));
8686+ TransArgs args{data, src_format, dst_format, FORMAT_FRACTAL_ZZ, FORMAT_ND, FORMAT_RESERVED, FORMAT_RESERVED, 32,
8687+ 32, {1, 1, 32, 32}, {33}, DT_UINT8};
8688+ TransResult result;
8689+ FormatTransferFractalZzND transfer;
8690+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
8691+}
8692+ 
8693+TEST_F(UtestFormatTransferNdFractZz, nd_trans_shape_fzz_to_nd_invalid) {
8694+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_ZZ, FORMAT_RESERVED, 6));
8695+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 6));
8696+ std::vector<int64_t> dst_shape;
8697+ FormatTransferFractalZzND transfer;
8698+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 32, 32}, DT_UINT8, dst_format, dst_shape),
8699+ ACL_ERROR_GE_FORMAT_INVALID);
8700+}
8644} // namespace formats8701} // namespace formats
8645} // namespace ge8702} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_fzc04_unittest.cc+45-0
@@ -3818,5 +3818,50 @@ TEST_F(UtestFormatTransfer4DToFZC04, hwcn_fzc04_hwcn_success_4) {
3818 }3818 }
3819 delete[] ret;3819 delete[] ret;
3820}3820}
3821+TEST_F(UtestFormatTransfer4DToFZC04, fzc04_to_4d_trans_shape_invalid) {
3822+ std::vector<int64_t> dst_shape;
3823+ FormatTransferFZC04To4D transfer;
3824+ EXPECT_EQ(transfer.TransShape(FORMAT_FRACTAL_Z_C04, {1, 1, 16, 16}, DT_FLOAT16, FORMAT_HWCN, dst_shape),
3825+ ACL_ERROR_GE_FORMAT_INVALID);
3826+}
3827+ 
3828+TEST_F(UtestFormatTransfer4DToFZC04, fzc04_to_4d_invalid_src_format) {
3829+ uint8_t data[1] = {0};
3830+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
3831+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
3832+ TransArgs args{data, src_format, dst_format, FORMAT_NCHW, FORMAT_HWCN, FORMAT_RESERVED, FORMAT_RESERVED,
3833+ 16, 16, {1, 1, 16, 16}, {1, 1, 16, 16}, DT_FLOAT16};
3834+ TransResult result;
3835+ FormatTransferFZC04To4D transfer;
3836+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);
3837+}
3838+ 
3839+TEST_F(UtestFormatTransfer4DToFZC04, trans_shape_invalid_dst_format) {
3840+ std::vector<int64_t> src_shape = {4, 4, 16, 16};
3841+ std::vector<int64_t> dst_shape;
3842+ FormatTransfer4DToFZC04 transfer;
3843+ EXPECT_EQ(transfer.TransShape(FORMAT_NCHW, src_shape, DT_UINT8, FORMAT_NCHW, dst_shape), ACL_ERROR_GE_FORMAT_INVALID);
3844+}
3845+ 
3846+TEST_F(UtestFormatTransfer4DToFZC04, nchw_to_fzc04_empty_tensor) {
3847+ uint8_t data[1] = {0};
3848+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, sub_format_groups_1, 6));
3849+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z_C04, sub_format_groups_1, 6));
3850+ TransArgs args{data,
3851+ src_format,
3852+ dst_format,
3853+ FORMAT_NCHW,
3854+ FORMAT_FRACTAL_Z_C04,
3855+ sub_format_groups_1,
3856+ sub_format_groups_1,
3857+ 32,
3858+ 32,
3859+ {0, 4, 16, 16},
3860+ {0, 1, 16, 32},
3861+ DT_UINT8};
3862+ TransResult result;
3863+ FormatTransfer4DToFZC04 transfer;
3864+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
3865+}
3821} // namespace formats3866} // namespace formats
3822} // namespace ge3867} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_hwcn_c1hwncoc0_unittest.cc+40-0
@@ -13939,5 +13939,45 @@ TEST_F(UtestFormatTransferHwcnC1hwncoc0, hwcn_to_6d_fp32_success_gt_cube) {
13939 EXPECT_EQ((reinterpret_cast<float *>(result.data.get()))[i], data_6d[i]);13939 EXPECT_EQ((reinterpret_cast<float *>(result.data.get()))[i], data_6d[i]);
13940 }13940 }
13941}13941}
13942+TEST_F(UtestFormatTransferHwcnC1hwncoc0, empty_tensor_success) {
13943+ uint8_t data[1] = {0};
13944+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
13945+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_C1HWNCoC0, FORMAT_RESERVED, 5));
13946+ TransArgs args{
13947+ data, src_format, dst_format, FORMAT_HWCN, FORMAT_C1HWNCoC0, FORMAT_RESERVED, FORMAT_RESERVED,
13948+ 16, 16, {1, 1, 0, 1}, {0, 1, 1, 1, 16, 16}, DT_FLOAT};
13949+ TransResult result;
13950+ FormatTransferHwcnC1hwncoc0 transfer;
13951+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
13952+ EXPECT_EQ(result.length, 0U);
13953+}
13954+ 
13955+TEST_F(UtestFormatTransferHwcnC1hwncoc0, invalid_data_type_trans_shape) {
13956+ FormatTransferHwcnC1hwncoc0 transfer;
13957+ std::vector<int64_t> dst_shape;
13958+ EXPECT_EQ(transfer.TransShape(FORMAT_HWCN, {1, 1, 1, 1}, DT_DOUBLE, FORMAT_C1HWNCoC0, dst_shape),
13959+ ACL_ERROR_GE_DATATYPE_INVALID);
13960+}
13961+ 
13962+TEST_F(UtestFormatTransferHwcnC1hwncoc0, invalid_format_trans_shape) {
13963+ FormatTransferHwcnC1hwncoc0 transfer;
13964+ std::vector<int64_t> dst_shape;
13965+ EXPECT_EQ(transfer.TransShape(FORMAT_NCHW, {1, 1, 1, 1}, DT_FLOAT, FORMAT_C1HWNCoC0, dst_shape),
13966+ ACL_ERROR_GE_FORMAT_INVALID);
13967+}
13968+ 
13969+TEST_F(UtestFormatTransferHwcnC1hwncoc0, invalid_src_shape_trans_shape) {
13970+ FormatTransferHwcnC1hwncoc0 transfer;
13971+ std::vector<int64_t> dst_shape;
13972+ EXPECT_EQ(transfer.TransShape(FORMAT_HWCN, {1, 1}, DT_FLOAT, FORMAT_C1HWNCoC0, dst_shape),
13973+ ACL_ERROR_GE_SHAPE_INVALID);
13974+}
13975+ 
13976+TEST_F(UtestFormatTransferHwcnC1hwncoc0, invalid_dst_shape_trans_shape_mismatch) {
13977+ FormatTransferHwcnC1hwncoc0 transfer;
13978+ std::vector<int64_t> 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);
13981+}
13942} // namespace formats13982} // namespace formats
13943} // namespace ge13983} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_hwcn_fractalz_unittest.cc+67-0
@@ -34753,5 +34753,72 @@ TEST_F(UtestFormatTransferHwcnFz, build_transfer_not_support) {
34753 auto transfer = BuildFormatTransfer(args);34753 auto transfer = BuildFormatTransfer(args);
34754 EXPECT_EQ(transfer, nullptr);34754 EXPECT_EQ(transfer, nullptr);
34755}34755}
34756+TEST_F(UtestFormatTransferHwcnFz, invalid_data_type_trans_shape) {
34757+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
34758+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
34759+ std::vector<int64_t> dst_shape;
34760+ FormatTransferFractalZ transfer;
34761+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 1, 1}, DT_STRING, dst_format, dst_shape),
34762+ ACL_ERROR_GE_DATATYPE_INVALID);
34763+}
34764+ 
34765+TEST_F(UtestFormatTransferHwcnFz, invalid_format_trans_shape) {
34766+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
34767+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
34768+ std::vector<int64_t> dst_shape;
34769+ FormatTransferFractalZ transfer;
34770+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 1, 1}, DT_FLOAT16, dst_format, dst_shape),
34771+ ACL_ERROR_GE_FORMAT_INVALID);
34772+}
34773+ 
34774+TEST_F(UtestFormatTransferHwcnFz, invalid_dst_shape_relation) {
34775+ uint16_t data[1 * 1 * 1 * 1] = {0};
34776+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
34777+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
34778+ TransArgs args{reinterpret_cast<uint8_t *>(data),
34779+ src_format,
34780+ dst_format,
34781+ FORMAT_HWCN,
34782+ FORMAT_FRACTAL_Z,
34783+ FORMAT_RESERVED,
34784+ FORMAT_RESERVED,
34785+ 16,
34786+ 16,
34787+ {1, 1, 1, 1},
34788+ {2, 1, 16, 16},
34789+ DT_FLOAT16};
34790+ TransResult result;
34791+ FormatTransferFractalZ transfer;
34792+ EXPECT_EQ(transfer.TransFormat(args, result), FAILED);
34793+}
34794+ 
34795+TEST_F(UtestFormatTransferHwcnFz, hwcn_invalid_src_shape_trans_shape) {
34796+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
34797+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
34798+ std::vector<int64_t> dst_shape;
34799+ FormatTransferFractalZ transfer;
34800+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 1}, DT_FLOAT16, dst_format, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
34801+}
34802+ 
34803+TEST_F(UtestFormatTransferHwcnFz, unsupported_format_trans_format) {
34804+ uint16_t data[1 * 1 * 1 * 1] = {0};
34805+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
34806+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_HWCN, FORMAT_RESERVED, 5));
34807+ TransArgs args{reinterpret_cast<uint8_t *>(data),
34808+ src_format,
34809+ dst_format,
34810+ FORMAT_NCHW,
34811+ FORMAT_HWCN,
34812+ FORMAT_RESERVED,
34813+ FORMAT_RESERVED,
34814+ 16,
34815+ 16,
34816+ {1, 1, 1, 1},
34817+ {1, 1, 1, 1},
34818+ DT_FLOAT16};
34819+ TransResult result;
34820+ FormatTransferFractalZ transfer;
34821+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);
34822+}
34756} // namespace formats34823} // namespace formats
34757} // namespace ge34824} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nchw_5d_unittest.cc+24-0
@@ -824,5 +824,29 @@ TEST_F(UtestFormatTransferNchw5d, invalid_data_format) {
824 EXPECT_EQ(transfer.TransShape(args.src_format, args.src_shape, args.src_data_type, args.dst_format, args.dst_shape),824 EXPECT_EQ(transfer.TransShape(args.src_format, args.src_shape, args.src_data_type, args.dst_format, args.dst_shape),
825 ACL_ERROR_GE_FORMAT_INVALID);825 ACL_ERROR_GE_FORMAT_INVALID);
826}826}
827+TEST_F(UtestFormatTransferNchw5d, invalid_data_type_no_c0_trans_shape) {
828+ FormatTransferNchwNc1hwc0 transfer;
829+ std::vector<int64_t> dst_shape;
830+ EXPECT_EQ(transfer.TransShape(FORMAT_NCHW, {1, 1, 1, 16}, DT_STRING, FORMAT_NC1HWC0, dst_shape),
831+ ACL_ERROR_GE_DATATYPE_INVALID);
832+}
833+ 
834+TEST_F(UtestFormatTransferNchw5d, empty_tensor_success) {
835+ uint8_t data[1] = {0};
836+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
837+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NC1HWC0, FORMAT_RESERVED, 5));
838+ TransArgs args{data, src_format, dst_format, FORMAT_NCHW, FORMAT_NC1HWC0, FORMAT_RESERVED, FORMAT_RESERVED,
839+ 16, 16, {0, 1, 1, 16}, {0, 1, 1, 16, 16}, DT_FLOAT16};
840+ TransResult result;
841+ FormatTransferNchwNc1hwc0 transfer;
842+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
843+ EXPECT_EQ(result.length, 0U);
844+}
845+ 
846+TEST_F(UtestFormatTransferNchw5d, invalid_src_shape_trans_shape) {
847+ FormatTransferNchwNc1hwc0 transfer;
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);
850+}
827} // namespace formats851} // namespace formats
828} // namespace ge852} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nchw_fractalz_unittest.cc+58-0
@@ -17062,5 +17062,63 @@ TEST_F(UtestFormatTransferNchwFz, build_transfer_uint8) {
17062 auto transfer = BuildFormatTransfer(args);17062 auto transfer = BuildFormatTransfer(args);
17063 EXPECT_NE(transfer, nullptr);17063 EXPECT_NE(transfer, nullptr);
17064}17064}
17065+TEST_F(UtestFormatTransferNchwFz, nchw_invalid_data_type_trans_shape) {
17066+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
17067+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
17068+ std::vector<int64_t> dst_shape;
17069+ FormatTransferFractalZ transfer;
17070+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 1, 1}, DT_STRING, dst_format, dst_shape),
17071+ ACL_ERROR_GE_DATATYPE_INVALID);
17072+}
17073+ 
17074+TEST_F(UtestFormatTransferNchwFz, nchw_invalid_src_shape_trans_shape) {
17075+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
17076+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
17077+ std::vector<int64_t> dst_shape;
17078+ FormatTransferFractalZ transfer;
17079+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1}, DT_FLOAT16, dst_format, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
17080+}
17081+ 
17082+TEST_F(UtestFormatTransferNchwFz, nchw_invalid_dst_shape_relation) {
17083+ uint16_t data[1 * 1 * 1 * 1] = {0};
17084+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NCHW, FORMAT_RESERVED, 5));
17085+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
17086+ TransArgs args{reinterpret_cast<uint8_t *>(data),
17087+ src_format,
17088+ dst_format,
17089+ FORMAT_NCHW,
17090+ FORMAT_FRACTAL_Z,
17091+ FORMAT_RESERVED,
17092+ FORMAT_RESERVED,
17093+ 16,
17094+ 16,
17095+ {1, 1, 1, 1},
17096+ {2, 1, 16, 16},
17097+ DT_FLOAT16};
17098+ TransResult result;
17099+ FormatTransferFractalZ transfer;
17100+ EXPECT_EQ(transfer.TransFormat(args, result), FAILED);
17101+}
17102+ 
17103+TEST_F(UtestFormatTransferNchwFz, nchw_unsupported_format_trans_format) {
17104+ uint16_t data[1 * 1 * 1 * 1] = {0};
17105+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_ND, FORMAT_RESERVED, 5));
17106+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
17107+ TransArgs args{reinterpret_cast<uint8_t *>(data),
17108+ src_format,
17109+ dst_format,
17110+ FORMAT_ND,
17111+ FORMAT_FRACTAL_Z,
17112+ FORMAT_RESERVED,
17113+ FORMAT_RESERVED,
17114+ 16,
17115+ 16,
17116+ {1, 1, 1, 1},
17117+ {1, 1, 16, 16},
17118+ DT_FLOAT16};
17119+ TransResult result;
17120+ FormatTransferFractalZ transfer;
17121+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_FORMAT_INVALID);
17122+}
17065} // namespace formats17123} // namespace formats
17066} // namespace ge17124} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nhwc_5d_unittest.cc+28-0
@@ -927,5 +927,33 @@ TEST_F(UtestFormatTransferNhwc5d, invalid_data_shape) {
927 transfer2.TransShape(args2.src_format, args2.src_shape, args2.src_data_type, args2.dst_format, args2.dst_shape),927 transfer2.TransShape(args2.src_format, args2.src_shape, args2.src_data_type, args2.dst_format, args2.dst_shape),
928 ACL_ERROR_GE_DATATYPE_INVALID);928 ACL_ERROR_GE_DATATYPE_INVALID);
929}929}
930+TEST_F(UtestFormatTransferNhwc5d, empty_tensor_success) {
931+ uint8_t data[1] = {0};
932+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
933+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NC1HWC0, FORMAT_RESERVED, 5));
934+ TransArgs args{data, src_format, dst_format, FORMAT_NHWC, FORMAT_NC1HWC0, FORMAT_RESERVED, FORMAT_RESERVED,
935+ 16, 16, {0, 1, 16, 16}, {0, 1, 1, 16, 16}, DT_FLOAT16};
936+ TransResult result;
937+ FormatTransferNhwcNc1hwc0 transfer;
938+ EXPECT_EQ(transfer.TransFormat(args, result), SUCCESS);
939+ EXPECT_EQ(result.length, 0U);
940+}
941+ 
942+TEST_F(UtestFormatTransferNhwc5d, invalid_dst_shape_trans_shape) {
943+ FormatTransferNhwcNc1hwc0 transfer;
944+ std::vector<int64_t> dst_shape;
945+ EXPECT_EQ(transfer.TransShape(FORMAT_NHWC, {1, 1, 1, 16}, DT_FLOAT, FORMAT_NC1HWC0, dst_shape), SUCCESS);
946+ dst_shape.clear();
947+ EXPECT_EQ(transfer.TransShape(FORMAT_NHWC, {1, 1}, DT_FLOAT, FORMAT_NC1HWC0, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
948+}
949+ 
950+TEST_F(UtestFormatTransferNhwc5d, invalid_src_dst_format_trans_shape) {
951+ FormatTransferNhwcNc1hwc0 transfer;
952+ std::vector<int64_t> dst_shape;
953+ EXPECT_EQ(transfer.TransShape(FORMAT_NCHW, {1, 1, 1, 16}, DT_FLOAT, FORMAT_NC1HWC0, dst_shape),
954+ ACL_ERROR_GE_FORMAT_INVALID);
955+ EXPECT_EQ(transfer.TransShape(FORMAT_NHWC, {1, 1, 1, 16}, DT_STRING, FORMAT_NC1HWC0, dst_shape),
956+ ACL_ERROR_GE_DATATYPE_INVALID);
957+}
930} // namespace formats958} // namespace formats
931} // namespace ge959} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_nhwc_fractalz_unittest.cc+37-0
@@ -5575,5 +5575,42 @@ TEST_F(UtestFormatTransferNhwcFz, invalid_data_shape) {
5575 transfer3.TransShape(args3.src_format, args3.src_shape, args3.src_data_type, args3.dst_format, args3.dst_shape),5575 transfer3.TransShape(args3.src_format, args3.src_shape, args3.src_data_type, args3.dst_format, args3.dst_shape),
5576 ACL_ERROR_GE_SHAPE_INVALID);5576 ACL_ERROR_GE_SHAPE_INVALID);
5577}5577}
5578+TEST_F(UtestFormatTransferNhwcFz, nhwc_invalid_data_type_trans_shape) {
5579+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
5580+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
5581+ std::vector<int64_t> dst_shape;
5582+ FormatTransferFractalZ transfer;
5583+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1, 1, 1}, DT_STRING, dst_format, dst_shape),
5584+ ACL_ERROR_GE_DATATYPE_INVALID);
5585+}
5586+ 
5587+TEST_F(UtestFormatTransferNhwcFz, nhwc_invalid_src_shape_trans_shape) {
5588+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
5589+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
5590+ std::vector<int64_t> dst_shape;
5591+ FormatTransferFractalZ transfer;
5592+ EXPECT_EQ(transfer.TransShape(src_format, {1, 1}, DT_FLOAT16, dst_format, dst_shape), ACL_ERROR_GE_SHAPE_INVALID);
5593+}
5594+ 
5595+TEST_F(UtestFormatTransferNhwcFz, nhwc_invalid_dst_shape_relation) {
5596+ uint16_t data[1 * 1 * 1 * 1] = {0};
5597+ const Format src_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_NHWC, FORMAT_RESERVED, 5));
5598+ const Format dst_format = static_cast<Format>(GetFormatFromSubAndC0(FORMAT_FRACTAL_Z, FORMAT_RESERVED, 5));
5599+ TransArgs args{reinterpret_cast<uint8_t *>(data),
5600+ src_format,
5601+ dst_format,
5602+ FORMAT_NHWC,
5603+ FORMAT_FRACTAL_Z,
5604+ FORMAT_RESERVED,
5605+ FORMAT_RESERVED,
5606+ 16,
5607+ 16,
5608+ {1, 1, 1, 1},
5609+ {2, 1, 16, 16},
5610+ DT_FLOAT16};
5611+ TransResult result;
5612+ FormatTransferFractalZ transfer;
5613+ EXPECT_EQ(transfer.TransFormat(args, result), ACL_ERROR_GE_SHAPE_INVALID);
5614+}
5578} // namespace formats5615} // namespace formats
5579} // namespace ge5616} // namespace ge
Mtests/ge/ut/ge/common/format_transfer_transpose_unittest.cc+42-0
@@ -4960,5 +4960,47 @@ TEST_F(UtestFormatTranspose, invalid_src_data) {
4960 TransResult result2;4960 TransResult result2;
4961 EXPECT_EQ(transpose2.TransFormat(args2, result2), ACL_ERROR_GE_SHAPE_INVALID);4961 EXPECT_EQ(transpose2.TransFormat(args2, result2), ACL_ERROR_GE_SHAPE_INVALID);
4962}4962}
4963+TEST_F(UtestFormatTranspose, duplicated_perm_arg) {
4964+ uint16_t data[4] = {1, 2, 3, 4};
4965+ TransResult result;
4966+ EXPECT_EQ(Transpose(reinterpret_cast<uint8_t *>(data), {2, 2}, DT_FLOAT16, {0, 0}, result),
4967+ ACL_ERROR_GE_PARAM_INVALID);
4968+}
4969+ 
4970+TEST_F(UtestFormatTranspose, invalid_data_type_transpose) {
4971+ uint8_t data[4] = {1, 2, 3, 4};
4972+ TransResult result;
4973+ auto ret = Transpose(data, {2, 2}, DT_STRING, {1, 0}, result);
4974+ EXPECT_NE(ret, SUCCESS);
4975+}
4976+ 
4977+TEST_F(UtestFormatTranspose, empty_tensor_transpose) {
4978+ uint8_t data[1] = {0};
4979+ TransResult result;
4980+ EXPECT_EQ(Transpose(data, {0, 2}, DT_FLOAT16, {1, 0}, result), SUCCESS);
4981+ EXPECT_EQ(result.length, 0U);
4982+}
4983+ 
4984+TEST_F(UtestFormatTranspose, transpose_with_shape_check_mismatch) {
4985+ uint16_t data[6] = {1, 2, 3, 4, 5, 6};
4986+ TransResult result;
4987+ auto ret = TransposeWithShapeCheck(reinterpret_cast<uint8_t *>(data), {2, 3}, {2, 3}, DT_FLOAT16, {1, 0}, result);
4988+ EXPECT_TRUE((ret == SUCCESS) || (ret == ACL_ERROR_GE_SHAPE_INVALID));
4989+}
4990+ 
4991+TEST_F(UtestFormatTranspose, get_perm_by_format_not_support_src) {
4992+ std::vector<int64_t> perm;
4993+ EXPECT_EQ(GetPermByForamt(FORMAT_ND, FORMAT_NHWC, perm), ACL_ERROR_GE_FORMAT_INVALID);
4994+}
4995+ 
4996+TEST_F(UtestFormatTranspose, get_perm_by_format_not_support_dst) {
4997+ std::vector<int64_t> perm;
4998+ EXPECT_EQ(GetPermByForamt(FORMAT_NCHW, FORMAT_ND, perm), ACL_ERROR_GE_FORMAT_INVALID);
4999+}
5000+ 
5001+TEST_F(UtestFormatTranspose, null_src_transpose) {
5002+ TransResult result;
5003+ EXPECT_EQ(Transpose(nullptr, {2, 2}, DT_FLOAT16, {1, 0}, result), ACL_ERROR_GE_PARAM_INVALID);
5004+}
4963} // namespace formats5005} // namespace formats
4964} // namespace ge5006} // namespace ge
Mtests/ge/ut/ge/common/fp16_unittest.cc+240-0
@@ -259,5 +259,245 @@ TEST_F(UtestFP16, GetManSum_success) {
259 EXPECT_EQ(GetManSum(0, m_a, 1, m_b), 0);259 EXPECT_EQ(GetManSum(0, m_a, 1, m_b), 0);
260 EXPECT_EQ(GetManSum(1, m_a, 0, m_b), 0);260 EXPECT_EQ(GetManSum(1, m_a, 0, m_b), 0);
261}261}
262+ 
263+TEST_F(UtestFP16, Fp16ToFloat_Denormal_CovEnhance) {
264+ fp16_t denorm;
265+ denorm.val = 0x0001U;
266+ float f = denorm.ToFloat();
267+ EXPECT_NE(f, 0.0f);
268+ 
269+ fp16_t denorm2;
270+ denorm2.val = 0x0200U;
271+ float f2 = denorm2.ToFloat();
272+ EXPECT_NE(f2, 0.0f);
273+}
274+ 
275+TEST_F(UtestFP16, Fp16ToDouble_Denormal_CovEnhance) {
276+ fp16_t denorm;
277+ denorm.val = 0x0001U;
278+ double d = denorm.ToDouble();
279+ EXPECT_NE(d, 0.0);
280+}
281+ 
282+TEST_F(UtestFP16, Int8_OverflowPaths_CovEnhance) {
283+ fp16_t pos_val;
284+ pos_val.val = 0x4C00U; // 2^4 * 1.0 = 16.0
285+ int8_t i8_pos = pos_val.ToInt8();
286+ EXPECT_EQ(i8_pos, 16);
287+ 
288+ fp16_t neg_val;
289+ neg_val.val = 0xCC00U; // -16.0
290+ int8_t i8_neg = neg_val.ToInt8();
291+ EXPECT_EQ(i8_neg, -16);
292+ 
293+ fp16_t small_pos;
294+ small_pos.val = 0x4180U; // ~2.75
295+ int8_t i8_small = small_pos.ToInt8();
296+ EXPECT_EQ(i8_small, 3);
297+}
298+ 
299+TEST_F(UtestFP16, Uint8_OverflowPath_CovEnhance) {
300+ fp16_t large_val;
301+ large_val.val = 0x5400U; // 2^6 = 64.0
302+ uint8_t u8 = large_val.ToUInt8();
303+ EXPECT_EQ(u8, 64);
304+ 
305+ fp16_t normal_val;
306+ normal_val.val = 0x4180U; // ~2.75
307+ uint8_t u8_normal = normal_val.ToUInt8();
308+ EXPECT_EQ(u8_normal, 3);
309+}
310+ 
311+TEST_F(UtestFP16, Int16_OverflowPaths_CovEnhance) {
312+ fp16_t large_pos;
313+ large_pos.val = 0x6C00U; // 2^12 = 4096.0
314+ int16_t i16 = large_pos.ToInt16();
315+ EXPECT_EQ(i16, 4096);
316+ 
317+ fp16_t large_neg;
318+ large_neg.val = 0xEC00U; // -4096.0
319+ int16_t i16_neg = large_neg.ToInt16();
320+ EXPECT_EQ(i16_neg, -4096);
321+ 
322+ fp16_t mid_val;
323+ mid_val.val = 0x4400U; // 4.0
324+ int16_t i16_mid = mid_val.ToInt16();
325+ EXPECT_EQ(i16_mid, 4);
326+}
327+ 
328+TEST_F(UtestFP16, Uint16_Conversion_CovEnhance) {
329+ fp16_t val;
330+ val.val = 0x4400U; // 4.0
331+ uint16_t u16 = val.ToUInt16();
332+ EXPECT_EQ(u16, 4);
333+ 
334+ fp16_t large_val;
335+ large_val.val = 0x6C00U; // 2^12 = 4096.0
336+ uint16_t u16_large = large_val.ToUInt16();
337+ EXPECT_EQ(u16_large, 4096);
338+}
339+ 
340+TEST_F(UtestFP16, Int32_Rounding_CovEnhance) {
341+ fp16_t val;
342+ val.val = 0x4180U; // ~2.75
343+ int32_t i32 = val.ToInt32();
344+ EXPECT_EQ(i32, 3);
345+ 
346+ fp16_t neg_val;
347+ neg_val.val = 0xC180U; // ~-2.75
348+ int32_t i32_neg = neg_val.ToInt32();
349+ EXPECT_EQ(i32_neg, -3);
350+}
351+ 
352+TEST_F(UtestFP16, Uint32_Conversion_CovEnhance) {
353+ fp16_t val;
354+ val.val = 0x4400U; // 4.0
355+ uint32_t u32 = val.ToUInt32();
356+ EXPECT_EQ(u32, 4U);
357+ 
358+ fp16_t neg_val;
359+ neg_val.val = 0xC400U; // -4.0
360+ uint32_t u32_neg = neg_val.ToUInt32();
361+ EXPECT_EQ(u32_neg, 0U);
362+}
363+ 
364+TEST_F(UtestFP16, OperatorGreaterThan_NegativeBoth_CovEnhance) {
365+ fp16_t neg1;
366+ neg1.val = 0xBC00U; // -1.0
367+ fp16_t neg2;
368+ neg2.val = 0xBE00U; // -1.5
369+ EXPECT_EQ(neg1 > neg2, true); // -1 > -1.5
370+ 
371+ fp16_t neg3;
372+ neg3.val = 0xC000U; // -2.0
373+ EXPECT_EQ(neg3 > neg1, false); // -2 > -1 is false (e_a >= e_b)
374+}
375+ 
376+TEST_F(UtestFP16, OperatorGreaterThan_PositiveBoth_EDiff_CovEnhance) {
377+ fp16_t pos1;
378+ pos1.val = 0x4000U; // 2.0
379+ fp16_t pos2;
380+ pos2.val = 0x4400U; // 4.0
381+ EXPECT_EQ(pos1 > pos2, false); // 2 > 4 is false, e_a < e_b
382+}
383+ 
384+TEST_F(UtestFP16, OperatorAssign_Int32_Zero_CovEnhance) {
385+ fp16_t test(1);
386+ test = 0;
387+ EXPECT_EQ(test.val, 0U);
388+}
389+ 
390+TEST_F(UtestFP16, OperatorAssign_Int32_Negative_CovEnhance) {
391+ fp16_t test(1);
392+ test = -2;
393+ EXPECT_EQ(test.val, 0xC000U); // -2.0 in fp16_t
394+ 
395+ test = -1;
396+ EXPECT_EQ(test.val, 0xBC00U); // -1.0 in fp16_t
397+}
398+ 
399+TEST_F(UtestFP16, OperatorAssign_Float64_Denormal_CovEnhance) {
400+ fp16_t test(1);
401+ double tiny = 5.960464477539063e-08; // 2^-24, denormal range
402+ test = tiny;
403+ EXPECT_NE(test.val, 0U);
404+ 
405+ fp16_t test2(1);
406+ double tinier = 2.980232238769531e-08; // 2^-25, smaller than smallest denormal
407+ test2 = tinier;
408+ EXPECT_EQ(test2.val, 0U);
409+ 
410+ fp16_t test3(1);
411+ double very_tiny = 1.0e-45; // smaller than smallest denormal
412+ test3 = very_tiny;
413+ EXPECT_EQ(test3.val, 0U);
414+ 
415+ fp16_t test4(1);
416+ double normal = 2.0;
417+ test4 = normal;
418+ EXPECT_EQ(test4.val, 0x4000U);
419+ 
420+ fp16_t test5(1);
421+ double overflow_val = 1e20;
422+ test5 = overflow_val;
423+ EXPECT_EQ(test5.val, 0x7BFFU);
424+}
425+ 
426+TEST_F(UtestFP16, OperatorAssign_Float32_Denormal_CovEnhance) {
427+ fp16_t test(1);
428+ float tiny = 5.960464477539063e-08F; // 2^-24, denormal
429+ test = tiny;
430+ EXPECT_NE(test.val, 0U);
431+ 
432+ fp16_t test2(1);
433+ float tinier = 2.980232238769531e-08F; // 2^-25, smaller than smallest denormal
434+ test2 = tinier;
435+ EXPECT_EQ(test2.val, 0U);
436+ 
437+ fp16_t test3(1);
438+ float zero = 0.0F;
439+ test3 = zero;
440+ EXPECT_EQ(test3.val, 0U);
441+ 
442+ fp16_t test4(1);
443+ float overflow_val = 1e20F;
444+ test4 = overflow_val;
445+ EXPECT_EQ(test4.val, 0x7BFFU);
446+}
447+ 
448+TEST_F(UtestFP16, Fp16Add_DifferentExponents_CovEnhance) {
449+ fp16_t a;
450+ a.val = 0x4000U; // 2.0
451+ fp16_t b;
452+ b.val = 0x3C00U; // 1.0
453+ fp16_t result = a + b;
454+ EXPECT_EQ(result.val, 0x4200U); // 3.0
455+ 
456+ fp16_t c;
457+ c.val = 0x3C00U; // 1.0
458+ fp16_t d;
459+ d.val = 0x4000U; // 2.0
460+ fp16_t result2 = c + d;
461+ EXPECT_EQ(result2.val, 0x4200U); // 3.0
462+}
463+ 
464+TEST_F(UtestFP16, Fp16Mul_ShiftPaths_CovEnhance) {
465+ fp16_t a;
466+ a.val = 0x4000U; // 2.0
467+ fp16_t b;
468+ b.val = 0x4000U; // 2.0
469+ fp16_t result = a * b;
470+ EXPECT_EQ(result.val, 0x4400U); // 4.0
471+ 
472+ fp16_t c;
473+ c.val = 0x3C00U; // 1.0
474+ fp16_t d;
475+ d.val = 0x3C00U; // 1.0
476+ fp16_t result2 = c * d;
477+ EXPECT_EQ(result2.val, 0x3C00U); // 1.0
478+ 
479+ fp16_t e;
480+ e.val = 0x4400U; // 4.0
481+ fp16_t f;
482+ f.val = 0x4400U; // 4.0
483+ fp16_t result3 = e * f;
484+ EXPECT_EQ(result3.val, 0x4C00U); // 16.0
485+}
486+ 
487+TEST_F(UtestFP16, Fp16Sub_DifferentSign_CovEnhance) {
488+ fp16_t a;
489+ a.val = 0x4200U; // 3.0
490+ fp16_t b;
491+ b.val = 0x4000U; // 2.0
492+ fp16_t result = a - b;
493+ EXPECT_EQ(result.val, 0x3C00U); // 1.0
494+ 
495+ fp16_t c;
496+ c.val = 0x3C00U; // 1.0
497+ fp16_t d;
498+ d.val = 0x4000U; // 2.0
499+ fp16_t result2 = c - d;
500+ EXPECT_EQ(result2.val, 0xBC00U); // -1.0
501+}
262} // namespace formats502} // namespace formats
263} // namespace ge503} // namespace ge
Mtests/ge/ut/ge/common/ge_auth_file_saver_unittest.cc+90-0
@@ -175,4 +175,94 @@ TEST_F(UTEST_file_saver, SaveWithAlignFill1_success) {
175 system("rm -rf ./test.om");175 system("rm -rf ./test.om");
176}176}
177 177 
178+TEST_F(UTEST_file_saver, WriteData_null_or_zero_returns_param_invalid) {
179+ int32_t fd = 0;
180+ EXPECT_EQ(FileSaver::OpenFile(fd, "./test_write.om"), SUCCESS);
181+ EXPECT_EQ(FileSaver::WriteData(nullptr, 100U, fd), PARAM_INVALID);
182+ std::string data = "abc";
183+ EXPECT_EQ(FileSaver::WriteData(data.data(), 0U, fd), PARAM_INVALID);
184+ (void)mmClose(fd);
185+ system("rm -rf ./test_write.om");
186+}
187+ 
188+TEST_F(UTEST_file_saver, SaveToFile_with_null_model_data_returns_failed) {
189+ ge::ModelData modelData;
190+ modelData.model_data = nullptr;
191+ modelData.model_len = 0U;
192+ EXPECT_EQ(FileSaver::SaveToFile("./test_om.om", modelData), FAILED);
193+ 
194+ std::string model_data_str(256, '1');
195+ modelData.model_data = reinterpret_cast<void *>(const_cast<char *>(model_data_str.c_str()));
196+ modelData.model_len = model_data_str.size();
197+ ModelFileHeader file_header;
198+ EXPECT_EQ(FileSaver::SaveToFile("./test_om.om", modelData, &file_header), SUCCESS);
199+ system("rm -rf ./test_om.om");
200+}
201+ 
202+TEST_F(UTEST_file_saver, SaveToFile_data_null_or_zero_len_returns_failed) {
203+ EXPECT_EQ(FileSaver::SaveToFile("./test_om.om", nullptr, 0U), FAILED);
204+ std::string data = "test_data";
205+ EXPECT_EQ(FileSaver::SaveToFile("./test_om.om", data.data(), data.size(), false), SUCCESS);
206+ system("rm -rf ./test_om.om");
207+}
208+ 
209+TEST_F(UTEST_file_saver, SaveWithFileHeader_null_data_returns_failed) {
210+ ModelFileHeader file_header;
211+ EXPECT_EQ(FileSaver::SaveWithFileHeader("./test_om.om", file_header, nullptr, 0U), FAILED);
212+ 
213+ std::string data = "test_data";
214+ EXPECT_EQ(FileSaver::SaveWithFileHeader("./test_om.om", file_header, data.data(), data.size()), SUCCESS);
215+ system("rm -rf ./test_om.om");
216+}
217+ 
218+TEST_F(UTEST_file_saver, CheckPathValid_root_path_returns_success) {
219+ EXPECT_EQ(FileSaver::CheckPathValid("/"), SUCCESS);
220+ EXPECT_EQ(FileSaver::CheckPathValid("./test_path/file.om"), SUCCESS);
221+ system("rm -rf ./test_path");
222+}
223+ 
224+TEST_F(UTEST_file_saver, SaveToBuffWithFileHeader_mismatched_sizes_returns_param_invalid) {
225+ ModelFileHeader file_header;
226+ std::vector<char> data;
227+ data.resize(sizeof(ModelPartitionTable) + sizeof(ModelPartitionMemInfo), 0);
228+ ModelPartitionTable *partition_table = reinterpret_cast<ModelPartitionTable *>(data.data());
229+ partition_table->num = 1;
230+ partition_table->partition[0] = {MODEL_DEF, 0, 12};
231+ 
232+ std::vector<ModelPartitionTable *> partition_tables;
233+ partition_tables.push_back(partition_table);
234+ std::vector<ModelPartitionTable *> partition_tables2;
235+ partition_tables2.push_back(partition_table);
236+ partition_tables2.push_back(partition_table);
237+ 
238+ auto buff = reinterpret_cast<uint8_t *>(malloc(12));
239+ struct ge::ModelPartition model_partition;
240+ model_partition.type = MODEL_DEF;
241+ model_partition.data = buff;
242+ model_partition.size = 12;
243+ std::vector<ModelPartition> model_partitions = {model_partition};
244+ std::vector<std::vector<ModelPartition>> all_partition_datas = {model_partitions};
245+ 
246+ ge::ModelBufferData model;
247+ EXPECT_EQ(FileSaver::SaveToBuffWithFileHeader(file_header, partition_tables2, all_partition_datas, model),
248+ PARAM_INVALID);
249+ free(buff);
250+ model_partition.data = nullptr;
251+}
252+ 
253+TEST_F(UTEST_file_saver, SaveToFile3_empty_partition_returns_failed) {
254+ std::vector<ModelPartition> partition_datas;
255+ std::vector<char> data;
256+ data.resize(sizeof(ModelPartitionTable) + sizeof(ModelPartitionMemInfo), 0);
257+ ModelPartitionTable *partition_table = reinterpret_cast<ModelPartitionTable *>(data.data());
258+ partition_table->num = 1;
259+ partition_table->partition[0] = {MODEL_DEF, 0, 12};
260+ ModelFileHeader model_header;
261+ EXPECT_EQ(FileSaver::SaveToFile("./test_om.om", model_header, *partition_table, partition_datas), FAILED);
262+}
263+ 
264+TEST_F(UTEST_file_saver, PrintModelSaveLog_when_not_initialized) {
265+ FileSaver::PrintModelSaveLog();
266+}
267+ 
178} // namespace ge268} // namespace ge
Mtests/ge/ut/ge/common/ge_op_utils_unittest.cc+138-0
@@ -16,6 +16,7 @@
16#include "mmpa/mmpa_api.h"16#include "mmpa/mmpa_api.h"
17#include "framework/common/helper/model_helper.h"17#include "framework/common/helper/model_helper.h"
18#include "common/op/ge_op_utils.h"18#include "common/op/ge_op_utils.h"
19+#include "common/fp16_t/fp16_t.h"
19#include "ge_graph_dsl/graph_dsl.h"20#include "ge_graph_dsl/graph_dsl.h"
20 21 
21using namespace testing;22using namespace testing;
@@ -39,4 +40,141 @@ TEST_F(UtestGeOpUtils, GetConstantStrMemSize_Success) {
39 ASSERT_EQ(OpUtils::GetConstantStrMemSize(const_op_desc, mem_size), SUCCESS);40 ASSERT_EQ(OpUtils::GetConstantStrMemSize(const_op_desc, mem_size), SUCCESS);
40 EXPECT_EQ(mem_size, 4);41 EXPECT_EQ(mem_size, 4);
41}42}
43+ 
44+TEST_F(UtestGeOpUtils, SetOutputSliceData_DimZero_CovEnhance) {
45+ uint8_t buf[64] = {0};
46+ GeTensor output;
47+ std::vector<int64_t> input_dims = {0, 4};
48+ std::vector<int64_t> begin = {0, 0};
49+ std::vector<int64_t> output_dims = {1, 4};
50+ std::vector<int64_t> stride = {1, 1};
51+ EXPECT_EQ(OpUtils::SetOutputSliceData(buf, 4, DT_INT32, input_dims, begin, output_dims, &output, stride),
52+ PARAM_INVALID);
53+}
54+ 
55+TEST_F(UtestGeOpUtils, SetOutputSliceData_Float_CovEnhance) {
56+ float data[4] = {1.0f, 2.0f, 3.0f, 4.0f};
57+ GeTensor output;
58+ std::vector<int64_t> input_dims = {4};
59+ std::vector<int64_t> begin = {0};
60+ std::vector<int64_t> output_dims = {2};
61+ std::vector<int64_t> stride = {1};
62+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_FLOAT, input_dims, begin, output_dims, &output, stride), SUCCESS);
63+}
64+ 
65+TEST_F(UtestGeOpUtils, SetOutputSliceData_Double_CovEnhance) {
66+ double data[4] = {1.0, 2.0, 3.0, 4.0};
67+ GeTensor output;
68+ std::vector<int64_t> input_dims = {4};
69+ std::vector<int64_t> begin = {0};
70+ std::vector<int64_t> output_dims = {2};
71+ std::vector<int64_t> stride = {1};
72+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_DOUBLE, input_dims, begin, output_dims, &output, stride), SUCCESS);
73+}
74+ 
75+TEST_F(UtestGeOpUtils, SetOutputSliceData_Float16_CovEnhance) {
76+ fp16_t data[4] = {fp16_t(1), fp16_t(2), fp16_t(3), fp16_t(4)};
77+ GeTensor output;
78+ std::vector<int64_t> input_dims = {4};
79+ std::vector<int64_t> begin = {0};
80+ std::vector<int64_t> output_dims = {2};
81+ std::vector<int64_t> stride = {1};
82+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_FLOAT16, input_dims, begin, output_dims, &output, stride), SUCCESS);
83+}
84+ 
85+TEST_F(UtestGeOpUtils, SetOutputSliceData_Uint8_CovEnhance) {
86+ uint8_t data[4] = {1, 2, 3, 4};
87+ GeTensor output;
88+ std::vector<int64_t> input_dims = {4};
89+ std::vector<int64_t> begin = {0};
90+ std::vector<int64_t> output_dims = {2};
91+ std::vector<int64_t> stride = {1};
92+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_UINT8, input_dims, begin, output_dims, &output, stride), SUCCESS);
93+}
94+ 
95+TEST_F(UtestGeOpUtils, SetOutputSliceData_Int8_CovEnhance) {
96+ int8_t data[4] = {1, 2, 3, 4};
97+ GeTensor output;
98+ std::vector<int64_t> input_dims = {4};
99+ std::vector<int64_t> begin = {0};
100+ std::vector<int64_t> output_dims = {2};
101+ std::vector<int64_t> stride = {1};
102+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_INT8, input_dims, begin, output_dims, &output, stride), SUCCESS);
103+}
104+ 
105+TEST_F(UtestGeOpUtils, SetOutputSliceData_Uint16_CovEnhance) {
106+ uint16_t data[4] = {1, 2, 3, 4};
107+ GeTensor output;
108+ std::vector<int64_t> input_dims = {4};
109+ std::vector<int64_t> begin = {0};
110+ std::vector<int64_t> output_dims = {2};
111+ std::vector<int64_t> stride = {1};
112+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_UINT16, input_dims, begin, output_dims, &output, stride), SUCCESS);
113+}
114+ 
115+TEST_F(UtestGeOpUtils, SetOutputSliceData_Int16_CovEnhance) {
116+ int16_t data[4] = {1, 2, 3, 4};
117+ GeTensor output;
118+ std::vector<int64_t> input_dims = {4};
119+ std::vector<int64_t> begin = {0};
120+ std::vector<int64_t> output_dims = {2};
121+ std::vector<int64_t> stride = {1};
122+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_INT16, input_dims, begin, output_dims, &output, stride), SUCCESS);
123+}
124+ 
125+TEST_F(UtestGeOpUtils, SetOutputSliceData_Uint32_CovEnhance) {
126+ uint32_t data[4] = {1, 2, 3, 4};
127+ GeTensor output;
128+ std::vector<int64_t> input_dims = {4};
129+ std::vector<int64_t> begin = {0};
130+ std::vector<int64_t> output_dims = {2};
131+ std::vector<int64_t> stride = {1};
132+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_UINT32, input_dims, begin, output_dims, &output, stride), SUCCESS);
133+}
134+ 
135+TEST_F(UtestGeOpUtils, SetOutputSliceData_Uint64_CovEnhance) {
136+ uint64_t data[4] = {1, 2, 3, 4};
137+ GeTensor output;
138+ std::vector<int64_t> input_dims = {4};
139+ std::vector<int64_t> begin = {0};
140+ std::vector<int64_t> output_dims = {2};
141+ std::vector<int64_t> stride = {1};
142+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_UINT64, input_dims, begin, output_dims, &output, stride), SUCCESS);
143+}
144+ 
145+TEST_F(UtestGeOpUtils, SetOutputSliceData_Int64_CovEnhance) {
146+ int64_t data[4] = {1, 2, 3, 4};
147+ GeTensor output;
148+ std::vector<int64_t> input_dims = {4};
149+ std::vector<int64_t> begin = {0};
150+ std::vector<int64_t> output_dims = {2};
151+ std::vector<int64_t> stride = {1};
152+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_INT64, input_dims, begin, output_dims, &output, stride), SUCCESS);
153+}
154+ 
155+TEST_F(UtestGeOpUtils, SetOutputSliceData_Bool_CovEnhance) {
156+ bool data[4] = {true, false, true, false};
157+ GeTensor output;
158+ std::vector<int64_t> input_dims = {4};
159+ std::vector<int64_t> begin = {0};
160+ std::vector<int64_t> output_dims = {2};
161+ std::vector<int64_t> stride = {1};
162+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_BOOL, input_dims, begin, output_dims, &output, stride), SUCCESS);
163+}
164+ 
165+TEST_F(UtestGeOpUtils, SetOutputSliceData_UnsupportedType_CovEnhance) {
166+ uint8_t data[4] = {1, 2, 3, 4};
167+ GeTensor output;
168+ std::vector<int64_t> input_dims = {4};
169+ std::vector<int64_t> begin = {0};
170+ std::vector<int64_t> output_dims = {2};
171+ std::vector<int64_t> stride = {1};
172+ EXPECT_EQ(OpUtils::SetOutputSliceData(data, 4, DT_STRING, input_dims, begin, output_dims, &output, stride),
173+ PARAM_INVALID);
174+}
175+ 
176+TEST_F(UtestGeOpUtils, GetShapeDataFromConstTensor_NullTensor_CovEnhance) {
177+ std::vector<int64_t> dims;
178+ EXPECT_EQ(OpUtils::GetShapeDataFromConstTensor(nullptr, DT_INT32, dims), PARAM_INVALID);
179+}
42} // namespace ge180} // namespace ge
Mtests/ge/ut/ge/common/ge_root_model_unittest.cc+92-0
@@ -11,9 +11,12 @@
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12#include <gmock/gmock.h>12#include <gmock/gmock.h>
13#include <vector>13#include <vector>
14+#include <fstream>
15+#include <cstdio>
14#include "graph/utils/graph_utils.h"16#include "graph/utils/graph_utils.h"
15#include "graph/ge_tensor.h"17#include "graph/ge_tensor.h"
16#include "graph/op_desc.h"18#include "graph/op_desc.h"
19+#include "graph/ge_context.h"
17#include "mmpa/mmpa_api.h"20#include "mmpa/mmpa_api.h"
18#include "framework/common/helper/model_helper.h"21#include "framework/common/helper/model_helper.h"
19 22 
@@ -296,4 +299,93 @@ TEST_F(UtestGeRootModel, ForkSharesOm2ModelData) {
296 EXPECT_EQ(forked->GetOm2ModelData(), ge_root_model->GetOm2ModelData());299 EXPECT_EQ(forked->GetOm2ModelData(), ge_root_model->GetOm2ModelData());
297}300}
298 301 
302+TEST_F(UtestGeRootModel, GetOpSoStoreData_And_GetOpStoreDataSize) {
303+ GeRootModel ge_root_model;
304+ EXPECT_EQ(ge_root_model.GetOpSoStoreData(), nullptr);
305+ EXPECT_EQ(ge_root_model.GetOpStoreDataSize(), 0U);
306+}
307+ 
308+TEST_F(UtestGeRootModel, CheckIsUnknownShape_NullRootGraph) {
309+ GeRootModel ge_root_model;
310+ bool is_dynamic_shape = false;
311+ EXPECT_EQ(ge_root_model.CheckIsUnknownShape(is_dynamic_shape), FAILED);
312+}
313+ 
314+TEST_F(UtestGeRootModel, IsNeedMallocFixedFeatureMem_WithStaticModelAddrFixed) {
315+ GeRootModel ge_root_model;
316+ auto root_graph = std::make_shared<ComputeGraph>("test_graph");
317+ EXPECT_EQ(ge_root_model.Initialize(root_graph), SUCCESS);
318+ auto old_options = GetThreadLocalContext().GetAllGraphOptions();
319+ GetThreadLocalContext().SetGraphOption({{"ge.exec.static_model_addr_fixed", "1"}});
320+ EXPECT_FALSE(ge_root_model.IsNeedMallocFixedFeatureMem());
321+ GetThreadLocalContext().SetGraphOption(old_options);
322+}
323+ 
324+TEST_F(UtestGeRootModel, CheckSoArchMatchesTarget_UnsupportedCpu) {
325+ GeRootModel ge_root_model;
326+ EXPECT_EQ(ge_root_model.CheckSoArchMatchesTarget("/nonexistent/path.so", "mips"), SUCCESS);
327+}
328+ 
329+TEST_F(UtestGeRootModel, CheckSoArchMatchesTarget_NonExistentFile) {
330+ GeRootModel ge_root_model;
331+ EXPECT_EQ(ge_root_model.CheckSoArchMatchesTarget("/nonexistent/path.so", "x86_64"), FAILED);
332+}
333+ 
334+TEST_F(UtestGeRootModel, CheckSoArchMatchesTarget_NotElfFile) {
335+ std::string test_file = "/tmp/ge_ut_not_elf_test.txt";
336+ std::ofstream ofs(test_file);
337+ ofs << "not an elf file content";
338+ ofs.close();
339+ 
340+ GeRootModel ge_root_model;
341+ EXPECT_EQ(ge_root_model.CheckSoArchMatchesTarget(test_file, "x86_64"), FAILED);
342+ std::remove(test_file.c_str());
343+}
344+ 
345+TEST_F(UtestGeRootModel, LoadSoBinData_Success) {
346+ GeRootModel ge_root_model;
347+ std::vector<uint8_t> data(64, 0);
348+ EXPECT_FALSE(ge_root_model.LoadSoBinData(data.data(), data.size()));
349+}
350+ 
351+TEST_F(UtestGeRootModel, GetSoInOmFlag_Default) {
352+ GeRootModel ge_root_model;
353+ EXPECT_EQ(ge_root_model.GetSoInOmFlag(), 0U);
354+}
355+ 
356+TEST_F(UtestGeRootModel, SetSoInOmInfo_And_Get) {
357+ GeRootModel ge_root_model;
358+ SoInOmInfo so_info;
359+ so_info.cpu_info = "test_cpu";
360+ ge_root_model.SetSoInOmInfo(so_info);
361+ auto retrieved = ge_root_model.GetSoInOmInfo();
362+ EXPECT_EQ(retrieved.cpu_info, "test_cpu");
363+}
364+ 
365+TEST_F(UtestGeRootModel, GetAllSoBin_Empty) {
366+ GeRootModel ge_root_model;
367+ auto so_bins = ge_root_model.GetAllSoBin();
368+ EXPECT_TRUE(so_bins.empty());
369+}
370+ 
371+TEST_F(UtestGeRootModel, RemoveInstanceSubgraphModel) {
372+ auto root_graph = std::make_shared<ComputeGraph>("root-graph");
373+ auto root_model = std::make_shared<GeRootModel>();
374+ EXPECT_EQ(root_model->Initialize(root_graph), SUCCESS);
375+ auto ge_model = std::make_shared<GeModel>();
376+ ge_model->SetGraph(root_graph);
377+ ge_model->SetName("test_instance");
378+ root_model->SetSubgraphInstanceNameToModel("test_instance", ge_model);
379+ root_model->RemoveInstanceSubgraphModel("test_instance");
380+ EXPECT_EQ(root_model->GetSubgraphInstanceNameToModel().size(), 0U);
381+}
382+ 
383+TEST_F(UtestGeRootModel, CheckAndSetNeedOpMasterDeviceSo) {
384+ auto root_graph = std::make_shared<ComputeGraph>("root-graph");
385+ auto root_model = std::make_shared<GeRootModel>();
386+ EXPECT_EQ(root_model->Initialize(root_graph), SUCCESS);
387+ root_model->SetCustomOpRegistry(CustomOpFactory::GetGlobalRegistryPtr());
388+ EXPECT_EQ(root_model->CheckAndSetNeedOpMasterDeviceSo(), SUCCESS);
389+}
390+ 
299} // namespace ge391} // namespace ge
Mtests/ge/ut/ge/common/kernel_store_unittest.cc+61-0
@@ -9,9 +9,20 @@
9 */9 */
10 10 
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12+#include <vector>
12#include "common/tbe_handle_store/kernel_store.h"13#include "common/tbe_handle_store/kernel_store.h"
14+#include "common/tbe_handle_store/tbe_kernel_store.h"
15+#include "graph/op_kernel_bin.h"
16+#include "graph/op_desc.h"
17+#include "graph/utils/attr_utils.h"
18+#include "graph/debug/ge_attr_define.h"
13 19 
14namespace ge {20namespace ge {
21+namespace {
22+std::vector<char> CreateStubBin() {
23+ return std::vector<char>(64, '\0');
24+}
25+} // namespace
15class UtestKernelStore : public testing::Test {26class UtestKernelStore : public testing::Test {
16 protected:27 protected:
17 void SetUp() {}28 void SetUp() {}
@@ -25,4 +36,54 @@ TEST_F(UtestKernelStore, Load_success) {
25 free(buff);36 free(buff);
26 buff = nullptr;37 buff = nullptr;
27}38}
39+ 
40+TEST_F(UtestKernelStore, LoadTBEKernelBinToOpDesc_WithNamesPrefix_Success) {
41+ TBEKernelStore tbe_kernel_store;
42+ const std::string kernel_name = "mix_kernel_bin";
43+ const auto kernel = MakeShared<OpKernelBin>(kernel_name, CreateStubBin());
44+ tbe_kernel_store.AddTBEKernel(kernel);
45+ 
46+ auto op_desc = std::make_shared<OpDesc>("test_op", "Add");
47+ ASSERT_NE(op_desc, nullptr);
48+ std::vector<std::string> names_prefix = {"_mix_enhanced"};
49+ AttrUtils::SetListStr(op_desc, ATTR_NAME_KERNEL_NAMES_PREFIX, names_prefix);
50+ AttrUtils::SetStr(op_desc, "_mix_enhanced" + ATTR_NAME_TBE_KERNEL_NAME, kernel_name);
51+ 
52+ tbe_kernel_store.LoadTBEKernelBinToOpDesc(op_desc);
53+ auto ext_kernel = op_desc->TryGetExtAttr("_mix_enhanced" + std::string(OP_EXTATTR_NAME_TBE_KERNEL),
54+ static_cast<TBEKernelPtr>(nullptr));
55+ EXPECT_NE(ext_kernel, nullptr);
56+}
57+ 
58+TEST_F(UtestKernelStore, LoadTBEKernelBinToOpDesc_WithAtomicKernel_Success) {
59+ TBEKernelStore tbe_kernel_store;
60+ const std::string kernel_name = "atomic_kernel_bin";
61+ const auto kernel = MakeShared<OpKernelBin>(kernel_name, CreateStubBin());
62+ tbe_kernel_store.AddTBEKernel(kernel);
63+ 
64+ auto op_desc = std::make_shared<OpDesc>("test_op", "Add");
65+ ASSERT_NE(op_desc, nullptr);
66+ AttrUtils::SetStr(op_desc, ATOMIC_ATTR_TBE_KERNEL_NAME, kernel_name);
67+ 
68+ tbe_kernel_store.LoadTBEKernelBinToOpDesc(op_desc);
69+ auto ext_kernel = op_desc->TryGetExtAttr(EXT_ATTR_ATOMIC_TBE_KERNEL, static_cast<TBEKernelPtr>(nullptr));
70+ EXPECT_NE(ext_kernel, nullptr);
71+}
72+ 
73+TEST_F(UtestKernelStore, LoadTBEKernelBinToOpDesc_WithNullOpDesc_NoCrash) {
74+ TBEKernelStore tbe_kernel_store;
75+ std::shared_ptr<OpDesc> null_op_desc = nullptr;
76+ tbe_kernel_store.LoadTBEKernelBinToOpDesc(null_op_desc);
77+}
78+ 
79+TEST_F(UtestKernelStore, LoadTBEKernelBinToOpDesc_WithoutNamesPrefix_Success) {
80+ TBEKernelStore tbe_kernel_store;
81+ const std::string kernel_name = "normal_kernel_bin";
82+ const auto kernel = MakeShared<OpKernelBin>(kernel_name, CreateStubBin());
83+ tbe_kernel_store.AddTBEKernel(kernel);
84+ 
85+ auto op_desc = std::make_shared<OpDesc>("test_op_name", "Add");
86+ ASSERT_NE(op_desc, nullptr);
87+ tbe_kernel_store.LoadTBEKernelBinToOpDesc(op_desc);
88+}
28} // namespace ge89} // namespace ge
Mtests/ge/ut/ge/common/mobile_model_helper_unittest.cc+46-0
@@ -574,4 +574,50 @@ TEST_F(UtestMobileModelHelper, SaveToOmRootModelDoesNotWriteSoOrCustomOpsPartiti
574 EXPECT_FALSE(FileContainsStringForTest(omc_file, "libmobile_custom_op_no_so_ut.so"));574 EXPECT_FALSE(FileContainsStringForTest(omc_file, "libmobile_custom_op_no_so_ut.so"));
575 EXPECT_FALSE(FileContainsStringForTest(omc_file, kMobileCustomOpSoPayloadMarker));575 EXPECT_FALSE(FileContainsStringForTest(omc_file, kMobileCustomOpSoPayloadMarker));
576}576}
577+ 
578+TEST_F(UtestMobileModelHelper, ModelToMobileWithInvalidDataType) {
579+ std::string output_file = "mobile_model_invalid.om";
580+ ModelBufferData model;
581+ MobileModelHelper model_save_helper;
582+ GeRootModelPtr ge_root_model = GenGeRootModel(true);
583+ EXPECT_NE(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
584+ system("rm -rf mobile_model_invalid.omc");
585+}
586+ 
587+TEST_F(UtestMobileModelHelper, SetSaveMode) {
588+ MobileModelHelper model_save_helper;
589+ model_save_helper.SetSaveMode(true);
590+ model_save_helper.SetSaveMode(false);
591+}
592+ 
593+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithConstNode) {
594+ std::string output_file = "mobile_model_const.om";
595+ ModelBufferData model;
596+ MobileModelHelper model_save_helper;
597+ GeRootModelPtr ge_root_model = GenGeRootModel();
598+ auto graph = ge_root_model->GetRootGraph();
599+ auto const_op_desc = std::make_shared<ge::OpDesc>("const_node", "Const");
600+ ge::GeTensorDesc tensor_desc(ge::GeShape({8}), ge::FORMAT_ND, ge::DT_INT64);
601+ (void)const_op_desc->AddOutputDesc(tensor_desc);
602+ (void)graph->AddNode(const_op_desc);
603+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
604+ system("rm -rf mobile_model_const.omc");
605+}
606+ 
607+TEST_F(UtestMobileModelHelper, SaveToOmRootModelWithNetOutputMissingOutputDesc) {
608+ std::string output_file = "mobile_model_netout.om";
609+ ModelBufferData model;
610+ MobileModelHelper model_save_helper;
611+ GeRootModelPtr ge_root_model = GenGeRootModel();
612+ auto graph = ge_root_model->GetRootGraph();
613+ for (const auto &node : graph->GetDirectNode()) {
614+ if (node->GetType() == "NetOutput") {
615+ auto op_desc = node->GetOpDesc();
616+ ge::GeTensorDesc extra_desc(ge::GeShape({8}), ge::FORMAT_ND, ge::DT_INT64);
617+ (void)op_desc->AddInputDesc(extra_desc);
618+ }
619+ }
620+ EXPECT_EQ(model_save_helper.SaveToOmRootModel(ge_root_model, output_file, model, false), ge::SUCCESS);
621+ system("rm -rf mobile_model_netout.omc");
622+}
577} // namespace ge623} // namespace ge
Mtests/ge/ut/ge/common/model_saver_unittest.cc+34-0
@@ -18,6 +18,7 @@
18#include "macro_utils/dt_public_unscope.h"18#include "macro_utils/dt_public_unscope.h"
19 19 
20#include "graph/passes/graph_builder_utils.h"20#include "graph/passes/graph_builder_utils.h"
21+#include "mmpa/mmpa_api.h"
21 22 
22namespace ge {23namespace ge {
23class UtestModelSaver : public testing::Test {24class UtestModelSaver : public testing::Test {
@@ -40,4 +41,37 @@ TEST_F(UtestModelSaver, SaveJsonToFile_success) {
40 system("rm -rf ./test.pb");41 system("rm -rf ./test.pb");
41}42}
42 43 
44+TEST_F(UtestModelSaver, SaveJsonToFile_long_path_returns_failed) {
45+ Json tmp_json;
46+ tmp_json["key"] = "value";
47+ std::string long_path(MMPA_MAX_PATH + 1, 'a');
48+ EXPECT_EQ(ModelSaver::SaveJsonToFile(long_path.c_str(), tmp_json), FAILED);
49+}
50+ 
51+TEST_F(UtestModelSaver, SaveJsonToFile_valid_json_success) {
52+ Json tmp_json;
53+ tmp_json["name"] = "test_model";
54+ tmp_json["version"] = 1;
55+ tmp_json["nested"] = Json::object();
56+ tmp_json["nested"]["field"] = "value";
57+ EXPECT_EQ(ModelSaver::SaveJsonToFile("./test_valid_json.pb", tmp_json), SUCCESS);
58+ system("rm -rf ./test_valid_json.pb");
59+}
60+ 
61+TEST_F(UtestModelSaver, SaveJsonToFile_empty_json_success) {
62+ Json tmp_json;
63+ EXPECT_EQ(ModelSaver::SaveJsonToFile("./test_empty_json.pb", tmp_json), SUCCESS);
64+ system("rm -rf ./test_empty_json.pb");
65+}
66+ 
67+TEST_F(UtestModelSaver, SaveJsonToFile_nested_json_success) {
68+ Json tmp_json;
69+ for (int i = 0; i < 10; ++i) {
70+ tmp_json[std::to_string(i)] = Json::object();
71+ tmp_json[std::to_string(i)]["val"] = i;
72+ }
73+ EXPECT_EQ(ModelSaver::SaveJsonToFile("./test_nested_json.pb", tmp_json), SUCCESS);
74+ system("rm -rf ./test_nested_json.pb");
75+}
76+ 
43} // namespace ge77} // namespace ge
Mtests/ge/ut/ge/common/om2_codegen_model_builder_unittest.cc+104-0
@@ -2083,4 +2083,108 @@ TEST_F(Om2CodegenModelBuilderUt, BuildModelIo_TwoNetOutputs_DenseIndexing) {
2083 EXPECT_EQ(doc.model_io.entries[3].index, 1U);2083 EXPECT_EQ(doc.model_io.entries[3].index, 1U);
2084 EXPECT_EQ(doc.model_io.entries[3].memory_offset, 2048);2084 EXPECT_EQ(doc.model_io.entries[3].memory_offset, 2048);
2085}2085}
2086+ 
2087+TEST_F(Om2CodegenModelBuilderUt, BuildRuntimeSemantic_StreamSwitch_Ok) {
2088+ GeModelPtr ge_model = CreateGeModelWithStreamSwitchTask();
2089+ ASSERT_NE(ge_model, nullptr);
2090+ Om2CodegenModel doc;
2091+ ASSERT_EQ(BuildCodegenModel(ge_model, doc), SUCCESS);
2092+ 
2093+ EXPECT_EQ(doc.runtime.stream_num, 2U);
2094+}
2095+ 
2096+TEST_F(Om2CodegenModelBuilderUt, KernelTaskCodeBuilder_UpdateShapeAndType_Success) {
2097+ AstContext ast_ctx;
2098+ AstBuildContext ast(ast_ctx);
2099+ KernelTaskCodeBuilder builder(ast);
2100+ AicpuShapeAndType shape_and_type = {};
2101+ GeShape shape({1, 2, 3, 4});
2102+ EXPECT_EQ(builder.UpdateShapeAndType(shape, &shape_and_type), SUCCESS);
2103+ EXPECT_EQ(shape_and_type.dims[0], 1);
2104+ EXPECT_EQ(shape_and_type.dims[1], 2);
2105+ EXPECT_EQ(shape_and_type.dims[2], 3);
2106+ EXPECT_EQ(shape_and_type.dims[3], 4);
2107+}
2108+ 
2109+TEST_F(Om2CodegenModelBuilderUt, KernelTaskCodeBuilder_UpdateShapeAndType_DimsOverMax) {
2110+ AstContext ast_ctx;
2111+ AstBuildContext ast(ast_ctx);
2112+ KernelTaskCodeBuilder builder(ast);
2113+ AicpuShapeAndType shape_and_type = {};
2114+ std::vector<int64_t> dims;
2115+ for (size_t i = 0; i <= aicpu::FWKAdapter::kMaxShapeDims + 1; ++i) {
2116+ dims.push_back(static_cast<int64_t>(i));
2117+ }
2118+ GeShape shape(dims);
2119+ EXPECT_NE(builder.UpdateShapeAndType(shape, &shape_and_type), SUCCESS);
2120+}
2121+ 
2122+TEST_F(Om2CodegenModelBuilderUt, KernelTaskCodeBuilder_UpdateShapeAndType_EmptyShape) {
2123+ AstContext ast_ctx;
2124+ AstBuildContext ast(ast_ctx);
2125+ KernelTaskCodeBuilder builder(ast);
2126+ AicpuShapeAndType shape_and_type = {};
2127+ GeShape shape;
2128+ EXPECT_EQ(builder.UpdateShapeAndType(shape, &shape_and_type), SUCCESS);
2129+}
2130+ 
2131+TEST_F(Om2CodegenModelBuilderUt, KernelTaskCodeBuilder_GetFuncName_NotEmpty) {
2132+ AstContext ast_ctx;
2133+ AstBuildContext ast(ast_ctx);
2134+ KernelTaskCodeBuilder builder(ast);
2135+ EXPECT_FALSE(builder.GetFuncName().empty());
2136+}
2137+ 
2138+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_UnsupportedTaskType) {
2139+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicoreOp();
2140+ ASSERT_NE(ge_root_model, nullptr);
2141+ const auto &name_to_ge_model = ge_root_model->GetSubgraphInstanceNameToModel();
2142+ ASSERT_FALSE(name_to_ge_model.empty());
2143+ const auto ge_model = name_to_ge_model.begin()->second;
2144+ auto *model_task_def = ge_model->GetModelTaskDefPtr().get();
2145+ ASSERT_NE(model_task_def, nullptr);
2146+ 
2147+ auto *unsupported_task = model_task_def->add_task();
2148+ ASSERT_NE(unsupported_task, nullptr);
2149+ unsupported_task->set_type(static_cast<uint32_t>(ModelTaskType::MODEL_TASK_EVENT_RECORD));
2150+ unsupported_task->set_stream_id(0U);
2151+ 
2152+ Om2CodegenModel doc;
2153+ EXPECT_NE(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2154+}
2155+ 
2156+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_AicoreChain_Ok) {
2157+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicoreChainOp();
2158+ ASSERT_NE(ge_root_model, nullptr);
2159+ Om2CodegenModel doc;
2160+ ASSERT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2161+}
2162+ 
2163+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_AicpuOp_Ok) {
2164+ GeRootModelPtr ge_root_model = CreateGeRootModelWithAicpuOp();
2165+ ASSERT_NE(ge_root_model, nullptr);
2166+ Om2CodegenModel doc;
2167+ ASSERT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2168+}
2169+ 
2170+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_TfAicpuOp_Ok) {
2171+ GeRootModelPtr ge_root_model = CreateGeRootModelWithTfAicpuOp();
2172+ ASSERT_NE(ge_root_model, nullptr);
2173+ Om2CodegenModel doc;
2174+ ASSERT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2175+}
2176+ 
2177+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_MemcpyAsync_Ok) {
2178+ GeModelPtr ge_model = CreateGeModelWithMemcpyAsyncTask();
2179+ ASSERT_NE(ge_model, nullptr);
2180+ Om2CodegenModel doc;
2181+ ASSERT_EQ(BuildCodegenModel(ge_model, doc), SUCCESS);
2182+}
2183+ 
2184+TEST_F(Om2CodegenModelBuilderUt, BuildCodegenModel_SimpleTasksWithStub_Ok) {
2185+ GeRootModelPtr ge_root_model = CreateGeRootModelWithSimpleTasksAndStub();
2186+ ASSERT_NE(ge_root_model, nullptr);
2187+ Om2CodegenModel doc;
2188+ ASSERT_EQ(BuildCodegenModel(ge_root_model, doc), SUCCESS);
2189+}
2086} // namespace ge2190} // namespace ge
Mtests/ge/ut/ge/common/om2_codegen_unittest.cc+93-0
@@ -2149,4 +2149,97 @@ TEST_F(Om2CodegenUt, TaskCodeBuilderUtil_ConvertAddrDesc_NoConstIndex) {
2149 EXPECT_EQ(desc.type, OP_ARG_INPUT);2149 EXPECT_EQ(desc.type, OP_ARG_INPUT);
2150 EXPECT_EQ(desc.mem_src, 0U);2150 EXPECT_EQ(desc.mem_src, 0U);
2151}2151}
2152+ 
2153+TEST_F(Om2CodegenUt, CppEmitter_ProtectedAccessAndConstCast) {
2154+ AstContext ctx;
2155+ AstBuildContext ast(ctx);
2156+ 
2157+ auto *protected_decl = AccessSectionDecl::Create(ctx, AccessSectionDecl::Kind::kProtected);
2158+ ASSERT_NE(protected_decl, nullptr);
2159+ auto *class_decl =
2160+ ClassDecl::Create(ctx, "ProtectedClass", {protected_decl, FieldDecl::Create(ctx, "int", "hidden")});
2161+ ASSERT_NE(class_decl, nullptr);
2162+ 
2163+ auto *ident_x = IdentifierExpr::Create(ctx, "x");
2164+ auto *const_cast_expr = CppCastExpr::Create(ctx, CppCastExpr::Kind::kConst, "int &", ident_x);
2165+ ASSERT_NE(const_cast_expr, nullptr);
2166+ 
2167+ auto *tu = TranslationUnit::Create(ctx, {class_decl});
2168+ ASSERT_NE(tu, nullptr);
2169+ const auto class_output = EmitNode(*tu);
2170+ const auto cast_output = EmitNode(*const_cast_expr);
2171+ const std::string output = class_output + "\n" + cast_output;
2172+ ExpectContainsAll(output, {"protected:", "const_cast<int &>(x)"});
2173+}
2174+ 
2175+TEST_F(Om2CodegenUt, CppEmitter_AllBuiltinTypes) {
2176+ AstContext ctx;
2177+ AstBuildContext ast(ctx);
2178+ 
2179+ auto count = ast.Var("size_t", "count");
2180+ const std::vector<std::pair<BuiltinType, std::string>> type_pairs = {
2181+ {BuiltinType::kVoid, "void"}, {BuiltinType::kBool, "bool"}, {BuiltinType::kChar, "char"},
2182+ {BuiltinType::kInt8, "int8_t"}, {BuiltinType::kUInt8, "uint8_t"}, {BuiltinType::kInt16, "int16_t"},
2183+ {BuiltinType::kUInt16, "uint16_t"}, {BuiltinType::kInt32, "int32_t"}, {BuiltinType::kUInt32, "uint32_t"},
2184+ {BuiltinType::kInt64, "int64_t"}, {BuiltinType::kUInt64, "uint64_t"}, {BuiltinType::kFloat, "float"},
2185+ {BuiltinType::kDouble, "double"},
2186+ };
2187+ 
2188+ std::vector<Stmt *> body;
2189+ for (const auto &pair : type_pairs) {
2190+ body.push_back(ast.VarDecl("auto", "buf_" + pair.second, ast.MakeUniqueArray(pair.first, count)));
2191+ }
2192+ body.push_back(ast.Return());
2193+ 
2194+ auto *fn = ast.DefineFunction("TestAllBuiltinTypes", {count}, "void", body);
2195+ ASSERT_NE(fn, nullptr);
2196+ 
2197+ const auto output = EmitNode(*fn);
2198+ for (const auto &pair : type_pairs) {
2199+ EXPECT_NE(output.find("std::make_unique<" + pair.second + "[]>(count)"), std::string::npos)
2200+ << "Missing builtin type: " << pair.second;
2201+ }
2202+}
2203+ 
2204+TEST_F(Om2CodegenUt, CppEmitter_IntSuffixL) {
2205+ AstContext ctx;
2206+ 
2207+ auto *lit_l = LiteralExpr::CreateInt(ctx, 42, LiteralExpr::IntSuffix::kL);
2208+ ASSERT_NE(lit_l, nullptr);
2209+ EXPECT_EQ(lit_l->GetIntSuffix(), LiteralExpr::IntSuffix::kL);
2210+ 
2211+ auto *var_decl = VarDeclStmt::Create(ctx, "long", "val", lit_l);
2212+ ASSERT_NE(var_decl, nullptr);
2213+ 
2214+ const auto output = EmitNode(*var_decl);
2215+ EXPECT_NE(output.find("42L"), std::string::npos);
2216+}
2217+ 
2218+TEST_F(Om2CodegenUt, CppEmitter_ForLoopWithExprStmtInit) {
2219+ AstContext ctx;
2220+ AstBuildContext ast(ctx);
2221+ 
2222+ auto i = ast.Var("size_t", "i");
2223+ auto assign_init = ast.Assign(i, 0);
2224+ auto *for_stmt = ast.For(ExprStmt::Create(ctx, assign_init.Get()), i < 10, ast.PreInc(i), {ast.Assign(i, i + 1)});
2225+ 
2226+ auto *fn = ast.DefineFunction("TestForWithExprInit", std::vector<VarRef>{}, "void",
2227+ std::vector<Stmt *>{for_stmt, ast.Return()});
2228+ ASSERT_NE(fn, nullptr);
2229+ 
2230+ const auto output = EmitNode(*fn);
2231+ EXPECT_NE(output.find("for (i = 0;"), std::string::npos);
2232+}
2233+ 
2234+TEST_F(Om2CodegenUt, CppEmitter_EmptyTypeNameSeparator) {
2235+ AstContext ctx;
2236+ AstBuildContext ast(ctx);
2237+ 
2238+ auto *type_alias = TypeAliasDecl::Create(ctx, "", "EmptyTypeAlias");
2239+ ASSERT_NE(type_alias, nullptr);
2240+ auto *tu = TranslationUnit::Create(ctx, {type_alias});
2241+ ASSERT_NE(tu, nullptr);
2242+ const auto output = EmitNode(*tu);
2243+ EXPECT_NE(output.find("EmptyTypeAlias"), std::string::npos);
2244+}
2152} // namespace ge2245} // namespace ge
Mtests/ge/ut/ge/common/op_tiling_rt2_unittest.cc+31-0
@@ -1207,4 +1207,35 @@ TEST_F(RegisterOpTilingRT2UT, AutofuseNodeNativeFallbackSuccess) {
1207 1207 
1208 ge::MmpaStub::GetInstance().Reset();1208 ge::MmpaStub::GetInstance().Reset();
1209}1209}
1210+ 
1211+TEST_F(RegisterOpTilingRT2UT, EnableRt2Tiling_WithUnknownOpType_ReturnsTrue) {
1212+ auto op_desc = std::make_shared<ge::OpDesc>("unknown_op", "UnknownOpType");
1213+ EXPECT_TRUE(EnableRt2Tiling(op_desc));
1214+}
1215+ 
1216+TEST_F(RegisterOpTilingRT2UT, EnableRt2Tiling_WithRt2RegisteredOp_ReturnsTrue) {
1217+ SpaceRegistryFaker::UpdateOpImplToDefaultSpaceRegistry();
1218+ auto op_desc = std::make_shared<ge::OpDesc>("concat_op", "ConcatV2");
1219+ EXPECT_TRUE(EnableRt2Tiling(op_desc));
1220+}
1221+ 
1222+TEST_F(RegisterOpTilingRT2UT, EnableAtomicRt2Tiling_WithUnknownOpType_ReturnsTrue) {
1223+ auto op_desc = std::make_shared<ge::OpDesc>("unknown_atomic_op", "UnknownOpType");
1224+ EXPECT_TRUE(EnableAtomicRt2Tiling(op_desc));
1225+}
1226+ 
1227+TEST_F(RegisterOpTilingRT2UT, EnableRt2Tiling_WithNullOpDesc) {
1228+ ge::OpDescPtr null_op_desc = nullptr;
1229+ EXPECT_FALSE(EnableRt2Tiling(null_op_desc));
1230+}
1231+ 
1232+TEST_F(RegisterOpTilingRT2UT, GetDeterministicLevel_WithSessionOption) {
1233+ ge::GetThreadLocalContext().SetSessionOption({{"ge.deterministicLevel", "1"}});
1234+ int32_t deterministic_level = -1;
1235+ bool has_deterministic_level = false;
1236+ EXPECT_EQ(GetDeterministicLevel(deterministic_level, has_deterministic_level), GRAPH_SUCCESS);
1237+ EXPECT_EQ(deterministic_level, 1);
1238+ EXPECT_TRUE(has_deterministic_level);
1239+ ge::GetThreadLocalContext().SetSessionOption({});
1240+}
1210} // namespace optiling1241} // namespace optiling
Mtests/ge/ut/ge/common/program_generator_unittest.cc+251-0
@@ -6803,4 +6803,255 @@ TEST_F(ProgramGeneratorUt, GenerateLoadAndRunSource_ContainsProfilingPatterns) {
6803 EXPECT_NE(load_run.find("weight_mem_size"), std::string::npos);6803 EXPECT_NE(load_run.find("weight_mem_size"), std::string::npos);
6804}6804}
6805 6805 
6806+void AppendShapeType(std::string &out, int32_t type_value) {
6807+ size_t len = sizeof(int32_t) + sizeof(AicpuExtInfo);
6808+ vector<char> vec(len, 0);
6809+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6810+ aicpu_ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE;
6811+ aicpu_ext_info->infoLen = sizeof(int32_t);
6812+ *(ge::PtrToPtr<char, int32_t>(aicpu_ext_info->infoMsg)) = type_value;
6813+ std::string s(vec.data(), len);
6814+ out.append(s);
6815+}
6816+ 
6817+void AppendShapeTypeWrongLen(std::string &out) {
6818+ size_t len = 2U + sizeof(AicpuExtInfo);
6819+ vector<char> vec(len, 0);
6820+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6821+ aicpu_ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_SHAPE_TYPE;
6822+ aicpu_ext_info->infoLen = 2U;
6823+ std::string s(vec.data(), len);
6824+ out.append(s);
6825+}
6826+ 
6827+void AppendUnknownInfoType(std::string &out) {
6828+ size_t len = sizeof(int32_t) + sizeof(AicpuExtInfo);
6829+ vector<char> vec(len, 0);
6830+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6831+ aicpu_ext_info->infoType = 9999;
6832+ aicpu_ext_info->infoLen = sizeof(int32_t);
6833+ std::string s(vec.data(), len);
6834+ out.append(s);
6835+}
6836+ 
6837+void AppendWorkSpaceInfoWrongLen(std::string &out) {
6838+ size_t len = 2U + sizeof(AicpuExtInfo);
6839+ vector<char> vec(len, 0);
6840+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6841+ aicpu_ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_WORKSPACE_INFO;
6842+ aicpu_ext_info->infoLen = 2U;
6843+ std::string s(vec.data(), len);
6844+ out.append(s);
6845+}
6846+ 
6847+void AppendAsyncWaitWrongLen(std::string &out) {
6848+ size_t len = 2U + sizeof(AicpuExtInfo);
6849+ vector<char> vec(len, 0);
6850+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6851+ aicpu_ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_ASYNCWAIT;
6852+ aicpu_ext_info->infoLen = 2U;
6853+ std::string s(vec.data(), len);
6854+ out.append(s);
6855+}
6856+ 
6857+void AppendTopicTypeWrongLen(std::string &out) {
6858+ size_t len = 2U + sizeof(AicpuExtInfo);
6859+ vector<char> vec(len, 0);
6860+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6861+ aicpu_ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_TOPIC_TYPE;
6862+ aicpu_ext_info->infoLen = 2U;
6863+ std::string s(vec.data(), len);
6864+ out.append(s);
6865+}
6866+ 
6867+void AppendTopicTypeInvalid(std::string &out) {
6868+ size_t len = sizeof(int32_t) + sizeof(AicpuExtInfo);
6869+ vector<char> vec(len, 0);
6870+ AicpuExtInfo *aicpu_ext_info = reinterpret_cast<AicpuExtInfo *>(vec.data());
6871+ aicpu_ext_info->infoType = aicpu::FWKAdapter::FWK_ADPT_EXT_TOPIC_TYPE;
6872+ aicpu_ext_info->infoLen = sizeof(int32_t);
6873+ *(ge::PtrToPtr<char, int32_t>(aicpu_ext_info->infoMsg)) = 0xFF;
6874+ std::string s(vec.data(), len);
6875+ out.append(s);
6876+}
6877+ 
6878+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseEmptyExtInfo) {
6879+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6880+ std::string empty_ext_info;
6881+ EXPECT_EQ(handler.Parse(empty_ext_info), ACL_ERROR_GE_PARAM_INVALID);
6882+}
6883+ 
6884+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseWithShapeType) {
6885+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6886+ std::string ext_info;
6887+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6888+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6889+ AppendShapeType(ext_info, static_cast<int32_t>(0));
6890+ EXPECT_EQ(handler.Parse(ext_info), SUCCESS);
6891+}
6892+ 
6893+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseWithShapeTypeWrongLen) {
6894+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6895+ std::string ext_info;
6896+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6897+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6898+ AppendShapeTypeWrongLen(ext_info);
6899+ EXPECT_EQ(handler.Parse(ext_info), ACL_ERROR_GE_PARAM_INVALID);
6900+}
6901+ 
6902+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseWithShapeTypeWrongType) {
6903+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6904+ std::string ext_info;
6905+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6906+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6907+ AppendShapeType(ext_info, 999);
6908+ EXPECT_EQ(handler.Parse(ext_info), ACL_ERROR_GE_PARAM_INVALID);
6909+}
6910+ 
6911+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseWithUnknownInfoType) {
6912+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6913+ std::string ext_info;
6914+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6915+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6916+ AppendUnknownInfoType(ext_info);
6917+ EXPECT_EQ(handler.Parse(ext_info), SUCCESS);
6918+}
6919+ 
6920+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseWorkSpaceInfoWrongLen) {
6921+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6922+ std::string ext_info;
6923+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6924+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6925+ AppendWorkSpaceInfoWrongLen(ext_info);
6926+ EXPECT_EQ(handler.Parse(ext_info), ACL_ERROR_GE_PARAM_INVALID);
6927+}
6928+ 
6929+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseAsyncWaitWrongLen) {
6930+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6931+ std::string ext_info;
6932+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6933+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6934+ AppendAsyncWaitWrongLen(ext_info);
6935+ EXPECT_EQ(handler.Parse(ext_info), ACL_ERROR_GE_PARAM_INVALID);
6936+}
6937+ 
6938+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_ParseTopicTypeWrongLen) {
6939+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6940+ std::string ext_info;
6941+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_INPUT_SHAPE, 2, ext_info);
6942+ AppendShape(aicpu::FWKAdapter::FWK_ADPT_EXT_OUTPUT_SHAPE, 1, ext_info);
6943+ AppendTopicTypeWrongLen(ext_info);
6944+ EXPECT_EQ(handler.Parse(ext_info), ACL_ERROR_GE_PARAM_INVALID);
6945+}
6946+ 
6947+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_UpdateExecuteMode_NoBitMap) {
6948+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6949+ std::string ext_info = GetFakeExtInfoWithWorkSpace();
6950+ ASSERT_EQ(handler.Parse(ext_info), SUCCESS);
6951+ EXPECT_EQ(handler.UpdateExecuteMode(true), SUCCESS);
6952+}
6953+ 
6954+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_UpdateExecuteMode_WithBitMap) {
6955+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6956+ std::string ext_info = GetFakeExtInfo();
6957+ ASSERT_EQ(handler.Parse(ext_info), SUCCESS);
6958+ EXPECT_EQ(handler.UpdateExecuteMode(false), SUCCESS);
6959+ EXPECT_EQ(handler.UpdateExecuteMode(true), SUCCESS);
6960+}
6961+ 
6962+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_UpdateSessionInfoId_WithSessionInfo) {
6963+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6964+ std::string ext_info = GetFakeExtInfo();
6965+ ASSERT_EQ(handler.Parse(ext_info), SUCCESS);
6966+ EXPECT_EQ(handler.UpdateSessionInfoId(12345U), SUCCESS);
6967+}
6968+ 
6969+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_UpdateSessionInfoId_NoSessionInfo) {
6970+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6971+ std::string ext_info = GetFakeExtInfoWithWorkSpace();
6972+ ASSERT_EQ(handler.Parse(ext_info), SUCCESS);
6973+ EXPECT_EQ(handler.UpdateSessionInfoId(12345U), SUCCESS);
6974+}
6975+ 
6976+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_UpdateWorkSpaceInfo_NoWorkspace) {
6977+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6978+ std::string ext_info = GetFakeExtInfo();
6979+ ASSERT_EQ(handler.Parse(ext_info), SUCCESS);
6980+ EXPECT_EQ(handler.UpdateWorkSpaceInfo(1024U, 2048U), FAILED);
6981+}
6982+ 
6983+TEST_F(ProgramGeneratorUt, AicpuExtInfoHandler_UpdateShapeAndTypeGeShape_DimsOverMax) {
6984+ om2::Om2AicpuExtInfoHandler handler("test_node", 2, 1, static_cast<UnknowShapeOpType>(0));
6985+ std::string ext_info = GetFakeExtInfo();
6986+ ASSERT_EQ(handler.Parse(ext_info), SUCCESS);
6987+ 
6988+ std::vector<int64_t> dims;
6989+ for (size_t i = 0; i <= aicpu::FWKAdapter::kMaxShapeDims + 1; ++i) {
6990+ dims.push_back(static_cast<int64_t>(i));
6991+ }
6992+ GeShape shape(dims);
6993+ AicpuShapeAndType shape_and_type = {};
6994+ EXPECT_EQ(om2::Om2AicpuExtInfoHandler::UpdateShapeAndType(shape, DT_FLOAT, &shape_and_type),
6995+ ACL_ERROR_GE_PARAM_INVALID);
6996+}
6997+ 
6998+TEST_F(ProgramGeneratorUt, Om2ModelUtils_GetWorkspaceMemTypeByPriority_AllTypes) {
6999+ auto p2p_type = Om2ModelUtils::GetWorkspaceMemTypeByPriority(true, false, false, false);
7000+ auto l1_type = Om2ModelUtils::GetWorkspaceMemTypeByPriority(false, true, false, false);
7001+ auto ub_type = Om2ModelUtils::GetWorkspaceMemTypeByPriority(false, false, true, false);
7002+ auto session_type = Om2ModelUtils::GetWorkspaceMemTypeByPriority(false, false, false, true);
7003+ auto hbm_type = Om2ModelUtils::GetWorkspaceMemTypeByPriority(false, false, false, false);
7004+ EXPECT_NE(p2p_type, hbm_type);
7005+ EXPECT_NE(l1_type, hbm_type);
7006+ EXPECT_NE(ub_type, hbm_type);
7007+ EXPECT_NE(session_type, hbm_type);
7008+ EXPECT_EQ(hbm_type, RT_MEMORY_HBM);
7009+}
7010+ 
7011+TEST_F(ProgramGeneratorUt, Om2ModelUtils_ValidateMemRange_Overflow) {
7012+ auto op_desc = std::make_shared<OpDesc>("test_op", "Add");
7013+ EXPECT_FALSE(Om2ModelUtils::ValidateMemRange(op_desc, 1024U, std::numeric_limits<int64_t>::max(), 1));
7014+}
7015+ 
7016+TEST_F(ProgramGeneratorUt, Om2ModelUtils_ValidateMemRange_OutOfRange) {
7017+ auto op_desc = std::make_shared<OpDesc>("test_op", "Add");
7018+ EXPECT_FALSE(Om2ModelUtils::ValidateMemRange(op_desc, 100U, 50, 200));
7019+}
7020+ 
7021+TEST_F(ProgramGeneratorUt, Om2ModelUtils_ValidateMemRange_Success) {
7022+ auto op_desc = std::make_shared<OpDesc>("test_op", "Add");
7023+ EXPECT_TRUE(Om2ModelUtils::ValidateMemRange(op_desc, 1024U, 0, 512));
7024+}
7025+ 
7026+TEST_F(ProgramGeneratorUt, Om2ModelUtils_GetValidatedTensorMemType_InvalidType) {
7027+ auto tensor_desc = std::make_shared<GeTensorDesc>();
7028+ AttrUtils::SetInt(tensor_desc, ATTR_NAME_TENSOR_MEM_TYPE, 9999);
7029+ std::vector<int64_t> mem_types;
7030+ uint64_t memory_type = 0U;
7031+ EXPECT_EQ(Om2ModelUtils::GetValidatedTensorMemType(tensor_desc, mem_types, 0, memory_type), FAILED);
7032+}
7033+ 
7034+TEST_F(ProgramGeneratorUt, Om2ModelUtils_GetValidatedTensorMemType_FromMemTypes) {
7035+ auto tensor_desc = std::make_shared<GeTensorDesc>();
7036+ std::vector<int64_t> mem_types = {static_cast<int64_t>(RT_MEMORY_HBM)};
7037+ uint64_t memory_type = 0U;
7038+ EXPECT_EQ(Om2ModelUtils::GetValidatedTensorMemType(tensor_desc, mem_types, 0, memory_type), SUCCESS);
7039+ EXPECT_EQ(memory_type, RT_MEMORY_HBM);
7040+}
7041+ 
7042+TEST_F(ProgramGeneratorUt, Om2ModelUtils_GetValidatedTensorMemType_DefaultHBM) {
7043+ auto tensor_desc = std::make_shared<GeTensorDesc>();
7044+ std::vector<int64_t> mem_types;
7045+ uint64_t memory_type = 0U;
7046+ EXPECT_EQ(Om2ModelUtils::GetValidatedTensorMemType(tensor_desc, mem_types, 0, memory_type), SUCCESS);
7047+ EXPECT_EQ(memory_type, RT_MEMORY_DEFAULT);
7048+}
7049+ 
7050+TEST_F(ProgramGeneratorUt, Om2ModelUtils_ArgsSizeAlign8_Success) {
7051+ EXPECT_EQ(Om2ModelUtils::ArgsSizeAlign8(static_cast<uint32_t>(1)), 8U);
7052+ EXPECT_EQ(Om2ModelUtils::ArgsSizeAlign8(static_cast<uint32_t>(8)), 8U);
7053+ EXPECT_EQ(Om2ModelUtils::ArgsSizeAlign8(static_cast<uint32_t>(9)), 16U);
7054+ EXPECT_EQ(Om2ModelUtils::ArgsSizeAlign8(static_cast<uint64_t>(1)), 8UL);
7055+ EXPECT_EQ(Om2ModelUtils::ArgsSizeAlign8(static_cast<uint64_t>(16)), 16UL);
7056+}
6806} // namespace ge7057} // namespace ge
Mtests/ge/ut/ge/common/tensor_trans_utils_unittest.cc+82-0
@@ -571,4 +571,86 @@ TEST_F(UtestTensorTransUtils, RunGraphAsyncCallback_FullSimulation) {
571 571 
572 // 如果代码运行到这里没有 coredump，说明在这个场景下没有触发问题572 // 如果代码运行到这里没有 coredump，说明在这个场景下没有触发问题
573}573}
574+ 
575+TEST_F(UtestTensorTransUtils, ContructRtShapeFromShape_Success) {
576+ Shape ge_shape({2, 3, 4});
577+ auto rt_shape = TensorTransUtils::ContructRtShapeFromShape(ge_shape);
578+ EXPECT_EQ(rt_shape.GetDimNum(), 3U);
579+ EXPECT_EQ(rt_shape.GetDim(0), 2);
580+ EXPECT_EQ(rt_shape.GetDim(1), 3);
581+ EXPECT_EQ(rt_shape.GetDim(2), 4);
582+}
583+ 
584+TEST_F(UtestTensorTransUtils, ContructRtShapeFromShape_Empty) {
585+ Shape ge_shape;
586+ auto rt_shape = TensorTransUtils::ContructRtShapeFromShape(ge_shape);
587+ EXPECT_EQ(rt_shape.GetDimNum(), 0U);
588+}
589+ 
590+TEST_F(UtestTensorTransUtils, TransTensorToGertTensor_Success) {
591+ Tensor ge_tensor;
592+ TensorDesc tensor_desc(Shape({2, 3}), FORMAT_ND, DT_FLOAT);
593+ tensor_desc.SetOriginFormat(FORMAT_ND);
594+ tensor_desc.SetOriginShape(Shape({2, 3}));
595+ tensor_desc.SetPlacement(Placement::kPlacementHost);
596+ ge_tensor.SetTensorDesc(tensor_desc);
597+ 
598+ gert::Tensor rt_tensor;
599+ EXPECT_EQ(TensorTransUtils::TransTensorToGertTensor(ge_tensor, rt_tensor), SUCCESS);
600+ EXPECT_EQ(rt_tensor.GetDataType(), DT_FLOAT);
601+ EXPECT_EQ(rt_tensor.GetStorageShape().GetDimNum(), 2U);
602+ EXPECT_EQ(rt_tensor.GetStorageShape().GetDim(0), 2);
603+ EXPECT_EQ(rt_tensor.GetStorageShape().GetDim(1), 3);
604+}
605+ 
606+TEST_F(UtestTensorTransUtils, TransTensorToGertTensor_DevicePlacement) {
607+ Tensor ge_tensor;
608+ TensorDesc tensor_desc(Shape({1, 4}), FORMAT_NCHW, DT_FLOAT16);
609+ tensor_desc.SetOriginFormat(FORMAT_NCHW);
610+ tensor_desc.SetOriginShape(Shape({1, 4}));
611+ tensor_desc.SetPlacement(Placement::kPlacementDevice);
612+ ge_tensor.SetTensorDesc(tensor_desc);
613+ 
614+ gert::Tensor rt_tensor;
615+ EXPECT_EQ(TensorTransUtils::TransTensorToGertTensor(ge_tensor, rt_tensor), SUCCESS);
616+ EXPECT_EQ(rt_tensor.GetDataType(), DT_FLOAT16);
617+ EXPECT_EQ(rt_tensor.GetPlacement(), gert::TensorPlacement::kOnDeviceHbm);
618+}
619+ 
620+TEST_F(UtestTensorTransUtils, FillRtTensorDesc_Success) {
621+ Tensor ge_tensor;
622+ TensorDesc tensor_desc(Shape({2, 3}), FORMAT_ND, DT_INT32);
623+ tensor_desc.SetOriginFormat(FORMAT_ND);
624+ tensor_desc.SetOriginShape(Shape({2, 3}));
625+ tensor_desc.SetPlacement(Placement::kPlacementHost);
626+ ge_tensor.SetTensorDesc(tensor_desc);
627+ 
628+ gert::Tensor rt_tensor;
629+ EXPECT_EQ(TensorTransUtils::FillRtTensorDesc(ge_tensor, rt_tensor), SUCCESS);
630+ EXPECT_EQ(rt_tensor.GetDataType(), DT_INT32);
631+ EXPECT_EQ(rt_tensor.GetStorageShape().GetDimNum(), 2U);
632+ EXPECT_EQ(rt_tensor.GetStorageShape().GetDim(0), 2);
633+ EXPECT_EQ(rt_tensor.GetStorageShape().GetDim(1), 3);
634+}
635+ 
636+TEST_F(UtestTensorTransUtils, FillRtTensorDesc_DevicePlacement) {
637+ Tensor ge_tensor;
638+ TensorDesc tensor_desc(Shape({4, 5, 6}), FORMAT_NCHW, DT_FLOAT);
639+ tensor_desc.SetOriginFormat(FORMAT_NCHW);
640+ tensor_desc.SetOriginShape(Shape({4, 5, 6}));
641+ tensor_desc.SetPlacement(Placement::kPlacementDevice);
642+ ge_tensor.SetTensorDesc(tensor_desc);
643+ 
644+ gert::Tensor rt_tensor;
645+ EXPECT_EQ(TensorTransUtils::FillRtTensorDesc(ge_tensor, rt_tensor), SUCCESS);
646+ EXPECT_EQ(rt_tensor.GetPlacement(), gert::TensorPlacement::kOnDeviceHbm);
647+}
648+ 
649+TEST_F(UtestTensorTransUtils, TransGertTensorToHost_EmptyShape_ZeroOutputSize) {
650+ gert::Tensor src_tensor = {
651+ {{0, 0, 0, 0}, {0, 0, 0, 0}}, {ge::FORMAT_ND, ge::FORMAT_ND, {}}, gert::kOnHost, ge::DT_FLOAT, nullptr};
652+ gert::Tensor dst_tensor;
653+ EXPECT_EQ(TensorTransUtils::TransGertTensorToHost(src_tensor, dst_tensor), SUCCESS);
654+ EXPECT_EQ(dst_tensor.GetSize(), 0U);
655+}
574} // namespace ge656} // namespace ge
Mtests/ge/ut/ge/common/util_unittest.cc+110-0
@@ -547,5 +547,115 @@ TEST_F(UtestUtilTransfer, ReadBytesFromBinaryFile_BufferAllocFailed) {
547 g_fail_nothrow_new = false;547 g_fail_nothrow_new = false;
548 system("rm -f ut_test_buf_alloc");548 system("rm -f ut_test_buf_alloc");
549}549}
550+ 
551+TEST_F(UtestUtilTransfer, CheckInputPathValid_InvalidPathChars_CovEnhance) {
552+ system("touch 'test file with spaces.txt'");
553+ EXPECT_EQ(CheckInputPathValid("test file with spaces.txt", ""), false);
554+ system("rm 'test file with spaces.txt'");
555+}
556+ 
557+TEST_F(UtestUtilTransfer, CheckOutputPathValid_RootPath_CovEnhance) {
558+ EXPECT_EQ(CheckOutputPathValid("/testfile", ""), true);
559+}
560+ 
561+TEST_F(UtestUtilTransfer, ValidateStr_RegcompFail_CovEnhance) {
562+ EXPECT_TRUE(ValidateStr("test", "["));
563+}
564+ 
565+TEST_F(UtestUtilTransfer, ValidateStr_RegexecFail_CovEnhance) {
566+ EXPECT_FALSE(ValidateStr("test!@#", "^[a-zA-Z0-9]+$"));
567+}
568+ 
569+TEST_F(UtestUtilTransfer, ConvertToInt32_InvalidArg_CovEnhance) {
570+ int32_t val = 0;
571+ EXPECT_EQ(ConvertToInt32("abc", val), FAILED);
572+}
573+ 
574+TEST_F(UtestUtilTransfer, ConvertToInt32_OutOfRange_CovEnhance) {
575+ int32_t val = 0;
576+ EXPECT_EQ(ConvertToInt32("999999999999999", val), FAILED);
577+}
578+ 
579+TEST_F(UtestUtilTransfer, ConvertToInt32_PartialParse_CovEnhance) {
580+ int32_t val = 0;
581+ EXPECT_EQ(ConvertToInt32("123abc", val), FAILED);
582+}
583+ 
584+TEST_F(UtestUtilTransfer, ConvertToInt32_Success_CovEnhance) {
585+ int32_t val = 0;
586+ EXPECT_EQ(ConvertToInt32("42", val), SUCCESS);
587+ EXPECT_EQ(val, 42);
588+}
589+ 
590+TEST_F(UtestUtilTransfer, ConvertToInt64_InvalidArg_CovEnhance) {
591+ int64_t val = 0;
592+ EXPECT_EQ(ConvertToInt64("abc", val), FAILED);
593+}
594+ 
595+TEST_F(UtestUtilTransfer, ConvertToInt64_OutOfRange_CovEnhance) {
596+ int64_t val = 0;
597+ EXPECT_EQ(ConvertToInt64("99999999999999999999999999", val), FAILED);
598+}
599+ 
600+TEST_F(UtestUtilTransfer, ConvertToInt64_Success_CovEnhance) {
601+ int64_t val = 0;
602+ EXPECT_EQ(ConvertToInt64("42", val), SUCCESS);
603+ EXPECT_EQ(val, 42);
604+}
605+ 
606+TEST_F(UtestUtilTransfer, ConvertToUint64_InvalidArg_CovEnhance) {
607+ uint64_t val = 0;
608+ EXPECT_EQ(ConvertToUint64("abc", val), FAILED);
609+}
610+ 
611+TEST_F(UtestUtilTransfer, ConvertToUint64_OutOfRange_CovEnhance) {
612+ uint64_t val = 0;
613+ EXPECT_EQ(ConvertToUint64("99999999999999999999999999", val), FAILED);
614+}
615+ 
616+TEST_F(UtestUtilTransfer, ConvertToUint64_Success_CovEnhance) {
617+ uint64_t val = 0;
618+ EXPECT_EQ(ConvertToUint64("42", val), SUCCESS);
619+ EXPECT_EQ(val, 42U);
620+}
621+ 
622+TEST_F(UtestUtilTransfer, CheckIoReuseAddrPairs_Success_CovEnhance) {
623+ std::vector<std::pair<size_t, size_t>> pairs = {{0, 0}};
624+ int32_t dummy = 0;
625+ auto get_input = [&dummy](size_t) -> const void * { return &dummy; };
626+ auto get_output = [&dummy](size_t) -> const void * { return &dummy; };
627+ EXPECT_EQ(CheckIoReuseAddrPairs(pairs, get_input, 1, get_output, 1), SUCCESS);
628+}
629+ 
630+TEST_F(UtestUtilTransfer, CheckIoReuseAddrPairs_AddrMismatch_CovEnhance) {
631+ std::vector<std::pair<size_t, size_t>> pairs = {{0, 0}};
632+ int32_t dummy1 = 0;
633+ int32_t dummy2 = 1;
634+ auto get_input = [&dummy1](size_t) -> const void * { return &dummy1; };
635+ auto get_output = [&dummy2](size_t) -> const void * { return &dummy2; };
636+ EXPECT_EQ(CheckIoReuseAddrPairs(pairs, get_input, 1, get_output, 1), PARAM_INVALID);
637+}
638+ 
639+TEST_F(UtestUtilTransfer, CheckIoReuseAddrPairs_InputOutOfRange_CovEnhance) {
640+ std::vector<std::pair<size_t, size_t>> pairs = {{5, 0}};
641+ int32_t dummy = 0;
642+ auto get_input = [&dummy](size_t) -> const void * { return &dummy; };
643+ auto get_output = [&dummy](size_t) -> const void * { return &dummy; };
644+ EXPECT_EQ(CheckIoReuseAddrPairs(pairs, get_input, 1, get_output, 1), PARAM_INVALID);
645+}
646+ 
647+TEST_F(UtestUtilTransfer, CheckIoReuseAddrPairs_OutputOutOfRange_CovEnhance) {
648+ std::vector<std::pair<size_t, size_t>> pairs = {{0, 5}};
649+ int32_t dummy = 0;
650+ auto get_input = [&dummy](size_t) -> const void * { return &dummy; };
651+ auto get_output = [&dummy](size_t) -> const void * { return &dummy; };
652+ EXPECT_EQ(CheckIoReuseAddrPairs(pairs, get_input, 1, get_output, 1), PARAM_INVALID);
653+}
654+ 
655+TEST_F(UtestUtilTransfer, PrintOptionsWithLengthLimit_LongValue_CovEnhance) {
656+ std::map<std::string, std::string> options;
657+ options["key"] = std::string(200, 'x');
658+ PrintOptionsWithLengthLimit(options, "prefix", 50U);
659+}
550} // namespace formats660} // namespace formats
551} // namespace ge661} // namespace ge
Mtests/ge/ut/ge/common/visualization_unittest.cc+317-0
@@ -912,5 +912,322 @@ TEST_F(VisualizationTest, SerializeFromModelDef_EmptyModel) {
912 EXPECT_FALSE(j["model"].contains("graph"));912 EXPECT_FALSE(j["model"].contains("graph"));
913}913}
914 914 
915+TEST_F(VisualizationTest, SerializeFromModelDef_DoubleField) {
916+ proto::ModelDef model_def;
917+ model_def.set_name("double_model");
918+ auto *graph = model_def.add_graph();
919+ graph->set_name("main_graph");
920+ auto *op = graph->add_op();
921+ op->set_name("double_op");
922+ op->set_type("DoubleOp");
923+ 
924+ auto *td = op->add_input_desc();
925+ td->set_name("input_td");
926+ td->set_dtype(proto::DT_DOUBLE);
927+ td->mutable_shape()->add_dim(2);
928+ td->mutable_shape()->add_dim(3);
929+ 
930+ std::string json_str;
931+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
932+ 
933+ nlohmann::json j;
934+ ASSERT_NO_THROW(j = nlohmann::json::parse(json_str));
935+ EXPECT_EQ(j["model"]["graph"][0]["op"][0]["input_desc"][0]["dtype"], "DT_DOUBLE");
936+}
937+ 
938+TEST_F(VisualizationTest, SerializeFromModelDef_RepeatedDoubleField) {
939+ proto::ModelDef model_def;
940+ auto *graph = model_def.add_graph();
941+ graph->set_name("main_graph");
942+ auto *op = graph->add_op();
943+ op->set_name("rep_dt_op");
944+ op->set_type("RepDtOp");
945+ 
946+ auto *list = (*op->mutable_attr())["list_dt"].mutable_list();
947+ list->set_val_type(proto::AttrDef_ListValue_ListValueType_VT_LIST_DATA_TYPE);
948+ list->add_dt(proto::DT_DOUBLE);
949+ list->add_dt(proto::DT_FLOAT);
950+ 
951+ std::string json_str;
952+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
953+ 
954+ nlohmann::json j;
955+ ASSERT_NO_THROW(j = nlohmann::json::parse(json_str));
956+ const auto &attr = j["model"]["graph"][0]["op"][0]["attr"]["list_dt"];
957+ EXPECT_EQ(attr["type"], "list_data_type");
958+ EXPECT_EQ(attr["value"].size(), 2U);
959+ EXPECT_EQ(attr["value"][0], proto::DT_DOUBLE);
960+}
961+ 
962+TEST_F(VisualizationTest, SerializeFromModelDef_AttrDefWithUnknownValueCase) {
963+ proto::ModelDef model_def;
964+ auto *graph = model_def.add_graph();
965+ graph->set_name("main_graph");
966+ auto *op = graph->add_op();
967+ op->set_name("unknown_val_op");
968+ op->set_type("UnknownValOp");
969+ 
970+ // Create an AttrDef with no value set (kValueNotSet)
971+ (void)(*op->mutable_attr())["unknown_val"];
972+ 
973+ std::string json_str;
974+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
975+ 
976+ nlohmann::json j;
977+ ASSERT_NO_THROW(j = nlohmann::json::parse(json_str));
978+}
979+ 
980+TEST_F(VisualizationTest, SerializeFromModelDef_ListValueWithEmptyListAndNoValType) {
981+ proto::ModelDef model_def;
982+ auto *graph = model_def.add_graph();
983+ graph->set_name("main_graph");
984+ auto *op = graph->add_op();
985+ op->set_name("empty_no_type_op");
986+ op->set_type("EmptyNoTypeOp");
987+ 
988+ auto *list = (*op->mutable_attr())["empty_no_type"].mutable_list();
989+ // Don't set val_type, don't add any elements
990+ 
991+ std::string json_str;
992+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
993+ 
994+ nlohmann::json j;
995+ ASSERT_NO_THROW(j = nlohmann::json::parse(json_str));
996+ const auto &attr = j["model"]["graph"][0]["op"][0]["attr"]["empty_no_type"];
997+ EXPECT_TRUE(attr.is_object());
998+}
999+ 
1000+TEST_F(VisualizationTest, LoadFromVisualJson_EnumFieldAsStringWithEnumAsStringTrue) {
1001+ const std::string visual_json = R"({
1002+ "format": "ge_visual_json",
1003+ "format_version": 1,
1004+ "model": {
1005+ "name": "enum_model",
1006+ "graph": [{
1007+ "name": "main_graph",
1008+ "op": [{
1009+ "name": "enum_op",
1010+ "type": "EnumOp",
1011+ "input_desc": [{"name": "x", "dtype": "DT_FLOAT"}],
1012+ "output_desc": [{"name": "y", "dtype": "DT_INT32"}]
1013+ }]
1014+ }]
1015+ }
1016+ })";
1017+ 
1018+ nlohmann::json pb_json;
1019+ const std::set<std::string> black_fields;
1020+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, black_fields, pb_json, true), SUCCESS);
1021+ 
1022+ const auto &input_desc = pb_json["graph"][0]["op"][0]["input_desc"][0];
1023+ EXPECT_EQ(input_desc["dtype"], "DT_FLOAT");
1024+ const auto &output_desc = pb_json["graph"][0]["op"][0]["output_desc"][0];
1025+ EXPECT_EQ(output_desc["dtype"], "DT_INT32");
1026+}
1027+ 
1028+TEST_F(VisualizationTest, LoadFromVisualJson_ArrayElementNotObject) {
1029+ const std::string visual_json = R"({
1030+ "format": "ge_visual_json",
1031+ "format_version": 1,
1032+ "model": {
1033+ "name": "array_elem_model",
1034+ "graph": [{
1035+ "name": "main_graph",
1036+ "op": [{
1037+ "name": "array_op",
1038+ "type": "ArrayOp",
1039+ "attr": {
1040+ "list_int_mixed": {"type": "list_int", "value": [1, "not_object", 3]}
1041+ }
1042+ }]
1043+ }]
1044+ }
1045+ })";
1046+ 
1047+ nlohmann::json pb_json;
1048+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, pb_json), SUCCESS);
1049+}
1050+ 
1051+TEST_F(VisualizationTest, LoadFromVisualJson_RepeatedMessageFieldWithNonArray) {
1052+ const std::string visual_json = R"({
1053+ "format": "ge_visual_json",
1054+ "format_version": 1,
1055+ "model": {
1056+ "name": "rep_msg_model",
1057+ "graph": [{
1058+ "name": "main_graph",
1059+ "op": [{
1060+ "name": "rep_msg_op",
1061+ "type": "RepMsgOp",
1062+ "input_desc": "not_an_array"
1063+ }]
1064+ }]
1065+ }
1066+ })";
1067+ 
1068+ nlohmann::json pb_json;
1069+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, pb_json), SUCCESS);
1070+}
1071+ 
1072+TEST_F(VisualizationTest, LoadFromVisualJson_NullAttrValue) {
1073+ const std::string visual_json = R"({
1074+ "format": "ge_visual_json",
1075+ "format_version": 1,
1076+ "model": {
1077+ "name": "null_attr_model",
1078+ "graph": [{
1079+ "name": "main_graph",
1080+ "attr": {
1081+ "null_value": null
1082+ },
1083+ "op": [{
1084+ "name": "null_op",
1085+ "type": "NullOp",
1086+ "attr": {
1087+ "null_attr": null
1088+ }
1089+ }]
1090+ }]
1091+ }
1092+ })";
1093+ 
1094+ nlohmann::json pb_json;
1095+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, pb_json), SUCCESS);
1096+}
1097+ 
1098+TEST_F(VisualizationTest, SerializeFromModelDef_GraphDefWithAttrs) {
1099+ proto::ModelDef model_def;
1100+ model_def.set_name("graph_attr_model");
1101+ auto *graph = model_def.add_graph();
1102+ graph->set_name("main_graph");
1103+ graph->add_input("input:0");
1104+ graph->add_output("output:0");
1105+ 
1106+ auto *graph_attr = graph->mutable_attr();
1107+ (*graph_attr)["graph_str"].set_s("graph_value");
1108+ (*graph_attr)["graph_int"].set_i(42);
1109+ 
1110+ std::string json_str;
1111+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
1112+ 
1113+ nlohmann::json j;
1114+ ASSERT_NO_THROW(j = nlohmann::json::parse(json_str));
1115+ const auto &graph_json = j["model"]["graph"][0];
1116+ EXPECT_EQ(graph_json["attr"]["graph_str"], "graph_value");
1117+ EXPECT_EQ(graph_json["attr"]["graph_int"], 42);
1118+}
1119+ 
1120+TEST_F(VisualizationTest, SerializeFromModelDef_ModelDefWithAttrs) {
1121+ proto::ModelDef model_def;
1122+ model_def.set_name("model_with_attrs");
1123+ model_def.set_version(2);
1124+ model_def.set_custom_version("2.0.0");
1125+ 
1126+ auto *model_attr = model_def.mutable_attr();
1127+ auto *list_attr = (*model_attr)["model_list"].mutable_list();
1128+ list_attr->set_val_type(proto::AttrDef_ListValue_ListValueType_VT_LIST_INT);
1129+ list_attr->add_i(10);
1130+ list_attr->add_i(20);
1131+ 
1132+ std::string json_str;
1133+ ASSERT_EQ(VisualJsonConverter::SerializeFromModelDef(model_def, json_str), SUCCESS);
1134+ 
1135+ nlohmann::json j;
1136+ ASSERT_NO_THROW(j = nlohmann::json::parse(json_str));
1137+ EXPECT_EQ(j["model"]["attr"]["model_list"]["type"], "list_int");
1138+ EXPECT_EQ(j["model"]["attr"]["model_list"]["value"][1], 20);
1139+}
1140+ 
1141+TEST_F(VisualizationTest, LoadFromVisualJson_AttrDefWithBytesAndFunc) {
1142+ const std::string visual_json = R"({
1143+ "format": "ge_visual_json",
1144+ "format_version": 1,
1145+ "model": {
1146+ "name": "bytes_func_model",
1147+ "graph": [{
1148+ "name": "main_graph",
1149+ "op": [{
1150+ "name": "bytes_op",
1151+ "type": "BytesOp",
1152+ "attr": {
1153+ "bytes_attr": {"type": "bytes", "value": "raw_bytes_data"},
1154+ "expr_attr": {"type": "expression", "value": "a * b + c"}
1155+ }
1156+ }]
1157+ }]
1158+ }
1159+ })";
1160+ 
1161+ nlohmann::json pb_json;
1162+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, pb_json), SUCCESS);
1163+ 
1164+ const auto &attrs = pb_json["graph"][0]["op"][0]["attr"];
1165+ ASSERT_TRUE(attrs.is_array());
1166+ EXPECT_EQ(RequireMapValue(attrs, "bytes_attr")["bt"], "raw_bytes_data");
1167+ EXPECT_EQ(RequireMapValue(attrs, "expr_attr")["expression"], "a * b + c");
1168+}
1169+ 
1170+TEST_F(VisualizationTest, LoadFromVisualJson_AttrDefWithTensorDescAndGraph) {
1171+ const std::string visual_json = R"({
1172+ "format": "ge_visual_json",
1173+ "format_version": 1,
1174+ "model": {
1175+ "name": "td_graph_model",
1176+ "graph": [{
1177+ "name": "main_graph",
1178+ "op": [{
1179+ "name": "td_op",
1180+ "type": "TdOp",
1181+ "attr": {
1182+ "td_attr": {"type": "tensor_desc", "value": {"name": "td0", "dtype": "DT_FLOAT", "shape": {"dim": [1, 2]}}},
1183+ "g_attr": {"type": "graph", "value": {"name": "sub_graph", "input": ["in:0"], "output": ["out:0"]}}
1184+ }
1185+ }]
1186+ }]
1187+ }
1188+ })";
1189+ 
1190+ nlohmann::json pb_json;
1191+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, pb_json), SUCCESS);
1192+ 
1193+ const auto &attrs = pb_json["graph"][0]["op"][0]["attr"];
1194+ ASSERT_TRUE(attrs.is_array());
1195+ EXPECT_EQ(RequireMapValue(attrs, "td_attr")["td"]["name"], "td0");
1196+ EXPECT_EQ(RequireMapValue(attrs, "g_attr")["g"]["name"], "sub_graph");
1197+}
1198+ 
1199+TEST_F(VisualizationTest, LoadFromVisualJson_ListValueWithObjectElementsFallback) {
1200+ const std::string visual_json = R"({
1201+ "format": "ge_visual_json",
1202+ "format_version": 1,
1203+ "model": {
1204+ "name": "list_obj_model",
1205+ "graph": [{
1206+ "name": "main_graph",
1207+ "op": [{
1208+ "name": "list_obj_op",
1209+ "type": "ListObjOp",
1210+ "attr": {
1211+ "list_td_fallback": {"type": "list_tensor_desc", "value": [{"name": "td_f0"}, {"name": "td_f1"}]},
1212+ "list_t_fallback": {"type": "list_tensor", "value": [{"desc": {"name": "t_f0"}}, {"desc": {"name": "t_f1"}}]},
1213+ "list_g_fallback": {"type": "list_graph", "value": [{"name": "g_f0"}, {"name": "g_f1"}]},
1214+ "list_na_fallback": {"type": "list_named_attrs", "value": [{"name": "na_f0", "attr": {"k": "v"}}]}
1215+ }
1216+ }]
1217+ }]
1218+ }
1219+ })";
1220+ 
1221+ nlohmann::json pb_json;
1222+ ASSERT_EQ(VisualJsonConverter::LoadFromVisualJson(visual_json, pb_json), SUCCESS);
1223+ 
1224+ const auto &attrs = pb_json["graph"][0]["op"][0]["attr"];
1225+ ASSERT_TRUE(attrs.is_array());
1226+ const auto *list_td = FindMapValue(attrs, "list_td_fallback");
1227+ ASSERT_NE(list_td, nullptr);
1228+ EXPECT_EQ((*list_td)["list"]["val_type"], 6);
1229+ EXPECT_EQ((*list_td)["list"]["td"][0]["name"], "td_f0");
1230+}
1231+ 
915} // namespace1232} // namespace
916} // namespace ge1233} // namespace ge
Mtests/ge/ut/ge/common/zip_archive_unittest.cc+119-0
@@ -439,4 +439,123 @@ TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_RepeatedAddSameFile) {
439 // 解压并校验内容439 // 解压并校验内容
440 CheckExtractedFiles(zipfile_path, {arc_name, arc_name2});440 CheckExtractedFiles(zipfile_path, {arc_name, arc_name2});
441}441}
442+ 
443+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_LargeDataWriteTriggersMemGrow) {
444+ const std::string zipfile_name = kZipFileBaseName + "_grow.zip";
445+ const auto zipfile_path = PathUtils::Join({test_work_dir, zipfile_name});
446+ ZipArchiveWriter zip_writer(zipfile_path);
447+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
448+ 
449+ constexpr size_t kLargeDataSize = 128UL * 1024UL;
450+ std::vector<uint8_t> large_data(kLargeDataSize, 0xAB);
451+ EXPECT_TRUE(zip_writer.WriteBytes("large/data.bin", large_data.data(), large_data.size(), false));
452+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
453+ 
454+ const auto file_buf = ReadFileToVector(zipfile_path);
455+ RAIIZipArchive archive(file_buf.data(), file_buf.size());
456+ ASSERT_TRUE(archive.IsGood());
457+ const auto file_names = archive.ListFiles();
458+ ASSERT_EQ(file_names.size(), 1U);
459+}
460+ 
461+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_CompressedWriteTriggersMemGrow) {
462+ const std::string zipfile_name = kZipFileBaseName + "_compressed_grow.zip";
463+ const auto zipfile_path = PathUtils::Join({test_work_dir, zipfile_name});
464+ ZipArchiveWriter zip_writer(zipfile_path);
465+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
466+ 
467+ std::string compressible_data(200000, 'X');
468+ EXPECT_TRUE(zip_writer.WriteBytes("compressed/data.txt", compressible_data.data(), compressible_data.size(), true));
469+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
470+}
471+ 
472+TEST_F(ZipArchiveUt, TestSimpleZipArchiveReader_Ok_ReadFromArchive) {
473+ const std::string archive_path = PathUtils::Join({test_work_dir, "__reader_test.zip"});
474+ const std::vector<std::pair<std::string, std::string>> entries = {
475+ {"dir/file1.txt", "content1"},
476+ {"dir/file2.txt", "content2_content2"},
477+ };
478+ CreateTestZipArchive(archive_path, entries);
479+ 
480+ const auto file_buf = ReadFileToVector(archive_path);
481+ SimpleZipArchiveReader reader(file_buf.data(), file_buf.size());
482+ ASSERT_TRUE(reader.IsGood());
483+ 
484+ const auto file_names = reader.ListFiles();
485+ ASSERT_EQ(file_names.size(), 2U);
486+ 
487+ size_t extracted_size = 0U;
488+ const auto extracted = reader.ExtractToMem("dir/file2.txt", extracted_size);
489+ ASSERT_NE(extracted, nullptr);
490+ EXPECT_EQ(extracted_size, entries[1].second.size());
491+ EXPECT_EQ(std::memcmp(extracted.get(), entries[1].second.data(), extracted_size), 0);
492+}
493+ 
494+TEST_F(ZipArchiveUt, TestSimpleZipArchiveReader_Fail_ExtractNonExistentEntry) {
495+ const std::string archive_path = PathUtils::Join({test_work_dir, "__non_existent.zip"});
496+ const std::vector<std::pair<std::string, std::string>> entries = {{"file.txt", "data"}};
497+ CreateTestZipArchive(archive_path, entries);
498+ 
499+ const auto file_buf = ReadFileToVector(archive_path);
500+ SimpleZipArchiveReader reader(file_buf.data(), file_buf.size());
501+ ASSERT_TRUE(reader.IsGood());
502+ 
503+ size_t extracted_size = 0U;
504+ const auto extracted = reader.ExtractToMem("non_existent.txt", extracted_size);
505+ EXPECT_EQ(extracted, nullptr);
506+}
507+ 
508+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_MultipleFilesWithDifferentCompression) {
509+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "mixed_compression.zip"});
510+ ZipArchiveWriter zip_writer(zipfile_path);
511+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
512+ 
513+ const std::string uncompressed_data = "uncompressed_data_12345";
514+ EXPECT_TRUE(zip_writer.WriteBytes("raw/data.bin", uncompressed_data.data(), uncompressed_data.size(), false));
515+ 
516+ const std::string compressed_data(10000, 'Z');
517+ EXPECT_TRUE(zip_writer.WriteBytes("compressed/data.bin", compressed_data.data(), compressed_data.size(), true));
518+ 
519+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
520+ 
521+ const auto file_buf = ReadFileToVector(zipfile_path);
522+ RAIIZipArchive archive(file_buf.data(), file_buf.size());
523+ ASSERT_TRUE(archive.IsGood());
524+ const auto file_names = archive.ListFiles();
525+ ASSERT_EQ(file_names.size(), 2U);
526+}
527+ 
528+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Fail_WriteFileAfterClose) {
529+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "closed_writer.zip"});
530+ ZipArchiveWriter zip_writer(zipfile_path);
531+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
532+ ASSERT_TRUE(zip_writer.SaveModelDataToFile());
533+ ASSERT_FALSE(zip_writer.IsMemFileOpened());
534+ 
535+ const std::string data = "test_data";
536+ EXPECT_FALSE(zip_writer.WriteBytes("test.txt", data.data(), data.size()));
537+}
538+ 
539+TEST_F(ZipArchiveUt, TestZipArchiveWriter_Ok_SaveModelDataToBufferWithLargeData) {
540+ const std::string zipfile_path = PathUtils::Join({test_work_dir, "buffer_large.zip"});
541+ ModelBufferData model;
542+ 
543+ {
544+ ZipArchiveWriter zip_writer(zipfile_path);
545+ ASSERT_TRUE(zip_writer.IsMemFileOpened());
546+ 
547+ constexpr size_t kDataSize = 256UL * 1024UL;
548+ std::vector<uint8_t> data(kDataSize, 0xCD);
549+ EXPECT_TRUE(zip_writer.WriteBytes("large.bin", data.data(), data.size(), false));
550+ ASSERT_TRUE(zip_writer.SaveModelData(model, false));
551+ }
552+ 
553+ ASSERT_NE(model.data, nullptr);
554+ ASSERT_GT(model.length, 0U);
555+ 
556+ RAIIZipArchive archive(model.data.get(), model.length);
557+ ASSERT_TRUE(archive.IsGood());
558+ const auto file_names = archive.ListFiles();
559+ ASSERT_EQ(file_names.size(), 1U);
560+}
442} // namespace ge561} // namespace ge
Mtests/ge/ut/ge/graph/bin_cache/node_compile_cache_module_unittest.cc+112-0
@@ -427,3 +427,115 @@ TEST_F(UtestCcm, testGetCompileCacheDescNotFound) {
427 NodeCompileCacheModule ccm;427 NodeCompileCacheModule ccm;
428 ASSERT_EQ(ccm.GetCompileCacheDesc(node), nullptr);428 ASSERT_EQ(ccm.GetCompileCacheDesc(node), nullptr);
429}429}
430+ 
431+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_ListListInt) {
432+ std::vector<std::vector<int64_t>> val = {{1, 2}, {3, 4, 5}};
433+ auto any_value = ge::GeAttrValue::CreateFrom<std::vector<std::vector<int64_t>>>(val);
434+ NodeCompileCacheModule ccm;
435+ uint8_t buffer[1024] = {0};
436+ size_t offset = 0;
437+ ASSERT_EQ(ccm.CopyAttrValues(any_value, buffer, sizeof(buffer), offset), SUCCESS);
438+ ASSERT_EQ(offset, sizeof(int64_t) * 5U);
439+}
440+ 
441+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_Int_SmallBuffer) {
442+ int64_t val = 42;
443+ auto any_value = ge::GeAttrValue::CreateFrom<int64_t>(val);
444+ NodeCompileCacheModule ccm;
445+ uint8_t buffer[1] = {0};
446+ size_t offset = 0;
447+ ASSERT_EQ(ccm.CopyAttrValues(any_value, buffer, sizeof(buffer), offset), FAILED);
448+}
449+ 
450+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_String_SmallBuffer) {
451+ std::string val = "hello";
452+ auto any_value = ge::GeAttrValue::CreateFrom<std::string>(val);
453+ NodeCompileCacheModule ccm;
454+ uint8_t buffer[2] = {0};
455+ size_t offset = 0;
456+ ASSERT_EQ(ccm.CopyAttrValues(any_value, buffer, sizeof(buffer), offset), FAILED);
457+}
458+ 
459+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_ListInt_SmallBuffer) {
460+ std::vector<int64_t> val = {1, 2, 3};
461+ auto any_value = ge::GeAttrValue::CreateFrom<std::vector<int64_t>>(val);
462+ NodeCompileCacheModule ccm;
463+ uint8_t buffer[1] = {0};
464+ size_t offset = 0;
465+ ASSERT_EQ(ccm.CopyAttrValues(any_value, buffer, sizeof(buffer), offset), FAILED);
466+}
467+ 
468+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_ListString_WithEmpty) {
469+ std::vector<std::string> val = {"", "ab", ""};
470+ auto any_value = ge::GeAttrValue::CreateFrom<std::vector<std::string>>(val);
471+ NodeCompileCacheModule ccm;
472+ uint8_t buffer[1024] = {0};
473+ size_t offset = 0;
474+ ASSERT_EQ(ccm.CopyAttrValues(any_value, buffer, sizeof(buffer), offset), SUCCESS);
475+ ASSERT_EQ(offset, 2U);
476+}
477+ 
478+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_ListString_SmallBuffer) {
479+ std::vector<std::string> val = {"abc"};
480+ auto any_value = ge::GeAttrValue::CreateFrom<std::vector<std::string>>(val);
481+ NodeCompileCacheModule ccm;
482+ uint8_t buffer[1] = {0};
483+ size_t offset = 0;
484+ ASSERT_EQ(ccm.CopyAttrValues(any_value, buffer, sizeof(buffer), offset), FAILED);
485+}
486+ 
487+TEST_F(UtestCcm, CopyAttrValues_CovEnhance_AllTypes_Success) {
488+ NodeCompileCacheModule ccm;
489+ uint8_t buffer[1024] = {0};
490+ size_t offset = 0;
491+ bool bool_val = true;
492+ ASSERT_EQ(ccm.CopyAttrValues(ge::GeAttrValue::CreateFrom<bool>(bool_val), buffer, sizeof(buffer), offset), SUCCESS);
493+ float float_val = 1.0f;
494+ ASSERT_EQ(ccm.CopyAttrValues(ge::GeAttrValue::CreateFrom<float>(float_val), buffer, sizeof(buffer), offset), SUCCESS);
495+ DataType dt_val = DT_FLOAT;
496+ ASSERT_EQ(ccm.CopyAttrValues(ge::GeAttrValue::CreateFrom<DataType>(dt_val), buffer, sizeof(buffer), offset), SUCCESS);
497+ std::vector<bool> list_bool = {true, false};
498+ ASSERT_EQ(
499+ ccm.CopyAttrValues(ge::GeAttrValue::CreateFrom<std::vector<bool>>(list_bool), buffer, sizeof(buffer), offset),
500+ SUCCESS);
501+ std::vector<float> list_float = {1.0f, 2.0f};
502+ ASSERT_EQ(
503+ ccm.CopyAttrValues(ge::GeAttrValue::CreateFrom<std::vector<float>>(list_float), buffer, sizeof(buffer), offset),
504+ SUCCESS);
505+ std::vector<DataType> list_dt = {DT_FLOAT, DT_INT8};
506+ ASSERT_EQ(
507+ ccm.CopyAttrValues(ge::GeAttrValue::CreateFrom<std::vector<DataType>>(list_dt), buffer, sizeof(buffer), offset),
508+ SUCCESS);
509+}
510+ 
511+TEST_F(UtestCcm, CopyAttrToMem_CovEnhance_NameMemcpyFail) {
512+ std::map<std::string, ge::AnyValue> all_attributes;
513+ int64_t val = 0;
514+ all_attributes["test_attr"] = ge::GeAttrValue::CreateFrom<int64_t>(val);
515+ std::set<string> ordered_origin_attr_name = {"test_attr"};
516+ size_t attr_size = 2U;
517+ auto attr_mem = std::unique_ptr<uint8_t[]>(new uint8_t[attr_size]);
518+ NodeCompileCacheModule ccm;
519+ ASSERT_EQ(ccm.CopyAttrToMem(all_attributes, attr_mem, ordered_origin_attr_name, attr_size), FAILED);
520+}
521+ 
522+TEST_F(UtestCcm, CopyAttrToMem_CovEnhance_CopyAttrFail) {
523+ std::map<std::string, ge::AnyValue> all_attributes;
524+ int64_t val = 0;
525+ all_attributes["ab"] = ge::GeAttrValue::CreateFrom<int64_t>(val);
526+ std::set<string> ordered_origin_attr_name = {"ab"};
527+ size_t attr_size = 4U;
528+ auto attr_mem = std::unique_ptr<uint8_t[]>(new uint8_t[attr_size]);
529+ NodeCompileCacheModule ccm;
530+ ASSERT_EQ(ccm.CopyAttrToMem(all_attributes, attr_mem, ordered_origin_attr_name, attr_size), FAILED);
531+}
532+ 
533+TEST_F(UtestCcm, FindAddCompileCache_CovEnhance_UnregisteredOp) {
534+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
535+ auto node = builder.AddNode("UnknownOp", "UnknownOpType123", 1, 1);
536+ ASSERT_NE(node, nullptr);
537+ NodeCompileCacheModule ccm;
538+ ASSERT_EQ(ccm.FindCompileCache(node), nullptr);
539+ NodeCompileCacheItem item;
540+ ASSERT_EQ(ccm.AddCompileCache(node, item), nullptr);
541+}
Mtests/ge/ut/ge/graph/build/var_mem_assign_util_unittest.cc+164-0
@@ -105,3 +105,167 @@ TEST_F(UtestVarMemAssignUtil, GetNameForVarManager_EmptySrcConstName) {
105 ge::AttrUtils::SetStr(op_desc, ge::ATTR_NAME_SRC_CONST_NAME, "");105 ge::AttrUtils::SetStr(op_desc, ge::ATTR_NAME_SRC_CONST_NAME, "");
106 ASSERT_EQ(ge::VarMemAssignUtil::GetNameForVarManager(op_desc), "test_name");106 ASSERT_EQ(ge::VarMemAssignUtil::GetNameForVarManager(op_desc), "test_name");
107}107}
108+ 
109+TEST_F(UtestVarMemAssignUtil, AssignVarMemory_CovEnhance_RdmaHbm) {
110+ auto graph = gert::ShareGraph::SimpleVariableGraph();
111+ graph->SetSessionID(202311132103);
112+ auto variable = graph->FindFirstNodeMatchType("Variable");
113+ ASSERT_NE(variable, nullptr);
114+ ge::AttrUtils::SetInt(variable->GetOpDesc(), ge::ATTR_OUTPUT_MEMORY_TYPE, 1U);
115+ VarManager::Instance(graph->GetSessionID())->Init(0, graph->GetSessionID(), 0, 0);
116+ ASSERT_NE(ge::VarMemAssignUtil::AssignVarMemory(graph), ge::SUCCESS);
117+ VarManager::Instance(graph->GetSessionID())->Destroy();
118+}
119+ 
120+TEST_F(UtestVarMemAssignUtil, AssignData2Fp32Var_CovEnhance_WithSrcVarName) {
121+ uint64_t session_id = 202311132107;
122+ auto op_desc = std::make_shared<ge::OpDesc>("test_var", "Variable");
123+ op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
124+ ge::AttrUtils::SetStr(op_desc, ge::VAR_ATTR_SRC_VAR_NAME, "src_var");
125+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
126+ auto node = graph->AddNode(op_desc);
127+ 
128+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
129+ GeTensorDesc src_tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
130+ TensorUtils::SetSize(src_tensor_desc, 16);
131+ VarManager::Instance(session_id)->AssignVarMem("src_var", nullptr, src_tensor_desc, RT_MEMORY_HBM);
132+ 
133+ ASSERT_EQ(ge::VarMemAssignUtil::AssignData2Fp32Var(node, session_id), ge::SUCCESS);
134+ VarManager::Instance(session_id)->Destroy();
135+}
136+ 
137+TEST_F(UtestVarMemAssignUtil, SetOutVariableAttr_CovEnhance_EmptyOutputList) {
138+ uint64_t session_id = 202311132108;
139+ auto op_desc = std::make_shared<ge::OpDesc>("test_node", "Assign");
140+ op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
141+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
142+ auto node = graph->AddNode(op_desc);
143+ auto var_op_desc = std::make_shared<ge::OpDesc>("var_node", "Variable");
144+ var_op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
145+ auto var_node = graph->AddNode(var_op_desc);
146+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
147+ ASSERT_EQ(ge::VarMemAssignUtil::SetOutVariableAttr(node, var_node, 0, session_id), ge::PARAM_INVALID);
148+ VarManager::Instance(session_id)->Destroy();
149+}
150+ 
151+TEST_F(UtestVarMemAssignUtil, SetOutVariableAttr_CovEnhance_IndexOutOfBounds) {
152+ uint64_t session_id = 202311132109;
153+ auto op_desc = std::make_shared<ge::OpDesc>("test_node", "Assign");
154+ op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
155+ op_desc->SetOutputOffset({100});
156+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
157+ auto node = graph->AddNode(op_desc);
158+ auto var_op_desc = std::make_shared<ge::OpDesc>("var_node", "Variable");
159+ GeTensorDesc var_tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
160+ TensorUtils::SetSize(var_tensor_desc, 16);
161+ var_op_desc->AddOutputDesc(var_tensor_desc);
162+ auto var_node = graph->AddNode(var_op_desc);
163+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
164+ VarManager::Instance(session_id)->AssignVarMem("var_node", var_op_desc, var_tensor_desc, RT_MEMORY_HBM);
165+ ASSERT_EQ(ge::VarMemAssignUtil::SetOutVariableAttr(node, var_node, 5, session_id), ge::FAILED);
166+ VarManager::Instance(session_id)->Destroy();
167+}
168+ 
169+TEST_F(UtestVarMemAssignUtil, AssignData2VarRef_CovEnhance_RefData) {
170+ uint64_t session_id = 202311132110;
171+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
172+ graph->SetSessionID(session_id);
173+ auto refdata_op_desc = std::make_shared<ge::OpDesc>("refdata_node", "RefData");
174+ refdata_op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
175+ auto refdata_node = graph->AddNode(refdata_op_desc);
176+ auto has_ref_op_desc = std::make_shared<ge::OpDesc>("has_ref_node", "Assign");
177+ has_ref_op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
178+ has_ref_op_desc->SetOutputOffset({200});
179+ auto has_ref_node = graph->AddNode(has_ref_op_desc);
180+ ge::GraphToNodeMap graph_to_node;
181+ ASSERT_EQ(ge::VarMemAssignUtil::AssignData2VarRef(has_ref_node, "refdata_node", session_id, 0, graph_to_node),
182+ ge::SUCCESS);
183+}
184+ 
185+TEST_F(UtestVarMemAssignUtil, DealBroadCastNode_CovEnhance_BasicFlow) {
186+ uint64_t session_id = 202311132111;
187+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
188+ graph->SetSessionID(session_id);
189+ graph->SetGraphID(0);
190+ auto var_op_desc = std::make_shared<ge::OpDesc>("var_node", "Variable");
191+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
192+ TensorUtils::SetSize(tensor_desc, 16);
193+ var_op_desc->AddOutputDesc(tensor_desc);
194+ var_op_desc->SetOutputOffset({100});
195+ auto var_node = graph->AddNode(var_op_desc);
196+ auto bc_op_desc = std::make_shared<ge::OpDesc>("bc_node", "HcomBroadcast");
197+ GeTensorDesc bc_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
198+ TensorUtils::SetSize(bc_desc, 16);
199+ bc_op_desc->AddInputDesc("input", bc_desc);
200+ bc_op_desc->AddOutputDesc("output", bc_desc);
201+ bc_op_desc->SetOutputOffset({200});
202+ auto bc_node = graph->AddNode(bc_op_desc);
203+ EXPECT_EQ(var_node->GetOutDataAnchor(0)->LinkTo(bc_node->GetInDataAnchor(0)), GRAPH_SUCCESS);
204+ auto in_data_anchor = bc_node->GetInDataAnchor(0);
205+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
206+ VarManager::Instance(session_id)->AssignVarMem("var_node", var_op_desc, tensor_desc, RT_MEMORY_HBM);
207+ ASSERT_EQ(ge::VarMemAssignUtil::DealBroadCastNode(0, bc_node, in_data_anchor, var_node, session_id), ge::SUCCESS);
208+ VarManager::Instance(session_id)->Destroy();
209+}
210+ 
211+TEST_F(UtestVarMemAssignUtil, DealVariableNode_CovEnhance_WithBroadCast) {
212+ uint64_t session_id = 202311132112;
213+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
214+ graph->SetSessionID(session_id);
215+ graph->SetGraphID(0);
216+ auto var_op_desc = std::make_shared<ge::OpDesc>("var_node2", "Variable");
217+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
218+ TensorUtils::SetSize(tensor_desc, 16);
219+ var_op_desc->AddOutputDesc(tensor_desc);
220+ var_op_desc->SetOutputOffset({100});
221+ auto var_node = graph->AddNode(var_op_desc);
222+ auto bc_op_desc = std::make_shared<ge::OpDesc>("bc_node2", "HcomBroadcast");
223+ GeTensorDesc bc_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
224+ TensorUtils::SetSize(bc_desc, 16);
225+ bc_op_desc->AddInputDesc("input", bc_desc);
226+ bc_op_desc->AddOutputDesc("output", bc_desc);
227+ bc_op_desc->SetOutputOffset({200});
228+ auto bc_node = graph->AddNode(bc_op_desc);
229+ EXPECT_EQ(var_node->GetOutDataAnchor(0)->LinkTo(bc_node->GetInDataAnchor(0)), GRAPH_SUCCESS);
230+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
231+ VarManager::Instance(session_id)->AssignVarMem("var_node2", var_op_desc, tensor_desc, RT_MEMORY_HBM);
232+ ASSERT_EQ(ge::VarMemAssignUtil::DealVariableNode(0, var_node, session_id), ge::SUCCESS);
233+ VarManager::Instance(session_id)->Destroy();
234+}
235+ 
236+TEST_F(UtestVarMemAssignUtil, DealExportVariableNode_CovEnhance_RecursionLimit) {
237+ uint64_t session_id = 202311132113;
238+ auto op_desc = std::make_shared<ge::OpDesc>("assign_node", "Assign");
239+ op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
240+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
241+ auto node = graph->AddNode(op_desc);
242+ auto var_op_desc = std::make_shared<ge::OpDesc>("var_node3", "Variable");
243+ var_op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
244+ auto var_node = graph->AddNode(var_op_desc);
245+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
246+ ASSERT_EQ(ge::VarMemAssignUtil::DealExportVariableNode(node, var_node, session_id, 16U), ge::FAILED);
247+ VarManager::Instance(session_id)->Destroy();
248+}
249+ 
250+TEST_F(UtestVarMemAssignUtil, GetFinalTransNode_CovEnhance_RecursionLimit) {
251+ auto op_desc = std::make_shared<ge::OpDesc>("trans_node", "TransData");
252+ op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
253+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
254+ auto node = graph->AddNode(op_desc);
255+ auto result = ge::VarMemAssignUtil::GetFinalTransNode(node, 16U);
256+ EXPECT_EQ(result, node);
257+}
258+ 
259+TEST_F(UtestVarMemAssignUtil, DealExportTransNode_CovEnhance_RecursionLimit) {
260+ uint64_t session_id = 202311132114;
261+ auto op_desc = std::make_shared<ge::OpDesc>("assign_node2", "Assign");
262+ op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
263+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_graph");
264+ auto node = graph->AddNode(op_desc);
265+ auto trans_op_desc = std::make_shared<ge::OpDesc>("trans_node2", "TransData");
266+ trans_op_desc->AddOutputDesc("output", GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
267+ auto trans_node = graph->AddNode(trans_op_desc);
268+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
269+ ASSERT_EQ(ge::VarMemAssignUtil::DealExportTransNode(node, trans_node, 16U), ge::FAILED);
270+ VarManager::Instance(session_id)->Destroy();
271+}
Mtests/ge/ut/ge/graph/load/model_helper_unittest.cc+141-0
@@ -3010,4 +3010,145 @@ TEST_F(UtestModelHelper, ConfigureAttrCompressionMode) {
3010 EXPECT_EQ(model_helper.ConfigureAttrCompressionMode(""), PARAM_INVALID);3010 EXPECT_EQ(model_helper.ConfigureAttrCompressionMode(""), PARAM_INVALID);
3011}3011}
3012 3012 
3013+TEST_F(UtestModelHelper, SaveToOmModel_WithNullGeModel_ReturnsFailed) {
3014+ ModelHelper model_helper;
3015+ ModelBufferData model;
3016+ EXPECT_NE(model_helper.SaveToOmModel(nullptr, "output.om", model), SUCCESS);
3017+}
3018+ 
3019+TEST_F(UtestModelHelper, SaveToOmRootModel_WithNullRootModel_ReturnsFailed) {
3020+ ModelHelper model_helper;
3021+ ModelBufferData model;
3022+ EXPECT_NE(model_helper.SaveToOmRootModel(nullptr, "output.om", model, false), SUCCESS);
3023+}
3024+ 
3025+TEST_F(UtestModelHelper, SaveToOmRootModel_WithEmptyOutputFile_ReturnsFailed) {
3026+ ModelHelper model_helper;
3027+ GeRootModelPtr ge_root_model = ConstructGeRootModel(false);
3028+ ASSERT_NE(ge_root_model, nullptr);
3029+ ModelBufferData model;
3030+ EXPECT_NE(model_helper.SaveToOmRootModel(ge_root_model, "", model, false), SUCCESS);
3031+}
3032+ 
3033+TEST_F(UtestModelHelper, SaveModelTaskDef_WithNullModelTaskDef_ReturnsFailed) {
3034+ ModelHelper model_helper;
3035+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3036+ GeModelPtr ge_model = std::make_shared<GeModel>();
3037+ ge::Buffer task_buffer;
3038+ EXPECT_NE(model_helper.SaveModelTaskDef(om_file_save_helper, ge_model, task_buffer, 0U), SUCCESS);
3039+}
3040+ 
3041+TEST_F(UtestModelHelper, SaveModelTaskDef_WithEmptyTaskDef_ReturnsFailed) {
3042+ ModelHelper model_helper;
3043+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3044+ GeModelPtr ge_model = std::make_shared<GeModel>();
3045+ auto task_def = std::make_shared<domi::ModelTaskDef>();
3046+ ge_model->SetModelTaskDef(task_def);
3047+ ge::Buffer task_buffer;
3048+ EXPECT_EQ(model_helper.SaveModelTaskDef(om_file_save_helper, ge_model, task_buffer, 0U), FAILED);
3049+}
3050+ 
3051+TEST_F(UtestModelHelper, SaveModelWeights_WithWeightData_ReturnsSuccess) {
3052+ ModelHelper model_helper;
3053+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3054+ GeModelPtr ge_model = std::make_shared<GeModel>();
3055+ std::vector<uint8_t> weight_data(100, 1U);
3056+ ge_model->SetWeight(ge::Buffer::CopyFrom(weight_data.data(), weight_data.size()));
3057+ EXPECT_EQ(model_helper.SaveModelWeights(om_file_save_helper, ge_model, 0U), SUCCESS);
3058+}
3059+ 
3060+TEST_F(UtestModelHelper, SaveModelTbeKernel_WithKernelStore_ReturnsSuccess) {
3061+ ModelHelper model_helper;
3062+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3063+ GeModelPtr ge_model = std::make_shared<GeModel>();
3064+ ge::TBEKernelStore tbe_kernel_store;
3065+ const auto kernel = ge::MakeShared<ge::OpKernelBin>("test_kernel", std::vector<char>(10, 'a'));
3066+ tbe_kernel_store.AddTBEKernel(kernel);
3067+ ge_model->SetTBEKernelStore(tbe_kernel_store);
3068+ EXPECT_EQ(model_helper.SaveModelTbeKernel(om_file_save_helper, ge_model, 0U), SUCCESS);
3069+}
3070+ 
3071+TEST_F(UtestModelHelper, SaveModelCustAICPU_WithKernelStore_ReturnsSuccess) {
3072+ ModelHelper model_helper;
3073+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3074+ GeModelPtr ge_model = std::make_shared<GeModel>();
3075+ EXPECT_EQ(model_helper.SaveModelCustAICPU(om_file_save_helper, ge_model, 0U), SUCCESS);
3076+}
3077+ 
3078+TEST_F(UtestModelHelper, SaveModelHeader_WithValidModel_ReturnsSuccess) {
3079+ ModelHelper model_helper;
3080+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3081+ GeModelPtr ge_model = std::make_shared<GeModel>();
3082+ ge_model->SetName("test_model");
3083+ ge_model->SetPlatformVersion("1.0");
3084+ EXPECT_EQ(model_helper.SaveModelHeader(om_file_save_helper, ge_model, 1U, false, false), SUCCESS);
3085+}
3086+ 
3087+TEST_F(UtestModelHelper, SaveModelHeader_WithNeedCheckOsCpu_ReturnsSuccess) {
3088+ ModelHelper model_helper;
3089+ std::shared_ptr<OmFileSaveHelper> om_file_save_helper = std::make_shared<OmFileSaveHelper>();
3090+ GeModelPtr ge_model = std::make_shared<GeModel>();
3091+ ge_model->SetName("test_model");
3092+ ge_model->SetPlatformVersion("1.0");
3093+ EXPECT_EQ(model_helper.SaveModelHeader(om_file_save_helper, ge_model, 1U, true, false), SUCCESS);
3094+}
3095+ 
3096+TEST_F(UtestModelHelper, SetModelAttributes_ReturnsSuccess) {
3097+ ModelHelper model_helper;
3098+ GeModelPtr ge_model = std::make_shared<GeModel>();
3099+ EXPECT_EQ(model_helper.SetModelAttributes(ge_model), SUCCESS);
3100+}
3101+ 
3102+TEST_F(UtestModelHelper, LoadModel_WithInvalidData_ReturnsFailed) {
3103+ ModelHelper model_helper;
3104+ ModelData model_data;
3105+ model_data.model_data = nullptr;
3106+ model_data.model_len = 0U;
3107+ EXPECT_NE(model_helper.LoadModel(model_data), SUCCESS);
3108+}
3109+ 
3110+TEST_F(UtestModelHelper, LoadModel_WithSmallData_ReturnsFailed) {
3111+ ModelHelper model_helper;
3112+ std::vector<uint8_t> small_data(10, 0);
3113+ ModelData model_data;
3114+ model_data.model_data = small_data.data();
3115+ model_data.model_len = small_data.size();
3116+ EXPECT_NE(model_helper.LoadModel(model_data), SUCCESS);
3117+}
3118+ 
3119+TEST_F(UtestModelHelper, LoadRootModel_WithInvalidData_ReturnsFailed) {
3120+ ModelHelper model_helper;
3121+ ModelData model_data;
3122+ model_data.model_data = nullptr;
3123+ model_data.model_len = 0U;
3124+ EXPECT_NE(model_helper.LoadRootModel(model_data), SUCCESS);
3125+}
3126+ 
3127+TEST_F(UtestModelHelper, GetBaseNameFromFileName_NoExtension) {
3128+ ModelHelper model_helper;
3129+ std::string base_name;
3130+ EXPECT_EQ(model_helper.GetBaseNameFromFileName("model_no_ext", base_name), SUCCESS);
3131+ EXPECT_EQ(base_name, "model_no_ext");
3132+}
3133+ 
3134+TEST_F(UtestModelHelper, SaveOriginalGraphToOmModel_WithEmptyGraph_ReturnsFailed) {
3135+ ModelHelper model_helper;
3136+ Graph graph("");
3137+ EXPECT_EQ(model_helper.SaveOriginalGraphToOmModel(graph, ""), FAILED);
3138+ EXPECT_EQ(model_helper.SaveOriginalGraphToOmModel(graph, "output.om"), FAILED);
3139+}
3140+ 
3141+TEST_F(UtestModelHelper, SaveBundleModelBufferToMem_WithEmptyBuffers_ReturnsSuccess) {
3142+ std::vector<ModelBufferData> model_buffers;
3143+ const uint64_t var_size = 0U;
3144+ ModelBufferData output;
3145+ EXPECT_EQ(ModelHelper::SaveBundleModelBufferToMem(model_buffers, var_size, output), SUCCESS);
3146+}
3147+ 
3148+TEST_F(UtestModelHelper, SetSaveMode_Test) {
3149+ ModelHelper model_helper;
3150+ model_helper.SetSaveMode(true);
3151+ model_helper.SetSaveMode(false);
3152+}
3153+ 
3013} // namespace ge3154} // namespace ge
Mtests/ge/ut/ge/graph/load/om2_package_helper_unittest.cc+238-0
@@ -2153,4 +2153,242 @@ TEST_F(Om2PackageHelperUt, SaveModelInfo_MissingAippAttr_Skipped) {
2153 ASSERT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);2153 ASSERT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2154}2154}
2155 2155 
2156+TEST_F(Om2PackageHelperUt, SaveToOmRootModel_UnknownShape_ReturnsFailed) {
2157+ Om2PackageHelper om2_packager;
2158+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2159+ ASSERT_NE(ge_root_model, nullptr);
2160+ ModelBufferData model_data;
2161+ const std::string output_file = PathUtils::Join({test_work_dir, "test_unknown_shape.om2"});
2162+ EXPECT_NE(om2_packager.SaveToOmRootModel(ge_root_model, output_file, model_data, true), SUCCESS);
2163+}
2164+ 
2165+TEST_F(Om2PackageHelperUt, SaveToOmRootModel_NullRootModel_ReturnsFailed) {
2166+ Om2PackageHelper om2_packager;
2167+ ModelBufferData model_data;
2168+ const std::string output_file = PathUtils::Join({test_work_dir, "test_null_root.om2"});
2169+ EXPECT_NE(om2_packager.SaveToOmRootModel(nullptr, output_file, model_data, false), SUCCESS);
2170+}
2171+ 
2172+TEST_F(Om2PackageHelperUt, SaveToOmRootModel_EmptyOutputFile_ReturnsFailed) {
2173+ Om2PackageHelper om2_packager;
2174+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2175+ ASSERT_NE(ge_root_model, nullptr);
2176+ ModelBufferData model_data;
2177+ EXPECT_NE(om2_packager.SaveToOmRootModel(ge_root_model, "", model_data, false), SUCCESS);
2178+}
2179+ 
2180+TEST_F(Om2PackageHelperUt, SaveToOmRootModel_EmptySubModels_ReturnsFailed) {
2181+ Om2PackageHelper om2_packager;
2182+ auto root_graph = std::make_shared<ComputeGraph>("empty_root");
2183+ auto ge_root_model = std::make_shared<GeRootModel>();
2184+ ASSERT_EQ(ge_root_model->Initialize(root_graph), SUCCESS);
2185+ ModelBufferData model_data;
2186+ const std::string output_file = PathUtils::Join({test_work_dir, "test_empty_sub.om2"});
2187+ EXPECT_NE(om2_packager.SaveToOmRootModel(ge_root_model, output_file, model_data, false), SUCCESS);
2188+}
2189+ 
2190+TEST_F(Om2PackageHelperUt, SaveManifest_Ok_WritesManifestJson) {
2191+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2192+ ASSERT_NE(ge_root_model, nullptr);
2193+ 
2194+ const std::string output_file = PathUtils::Join({test_work_dir, "test_manifest.om2"});
2195+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2196+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2197+ 
2198+ ASSERT_EQ(Om2PackageHelper::SaveManifest(zip_writer, ge_root_model), SUCCESS);
2199+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2200+ 
2201+ uint32_t model_buf_size = 0;
2202+ const auto model_buf = GetBinDataFromFile(output_file, model_buf_size);
2203+ SimpleZipArchiveReader archive(reinterpret_cast<const uint8_t *>(model_buf.get()), model_buf_size);
2204+ ASSERT_TRUE(archive.IsGood());
2205+ 
2206+ size_t manifest_size = 0;
2207+ const auto manifest_buf = archive.ExtractToMem("test_manifest/manifest.json", manifest_size);
2208+ ASSERT_NE(manifest_buf, nullptr);
2209+ const JsonFile manifest_json(reinterpret_cast<const uint8_t *>(manifest_buf.get()), manifest_size);
2210+ ASSERT_TRUE(manifest_json.IsValid());
2211+ std::string om2_version;
2212+ ASSERT_TRUE(manifest_json.Get("om2_version", om2_version));
2213+ EXPECT_EQ(om2_version, "0");
2214+}
2215+ 
2216+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithSpecialInputSize_WritesSpecialSize) {
2217+ auto ge_model = CreateGeModelWithCaseOp();
2218+ ASSERT_NE(ge_model, nullptr);
2219+ auto graph = ge_model->GetGraph();
2220+ ASSERT_NE(graph, nullptr);
2221+ 
2222+ auto data_node = graph->FindNode("data1");
2223+ ASSERT_NE(data_node, nullptr);
2224+ auto data_desc = data_node->GetOpDesc();
2225+ ASSERT_NE(data_desc, nullptr);
2226+ auto output_desc = data_desc->MutableOutputDesc(0U);
2227+ ASSERT_NE(output_desc, nullptr);
2228+ AttrUtils::SetInt(*output_desc, ATTR_NAME_SPECIAL_INPUT_SIZE, 1024);
2229+ 
2230+ AttrUtils::SetListInt(data_desc, ATTR_NAME_INPUT_DIMS, {1, 2, 3});
2231+ 
2232+ const std::string output_file = PathUtils::Join({test_work_dir, "test_special_input.om2"});
2233+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2234+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2235+ 
2236+ ASSERT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2237+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2238+}
2239+ 
2240+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithSpecialOutputSize_WritesSpecialSize) {
2241+ auto ge_model = CreateGeModelWithCaseOp();
2242+ ASSERT_NE(ge_model, nullptr);
2243+ auto graph = ge_model->GetGraph();
2244+ ASSERT_NE(graph, nullptr);
2245+ 
2246+ auto netoutput_node = graph->FindNode("NetOutput");
2247+ ASSERT_NE(netoutput_node, nullptr);
2248+ auto netoutput_desc = netoutput_node->GetOpDesc();
2249+ ASSERT_NE(netoutput_desc, nullptr);
2250+ 
2251+ auto input_desc = netoutput_desc->MutableInputDesc(0U);
2252+ ASSERT_NE(input_desc, nullptr);
2253+ AttrUtils::SetInt(*input_desc, ATTR_NAME_SPECIAL_OUTPUT_SIZE, 2048);
2254+ 
2255+ std::vector<std::string> out_node_names = {"case1:0"};
2256+ AttrUtils::SetListStr(ge_model, ATTR_MODEL_OUT_NODES_NAME, out_node_names);
2257+ 
2258+ const std::string output_file = PathUtils::Join({test_work_dir, "test_special_output.om2"});
2259+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2260+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2261+ 
2262+ ASSERT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2263+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2264+}
2265+ 
2266+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithDynamicOutputDims_WritesShapeInfo) {
2267+ auto ge_model = CreateGeModelWithCaseOp();
2268+ ASSERT_NE(ge_model, nullptr);
2269+ auto graph = ge_model->GetGraph();
2270+ ASSERT_NE(graph, nullptr);
2271+ 
2272+ auto netoutput_node = graph->FindNode("NetOutput");
2273+ ASSERT_NE(netoutput_node, nullptr);
2274+ auto netoutput_desc = netoutput_node->GetOpDesc();
2275+ ASSERT_NE(netoutput_desc, nullptr);
2276+ 
2277+ std::vector<std::string> dynamic_output_dims = {"data1_0_1_3_224_224", "data1_0_2_3_448_448"};
2278+ AttrUtils::SetListStr(netoutput_desc, ATTR_NAME_DYNAMIC_OUTPUT_DIMS, dynamic_output_dims);
2279+ 
2280+ const std::string output_file = PathUtils::Join({test_work_dir, "test_dynamic_output.om2"});
2281+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2282+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2283+ 
2284+ ASSERT_EQ(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2285+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2286+}
2287+ 
2288+TEST_F(Om2PackageHelperUt, SaveModelInfo_WithGetDynamicBatchInfoFail_ReturnsFailed) {
2289+ auto ge_model = CreateGeModelWithCaseOp();
2290+ ASSERT_NE(ge_model, nullptr);
2291+ auto graph = ge_model->GetGraph();
2292+ ASSERT_NE(graph, nullptr);
2293+ 
2294+ auto case_node = graph->FindNode("case1");
2295+ ASSERT_NE(case_node, nullptr);
2296+ auto case_desc = case_node->GetOpDesc();
2297+ ASSERT_NE(case_desc, nullptr);
2298+ 
2299+ AttrUtils::SetInt(case_desc, ATTR_NAME_BATCH_NUM, 2U);
2300+ // Do NOT set ATTR_NAME_PRED_VALUE_0, so GetListInt will fail
2301+ 
2302+ const std::string output_file = PathUtils::Join({test_work_dir, "test_batch_fail.om2"});
2303+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2304+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2305+ 
2306+ EXPECT_NE(Om2PackageHelper::SaveModelInfo(zip_writer, ge_model, 0UL), SUCCESS);
2307+}
2308+ 
2309+TEST_F(Om2PackageHelperUt, SaveVisualJson_Ok_WritesVisualJsonToZip) {
2310+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2311+ ASSERT_NE(ge_root_model, nullptr);
2312+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2313+ ASSERT_NE(ge_model, nullptr);
2314+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2315+ 
2316+ const std::string output_file = PathUtils::Join({test_work_dir, "test_visual_json.om2"});
2317+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2318+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2319+ 
2320+ ASSERT_EQ(Om2PackageHelper::SaveVisualJson(zip_writer, ge_model, 0UL), SUCCESS);
2321+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2322+}
2323+ 
2324+TEST_F(Om2PackageHelperUt, SaveOpAttrJson_WithMultipleOpsHavingAttr_GenValidOpAttrJson) {
2325+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2326+ ASSERT_NE(ge_root_model, nullptr);
2327+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2328+ ASSERT_NE(ge_model, nullptr);
2329+ auto graph = ge_model->GetGraph();
2330+ ASSERT_NE(graph, nullptr);
2331+ 
2332+ for (const auto &node : graph->GetDirectNode()) {
2333+ auto op_desc = node->GetOpDesc();
2334+ if (op_desc == nullptr) {
2335+ continue;
2336+ }
2337+ std::vector<std::string> original_op_names = {"orig_" + op_desc->GetName()};
2338+ AttrUtils::SetListStr(op_desc, ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, original_op_names);
2339+ }
2340+ 
2341+ const std::string output_file = PathUtils::Join({test_work_dir, "test_op_attr_multi.om2"});
2342+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2343+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2344+ 
2345+ ASSERT_EQ(Om2PackageHelper::SaveOpAttrJson(zip_writer, ge_model, 0UL), SUCCESS);
2346+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2347+}
2348+ 
2349+TEST_F(Om2PackageHelperUt, RelocateExternalWeights_NoExternalWeights_ReturnsSuccess) {
2350+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2351+ ASSERT_NE(ge_root_model, nullptr);
2352+ 
2353+ ModelBufferData model_data;
2354+ const std::string output_file = PathUtils::Join({test_work_dir, "test_relocate.om2"});
2355+ Om2PackageHelper om2_packager;
2356+ SyncKernelNameForAllModels(ge_root_model);
2357+ ASSERT_EQ(om2_packager.SaveToOmRootModel(ge_root_model, output_file, model_data, false), SUCCESS);
2358+ 
2359+ ModelBufferData relocated_model;
2360+ bool relocated = false;
2361+ ASSERT_EQ(Om2PackageHelper::RelocateExternalWeights(output_file, model_data, relocated_model, relocated), SUCCESS);
2362+ EXPECT_FALSE(relocated);
2363+}
2364+ 
2365+TEST_F(Om2PackageHelperUt, ExtractVisualJson_Fail_InvalidModelData) {
2366+ std::string json_out;
2367+ const uint8_t garbage[] = {0x01, 0x02, 0x03, 0x04};
2368+ EXPECT_NE(Om2PackageHelper::ExtractVisualJson(garbage, sizeof(garbage), json_out), SUCCESS);
2369+}
2370+ 
2371+TEST_F(Om2PackageHelperUt, SaveCodegenArtifacts_Ok_GenArtifacts) {
2372+ const auto ge_root_model = CreateGeRootModelWithAicoreOp();
2373+ ASSERT_NE(ge_root_model, nullptr);
2374+ const auto ge_model = ge_root_model->GetSubgraphInstanceNameToModel().begin()->second;
2375+ ASSERT_NE(ge_model, nullptr);
2376+ ge_model->GetGraph()->SetParentGraph(std::make_shared<ComputeGraph>("root_g1"));
2377+ SyncKernelNameFromOpDesc(ge_model);
2378+ 
2379+ const std::string output_file = PathUtils::Join({test_work_dir, "test_codegen.om2"});
2380+ auto zip_writer = std::make_shared<ZipArchiveWriter>(output_file);
2381+ ASSERT_TRUE(zip_writer->IsMemFileOpened());
2382+ 
2383+ std::vector<Om2ConstMeta> const_metas;
2384+ ASSERT_EQ(Om2PackageHelper::SaveCodegenArtifacts(zip_writer, ge_model, 0UL, const_metas), SUCCESS);
2385+ ASSERT_TRUE(zip_writer->SaveModelDataToFile());
2386+}
2387+ 
2388+TEST_F(Om2PackageHelperUt, SetSaveMode_Ok) {
2389+ Om2PackageHelper om2_packager;
2390+ om2_packager.SetSaveMode(true);
2391+ om2_packager.SetSaveMode(false);
2392+}
2393+ 
2156} // namespace ge2394} // namespace ge
Mtests/ge/ut/ge/graph/manager/graph_var_manager_unittest.cc+104-0
@@ -862,4 +862,108 @@ TEST_F(UtestGraphVarManagerTest, test_init_var_if_has_init_value_size_exceeds) {
862 862 
863 EXPECT_EQ(dev_addr, nullptr);863 EXPECT_EQ(dev_addr, nullptr);
864}864}
865+ 
866+TEST_F(UtestGraphVarManagerTest, Cov_GetSizeByTensoDataType_NoOutput) {
867+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_no_out", CONSTANTOP);
868+ VarResource var_res(0);
869+ EXPECT_EQ(var_res.GetSizeByTensoDataType(op_desc), -1);
870+}
871+ 
872+TEST_F(UtestGraphVarManagerTest, Cov_GetReuseAddr_NoWeight) {
873+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_no_weight", CONSTANTOP);
874+ op_desc->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_FLOAT));
875+ VarResource var_res(0);
876+ uint8_t *mem_offset = nullptr;
877+ rtMemType_t memory_type = RT_MEMORY_HBM;
878+ EXPECT_EQ(var_res.GetReuseAddr(op_desc, &mem_offset, memory_type), FAILED);
879+}
880+ 
881+TEST_F(UtestGraphVarManagerTest, Cov_RenewCurVarDesc_NoVarInMap_OpDescVer) {
882+ VarResource var_res(0);
883+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Add");
884+ EXPECT_EQ(var_res.RenewCurVarDesc("nonexistent_var", op_desc), SUCCESS);
885+}
886+ 
887+TEST_F(UtestGraphVarManagerTest, Cov_RenewCurVarDesc_NullOpDesc) {
888+ VarResource var_res(0);
889+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
890+ var_res.SetVarAddr("test_var", tensor_desc, nullptr, RT_MEMORY_RDMA_HBM, nullptr);
891+ OpDescPtr null_op_desc = nullptr;
892+ EXPECT_EQ(var_res.RenewCurVarDesc("test_var", null_op_desc), FAILED);
893+}
894+ 
895+TEST_F(UtestGraphVarManagerTest, Cov_GetVarMemType_Reserved) {
896+ VarResource var_res(0);
897+ EXPECT_EQ(var_res.GetVarMemType(0), RT_MEMORY_RESERVED);
898+}
899+ 
900+TEST_F(UtestGraphVarManagerTest, Cov_CheckLogicAddrValid_Success) {
901+ VarResource var_res(0);
902+ GeTensorDesc tensor_desc;
903+ TensorUtils::SetSize(tensor_desc, 1000);
904+ VarDevAddrMgr addr_mgr = {tensor_desc, reinterpret_cast<uint8_t *>(500), nullptr, false};
905+ var_res.device_id_to_var_dev_addr_mgr_map_[0][500] = addr_mgr;
906+ uint64_t inner_offset = 0;
907+ uint64_t logic_addr_tmp = 0;
908+ EXPECT_EQ(var_res.CheckLogicAddrValid(0, reinterpret_cast<uint8_t *>(700), inner_offset, logic_addr_tmp), SUCCESS);
909+ EXPECT_EQ(inner_offset, 200U);
910+ EXPECT_EQ(logic_addr_tmp, 500U);
911+}
912+ 
913+TEST_F(UtestGraphVarManagerTest, Cov_SessionId) {
914+ VarManager tmp_mgr(42);
915+ EXPECT_EQ(tmp_mgr.SessionId(), 42U);
916+}
917+ 
918+TEST_F(UtestGraphVarManagerTest, Cov_GetVarMemSize_NullMemResource) {
919+ VarManager tmp_mgr(0);
920+ tmp_mgr.mem_resource_map_[RT_MEMORY_HBM] = nullptr;
921+ EXPECT_EQ(tmp_mgr.GetVarMemSize(RT_MEMORY_HBM), 0);
922+}
923+ 
924+TEST_F(UtestGraphVarManagerTest, Cov_GetVarMemSize_NonHBM) {
925+ VarManager tmp_mgr(0);
926+ auto mem_res = std::make_shared<RdmaMemResource>();
927+ tmp_mgr.mem_resource_map_[RT_MEMORY_RDMA_HBM] = mem_res;
928+ EXPECT_EQ(tmp_mgr.GetVarMemSize(RT_MEMORY_RDMA_HBM), 0);
929+}
930+ 
931+TEST_F(UtestGraphVarManagerTest, Cov_GetRdmaPoolMemory_NullMemManager) {
932+ VarManager tmp_mgr(0);
933+ EXPECT_EQ(tmp_mgr.GetRdmaPoolMemory(RT_MEMORY_HBM, 1024), nullptr);
934+}
935+ 
936+TEST_F(UtestGraphVarManagerTest, Cov_SetChangedGraphId_NullVarResource) {
937+ VarManager tmp_mgr(0);
938+ EXPECT_EQ(tmp_mgr.SetChangedGraphId("test_var", 0), INTERNAL_ERROR);
939+}
940+ 
941+TEST_F(UtestGraphVarManagerTest, Cov_RemoveChangedGraphId_NullVarResource) {
942+ VarManager tmp_mgr(0);
943+ tmp_mgr.RemoveChangedGraphId("test_var");
944+}
945+ 
946+TEST_F(UtestGraphVarManagerTest, Cov_SetAllMemoryMaxValue_Overflow) {
947+ VarManager tmp_mgr(0);
948+ tmp_mgr.graph_mem_max_size_ = 128UL * 1024UL * 1024UL * 1024UL + 1U;
949+ tmp_mgr.var_mem_max_size_ = 128UL * 1024UL * 1024UL * 1024UL;
950+ std::map<std::string, std::string> options;
951+ EXPECT_NE(tmp_mgr.SetAllMemoryMaxValue(options), SUCCESS);
952+}
953+ 
954+TEST_F(UtestGraphVarManagerTest, Cov_GetAllVariables_WithTransRoad) {
955+ uint64_t session_id = 202311132120;
956+ VarManager::Instance(session_id)->Init(0, session_id, 0, 0);
957+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
958+ TensorUtils::SetSize(tensor_desc, 16);
959+ VarManager::Instance(session_id)->AssignVarMem("test_var_road", nullptr, tensor_desc, RT_MEMORY_HBM);
960+ TransNodeInfo trans_node_info;
961+ trans_node_info.input = GeTensorDesc(GeShape({4}), FORMAT_ND, DT_FLOAT);
962+ VarTransRoad trans_road{trans_node_info};
963+ VarManager::Instance(session_id)->SetTransRoad("test_var_road", trans_road);
964+ std::map<std::string, GeTensorDesc> all_variables;
965+ EXPECT_EQ(VarManager::Instance(session_id)->GetAllVariables(all_variables), SUCCESS);
966+ EXPECT_EQ(all_variables.size(), 1U);
967+ VarManager::Instance(session_id)->Destroy();
968+}
865} // namespace ge969} // namespace ge
Mtests/ge/ut/ge/om2/codegen/stream_switch_task_code_builder_unittest.cc+17-10
@@ -14,6 +14,7 @@
14#include "common/om2/codegen/ast/ast_nodes.h"14#include "common/om2/codegen/ast/ast_nodes.h"
15#include "common/om2/codegen/ast/ast_build_context.h"15#include "common/om2/codegen/ast/ast_build_context.h"
16#include "common/om2/codegen/ast/ast_context.h"16#include "common/om2/codegen/ast/ast_context.h"
17+#include "framework/common/taskdown_common.h"
17 18 
18namespace ge {19namespace ge {
19 20 
@@ -23,29 +24,35 @@ class UtestStreamSwitchTaskCodeBuilder : public ::testing::Test {
23 builder_ = std::make_unique<StreamSwitchTaskCodeBuilder>(ast_);24 builder_ = std::make_unique<StreamSwitchTaskCodeBuilder>(ast_);
24 }25 }
25 26 
26- void TearDown() override {27+ void TearDown() override {}
27- // 清理测试残留
28- }
29 28 
30 AstContext ctx_;29 AstContext ctx_;
31 AstBuildContext ast_{ctx_};30 AstBuildContext ast_{ctx_};
32 std::unique_ptr<StreamSwitchTaskCodeBuilder> builder_;31 std::unique_ptr<StreamSwitchTaskCodeBuilder> builder_;
33};32};
34 33 
35-// 覆盖 RenderDistHelper 正常执行路径
36TEST_F(UtestStreamSwitchTaskCodeBuilder, RenderDistHelperSuccess) {34TEST_F(UtestStreamSwitchTaskCodeBuilder, RenderDistHelperSuccess) {
37 std::vector<DeclNode *> items;35 std::vector<DeclNode *> items;
38- 
39- // 1. 调用目标函数
40 Status ret = builder_->RenderDistHelper(items);36 Status ret = builder_->RenderDistHelper(items);
41- 
42- // 2. 验证返回值
43 EXPECT_EQ(ret, SUCCESS);37 EXPECT_EQ(ret, SUCCESS);
44- 
45- // 3. 验证生成了函数定义节点（distribute + dispatch）
46 ASSERT_GE(items.size(), 1U);38 ASSERT_GE(items.size(), 1U);
47 ASSERT_NE(items[0], nullptr);39 ASSERT_NE(items[0], nullptr);
48 items.clear();40 items.clear();
49}41}
50 42 
43+TEST_F(UtestStreamSwitchTaskCodeBuilder, ParseOpIndex_Success) {
44+ domi::TaskDef task_def;
45+ task_def.mutable_stream_switch()->set_op_index(42);
46+ EXPECT_EQ(builder_->ParseOpIndex(task_def), 42);
47+}
48+ 
49+TEST_F(UtestStreamSwitchTaskCodeBuilder, ParseOpIndex_DefaultZero) {
50+ domi::TaskDef task_def;
51+ EXPECT_EQ(builder_->ParseOpIndex(task_def), 0);
52+}
53+ 
54+TEST_F(UtestStreamSwitchTaskCodeBuilder, GetFuncName_NotEmpty) {
55+ EXPECT_FALSE(builder_->GetFuncName().empty());
56+}
57+ 
51} // namespace ge58} // namespace ge
Mtests/ge/ut/ge/session/ge_api_unittest.cc+38-0
@@ -2280,4 +2280,42 @@ TEST_F(UtestGeApi, FullSetupRunGraphForPrintOutput) {
2280 AclRuntimeStub::Reset();2280 AclRuntimeStub::Reset();
2281 ge_env.Reset();2281 ge_env.Reset();
2282}2282}
2283+ 
2284+TEST_F(UtestGeApi, GetVariables_NullName_CovEnhance) {
2285+ std::map<std::string, std::string> options;
2286+ EXPECT_EQ(GEInitialize(options), SUCCESS);
2287+ Session session(options);
2288+ std::vector<AscendString> var_names;
2289+ var_names.emplace_back(AscendString());
2290+ std::vector<Tensor> var_values;
2291+ EXPECT_EQ(session.GetVariables(var_names, var_values), FAILED);
2292+ EXPECT_EQ(GEFinalize(), SUCCESS);
2293+}
2294+ 
2295+TEST_F(UtestGeApi, FeedDataFlowGraph_TensorNotInit_CovEnhance) {
2296+ GEFinalize();
2297+ std::map<std::string, std::string> options;
2298+ Session session(options);
2299+ std::vector<Tensor> inputs;
2300+ DataFlowInfo info;
2301+ EXPECT_EQ(session.FeedDataFlowGraph(1U, inputs, info, 0), FAILED);
2302+}
2303+ 
2304+TEST_F(UtestGeApi, FeedRawData_NotInit_CovEnhance) {
2305+ GEFinalize();
2306+ std::map<std::string, std::string> options;
2307+ Session session(options);
2308+ std::vector<RawData> raw_data_list;
2309+ DataFlowInfo info;
2310+ EXPECT_EQ(session.FeedRawData(1U, raw_data_list, 0U, info, 0), FAILED);
2311+}
2312+ 
2313+TEST_F(UtestGeApi, FetchDataFlowGraph_TensorNotInit_CovEnhance) {
2314+ GEFinalize();
2315+ std::map<std::string, std::string> options;
2316+ Session session(options);
2317+ std::vector<Tensor> outputs;
2318+ DataFlowInfo info;
2319+ EXPECT_EQ(session.FetchDataFlowGraph(1U, outputs, info, 0), FAILED);
2320+}
2283} // namespace ge2321} // namespace ge
Mtests/ge/ut/ge/session/inner_session_unittest.cc+108-0
@@ -780,4 +780,112 @@ TEST_F(UtestInnerSession, DumpDebugJSONPrint_graph_not_exist) {
780 EXPECT_EQ(inner_session.DumpDebugJSONPrint(1U, 0U, json_result), GE_GRAPH_GRAPH_NOT_EXIST);780 EXPECT_EQ(inner_session.DumpDebugJSONPrint(1U, 0U, json_result), GE_GRAPH_GRAPH_NOT_EXIST);
781 EXPECT_EQ(inner_session.Finalize(), SUCCESS);781 EXPECT_EQ(inner_session.Finalize(), SUCCESS);
782}782}
783+ 
784+TEST_F(UtestInnerSession, CopyGeOutputsMemToUserOutputs_NonEmptyOutputs_CovEnhance) {
785+ std::vector<ge::Tensor> outputs;
786+ std::vector<ge::GeTensor> ge_outputs;
787+ ge::GeTensorDesc tensor_desc(ge::GeShape({1}), ge::FORMAT_ND, ge::DT_FLOAT16);
788+ ge::GeTensor ge_tensor(tensor_desc);
789+ ge_outputs.emplace_back(std::move(ge_tensor));
790+ ge::Tensor t;
791+ outputs.emplace_back(t);
792+ CopyGeOutputsMemToUserOutputs(ge_outputs, outputs);
793+ EXPECT_EQ(outputs.size(), 1U);
794+}
795+ 
796+TEST_F(UtestInnerSession, RemoveGraph_NotExist_CovEnhance) {
797+ std::map<std::string, std::string> options;
798+ InnerSession inner_session(1U, options);
799+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
800+ EXPECT_NE(inner_session.RemoveGraph(999U), SUCCESS);
801+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
802+}
803+ 
804+TEST_F(UtestInnerSession, SaveVariables_CovEnhance) {
805+ std::map<std::string, std::string> options;
806+ InnerSession inner_session(1U, options);
807+ Graph graph("test");
808+ std::vector<std::string> var_names = {"var1"};
809+ std::vector<ge::Tensor> outputs;
810+ std::vector<ge::Tensor> var_values;
811+ auto ret = inner_session.SaveVariables(graph, var_names, outputs, var_values);
812+ EXPECT_NE(ret, SUCCESS);
813+}
814+ 
815+TEST_F(UtestInnerSession, RegisterCallBackFunc_AllOverloads_CovEnhance) {
816+ std::map<std::string, std::string> options;
817+ InnerSession inner_session(1U, options);
818+ auto ret1 = inner_session.RegisterCallBackFunc("key1", Callback1);
819+ EXPECT_EQ(ret1, SUCCESS);
820+ auto ret2 = inner_session.RegisterCallBackFunc("key2", Callback2);
821+ EXPECT_EQ(ret2, SUCCESS);
822+ auto callback3 = [](uint32_t, const std::map<AscendString, gert::Tensor> &) -> Status { return SUCCESS; };
823+ auto ret3 = inner_session.RegisterCallBackFunc("key3", callback3);
824+ EXPECT_EQ(ret3, SUCCESS);
825+}
826+ 
827+TEST_F(UtestInnerSession, BuildGraph_InputTensorInfo_CovEnhance) {
828+ std::map<std::string, std::string> options;
829+ InnerSession inner_session(1U, options);
830+ std::vector<InputTensorInfo> inputs;
831+ InputTensorInfo info;
832+ info.dims = {1, 2, 3};
833+ info.data_type = 0U;
834+ inputs.emplace_back(info);
835+ auto ret = inner_session.BuildGraph(1U, inputs);
836+ EXPECT_NE(ret, SUCCESS);
837+}
838+ 
839+TEST_F(UtestInnerSession, RunGraphAsync_NotInit_CovEnhance) {
840+ std::map<std::string, std::string> options;
841+ InnerSession inner_session(1U, options);
842+ std::vector<gert::Tensor> inputs;
843+ RunAsyncCallbackV2 callback = [](Status, std::vector<gert::Tensor> &) {};
844+ auto ret = inner_session.RunGraphAsync(1U, std::move(inputs), callback);
845+ EXPECT_NE(ret, SUCCESS);
846+}
847+ 
848+TEST_F(UtestInnerSession, SetGraphConstMemoryBase_NotExist_CovEnhance) {
849+ std::map<std::string, std::string> options;
850+ options[ge::SOC_VERSION] = "Ascend910B";
851+ EXPECT_EQ(GEInitialize(options), SUCCESS);
852+ InnerSession inner_session(0U, options);
853+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
854+ EXPECT_NE(inner_session.SetGraphConstMemoryBase(1U, nullptr, 0U), SUCCESS);
855+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
856+ EXPECT_EQ(GEFinalize(), SUCCESS);
857+}
858+ 
859+TEST_F(UtestInnerSession, UpdateGraphFeatureMemoryBase_NotExist_CovEnhance) {
860+ std::map<std::string, std::string> options;
861+ options[ge::SOC_VERSION] = "Ascend910B";
862+ EXPECT_EQ(GEInitialize(options), SUCCESS);
863+ InnerSession inner_session(0U, options);
864+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
865+ EXPECT_NE(inner_session.UpdateGraphFeatureMemoryBase(1U, nullptr, 0U), SUCCESS);
866+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
867+ EXPECT_EQ(GEFinalize(), SUCCESS);
868+}
869+ 
870+TEST_F(UtestInnerSession, UpdateGraphRefreshableFeatureMemoryBase_NotExist_CovEnhance) {
871+ std::map<std::string, std::string> options;
872+ options[ge::SOC_VERSION] = "Ascend910B";
873+ EXPECT_EQ(GEInitialize(options), SUCCESS);
874+ InnerSession inner_session(0U, options);
875+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
876+ EXPECT_NE(inner_session.UpdateGraphRefreshableFeatureMemoryBase(1U, nullptr, 0U), SUCCESS);
877+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
878+ EXPECT_EQ(GEFinalize(), SUCCESS);
879+}
880+ 
881+TEST_F(UtestInnerSession, SetGraphFixedFeatureMemoryBase_NotExist_CovEnhance) {
882+ std::map<std::string, std::string> options;
883+ options[ge::SOC_VERSION] = "Ascend910B";
884+ EXPECT_EQ(GEInitialize(options), SUCCESS);
885+ InnerSession inner_session(0U, options);
886+ EXPECT_EQ(inner_session.Initialize(), SUCCESS);
887+ EXPECT_NE(inner_session.SetGraphFixedFeatureMemoryBase(1U, MemoryType::MEMORY_TYPE_DEFAULT, nullptr, 0U), SUCCESS);
888+ EXPECT_EQ(inner_session.Finalize(), SUCCESS);
889+ EXPECT_EQ(GEFinalize(), SUCCESS);
890+}
783} // namespace ge891} // namespace ge
Mtests/ge/ut/ge/session/main_unittest.cc+165-0
@@ -2319,3 +2319,168 @@ TEST_F(UtestLegacySoPartition, SimilarButNotLegacySuffix_NotMoved) {
2319 EXPECT_EQ(fileList[2], "/path/_legacy.sox");2319 EXPECT_EQ(fileList[2], "/path/_legacy.sox");
2320 EXPECT_EQ(fileList[3], "/path/real_legacy.so");2320 EXPECT_EQ(fileList[3], "/path/real_legacy.so");
2321}2321}
2322+ 
2323+TEST_F(UtestMain, MainImplTest_invalid_mode_CovEnhance) {
2324+ std::string om_arg = AtcFileFactory::Generatefile1("--model=", "add.pb");
2325+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "tmp");
2326+ char *argv[] = {"atc",
2327+ "--mode=999",
2328+ "--framework=3",
2329+ const_cast<char *>(om_arg.c_str()),
2330+ const_cast<char *>(output_arg.c_str()),
2331+ "--soc_version=Ascend910B",
2332+ "--input_format=NCHW"};
2333+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2334+ EXPECT_NE(ret, 0);
2335+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "tmp.om").c_str());
2336+}
2337+ 
2338+TEST_F(UtestMain, MainImplTest_json_path_invalid_CovEnhance) {
2339+ char *argv[] = {"atc", "--mode=1", "--om=/nonexistent_dir/model.om", "--json=/nonexistent_dir/output.json"};
2340+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2341+ EXPECT_NE(ret, 0);
2342+}
2343+ 
2344+TEST_F(UtestMain, MainImplTest_save_original_model_invalid_CovEnhance) {
2345+ const auto opp_path = ConstructOppEnv();
2346+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_test_model.pb");
2347+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_tmp");
2348+ char *argv[] = {"atc",
2349+ "--framework=3",
2350+ const_cast<char *>(model_arg.c_str()),
2351+ const_cast<char *>(output_arg.c_str()),
2352+ "--soc_version=Ascend910B",
2353+ "--input_format=NCHW",
2354+ "--host_env_os=linux",
2355+ "--host_env_cpu=x86_64",
2356+ "--save_original_model=invalid"};
2357+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2358+ EXPECT_NE(ret, 0);
2359+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.pb").c_str());
2360+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp.om").c_str());
2361+ system(("rm -rf " + opp_path).c_str());
2362+}
2363+ 
2364+TEST_F(UtestMain, MainImplTest_op_name_map_not_found_CovEnhance) {
2365+ const auto opp_path = ConstructOppEnv();
2366+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_test_model.pb");
2367+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_tmp");
2368+ char *argv[] = {"atc",
2369+ "--framework=3",
2370+ const_cast<char *>(model_arg.c_str()),
2371+ const_cast<char *>(output_arg.c_str()),
2372+ "--soc_version=Ascend910B",
2373+ "--input_format=NCHW",
2374+ "--host_env_os=linux",
2375+ "--host_env_cpu=x86_64",
2376+ "--op_name_map=/nonexistent_dir/op_name_map.txt"};
2377+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2378+ EXPECT_NE(ret, 0);
2379+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.pb").c_str());
2380+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp.om").c_str());
2381+ system(("rm -rf " + opp_path).c_str());
2382+}
2383+ 
2384+TEST_F(UtestMain, MainImplTest_static_model_ops_lower_limit_CovEnhance) {
2385+ const auto opp_path = ConstructOppEnv();
2386+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_test_model.pb");
2387+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_tmp");
2388+ char *argv[] = {"atc",
2389+ "--framework=3",
2390+ const_cast<char *>(model_arg.c_str()),
2391+ const_cast<char *>(output_arg.c_str()),
2392+ "--soc_version=Ascend910B",
2393+ "--input_format=NCHW",
2394+ "--host_env_os=linux",
2395+ "--host_env_cpu=x86_64",
2396+ "--static_model_ops_lower_limit=10"};
2397+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2398+ EXPECT_NE(ret, 0);
2399+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.pb").c_str());
2400+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp.om").c_str());
2401+ system(("rm -rf " + opp_path).c_str());
2402+}
2403+ 
2404+TEST_F(UtestMain, MainImplTest_save_original_model_true_CovEnhance) {
2405+ const auto opp_path = ConstructOppEnv();
2406+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_test_model.pb");
2407+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_tmp");
2408+ char *argv[] = {"atc",
2409+ "--framework=3",
2410+ const_cast<char *>(model_arg.c_str()),
2411+ const_cast<char *>(output_arg.c_str()),
2412+ "--soc_version=Ascend910B",
2413+ "--input_format=NCHW",
2414+ "--host_env_os=linux",
2415+ "--host_env_cpu=x86_64",
2416+ "--save_original_model=true"};
2417+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2418+ EXPECT_NE(ret, 0);
2419+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.pb").c_str());
2420+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp.om").c_str());
2421+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp_original.om").c_str());
2422+ system(("rm -rf " + opp_path).c_str());
2423+}
2424+ 
2425+TEST_F(UtestMain, MainImplTest_input_fp16_nodes_CovEnhance) {
2426+ const auto opp_path = ConstructOppEnv();
2427+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_test_model.pb");
2428+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_tmp");
2429+ char *argv[] = {"atc",
2430+ "--framework=3",
2431+ const_cast<char *>(model_arg.c_str()),
2432+ const_cast<char *>(output_arg.c_str()),
2433+ "--soc_version=Ascend910B",
2434+ "--input_format=NCHW",
2435+ "--host_env_os=linux",
2436+ "--host_env_cpu=x86_64",
2437+ "--input_fp16_nodes=data1"};
2438+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2439+ EXPECT_NE(ret, 0);
2440+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.pb").c_str());
2441+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp.om").c_str());
2442+ system(("rm -rf " + opp_path).c_str());
2443+}
2444+ 
2445+TEST_F(UtestMain, MainImplTest_optimization_switch_CovEnhance) {
2446+ const auto opp_path = ConstructOppEnv();
2447+ std::string model_arg = AtcFileFactory::GenerateModel("--model=", "cov_test_model.pb");
2448+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "cov_tmp");
2449+ char *argv[] = {"atc",
2450+ "--framework=3",
2451+ const_cast<char *>(model_arg.c_str()),
2452+ const_cast<char *>(output_arg.c_str()),
2453+ "--soc_version=Ascend910B",
2454+ "--input_format=NCHW",
2455+ "--host_env_os=linux",
2456+ "--host_env_cpu=x86_64",
2457+ "--optimization_switch=forbidden_close_pass:on"};
2458+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2459+ EXPECT_NE(ret, 0);
2460+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.pb").c_str());
2461+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_tmp.om").c_str());
2462+ system(("rm -rf " + opp_path).c_str());
2463+}
2464+ 
2465+TEST_F(UtestMain, MainImplTest_display_model_info_mode6_CovEnhance) {
2466+ std::string om_arg = AtcFileFactory::GenerateModel("--om=", "cov_test_model.om");
2467+ char *argv[] = {"atc", "--mode=6", "--framework=-1", const_cast<char *>(om_arg.c_str())};
2468+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2469+ EXPECT_NE(ret, 0);
2470+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "cov_test_model.om").c_str());
2471+}
2472+ 
2473+TEST_F(UtestMain, MainImplTest_auto_tune_mode_deprecated_CovEnhance) {
2474+ std::string om_arg = AtcFileFactory::Generatefile1("--model=", "add.pb");
2475+ std::string output_arg = AtcFileFactory::Generatefile1("--output=", "tmp");
2476+ char *argv[] = {"atc",
2477+ "--framework=3",
2478+ const_cast<char *>(om_arg.c_str()),
2479+ const_cast<char *>(output_arg.c_str()),
2480+ "--soc_version=Ascend910B",
2481+ "--input_format=NCHW",
2482+ "--auto_tune_mode=RA"};
2483+ int32_t ret = main_impl(sizeof(argv) / sizeof(argv[0]), argv);
2484+ EXPECT_NE(ret, 0);
2485+ AtcFileFactory::RemoveFile(AtcFileFactory::Generatefile1("", "tmp.om").c_str());
2486+}
Mtests/ge/ut/ge/session/single_op_parser_unittest.cc+170-0
@@ -871,4 +871,174 @@ TEST_F(UtestOmg, ParseSingleOpList_UnsupportedAttrType) {
871 EXPECT_NE(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);871 EXPECT_NE(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
872 system(("rm " + file).c_str());872 system(("rm " + file).c_str());
873}873}
874+ 
875+TEST_F(UtestOmg, ParseSingleOpList_InvalidJson_ParseException) {
876+ std::string file = __FILE__;
877+ file = file.substr(0, file.rfind("/") + 1) + "invalid_json_test.json";
878+ stringstream sstream;
879+ sstream << R"(cat - << EOF > )" << file;
880+ sstream << R"(
881+{invalid json content}
882+)";
883+ sstream << R"(EOF)";
884+ system(sstream.str().c_str());
885+ std::vector<SingleOpBuildParam> op_list;
886+ EXPECT_NE(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
887+ system(("rm " + file).c_str());
888+}
889+ 
890+TEST_F(UtestOmg, Validate_EmptyOpName) {
891+ SingleOpDesc op_desc;
892+ op_desc.op = "";
893+ EXPECT_EQ(SingleOpParser::Validate(op_desc), false);
894+}
895+ 
896+TEST_F(UtestOmg, Validate_InputFormatReserved) {
897+ SingleOpDesc op_desc;
898+ op_desc.op = "test_op";
899+ SingleOpTensorDesc input_tensor_desc;
900+ input_tensor_desc.is_valid = true;
901+ input_tensor_desc.type = ge::DT_FLOAT;
902+ input_tensor_desc.format = ge::FORMAT_RESERVED;
903+ op_desc.input_desc.push_back(input_tensor_desc);
904+ EXPECT_EQ(SingleOpParser::Validate(op_desc), false);
905+}
906+ 
907+TEST_F(UtestOmg, Validate_InputDataTypeUndefined) {
908+ SingleOpDesc op_desc;
909+ op_desc.op = "test_op";
910+ SingleOpTensorDesc input_tensor_desc;
911+ input_tensor_desc.is_valid = true;
912+ input_tensor_desc.type = ge::DT_UNDEFINED;
913+ input_tensor_desc.format = ge::FORMAT_NCHW;
914+ op_desc.input_desc.push_back(input_tensor_desc);
915+ EXPECT_EQ(SingleOpParser::Validate(op_desc), false);
916+}
917+ 
918+TEST_F(UtestOmg, Validate_OutputInvalidFlag) {
919+ SingleOpDesc op_desc;
920+ op_desc.op = "test_op";
921+ SingleOpTensorDesc output_tensor_desc;
922+ output_tensor_desc.is_valid = false;
923+ output_tensor_desc.type = ge::DT_FLOAT;
924+ output_tensor_desc.format = ge::FORMAT_NCHW;
925+ op_desc.output_desc.push_back(output_tensor_desc);
926+ EXPECT_EQ(SingleOpParser::Validate(op_desc), false);
927+}
928+ 
929+TEST_F(UtestOmg, TransConstValue_UnsupportedType) {
930+ std::string type_str = "bool";
931+ nlohmann::json j;
932+ SingleOpTensorDesc desc;
933+ desc.type = ge::DT_BOOL;
934+ desc.const_value_size = 0U;
935+ j["const_value"] = {true, false};
936+ TransConstValue(type_str, j, desc);
937+ EXPECT_EQ(desc.const_value_size, 0U);
938+}
939+ 
940+TEST_F(UtestOmg, TransConstValue_NoConstValue) {
941+ std::string type_str = "int32";
942+ nlohmann::json j;
943+ SingleOpTensorDesc desc;
944+ desc.type = ge::DT_INT32;
945+ desc.const_value_size = 0U;
946+ TransConstValue(type_str, j, desc);
947+ EXPECT_EQ(desc.const_value_size, 0U);
948+}
949+ 
950+TEST_F(UtestOmg, FromJson_WithOriginShape) {
951+ nlohmann::json j;
952+ j["shape"] = {1, 2};
953+ j["origin_shape"] = {1, 2, 3};
954+ j["format"] = "ND";
955+ j["type"] = "int32";
956+ SingleOpTensorDesc desc;
957+ from_json(j, desc);
958+ EXPECT_EQ(desc.ori_dims.size(), 3U);
959+ EXPECT_EQ(desc.ori_dims[0], 1);
960+}
961+ 
962+TEST_F(UtestOmg, FromJson_AttrDataTypeWithIntValue) {
963+ nlohmann::json j;
964+ j["name"] = "test_attr";
965+ j["type"] = "data_type";
966+ j["value"] = 1;
967+ SingleOpAttr attr;
968+ from_json(j, attr);
969+ EXPECT_EQ(attr.name, "test_attr");
970+ EXPECT_EQ(attr.type, "data_type");
971+}
972+ 
973+TEST_F(UtestOmg, UpdateDynamicTensorName_MultipleSameName) {
974+ std::vector<SingleOpTensorDesc> desc;
975+ SingleOpTensorDesc tensor1;
976+ tensor1.dynamic_input_name = "input0";
977+ desc.push_back(tensor1);
978+ SingleOpTensorDesc tensor2;
979+ tensor2.dynamic_input_name = "input0";
980+ desc.push_back(tensor2);
981+ SingleOpTensorDesc tensor3;
982+ tensor3.dynamic_input_name = "input0";
983+ desc.push_back(tensor3);
984+ EXPECT_EQ(SingleOpParser::UpdateDynamicTensorName(desc), SUCCESS);
985+ EXPECT_EQ(desc[0].name, "input00");
986+ EXPECT_EQ(desc[1].name, "input01");
987+ EXPECT_EQ(desc[2].name, "input02");
988+}
989+ 
990+TEST_F(UtestOmg, ReadJsonFile_NotAJsonArray) {
991+ std::string file = __FILE__;
992+ file = file.substr(0, file.rfind("/") + 1) + "not_array_json_test.json";
993+ stringstream sstream;
994+ sstream << R"(cat - << EOF > )" << file;
995+ sstream << R"(
996+{"op": "Add"}
997+)";
998+ sstream << R"(EOF)";
999+ system(sstream.str().c_str());
1000+ std::vector<SingleOpBuildParam> op_list;
1001+ EXPECT_NE(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
1002+ system(("rm " + file).c_str());
1003+}
1004+ 
1005+TEST_F(UtestOmg, ParseSingleOpList_ConstValueWithUnsupportedType) {
1006+ std::string file = __FILE__;
1007+ file = file.substr(0, file.rfind("/") + 1) + "const_unsupported_type_test.json";
1008+ stringstream sstream;
1009+ sstream << R"(cat - << EOF > )" << file;
1010+ sstream << R"(
1011+[
1012+ {
1013+ "op": "Add",
1014+ "input_desc": [
1015+ {
1016+ "format": "ND",
1017+ "shape": [1,2],
1018+ "type": "int32",
1019+ "is_const": true,
1020+ "const_value": [1, 2]
1021+ },
1022+ {
1023+ "format": "ND",
1024+ "shape": [1,2],
1025+ "type": "int32"
1026+ }
1027+ ],
1028+ "output_desc": [
1029+ {
1030+ "format": "ND",
1031+ "shape": [1,2],
1032+ "type": "int32"
1033+ }
1034+ ]
1035+ }
1036+]
1037+)";
1038+ sstream << R"(EOF)";
1039+ system(sstream.str().c_str());
1040+ std::vector<SingleOpBuildParam> op_list;
1041+ EXPECT_EQ(SingleOpParser::ParseSingleOpList(file, op_list), SUCCESS);
1042+ system(("rm " + file).c_str());
1043+}
874} // namespace ge1044} // namespace ge
Mtests/ge/ut/ge/session_v2/ge_api_v2_unittest.cc+76-0
@@ -2746,4 +2746,80 @@ TEST_F(UtestGeApiV2, GEInitialize_InvalidSocVersion) {
2746 (void)ret;2746 (void)ret;
2747 GEFinalizeV2();2747 GEFinalizeV2();
2748}2748}
2749+ 
2750+TEST_F(UtestGeApiV2, AreOptionsEqual_DifferentOptions_CovEnhance) {
2751+ std::map<AscendString, AscendString> options1;
2752+ options1[ge::SOC_VERSION.c_str()] = "Ascend910B";
2753+ options1["ge.option_A"] = "value_A";
2754+ EXPECT_EQ(GEInitializeV2(options1), SUCCESS);
2755+ 
2756+ std::map<AscendString, AscendString> options2;
2757+ options2[ge::SOC_VERSION.c_str()] = "Ascend910B";
2758+ options2["ge.option_B"] = "value_B";
2759+ EXPECT_EQ(GEInitializeV2(options2), SUCCESS);
2760+ 
2761+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2762+}
2763+ 
2764+TEST_F(UtestGeApiV2, AreOptionsEqual_DifferentSize_CovEnhance) {
2765+ std::map<AscendString, AscendString> options1;
2766+ options1[ge::SOC_VERSION.c_str()] = "Ascend910B";
2767+ EXPECT_EQ(GEInitializeV2(options1), SUCCESS);
2768+ 
2769+ std::map<AscendString, AscendString> options2;
2770+ EXPECT_EQ(GEInitializeV2(options2), SUCCESS);
2771+ 
2772+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2773+}
2774+ 
2775+TEST_F(UtestGeApiV2, GeSessionConstructor_AllocFail_CovEnhance) {
2776+ gert::GertRuntimeStub runtime_stub;
2777+ runtime_stub.GetSlogStub().Clear();
2778+ dlog_setlevel(GE_MODULE_NAME, 0, 0);
2779+ 
2780+ g_fail_nothrow_new = true;
2781+ std::map<AscendString, AscendString> options;
2782+ GeSession session(options);
2783+ g_fail_nothrow_new = false;
2784+ 
2785+ EXPECT_EQ(session.GetSessionId(), uint64_t{0});
2786+ dlog_setlevel(GE_MODULE_NAME, 3, 0);
2787+}
2788+ 
2789+TEST_F(UtestGeApiV2, GraphDebugJSONPrint_SuccessPath_CovEnhance) {
2790+ gert::GertRuntimeStub rtstub;
2791+ rtstub.GetRtsRuntimeStub().Clear();
2792+ rtstub.StubByNodeTypes({"Data", "Add", "NetOutput"});
2793+ rtstub.GetKernelStub().AllKernelRegisteredAndSuccess();
2794+ 
2795+ OpsKernelBuilderPtr builder = MakeShared<GeFakeOpsKernelBuilder>();
2796+ OpsKernelBuilderRegistry::GetInstance().Register(kEngineNameAiCore, builder);
2797+ OpsKernelBuilderRegistry::GetInstance().Register(kEngineNameGeLocal, builder);
2798+ 
2799+ std::map<AscendString, AscendString> options;
2800+ options[ge::OPTION_GRAPH_RUN_MODE] = "0";
2801+ options[ge::SOC_VERSION.c_str()] = "Ascend910B";
2802+ EXPECT_EQ(GEInitializeV2(options), SUCCESS);
2803+ GeSession session(options);
2804+ ComputeGraphPtr com_graph = gert::ShareGraph::AicoreGraph();
2805+ auto graph = GraphUtilsEx::CreateGraphFromComputeGraph(com_graph);
2806+ (void)ge::AttrUtils::SetBool(com_graph, ge::ATTR_SINGLE_OP_SCENE, true);
2807+ 
2808+ GraphId graph_id = 1;
2809+ EXPECT_EQ(session.AddGraph(graph_id, graph, options), SUCCESS);
2810+ EXPECT_EQ(session.CompileGraph(graph_id, {}), SUCCESS);
2811+ 
2812+ AscendString json_result;
2813+ (void)session.GraphDebugJSONPrint(graph_id, 0U, json_result);
2814+ 
2815+ EXPECT_EQ(GEFinalizeV2(), SUCCESS);
2816+}
2817+ 
2818+TEST_F(UtestGeApiV2, GetCompiledModel_NotInit_CovEnhance) {
2819+ GEFinalizeV2();
2820+ std::map<AscendString, AscendString> options;
2821+ GeSession session(options);
2822+ ModelBufferData model_buffer;
2823+ EXPECT_NE(session.GetCompiledModel(1U, model_buffer), SUCCESS);
2824+}
2749} // namespace ge2825} // namespace ge
Mtests/graph_metadef/ut/exe_graph/fast_value_holder_unittest.cc+132-0
@@ -1874,5 +1874,137 @@ TEST_F(FastValueHolderUt, ClearGraphFrameSucc) {
1874 EXPECT_EQ(ValueHolder::GetCurrentFrame(), nullptr);1874 EXPECT_EQ(ValueHolder::GetCurrentFrame(), nullptr);
1875 EXPECT_EQ(ValueHolder::PopGraphFrame(), nullptr);1875 EXPECT_EQ(ValueHolder::PopGraphFrame(), nullptr);
1876}1876}
1877+ 
1878+TEST_F(FastValueHolderUt, IncCov_CreateSingleDataOutput_NoFrame) {
1879+ ValueHolder::ClearGraphFrameResource();
1880+ auto holder = ValueHolder::CreateSingleDataOutput("TestNode", {});
1881+ EXPECT_EQ(holder, nullptr);
1882+}
1883+ 
1884+TEST_F(FastValueHolderUt, IncCov_AddDependency_NullDst) {
1885+ auto data = ValueHolder::CreateFeed(0);
1886+ auto result = ValueHolder::AddDependency(data, nullptr);
1887+ EXPECT_FALSE(result.IsSuccess());
1888+ ValueHolderPtr null_holder;
1889+ auto result2 = ValueHolder::AddDependency(null_holder, data);
1890+ EXPECT_FALSE(result2.IsSuccess());
1891+}
1892+ 
1893+TEST_F(FastValueHolderUt, IncCov_AddDependency_NullFastNode) {
1894+ ValueHolderPtr null_holder = std::make_shared<ValueHolder>();
1895+ auto data = ValueHolder::CreateFeed(0);
1896+ auto result = ValueHolder::AddDependency(null_holder, data);
1897+ EXPECT_FALSE(result.IsSuccess());
1898+ auto result2 = ValueHolder::AddDependency(data, null_holder);
1899+ EXPECT_FALSE(result2.IsSuccess());
1900+}
1901+ 
1902+TEST_F(FastValueHolderUt, IncCov_PushGraphFrame_RootWhenNotEmpty) {
1903+ auto frame = ValueHolder::PushGraphFrame();
1904+ EXPECT_EQ(frame, nullptr);
1905+}
1906+ 
1907+TEST_F(FastValueHolderUt, IncCov_PushGraphFrame_NonRootWhenEmpty) {
1908+ auto data = ValueHolder::CreateFeed(0);
1909+ auto frame = ValueHolder::PopGraphFrame();
1910+ ASSERT_NE(frame, nullptr);
1911+ auto result = ValueHolder::PushGraphFrame(data, "subgraph");
1912+ EXPECT_EQ(result, nullptr);
1913+ ValueHolder::PushGraphFrame(frame.release());
1914+}
1915+ 
1916+TEST_F(FastValueHolderUt, IncCov_AddRelevantInputNode_NoFrame) {
1917+ ValueHolder::ClearGraphFrameResource();
1918+ auto node = FakeNode();
1919+ ValueHolder::AddRelevantInputNode(node);
1920+}
1921+ 
1922+TEST_F(FastValueHolderUt, IncCov_GetLastExecNodes_EmptyFrames) {
1923+ ValueHolder::ClearGraphFrameResource();
1924+ auto nodes = ValueHolder::GetLastExecNodes();
1925+ EXPECT_TRUE(nodes.empty());
1926+}
1927+ 
1928+TEST_F(FastValueHolderUt, IncCov_RefFrom_NegativeIndex) {
1929+ auto data = ValueHolder::CreateFeed(0);
1930+ auto holder = data->CreateMateFromNode(data->GetFastNode(), -1, ValueHolder::ValueHolderType::kOutput);
1931+ ASSERT_NE(holder, nullptr);
1932+ auto result = holder->RefFrom(data);
1933+ EXPECT_NE(result, ge::GRAPH_SUCCESS);
1934+ 
1935+ auto holder2 = data->CreateMateFromNode(data->GetFastNode(), 0, ValueHolder::ValueHolderType::kOutput);
1936+ ASSERT_NE(holder2, nullptr);
1937+ auto result2 = holder2->RefFrom(holder);
1938+ EXPECT_NE(result2, ge::GRAPH_SUCCESS);
1939+}
1940+ 
1941+TEST_F(FastValueHolderUt, IncCov_SetCurrentComputeNode_NoFrame) {
1942+ ValueHolder::ClearGraphFrameResource();
1943+ auto node = FakeNode();
1944+ ValueHolder::SetCurrentComputeNode(node);
1945+}
1946+ 
1947+TEST_F(FastValueHolderUt, IncCov_PopGraphFrame_Empty) {
1948+ ValueHolder::ClearGraphFrameResource();
1949+ auto frame = ValueHolder::PopGraphFrame();
1950+ EXPECT_EQ(frame, nullptr);
1951+}
1952+ 
1953+TEST_F(FastValueHolderUt, IncCov_GetCurrentFrame_AfterClear) {
1954+ ValueHolder::ClearGraphFrameResource();
1955+ EXPECT_EQ(ValueHolder::GetCurrentFrame(), nullptr);
1956+}
1957+ 
1958+TEST_F(FastValueHolderUt, IncCov_GetCurrentExecuteGraph_NoFrame) {
1959+ ValueHolder::ClearGraphFrameResource();
1960+ EXPECT_EQ(ValueHolder::GetCurrentExecuteGraph(), nullptr);
1961+}
1962+ 
1963+TEST_F(FastValueHolderUt, IncCov_CreateError_VaList) {
1964+ auto holder = ValueHolder::CreateError("test error %d", 42);
1965+ ASSERT_NE(holder, nullptr);
1966+ EXPECT_FALSE(holder->IsOk());
1967+ EXPECT_EQ(holder->GetType(), ValueHolder::ValueHolderType::kValueHolderTypeEnd);
1968+}
1969+ 
1970+TEST_F(FastValueHolderUt, IncCov_GetGuarder_SetGuarder) {
1971+ auto data0 = ValueHolder::CreateFeed(0);
1972+ auto allocator0 = ValueHolder::CreateSingleDataOutput("CreateAllocator", {data0});
1973+ auto guarder = ValueHolder::CreateVoidGuarder("DestroyAllocator", allocator0, {});
1974+ ASSERT_NE(guarder, nullptr);
1975+ EXPECT_EQ(allocator0->GetGuarder(), guarder);
1976+ EXPECT_EQ(guarder->GetGuarder(), nullptr);
1977+}
1978+ 
1979+TEST_F(FastValueHolderUt, IncCov_ReleaseAfter_NoGuarder) {
1980+ auto data0 = ValueHolder::CreateFeed(0);
1981+ auto allocator0 = ValueHolder::CreateSingleDataOutput("CreateAllocator", {data0});
1982+ allocator0->ReleaseAfter(data0);
1983+}
1984+ 
1985+TEST_F(FastValueHolderUt, IncCov_GetLastExecNodes_WithRootFrame) {
1986+ auto data0 = ValueHolder::CreateFeed(0);
1987+ auto foo = ValueHolder::CreateSingleDataOutput("Foo", {data0});
1988+ auto frame = ValueHolder::PopGraphFrame({foo}, {});
1989+ ASSERT_NE(frame, nullptr);
1990+}
1991+ 
1992+TEST_F(FastValueHolderUt, IncCov_SetScopedCurrentComputeNode) {
1993+ auto op_desc = std::make_shared<ge::OpDesc>("node", "node");
1994+ ge::GeTensorDesc tensor_desc;
1995+ tensor_desc.SetOriginFormat(ge::FORMAT_NCHW);
1996+ tensor_desc.SetFormat(ge::FORMAT_NC1HWC0);
1997+ tensor_desc.SetDataType(ge::DT_FLOAT16);
1998+ tensor_desc.SetOriginDataType(ge::DT_FLOAT);
1999+ tensor_desc.SetShape(ge::GeShape({8, 1, 224, 224, 16}));
2000+ tensor_desc.SetOriginShape(ge::GeShape({8, 3, 224, 224}));
2001+ op_desc->AddInputDesc("x1", tensor_desc);
2002+ auto graph = std::make_shared<ge::ComputeGraph>("graph");
2003+ auto node = graph->AddNode(op_desc);
2004+ 
2005+ ValueHolder::SetCurrentComputeNode(node);
2006+ auto guarder = ValueHolder::SetScopedCurrentComputeNode(node);
2007+ ASSERT_NE(guarder, nullptr);
2008+}
1877} // namespace bg2009} // namespace bg
1878} // namespace gert2010} // namespace gert
Mtests/graph_metadef/ut/expression/testcase/expression_unittest.cc+69-0
@@ -2348,4 +2348,73 @@ TEST_F(UtestExpression, AsNumerDenomToStringTest) {
2348 auto e2 = r1 * s0 * s1;2348 auto e2 = r1 * s0 * s1;
2349 EXPECT_EQ(SymbolicUtils::AsNumerDenomToString(e2), "((2 * s0 * s1))/(3)");2349 EXPECT_EQ(SymbolicUtils::AsNumerDenomToString(e2), "((2 * s0 * s1))/(3)");
2350}2350}
2351+ 
2352+TEST_F(UtestExpression, NullExpression_AllNullPaths) {
2353+ Expression e(nullptr);
2354+ EXPECT_EQ(e.IsVariableExpr(), false);
2355+ EXPECT_EQ(e.IsBooleanExpr(), false);
2356+ EXPECT_EQ(e.Hash(), std::numeric_limits<uint64_t>::max());
2357+ Expression e2(nullptr);
2358+ EXPECT_EQ(e.Compare(e2), std::numeric_limits<int64_t>::max());
2359+ auto var_b = Symbol("b");
2360+ EXPECT_EQ(e.ContainVar(var_b), false);
2361+ Expression numer;
2362+ Expression denom;
2363+ e.AsNumerDenom(numer, denom);
2364+ EXPECT_EQ(numer.IsValid(), false);
2365+ EXPECT_EQ(denom.IsValid(), false);
2366+ std::ostringstream os;
2367+ os << e;
2368+ EXPECT_TRUE(os.str().empty());
2369+}
2370+ 
2371+TEST_F(UtestExpression, NullExpression_ReplaceSubs) {
2372+ Expression e(nullptr);
2373+ auto var_b = Symbol("b");
2374+ auto var_c = Symbol("c");
2375+ auto replaced = e.Replace({{var_b, var_c}});
2376+ EXPECT_EQ(replaced.IsValid(), false);
2377+ auto subsed = e.Subs({{var_b, var_c}});
2378+ EXPECT_EQ(subsed.IsValid(), false);
2379+}
2380+ 
2381+TEST_F(UtestExpression, ComputeHint_NoShapeEnv_NonConstExpr) {
2382+ SetCurShapeEnvContext(nullptr);
2383+ auto s0 = Symbol("s0");
2384+ int64_t hint;
2385+ EXPECT_EQ(s0.GetHint(hint), false);
2386+ double hint_d;
2387+ EXPECT_EQ(s0.GetHint(hint_d), false);
2388+}
2389+ 
2390+TEST_F(UtestExpression, Expression_MoveConstructor) {
2391+ auto s0 = Symbol("s0");
2392+ auto s1 = Symbol("s1");
2393+ auto expr = Add(s0, s1);
2394+ Expression moved(std::move(expr));
2395+ EXPECT_EQ(moved.IsValid(), true);
2396+ EXPECT_EQ(moved, Add(s0, s1));
2397+}
2398+ 
2399+TEST_F(UtestExpression, Expression_MoveAssign) {
2400+ auto s0 = Symbol("s0");
2401+ auto s1 = Symbol("s1");
2402+ auto expr = Add(s0, s1);
2403+ Expression target;
2404+ target = std::move(expr);
2405+ EXPECT_EQ(target.IsValid(), true);
2406+ EXPECT_EQ(target, Add(s0, s1));
2407+}
2408+ 
2409+TEST_F(UtestExpression, Expression_CopyConstructor) {
2410+ auto s0 = Symbol("s0");
2411+ auto expr = Add(s0, Symbol(2));
2412+ Expression copied(expr);
2413+ EXPECT_EQ(copied, expr);
2414+}
2415+ 
2416+TEST_F(UtestExpression, Expression_GetName_EmptyImpl) {
2417+ Expression e(nullptr);
2418+ EXPECT_EQ(e.Str().get(), nullptr);
2419+}
2351} // namespace ge2420} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/aligned_ptr_unittest.cc+20-0
@@ -120,4 +120,24 @@ TEST_F(UtestAlignedPtr, BuildFromDataNullDeleter) {
120 EXPECT_EQ(ptr, nullptr);120 EXPECT_EQ(ptr, nullptr);
121 delete[] data;121 delete[] data;
122}122}
123+ 
124+TEST_F(UtestAlignedPtr, BuildFromAllocFuncNullAllocOnly) {
125+ auto deleter = [](uint8_t *ptr) { delete[] ptr; };
126+ auto ptr = AlignedPtr::BuildFromAllocFunc(nullptr, deleter);
127+ EXPECT_EQ(ptr, nullptr);
128+}
129+ 
130+TEST_F(UtestAlignedPtr, ResetWithValidDeleterReturnsOld) {
131+ auto aligned_ptr = MakeShared<AlignedPtr>(100U, 32U);
132+ ASSERT_NE(aligned_ptr, nullptr);
133+ auto old_addr = aligned_ptr->Get();
134+ auto output = aligned_ptr->Reset();
135+ EXPECT_NE(output, nullptr);
136+ EXPECT_EQ(output.get(), old_addr);
137+}
138+ 
139+TEST_F(UtestAlignedPtr, BuildFromDataBothNull) {
140+ auto ptr = AlignedPtr::BuildFromData(nullptr, nullptr);
141+ EXPECT_EQ(ptr, nullptr);
142+}
123} // namespace ge143} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/attr_serializer_registry_unittest.cc+55-0
@@ -13,6 +13,9 @@
13#include <iostream>13#include <iostream>
14#include "graph/serialization/attr_serializer_registry.h"14#include "graph/serialization/attr_serializer_registry.h"
15#include "graph/serialization/string_serializer.h"15#include "graph/serialization/string_serializer.h"
16+#include "graph/buffer.h"
17+#include "graph/ge_tensor.h"
18+#include "graph/ge_attr_value.h"
16 19 
17#include "proto/ge_ir.pb.h"20#include "proto/ge_ir.pb.h"
18#include <string>21#include <string>
@@ -37,4 +40,56 @@ TEST_F(AttrSerializerRegistryUt, IncCov_GetDeserializerUnregistered) {
37TEST_F(AttrSerializerRegistryUt, IncCov_RegistrarWithNullBuilder) {40TEST_F(AttrSerializerRegistryUt, IncCov_RegistrarWithNullBuilder) {
38 AttrSerializerRegistrar registrar(nullptr, GetTypeId<int32_t>(), proto::AttrDef::kI);41 AttrSerializerRegistrar registrar(nullptr, GetTypeId<int32_t>(), proto::AttrDef::kI);
39}42}
43+ 
44+TEST_F(AttrSerializerRegistryUt, AllDeserializersRegistered) {
45+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kB), nullptr);
46+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kBt), nullptr);
47+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kDt), nullptr);
48+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kF), nullptr);
49+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kG), nullptr);
50+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kI), nullptr);
51+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kListListFloat), nullptr);
52+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kListListInt), nullptr);
53+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kList), nullptr);
54+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kFunc), nullptr);
55+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kS), nullptr);
56+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kTd), nullptr);
57+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetDeserializer(proto::AttrDef::kT), nullptr);
58+}
59+ 
60+TEST_F(AttrSerializerRegistryUt, AllSerializersRegistered) {
61+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<bool>()), nullptr);
62+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<ge::Buffer>()), nullptr);
63+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<ge::DataType>()), nullptr);
64+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<float>()), nullptr);
65+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<proto::GraphDef>()), nullptr);
66+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<int64_t>()), nullptr);
67+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<std::vector<float>>>()), nullptr);
68+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<std::vector<int64_t>>>()),
69+ nullptr);
70+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<int64_t>>()), nullptr);
71+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<std::string>>()), nullptr);
72+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<float>>()), nullptr);
73+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<bool>>()), nullptr);
74+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<GeTensorDesc>>()), nullptr);
75+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<GeTensor>>()), nullptr);
76+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<Buffer>>()), nullptr);
77+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<proto::GraphDef>>()), nullptr);
78+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<ge::NamedAttrs>>()), nullptr);
79+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::vector<ge::DataType>>()), nullptr);
80+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<ge::NamedAttrs>()), nullptr);
81+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::string>()), nullptr);
82+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<GeTensorDesc>()), nullptr);
83+ EXPECT_NE(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<GeTensor>()), nullptr);
84+}
85+ 
86+TEST_F(AttrSerializerRegistryUt, GetSerializerUnregistered) {
87+ EXPECT_EQ(AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<int32_t>()), nullptr);
88+}
89+ 
90+TEST_F(AttrSerializerRegistryUt, RegisterDuplicateType) {
91+ REG_GEIR_SERIALIZER(dup_str_ut, ge::StringSerializer, GetTypeId<std::string>(), proto::AttrDef::kS);
92+ GeIrAttrSerializer *serializer = AttrSerializerRegistry::GetInstance().GetSerializer(GetTypeId<std::string>());
93+ ASSERT_NE(serializer, nullptr);
94+}
40} // namespace ge95} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/attr_serializer_unittest.cc+74-0
@@ -13,6 +13,8 @@
13#include <iostream>13#include <iostream>
14#include <string>14#include <string>
15#include <map>15#include <map>
16+ 
17+#define private public
16#include "graph/serialization/attr_serializer_registry.h"18#include "graph/serialization/attr_serializer_registry.h"
17#include "graph/serialization/string_serializer.h"19#include "graph/serialization/string_serializer.h"
18#include "graph/serialization/int_serializer.h"20#include "graph/serialization/int_serializer.h"
@@ -36,6 +38,7 @@
36#include "graph/model_serialize.h"38#include "graph/model_serialize.h"
37#include "graph_builder_utils.h"39#include "graph_builder_utils.h"
38#include "test_std_structs.h"40#include "test_std_structs.h"
41+#undef private
39 42 
40namespace ge {43namespace ge {
41GeTensorPtr CreateTensor_1_1_224_224(float *tensor_data) {44GeTensorPtr CreateTensor_1_1_224_224(float *tensor_data) {
@@ -745,4 +748,75 @@ TEST_F(AttrSerializerUt, IncCov_ListValueSerializerDeserializeListNamedAttrsFail
745 ListValueSerializer serializer;748 ListValueSerializer serializer;
746 EXPECT_EQ(serializer.Deserialize(def, av), GRAPH_FAILED);749 EXPECT_EQ(serializer.Deserialize(def, av), GRAPH_FAILED);
747}750}
751+ 
752+TEST_F(AttrSerializerUt, IncCov_SerializeListIntGetValueFail) {
753+ AnyValue av;
754+ av.SetValue(static_cast<int64_t>(123));
755+ proto::AttrDef def;
756+ EXPECT_EQ(ListValueSerializer::SerializeListInt(av, def), GRAPH_FAILED);
757+}
758+ 
759+TEST_F(AttrSerializerUt, IncCov_SerializeListStringGetValueFail) {
760+ AnyValue av;
761+ av.SetValue(static_cast<int64_t>(123));
762+ proto::AttrDef def;
763+ EXPECT_EQ(ListValueSerializer::SerializeListString(av, def), GRAPH_FAILED);
764+}
765+ 
766+TEST_F(AttrSerializerUt, IncCov_SerializeListFloatGetValueFail) {
767+ AnyValue av;
768+ av.SetValue(static_cast<int64_t>(123));
769+ proto::AttrDef def;
770+ EXPECT_EQ(ListValueSerializer::SerializeListFloat(av, def), GRAPH_FAILED);
771+}
772+ 
773+TEST_F(AttrSerializerUt, IncCov_SerializeListBoolGetValueFail) {
774+ AnyValue av;
775+ av.SetValue(static_cast<int64_t>(123));
776+ proto::AttrDef def;
777+ EXPECT_EQ(ListValueSerializer::SerializeListBool(av, def), GRAPH_FAILED);
778+}
779+ 
780+TEST_F(AttrSerializerUt, IncCov_SerializeListGeTensorDescGetValueFail) {
781+ AnyValue av;
782+ av.SetValue(static_cast<int64_t>(123));
783+ proto::AttrDef def;
784+ EXPECT_EQ(ListValueSerializer::SerializeListGeTensorDesc(av, def), GRAPH_FAILED);
785+}
786+ 
787+TEST_F(AttrSerializerUt, IncCov_SerializeListGeTensorGetValueFail) {
788+ AnyValue av;
789+ av.SetValue(static_cast<int64_t>(123));
790+ proto::AttrDef def;
791+ EXPECT_EQ(ListValueSerializer::SerializeListGeTensor(av, def), GRAPH_FAILED);
792+}
793+ 
794+TEST_F(AttrSerializerUt, IncCov_SerializeListBufferGetValueFail) {
795+ AnyValue av;
796+ av.SetValue(static_cast<int64_t>(123));
797+ proto::AttrDef def;
798+ EXPECT_EQ(ListValueSerializer::SerializeListBuffer(av, def), GRAPH_FAILED);
799+}
800+ 
801+TEST_F(AttrSerializerUt, IncCov_SerializeListGraphDefGetValueFail) {
802+ AnyValue av;
803+ av.SetValue(static_cast<int64_t>(123));
804+ proto::AttrDef def;
805+ EXPECT_EQ(ListValueSerializer::SerializeListGraphDef(av, def), GRAPH_FAILED);
806+}
807+ 
808+TEST_F(AttrSerializerUt, IncCov_SerializeListNamedAttrsGetValueFail) {
809+ REG_GEIR_SERIALIZER(named_attr_serializer, NamedAttrsSerializer, GetTypeId<ge::NamedAttrs>(), proto::AttrDef::kFunc);
810+ AnyValue av;
811+ av.SetValue(static_cast<int64_t>(123));
812+ proto::AttrDef def;
813+ EXPECT_EQ(ListValueSerializer::SerializeListNamedAttrs(av, def), GRAPH_FAILED);
814+}
815+ 
816+TEST_F(AttrSerializerUt, IncCov_SerializeListDataTypeGetValueFail) {
817+ AnyValue av;
818+ av.SetValue(static_cast<int64_t>(123));
819+ proto::AttrDef def;
820+ EXPECT_EQ(ListValueSerializer::SerializeListDataType(av, def), GRAPH_FAILED);
821+}
748} // namespace ge822} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/attributes_holder_unittest.cc+51-0
@@ -357,4 +357,55 @@ TEST_F(AttrHolderUt, CovGetAllAttrsWithFilter) {
357 EXPECT_EQ(filtered.size(), 1U);357 EXPECT_EQ(filtered.size(), 1U);
358 EXPECT_NE(filtered.find("keep_key"), filtered.end());358 EXPECT_NE(filtered.find("keep_key"), filtered.end());
359}359}
360+ 
361+TEST_F(AttrHolderUt, Cov_GeIrProtoHelper_AttrDef_InitDefault) {
362+ GeIrProtoHelper<proto::AttrDef> helper;
363+ helper.InitDefault();
364+ EXPECT_NE(helper.GetProtoMsg(), nullptr);
365+}
366+ 
367+TEST_F(AttrHolderUt, Cov_GeIrProtoHelper_TensorDef_InitDefault) {
368+ GeIrProtoHelper<proto::TensorDef> helper;
369+ helper.InitDefault();
370+ EXPECT_NE(helper.GetProtoMsg(), nullptr);
371+}
372+ 
373+TEST_F(AttrHolderUt, Cov_GeIrProtoHelper_All_InitDefault) {
374+ EXPECT_NO_THROW(GeIrProtoHelper<proto::AttrDef> h1; h1.InitDefault(); GeIrProtoHelper<proto::TensorDef> h2;
375+ h2.InitDefault(); GeIrProtoHelper<proto::TensorDescriptor> h3; h3.InitDefault();
376+ GeIrProtoHelper<proto::ShapeDef> h4; h4.InitDefault(); GeIrProtoHelper<proto::NamedAttrs> h5;
377+ h5.InitDefault(); GeIrProtoHelper<proto::ModelDef> h6; h6.InitDefault();
378+ GeIrProtoHelper<proto::OpDef> h7; h7.InitDefault(); GeIrProtoHelper<proto::GraphDef> h8;
379+ h8.InitDefault(););
380+}
381+ 
382+TEST_F(AttrHolderUt, Cov_TrySetAttr_NewAttr) {
383+ SubAttrHolder holder;
384+ AnyValue av = AnyValue::CreateFrom<int>(42);
385+ EXPECT_EQ(holder.TrySetAttr("new_key", av), GRAPH_SUCCESS);
386+ AnyValue got;
387+ EXPECT_EQ(holder.GetAttr("new_key", got), GRAPH_SUCCESS);
388+}
389+ 
390+TEST_F(AttrHolderUt, Cov_HasAttr_RequiredAttrOnly) {
391+ SubAttrHolder holder;
392+ EXPECT_EQ(holder.AddRequiredAttr("req_only"), GRAPH_SUCCESS);
393+ EXPECT_TRUE(holder.HasAttr("req_only"));
394+ EXPECT_FALSE(holder.HasAttr("nonexistent"));
395+}
396+ 
397+TEST_F(AttrHolderUt, Cov_GetAllAttrs_Empty) {
398+ SubAttrHolder holder;
399+ auto all_attrs = holder.GetAllAttrs();
400+ EXPECT_EQ(all_attrs.size(), 0U);
401+}
402+ 
403+TEST_F(AttrHolderUt, Cov_CopyAttrsFrom_Self) {
404+ SubAttrHolder holder;
405+ AnyValue av = AnyValue::CreateFrom<int>(42);
406+ EXPECT_EQ(holder.SetAttr("self_key", av), GRAPH_SUCCESS);
407+ holder.CopyAttrsFrom(holder);
408+ AnyValue got;
409+ EXPECT_EQ(holder.GetAttr("self_key", got), GRAPH_SUCCESS);
410+}
360} // namespace ge411} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/buffer_unittest.cc+94-0
@@ -391,4 +391,98 @@ TEST_F(BufferUT, Cov_Buffer_FromProtoOwnerString) {
391 ASSERT_NE(const_buf.GetData(), nullptr);391 ASSERT_NE(const_buf.GetData(), nullptr);
392 EXPECT_EQ(const_buf.data()[0], static_cast<uint8_t>('t'));392 EXPECT_EQ(const_buf.data()[0], static_cast<uint8_t>('t'));
393}393}
394+ 
395+TEST_F(BufferUT, Cov_BufferImpl_BadAlloc_LargeSize) {
396+ try {
397+ Buffer buf(std::numeric_limits<size_t>::max(), 0);
398+ EXPECT_EQ(buf.GetSize(), 0UL);
399+ EXPECT_EQ(buf.GetData(), nullptr);
400+ } catch (const std::exception &) {
401+ SUCCEED();
402+ }
403+}
404+ 
405+TEST_F(BufferUT, Cov_BufferImpl_CopyFrom_BadAlloc) {
406+ try {
407+ std::vector<uint8_t> huge(std::numeric_limits<size_t>::max(), 0);
408+ Buffer buf = Buffer::CopyFrom(huge.data(), huge.size());
409+ EXPECT_EQ(buf.GetSize(), 0UL);
410+ } catch (const std::exception &) {
411+ SUCCEED();
412+ }
413+}
414+ 
415+TEST_F(BufferUT, Cov_BufferImpl_CopyConstructor) {
416+ uint8_t data[5] = {1, 2, 3, 4, 5};
417+ BufferImpl impl1;
418+ impl1.CopyFrom(data, sizeof(data));
419+ BufferImpl impl2(impl1);
420+ EXPECT_EQ(impl2.GetSize(), 5UL);
421+ EXPECT_EQ(memcmp(impl2.GetData(), data, sizeof(data)), 0);
422+}
423+ 
424+TEST_F(BufferUT, Cov_BufferImpl_OperatorAssign) {
425+ uint8_t data[5] = {10, 20, 30, 40, 50};
426+ BufferImpl impl1;
427+ impl1.CopyFrom(data, sizeof(data));
428+ BufferImpl impl2;
429+ impl2 = impl1;
430+ EXPECT_EQ(impl2.GetSize(), 5UL);
431+ EXPECT_EQ(memcmp(impl2.GetData(), data, sizeof(data)), 0);
432+}
433+ 
434+TEST_F(BufferUT, Cov_BufferImpl_OperatorAssign_SelfAssign) {
435+ uint8_t data[3] = {1, 2, 3};
436+ BufferImpl impl1;
437+ impl1.CopyFrom(data, sizeof(data));
438+ BufferImpl &ref = impl1;
439+ impl1 = ref;
440+ EXPECT_EQ(impl1.GetSize(), 3UL);
441+}
442+ 
443+TEST_F(BufferUT, Cov_BufferImpl_OperatorIndex_Empty) {
444+ BufferImpl impl;
445+ EXPECT_EQ(impl[0], 0xffU);
446+}
447+ 
448+TEST_F(BufferUT, Cov_BufferImpl_ClearBuffer) {
449+ uint8_t data[5] = {1, 2, 3, 4, 5};
450+ BufferImpl impl;
451+ impl.CopyFrom(data, sizeof(data));
452+ EXPECT_EQ(impl.GetSize(), 5UL);
453+ impl.ClearBuffer();
454+ EXPECT_EQ(impl.GetSize(), 0UL);
455+}
456+ 
457+TEST_F(BufferUT, Cov_BufferImpl_GetDataMutable_WithData) {
458+ uint8_t data[5] = {1, 2, 3, 4, 5};
459+ BufferImpl impl;
460+ impl.CopyFrom(data, sizeof(data));
461+ uint8_t *ptr = impl.GetData();
462+ ASSERT_NE(ptr, nullptr);
463+ ptr[0] = 99;
464+ EXPECT_EQ(impl[0], 99);
465+}
466+ 
467+TEST_F(BufferUT, Cov_BufferImpl_GetDataMutable_EmptyBuffer) {
468+ BufferImpl impl;
469+ EXPECT_EQ(impl.GetData(), nullptr);
470+}
471+ 
472+TEST_F(BufferUT, Cov_Buffer_CopyFrom_WithImpl) {
473+ uint8_t data[5] = {1, 2, 3, 4, 5};
474+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
475+ EXPECT_EQ(buf.GetSize(), 5UL);
476+ EXPECT_NE(buf.GetData(), nullptr);
477+}
478+ 
479+TEST_F(BufferUT, Cov_Buffer_OperatorAssign_OverwriteExisting) {
480+ uint8_t data1[3] = {1, 2, 3};
481+ uint8_t data2[5] = {4, 5, 6, 7, 8};
482+ Buffer buf1 = Buffer::CopyFrom(data1, sizeof(data1));
483+ Buffer buf2 = Buffer::CopyFrom(data2, sizeof(data2));
484+ buf1 = buf2;
485+ EXPECT_EQ(buf1.GetSize(), 5UL);
486+ EXPECT_EQ(buf1[0], 4);
487+}
394} // namespace ge488} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/compile_cache_desc_cov_unittest.cc+155-0
@@ -748,4 +748,159 @@ TEST_F(UtestCompileCacheDescCov, TensorInfoSetShapeRange_Overwrite) {
748 EXPECT_EQ(t.shape_range_.size(), 2U);748 EXPECT_EQ(t.shape_range_.size(), 2U);
749 EXPECT_EQ(t.shape_range_[1].second, 30);749 EXPECT_EQ(t.shape_range_[1].second, 30);
750}750}
751+ 
752+TEST_F(UtestCompileCacheDescCov, BinaryHolderConstructor_NullData) {
753+ BinaryHolder h(nullptr, 10);
754+ EXPECT_EQ(h.GetDataPtr(), nullptr);
755+ EXPECT_EQ(h.GetDataLen(), 0UL);
756+}
757+ 
758+TEST_F(UtestCompileCacheDescCov, BinaryHolderConstructor_ZeroLength) {
759+ uint8_t data = 42;
760+ BinaryHolder h(&data, 0);
761+ EXPECT_EQ(h.GetDataPtr(), nullptr);
762+ EXPECT_EQ(h.GetDataLen(), 0UL);
763+}
764+ 
765+TEST_F(UtestCompileCacheDescCov, BinaryHolderCreateFrom_NullPtr) {
766+ std::unique_ptr<uint8_t[]> null_ptr;
767+ auto holder = BinaryHolder::createFrom(std::move(null_ptr), 10);
768+ ASSERT_NE(holder, nullptr);
769+ EXPECT_EQ(holder->GetDataPtr(), nullptr);
770+ EXPECT_EQ(holder->GetDataLen(), 0UL);
771+}
772+ 
773+TEST_F(UtestCompileCacheDescCov, BinaryHolderCreateFrom_ZeroLength) {
774+ auto ptr = std::unique_ptr<uint8_t[]>(new uint8_t[4]{1, 2, 3, 4});
775+ auto holder = BinaryHolder::createFrom(std::move(ptr), 0);
776+ ASSERT_NE(holder, nullptr);
777+ EXPECT_EQ(holder->GetDataPtr(), nullptr);
778+ EXPECT_EQ(holder->GetDataLen(), 0UL);
779+}
780+ 
781+TEST_F(UtestCompileCacheDescCov, BinaryHolderCopyCtor_FromEmpty) {
782+ BinaryHolder h1;
783+ BinaryHolder h2(h1);
784+ EXPECT_EQ(h2.GetDataPtr(), nullptr);
785+ EXPECT_EQ(h2.GetDataLen(), 0UL);
786+}
787+ 
788+TEST_F(UtestCompileCacheDescCov, BinaryHolderMoveCtor_Empty) {
789+ BinaryHolder h1;
790+ BinaryHolder h2(std::move(h1));
791+ EXPECT_EQ(h2.GetDataPtr(), nullptr);
792+ EXPECT_EQ(h2.GetDataLen(), 0UL);
793+}
794+ 
795+TEST_F(UtestCompileCacheDescCov, BinaryHolderGetDataPtr_NullHolder) {
796+ BinaryHolder h;
797+ EXPECT_EQ(h.GetDataPtr(), nullptr);
798+ EXPECT_EQ(h.GetDataLen(), 0UL);
799+}
800+ 
801+TEST_F(UtestCompileCacheDescCov, IsMatch_NullDesc) {
802+ CompileCacheDescPtr desc1 = std::make_shared<CompileCacheDesc>();
803+ desc1->SetOpType("op_a");
804+ EXPECT_FALSE(desc1->IsMatch(nullptr));
805+}
806+ 
807+TEST_F(UtestCompileCacheDescCov, IsEqual_NullDesc) {
808+ CompileCacheDescPtr desc1 = std::make_shared<CompileCacheDesc>();
809+ desc1->SetOpType("op_a");
810+ EXPECT_FALSE(desc1->IsEqual(nullptr));
811+}
812+ 
813+TEST_F(UtestCompileCacheDescCov, IsMatch_DirectCall_Fail) {
814+ CompileCacheDescPtr desc1 = std::make_shared<CompileCacheDesc>();
815+ desc1->SetOpType("op_a");
816+ TensorInfoArgs t1(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
817+ std::vector<int64_t> s1{1, 2};
818+ t1.SetShape(s1);
819+ t1.SetOriginShape(s1);
820+ desc1->AddTensorInfo(t1);
821+ 
822+ CompileCacheDescPtr desc2 = std::make_shared<CompileCacheDesc>();
823+ desc2->SetOpType("op_b");
824+ TensorInfoArgs t2(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
825+ t2.SetShape(s1);
826+ t2.SetOriginShape(s1);
827+ desc2->AddTensorInfo(t2);
828+ EXPECT_FALSE(desc1->IsMatch(desc2));
829+}
830+ 
831+TEST_F(UtestCompileCacheDescCov, IsEqual_DirectCall_Fail) {
832+ CompileCacheDescPtr desc1 = std::make_shared<CompileCacheDesc>();
833+ desc1->SetOpType("op_a");
834+ TensorInfoArgs t1(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
835+ std::vector<int64_t> s1{1, 2};
836+ t1.SetShape(s1);
837+ t1.SetOriginShape(s1);
838+ desc1->AddTensorInfo(t1);
839+ 
840+ CompileCacheDescPtr desc2 = std::make_shared<CompileCacheDesc>();
841+ desc2->SetOpType("op_b");
842+ TensorInfoArgs t2(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
843+ t2.SetShape(s1);
844+ t2.SetOriginShape(s1);
845+ desc2->AddTensorInfo(t2);
846+ EXPECT_FALSE(desc1->IsEqual(desc2));
847+}
848+ 
849+TEST_F(UtestCompileCacheDescCov, IsEqual_DirectCall_Success) {
850+ CompileCacheDescPtr desc1 = std::make_shared<CompileCacheDesc>();
851+ desc1->SetOpType("op_a");
852+ TensorInfoArgs t1(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
853+ std::vector<int64_t> s1{1, 2};
854+ t1.SetShape(s1);
855+ t1.SetOriginShape(s1);
856+ desc1->AddTensorInfo(t1);
857+ 
858+ CompileCacheDescPtr desc2 = std::make_shared<CompileCacheDesc>();
859+ desc2->SetOpType("op_a");
860+ TensorInfoArgs t2(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
861+ t2.SetShape(s1);
862+ t2.SetOriginShape(s1);
863+ desc2->AddTensorInfo(t2);
864+ EXPECT_TRUE(desc1->IsEqual(desc2));
865+}
866+ 
867+TEST_F(UtestCompileCacheDescCov, CheckWithoutTensorInfo_OpTypeMatch_BinaryMatch_Success) {
868+ CompileCacheDescPtr desc1 = std::make_shared<CompileCacheDesc>();
869+ desc1->SetOpType("op_a");
870+ uint8_t v1 = 1;
871+ BinaryHolder h1(&v1, 1);
872+ desc1->AddBinary(h1);
873+ 
874+ CompileCacheDescPtr desc2 = std::make_shared<CompileCacheDesc>();
875+ desc2->SetOpType("op_a");
876+ uint8_t v2 = 1;
877+ BinaryHolder h2(&v2, 1);
878+ desc2->AddBinary(h2);
879+ EXPECT_TRUE(desc1->IsMatch(desc2));
880+}
881+ 
882+TEST_F(UtestCompileCacheDescCov, TensorInfoMatch_AllShapeMatch) {
883+ TensorInfoArgs t1(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
884+ std::vector<int64_t> shape{-2};
885+ t1.SetShape(shape);
886+ t1.SetOriginShape(shape);
887+ TensorInfoArgs t2(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
888+ std::vector<int64_t> shape2{1, 2};
889+ t2.SetShape(shape2);
890+ t2.SetOriginShape(shape2);
891+ EXPECT_TRUE(t1.IsTensorInfoMatch(t2));
892+}
893+ 
894+TEST_F(UtestCompileCacheDescCov, TensorInfoNeq_DifferentOriginShape) {
895+ TensorInfoArgs t1(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
896+ std::vector<int64_t> s1{1, 2};
897+ t1.SetShape(s1);
898+ std::vector<int64_t> o1{1, 2};
899+ t1.SetOriginShape(o1);
900+ TensorInfoArgs t2(FORMAT_ND, FORMAT_ND, DT_FLOAT16);
901+ t2.SetShape(s1);
902+ std::vector<int64_t> o2{3, 4};
903+ t2.SetOriginShape(o2);
904+ EXPECT_TRUE(t1 != t2);
905+}
751} // namespace ge906} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/compute_graph_unittest.cc+222-0
@@ -28,6 +28,9 @@
28#include "graph/utils/graph_utils_ex.h"28#include "graph/utils/graph_utils_ex.h"
29#include "graph/attribute_group/attr_group_shape_env.h"29#include "graph/attribute_group/attr_group_shape_env.h"
30 30 
31+ge::ComputeGraphPtr GeApiWrapper_MakeComputeGraphPtr(const char *graph_name);
32+size_t GeApiWrapper_GetAllNodesSize(const ge::ComputeGraphPtr &graph_ptr);
33+ 
31namespace {34namespace {
32constexpr const char *kDeterministicAttr = "_deterministic";35constexpr const char *kDeterministicAttr = "_deterministic";
33constexpr const char *kDeterministicLevelAttr = "_deterministic_level";36constexpr const char *kDeterministicLevelAttr = "_deterministic_level";
@@ -2550,4 +2553,223 @@ TEST_F(UtestComputeGraph, IncCov_TopologicalSorting_WithSubgraph) {
2550 graph->AddSubGraph(sub_graph);2553 graph->AddSubGraph(sub_graph);
2551 EXPECT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);2554 EXPECT_EQ(graph->TopologicalSorting(), GRAPH_SUCCESS);
2552}2555}
2556+ 
2557+TEST_F(UtestComputeGraph, IncCov_FindFirstNodeMatchType_NotFound) {
2558+ auto graph = std::make_shared<ComputeGraph>("graph");
2559+ auto op_desc = std::make_shared<OpDesc>("node1", "Data");
2560+ op_desc->AddOutputDesc(GeTensorDesc());
2561+ graph->AddNode(op_desc);
2562+ EXPECT_EQ(graph->FindFirstNodeMatchType("NonExistent"), nullptr);
2563+ EXPECT_NE(graph->FindFirstNodeMatchType("Data"), nullptr);
2564+}
2565+ 
2566+TEST_F(UtestComputeGraph, IncCov_VectorInputNodePtrIsEqual_DifferentNames) {
2567+ auto graph = std::make_shared<ComputeGraph>("graph");
2568+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2569+ op1->AddOutputDesc(GeTensorDesc());
2570+ auto op2 = std::make_shared<OpDesc>("node2", "Data");
2571+ op2->AddOutputDesc(GeTensorDesc());
2572+ auto node1 = graph->AddNode(op1);
2573+ auto node2 = graph->AddNode(op2);
2574+ std::vector<NodePtr> left{node1};
2575+ std::vector<NodePtr> right{node2};
2576+ EXPECT_FALSE(graph->VectorInputNodePtrIsEqual(left, right));
2577+}
2578+ 
2579+TEST_F(UtestComputeGraph, IncCov_AddOutputNodeByIndex_NullNode) {
2580+ auto graph = std::make_shared<ComputeGraph>("graph");
2581+ EXPECT_EQ(graph->AddOutputNodeByIndex(nullptr, 0), nullptr);
2582+ 
2583+ auto op = std::make_shared<OpDesc>("node1", "Data");
2584+ op->AddOutputDesc(GeTensorDesc());
2585+ auto node = graph->AddNode(op);
2586+ auto result = graph->AddOutputNode(node);
2587+ EXPECT_NE(result, nullptr);
2588+ 
2589+ auto result2 = graph->AddOutputNodeByIndex(node, 0);
2590+ EXPECT_NE(result2, nullptr);
2591+}
2592+ 
2593+TEST_F(UtestComputeGraph, IncCov_UpdateInputMapping_WithDataNode) {
2594+ auto graph = std::make_shared<ComputeGraph>("graph");
2595+ auto op = std::make_shared<OpDesc>("data1", DATA);
2596+ op->AddOutputDesc(GeTensorDesc());
2597+ AttrUtils::SetInt(op, ATTR_NAME_PARENT_NODE_INDEX, 0);
2598+ graph->AddNode(op);
2599+ 
2600+ std::map<uint32_t, uint32_t> input_mapping{{0, 5}};
2601+ EXPECT_EQ(graph->UpdateInputMapping(input_mapping), GRAPH_SUCCESS);
2602+ 
2603+ std::map<uint32_t, uint32_t> empty_mapping;
2604+ EXPECT_EQ(graph->UpdateInputMapping(empty_mapping), GRAPH_SUCCESS);
2605+}
2606+ 
2607+TEST_F(UtestComputeGraph, IncCov_UpdateOutputMapping_WithNodeNoNetOutput) {
2608+ auto graph = std::make_shared<ComputeGraph>("graph");
2609+ auto op = std::make_shared<OpDesc>("node1", "Data");
2610+ op->AddOutputDesc(GeTensorDesc());
2611+ graph->AddNode(op);
2612+ 
2613+ std::map<uint32_t, uint32_t> output_mapping{{0, 1}};
2614+ EXPECT_EQ(graph->UpdateOutputMapping(output_mapping), GRAPH_FAILED);
2615+}
2616+ 
2617+TEST_F(UtestComputeGraph, IncCov_SetGraphTargetNodesInfo_NullNode) {
2618+ auto graph = std::make_shared<ComputeGraph>("graph");
2619+ auto op = std::make_shared<OpDesc>("node1", "Data");
2620+ op->AddOutputDesc(GeTensorDesc());
2621+ auto node = graph->AddNode(op);
2622+ 
2623+ std::vector<NodePtr> targets{nullptr, node};
2624+ graph->SetGraphTargetNodesInfo(targets);
2625+ EXPECT_EQ(graph->GetGraphTargetNodesInfo().size(), 2U);
2626+}
2627+ 
2628+TEST_F(UtestComputeGraph, IncCov_GetInEdgeSize_NullNode) {
2629+ auto graph = std::make_shared<ComputeGraph>("graph");
2630+ EXPECT_EQ(graph->GetInEdgeSize(nullptr), 0U);
2631+ EXPECT_EQ(graph->GetOutEdgeSize(nullptr), 0U);
2632+}
2633+ 
2634+TEST_F(UtestComputeGraph, IncCov_Swap_TwoGraphs) {
2635+ auto graph1 = std::make_shared<ComputeGraph>("graph1");
2636+ auto graph2 = std::make_shared<ComputeGraph>("graph2");
2637+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2638+ op1->AddOutputDesc(GeTensorDesc());
2639+ graph1->AddNode(op1);
2640+ 
2641+ graph1->Swap(*graph2);
2642+ EXPECT_EQ(graph1->GetName(), "graph2");
2643+ EXPECT_EQ(graph2->GetName(), "graph1");
2644+ EXPECT_EQ(graph2->GetDirectNodesSize(), 1U);
2645+}
2646+ 
2647+TEST_F(UtestComputeGraph, IncCov_SetUserDefOutput_InvalidFormat) {
2648+ auto graph = std::make_shared<ComputeGraph>("graph");
2649+ graph->SetUserDefOutput("invalidformat");
2650+ graph->SetUserDefOutput("node:abc");
2651+ graph->SetUserDefOutput("node:999999999999999999999999");
2652+ graph->SetUserDefOutput("");
2653+ graph->SetUserDefOutput("node:0");
2654+ graph->SetUserDefOutput("node:0");
2655+ EXPECT_FALSE(graph->GetOutput().empty());
2656+}
2657+ 
2658+TEST_F(UtestComputeGraph, IncCov_AddSubgraph_NullSubgraph) {
2659+ auto graph = std::make_shared<ComputeGraph>("graph");
2660+ EXPECT_EQ(graph->AddSubgraph(std::shared_ptr<ComputeGraph>()), GRAPH_PARAM_INVALID);
2661+ 
2662+ auto sub = std::make_shared<ComputeGraph>("sub");
2663+ EXPECT_NE(graph->AddSubgraph(sub), GRAPH_SUCCESS);
2664+ EXPECT_NE(graph->AddSubgraph(sub->GetName(), sub), GRAPH_SUCCESS);
2665+}
2666+ 
2667+TEST_F(UtestComputeGraph, IncCov_SetGetGraphOpName) {
2668+ auto graph = std::make_shared<ComputeGraph>("graph");
2669+ std::map<uint32_t, std::string> op_name_map{{0, "op0"}, {1, "op1"}};
2670+ graph->SetGraphOpName(op_name_map);
2671+ EXPECT_EQ(graph->GetGraphOpName().size(), 2U);
2672+}
2673+ 
2674+TEST_F(UtestComputeGraph, IncCov_GeApiWrapper_Functions) {
2675+ auto graph = ::GeApiWrapper_MakeComputeGraphPtr("test_graph");
2676+ EXPECT_NE(graph, nullptr);
2677+ EXPECT_EQ(graph->GetName(), "test_graph");
2678+ 
2679+ EXPECT_EQ(::GeApiWrapper_GetAllNodesSize(nullptr), 0U);
2680+ 
2681+ auto op = std::make_shared<OpDesc>("node1", "Data");
2682+ op->AddOutputDesc(GeTensorDesc());
2683+ graph->AddNode(op);
2684+ EXPECT_EQ(::GeApiWrapper_GetAllNodesSize(graph), 1U);
2685+}
2686+ 
2687+TEST_F(UtestComputeGraph, IncCov_GraphMembersAreEqual_Different) {
2688+ auto graph1 = std::make_shared<ComputeGraph>("graph1");
2689+ auto graph2 = std::make_shared<ComputeGraph>("graph2");
2690+ EXPECT_FALSE(graph1->GraphMembersAreEqual(*graph2));
2691+ 
2692+ auto graph3 = std::make_shared<ComputeGraph>("graph1");
2693+ EXPECT_TRUE(graph1->GraphMembersAreEqual(*graph3));
2694+ EXPECT_TRUE(graph1->GraphAttrsAreEqual(*graph3));
2695+}
2696+ 
2697+TEST_F(UtestComputeGraph, IncCov_Dump_Graph) {
2698+ auto graph = std::make_shared<ComputeGraph>("graph");
2699+ auto op = std::make_shared<OpDesc>("node1", "Data");
2700+ op->AddOutputDesc(GeTensorDesc());
2701+ auto node = graph->AddNode(op);
2702+ graph->Dump();
2703+ 
2704+ auto op2 = std::make_shared<OpDesc>("node2", "Data");
2705+ op2->AddOutputDesc(GeTensorDesc());
2706+ auto node2 = graph->AddNode(op2);
2707+ GraphUtils::AddEdge(node->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
2708+ GraphUtils::AddEdge(node->GetOutControlAnchor(), node2->GetInControlAnchor());
2709+ graph->Dump();
2710+}
2711+ 
2712+TEST_F(UtestComputeGraph, IncCov_ReorderByNodeId) {
2713+ auto graph = std::make_shared<ComputeGraph>("graph");
2714+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2715+ op1->AddOutputDesc(GeTensorDesc());
2716+ auto op2 = std::make_shared<OpDesc>("node2", "Data");
2717+ op2->AddOutputDesc(GeTensorDesc());
2718+ graph->AddNode(op2);
2719+ graph->AddNode(op1);
2720+ graph->ReorderByNodeId();
2721+ auto nodes = graph->GetDirectNode();
2722+ EXPECT_EQ(nodes.size(), 2U);
2723+}
2724+ 
2725+TEST_F(UtestComputeGraph, IncCov_IsolateNode_WithEdges) {
2726+ auto graph = std::make_shared<ComputeGraph>("graph");
2727+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2728+ op1->AddOutputDesc(GeTensorDesc());
2729+ auto op2 = std::make_shared<OpDesc>("node2", "Relu");
2730+ op2->AddInputDesc(GeTensorDesc());
2731+ op2->AddOutputDesc(GeTensorDesc());
2732+ auto op3 = std::make_shared<OpDesc>("node3", "Relu");
2733+ op3->AddInputDesc(GeTensorDesc());
2734+ 
2735+ auto node1 = graph->AddNode(op1);
2736+ auto node2 = graph->AddNode(op2);
2737+ auto node3 = graph->AddNode(op3);
2738+ 
2739+ GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
2740+ GraphUtils::AddEdge(node2->GetOutDataAnchor(0), node3->GetInDataAnchor(0));
2741+ 
2742+ EXPECT_EQ(graph->IsolateNode(node2), GRAPH_SUCCESS);
2743+ EXPECT_EQ(node2->GetOutDataNodesSize(), 0U);
2744+}
2745+ 
2746+TEST_F(UtestComputeGraph, IncCov_RemoveExtraOutEdge) {
2747+ auto graph = std::make_shared<ComputeGraph>("graph");
2748+ auto op1 = std::make_shared<OpDesc>("node1", "Data");
2749+ op1->AddOutputDesc(GeTensorDesc());
2750+ auto op2 = std::make_shared<OpDesc>("node2", "Relu");
2751+ op2->AddInputDesc(GeTensorDesc());
2752+ 
2753+ auto node1 = graph->AddNode(op1);
2754+ auto node2 = graph->AddNode(op2);
2755+ 
2756+ GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
2757+ EXPECT_EQ(graph->RemoveExtraOutEdge(node1), GRAPH_SUCCESS);
2758+}
2759+ 
2760+TEST_F(UtestComputeGraph, IncCov_GetNetOutputNode_Null) {
2761+ auto graph = std::make_shared<ComputeGraph>("graph");
2762+ auto op = std::make_shared<OpDesc>("node1", "Data");
2763+ op->AddOutputDesc(GeTensorDesc());
2764+ graph->AddNode(op);
2765+ EXPECT_EQ(graph->GetOrUpdateNetOutputNode(), nullptr);
2766+}
2767+ 
2768+TEST_F(UtestComputeGraph, IncCov_SetNodesOwner) {
2769+ auto graph = std::make_shared<ComputeGraph>("graph");
2770+ auto sub_graph = std::make_shared<ComputeGraph>("sub");
2771+ graph->AddSubGraph(sub_graph);
2772+ graph->SetNodesOwner();
2773+ graph->SetTopParentGraph();
2774+}
2553} // namespace ge2775} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/cov_utils_misc_unittest.cc+121-2
@@ -1,11 +1,27 @@
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+ 
1#include <gtest/gtest.h>11#include <gtest/gtest.h>
2#include <thread>12#include <thread>
3#include <chrono>13#include <chrono>
4#include "graph/utils/graph_thread_pool.h"14#include "graph/utils/graph_thread_pool.h"
5-#include "graph/utils/multi_thread_graph_builder.h"
6-#include "graph/utils/type_utils.h"
7#include "graph/graph.h"15#include "graph/graph.h"
8#include "graph/utils/graph_utils.h"16#include "graph/utils/graph_utils.h"
17+#define private public
18+#define protected public
19+#include "graph/utils/multi_thread_graph_builder.h"
20+#undef private
21+#undef protected
22+#include "graph/utils/type_utils.h"
23+#include "graph/normal_graph/operator_impl.h"
24+#include "graph/debug/ge_util.h"
9 25 
10namespace ge {26namespace ge {
11 27 
@@ -196,4 +212,107 @@ TEST_F(CovUtilsMiscTest, CovMultiThreadGraphBuilderMultipleInputsWithLinks) {
196 SUCCEED();212 SUCCEED();
197}213}
198 214 
215+TEST_F(CovUtilsMiscTest, CovMultiThreadGetGraphRelatedOperators) {
216+ ge::Operator data_op = ge::Operator("CovRelData", "Data");
217+ ge::Operator relu_op = ge::Operator("CovRelRelu", "Relu");
218+ data_op.InputRegister("x");
219+ data_op.OutputRegister("y");
220+ relu_op.InputRegister("x");
221+ relu_op.OutputRegister("y");
222+ relu_op.SetInput(0U, data_op, 0U);
223+ std::vector<ge::Operator> inputs{data_op};
224+ std::vector<OperatorImplPtr> related_ops;
225+ EXPECT_EQ(MultiThreadGraphBuilder::GetGraphRelatedOperators(inputs, related_ops), GRAPH_SUCCESS);
226+ EXPECT_GE(related_ops.size(), 1U);
227+}
228+ 
229+TEST_F(CovUtilsMiscTest, CovMultiThreadGetOutputLinkOps) {
230+ ge::Operator data_op = ge::Operator("CovLinkData", "Data");
231+ ge::Operator relu_op = ge::Operator("CovLinkRelu", "Relu");
232+ data_op.InputRegister("x");
233+ data_op.OutputRegister("y");
234+ relu_op.InputRegister("x");
235+ relu_op.OutputRegister("y");
236+ relu_op.SetInput(0U, data_op, 0U);
237+ relu_op.AddControlInput(data_op);
238+ std::vector<OperatorImplPtr> output_ops;
239+ MultiThreadGraphBuilder::GetOutputLinkOps(data_op.operator_impl_, output_ops);
240+ EXPECT_GE(output_ops.size(), 1U);
241+}
242+ 
243+TEST_F(CovUtilsMiscTest, CovMultiThreadWalkForwardOperators) {
244+ ge::Operator data_op = ge::Operator("CovWalkData", "Data");
245+ ge::Operator relu_op = ge::Operator("CovWalkRelu", "Relu");
246+ ge::Operator add_op = ge::Operator("CovWalkAdd", "Add");
247+ data_op.InputRegister("x");
248+ data_op.OutputRegister("y");
249+ relu_op.InputRegister("x");
250+ relu_op.OutputRegister("y");
251+ add_op.InputRegister("x1");
252+ add_op.InputRegister("x2");
253+ add_op.OutputRegister("y");
254+ relu_op.SetInput(0U, data_op, 0U);
255+ add_op.SetInput(0U, relu_op, 0U);
256+ add_op.SetInput(1U, data_op, 0U);
257+ std::vector<OperatorImplPtr> vec_ops{data_op.operator_impl_};
258+ std::vector<OperatorImplPtr> related_ops;
259+ EXPECT_EQ(MultiThreadGraphBuilder::WalkForwardOperators(vec_ops, related_ops), GRAPH_SUCCESS);
260+ EXPECT_GE(related_ops.size(), 2U);
261+}
262+ 
263+TEST_F(CovUtilsMiscTest, CovMultiThreadResetOpSubgraphBuilderNullBuilder) {
264+ ge::Operator if_op = ge::Operator("CovNullBuilderIf", "If");
265+ if_op.InputRegister("cond");
266+ if_op.DynamicInputRegister("input", 1);
267+ if_op.DynamicOutputRegister("output", 1);
268+ if_op.SubgraphRegister("then_branch", false);
269+ if_op.SubgraphCountRegister("then_branch", 1);
270+ 
271+ MultiThreadGraphBuilder builder(2);
272+ auto op_desc = if_op.operator_impl_->op_desc_;
273+ ASSERT_NE(op_desc, nullptr);
274+ builder.ResetOpSubgraphBuilder(op_desc, if_op.operator_impl_);
275+ SUCCEED();
276+}
277+ 
278+TEST_F(CovUtilsMiscTest, CovMultiThreadSetInputsWithPoolDirectly) {
279+ ge::Operator data_op = ge::Operator("CovPoolData", "Data");
280+ ge::Operator relu_op = ge::Operator("CovPoolRelu", "Relu");
281+ data_op.InputRegister("x");
282+ data_op.OutputRegister("y");
283+ relu_op.InputRegister("x");
284+ relu_op.OutputRegister("y");
285+ relu_op.SetInput(0U, data_op, 0U);
286+ 
287+ MultiThreadGraphBuilder builder(2);
288+ builder.pool_ = ComGraphMakeUnique<GraphThreadPool>(2);
289+ ASSERT_NE(builder.pool_, nullptr);
290+ ge::Graph graph("cov_pool_direct");
291+ std::vector<ge::Operator> inputs{data_op};
292+ auto &result = builder.SetInputs(inputs, graph);
293+ SUCCEED();
294+}
295+ 
296+TEST_F(CovUtilsMiscTest, CovMultiThreadGetGraphRelatedOperatorsEmpty) {
297+ std::vector<ge::Operator> inputs;
298+ std::vector<OperatorImplPtr> related_ops;
299+ EXPECT_EQ(MultiThreadGraphBuilder::GetGraphRelatedOperators(inputs, related_ops), GRAPH_SUCCESS);
300+ EXPECT_EQ(related_ops.size(), 0U);
301+}
302+ 
303+TEST_F(CovUtilsMiscTest, CovMultiThreadWalkForwardOperatorsEmpty) {
304+ std::vector<OperatorImplPtr> vec_ops;
305+ std::vector<OperatorImplPtr> related_ops;
306+ EXPECT_EQ(MultiThreadGraphBuilder::WalkForwardOperators(vec_ops, related_ops), GRAPH_SUCCESS);
307+ EXPECT_EQ(related_ops.size(), 0U);
308+}
309+ 
310+TEST_F(CovUtilsMiscTest, CovMultiThreadGetOutputLinkOpsNoLinks) {
311+ ge::Operator data_op = ge::Operator("CovNoLinkData", "Data");
312+ data_op.InputRegister("x");
313+ data_op.OutputRegister("y");
314+ std::vector<OperatorImplPtr> output_ops;
315+ MultiThreadGraphBuilder::GetOutputLinkOps(data_op.operator_impl_, output_ops);
316+ EXPECT_EQ(output_ops.size(), 0U);
317+}
199} // namespace ge318} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ffts_graph_utils_unittest.cc+301-0
@@ -594,4 +594,305 @@ TEST_F(UtestFftsGraphUtils, CovIsValueInvalid) {
594 std::vector<uint32_t> upper_limit = {8};594 std::vector<uint32_t> upper_limit = {8};
595 ASSERT_FALSE(FftsGraphUtils::IsValueValid(graph, upper_limit, node_value, graph_value));595 ASSERT_FALSE(FftsGraphUtils::IsValueValid(graph, upper_limit, node_value, graph_value));
596}596}
597+ 
598+TEST_F(UtestFftsGraphUtils, CovClipNoInputNode) {
599+ ComputeGraphPtr graph;
600+ ComputeGraphPtr subgraph;
601+ BuildGraphForSplit_without_func_node(graph, subgraph);
602+ const auto &data1 = FindNodeWithNamePattern(subgraph, "data1");
603+ ASSERT_NE(data1, nullptr);
604+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph, {data1}), GRAPH_SUCCESS);
605+}
606+ 
607+TEST_F(UtestFftsGraphUtils, CovCollectClipNullParentNode) {
608+ auto nested_builder = ut::GraphBuilder("nested_sub");
609+ const auto &nested_data = nested_builder.AddNode("nested_data", DATA, 1, 1);
610+ const auto &nested_cast = nested_builder.AddNode("nested_cast", "Cast", 1, 1);
611+ const auto &nested_netoutput = nested_builder.AddNode("nested_netoutput", NETOUTPUT, 1, 0);
612+ nested_builder.AddDataEdge(nested_data, 0, nested_cast, 0);
613+ nested_builder.AddDataEdge(nested_cast, 0, nested_netoutput, 0);
614+ AttrUtils::SetInt(nested_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
615+ AttrUtils::SetInt(nested_netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
616+ auto nested_sub = nested_builder.GetGraph();
617+ AttrUtils::SetStr(nested_sub, "_session_graph_id", "_session_graph_id");
618+ 
619+ auto sub_builder = ut::GraphBuilder("ffts_subgraph");
620+ const auto &data1 = sub_builder.AddNode("data1", DATA, 1, 1);
621+ const auto &nested_func = sub_builder.AddNode("nested_func", PARTITIONEDCALL, 1, 1);
622+ const auto &netoutput = sub_builder.AddNode("netoutput", NETOUTPUT, 1, 0);
623+ sub_builder.AddDataEdge(data1, 0, nested_func, 0);
624+ sub_builder.AddDataEdge(nested_func, 0, netoutput, 0);
625+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
626+ AttrUtils::SetInt(netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
627+ auto subgraph = sub_builder.GetGraph();
628+ AttrUtils::SetStr(subgraph, "_session_graph_id", "_session_graph_id");
629+ 
630+ auto root_builder = ut::GraphBuilder("root");
631+ const auto &input = root_builder.AddNode("input", DATA, 1, 1);
632+ const auto &func_node = root_builder.AddNode("func_node", PARTITIONEDCALL, 1, 1);
633+ const auto &output = root_builder.AddNode("output", NETOUTPUT, 1, 0);
634+ root_builder.AddDataEdge(input, 0, func_node, 0);
635+ root_builder.AddDataEdge(func_node, 0, output, 0);
636+ auto graph = root_builder.GetGraph();
637+ AttrUtils::SetStr(graph, "_session_graph_id", "_session_graph_id");
638+ 
639+ func_node->GetOpDesc()->AddSubgraphName("f");
640+ func_node->GetOpDesc()->SetSubgraphInstanceName(0, subgraph->GetName());
641+ AttrUtils::SetStr(func_node->GetOpDesc(), ATTR_NAME_FFTS_PLUS_SUB_GRAPH, "ffts_plus");
642+ subgraph->SetParentNode(func_node);
643+ subgraph->SetParentGraph(graph);
644+ graph->AddSubGraph(subgraph);
645+ 
646+ nested_func->GetOpDesc()->AddSubgraphName("nf");
647+ nested_func->GetOpDesc()->SetSubgraphInstanceName(0, nested_sub->GetName());
648+ nested_sub->SetParentNode(nested_func);
649+ nested_sub->SetParentGraph(subgraph);
650+ graph->AddSubGraph(nested_sub);
651+ nested_sub->SetParentNode(nullptr);
652+ 
653+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph, {nested_cast}), GRAPH_SUCCESS);
654+}
655+ 
656+TEST_F(UtestFftsGraphUtils, CovCollectEndNodeNoNetoutput) {
657+ auto sub_builder = ut::GraphBuilder("ffts_subgraph");
658+ const auto &data1 = sub_builder.AddNode("data1", DATA, 1, 1);
659+ const auto &cast1 = sub_builder.AddNode("cast1", "Cast", 1, 1);
660+ sub_builder.AddDataEdge(data1, 0, cast1, 0);
661+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
662+ auto subgraph = sub_builder.GetGraph();
663+ AttrUtils::SetStr(subgraph, "_session_graph_id", "_session_graph_id");
664+ 
665+ auto root_builder = ut::GraphBuilder("root");
666+ const auto &input = root_builder.AddNode("input", DATA, 1, 1);
667+ const auto &func_node = root_builder.AddNode("func_node", PARTITIONEDCALL, 1, 1);
668+ const auto &output = root_builder.AddNode("output", NETOUTPUT, 1, 0);
669+ root_builder.AddDataEdge(input, 0, func_node, 0);
670+ root_builder.AddDataEdge(func_node, 0, output, 0);
671+ auto graph = root_builder.GetGraph();
672+ AttrUtils::SetStr(graph, "_session_graph_id", "_session_graph_id");
673+ 
674+ func_node->GetOpDesc()->AddSubgraphName("f");
675+ func_node->GetOpDesc()->SetSubgraphInstanceName(0, subgraph->GetName());
676+ AttrUtils::SetStr(func_node->GetOpDesc(), ATTR_NAME_FFTS_PLUS_SUB_GRAPH, "ffts_plus");
677+ subgraph->SetParentNode(func_node);
678+ subgraph->SetParentGraph(graph);
679+ graph->AddSubGraph(subgraph);
680+ 
681+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph, {cast1}), GRAPH_SUCCESS);
682+}
683+ 
684+TEST_F(UtestFftsGraphUtils, CovCtrlGotoInSubgraph) {
685+ auto sub_builder = ut::GraphBuilder("ffts_subgraph");
686+ const auto &data1 = sub_builder.AddNode("data1", DATA, 1, 1);
687+ const auto &labelgoto1 = sub_builder.AddNode("labelgoto1", LABELGOTOEX, 1, 1);
688+ const auto &cast1 = sub_builder.AddNode("cast1", "Cast", 1, 2);
689+ const auto &labelset1 = sub_builder.AddNode("labelset1", LABELSET, 1, 1);
690+ const auto &labelswitch1 = sub_builder.AddNode("labelswitch1", LABELSWITCHBYINDEX, 1, 1);
691+ const auto &netoutput = sub_builder.AddNode("netoutput", NETOUTPUT, 1, 0);
692+ sub_builder.AddDataEdge(data1, 0, labelgoto1, 0);
693+ sub_builder.AddDataEdge(labelgoto1, 0, cast1, 0);
694+ sub_builder.AddDataEdge(cast1, 0, netoutput, 0);
695+ sub_builder.AddDataEdge(cast1, 1, labelset1, 0);
696+ sub_builder.AddDataEdge(labelset1, 0, labelswitch1, 0);
697+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
698+ AttrUtils::SetInt(netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
699+ auto subgraph = sub_builder.GetGraph();
700+ AttrUtils::SetStr(subgraph, "_session_graph_id", "_session_graph_id");
701+ 
702+ auto root_builder = ut::GraphBuilder("root");
703+ const auto &input = root_builder.AddNode("input", DATA, 1, 1);
704+ const auto &func_node = root_builder.AddNode("func_node", PARTITIONEDCALL, 1, 1);
705+ const auto &output = root_builder.AddNode("output", NETOUTPUT, 1, 0);
706+ root_builder.AddDataEdge(input, 0, func_node, 0);
707+ root_builder.AddDataEdge(func_node, 0, output, 0);
708+ auto graph = root_builder.GetGraph();
709+ AttrUtils::SetStr(graph, "_session_graph_id", "_session_graph_id");
710+ 
711+ func_node->GetOpDesc()->AddSubgraphName("f");
712+ func_node->GetOpDesc()->SetSubgraphInstanceName(0, subgraph->GetName());
713+ AttrUtils::SetStr(func_node->GetOpDesc(), ATTR_NAME_FFTS_PLUS_SUB_GRAPH, "ffts_plus");
714+ subgraph->SetParentNode(func_node);
715+ subgraph->SetParentGraph(graph);
716+ graph->AddSubGraph(subgraph);
717+ 
718+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph, {cast1}), GRAPH_SUCCESS);
719+}
720+ 
721+TEST_F(UtestFftsGraphUtils, CovGetFftsPlusGraphSubgraphCountMismatch) {
722+ auto sub1_builder = ut::GraphBuilder("sub1");
723+ sub1_builder.AddNode("data1", DATA, 1, 1);
724+ auto subgraph1 = sub1_builder.GetGraph();
725+ AttrUtils::SetStr(subgraph1, "_session_graph_id", "_session_graph_id");
726+ 
727+ auto sub2_builder = ut::GraphBuilder("sub2");
728+ sub2_builder.AddNode("data2", DATA, 1, 1);
729+ auto subgraph2 = sub2_builder.GetGraph();
730+ AttrUtils::SetStr(subgraph2, "_session_graph_id", "_session_graph_id");
731+ 
732+ auto root_builder = ut::GraphBuilder("root");
733+ const auto &func_node = root_builder.AddNode("func", PARTITIONEDCALL, 1, 1);
734+ auto graph = root_builder.GetGraph();
735+ AttrUtils::SetStr(graph, "_session_graph_id", "_session_graph_id");
736+ 
737+ func_node->GetOpDesc()->AddSubgraphName("f1");
738+ func_node->GetOpDesc()->SetSubgraphInstanceName(0, subgraph1->GetName());
739+ func_node->GetOpDesc()->AddSubgraphName("f2");
740+ func_node->GetOpDesc()->SetSubgraphInstanceName(1, subgraph2->GetName());
741+ subgraph1->SetParentNode(func_node);
742+ subgraph1->SetParentGraph(graph);
743+ subgraph2->SetParentNode(func_node);
744+ subgraph2->SetParentGraph(graph);
745+ graph->AddSubGraph(subgraph1);
746+ graph->AddSubGraph(subgraph2);
747+ 
748+ const auto &calc_func = [](const NodePtr &n) { return std::vector<uint32_t>{1}; };
749+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph1, calc_func, {8}), PARAM_INVALID);
750+}
751+ 
752+TEST_F(UtestFftsGraphUtils, CovGraphPartitionValueInvalid) {
753+ ComputeGraphPtr graph;
754+ ComputeGraphPtr subgraph;
755+ BuildGraphForSplit_without_func_node(graph, subgraph);
756+ const auto &calc_func = [](const NodePtr &n) { return std::vector<uint32_t>{1, 2}; };
757+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph, calc_func, {8}), GRAPH_FAILED);
758+}
759+ 
760+TEST_F(UtestFftsGraphUtils, CovCalculateFuncNodeFailed) {
761+ auto s1_builder = ut::GraphBuilder("s1");
762+ const auto &s1_data = s1_builder.AddNode("s1_data", DATA, 1, 1);
763+ const auto &s1_netoutput = s1_builder.AddNode("s1_netoutput", NETOUTPUT, 1, 0);
764+ s1_builder.AddDataEdge(s1_data, 0, s1_netoutput, 0);
765+ AttrUtils::SetInt(s1_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
766+ AttrUtils::SetInt(s1_netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
767+ auto s1 = s1_builder.GetGraph();
768+ AttrUtils::SetStr(s1, "_session_graph_id", "_session_graph_id");
769+ 
770+ auto s2_builder = ut::GraphBuilder("s2");
771+ const auto &s2_data = s2_builder.AddNode("s2_data", DATA, 1, 1);
772+ const auto &s2_netoutput = s2_builder.AddNode("s2_netoutput", NETOUTPUT, 1, 0);
773+ s2_builder.AddDataEdge(s2_data, 0, s2_netoutput, 0);
774+ AttrUtils::SetInt(s2_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
775+ AttrUtils::SetInt(s2_netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
776+ auto s2 = s2_builder.GetGraph();
777+ AttrUtils::SetStr(s2, "_session_graph_id", "_session_graph_id");
778+ 
779+ auto main_builder = ut::GraphBuilder("main");
780+ const auto &main_data = main_builder.AddNode("main_data", DATA, 1, 1);
781+ const auto &nested_func = main_builder.AddNode("nested_func", "If", 2, 1);
782+ const auto &main_netoutput = main_builder.AddNode("main_netoutput", NETOUTPUT, 1, 0);
783+ main_builder.AddDataEdge(main_data, 0, nested_func, 0);
784+ main_builder.AddDataEdge(nested_func, 0, main_netoutput, 0);
785+ AttrUtils::SetInt(main_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
786+ AttrUtils::SetInt(main_netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
787+ auto main_graph = main_builder.GetGraph();
788+ AttrUtils::SetStr(main_graph, "_session_graph_id", "_session_graph_id");
789+ 
790+ nested_func->GetOpDesc()->AddSubgraphName("then");
791+ nested_func->GetOpDesc()->SetSubgraphInstanceName(0, s1->GetName());
792+ nested_func->GetOpDesc()->AddSubgraphName("else");
793+ nested_func->GetOpDesc()->SetSubgraphInstanceName(1, s2->GetName());
794+ s1->SetParentNode(nested_func);
795+ s1->SetParentGraph(main_graph);
796+ s2->SetParentNode(nested_func);
797+ s2->SetParentGraph(main_graph);
798+ main_graph->AddSubGraph(s1);
799+ main_graph->AddSubGraph(s2);
800+ 
801+ const auto &calc_func = [](const NodePtr &n) {
802+ if (n->GetName().find("s1_") == 0U) {
803+ return std::vector<uint32_t>{1};
804+ }
805+ return std::vector<uint32_t>{1, 2};
806+ };
807+ 
808+ std::map<NodePtr, std::vector<uint32_t>> node_value;
809+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
810+ ASSERT_EQ(FftsGraphUtils::Calculate(main_graph, calc_func, node_value, graph_value, 1), GRAPH_FAILED);
811+}
812+ 
813+TEST_F(UtestFftsGraphUtils, CovCalculateSubgraphFailed) {
814+ auto s_builder = ut::GraphBuilder("s");
815+ const auto &s_data = s_builder.AddNode("s_data", DATA, 1, 1);
816+ const auto &s_cast = s_builder.AddNode("s_cast", "Cast", 1, 1);
817+ const auto &s_netoutput = s_builder.AddNode("s_netoutput", NETOUTPUT, 1, 0);
818+ s_builder.AddDataEdge(s_data, 0, s_cast, 0);
819+ s_builder.AddDataEdge(s_cast, 0, s_netoutput, 0);
820+ AttrUtils::SetInt(s_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
821+ AttrUtils::SetInt(s_netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
822+ auto s_graph = s_builder.GetGraph();
823+ AttrUtils::SetStr(s_graph, "_session_graph_id", "_session_graph_id");
824+ 
825+ auto main_builder = ut::GraphBuilder("main");
826+ const auto &main_data = main_builder.AddNode("main_data", DATA, 1, 1);
827+ const auto &nested_func = main_builder.AddNode("nested_func", PARTITIONEDCALL, 1, 1);
828+ const auto &main_netoutput = main_builder.AddNode("main_netoutput", NETOUTPUT, 1, 0);
829+ main_builder.AddDataEdge(main_data, 0, nested_func, 0);
830+ main_builder.AddDataEdge(nested_func, 0, main_netoutput, 0);
831+ AttrUtils::SetInt(main_data->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
832+ AttrUtils::SetInt(main_netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
833+ auto main_graph = main_builder.GetGraph();
834+ AttrUtils::SetStr(main_graph, "_session_graph_id", "_session_graph_id");
835+ 
836+ nested_func->GetOpDesc()->AddSubgraphName("f");
837+ nested_func->GetOpDesc()->SetSubgraphInstanceName(0, s_graph->GetName());
838+ s_graph->SetParentNode(nested_func);
839+ s_graph->SetParentGraph(main_graph);
840+ main_graph->AddSubGraph(s_graph);
841+ 
842+ const auto &calc_func = [](const NodePtr &n) {
843+ if (n->GetName() == "s_data") {
844+ return std::vector<uint32_t>{1};
845+ }
846+ return std::vector<uint32_t>{1, 2};
847+ };
848+ 
849+ std::map<NodePtr, std::vector<uint32_t>> node_value;
850+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
851+ ASSERT_EQ(FftsGraphUtils::Calculate(main_graph, calc_func, node_value, graph_value, 1), GRAPH_FAILED);
852+}
853+ 
854+TEST_F(UtestFftsGraphUtils, CovBuildFftsPlusSubgraphEmptyCalcNodes) {
855+ auto sub_builder = ut::GraphBuilder("subgraph");
856+ const auto &data1 = sub_builder.AddNode("data1", DATA, 1, 1);
857+ const auto &netoutput = sub_builder.AddNode("netoutput", NETOUTPUT, 1, 0);
858+ sub_builder.AddDataEdge(data1, 0, netoutput, 0);
859+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
860+ AttrUtils::SetInt(netoutput->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
861+ auto subgraph = sub_builder.GetGraph();
862+ AttrUtils::SetStr(subgraph, "_session_graph_id", "_session_graph_id");
863+ 
864+ ASSERT_EQ(FftsGraphUtils::BuildFftsPlusSubgraphWithAllNodes(subgraph), GRAPH_FAILED);
865+}
866+ 
867+TEST_F(UtestFftsGraphUtils, CovIsValueValidGraphValueMissing) {
868+ ComputeGraphPtr graph;
869+ ComputeGraphPtr subgraph;
870+ BuildGraphForSplit_without_func_node(graph, subgraph);
871+ std::map<NodePtr, std::vector<uint32_t>> node_value;
872+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
873+ graph_value[graph] = {1};
874+ ASSERT_FALSE(FftsGraphUtils::IsValueValid(graph, {1}, node_value, graph_value));
875+}
876+ 
877+TEST_F(UtestFftsGraphUtils, CovIsValueValidNodeValueMissing) {
878+ ComputeGraphPtr graph;
879+ ComputeGraphPtr subgraph;
880+ BuildGraphForSplit_without_func_node(graph, subgraph);
881+ std::map<NodePtr, std::vector<uint32_t>> node_value;
882+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
883+ graph_value[graph] = {1};
884+ graph_value[subgraph] = {1};
885+ ASSERT_FALSE(FftsGraphUtils::IsValueValid(graph, {1}, node_value, graph_value));
886+}
887+ 
888+TEST_F(UtestFftsGraphUtils, CovIsValueValidGraphSizeMismatch) {
889+ auto builder = ut::GraphBuilder("root");
890+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
891+ auto graph = builder.GetGraph();
892+ std::map<NodePtr, std::vector<uint32_t>> node_value;
893+ node_value[node1] = {1};
894+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
895+ graph_value[graph] = {1, 2};
896+ ASSERT_FALSE(FftsGraphUtils::IsValueValid(graph, {8}, node_value, graph_value));
897+}
597} // namespace ge898} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/file_utils_unittest.cc+120-0
@@ -146,4 +146,124 @@ TEST_F(UtestFileUtils, GetSanitizedNameCase0) {
146 std::string file_name = "ge_proto_a/b\\c";146 std::string file_name = "ge_proto_a/b\\c";
147 ASSERT_EQ(GetRegulatedName(file_name), "ge_proto_a_b_c");147 ASSERT_EQ(GetRegulatedName(file_name), "ge_proto_a_b_c");
148}148}
149+ 
150+TEST_F(UtestFileUtils, WriteBinToFileFdNullData) {
151+ ASSERT_EQ(WriteBinToFile(1, nullptr, 10), GRAPH_FAILED);
152+}
153+ 
154+TEST_F(UtestFileUtils, WriteBinToFileFdZeroLen) {
155+ char data[4] = {'1', '2', '3'};
156+ ASSERT_EQ(WriteBinToFile(1, reinterpret_cast<char_t *>(data), 0), GRAPH_FAILED);
157+}
158+ 
159+TEST_F(UtestFileUtils, SaveBinToFileNullData) {
160+ ASSERT_EQ(SaveBinToFile(nullptr, 10, "./test_file_for_ut.bin"), GRAPH_FAILED);
161+}
162+ 
163+TEST_F(UtestFileUtils, SaveBinToFileZeroLen) {
164+ char data[4] = {'1', '2', '3'};
165+ ASSERT_EQ(SaveBinToFile(data, 0, "./test_file_for_ut.bin"), GRAPH_FAILED);
166+}
167+ 
168+TEST_F(UtestFileUtils, GetBinDataFromFileNotOpen) {
169+ uint32_t data_len = 0;
170+ ASSERT_EQ(GetBinDataFromFile("./nonexistent_file_for_ut.bin", data_len), nullptr);
171+}
172+ 
173+TEST_F(UtestFileUtils, GetBinFromFileBufferNotOpen) {
174+ std::string dir_path = "./test_dir_for_ut_buffernotopen";
175+ system(("mkdir -p " + dir_path).c_str());
176+ size_t data_len = 10;
177+ char buffer[10];
178+ ASSERT_EQ(GetBinFromFile(dir_path, buffer, data_len), GRAPH_FAILED);
179+ system(("rmdir " + dir_path).c_str());
180+}
181+ 
182+TEST_F(UtestFileUtils, WriteBinToFileOpenFail) {
183+ std::string dir_path = "./test_dir_for_ut_openfail";
184+ system(("mkdir -p " + dir_path).c_str());
185+ std::string subdir = dir_path + "/subdir";
186+ system(("mkdir -p " + subdir).c_str());
187+ uint32_t data_len = 4;
188+ char data[4] = {'1', '2', '3'};
189+ ASSERT_EQ(WriteBinToFile(subdir, data, data_len), GRAPH_FAILED);
190+ system(("rmdir " + subdir).c_str());
191+ system(("rmdir " + dir_path).c_str());
192+}
193+ 
194+TEST_F(UtestFileUtils, CreateDirFailUnderFile) {
195+ std::string file_path = "./test_file_for_ut_createdir";
196+ system(("touch " + file_path).c_str());
197+ std::string dir_path = file_path + "/subdir";
198+ int32_t ret = ge::CreateDir(dir_path);
199+ EXPECT_NE(ret, 0);
200+ system(("rm -f " + file_path).c_str());
201+}
202+ 
203+TEST_F(UtestFileUtils, ScandirInvalidPath) {
204+ mmDirent **entry_list = nullptr;
205+ int32_t count = Scandir("/nonexistent_path_for_ut_12345", &entry_list, nullptr, nullptr);
206+ EXPECT_LT(count, 0);
207+}
208+ 
209+TEST_F(UtestFileUtils, GetAscendWorkPathInvalid) {
210+ setenv("ASCEND_WORK_PATH", "/dev/null/invalid_path_for_ut", 1);
211+ std::string work_path;
212+ Status ret = GetAscendWorkPath(work_path);
213+ EXPECT_EQ(ret, FAILED);
214+ unsetenv("ASCEND_WORK_PATH");
215+}
216+ 
217+TEST_F(UtestFileUtils, GetAscendWorkPathNotSet) {
218+ unsetenv("ASCEND_WORK_PATH");
219+ std::string work_path;
220+ Status ret = GetAscendWorkPath(work_path);
221+ EXPECT_EQ(ret, SUCCESS);
222+ EXPECT_EQ(work_path, "");
223+}
224+ 
225+TEST_F(UtestFileUtils, CreateDirEExist) {
226+ std::string dir_path = "./test_dir_for_ut_eexist";
227+ system(("mkdir -p " + dir_path).c_str());
228+ int32_t ret = ge::CreateDir(dir_path);
229+ EXPECT_EQ(ret, 0);
230+ system(("rmdir " + dir_path).c_str());
231+}
232+ 
233+TEST_F(UtestFileUtils, GetSanitizedNameTest) {
234+ std::string input = "file:/name\\with*bad?chars";
235+ std::string result = GetSanitizedName(input);
236+ EXPECT_EQ(result.find('/'), std::string::npos);
237+ EXPECT_EQ(result.find('\\'), std::string::npos);
238+ EXPECT_EQ(result.find(':'), std::string::npos);
239+ EXPECT_EQ(result.find('*'), std::string::npos);
240+ EXPECT_EQ(result.find('?'), std::string::npos);
241+}
242+ 
243+TEST_F(UtestFileUtils, SplitFilePathTest) {
244+ std::string dir_path;
245+ std::string file_name;
246+ SplitFilePath("/a/b/c.txt", dir_path, file_name);
247+ EXPECT_EQ(dir_path, "/a/b");
248+ EXPECT_EQ(file_name, "c.txt");
249+ 
250+ dir_path.clear();
251+ file_name.clear();
252+ SplitFilePath("filename_only", dir_path, file_name);
253+ EXPECT_EQ(dir_path, "");
254+ EXPECT_EQ(file_name, "filename_only");
255+ 
256+ dir_path.clear();
257+ file_name.clear();
258+ SplitFilePath("", dir_path, file_name);
259+ EXPECT_EQ(dir_path, "");
260+ EXPECT_EQ(file_name, "");
261+}
262+ 
263+TEST_F(UtestFileUtils, CreateDirectoryTest) {
264+ std::string dir_path = "./test_dir_for_ut_createdir_func";
265+ int32_t ret = ge::CreateDirectory(dir_path);
266+ EXPECT_EQ(ret, 0);
267+ system(("rmdir " + dir_path).c_str());
268+}
149} // namespace ge269} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/format_refiner_unittes.cc+112-0
@@ -1183,4 +1183,116 @@ TEST_F(UTEST_FormatRefiner, IncCov_DataNodeFormatProcess_SetFormatForUninferred)
1183 SetFirstInferFlag(graph, true);1183 SetFirstInferFlag(graph, true);
1184 graph->SaveDataFormat(FORMAT_ND);1184 graph->SaveDataFormat(FORMAT_ND);
1185}1185}
1186+ 
1187+ut::GraphBuilder BuildGraphBiasAddNCHW5D() {
1188+ auto builder = ut::GraphBuilder("g_biasadd_nchw_5d");
1189+ auto var = builder.AddNode("var", "Variable", 0, 1);
1190+ auto square = builder.AddNode("square", "Square", 1, 1);
1191+ auto biasadd = builder.AddNode("biasadd", "BiasAdd", 1, 1);
1192+ auto netoutput1 = builder.AddNode("netoutput1", "NetOutput", 1, 0);
1193+ 
1194+ auto biasadd_data = biasadd->GetOpDesc()->GetInputDesc(0);
1195+ biasadd_data.SetFormat(FORMAT_NCHW);
1196+ biasadd_data.SetOriginFormat(FORMAT_NCHW);
1197+ biasadd_data.SetShape(GeShape(std::vector<int64_t>({1, 3, 3, 224, 224})));
1198+ biasadd->GetOpDesc()->UpdateInputDesc(0, biasadd_data);
1199+ auto biasadd_out = biasadd->GetOpDesc()->GetOutputDesc(0);
1200+ biasadd_out.SetFormat(FORMAT_NCHW);
1201+ biasadd_out.SetOriginFormat(FORMAT_NCHW);
1202+ biasadd_out.SetShape(GeShape(std::vector<int64_t>({1, 3, 256, 224, 224})));
1203+ biasadd->GetOpDesc()->UpdateOutputDesc(0, biasadd_out);
1204+ 
1205+ builder.AddDataEdge(var, 0, square, 0);
1206+ builder.AddDataEdge(square, 0, biasadd, 0);
1207+ builder.AddDataEdge(biasadd, 0, netoutput1, 0);
1208+ SetFirstInferFlag(builder.GetGraph(), true);
1209+ return builder;
1210+}
1211+ 
1212+TEST_F(UTEST_FormatRefiner, IncCov_BiasAddFormatFixProcess_NCHW_5D) {
1213+ auto builder = BuildGraphBiasAddNCHW5D();
1214+ auto graph = builder.GetGraph();
1215+ SetFirstInferFlag(graph, false);
1216+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1217+ auto biasadd = graph->FindNode("biasadd");
1218+ EXPECT_EQ(biasadd->GetOpDesc()->GetInputDesc(0).GetOriginFormat(), FORMAT_NCDHW);
1219+ EXPECT_EQ(biasadd->GetOpDesc()->GetOutputDesc(0).GetOriginFormat(), FORMAT_NCDHW);
1220+ SetFirstInferFlag(graph, true);
1221+}
1222+ 
1223+TEST_F(UTEST_FormatRefiner, IncCov_DataNodeFormatProcess_AlreadyInferredDataNode) {
1224+ auto builder = BuildGraphDataNode4D();
1225+ auto graph = builder.GetGraph();
1226+ SetFirstInferFlag(graph, false);
1227+ graph->SaveDataFormat(FORMAT_NCHW);
1228+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1229+ auto data1 = graph->FindNode("data1");
1230+ EXPECT_EQ(data1->GetOpDesc()->GetOutputDesc(0).GetOriginFormat(), FORMAT_NCHW);
1231+ SetFirstInferFlag(graph, false);
1232+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1233+ SetFirstInferFlag(graph, true);
1234+ graph->SaveDataFormat(FORMAT_ND);
1235+}
1236+ 
1237+TEST_F(UTEST_FormatRefiner, IncCov_InferOrigineFormat_AlreadyInferredGraph) {
1238+ auto builder = BuildGraph1();
1239+ auto graph = builder.GetGraph();
1240+ SetFirstInferFlag(graph, false);
1241+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1242+ EXPECT_EQ(FormatRefiner::IsGraphInferred(graph), true);
1243+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1244+ SetFirstInferFlag(graph, true);
1245+}
1246+ 
1247+TEST_F(UTEST_FormatRefiner, IncCov_IsGraphInferred) {
1248+ auto builder = BuildGraph1();
1249+ auto graph = builder.GetGraph();
1250+ SetFirstInferFlag(graph, true);
1251+ EXPECT_EQ(FormatRefiner::IsGraphInferred(graph), false);
1252+ SetFirstInferFlag(graph, false);
1253+ EXPECT_EQ(FormatRefiner::IsGraphInferred(graph), true);
1254+ SetFirstInferFlag(graph, true);
1255+}
1256+ 
1257+TEST_F(UTEST_FormatRefiner, IncCov_BiasAddFormatFixProcess_LessThan4Dims_Output) {
1258+ auto builder = ut::GraphBuilder("g_biasadd_lt4_out");
1259+ auto data1 = builder.AddNode("data1", "Data", 1, 1, FORMAT_ND, DT_FLOAT, {3, 224});
1260+ auto biasadd = builder.AddNode("biasadd", "BiasAdd", 1, 1, FORMAT_NCHW, DT_FLOAT, {3, 224});
1261+ auto netoutput1 = builder.AddNode("netoutput1", "NetOutput", 1, 0, FORMAT_ND, DT_FLOAT, {3, 224});
1262+ auto biasadd_out = biasadd->GetOpDesc()->GetOutputDesc(0);
1263+ biasadd_out.SetOriginFormat(FORMAT_NCHW);
1264+ biasadd_out.SetShape(GeShape(std::vector<int64_t>({3, 224})));
1265+ biasadd->GetOpDesc()->UpdateOutputDesc(0, biasadd_out);
1266+ builder.AddDataEdge(data1, 0, biasadd, 0);
1267+ builder.AddDataEdge(biasadd, 0, netoutput1, 0);
1268+ SetFirstInferFlag(builder.GetGraph(), true);
1269+ auto graph = builder.GetGraph();
1270+ SetFirstInferFlag(graph, false);
1271+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1272+ auto biasadd_node = graph->FindNode("biasadd");
1273+ EXPECT_EQ(biasadd_node->GetOpDesc()->GetOutputDesc(0).GetOriginFormat(), FORMAT_NCHW);
1274+ SetFirstInferFlag(graph, true);
1275+}
1276+ 
1277+TEST_F(UTEST_FormatRefiner, IncCov_DataNodeFormatProcess_NDFormat) {
1278+ auto builder = BuildGraphDataNode4D();
1279+ auto graph = builder.GetGraph();
1280+ SetFirstInferFlag(graph, false);
1281+ graph->SaveDataFormat(FORMAT_ND);
1282+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1283+ auto data1 = graph->FindNode("data1");
1284+ EXPECT_EQ(data1->GetOpDesc()->GetOutputDesc(0).GetOriginFormat(), FORMAT_ND);
1285+ SetFirstInferFlag(graph, true);
1286+ graph->SaveDataFormat(FORMAT_ND);
1287+}
1288+ 
1289+TEST_F(UTEST_FormatRefiner, IncCov_DataNodeFormatProcess_InternalFormat) {
1290+ auto builder = BuildGraphDataNode4D();
1291+ auto graph = builder.GetGraph();
1292+ SetFirstInferFlag(graph, false);
1293+ graph->SaveDataFormat(FORMAT_FRACTAL_Z);
1294+ EXPECT_EQ(FormatRefiner::InferOrigineFormat(graph), GRAPH_SUCCESS);
1295+ SetFirstInferFlag(graph, true);
1296+ graph->SaveDataFormat(FORMAT_ND);
1297+}
1186} // namespace ge1298} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ge_attr_value_unittest.cc+127-0
@@ -16,6 +16,7 @@
16#include "graph/tensor.h"16#include "graph/tensor.h"
17#include "graph/ascend_string.h"17#include "graph/ascend_string.h"
18#include "graph/types.h"18#include "graph/types.h"
19+#include "graph/compute_graph.h"
19#include <string>20#include <string>
20#include <limits>21#include <limits>
21#include <functional>22#include <functional>
@@ -729,4 +730,130 @@ TEST_F(UtestGeAttrValue, IncCov_NamedAttrsGetItem) {
729 auto item2 = named_attrs.GetItem("nonexistent");730 auto item2 = named_attrs.GetItem("nonexistent");
730 EXPECT_TRUE(item2.IsEmpty());731 EXPECT_TRUE(item2.IsEmpty());
731}732}
733+ 
734+TEST_F(UtestGeAttrValue, IncCov_SetListIntWithUint32AndInitList) {
735+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
736+ 
737+ std::vector<uint32_t> u32_vals = {1, 2, 3};
738+ EXPECT_TRUE(AttrUtils::SetListInt(op_desc, "u32_list", u32_vals));
739+ std::vector<int64_t> i64_out;
740+ EXPECT_TRUE(AttrUtils::GetListInt(op_desc, "u32_list", i64_out));
741+ EXPECT_EQ(i64_out.size(), 3U);
742+ 
743+ std::vector<int32_t> i32_vals = {10, 20};
744+ EXPECT_TRUE(AttrUtils::SetListInt(op_desc, "i32_list", i32_vals));
745+ std::vector<int32_t> i32_out;
746+ EXPECT_TRUE(AttrUtils::GetListInt(op_desc, "i32_list", i32_out));
747+ EXPECT_EQ(i32_out.size(), 2U);
748+ 
749+ EXPECT_TRUE(AttrUtils::SetListInt(op_desc, "init_list", {static_cast<int64_t>(100), static_cast<int64_t>(200)}));
750+ std::vector<uint32_t> u32_out;
751+ EXPECT_TRUE(AttrUtils::GetListInt(op_desc, "init_list", u32_out));
752+ EXPECT_EQ(u32_out.size(), 2U);
753+}
754+ 
755+TEST_F(UtestGeAttrValue, IncCov_TensorAttrOperations) {
756+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
757+ 
758+ GeTensor tensor(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
759+ EXPECT_TRUE(AttrUtils::SetTensor(op_desc, "tensor_attr", tensor));
760+ 
761+ GeTensorPtr tensor_ptr = std::make_shared<GeTensor>(tensor);
762+ EXPECT_TRUE(AttrUtils::SetTensor(op_desc, "tensor_ptr_attr", tensor_ptr));
763+ 
764+ ConstGeTensorPtr const_tensor_ptr = std::make_shared<const GeTensor>(tensor);
765+ EXPECT_TRUE(AttrUtils::SetTensor(op_desc, "const_tensor_ptr_attr", const_tensor_ptr));
766+ 
767+ EXPECT_TRUE(AttrUtils::SetShareTensor(op_desc, "share_tensor_attr", tensor));
768+ 
769+ ConstGeTensorPtr get_tensor;
770+ EXPECT_TRUE(AttrUtils::GetTensor(op_desc, "tensor_attr", get_tensor));
771+ EXPECT_NE(get_tensor, nullptr);
772+ 
773+ GeTensorPtr mutable_tensor;
774+ EXPECT_TRUE(AttrUtils::MutableTensor(op_desc, "tensor_attr", mutable_tensor));
775+ EXPECT_NE(mutable_tensor, nullptr);
776+ 
777+ std::vector<GeTensor> tensor_vec = {tensor, tensor};
778+ EXPECT_TRUE(AttrUtils::SetListTensor(op_desc, "tensor_list", tensor_vec));
779+ 
780+ std::vector<GeTensorPtr> tensor_ptr_vec = {tensor_ptr, tensor_ptr};
781+ EXPECT_TRUE(AttrUtils::SetListTensor(op_desc, "tensor_ptr_list", tensor_ptr_vec));
782+ 
783+ std::vector<ConstGeTensorPtr> const_tensor_ptr_vec = {const_tensor_ptr, const_tensor_ptr};
784+ EXPECT_TRUE(AttrUtils::SetListTensor(op_desc, "const_tensor_ptr_list", const_tensor_ptr_vec));
785+ 
786+ std::vector<ConstGeTensorPtr> get_tensor_list;
787+ EXPECT_TRUE(AttrUtils::GetListTensor(op_desc, "tensor_list", get_tensor_list));
788+ EXPECT_EQ(get_tensor_list.size(), 2U);
789+ 
790+ std::vector<GeTensorPtr> mutable_tensor_list;
791+ EXPECT_TRUE(AttrUtils::MutableListTensor(op_desc, "tensor_list", mutable_tensor_list));
792+ EXPECT_EQ(mutable_tensor_list.size(), 2U);
793+}
794+ 
795+TEST_F(UtestGeAttrValue, IncCov_GraphAttrOperations) {
796+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
797+ 
798+ auto graph = std::make_shared<ComputeGraph>("test_graph");
799+ graph->AddNode(std::make_shared<OpDesc>("node", "Test"));
800+ EXPECT_TRUE(AttrUtils::SetGraph(op_desc, "graph_attr", graph));
801+ 
802+ ComputeGraphPtr get_graph;
803+ EXPECT_TRUE(AttrUtils::GetGraph(op_desc, "graph_attr", get_graph));
804+ EXPECT_NE(get_graph, nullptr);
805+ 
806+ EXPECT_FALSE(AttrUtils::GetGraph(op_desc, "nonexistent_graph", get_graph));
807+ 
808+ std::vector<ComputeGraphPtr> graphs = {graph, graph};
809+ EXPECT_TRUE(AttrUtils::SetListGraph(op_desc, "graph_list", graphs));
810+ 
811+ std::vector<ComputeGraphPtr> get_graphs;
812+ EXPECT_TRUE(AttrUtils::GetListGraph(op_desc, "graph_list", get_graphs));
813+ EXPECT_EQ(get_graphs.size(), 2U);
814+}
815+ 
816+TEST_F(UtestGeAttrValue, IncCov_BytesAttrOperations) {
817+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
818+ 
819+ std::vector<uint8_t> data = {1, 2, 3, 4};
820+ Buffer buffer = Buffer::CopyFrom(data.data(), data.size());
821+ EXPECT_TRUE(AttrUtils::SetBytes(op_desc, "bytes_attr", buffer));
822+ 
823+ Buffer get_buffer;
824+ EXPECT_TRUE(AttrUtils::GetBytes(op_desc, "bytes_attr", get_buffer));
825+ EXPECT_EQ(get_buffer.GetSize(), data.size());
826+ 
827+ Buffer zero_copy_buffer = Buffer::CopyFrom(data.data(), data.size());
828+ EXPECT_TRUE(AttrUtils::SetZeroCopyBytes(op_desc, "zero_bytes_attr", std::move(zero_copy_buffer)));
829+ Buffer get_zero_buffer;
830+ EXPECT_TRUE(AttrUtils::GetZeroCopyBytes(op_desc, "zero_bytes_attr", get_zero_buffer));
831+ EXPECT_EQ(get_zero_buffer.GetSize(), data.size());
832+ 
833+ std::vector<Buffer> buffers = {buffer, buffer};
834+ EXPECT_TRUE(AttrUtils::SetListBytes(op_desc, "bytes_list", buffers));
835+ std::vector<Buffer> get_buffers;
836+ EXPECT_TRUE(AttrUtils::GetListBytes(op_desc, "bytes_list", get_buffers));
837+ EXPECT_EQ(get_buffers.size(), 2U);
838+ 
839+ std::vector<Buffer> zero_buffers = {buffer, buffer};
840+ EXPECT_TRUE(AttrUtils::SetZeroCopyListBytes(op_desc, "zero_bytes_list", zero_buffers));
841+ std::vector<Buffer> get_zero_buffers;
842+ EXPECT_TRUE(AttrUtils::GetZeroCopyListBytes(op_desc, "zero_bytes_list", get_zero_buffers));
843+ EXPECT_EQ(get_zero_buffers.size(), 2U);
844+}
845+ 
846+TEST_F(UtestGeAttrValue, IncCov_GetAllAttrsWithFilterNullptr) {
847+ ConstOpDescPtr null_op;
848+ auto result = AttrUtils::GetAllAttrsWithFilter(std::move(null_op), nullptr);
849+ EXPECT_TRUE(result.empty());
850+}
851+ 
852+TEST_F(UtestGeAttrValue, IncCov_GetAllAttrsStrWithTensorDesc) {
853+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Test");
854+ GeTensorDesc td(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
855+ AttrUtils::SetTensorDesc(op_desc, "td_attr", td);
856+ auto result = AttrUtils::GetAllAttrsStr(op_desc);
857+ EXPECT_FALSE(result.empty());
858+}
732} // namespace ge859} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ge_ir_utils_inc_cov2_unittest.cc+231-0
@@ -867,4 +867,235 @@ TEST_F(GeIrUtilsIncCov2, IncCov2_ConvertGeModelToModelProto_WithEnvDumpLevel) {
867 unsetenv("DUMP_GE_GRAPH");867 unsetenv("DUMP_GE_GRAPH");
868}868}
869 869 
870+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProtoFromAttribute_DefaultCase) {
871+ onnx::NodeProto node_proto;
872+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
873+ AttrUtils::SetBool(op_desc, "bool_attr", true);
874+ GeAttrValue attr_value;
875+ op_desc->GetAttr("bool_attr", attr_value);
876+ std::pair<const std::string, ge::GeAttrValue> pair("bool_attr", attr_value);
877+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
878+ EXPECT_EQ(node_proto.attribute_size(), 1);
879+}
880+ 
881+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeNode_JsonPath_ManyInputs) {
882+ auto graph = std::make_shared<ComputeGraph>("json_test_graph");
883+ OpDescPtr op_desc = std::make_shared<OpDesc>("json_op", "Relu");
884+ GeTensorDesc tensor(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
885+ for (int i = 0; i < 21; i++) {
886+ op_desc->AddInputDesc(tensor);
887+ }
888+ op_desc->AddOutputDesc(tensor);
889+ auto node = graph->AddNode(op_desc);
890+ onnx::NodeProto node_proto;
891+ EXPECT_TRUE(OnnxUtils::EncodeNode(node, &node_proto));
892+ EXPECT_GT(node_proto.attribute_size(), 0);
893+}
894+ 
895+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeNode_JsonPath_ManyOutputs) {
896+ auto graph = std::make_shared<ComputeGraph>("json_out_graph");
897+ OpDescPtr op_desc = std::make_shared<OpDesc>("json_out_op", "Relu");
898+ GeTensorDesc tensor(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
899+ op_desc->AddInputDesc(tensor);
900+ for (int i = 0; i < 21; i++) {
901+ op_desc->AddOutputDesc(tensor);
902+ }
903+ auto node = graph->AddNode(op_desc);
904+ onnx::NodeProto node_proto;
905+ EXPECT_TRUE(OnnxUtils::EncodeNode(node, &node_proto));
906+ EXPECT_GT(node_proto.attribute_size(), 0);
907+}
908+ 
909+TEST_F(GeIrUtilsIncCov2, IncCov2_EncodeNodeDesc_ListListIntAttr) {
910+ auto graph = std::make_shared<ComputeGraph>("list_list_int_graph");
911+ OpDescPtr op_desc = std::make_shared<OpDesc>("list_list_op", "Relu");
912+ op_desc->AddInputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
913+ op_desc->AddOutputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
914+ std::vector<std::vector<int64_t>> list_list_int = {{1, 2}, {3, 4, 5}};
915+ AttrUtils::SetListListInt(op_desc, "list_list_attr", list_list_int);
916+ auto node = graph->AddNode(op_desc);
917+ onnx::NodeProto node_proto;
918+ EXPECT_TRUE(OnnxUtils::EncodeNodeDesc(node, &node_proto));
919+ EXPECT_GT(node_proto.attribute_size(), 0);
920+}
921+ 
922+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInAndOutDesc_NullOpDesc) {
923+ OpDescPtr null_op;
924+ onnx::AttributeProto attr_proto;
925+ attr_proto.set_name("input_desc_dtype:0");
926+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
927+ attr_proto.set_s("DT_FLOAT");
928+ OnnxUtils::DecodeNodeAttributeForOpInAndOutDesc(attr_proto, "input_desc_dtype", 0, null_op);
929+ SUCCEED();
930+}
931+ 
932+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInAndOutDesc_UnknownPrefix) {
933+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_unknown_prefix", "TestOp");
934+ onnx::AttributeProto attr_proto;
935+ attr_proto.set_name("unknown_field:0");
936+ attr_proto.set_type(onnx::AttributeProto_AttributeType_INT);
937+ attr_proto.set_i(0);
938+ OnnxUtils::DecodeNodeAttributeForOpInAndOutDesc(attr_proto, "unknown_field", 0, op_desc);
939+ SUCCEED();
940+}
941+ 
942+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeLink_SrcNodeNullptrInMap) {
943+ auto graph = std::make_shared<ComputeGraph>("test_nullptr_map");
944+ auto dst = CreateNodeIncCov2Helper(graph, "dst_null_map", "Relu", 1, 1);
945+ 
946+ onnx::NodeProto node_proto;
947+ node_proto.set_name("dst_null_map");
948+ node_proto.add_input("src_null:0");
949+ 
950+ std::vector<onnx::NodeProto> node_proto_vector;
951+ node_proto_vector.push_back(node_proto);
952+ 
953+ std::map<std::string, NodePtr> node_map;
954+ node_map["src_null"] = nullptr;
955+ node_map["dst_null_map"] = dst;
956+ 
957+ EXPECT_FALSE(OnnxUtils::DecodeNodeLink(node_proto_vector, node_map));
958+}
959+ 
960+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeLink_LinkImpFail) {
961+ auto graph = std::make_shared<ComputeGraph>("test_link_imp_fail");
962+ auto src = CreateNodeIncCov2Helper(graph, "src_imp_fail", "Data", 1, 1);
963+ auto dst = CreateNodeIncCov2Helper(graph, "dst_imp_fail", "Relu", 1, 1);
964+ 
965+ onnx::NodeProto node_proto;
966+ node_proto.set_name("dst_imp_fail");
967+ node_proto.add_input("src_imp_fail:5");
968+ 
969+ std::vector<onnx::NodeProto> node_proto_vector;
970+ node_proto_vector.push_back(node_proto);
971+ 
972+ std::map<std::string, NodePtr> node_map;
973+ node_map["src_imp_fail"] = src;
974+ node_map["dst_imp_fail"] = dst;
975+ 
976+ EXPECT_FALSE(OnnxUtils::DecodeNodeLink(node_proto_vector, node_map));
977+}
978+ 
979+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeGraph_DecodeNodeDescFail) {
980+ onnx::GraphProto graph_proto;
981+ graph_proto.set_name("bad_node_graph");
982+ auto *node_proto = graph_proto.add_node();
983+ node_proto->set_name("bad_node");
984+ node_proto->set_op_type("NoPrefixType");
985+ 
986+ ComputeGraphPtr graph;
987+ EXPECT_FALSE(OnnxUtils::DecodeGraph(0, graph_proto, graph));
988+}
989+ 
990+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeGraph_SubgraphNonGraphAttr) {
991+ onnx::GraphProto graph_proto;
992+ graph_proto.set_name("bad_subgraph_graph");
993+ auto *node_proto = graph_proto.add_node();
994+ node_proto->set_name("bad_subgraph");
995+ node_proto->set_op_type("subgraph");
996+ auto *attr = node_proto->add_attribute();
997+ attr->set_name("graph");
998+ attr->set_type(onnx::AttributeProto_AttributeType_INT);
999+ attr->set_i(42);
1000+ 
1001+ ComputeGraphPtr graph;
1002+ EXPECT_FALSE(OnnxUtils::DecodeGraph(0, graph_proto, graph));
1003+}
1004+ 
1005+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpDesc_DstIndex) {
1006+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_dst_idx", "TestOp");
1007+ onnx::AttributeProto attr_proto;
1008+ attr_proto.set_name("dst_index");
1009+ attr_proto.set_type(onnx::AttributeProto_AttributeType_INTS);
1010+ attr_proto.add_ints(0);
1011+ attr_proto.add_ints(1);
1012+ OnnxUtils::DecodeNodeAttributeForOpDesc(attr_proto, op_desc);
1013+ SUCCEED();
1014+}
1015+ 
1016+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProto_RepeatedInt64_WithData) {
1017+ onnx::NodeProto node_proto;
1018+ ::google::protobuf::RepeatedField<::google::protobuf::int64> data;
1019+ data.Add(10);
1020+ data.Add(20);
1021+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_INTS, "test_ints", data);
1022+ EXPECT_EQ(node_proto.attribute_size(), 1);
1023+ EXPECT_EQ(node_proto.attribute(0).ints_size(), 2);
1024+}
1025+ 
1026+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProto_RepeatedBool_WithData) {
1027+ onnx::NodeProto node_proto;
1028+ ::google::protobuf::RepeatedField<bool> data;
1029+ data.Add(true);
1030+ data.Add(false);
1031+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_INTS, "test_bools", data);
1032+ EXPECT_EQ(node_proto.attribute_size(), 1);
1033+ EXPECT_EQ(node_proto.attribute(0).ints_size(), 2);
1034+}
1035+ 
1036+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProto_RepeatedFloat_WithData) {
1037+ onnx::NodeProto node_proto;
1038+ ::google::protobuf::RepeatedField<float> data;
1039+ data.Add(1.5F);
1040+ data.Add(2.5F);
1041+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_FLOATS, "test_floats", data);
1042+ EXPECT_EQ(node_proto.attribute_size(), 1);
1043+ EXPECT_EQ(node_proto.attribute(0).floats_size(), 2);
1044+}
1045+ 
1046+TEST_F(GeIrUtilsIncCov2, IncCov2_AddAttrProto_RepeatedString_WithData) {
1047+ onnx::NodeProto node_proto;
1048+ ::google::protobuf::RepeatedPtrField<::std::string> data;
1049+ data.Add("hello");
1050+ data.Add("world");
1051+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_STRINGS, "test_strings", data);
1052+ EXPECT_EQ(node_proto.attribute_size(), 1);
1053+ EXPECT_EQ(node_proto.attribute(0).strings_size(), 2);
1054+}
1055+ 
1056+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInDesc_Dtype) {
1057+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_in_dtype", "TestOp");
1058+ op_desc->AddInputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1059+ onnx::AttributeProto attr_proto;
1060+ attr_proto.set_name("input_desc_dtype:0");
1061+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
1062+ attr_proto.set_s("DT_INT32");
1063+ OnnxUtils::DecodeNodeAttributeForOpInDesc(attr_proto, "input_desc_dtype", 0, op_desc);
1064+ EXPECT_EQ(op_desc->GetInputDesc(0).GetDataType(), DT_INT32);
1065+}
1066+ 
1067+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInDesc_Shape) {
1068+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_in_shape", "TestOp");
1069+ op_desc->AddInputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1070+ onnx::AttributeProto attr_proto;
1071+ attr_proto.set_name("input_desc_shape:0");
1072+ attr_proto.set_type(onnx::AttributeProto_AttributeType_INTS);
1073+ attr_proto.add_ints(2);
1074+ attr_proto.add_ints(3);
1075+ OnnxUtils::DecodeNodeAttributeForOpInDesc(attr_proto, "input_desc_shape", 0, op_desc);
1076+ EXPECT_EQ(op_desc->GetInputDesc(0).GetShape().GetDims(), std::vector<int64_t>({2, 3}));
1077+}
1078+ 
1079+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpInDesc_Layout) {
1080+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_in_layout", "TestOp");
1081+ op_desc->AddInputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1082+ onnx::AttributeProto attr_proto;
1083+ attr_proto.set_name("input_desc_layout:0");
1084+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
1085+ attr_proto.set_s("NCHW");
1086+ OnnxUtils::DecodeNodeAttributeForOpInDesc(attr_proto, "input_desc_layout", 0, op_desc);
1087+ EXPECT_EQ(op_desc->GetInputDesc(0).GetFormat(), FORMAT_NCHW);
1088+}
1089+ 
1090+TEST_F(GeIrUtilsIncCov2, IncCov2_DecodeNodeAttributeForOpOutDesc_OriginDtype) {
1091+ OpDescPtr op_desc = std::make_shared<OpDesc>("test_out_origin_dtype", "TestOp");
1092+ op_desc->AddOutputDesc(GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1093+ onnx::AttributeProto attr_proto;
1094+ attr_proto.set_name("output_desc_origin_dtype:0");
1095+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
1096+ attr_proto.set_s("DT_INT32");
1097+ OnnxUtils::DecodeNodeAttributeForOpOutDesc(attr_proto, "output_desc_origin_dtype", 0, op_desc);
1098+ SUCCEED();
1099+}
1100+ 
870} // namespace ge1101} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ge_tensor_unittest.cc+301-0
@@ -728,3 +728,304 @@ TEST_F(UtestGeTensor, IncCov_TensorDataMethods) {
728 EXPECT_EQ(td.ResetData(ptr, 0, [](uint8_t *p) {}), GRAPH_SUCCESS);728 EXPECT_EQ(td.ResetData(ptr, 0, [](uint8_t *p) {}), GRAPH_SUCCESS);
729 EXPECT_EQ(td.GetSize(), 0U);729 EXPECT_EQ(td.GetSize(), 0U);
730}730}
731+ 
732+TEST_F(UtestGeTensor, IncCov_SerializeDeserializeProto) {
733+ GeTensorDesc desc(GeShape({1, 2, 3}), FORMAT_NCHW, DT_FLOAT);
734+ desc.SetOriginFormat(FORMAT_NCHW);
735+ desc.SetOriginDataType(DT_FLOAT);
736+ desc.SetOriginShape(GeShape({4, 5, 6}));
737+ 
738+ proto::TensorDescriptor proto_desc;
739+ GeTensorSerializeUtils::GeTensorDescAsProto(desc, &proto_desc);
740+ 
741+ GeShape shape;
742+ GeTensorSerializeUtils::GetShapeFromDescProto(&proto_desc, shape);
743+ EXPECT_EQ(shape.GetDimNum(), 3U);
744+ 
745+ GeShape origin_shape;
746+ GeTensorSerializeUtils::GetOriginShapeFromDescProto(&proto_desc, origin_shape);
747+ EXPECT_EQ(origin_shape.GetDimNum(), 3U);
748+ 
749+ DataType dtype = DT_UNDEFINED;
750+ GeTensorSerializeUtils::GetDtypeFromDescProto(&proto_desc, dtype);
751+ EXPECT_EQ(dtype, DT_FLOAT);
752+ 
753+ DataType origin_dtype = DT_UNDEFINED;
754+ GeTensorSerializeUtils::GetOriginDtypeFromDescProto(&proto_desc, origin_dtype);
755+ EXPECT_EQ(origin_dtype, DT_FLOAT);
756+ 
757+ Format format = FORMAT_RESERVED;
758+ GeTensorSerializeUtils::GetFormatFromDescProto(&proto_desc, format);
759+ EXPECT_EQ(format, FORMAT_NCHW);
760+ 
761+ Format origin_format = FORMAT_RESERVED;
762+ GeTensorSerializeUtils::GetOriginFormatFromDescProto(&proto_desc, origin_format);
763+ EXPECT_EQ(origin_format, FORMAT_NCHW);
764+}
765+ 
766+TEST_F(UtestGeTensor, IncCov_NullProtoGetFromDescProto) {
767+ GeShape shape;
768+ GeTensorSerializeUtils::GetShapeFromDescProto(nullptr, shape);
769+ 
770+ GeShape origin_shape;
771+ GeTensorSerializeUtils::GetOriginShapeFromDescProto(nullptr, origin_shape);
772+ 
773+ DataType dtype = DT_FLOAT;
774+ GeTensorSerializeUtils::GetDtypeFromDescProto(nullptr, dtype);
775+ EXPECT_EQ(dtype, DT_FLOAT);
776+ 
777+ DataType origin_dtype = DT_FLOAT;
778+ GeTensorSerializeUtils::GetOriginDtypeFromDescProto(nullptr, origin_dtype);
779+ 
780+ Format format = FORMAT_NCHW;
781+ GeTensorSerializeUtils::GetFormatFromDescProto(nullptr, format);
782+ 
783+ Format origin_format = FORMAT_NCHW;
784+ GeTensorSerializeUtils::GetOriginFormatFromDescProto(nullptr, origin_format);
785+}
786+ 
787+TEST_F(UtestGeTensor, IncCov_GeTensorAsProtoAndAssemble) {
788+ GeTensorDesc desc(GeShape({1, 2, 3}), FORMAT_NCHW, DT_FLOAT);
789+ desc.SetOriginFormat(FORMAT_NCHW);
790+ desc.SetOriginDataType(DT_FLOAT);
791+ vector<uint8_t> data = {1, 2, 3, 4};
792+ GeTensor tensor(desc, data);
793+ 
794+ proto::TensorDef proto_tensor;
795+ GeTensorSerializeUtils::GeTensorAsProto(tensor, &proto_tensor);
796+ 
797+ GeTensor tensor2;
798+ GeTensorSerializeUtils::AssembleGeTensorFromProto(&proto_tensor, tensor2);
799+ EXPECT_EQ(tensor2.GetTensorDesc().GetDataType(), DT_FLOAT);
800+ EXPECT_EQ(tensor2.GetData().GetSize(), 4U);
801+ 
802+ GeTensorDesc desc2;
803+ GeTensorSerializeUtils::AssembleGeTensorDescFromProto(&(proto_tensor.desc()), desc2);
804+ EXPECT_EQ(desc2.GetDataType(), DT_FLOAT);
805+ 
806+ GeShape shape;
807+ GeTensorSerializeUtils::AssembleGeShapeFromProto(&(proto_tensor.desc().shape()), shape);
808+ EXPECT_EQ(shape.GetDimNum(), 3U);
809+ 
810+ GeTensorSerializeUtils::AssembleGeTensorFromProto(nullptr, tensor2);
811+ GeTensorSerializeUtils::AssembleGeTensorDescFromProto(nullptr, desc2);
812+ GeTensorSerializeUtils::AssembleGeShapeFromProto(nullptr, shape);
813+}
814+ 
815+TEST_F(UtestGeTensor, IncCov_NormalizeGeTensorDescProto) {
816+ proto::TensorDescriptor proto_desc;
817+ auto *attrs = proto_desc.mutable_attr();
818+ (*attrs)["size"].set_i(100);
819+ (*attrs)["weight_size"].set_i(200);
820+ (*attrs)["reuse_input"].set_b(true);
821+ (*attrs)["output_tensor"].set_b(false);
822+ (*attrs)["device_type"].set_s("NPU");
823+ (*attrs)["input_tensor"].set_b(true);
824+ (*attrs)["real_dim_cnt"].set_i(4);
825+ (*attrs)["reuse_input_index"].set_i(2);
826+ (*attrs)["data_offset"].set_i(10);
827+ (*attrs)["cmps_size"].set_i(50);
828+ (*attrs)["cmps_tab"].set_s("tab");
829+ (*attrs)["cmps_tab_offset"].set_i(5);
830+ 
831+ GeTensorSerializeUtils::NormalizeGeTensorDescProto(&proto_desc);
832+ EXPECT_EQ(proto_desc.size(), 100);
833+ EXPECT_EQ(proto_desc.weight_size(), 200);
834+ 
835+ GeTensorSerializeUtils::NormalizeGeTensorDescProto(nullptr);
836+}
837+ 
838+TEST_F(UtestGeTensor, IncCov_RangeInvalidSize) {
839+ GeTensorDesc desc;
840+ vector<vector<int64_t>> invalid_range = {{1, 2, 3}};
841+ EXPECT_TRUE(AttrUtils::SetListListInt(&desc, "value_range", invalid_range));
842+ vector<pair<int64_t, int64_t>> range;
843+ EXPECT_EQ(desc.GetValueRange(range), GRAPH_FAILED);
844+ 
845+ EXPECT_TRUE(AttrUtils::SetListListInt(&desc, "shape_range", invalid_range));
846+ vector<pair<int64_t, int64_t>> shape_range;
847+ EXPECT_EQ(desc.GetShapeRange(shape_range), GRAPH_FAILED);
848+ 
849+ EXPECT_TRUE(AttrUtils::SetListListInt(&desc, "origin_shape_range", invalid_range));
850+ vector<pair<int64_t, int64_t>> origin_shape_range;
851+ EXPECT_EQ(desc.GetOriginShapeRange(origin_shape_range), GRAPH_FAILED);
852+}
853+ 
854+TEST_F(UtestGeTensor, IncCov_TensorDataExtra) {
855+ TensorData td;
856+ vector<uint8_t> data = {1, 2, 3, 4, 5};
857+ EXPECT_EQ(td.SetData(std::move(data)), GRAPH_SUCCESS);
858+ EXPECT_EQ(td.GetSize(), 5U);
859+ 
860+ EXPECT_EQ(td[100], 0xffU);
861+ 
862+ EXPECT_EQ(td.SetData(nullptr, 4, [](uint8_t *p) {}), GRAPH_FAILED);
863+}
864+ 
865+TEST_F(UtestGeTensor, IncCov_GeTensorConstructorsAll) {
866+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
867+ vector<uint8_t> data = {1, 2, 3, 4};
868+ 
869+ GeTensor t1(desc, data);
870+ EXPECT_EQ(t1.GetData().GetSize(), 4U);
871+ EXPECT_TRUE(t1.IsTensorDataValid());
872+ 
873+ GeTensor t2(desc, data.data(), data.size());
874+ EXPECT_EQ(t2.GetData().GetSize(), 4U);
875+ 
876+ GeTensorDesc desc_move(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
877+ GeTensor t3(std::move(desc_move), std::move(data));
878+ EXPECT_EQ(t3.GetData().GetSize(), 4U);
879+ 
880+ GeTensorDesc desc4(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
881+ Buffer buf = Buffer::CopyFrom(data.data(), data.size());
882+ GeTensor t4(desc4, buf);
883+ EXPECT_EQ(t4.GetData().GetSize(), 4U);
884+ 
885+ GeTensorDesc desc5(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
886+ GeTensor t5(desc5, 100);
887+ EXPECT_EQ(t5.GetData().GetSize(), 100U);
888+ 
889+ GeTensorDesc desc6(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
890+ auto aligned_ptr = std::make_shared<AlignedPtr>(100);
891+ GeTensor t6(desc6, aligned_ptr, 100);
892+ EXPECT_EQ(t6.GetData().GetSize(), 100U);
893+ 
894+ GeTensor default_t;
895+ GeTensor move_t(std::move(default_t));
896+ GeTensor copy_t(move_t);
897+ GeTensor assign_t;
898+ assign_t = copy_t;
899+ GeTensor move_assign;
900+ move_assign = std::move(assign_t);
901+}
902+ 
903+TEST_F(UtestGeTensor, IncCov_GeTensorCloneSetDataClear) {
904+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
905+ vector<uint8_t> data = {1, 2, 3, 4};
906+ GeTensor tensor(desc, data);
907+ 
908+ GeTensor cloned = tensor.Clone();
909+ EXPECT_EQ(cloned.GetData().GetSize(), 4U);
910+ EXPECT_EQ(cloned.GetTensorDesc().GetDataType(), DT_FLOAT);
911+ 
912+ vector<uint8_t> new_data = {5, 6, 7, 8, 9};
913+ EXPECT_EQ(tensor.SetData(new_data), GRAPH_SUCCESS);
914+ EXPECT_EQ(tensor.GetData().GetSize(), 5U);
915+ 
916+ EXPECT_EQ(tensor.SetData(new_data.data(), new_data.size()), GRAPH_SUCCESS);
917+ 
918+ Buffer buf = Buffer::CopyFrom(new_data.data(), new_data.size());
919+ EXPECT_EQ(tensor.SetData(buf), GRAPH_SUCCESS);
920+ 
921+ TensorData td;
922+ td.SetData(new_data);
923+ EXPECT_EQ(tensor.SetData(td), GRAPH_SUCCESS);
924+ 
925+ tensor.ClearData();
926+ EXPECT_EQ(tensor.GetData().GetSize(), 0U);
927+ 
928+ auto aligned_ptr = tensor.GetAlignedPtr();
929+ auto new_aligned = std::make_shared<AlignedPtr>(10);
930+ tensor.SetData(std::move(new_aligned), 10);
931+ EXPECT_EQ(tensor.GetData().GetSize(), 10U);
932+}
933+ 
934+TEST_F(UtestGeTensor, IncCov_GeTensorSetDataWithDeleter) {
935+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
936+ GeTensor tensor(desc);
937+ 
938+ uint8_t *ptr = new uint8_t[4];
939+ EXPECT_EQ(tensor.SetData(ptr, 4, [](uint8_t *p) { delete[] p; }), GRAPH_SUCCESS);
940+ EXPECT_EQ(tensor.GetData().GetSize(), 4U);
941+ 
942+ uint8_t *ptr2 = new uint8_t[8];
943+ EXPECT_EQ(tensor.ResetData(ptr2, 8, [](uint8_t *p) { delete[] p; }), GRAPH_SUCCESS);
944+ EXPECT_EQ(tensor.GetData().GetSize(), 8U);
945+}
946+ 
947+TEST_F(UtestGeTensor, IncCov_TensorUtilsShareAndCopy) {
948+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
949+ vector<uint8_t> data = {1, 2, 3, 4};
950+ GeTensor tensor(desc, data);
951+ 
952+ GeTensor shared = TensorUtils::CreateShareTensor(tensor);
953+ EXPECT_EQ(shared.GetData().GetSize(), 4U);
954+ 
955+ GeTensor copy_tensor;
956+ TensorUtils::CopyTensor(tensor, copy_tensor);
957+ EXPECT_EQ(copy_tensor.GetData().GetSize(), 4U);
958+ 
959+ TensorData td = tensor.GetData();
960+ TensorData shared_td = TensorUtils::CreateShareTensorData(td);
961+ EXPECT_EQ(shared_td.GetSize(), 4U);
962+ 
963+ auto aligned_ptr = std::make_shared<AlignedPtr>(10);
964+ GeTensor tensor2(desc);
965+ TensorUtils::ShareAlignedPtr(aligned_ptr, 10, tensor2);
966+ EXPECT_EQ(tensor2.GetData().GetSize(), 10U);
967+ 
968+ GeTensorDesc desc2(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
969+ GeTensor shared2 = TensorUtils::CreateShareTensor(desc2, std::make_shared<AlignedPtr>(10), 10);
970+ EXPECT_EQ(shared2.GetData().GetSize(), 10U);
971+ 
972+ TensorData td_from;
973+ td_from.SetData(data);
974+ TensorData td_to;
975+ TensorUtils::ShareTensorData(td_from, td_to);
976+ EXPECT_EQ(td_to.GetSize(), 4U);
977+}
978+ 
979+TEST_F(UtestGeTensor, IncCov_TensorUtilsIsOriginShapeInited) {
980+ GeTensorDesc desc;
981+ EXPECT_FALSE(TensorUtils::IsOriginShapeInited(desc));
982+ desc.SetOriginShape(GeShape({1, 2}));
983+ EXPECT_TRUE(TensorUtils::IsOriginShapeInited(desc));
984+}
985+ 
986+TEST_F(UtestGeTensor, IncCov_IsShapeEqualDifferentDims) {
987+ GeShape src({1, 2, 3});
988+ GeShape dst({1, 2, 4});
989+ EXPECT_FALSE(TensorUtils::IsShapeEqual(src, dst));
990+ 
991+ GeShape src2({1, 2});
992+ GeShape dst2({1, 2, 3});
993+ EXPECT_FALSE(TensorUtils::IsShapeEqual(src2, dst2));
994+}
995+ 
996+TEST_F(UtestGeTensor, IncCov_GeTensorDescProtoCtorAndCompare) {
997+ proto::TensorDescriptor proto_desc;
998+ GeTensorDesc desc(&proto_desc);
999+ 
1000+ GeTensorDesc desc2(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
1001+ GeTensorDesc desc3(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
1002+ EXPECT_TRUE(desc2.GeTensorDescAttrsAreEqual(desc3));
1003+ EXPECT_TRUE(desc2 == desc3);
1004+ 
1005+ GeTensorDesc desc4(GeShape({1, 3}), FORMAT_NCHW, DT_FLOAT);
1006+ EXPECT_FALSE(desc2.GeTensorDescAttrsAreEqual(desc4));
1007+ EXPECT_FALSE(desc2 == desc4);
1008+ 
1009+ GeTensorDesc move_desc(std::move(desc2));
1010+ GeTensorDesc assign_desc;
1011+ assign_desc = desc3;
1012+ GeTensorDesc move_assign;
1013+ move_assign = std::move(assign_desc);
1014+}
1015+ 
1016+TEST_F(UtestGeTensor, IncCov_GeTensorMisc2) {
1017+ GeTensorDesc desc(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
1018+ GeTensor tensor(desc);
1019+ EXPECT_EQ(tensor.GetTensorDesc().GetDataType(), DT_FLOAT);
1020+ 
1021+ GeTensorDesc new_desc(GeShape({3, 4}), FORMAT_ND, DT_INT32);
1022+ tensor.SetTensorDesc(new_desc);
1023+ EXPECT_EQ(tensor.GetTensorDesc().GetDataType(), DT_INT32);
1024+ 
1025+ GeTensorDesc &mutable_desc = tensor.MutableTensorDesc();
1026+ mutable_desc.SetDataType(DT_FLOAT16);
1027+ EXPECT_EQ(tensor.GetTensorDesc().GetDataType(), DT_FLOAT16);
1028+ 
1029+ TensorData &mutable_data = tensor.MutableData();
1030+ (void)mutable_data;
1031+}
Mtests/graph_metadef/ut/graph/testcase/gnode_unittest.cc+90-0
@@ -1122,4 +1122,94 @@ TEST_F(GNodeTest, IncCov_GNodeGetInputDescOutOfRange) {
1122 EXPECT_EQ(gnode.GetOutputDesc(999, td), GRAPH_FAILED);1122 EXPECT_EQ(gnode.GetOutputDesc(999, td), GRAPH_FAILED);
1123 EXPECT_EQ(gnode.UpdateOutputDesc(999, td), GRAPH_FAILED);1123 EXPECT_EQ(gnode.UpdateOutputDesc(999, td), GRAPH_FAILED);
1124}1124}
1125+ 
1126+TEST_F(GNodeTest, IncCov_GNodeAttrTensorAndOpBytes) {
1127+ auto builder = ut::GraphBuilder("graph");
1128+ const auto node = builder.AddNode("node", "node", 1, 1);
1129+ GNode gnode = NodeAdapter::Node2GNode(node);
1130+ AscendString name = "test_attr";
1131+ 
1132+ Tensor tensor;
1133+ std::vector<int64_t> shape{2};
1134+ TensorDesc tensor_desc(Shape(shape), FORMAT_ND, DT_UINT8);
1135+ tensor.SetTensorDesc(tensor_desc);
1136+ std::vector<uint8_t> data{1, 2};
1137+ tensor.SetData(data);
1138+ EXPECT_EQ(gnode.SetAttr(name, tensor), GRAPH_SUCCESS);
1139+ Tensor get_tensor;
1140+ EXPECT_EQ(gnode.GetAttr(name, get_tensor), GRAPH_SUCCESS);
1141+ 
1142+ OpBytes op_bytes = {10, 20, 30};
1143+ EXPECT_EQ(gnode.SetAttr(name, op_bytes), GRAPH_SUCCESS);
1144+ OpBytes get_bytes;
1145+ EXPECT_EQ(gnode.GetAttr(name, get_bytes), GRAPH_SUCCESS);
1146+ 
1147+ gnode.impl_ = nullptr;
1148+ EXPECT_EQ(gnode.SetAttr(name, tensor), GRAPH_FAILED);
1149+ EXPECT_EQ(gnode.GetAttr(name, tensor), GRAPH_FAILED);
1150+ EXPECT_EQ(gnode.SetAttr(name, op_bytes), GRAPH_FAILED);
1151+ EXPECT_EQ(gnode.GetAttr(name, op_bytes), GRAPH_FAILED);
1152+}
1153+ 
1154+TEST_F(GNodeTest, IncCov_GNodeAttrVectorVectorAndVectorTensor) {
1155+ auto builder = ut::GraphBuilder("graph");
1156+ const auto node = builder.AddNode("node", "node", 1, 1);
1157+ GNode gnode = NodeAdapter::Node2GNode(node);
1158+ AscendString name = "test_attr";
1159+ 
1160+ std::vector<std::vector<int64_t>> vvi = {{1, 2}, {3, 4}};
1161+ EXPECT_EQ(gnode.SetAttr(name, vvi), GRAPH_SUCCESS);
1162+ std::vector<std::vector<int64_t>> gvvi;
1163+ EXPECT_EQ(gnode.GetAttr(name, gvvi), GRAPH_SUCCESS);
1164+ EXPECT_EQ(gvvi.size(), 2U);
1165+ 
1166+ std::vector<Tensor> vt;
1167+ vt.emplace_back(Tensor());
1168+ EXPECT_EQ(gnode.SetAttr(name, vt), GRAPH_SUCCESS);
1169+ std::vector<Tensor> gvt;
1170+ EXPECT_EQ(gnode.GetAttr(name, gvt), GRAPH_SUCCESS);
1171+ 
1172+ gnode.impl_ = nullptr;
1173+ EXPECT_EQ(gnode.SetAttr(name, vvi), GRAPH_FAILED);
1174+ EXPECT_EQ(gnode.GetAttr(name, vvi), GRAPH_FAILED);
1175+ EXPECT_EQ(gnode.SetAttr(name, vt), GRAPH_FAILED);
1176+ EXPECT_EQ(gnode.GetAttr(name, vt), GRAPH_FAILED);
1177+}
1178+ 
1179+TEST_F(GNodeTest, IncCov_GNodeAttrAttrValueType) {
1180+ auto builder = ut::GraphBuilder("graph");
1181+ const auto node = builder.AddNode("node", "node", 1, 1);
1182+ GNode gnode = NodeAdapter::Node2GNode(node);
1183+ AscendString name = "test_attr";
1184+ 
1185+ AttrValue av;
1186+ av.SetAttrValue(static_cast<int64_t>(42));
1187+ EXPECT_EQ(gnode.SetAttr(name, av), GRAPH_SUCCESS);
1188+ AttrValue gav;
1189+ EXPECT_EQ(gnode.GetAttr(name, gav), GRAPH_SUCCESS);
1190+ 
1191+ GNode empty_gnode;
1192+ AscendString empty_name = nullptr;
1193+ AttrValue empty_av;
1194+ EXPECT_EQ(empty_gnode.GetAttr(empty_name, empty_av), GRAPH_PARAM_INVALID);
1195+ EXPECT_EQ(empty_gnode.SetAttr(empty_name, empty_av), GRAPH_PARAM_INVALID);
1196+ empty_gnode.impl_ = nullptr;
1197+ EXPECT_EQ(empty_gnode.GetAttr(name, empty_av), GRAPH_FAILED);
1198+}
1199+ 
1200+TEST_F(GNodeTest, IncCov_GNodeGetInputConstDataExpiredNodePtr) {
1201+ GNode gnode;
1202+ Tensor data;
1203+ EXPECT_EQ(gnode.GetInputConstData(0, data), GRAPH_FAILED);
1204+}
1205+ 
1206+TEST_F(GNodeTest, IncCov_GNodeGetInputConstDataConstNoValue) {
1207+ auto builder = ut::GraphBuilder("graph");
1208+ const auto const_node = builder.AddNode("const_node", "Const", 0, 1);
1209+ const auto target_node = builder.AddNode("target_node", "target", 1, 0);
1210+ builder.AddDataEdge(const_node, 0, target_node, 0);
1211+ GNode gnode = NodeAdapter::Node2GNode(target_node);
1212+ Tensor data;
1213+ EXPECT_EQ(gnode.GetInputConstData(0, data), GRAPH_FAILED);
1214+}
1125} // namespace ge1215} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/graph_unittest.cc+191-0
@@ -44,6 +44,7 @@
44#include <google/protobuf/text_format.h>44#include <google/protobuf/text_format.h>
45#include "graph_metadef/graph/utils/file_utils.h"45#include "graph_metadef/graph/utils/file_utils.h"
46#include "proto/onnx/ge_onnx.pb.h"46#include "proto/onnx/ge_onnx.pb.h"
47+extern "C" void GeApiWrapper_RenameAllNodes(void *graph_ptr, const char *prefix);
47using namespace ge;48using namespace ge;
48namespace {49namespace {
49std::stringstream GetFilePathWhenDumpPathSet(const string &ascend_work_path) {50std::stringstream GetFilePathWhenDumpPathSet(const string &ascend_work_path) {
@@ -2419,3 +2420,193 @@ TEST_F(UtestGraph, IncCov_Dump_InvalidGraph) {
2419 std::ostringstream stream;2420 std::ostringstream stream;
2420 EXPECT_EQ(graph.Dump(Graph::DumpFormat::kOnnx, stream), ge::PARAM_INVALID);2421 EXPECT_EQ(graph.Dump(Graph::DumpFormat::kOnnx, stream), ge::PARAM_INVALID);
2421}2422}
2423+ 
2424+TEST_F(UtestGraph, IncCov_SetOutputsString_NonExistentNode) {
2425+ ge::OpDescPtr add_op(new ge::OpDesc("add_0", "add"));
2426+ add_op->AddDynamicOutputDesc("output", 1);
2427+ std::shared_ptr<ge::ComputeGraph> compute_graph(new ge::ComputeGraph("test_graph"));
2428+ compute_graph->AddNode(add_op);
2429+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
2430+ 
2431+ Operator op1 = Operator("nonexistent");
2432+ std::string out_name = "output0";
2433+ std::vector<std::pair<Operator, std::string>> outputs = {{op1, out_name}};
2434+ graph.SetOutputs(outputs);
2435+}
2436+ 
2437+TEST_F(UtestGraph, IncCov_SetTargets_EmptyTargets) {
2438+ auto compute_graph = BuildComputeGraphWithNetOutput();
2439+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
2440+ std::vector<Operator> empty_targets;
2441+ graph.SetTargets(empty_targets);
2442+}
2443+ 
2444+TEST_F(UtestGraph, IncCov_RemoveNode_ContainSubgraph_NotInGraph) {
2445+ auto cgp = BuildComputeGraphWithNetOutput();
2446+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2447+ 
2448+ ut::GraphBuilder builder = ut::GraphBuilder("other_graph");
2449+ auto data = builder.AddNode("OtherData", "Data", 0, 1);
2450+ auto other_cgp = builder.GetGraph();
2451+ Graph other_graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(other_cgp);
2452+ 
2453+ auto nodes = other_graph.GetAllNodes();
2454+ EXPECT_EQ(graph.RemoveNode(nodes[0], true), ge::GRAPH_FAILED);
2455+}
2456+ 
2457+TEST_F(UtestGraph, IncCov_RemoveEdge_ControlEdge) {
2458+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
2459+ auto data1 = builder.AddNode("Data1", "Data", 0, 1);
2460+ auto data2 = builder.AddNode("Data2", "Data", 0, 1);
2461+ auto cgp = builder.GetGraph();
2462+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2463+ 
2464+ auto nodes = graph.GetAllNodes();
2465+ graph.AddControlEdge(nodes[0], nodes[1]);
2466+ EXPECT_EQ(graph.RemoveEdge(nodes[0], -1, nodes[1], -1), GRAPH_SUCCESS);
2467+}
2468+ 
2469+TEST_F(UtestGraph, IncCov_ConstructFromInputs_NullName) {
2470+ std::vector<Operator> inputs;
2471+ AscendString null_name(nullptr);
2472+ auto result = Graph::ConstructFromInputs(inputs, null_name);
2473+ EXPECT_EQ(result, nullptr);
2474+}
2475+ 
2476+TEST_F(UtestGraph, IncCov_ConstructFromInputs_EmptyInputs) {
2477+ std::vector<Operator> inputs;
2478+ auto result = Graph::ConstructFromInputs(inputs, AscendString("test"));
2479+ EXPECT_EQ(result, nullptr);
2480+}
2481+ 
2482+TEST_F(UtestGraph, IncCov_Dump_TxtFormat) {
2483+ auto cgp = BuildComputeGraphWithNetOutput();
2484+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2485+ std::ostringstream stream;
2486+ EXPECT_EQ(graph.Dump(Graph::DumpFormat::kTxt, stream), SUCCESS);
2487+}
2488+ 
2489+TEST_F(UtestGraph, IncCov_Dump_ReadableFormat) {
2490+ auto cgp = BuildComputeGraphWithNetOutput();
2491+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2492+ std::ostringstream stream;
2493+ graph.Dump(Graph::DumpFormat::kReadable, stream);
2494+}
2495+ 
2496+TEST_F(UtestGraph, IncCov_DumpToFile_OnnxFormat) {
2497+ auto cgp = BuildComputeGraphWithNetOutput();
2498+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2499+ system("rm -rf ./ut_dump_onnx.*");
2500+ EXPECT_EQ(graph.DumpToFile(Graph::DumpFormat::kOnnx, AscendString("ut_dump_onnx")), SUCCESS);
2501+}
2502+ 
2503+TEST_F(UtestGraph, IncCov_DumpToFile_TxtFormat) {
2504+ auto cgp = BuildComputeGraphWithNetOutput();
2505+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2506+ system("rm -rf ./ut_dump_txt.*");
2507+ EXPECT_EQ(graph.DumpToFile(Graph::DumpFormat::kTxt, AscendString("ut_dump_txt")), SUCCESS);
2508+}
2509+ 
2510+TEST_F(UtestGraph, IncCov_DumpToFile_ReadableFormat) {
2511+ auto cgp = BuildComputeGraphWithNetOutput();
2512+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2513+ system("rm -rf ./ut_dump_readable.*");
2514+ EXPECT_EQ(graph.DumpToFile(Graph::DumpFormat::kReadable, AscendString("ut_dump_readable")), SUCCESS);
2515+}
2516+ 
2517+TEST_F(UtestGraph, IncCov_GeApiWrapper_RenameAllNodes) {
2518+ auto cgp = BuildComputeGraphWithNetOutput();
2519+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2520+ 
2521+ GeApiWrapper_RenameAllNodes(nullptr, "prefix");
2522+ GeApiWrapper_RenameAllNodes(static_cast<void *>(&graph), nullptr);
2523+ 
2524+ GeApiWrapper_RenameAllNodes(static_cast<void *>(&graph), "prefix");
2525+ auto nodes = graph.GetAllNodes();
2526+ EXPECT_FALSE(nodes.empty());
2527+}
2528+ 
2529+TEST_F(UtestGraph, IncCov_GraphNullName) {
2530+ Graph graph(nullptr);
2531+ EXPECT_FALSE(graph.IsValid());
2532+}
2533+ 
2534+TEST_F(UtestGraph, IncCov_GetAllOpNameAscendString) {
2535+ auto cgp = BuildComputeGraphWithNetOutput();
2536+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2537+ std::vector<AscendString> names;
2538+ EXPECT_EQ(graph.GetAllOpName(names), GRAPH_SUCCESS);
2539+}
2540+ 
2541+TEST_F(UtestGraph, IncCov_RecoverGraphOperators) {
2542+ auto cgp = BuildComputeGraphWithNetOutput();
2543+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2544+ EXPECT_EQ(GraphUtilsEx::RecoverGraphOperators(graph), SUCCESS);
2545+}
2546+ 
2547+TEST_F(UtestGraph, IncCov_CreateGraphFromComputeGraph_Null) {
2548+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(nullptr);
2549+ EXPECT_FALSE(graph.IsValid());
2550+}
2551+ 
2552+TEST_F(UtestGraph, IncCov_FindOpByType_FrameworkOp) {
2553+ ge::OpDescPtr fw_op(new ge::OpDesc("fw_op", FRAMEWORKOP));
2554+ fw_op->AddOutputDesc(GeTensorDesc());
2555+ ge::AttrUtils::SetStr(fw_op, ge::ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, "CustomOp");
2556+ std::shared_ptr<ge::ComputeGraph> compute_graph(new ge::ComputeGraph("test_graph"));
2557+ compute_graph->AddNode(fw_op);
2558+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
2559+ GraphUtilsEx::RecoverGraphOperators(graph);
2560+ 
2561+ std::vector<Operator> ops;
2562+ graph.FindOpByType("CustomOp", ops);
2563+ EXPECT_EQ(ops.size(), 1U);
2564+}
2565+ 
2566+TEST_F(UtestGraph, IncCov_SetOutputsIndex_OutOfRange) {
2567+ ge::OpDescPtr add_op(new ge::OpDesc("add_0", "add"));
2568+ add_op->AddDynamicOutputDesc("output", 1);
2569+ std::shared_ptr<ge::ComputeGraph> compute_graph(new ge::ComputeGraph("test_graph"));
2570+ compute_graph->AddNode(add_op);
2571+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
2572+ 
2573+ Operator op1 = Operator("add_0");
2574+ std::vector<std::pair<Operator, std::vector<size_t>>> outputs = {{op1, {10}}};
2575+ graph.SetOutputs(outputs);
2576+}
2577+ 
2578+TEST_F(UtestGraph, IncCov_SaveLoadFile_CharPtr) {
2579+ system("rm -rf ./ut_graph_charptr.txt");
2580+ auto cgp = BuildComputeGraphWithNetOutput();
2581+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2582+ 
2583+ EXPECT_EQ(graph.SaveToFile(nullptr), GRAPH_FAILED);
2584+ EXPECT_EQ(graph.SaveToFile("./ut_graph_charptr.txt"), GRAPH_SUCCESS);
2585+ 
2586+ Graph graph2;
2587+ EXPECT_EQ(graph2.LoadFromFile(nullptr), GRAPH_FAILED);
2588+ EXPECT_EQ(graph2.LoadFromFile("./ut_graph_charptr.txt"), GRAPH_SUCCESS);
2589+}
2590+ 
2591+TEST_F(UtestGraph, IncCov_GetComputeGraph_InvalidGraph) {
2592+ Graph graph("test");
2593+ EXPECT_EQ(GraphUtilsEx::GetComputeGraph(graph), nullptr);
2594+}
2595+ 
2596+TEST_F(UtestGraph, IncCov_SetOutputs_AscendString_NullName_InList) {
2597+ auto cgp = BuildComputeGraphWithNetOutput();
2598+ Graph graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(cgp);
2599+ auto node = cgp->FindNode("Transdata1");
2600+ auto op = OpDescUtils::CreateOperatorFromNode(node);
2601+ 
2602+ std::vector<std::pair<ge::Operator, AscendString>> outputs;
2603+ AscendString null_str(nullptr);
2604+ outputs.emplace_back(op, null_str);
2605+ graph.SetOutputs(outputs);
2606+}
2607+ 
2608+TEST_F(UtestGraph, IncCov_CreateGraphFromOperatorWithStableTopo) {
2609+ Operator op1 = Operator("data1");
2610+ Graph graph("test_stable");
2611+ EXPECT_EQ(GraphUtilsEx::CreateGraphFromOperatorWithStableTopo(graph, {op1}), SUCCESS);
2612+}
Mtests/graph_metadef/ut/graph/testcase/graph_utils_unittest.cc+400-0
@@ -5581,4 +5581,404 @@ TEST_F(UtestGraphUtils, CovWriteProtoToTextFileInvalidPath) {
5581 GraphUtils::WriteProtoToTextFile(model_proto, "/nonexistent_dir/cov_test.txt");5581 GraphUtils::WriteProtoToTextFile(model_proto, "/nonexistent_dir/cov_test.txt");
5582 SUCCEED();5582 SUCCEED();
5583}5583}
5584+ 
5585+TEST_F(UtestGraphUtils, CovRemoveJustNodeNullNode) {
5586+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5587+ auto graph = builder.GetGraph();
5588+ EXPECT_EQ(GraphUtils::RemoveJustNode(*graph, nullptr), GRAPH_FAILED);
5589+}
5590+ 
5591+TEST_F(UtestGraphUtils, CovRemoveJustNodeNotInGraph) {
5592+ ut::GraphBuilder builder1 = ut::GraphBuilder("graph1");
5593+ ut::GraphBuilder builder2 = ut::GraphBuilder("graph2");
5594+ auto node = builder1.AddNode("node1", "Relu", 1, 1);
5595+ auto graph2 = builder2.GetGraph();
5596+ EXPECT_EQ(GraphUtils::RemoveJustNode(*graph2, node), GRAPH_FAILED);
5597+}
5598+ 
5599+TEST_F(UtestGraphUtils, CovRemoveNodeWithoutRelinkNullNode) {
5600+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5601+ auto graph = builder.GetGraph();
5602+ EXPECT_EQ(GraphUtils::RemoveNodeWithoutRelink(graph, nullptr), GRAPH_FAILED);
5603+}
5604+ 
5605+TEST_F(UtestGraphUtils, CovRemoveNodesWithoutRelinkBasic) {
5606+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5607+ auto data = builder.AddNode("data", DATA, 0, 1);
5608+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5609+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
5610+ builder.AddDataEdge(data, 0, relu, 0);
5611+ builder.AddDataEdge(relu, 0, netoutput, 0);
5612+ auto graph = builder.GetGraph();
5613+ std::unordered_set<NodePtr> nodes = {relu};
5614+ EXPECT_EQ(GraphUtils::RemoveNodesWithoutRelink(graph, nodes), GRAPH_SUCCESS);
5615+}
5616+ 
5617+TEST_F(UtestGraphUtils, CovRecordOriginalNamesWithAttr) {
5618+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5619+ auto src = builder.AddNode("src", "Relu", 1, 1);
5620+ auto dst = builder.AddNode("dst", "Cast", 1, 1);
5621+ AttrUtils::SetListStr(src->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, {"orig_name1", "orig_name2"});
5622+ AttrUtils::SetListStr(src->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_TYPES, {"Relu", "Data"});
5623+ std::vector<NodePtr> original_nodes = {src};
5624+ GraphUtils::RecordOriginalNames(original_nodes, dst);
5625+ std::vector<std::string> names;
5626+ AttrUtils::GetListStr(dst->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, names);
5627+ EXPECT_EQ(names.size(), 2U);
5628+}
5629+ 
5630+TEST_F(UtestGraphUtils, CovRecordOriginalNamesFromStr) {
5631+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5632+ auto node = builder.AddNode("node", "Relu", 1, 1);
5633+ std::vector<std::string> names = {"name1", "name2"};
5634+ GraphUtils::RecordOriginalNames(names, node);
5635+ std::vector<std::string> result;
5636+ AttrUtils::GetListStr(node->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, result);
5637+ EXPECT_EQ(result.size(), 2U);
5638+}
5639+ 
5640+TEST_F(UtestGraphUtils, CovRecordOriginalNamesEmptyStr) {
5641+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5642+ auto node = builder.AddNode("node", "Relu", 1, 1);
5643+ std::vector<std::string> names;
5644+ GraphUtils::RecordOriginalNames(names, node);
5645+ std::vector<std::string> result;
5646+ AttrUtils::GetListStr(node->GetOpDesc(), ATTR_NAME_DATA_DUMP_ORIGIN_OP_NAMES, result);
5647+ EXPECT_EQ(result.size(), 1U);
5648+}
5649+ 
5650+TEST_F(UtestGraphUtils, CovIsolateNodeNull) {
5651+ EXPECT_EQ(GraphUtils::IsolateNode(nullptr, {0}), GRAPH_PARAM_INVALID);
5652+}
5653+ 
5654+TEST_F(UtestGraphUtils, CovIsolateNodeBasic) {
5655+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5656+ auto data = builder.AddNode("data", DATA, 0, 1);
5657+ auto cast = builder.AddNode("cast", "Cast", 1, 1);
5658+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5659+ builder.AddDataEdge(data, 0, cast, 0);
5660+ builder.AddDataEdge(cast, 0, relu, 0);
5661+ EXPECT_EQ(GraphUtils::IsolateNode(cast, {0}), GRAPH_SUCCESS);
5662+}
5663+ 
5664+TEST_F(UtestGraphUtils, CovIsolateNodeOneIONull) {
5665+ EXPECT_EQ(GraphUtils::IsolateNodeOneIO(nullptr), GRAPH_PARAM_INVALID);
5666+}
5667+ 
5668+TEST_F(UtestGraphUtils, CovIsolateNodeOneIOWrongCount) {
5669+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5670+ auto node = builder.AddNode("node", "Relu", 2, 2);
5671+ EXPECT_EQ(GraphUtils::IsolateNodeOneIO(node), GRAPH_PARAM_INVALID);
5672+}
5673+ 
5674+TEST_F(UtestGraphUtils, CovReplaceNodeAnchorsNull) {
5675+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5676+ auto node = builder.AddNode("node", "Relu", 1, 1);
5677+ EXPECT_EQ(GraphUtils::ReplaceNodeAnchors(nullptr, node, {}, {}), GRAPH_PARAM_INVALID);
5678+ EXPECT_EQ(GraphUtils::ReplaceNodeAnchors(node, nullptr, {}, {}), GRAPH_PARAM_INVALID);
5679+}
5680+ 
5681+TEST_F(UtestGraphUtils, CovCopyInCtrlEdgesNull) {
5682+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5683+ auto node = builder.AddNode("node", "Relu", 1, 1);
5684+ EXPECT_EQ(GraphUtils::CopyInCtrlEdges(nullptr, node), GRAPH_PARAM_INVALID);
5685+ EXPECT_EQ(GraphUtils::CopyInCtrlEdges(node, nullptr), GRAPH_PARAM_INVALID);
5686+}
5687+ 
5688+TEST_F(UtestGraphUtils, CovCopyInCtrlEdgesBasic) {
5689+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5690+ auto src = builder.AddNode("src", "Data", 0, 0);
5691+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
5692+ auto dst = builder.AddNode("dst", "Cast", 0, 0);
5693+ builder.AddControlEdge(ctrl1, src);
5694+ EXPECT_EQ(GraphUtils::CopyInCtrlEdges(src, dst), GRAPH_SUCCESS);
5695+}
5696+ 
5697+TEST_F(UtestGraphUtils, CovMoveInCtrlEdgesNull) {
5698+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5699+ auto node = builder.AddNode("node", "Relu", 1, 1);
5700+ EXPECT_EQ(GraphUtils::MoveInCtrlEdges(nullptr, node), GRAPH_FAILED);
5701+ EXPECT_EQ(GraphUtils::MoveInCtrlEdges(node, nullptr), GRAPH_FAILED);
5702+}
5703+ 
5704+TEST_F(UtestGraphUtils, CovMoveInCtrlEdgesBasic) {
5705+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5706+ auto src = builder.AddNode("src", "Data", 0, 0);
5707+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
5708+ auto dst = builder.AddNode("dst", "Cast", 0, 0);
5709+ builder.AddControlEdge(ctrl1, src);
5710+ EXPECT_EQ(GraphUtils::MoveInCtrlEdges(src, dst), GRAPH_SUCCESS);
5711+}
5712+ 
5713+TEST_F(UtestGraphUtils, CovCopyOutCtrlEdgesNull) {
5714+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5715+ auto node = builder.AddNode("node", "Relu", 1, 1);
5716+ EXPECT_EQ(GraphUtils::CopyOutCtrlEdges(nullptr, node), GRAPH_FAILED);
5717+ EXPECT_EQ(GraphUtils::CopyOutCtrlEdges(node, nullptr), GRAPH_FAILED);
5718+}
5719+ 
5720+TEST_F(UtestGraphUtils, CovCopyOutCtrlEdgesBasic) {
5721+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5722+ auto src = builder.AddNode("src", "Data", 0, 0);
5723+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
5724+ auto dst = builder.AddNode("dst", "Cast", 0, 0);
5725+ builder.AddControlEdge(src, ctrl1);
5726+ EXPECT_EQ(GraphUtils::CopyOutCtrlEdges(src, dst), GRAPH_SUCCESS);
5727+}
5728+ 
5729+TEST_F(UtestGraphUtils, CovMoveOutCtrlEdgesNull) {
5730+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5731+ auto node = builder.AddNode("node", "Relu", 1, 1);
5732+ EXPECT_EQ(GraphUtils::MoveOutCtrlEdges(node, node), GRAPH_SUCCESS);
5733+ NodePtr null_node;
5734+ EXPECT_EQ(GraphUtils::MoveOutCtrlEdges(null_node, node), GRAPH_FAILED);
5735+}
5736+ 
5737+TEST_F(UtestGraphUtils, CovMoveOutCtrlEdgesBasic) {
5738+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5739+ auto src = builder.AddNode("src", "Data", 0, 0);
5740+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
5741+ auto dst = builder.AddNode("dst", "Cast", 0, 0);
5742+ builder.AddControlEdge(src, ctrl1);
5743+ EXPECT_EQ(GraphUtils::MoveOutCtrlEdges(src, dst), GRAPH_SUCCESS);
5744+}
5745+ 
5746+TEST_F(UtestGraphUtils, CovConvertInDataEdgesToInCtrlEdgesNull) {
5747+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5748+ auto node = builder.AddNode("node", "Relu", 1, 1);
5749+ EXPECT_EQ(GraphUtils::ConvertInDataEdgesToInCtrlEdges(nullptr, node, [](const Node &) { return true; }),
5750+ GRAPH_PARAM_INVALID);
5751+ EXPECT_EQ(GraphUtils::ConvertInDataEdgesToInCtrlEdges(node, nullptr, [](const Node &) { return true; }),
5752+ GRAPH_PARAM_INVALID);
5753+}
5754+ 
5755+TEST_F(UtestGraphUtils, CovConvertInDataEdgesToInCtrlEdgesBasic) {
5756+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5757+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
5758+ auto data2 = builder.AddNode("data2", "Data", 0, 1);
5759+ auto src = builder.AddNode("src", "AddN", 2, 1);
5760+ auto dst = builder.AddNode("dst", "Cast", 0, 0);
5761+ builder.AddDataEdge(data1, 0, src, 0);
5762+ builder.AddDataEdge(data2, 0, src, 1);
5763+ EXPECT_EQ(GraphUtils::ConvertInDataEdgesToInCtrlEdges(src, dst, [](const Node &) { return true; }), GRAPH_SUCCESS);
5764+}
5765+ 
5766+TEST_F(UtestGraphUtils, CovConvertOutDataEdgesToOutCtrlEdgesNull) {
5767+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5768+ auto node = builder.AddNode("node", "Relu", 1, 1);
5769+ EXPECT_EQ(GraphUtils::ConvertOutDataEdgesToOutCtrlEdges(nullptr, node, [](const Node &) { return true; }),
5770+ GRAPH_PARAM_INVALID);
5771+ EXPECT_EQ(GraphUtils::ConvertOutDataEdgesToOutCtrlEdges(node, nullptr, [](const Node &) { return true; }),
5772+ GRAPH_PARAM_INVALID);
5773+}
5774+ 
5775+TEST_F(UtestGraphUtils, CovConvertOutDataEdgesToOutCtrlEdgesBasic) {
5776+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5777+ auto src = builder.AddNode("src", "Data", 0, 1);
5778+ auto dst1 = builder.AddNode("dst1", "Relu", 1, 0);
5779+ auto dst2 = builder.AddNode("dst2", "Cast", 0, 0);
5780+ builder.AddDataEdge(src, 0, dst1, 0);
5781+ EXPECT_EQ(GraphUtils::ConvertOutDataEdgesToOutCtrlEdges(src, dst2, [](const Node &) { return true; }), GRAPH_SUCCESS);
5782+}
5783+ 
5784+TEST_F(UtestGraphUtils, CovFindRootGraph) {
5785+ ut::GraphBuilder builder = ut::GraphBuilder("root");
5786+ auto node = builder.AddNode("node", "Relu", 1, 1);
5787+ auto graph = builder.GetGraph();
5788+ EXPECT_EQ(GraphUtils::FindRootGraph(graph), graph);
5789+ EXPECT_EQ(GraphUtils::FindRootGraph(nullptr), nullptr);
5790+}
5791+ 
5792+TEST_F(UtestGraphUtils, CovIsUnknownShapeGraphNull) {
5793+ EXPECT_EQ(GraphUtils::IsUnknownShapeGraph(nullptr), false);
5794+}
5795+ 
5796+TEST_F(UtestGraphUtils, CovIsUnknownShapeGraphBasic) {
5797+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5798+ auto node = builder.AddNode("node", "Relu", 1, 1);
5799+ auto graph = builder.GetGraph();
5800+ EXPECT_EQ(GraphUtils::IsUnknownShapeGraph(graph), false);
5801+}
5802+ 
5803+TEST_F(UtestGraphUtils, CovAppendInputNode) {
5804+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5805+ auto data = builder.AddNode("data", DATA, 0, 1);
5806+ auto graph = builder.GetGraph();
5807+ EXPECT_EQ(GraphUtils::AppendInputNode(graph, data), GRAPH_SUCCESS);
5808+}
5809+ 
5810+TEST_F(UtestGraphUtils, CovRemoveNodesByTypeWithoutRelinkBasic) {
5811+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5812+ auto data = builder.AddNode("data", DATA, 0, 1);
5813+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5814+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
5815+ builder.AddDataEdge(data, 0, relu, 0);
5816+ builder.AddDataEdge(relu, 0, netoutput, 0);
5817+ auto graph = builder.GetGraph();
5818+ EXPECT_EQ(GraphUtils::RemoveNodesByTypeWithoutRelink(graph, std::string("Relu")), GRAPH_SUCCESS);
5819+}
5820+ 
5821+TEST_F(UtestGraphUtils, CovDumpGEGraphByPathNoSeparator) {
5822+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5823+ auto node = builder.AddNode("node", "Relu", 1, 1);
5824+ auto graph = builder.GetGraph();
5825+ EXPECT_NE(GraphUtils::DumpGEGraphByPath(graph, "no_separator_file.txt", ge::DumpLevel::NO_DUMP), GRAPH_SUCCESS);
5826+}
5827+ 
5828+TEST_F(UtestGraphUtils, CovLoadGEGraphInvalidFile) {
5829+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
5830+ EXPECT_EQ(GraphUtils::LoadGEGraph("./nonexistent_graph_file_12345.txt", *graph), false);
5831+}
5832+ 
5833+TEST_F(UtestGraphUtils, CovLoadGEGraphPtrInvalidFile) {
5834+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
5835+ EXPECT_EQ(GraphUtils::LoadGEGraph("./nonexistent_graph_file_67890.txt", graph), false);
5836+}
5837+ 
5838+TEST_F(UtestGraphUtils, CovInsertNodeAfterNullSrc) {
5839+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Relu");
5840+ EXPECT_EQ(GraphUtils::InsertNodeAfter(nullptr, {}, op_desc, 0, 0), nullptr);
5841+}
5842+ 
5843+TEST_F(UtestGraphUtils, CovInsertNodeBeforeNullSrc) {
5844+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "Relu");
5845+ EXPECT_EQ(GraphUtils::InsertNodeBefore(nullptr, op_desc, 0, 0), nullptr);
5846+}
5847+ 
5848+TEST_F(UtestGraphUtils, CovRemoveJustNodePtrNull) {
5849+ ComputeGraphPtr null_graph;
5850+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5851+ auto node = builder.AddNode("node", "Relu", 1, 1);
5852+ EXPECT_NE(GraphUtils::RemoveJustNode(null_graph, node), GRAPH_SUCCESS);
5853+}
5854+ 
5855+TEST_F(UtestGraphUtils, CovRemoveJustNodePtrNullNode) {
5856+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5857+ auto graph = builder.GetGraph();
5858+ EXPECT_NE(GraphUtils::RemoveJustNode(graph, nullptr), GRAPH_SUCCESS);
5859+}
5860+ 
5861+TEST_F(UtestGraphUtils, CovCopyInCtrlEdgesWithFilter) {
5862+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5863+ auto src = builder.AddNode("src", "Data", 0, 0);
5864+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
5865+ auto ctrl2 = builder.AddNode("ctrl2", "Cast", 0, 0);
5866+ auto dst = builder.AddNode("dst", "AddN", 0, 0);
5867+ builder.AddControlEdge(ctrl1, src);
5868+ builder.AddControlEdge(ctrl2, src);
5869+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Relu"; };
5870+ EXPECT_EQ(GraphUtils::CopyInCtrlEdges(src, dst, filter), GRAPH_SUCCESS);
5871+}
5872+ 
5873+TEST_F(UtestGraphUtils, CovCopyOutCtrlEdgesWithFilter) {
5874+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5875+ auto src = builder.AddNode("src", "Data", 0, 0);
5876+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
5877+ auto ctrl2 = builder.AddNode("ctrl2", "Cast", 0, 0);
5878+ auto dst = builder.AddNode("dst", "AddN", 0, 0);
5879+ builder.AddControlEdge(src, ctrl1);
5880+ builder.AddControlEdge(src, ctrl2);
5881+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Relu"; };
5882+ EXPECT_EQ(GraphUtils::CopyOutCtrlEdges(src, dst, filter), GRAPH_SUCCESS);
5883+}
5884+ 
5885+TEST_F(UtestGraphUtils, CovConvertInDataEdgesToInCtrlEdgesWithFilter) {
5886+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5887+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
5888+ auto data2 = builder.AddNode("data2", "Const", 0, 1);
5889+ auto src = builder.AddNode("src", "AddN", 2, 1);
5890+ auto dst = builder.AddNode("dst", "Cast", 0, 0);
5891+ builder.AddDataEdge(data1, 0, src, 0);
5892+ builder.AddDataEdge(data2, 0, src, 1);
5893+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Data"; };
5894+ EXPECT_EQ(GraphUtils::ConvertInDataEdgesToInCtrlEdges(src, dst, filter), GRAPH_SUCCESS);
5895+}
5896+ 
5897+TEST_F(UtestGraphUtils, CovConvertOutDataEdgesToOutCtrlEdgesWithFilter) {
5898+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5899+ auto src = builder.AddNode("src", "Data", 0, 1);
5900+ auto dst1 = builder.AddNode("dst1", "Relu", 1, 0);
5901+ auto dst2 = builder.AddNode("dst2", "Cast", 1, 0);
5902+ auto dst3 = builder.AddNode("dst3", "AddN", 0, 0);
5903+ builder.AddDataEdge(src, 0, dst1, 0);
5904+ builder.AddDataEdge(src, 0, dst2, 0);
5905+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Relu"; };
5906+ EXPECT_EQ(GraphUtils::ConvertOutDataEdgesToOutCtrlEdges(src, dst3, filter), GRAPH_SUCCESS);
5907+}
5908+ 
5909+TEST_F(UtestGraphUtils, CovIsolateNodeWithControlEdge) {
5910+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5911+ auto data = builder.AddNode("data", DATA, 0, 1);
5912+ auto cast = builder.AddNode("cast", "Cast", 1, 1);
5913+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5914+ auto ctrl = builder.AddNode("ctrl", "NoOp", 0, 0);
5915+ builder.AddDataEdge(data, 0, cast, 0);
5916+ builder.AddDataEdge(cast, 0, relu, 0);
5917+ builder.AddControlEdge(cast, ctrl);
5918+ EXPECT_EQ(GraphUtils::IsolateNode(cast, {0}), GRAPH_SUCCESS);
5919+}
5920+ 
5921+TEST_F(UtestGraphUtils, CovIsolateNodeNoIoMap) {
5922+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5923+ auto data = builder.AddNode("data", DATA, 0, 1);
5924+ auto cast = builder.AddNode("cast", "Cast", 1, 1);
5925+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5926+ builder.AddDataEdge(data, 0, cast, 0);
5927+ builder.AddDataEdge(cast, 0, relu, 0);
5928+ EXPECT_EQ(GraphUtils::IsolateNode(cast, {}), GRAPH_SUCCESS);
5929+}
5930+ 
5931+TEST_F(UtestGraphUtils, CovIsolateNodeOneIOBasic) {
5932+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5933+ auto data = builder.AddNode("data", DATA, 0, 1);
5934+ auto cast = builder.AddNode("cast", "Cast", 1, 1);
5935+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5936+ builder.AddDataEdge(data, 0, cast, 0);
5937+ builder.AddDataEdge(cast, 0, relu, 0);
5938+ EXPECT_EQ(GraphUtils::IsolateNodeOneIO(cast), GRAPH_SUCCESS);
5939+}
5940+ 
5941+TEST_F(UtestGraphUtils, CovWriteProtoToOStream) {
5942+ onnx::ModelProto model_proto;
5943+ model_proto.set_producer_name("test_ostream");
5944+ std::ostringstream os;
5945+ EXPECT_EQ(GraphUtils::WriteProtoToOStream(model_proto, os), SUCCESS);
5946+ EXPECT_TRUE(os.str().find("test_ostream") != std::string::npos);
5947+}
5948+ 
5949+TEST_F(UtestGraphUtils, CovWriteProtoToOStreamNullStream) {
5950+ onnx::ModelProto model_proto;
5951+ model_proto.set_producer_name("test_null_stream");
5952+ std::ostringstream os;
5953+ os.setstate(std::ios::badbit);
5954+ EXPECT_EQ(GraphUtils::WriteProtoToOStream(model_proto, os), SUCCESS);
5955+}
5956+ 
5957+TEST_F(UtestGraphUtils, CovReplaceNodeAnchorsBasic) {
5958+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5959+ auto data = builder.AddNode("data", DATA, 0, 1);
5960+ auto old_node = builder.AddNode("old", "Cast", 1, 1);
5961+ auto new_node = builder.AddNode("new", "Relu", 1, 1);
5962+ auto dst = builder.AddNode("dst", "AddN", 1, 1);
5963+ builder.AddDataEdge(data, 0, old_node, 0);
5964+ builder.AddDataEdge(old_node, 0, dst, 0);
5965+ EXPECT_EQ(GraphUtils::ReplaceNodeAnchors(new_node, old_node, {0}, {0}), GRAPH_SUCCESS);
5966+}
5967+ 
5968+TEST_F(UtestGraphUtils, CovRemoveSubgraphRecursively) {
5969+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
5970+ auto data = builder.AddNode("data", DATA, 0, 1);
5971+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
5972+ builder.AddDataEdge(data, 0, relu, 0);
5973+ auto graph = builder.GetGraph();
5974+ EXPECT_EQ(GraphUtils::RemoveNodeWithoutRelink(graph, relu), GRAPH_SUCCESS);
5975+}
5976+ 
5977+TEST_F(UtestGraphUtils, CovRemoveNodeWithoutRelinkNotInGraph) {
5978+ ut::GraphBuilder builder1 = ut::GraphBuilder("graph1");
5979+ ut::GraphBuilder builder2 = ut::GraphBuilder("graph2");
5980+ auto node = builder1.AddNode("node", "Relu", 1, 1);
5981+ auto graph2 = builder2.GetGraph();
5982+ EXPECT_EQ(GraphUtils::RemoveNodeWithoutRelink(graph2, node), GRAPH_FAILED);
5983+}
5584} // namespace ge5984} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ir_data_type_symbol_store_cov_unittest.cc+152-0
@@ -237,4 +237,156 @@ TEST_F(UtestIRDataTypeSymbolStore, CovIsSupportOrderedSymbolicInferDtypeNullptrS
237 EXPECT_FALSE(store.IsSupportOrderedSymbolicInferDtype());237 EXPECT_FALSE(store.IsSupportOrderedSymbolicInferDtype());
238}238}
239 239 
240+REG_OP(OpTestInferDtypeMultiOutput)
241+ .INPUT(x, "T")
242+ .OUTPUT(y, "T")
243+ .OUTPUT(z, "T")
244+ .DATATYPE(T, TensorType({DT_FLOAT, DT_INT32}))
245+ .OP_END_FACTORY_REG(OpTestInferDtypeMultiOutput);
246+ 
247+TEST_F(UtestIRDataTypeSymbolStore, CovInferDtypeMultiOutputSameSym) {
248+ auto op = op::OpTestInferDtypeMultiOutput();
249+ auto desc = OpDescUtils::GetOpDescFromOperator(op);
250+ GeTensorDesc input_desc(GeShape({1}), FORMAT_ND, DT_FLOAT);
251+ desc->UpdateInputDesc("x", input_desc);
252+ desc->UpdateOutputDesc("y", GeTensorDesc(GeShape({1}), FORMAT_ND, DT_FLOAT));
253+ desc->UpdateOutputDesc("z", GeTensorDesc(GeShape({1}), FORMAT_ND, DT_FLOAT));
254+ const auto &sym_store = desc->impl_->GetIRMeta().GetIRDataTypeSymbolStore();
255+ auto ret = sym_store.InferDtype(desc);
256+ EXPECT_EQ(ret, GRAPH_SUCCESS);
257+ EXPECT_EQ(desc->GetOutputDesc("y").GetDataType(), DT_FLOAT);
258+ EXPECT_EQ(desc->GetOutputDesc("z").GetDataType(), DT_FLOAT);
259+}
260+ 
261+REG_OP(OpTestInferDtypeIntInput)
262+ .INPUT(x, "T")
263+ .OUTPUT(y, "T")
264+ .DATATYPE(T, TensorType({DT_FLOAT, DT_INT32}))
265+ .OP_END_FACTORY_REG(OpTestInferDtypeIntInput);
266+ 
267+TEST_F(UtestIRDataTypeSymbolStore, CovInferDtypeIntInputType) {
268+ auto op = op::OpTestInferDtypeIntInput();
269+ auto desc = OpDescUtils::GetOpDescFromOperator(op);
270+ GeTensorDesc input_desc(GeShape({1}), FORMAT_ND, DT_INT32);
271+ desc->UpdateInputDesc("x", input_desc);
272+ desc->UpdateOutputDesc("y", GeTensorDesc(GeShape({1}), FORMAT_ND, DT_FLOAT));
273+ const auto &sym_store = desc->impl_->GetIRMeta().GetIRDataTypeSymbolStore();
274+ auto ret = sym_store.InferDtype(desc);
275+ EXPECT_EQ(ret, GRAPH_SUCCESS);
276+ EXPECT_EQ(desc->GetOutputDesc("y").GetDataType(), DT_INT32);
277+}
278+ 
279+TEST_F(UtestIRDataTypeSymbolStore, CovDeclareSymbolOrderedTensorTypeListDuplicate) {
280+ IRDataTypeSymbolStore store;
281+ OrderedTensorTypeList types({DT_FLOAT, DT_INT32});
282+ auto *sym1 = store.DeclareSymbol("dup_ordered_sym", types);
283+ ASSERT_NE(sym1, nullptr);
284+ auto *sym2 = store.DeclareSymbol("dup_ordered_sym", types);
285+ EXPECT_EQ(sym2, nullptr);
286+}
287+ 
288+TEST_F(UtestIRDataTypeSymbolStore, CovIsSupportOrderedSymbolicInferDtypeAllNullptr) {
289+ IRDataTypeSymbolStore store;
290+ store.GetOrCreateSymbol("null_sym1");
291+ store.GetOrCreateSymbol("null_sym2");
292+ EXPECT_FALSE(store.IsSupportOrderedSymbolicInferDtype());
293+}
294+ 
295+TEST_F(UtestIRDataTypeSymbolStore, CovGetOrCreateSymbolExisting) {
296+ IRDataTypeSymbolStore store;
297+ auto *sym1 = store.GetOrCreateSymbol("existing_sym");
298+ ASSERT_NE(sym1, nullptr);
299+ auto *sym2 = store.GetOrCreateSymbol("existing_sym");
300+ EXPECT_EQ(sym1, sym2);
301+}
302+ 
303+TEST_F(UtestIRDataTypeSymbolStore, CovSetInputSymbol) {
304+ IRDataTypeSymbolStore store;
305+ auto *sym = store.SetInputSymbol("x", kIrInputRequired, "input_sym");
306+ ASSERT_NE(sym, nullptr);
307+ EXPECT_EQ(sym->Id(), "input_sym");
308+}
309+ 
310+TEST_F(UtestIRDataTypeSymbolStore, CovDeclareSymbolPromoteSelf) {
311+ IRDataTypeSymbolStore store;
312+ store.SetInputSymbol("x", kIrInputRequired, "self_sym");
313+ Promote promote({"self_sym", "self_sym"});
314+ auto *sym = store.DeclareSymbol("self_sym", promote);
315+ EXPECT_EQ(sym, nullptr);
316+}
317+ 
318+TEST_F(UtestIRDataTypeSymbolStore, CovIsSupportSymbolicInferDtypeEmpty) {
319+ IRDataTypeSymbolStore store;
320+ store.SetInputSymbol("x", kIrInputRequired, "input_only_sym");
321+ EXPECT_FALSE(store.IsSupportSymbolicInferDtype());
322+}
323+ 
324+TEST_F(UtestIRDataTypeSymbolStore, IncCov_TypeOrTypesMethods) {
325+ TypeOrTypes tot;
326+ DataType dt;
327+ EXPECT_EQ(tot.GetType(dt), GRAPH_FAILED);
328+ std::vector<DataType> dts;
329+ EXPECT_EQ(tot.GetTypes(dts), GRAPH_FAILED);
330+ EXPECT_EQ(tot.UnsafeGetType(), DT_UNDEFINED);
331+ EXPECT_TRUE(tot.UnsafeGetTypes().empty());
332+ EXPECT_EQ(tot.DebugString(), "Uninitialized");
333+ 
334+ tot.SetType(DT_FLOAT);
335+ EXPECT_EQ(tot.GetType(dt), GRAPH_SUCCESS);
336+ EXPECT_EQ(dt, DT_FLOAT);
337+ EXPECT_EQ(tot.GetTypes(dts), GRAPH_FAILED);
338+ 
339+ tot.SetTypes({DT_FLOAT, DT_INT32});
340+ EXPECT_EQ(tot.GetType(dt), GRAPH_FAILED);
341+ EXPECT_EQ(tot.GetTypes(dts), GRAPH_SUCCESS);
342+ EXPECT_EQ(dts.size(), 2U);
343+}
344+ 
345+TEST_F(UtestIRDataTypeSymbolStore, IncCov_SymDtypeExpressionMethods) {
346+ IRDataTypeSymbolStore store;
347+ TensorType types1({DT_FLOAT, DT_INT32});
348+ TensorType types2({DT_FLOAT, DT_INT32});
349+ store.DeclareSymbol("sym_x", types1);
350+ store.DeclareSymbol("sym_y", types2);
351+ store.SetInputSymbol("x", kIrInputRequired, "sym_x");
352+ store.SetInputSymbol("y", kIrInputRequired, "sym_y");
353+ Promote promote({"sym_x", "sym_y"});
354+ auto *promote_sym = store.DeclareSymbol("promote_sym", promote);
355+ ASSERT_NE(promote_sym, nullptr);
356+ EXPECT_FALSE(promote_sym->IsListType());
357+ EXPECT_EQ(promote_sym->Type(), ExpressionType::kPromote);
358+ auto indexes = promote_sym->GetIrInputIndexes();
359+ EXPECT_EQ(indexes.size(), 2U);
360+}
361+ 
362+TEST_F(UtestIRDataTypeSymbolStore, IncCov_SymDtypeGetDirectIrInputIndexes) {
363+ IRDataTypeSymbolStore store;
364+ TensorType types({DT_FLOAT, DT_INT32});
365+ auto *sym = store.DeclareSymbol("sym1", types);
366+ ASSERT_NE(sym, nullptr);
367+ store.SetInputSymbol("x", kIrInputRequired, "sym1");
368+ store.SetInputSymbol("y", kIrInputDynamic, "sym1");
369+ auto indexes = sym->GetIrInputIndexes();
370+ EXPECT_EQ(indexes.size(), 2U);
371+ EXPECT_EQ(sym->Type(), ExpressionType::kSingle);
372+ EXPECT_FALSE(sym->IsLegacy());
373+}
374+ 
375+REG_OP(OpTestInferDtypeOutOfRange)
376+ .INPUT(x, "T")
377+ .OUTPUT(y, "T")
378+ .DATATYPE(T, TensorType({DT_FLOAT, DT_INT32}))
379+ .OP_END_FACTORY_REG(OpTestInferDtypeOutOfRange);
380+ 
381+TEST_F(UtestIRDataTypeSymbolStore, IncCov_InferDtypeOutOfRange) {
382+ auto op = op::OpTestInferDtypeOutOfRange();
383+ auto desc = OpDescUtils::GetOpDescFromOperator(op);
384+ GeTensorDesc input_desc(GeShape({1}), FORMAT_ND, DT_BOOL);
385+ desc->UpdateInputDesc("x", input_desc);
386+ desc->UpdateOutputDesc("y", GeTensorDesc(GeShape({1}), FORMAT_ND, DT_FLOAT));
387+ const auto &sym_store = desc->impl_->GetIRMeta().GetIRDataTypeSymbolStore();
388+ auto ret = sym_store.InferDtype(desc);
389+ EXPECT_NE(ret, GRAPH_SUCCESS);
390+}
391+ 
240} // namespace ge392} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/ir_definitions_recover_test.cc+171-0
@@ -638,4 +638,175 @@ TEST_F(IrDefinitionsRecoverUT, DeriveCompatibilityStrategy_backward_input_only)
638 auto strategy = RecoverIrUtils::DeriveCompatibilityStrategy(op_desc, ir_def);638 auto strategy = RecoverIrUtils::DeriveCompatibilityStrategy(op_desc, ir_def);
639 EXPECT_EQ(strategy, ge::CompatibilityStrategy::kBackward);639 EXPECT_EQ(strategy, ge::CompatibilityStrategy::kBackward);
640}640}
641+ 
642+TEST_F(IrDefinitionsRecoverUT, IncCov_UnknownIrInputType) {
643+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
644+ ASSERT_NE(op_desc, nullptr);
645+ auto computeGraph = std::make_shared<ge::ComputeGraph>("graph_name");
646+ ASSERT_NE(computeGraph, nullptr);
647+ ASSERT_NE(computeGraph->AddNode(op_desc), nullptr);
648+ 
649+ auto op = ge::OperatorFactory::CreateOperator("MatMulUt", "MatMulUt");
650+ auto op_desc_origin = ge::OpDescUtils::GetOpDescFromOperator(op);
651+ 
652+ op_desc->impl_->meta_data_.ir_meta_.ir_attr_names_ = op_desc_origin->GetIrAttrNames();
653+ op_desc->impl_->meta_data_.ir_meta_.ir_inputs_.ir_inputs = {{"x1", static_cast<ge::IrInputType>(999)}};
654+ ASSERT_FALSE(op_desc->impl_->meta_data_.ir_meta_.ir_inputs_.ir_inputs.empty());
655+ auto ret = RecoverIrUtils::RecoverIrDefinitions(computeGraph);
656+ EXPECT_NE(ret, ge::GRAPH_SUCCESS);
657+}
658+ 
659+TEST_F(IrDefinitionsRecoverUT, IncCov_UnknownIrOutputType) {
660+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
661+ ASSERT_NE(op_desc, nullptr);
662+ auto computeGraph = std::make_shared<ge::ComputeGraph>("graph_name");
663+ ASSERT_NE(computeGraph, nullptr);
664+ ASSERT_NE(computeGraph->AddNode(op_desc), nullptr);
665+ 
666+ auto op = ge::OperatorFactory::CreateOperator("MatMulUt", "MatMulUt");
667+ auto op_desc_origin = ge::OpDescUtils::GetOpDescFromOperator(op);
668+ 
669+ op_desc->impl_->meta_data_.ir_meta_.ir_attr_names_ = op_desc_origin->GetIrAttrNames();
670+ op_desc->impl_->meta_data_.ir_meta_.ir_inputs_.ir_inputs = op_desc_origin->GetIrInputs();
671+ op_desc->impl_->meta_data_.ir_meta_.ir_outputs_.ir_outputs = {{"y", static_cast<ge::IrOutputType>(999)}};
672+ ASSERT_FALSE(op_desc->impl_->meta_data_.ir_meta_.ir_outputs_.ir_outputs.empty());
673+ auto ret = RecoverIrUtils::RecoverIrDefinitions(computeGraph);
674+ EXPECT_NE(ret, ge::GRAPH_SUCCESS);
675+}
676+ 
677+TEST_F(IrDefinitionsRecoverUT, IncCov_RecoverOpDescIrDefinition_KFailedStrategy) {
678+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
679+ ASSERT_NE(op_desc, nullptr);
680+ auto computeGraph = std::make_shared<ge::ComputeGraph>("graph_name");
681+ ASSERT_NE(computeGraph, nullptr);
682+ ASSERT_NE(computeGraph->AddNode(op_desc), nullptr);
683+ 
684+ op_desc->AppendIrAttrName("extra_attr1");
685+ op_desc->AppendIrAttrName("extra_attr2");
686+ op_desc->AppendIrAttrName("extra_attr3");
687+ op_desc->AppendIrAttrName("extra_attr4");
688+ 
689+ auto ret = RecoverIrUtils::RecoverIrDefinitions(computeGraph);
690+ EXPECT_NE(ret, ge::GRAPH_SUCCESS);
691+}
692+ 
693+TEST_F(IrDefinitionsRecoverUT, IncCov_RecoverIrDefinitions_DataNode) {
694+ auto op_desc = std::make_shared<ge::OpDesc>("data", "Data");
695+ ASSERT_NE(op_desc, nullptr);
696+ auto computeGraph = std::make_shared<ge::ComputeGraph>("graph_name");
697+ ASSERT_NE(computeGraph, nullptr);
698+ ASSERT_NE(computeGraph->AddNode(op_desc), nullptr);
699+ 
700+ auto ret = RecoverIrUtils::RecoverIrDefinitions(computeGraph);
701+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
702+}
703+ 
704+TEST_F(IrDefinitionsRecoverUT, IncCov_RecoverIrDefinitions_NetOutputNode) {
705+ auto op_desc = std::make_shared<ge::OpDesc>("netoutput", "NetOutput");
706+ ASSERT_NE(op_desc, nullptr);
707+ auto computeGraph = std::make_shared<ge::ComputeGraph>("graph_name");
708+ ASSERT_NE(computeGraph, nullptr);
709+ ASSERT_NE(computeGraph->AddNode(op_desc), nullptr);
710+ 
711+ auto ret = RecoverIrUtils::RecoverIrDefinitions(computeGraph);
712+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
713+}
714+ 
715+TEST_F(IrDefinitionsRecoverUT, IncCov_RecoverOpDescIrDefinition_WithOpType) {
716+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
717+ ASSERT_NE(op_desc, nullptr);
718+ 
719+ auto op = ge::OperatorFactory::CreateOperator("MatMulUt", "MatMulUt");
720+ auto op_desc_origin = ge::OpDescUtils::GetOpDescFromOperator(op);
721+ 
722+ for (const auto &attr : op_desc_origin->GetIrAttrNames()) {
723+ op_desc->AppendIrAttrName(attr);
724+ }
725+ for (const auto &pair : op_desc_origin->GetIrInputs()) {
726+ op_desc->AppendIrInput(pair.first, pair.second);
727+ }
728+ 
729+ auto ret = RecoverIrUtils::RecoverOpDescIrDefinition(op_desc, "");
730+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
731+}
732+ 
733+TEST_F(IrDefinitionsRecoverUT, IncCov_CheckIrSpec_Success) {
734+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
735+ ASSERT_NE(op_desc, nullptr);
736+ 
737+ auto op = ge::OperatorFactory::CreateOperator("MatMulUt", "MatMulUt");
738+ auto op_desc_origin = ge::OpDescUtils::GetOpDescFromOperator(op);
739+ 
740+ for (const auto &attr : op_desc_origin->GetIrAttrNames()) {
741+ op_desc->AppendIrAttrName(attr);
742+ }
743+ for (const auto &pair : op_desc_origin->GetIrInputs()) {
744+ op_desc->AppendIrInput(pair.first, pair.second);
745+ }
746+ for (const auto &pair : op_desc_origin->GetIrOutputs()) {
747+ op_desc->AppendIrOutput(pair.first, pair.second);
748+ }
749+ 
750+ GeTensorDesc tensor_desc;
751+ op_desc->AddInputDesc(tensor_desc);
752+ op_desc->AddInputDesc(tensor_desc);
753+ op_desc->AddOutputDesc(tensor_desc);
754+ (void)AttrUtils::SetBool(op_desc, "transpose_x1", true);
755+ (void)AttrUtils::SetBool(op_desc, "transpose_x2", false);
756+ (void)AttrUtils::SetBool(op_desc, "loss_attr", true);
757+ 
758+ auto ret = CheckIrSpec(op_desc);
759+ EXPECT_TRUE(ret);
760+}
761+ 
762+TEST_F(IrDefinitionsRecoverUT, IncCov_RecoverIrDefinitions_SubgraphFailure) {
763+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
764+ ASSERT_NE(op_desc, nullptr);
765+ auto computeGraph = std::make_shared<ge::ComputeGraph>("graph_name");
766+ ASSERT_NE(computeGraph, nullptr);
767+ ASSERT_NE(computeGraph->AddNode(op_desc), nullptr);
768+ 
769+ auto sub_op_desc = std::make_shared<ge::OpDesc>("sub_matmul", "MatMulUt");
770+ ASSERT_NE(sub_op_desc, nullptr);
771+ sub_op_desc->AppendIrAttrName("extra_attr1");
772+ sub_op_desc->AppendIrAttrName("extra_attr2");
773+ sub_op_desc->AppendIrAttrName("extra_attr3");
774+ sub_op_desc->AppendIrAttrName("extra_attr4");
775+ 
776+ auto sub_graph = std::make_shared<ge::ComputeGraph>("sub_graph");
777+ ASSERT_NE(sub_graph, nullptr);
778+ sub_graph->AddNode(sub_op_desc);
779+ 
780+ (void)ge::AttrUtils::SetGraph(op_desc, "subgraph_attr", sub_graph);
781+ 
782+ auto ret = RecoverIrUtils::RecoverIrDefinitions(computeGraph, {"subgraph_attr"});
783+ EXPECT_NE(ret, ge::GRAPH_SUCCESS);
784+}
785+ 
786+TEST_F(IrDefinitionsRecoverUT, IncCov_RecoverIrAttrDefaultValue_Success) {
787+ auto op_desc = std::make_shared<ge::OpDesc>("matmul", "MatMulUt");
788+ ASSERT_NE(op_desc, nullptr);
789+ 
790+ auto op = ge::OperatorFactory::CreateOperator("MatMulUt", "MatMulUt");
791+ auto op_desc_origin = ge::OpDescUtils::GetOpDescFromOperator(op);
792+ 
793+ ge::RecoverIrUtils::IrDefinition ir_def;
794+ ir_def.inited = false;
795+ RecoverIrUtils::InitIrDefinitionsIfNeed("MatMulUt", ir_def);
796+ ASSERT_TRUE(ir_def.inited);
797+ 
798+ for (const auto &attr : op_desc_origin->GetIrAttrNames()) {
799+ op_desc->AppendIrAttrName(attr);
800+ }
801+ for (const auto &pair : op_desc_origin->GetIrInputs()) {
802+ op_desc->AppendIrInput(pair.first, pair.second);
803+ }
804+ 
805+ (void)AttrUtils::SetBool(op_desc, "transpose_x1", true);
806+ auto ret = RecoverIrUtils::RecoverIrAttrDefaultValue(op_desc, "MatMulUt", ir_def);
807+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
808+ bool val = false;
809+ EXPECT_TRUE(AttrUtils::GetBool(op_desc, "transpose_x2", val));
810+ EXPECT_EQ(val, false);
811+}
641} // namespace gert812} // namespace gert
Mtests/graph_metadef/ut/graph/testcase/model_inc_cov_unittest.cc+55-0
@@ -314,4 +314,59 @@ TEST_F(ModelIncCovUt, IncCov2_SaveToFile_NoDirNoWorkPath) {
314 EXPECT_EQ(md.SaveToFile("just_a_file_inc.air"), GRAPH_SUCCESS);314 EXPECT_EQ(md.SaveToFile("just_a_file_inc.air"), GRAPH_SUCCESS);
315 system("rm -f just_a_file_inc.air");315 system("rm -f just_a_file_inc.air");
316}316}
317+ 
318+TEST_F(ModelIncCovUt, IncCov2_SaveToFile_NoGraph) {
319+ Model model("test_no_graph", "v1");
320+ system("mkdir -p ./tmp_model_inc_cov");
321+ EXPECT_NE(model.SaveToFile("./tmp_model_inc_cov/no_graph.air", false), GRAPH_SUCCESS);
322+ system("rm -f ./tmp_model_inc_cov/no_graph.air");
323+}
324+ 
325+TEST_F(ModelIncCovUt, IncCov2_SaveToFile_NoGraphForceSeparate) {
326+ Model model("test_no_graph_sep", "v1");
327+ system("mkdir -p ./tmp_model_inc_cov");
328+ EXPECT_NE(model.SaveToFile("./tmp_model_inc_cov/no_graph_sep.air", true), GRAPH_SUCCESS);
329+ system("rm -f ./tmp_model_inc_cov/no_graph_sep.air");
330+}
331+ 
332+TEST_F(ModelIncCovUt, IncCov2_LoadFromFile_EmptyFile) {
333+ system("mkdir -p ./tmp_model_inc_cov");
334+ std::string file_path = "./tmp_model_inc_cov/empty.air";
335+ std::ofstream ofs(file_path, std::ios::binary);
336+ if (ofs.is_open()) {
337+ ofs.close();
338+ }
339+ Model model;
340+ EXPECT_EQ(model.LoadFromFile(file_path), GRAPH_FAILED);
341+ system(("rm -f " + file_path).c_str());
342+}
343+ 
344+TEST_F(ModelIncCovUt, IncCov2_LoadFromFile_PermissionDenied) {
345+ system("mkdir -p ./tmp_model_inc_cov");
346+ std::string file_path = "./tmp_model_inc_cov/noperm.air";
347+ std::ofstream ofs(file_path, std::ios::binary);
348+ if (ofs.is_open()) {
349+ ofs.write("data", 4);
350+ ofs.close();
351+ }
352+ system(("chmod 000 " + file_path).c_str());
353+ Model model;
354+ EXPECT_EQ(model.LoadFromFile(file_path), GRAPH_FAILED);
355+ system(("chmod 644 " + file_path).c_str());
356+ system(("rm -f " + file_path).c_str());
357+}
358+ 
359+TEST_F(ModelIncCovUt, IncCov2_LoadFromFile_InvalidProtobufContent) {
360+ system("mkdir -p ./tmp_model_inc_cov");
361+ std::string file_path = "./tmp_model_inc_cov/invalid_proto.air";
362+ std::ofstream ofs(file_path, std::ios::binary);
363+ if (ofs.is_open()) {
364+ std::string invalid_data(128, '\xFF');
365+ ofs.write(invalid_data.data(), static_cast<std::streamsize>(invalid_data.size()));
366+ ofs.close();
367+ }
368+ Model model;
369+ EXPECT_EQ(model.LoadFromFile(file_path), GRAPH_FAILED);
370+ system(("rm -f " + file_path).c_str());
371+}
317} // namespace ge372} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/node_unittest.cc+125-0
@@ -527,4 +527,129 @@ TEST_F(UtestNode, IncCov_NodeAllAnchorsAndNodes) {
527 EXPECT_EQ(node2->GetInNodesSize(), 2U);527 EXPECT_EQ(node2->GetInNodesSize(), 2U);
528 EXPECT_EQ(node1->GetOutNodesSize(), 2U);528 EXPECT_EQ(node1->GetOutNodesSize(), 2U);
529}529}
530+ 
531+TEST_F(UtestNode, IncCov_IsAllInNodesSeen_NextIteration) {
532+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
533+ auto node1 = builder.AddNode("NextIter", "NextIteration", 1, 1);
534+ auto node2 = builder.AddNode("Data2", "Data", 1, 1);
535+ builder.AddDataEdge(node1, 0, node2, 0);
536+ std::unordered_set<Node *> us;
537+ EXPECT_EQ(node2->IsAllInNodesSeen(us), true);
538+}
539+ 
540+TEST_F(UtestNode, IncCov_IsAllInNodesSeen_RefNextIteration) {
541+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
542+ auto node1 = builder.AddNode("RefNextIter", "RefNextIteration", 1, 1);
543+ auto node2 = builder.AddNode("Data2", "Data", 1, 1);
544+ builder.AddDataEdge(node1, 0, node2, 0);
545+ std::unordered_set<Node *> us;
546+ EXPECT_EQ(node2->IsAllInNodesSeen(us), true);
547+}
548+ 
549+TEST_F(UtestNode, IncCov_GetInDataNodesAndAnchors_NullOwnerNode) {
550+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
551+ auto node1 = builder.AddNode("Data1", "Data", 1, 1);
552+ auto node2 = builder.AddNode("Data2", "Data", 1, 1);
553+ builder.AddDataEdge(node1, 0, node2, 0);
554+ 
555+ auto existing_peer = node2->GetInDataAnchor(0)->GetPeerOutAnchor();
556+ EXPECT_EQ(node2->GetInDataAnchor(0)->Unlink(existing_peer), GRAPH_SUCCESS);
557+ OutDataAnchorPtr null_out = std::make_shared<OutDataAnchor>(nullptr, 0);
558+ EXPECT_EQ(node2->GetInDataAnchor(0)->LinkFrom(null_out), GRAPH_SUCCESS);
559+ 
560+ EXPECT_EQ(node2->GetInDataNodesAndAnchors().size(), 0U);
561+ node2->GetInDataAnchor(0)->Unlink(null_out);
562+}
563+ 
564+TEST_F(UtestNode, IncCov_GetOutDataNodesAndAnchors_NullDstNode) {
565+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
566+ auto node1 = builder.AddNode("Data1", "Data", 1, 1);
567+ auto node2 = builder.AddNode("Data2", "Data", 1, 1);
568+ builder.AddDataEdge(node1, 0, node2, 0);
569+ 
570+ auto existing_peer = node2->GetInDataAnchor(0);
571+ EXPECT_EQ(node1->GetOutDataAnchor(0)->Unlink(existing_peer), GRAPH_SUCCESS);
572+ InDataAnchorPtr null_in = std::make_shared<InDataAnchor>(nullptr, 0);
573+ EXPECT_EQ(node1->GetOutDataAnchor(0)->LinkTo(null_in), GRAPH_SUCCESS);
574+ 
575+ EXPECT_EQ(node1->GetOutDataNodesAndAnchors().size(), 0U);
576+ node1->GetOutDataAnchor(0)->Unlink(null_in);
577+}
578+ 
579+TEST_F(UtestNode, IncCov_NodeInConnectsAreEqual_AnchorMismatch) {
580+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
581+ auto node1 = builder.AddNode("Data1", "Data", 1, 1);
582+ auto node2 = builder.AddNode("Data2", "Data", 1, 1);
583+ auto src1 = builder.AddNode("Src1", "Data", 0, 1);
584+ auto src2 = builder.AddNode("Src2", "Data", 0, 1);
585+ builder.AddDataEdge(src1, 0, node1, 0);
586+ builder.AddDataEdge(src2, 0, node2, 0);
587+ EXPECT_EQ(node1->NodeInConnectsAreEqual(*node2), false);
588+}
589+ 
590+TEST_F(UtestNode, IncCov_NodeOutConnectsAreEqual_AnchorMismatch) {
591+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
592+ auto node1 = builder.AddNode("Data1", "Data", 1, 1);
593+ auto node2 = builder.AddNode("Data2", "Data", 1, 1);
594+ auto dst1 = builder.AddNode("Dst1", "Data", 1, 0);
595+ auto dst2 = builder.AddNode("Dst2", "Data", 1, 0);
596+ builder.AddDataEdge(node1, 0, dst1, 0);
597+ builder.AddDataEdge(node2, 0, dst2, 0);
598+ EXPECT_EQ(node1->NodeOutConnectsAreEqual(*node2), false);
599+}
600+ 
601+TEST_F(UtestNode, IncCov_AddLinkFromByIndex_OverSize) {
602+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
603+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
604+ auto attr_node = builder.AddNode("Attr", "Attr", 2, 2);
605+ EXPECT_EQ(attr_node->AddLinkFrom(10, data_node), GRAPH_PARAM_INVALID);
606+}
607+ 
608+TEST_F(UtestNode, IncCov_AddLinkFromForParse_MultipleOutAnchors) {
609+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
610+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
611+ auto multi_out_node = builder.AddNode("MultiOut", "MultiOut", 0, 2);
612+ EXPECT_EQ(data_node->AddLinkFromForParse(multi_out_node), GRAPH_PARAM_INVALID);
613+}
614+ 
615+TEST_F(UtestNode, IncCov_AddLinkFrom_MultipleOutAnchors) {
616+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
617+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
618+ auto multi_out_node = builder.AddNode("MultiOut", "MultiOut", 0, 2);
619+ EXPECT_EQ(data_node->AddLinkFrom(multi_out_node), GRAPH_PARAM_INVALID);
620+}
621+ 
622+TEST_F(UtestNode, IncCov_AddLinkFromByName_MultipleOutAnchors) {
623+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
624+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
625+ auto multi_out_node = builder.AddNode("MultiOut", "MultiOut", 0, 2);
626+ EXPECT_EQ(data_node->AddLinkFrom("input0", multi_out_node), GRAPH_PARAM_INVALID);
627+}
628+ 
629+TEST_F(UtestNode, IncCov_NodeEqual_SameNode) {
630+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
631+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
632+ EXPECT_EQ((*data_node) == (*data_node), true);
633+}
634+ 
635+TEST_F(UtestNode, IncCov_NodeAnchorIsEqual_DifferentPeerNames) {
636+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
637+ auto node1 = builder.AddNode("Node1", "Data", 1, 1);
638+ auto node2 = builder.AddNode("Node2", "Data", 1, 1);
639+ auto src1 = builder.AddNode("Src1", "Data", 0, 1);
640+ auto src2 = builder.AddNode("Src2", "Data", 0, 1);
641+ builder.AddDataEdge(src1, 0, node1, 0);
642+ builder.AddDataEdge(src2, 0, node2, 0);
643+ 
644+ auto left_anchor = node1->GetInDataAnchor(0);
645+ auto right_anchor = node2->GetInDataAnchor(0);
646+ EXPECT_EQ(node1->NodeAnchorIsEqual(left_anchor, right_anchor, 0), false);
647+}
648+ 
649+TEST_F(UtestNode, IncCov_GetOutDataNodesSize_NullAnchor) {
650+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
651+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
652+ data_node->impl_->out_data_anchors_.push_back(nullptr);
653+ EXPECT_EQ(data_node->GetOutDataNodesSize(), 0U);
654+}
530} // namespace ge655} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/node_utils_unittest.cc+229-0
@@ -1225,4 +1225,233 @@ TEST_F(UtestNodeUtils, CovRemoveSubgraphsOnNodeNullPtr) {
1225 NodePtr null_node;1225 NodePtr null_node;
1226 EXPECT_NE(NodeUtils::RemoveSubgraphsOnNode(null_node), GRAPH_SUCCESS);1226 EXPECT_NE(NodeUtils::RemoveSubgraphsOnNode(null_node), GRAPH_SUCCESS);
1227}1227}
1228+ 
1229+TEST_F(UtestNodeUtils, CovGetOutputDescNullOpDesc) {
1230+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1231+ auto node = builder.AddNode("Node", "Node", 1, 1);
1232+ node->impl_->op_ = nullptr;
1233+ auto desc = NodeUtils::GetOutputDesc(*node, 0);
1234+ EXPECT_EQ(desc.GetDataType(), DT_FLOAT);
1235+}
1236+ 
1237+TEST_F(UtestNodeUtils, CovGetSubgraphNullRootGraph) {
1238+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1239+ auto node = builder.AddNode("Node", "Node", 1, 1);
1240+ node->impl_->owner_graph_.reset();
1241+ EXPECT_EQ(NodeUtils::GetSubgraph(*node, 0), nullptr);
1242+}
1243+ 
1244+TEST_F(UtestNodeUtils, CovIsMultiBranchControlFlowOpNull) {
1245+ EXPECT_EQ(NodeUtils::IsMultiBranchControlFlowOp(nullptr), false);
1246+}
1247+ 
1248+TEST_F(UtestNodeUtils, CovIsMultiBranchControlFlowOpTrue) {
1249+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1250+ auto if_node = builder.AddNode("if_node", "If", 1, 1);
1251+ EXPECT_EQ(NodeUtils::IsMultiBranchControlFlowOp(if_node), true);
1252+ auto while_node = builder.AddNode("while_node", "While", 1, 1);
1253+ EXPECT_EQ(NodeUtils::IsMultiBranchControlFlowOp(while_node), true);
1254+ auto for_node = builder.AddNode("for_node", "For", 1, 1);
1255+ EXPECT_EQ(NodeUtils::IsMultiBranchControlFlowOp(for_node), true);
1256+ auto switch_node = builder.AddNode("switch_node", "Switch", 1, 1);
1257+ EXPECT_EQ(NodeUtils::IsMultiBranchControlFlowOp(switch_node), true);
1258+ auto data_node = builder.AddNode("data_node", "Data", 1, 1);
1259+ EXPECT_EQ(NodeUtils::IsMultiBranchControlFlowOp(data_node), false);
1260+}
1261+ 
1262+TEST_F(UtestNodeUtils, CovTryGetWeightByDataNodeNonData) {
1263+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1264+ auto node = builder.AddNode("relu", "Relu", 1, 1);
1265+ ConstGeTensorPtr ge_tensor = nullptr;
1266+ EXPECT_EQ(NodeUtils::TryGetWeightByDataNode(node, ge_tensor), GRAPH_SUCCESS);
1267+ EXPECT_EQ(ge_tensor, nullptr);
1268+}
1269+ 
1270+TEST_F(UtestNodeUtils, CovGetInDataNodeAndAnchorByIndexNullSrcNode) {
1271+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1272+ auto node1 = builder.AddNode("Node1", "Node1", 1, 1);
1273+ auto node2 = builder.AddNode("Node2", "Node2", 1, 1);
1274+ builder.AddDataEdge(node1, 0, node2, 0);
1275+ auto result = NodeUtils::GetInDataNodeAndAnchorByIndex(*node2, 0);
1276+ EXPECT_NE(result.first, nullptr);
1277+ EXPECT_EQ(result.first, node1);
1278+}
1279+ 
1280+TEST_F(UtestNodeUtils, CovIsIdentityUsefulForRWControlNotIdentity) {
1281+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1282+ auto node = builder.AddNode("relu", "Relu", 1, 1);
1283+ EXPECT_EQ(NodeUtils::IsIdentityUsefulForRWControl(node), false);
1284+}
1285+ 
1286+TEST_F(UtestNodeUtils, CovIsIdentityUsefulForRWControlNoOutControl) {
1287+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1288+ auto id_node = builder.AddNode("id1", IDENTITY, 1, 1);
1289+ auto data = builder.AddNode("data", "Data", 1, 1);
1290+ builder.AddDataEdge(data, 0, id_node, 0);
1291+ auto out_node = builder.AddNode("out", "Relu", 1, 1);
1292+ builder.AddDataEdge(id_node, 0, out_node, 0);
1293+ EXPECT_EQ(NodeUtils::IsIdentityUsefulForRWControl(id_node), false);
1294+}
1295+ 
1296+TEST_F(UtestNodeUtils, CovIsIdentityUsefulForRWControlMultipleInData) {
1297+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1298+ auto id_node = builder.AddNode("id1", IDENTITY, 2, 1);
1299+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
1300+ auto data2 = builder.AddNode("data2", "Data", 1, 1);
1301+ builder.AddDataEdge(data1, 0, id_node, 0);
1302+ builder.AddDataEdge(data2, 0, id_node, 1);
1303+ auto out_node = builder.AddNode("out", "Relu", 1, 1);
1304+ builder.AddDataEdge(id_node, 0, out_node, 0);
1305+ auto ctrl_node = builder.AddNode("ctrl", "Assign", 1, 1);
1306+ builder.AddControlEdge(id_node, ctrl_node);
1307+ EXPECT_EQ(NodeUtils::IsIdentityUsefulForRWControl(id_node), false);
1308+}
1309+ 
1310+TEST_F(UtestNodeUtils, CovIsIdentityUsefulForRWControlNoOutData) {
1311+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1312+ auto id_node = builder.AddNode("id1", IDENTITY, 1, 1);
1313+ auto data = builder.AddNode("data", "Data", 1, 1);
1314+ builder.AddDataEdge(data, 0, id_node, 0);
1315+ auto ctrl_node = builder.AddNode("ctrl", "Assign", 1, 1);
1316+ builder.AddControlEdge(id_node, ctrl_node);
1317+ EXPECT_EQ(NodeUtils::IsIdentityUsefulForRWControl(id_node), false);
1318+}
1319+ 
1320+TEST_F(UtestNodeUtils, CovIsWrapperNode) {
1321+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1322+ auto node = builder.AddNode("Node", "Node", 1, 1);
1323+ EXPECT_EQ(NodeUtils::IsWrapperNode(node), false);
1324+ EXPECT_EQ(NodeUtils::IsWrapperNode(nullptr), false);
1325+ node->impl_->op_ = nullptr;
1326+ EXPECT_EQ(NodeUtils::IsWrapperNode(node), false);
1327+}
1328+ 
1329+TEST_F(UtestNodeUtils, CovIsLikeAtomicClean) {
1330+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1331+ auto atomic_node = builder.AddNode("atomic", ATOMICADDRCLEAN, 0, 0);
1332+ EXPECT_EQ(NodeUtils::IsLikeAtomicClean(atomic_node), true);
1333+ auto memset_node = builder.AddNode("memset", MEMSET, 0, 0);
1334+ EXPECT_EQ(NodeUtils::IsLikeAtomicClean(memset_node), true);
1335+ auto data_node = builder.AddNode("data", "Data", 0, 0);
1336+ EXPECT_EQ(NodeUtils::IsLikeAtomicClean(data_node), false);
1337+}
1338+ 
1339+TEST_F(UtestNodeUtils, CovGetNodeWithMinimalId) {
1340+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1341+ auto node1 = builder.AddNode("Node1", "Node", 1, 1);
1342+ auto node2 = builder.AddNode("Node2", "Node", 1, 1);
1343+ node1->GetOpDesc()->SetId(5);
1344+ node2->GetOpDesc()->SetId(3);
1345+ std::vector<NodePtr> nodes = {node1, node2};
1346+ auto result = NodeUtils::GetNodeWithMinimalId(nodes);
1347+ EXPECT_EQ(result, node2);
1348+}
1349+ 
1350+TEST_F(UtestNodeUtils, CovIsNameEqual) {
1351+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1352+ auto node = builder.AddNode("TestNode", "Node", 1, 1);
1353+ EXPECT_EQ(NodeUtils::IsNameEqual(node, "TestNode"), true);
1354+ EXPECT_EQ(NodeUtils::IsNameEqual(node, "WrongName"), false);
1355+}
1356+ 
1357+TEST_F(UtestNodeUtils, CovIsTypeEqual) {
1358+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1359+ auto node = builder.AddNode("Node", "TestType", 1, 1);
1360+ EXPECT_EQ(NodeUtils::IsTypeEqual(node, "TestType"), true);
1361+ EXPECT_EQ(NodeUtils::IsTypeEqual(node, "WrongType"), false);
1362+}
1363+ 
1364+TEST_F(UtestNodeUtils, CovGetParentInDataAnchor) {
1365+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1366+ auto node = builder.AddNode("Node", "Node", 1, 1);
1367+ EXPECT_EQ(NodeUtils::GetParentInDataAnchor(node), nullptr);
1368+ EXPECT_EQ(NodeUtils::GetParentInDataAnchor(nullptr), nullptr);
1369+}
1370+ 
1371+TEST_F(UtestNodeUtils, CovGetParentInputAndAnchorCrossSubgraph) {
1372+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1373+ auto node = builder.AddNode("Node", "Node", 1, 1);
1374+ auto result = NodeUtils::GetParentInputAndAnchorCrossSubgraph(node);
1375+ EXPECT_EQ(result.first, nullptr);
1376+ EXPECT_EQ(result.second, nullptr);
1377+}
1378+ 
1379+TEST_F(UtestNodeUtils, CovGetOutDataNodesWithFilter) {
1380+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1381+ auto src = builder.AddNode("src", "Data", 0, 1);
1382+ auto dst1 = builder.AddNode("dst1", "Relu", 1, 1);
1383+ auto dst2 = builder.AddNode("dst2", "Cast", 1, 1);
1384+ builder.AddDataEdge(src, 0, dst1, 0);
1385+ builder.AddDataEdge(src, 0, dst2, 0);
1386+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Relu"; };
1387+ auto result = NodeUtils::GetOutDataNodes(*src, filter);
1388+ EXPECT_EQ(result.size(), 1U);
1389+ EXPECT_EQ(result[0]->GetName(), "dst1");
1390+}
1391+ 
1392+TEST_F(UtestNodeUtils, CovGetInDataNodesWithFilter) {
1393+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1394+ auto src1 = builder.AddNode("src1", "Data", 0, 1);
1395+ auto src2 = builder.AddNode("src2", "Const", 0, 1);
1396+ auto dst = builder.AddNode("dst", "AddN", 2, 1);
1397+ builder.AddDataEdge(src1, 0, dst, 0);
1398+ builder.AddDataEdge(src2, 0, dst, 1);
1399+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Data"; };
1400+ auto result = NodeUtils::GetInDataNodes(*dst, filter);
1401+ EXPECT_EQ(result.size(), 1U);
1402+ EXPECT_EQ(result[0]->GetName(), "src1");
1403+}
1404+ 
1405+TEST_F(UtestNodeUtils, CovGetOutControlNodesWithFilter) {
1406+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1407+ auto src = builder.AddNode("src", "Data", 0, 0);
1408+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
1409+ auto ctrl2 = builder.AddNode("ctrl2", "Cast", 0, 0);
1410+ builder.AddControlEdge(src, ctrl1);
1411+ builder.AddControlEdge(src, ctrl2);
1412+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Relu"; };
1413+ auto result = NodeUtils::GetOutControlNodes(*src, filter);
1414+ EXPECT_EQ(result.size(), 1U);
1415+}
1416+ 
1417+TEST_F(UtestNodeUtils, CovGetInControlNodesWithFilter) {
1418+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1419+ auto ctrl1 = builder.AddNode("ctrl1", "Relu", 0, 0);
1420+ auto ctrl2 = builder.AddNode("ctrl2", "Cast", 0, 0);
1421+ auto dst = builder.AddNode("dst", "Data", 0, 0);
1422+ builder.AddControlEdge(ctrl1, dst);
1423+ builder.AddControlEdge(ctrl2, dst);
1424+ NodeFilter filter = [](const Node &n) { return n.GetType() == "Relu"; };
1425+ auto result = NodeUtils::GetInControlNodes(*dst, filter);
1426+ EXPECT_EQ(result.size(), 1U);
1427+}
1428+ 
1429+TEST_F(UtestNodeUtils, CovIsNodeInRootGraph) {
1430+ ut::GraphBuilder builder = ut::GraphBuilder("root");
1431+ auto node = builder.AddNode("node", "Relu", 1, 1);
1432+ EXPECT_EQ(NodeUtils::IsNodeInRootGraph(node), true);
1433+}
1434+ 
1435+TEST_F(UtestNodeUtils, CovIsNodeInRootGraphNull) {
1436+ NodePtr null_node;
1437+ EXPECT_EQ(NodeUtils::IsNodeInRootGraph(null_node), false);
1438+}
1439+ 
1440+TEST_F(UtestNodeUtils, CovGetParentInputAndAnchorNoAttr) {
1441+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1442+ auto node = builder.AddNode("Node", "Node", 1, 1);
1443+ auto result = NodeUtils::GetParentInputAndAnchor(node);
1444+ EXPECT_EQ(result.first, nullptr);
1445+ EXPECT_EQ(result.second, nullptr);
1446+}
1447+ 
1448+TEST_F(UtestNodeUtils, CovGetParentInputAndAnchorNullGraph) {
1449+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
1450+ auto node = builder.AddNode("Node", "Node", 1, 1);
1451+ AttrUtils::SetInt(node->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
1452+ node->impl_->owner_graph_.reset();
1453+ auto result = NodeUtils::GetParentInputAndAnchor(node);
1454+ EXPECT_EQ(result.first, nullptr);
1455+ EXPECT_EQ(result.second, nullptr);
1456+}
1228} // namespace ge1457} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/op_desc_unittest.cc+323-0
@@ -1304,4 +1304,327 @@ TEST_F(UtestOpDesc, IncCov_OpDescEqual) {
1304 EXPECT_TRUE(op_desc1->OpDescGenTensorDescsAreEqual(*op_desc2));1304 EXPECT_TRUE(op_desc1->OpDescGenTensorDescsAreEqual(*op_desc2));
1305 EXPECT_TRUE(*op_desc1 == *op_desc2);1305 EXPECT_TRUE(*op_desc1 == *op_desc2);
1306}1306}
1307+ 
1308+TEST_F(UtestOpDesc, IncCov_AddInputDescMiddleAndOutputMiddle) {
1309+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1310+ op_desc->AddInputDesc("input0", GeTensorDesc());
1311+ EXPECT_EQ(op_desc->AddInputDescMiddle("dyn", 2, 1), GRAPH_SUCCESS);
1312+ EXPECT_EQ(op_desc->GetAllInputsSize(), 3U);
1313+ 
1314+ EXPECT_EQ(op_desc->AddOutputDescMiddle("dyn_out", 2, 0), GRAPH_SUCCESS);
1315+ EXPECT_EQ(op_desc->GetOutputsSize(), 2U);
1316+}
1317+ 
1318+TEST_F(UtestOpDesc, IncCov_AddDynamicInputForwardAndOutputForward) {
1319+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1320+ EXPECT_EQ(op_desc->AddDynamicInputDesc("x", 2, false), GRAPH_SUCCESS);
1321+ EXPECT_EQ(op_desc->GetAllInputsSize(), 2U);
1322+ 
1323+ EXPECT_EQ(op_desc->AddDynamicOutputDesc("y", 2, false), GRAPH_SUCCESS);
1324+ EXPECT_EQ(op_desc->GetOutputsSize(), 2U);
1325+ 
1326+ EXPECT_EQ(op_desc->AddDynamicOutputDesc("z", 2, true), GRAPH_SUCCESS);
1327+ EXPECT_EQ(op_desc->GetOutputsSize(), 4U);
1328+}
1329+ 
1330+TEST_F(UtestOpDesc, IncCov_AddOptionalInputAndDynamicByIndex) {
1331+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1332+ EXPECT_EQ(op_desc->AddOptionalInputDesc("opt_input", GeTensorDesc()), GRAPH_SUCCESS);
1333+ EXPECT_EQ(op_desc->GetAllInputsSize(), 1U);
1334+ 
1335+ EXPECT_EQ(op_desc->AddDynamicInputDescByIndex("dyn", 2, 0), GRAPH_SUCCESS);
1336+ EXPECT_EQ(op_desc->GetAllInputsSize(), 3U);
1337+}
1338+ 
1339+TEST_F(UtestOpDesc, IncCov_UpdateDescByNameAndOutput) {
1340+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1341+ op_desc->AddInputDesc("input1", GeTensorDesc());
1342+ op_desc->AddOutputDesc("output1", GeTensorDesc());
1343+ 
1344+ EXPECT_EQ(op_desc->UpdateInputDesc("input1", GeTensorDesc(GeShape({2}), FORMAT_NCHW, DT_FLOAT)), GRAPH_SUCCESS);
1345+ EXPECT_EQ(op_desc->UpdateInputDesc("not_exist", GeTensorDesc()), GRAPH_FAILED);
1346+ 
1347+ EXPECT_EQ(op_desc->impl_->UpdateInputDesc("input1", GeTensorDesc()), GRAPH_SUCCESS);
1348+ EXPECT_EQ(op_desc->impl_->UpdateInputDesc("not_exist", GeTensorDesc()), GRAPH_FAILED);
1349+ 
1350+ EXPECT_EQ(op_desc->UpdateOutputDesc(0U, GeTensorDesc(GeShape({3}), FORMAT_NCHW, DT_INT32)), GRAPH_SUCCESS);
1351+ EXPECT_EQ(op_desc->impl_->UpdateOutputDesc(0U, GeTensorDesc()), GRAPH_SUCCESS);
1352+ EXPECT_EQ(op_desc->impl_->UpdateOutputDesc("output1", GeTensorDesc()), GRAPH_SUCCESS);
1353+ EXPECT_EQ(op_desc->impl_->UpdateOutputDesc("not_exist", GeTensorDesc()), GRAPH_FAILED);
1354+ EXPECT_EQ(op_desc->impl_->UpdateOutputDesc(999U, GeTensorDesc()), GRAPH_FAILED);
1355+}
1356+ 
1357+TEST_F(UtestOpDesc, IncCov_KernelLibAndEngineName) {
1358+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1359+ op_desc->SetOpKernelLibName("kernel_lib");
1360+ EXPECT_EQ(op_desc->GetOpKernelLibName(), "kernel_lib");
1361+ 
1362+ op_desc->SetOpEngineName("engine_name");
1363+ EXPECT_EQ(op_desc->GetOpEngineName(), "engine_name");
1364+ 
1365+ auto op_desc2 = std::make_shared<OpDesc>("test2", "Test2");
1366+ EXPECT_EQ(op_desc2->GetOpKernelLibName(), "");
1367+}
1368+ 
1369+TEST_F(UtestOpDesc, IncCov_AttachedStreamId) {
1370+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1371+ op_desc->SetAttachedStreamId(5);
1372+ EXPECT_EQ(op_desc->GetAttachedStreamId(), 5);
1373+ EXPECT_TRUE(op_desc->HasValidAttachedStreamId());
1374+ 
1375+ auto ids = op_desc->GetAttachedStreamIds();
1376+ EXPECT_EQ(ids.size(), 1U);
1377+ EXPECT_EQ(ids[0], 5);
1378+ 
1379+ std::vector<NamedAttrs> infos(2);
1380+ AttrUtils::SetListNamedAttrs(op_desc, ATTR_NAME_ATTACHED_STREAM_INFO_LIST, infos);
1381+ op_desc->SetAttachedStreamIds({10, 20});
1382+ auto multi_ids = op_desc->GetAttachedStreamIds();
1383+ EXPECT_EQ(multi_ids.size(), 2U);
1384+ 
1385+ auto op_desc2 = std::make_shared<OpDesc>("test2", "Test2");
1386+ EXPECT_FALSE(op_desc2->HasValidAttachedStreamId());
1387+ auto empty_ids = op_desc2->GetAttachedStreamIds();
1388+ EXPECT_TRUE(empty_ids.empty());
1389+ 
1390+ op_desc2->SetAttachedStreamIds({1, 2, 3});
1391+}
1392+ 
1393+TEST_F(UtestOpDesc, IncCov_OpInferDependsAndIsInputConst) {
1394+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1395+ std::vector<std::string> depends = {"x", "y"};
1396+ op_desc->SetOpInferDepends(depends);
1397+ auto get_depends = op_desc->GetOpInferDepends();
1398+ EXPECT_EQ(get_depends.size(), 2U);
1399+ 
1400+ std::vector<bool> is_const = {true, false};
1401+ op_desc->SetIsInputConst(is_const);
1402+ auto get_const = op_desc->GetIsInputConst();
1403+ EXPECT_EQ(get_const.size(), 2U);
1404+}
1405+ 
1406+TEST_F(UtestOpDesc, IncCov_SubgraphOperations) {
1407+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1408+ EXPECT_EQ(op_desc->AddSubgraphName("sub1"), GRAPH_SUCCESS);
1409+ EXPECT_EQ(op_desc->AddSubgraphName("sub1"), GRAPH_FAILED);
1410+ EXPECT_EQ(op_desc->SetSubgraphInstanceName(0, "instance1"), GRAPH_SUCCESS);
1411+ EXPECT_NE(op_desc->SetSubgraphInstanceName(999, "instance2"), GRAPH_SUCCESS);
1412+ 
1413+ EXPECT_EQ(op_desc->GetSubgraphInstanceName(0), "instance1");
1414+ EXPECT_EQ(op_desc->GetSubgraphInstanceName(999), "");
1415+ 
1416+ op_desc->RemoveSubgraphInstanceName("instance1");
1417+ EXPECT_EQ(op_desc->GetSubgraphInstanceName(0), "");
1418+ 
1419+ std::string subgraph_name;
1420+ EXPECT_NE(op_desc->GetSubgraphNameByInstanceName("nonexistent", subgraph_name), GRAPH_SUCCESS);
1421+}
1422+ 
1423+TEST_F(UtestOpDesc, IncCov_OpDescBuilderBuild) {
1424+ OpDescBuilder builder("test_op", "Test");
1425+ builder.AddInput("x");
1426+ builder.AddInput("y", GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1427+ builder.AddDynamicInput("dyn", 3);
1428+ builder.AddDynamicInput("dyn2", 2, GeTensorDesc(GeShape({2}), FORMAT_ND, DT_INT32));
1429+ builder.AddOutput("out");
1430+ builder.AddOutput("out2", GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1431+ builder.AddDynamicOutput("dyn_out", 2);
1432+ builder.AddDynamicOutput("dyn_out2", 2, GeTensorDesc(GeShape({3}), FORMAT_ND, DT_INT32));
1433+ auto op_desc = builder.Build();
1434+ EXPECT_NE(op_desc, nullptr);
1435+}
1436+ 
1437+TEST_F(UtestOpDesc, IncCov_DefaultInferFormat) {
1438+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1439+ auto desc = std::make_shared<GeTensorDesc>(GeShape({1, 2}), FORMAT_NCHW, DT_FLOAT);
1440+ desc->SetOriginFormat(FORMAT_NCHW);
1441+ op_desc->AddInputDesc("x", *desc);
1442+ op_desc->AddOutputDesc("y", GeTensorDesc());
1443+ EXPECT_EQ(op_desc->DefaultInferFormat(), GRAPH_SUCCESS);
1444+}
1445+ 
1446+TEST_F(UtestOpDesc, IncCov_InputIsSetAndValidName) {
1447+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1448+ op_desc->AddInputDesc("x", GeTensorDesc(GeShape({1, 2}), FORMAT_ND, DT_FLOAT));
1449+ EXPECT_TRUE(op_desc->InputIsSet("x"));
1450+ EXPECT_FALSE(op_desc->InputIsSet("not_exist"));
1451+ 
1452+ auto name = op_desc->GetValidInputNameByIndex(0);
1453+ EXPECT_EQ(name, "x");
1454+}
1455+ 
1456+TEST_F(UtestOpDesc, IncCov_OpDescComparisonFailures) {
1457+ auto op_desc1 = std::make_shared<OpDesc>("test", "Test");
1458+ auto op_desc2 = std::make_shared<OpDesc>("test2", "Test2");
1459+ op_desc1->AddInputDesc("x", GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1460+ op_desc2->AddInputDesc("x", GeTensorDesc(GeShape({2}), FORMAT_NCHW, DT_FLOAT));
1461+ EXPECT_FALSE(op_desc1->OpDescAttrsAreEqual(*op_desc2));
1462+ EXPECT_FALSE(op_desc1->OpDescGenTensorDescsAreEqual(*op_desc2));
1463+ 
1464+ auto op_desc3 = std::make_shared<OpDesc>("test", "Test");
1465+ op_desc3->AddInputDesc("x", GeTensorDesc());
1466+ op_desc3->AddInputDesc("y", GeTensorDesc());
1467+ EXPECT_FALSE(op_desc1->OpDescGenTensorDescsAreEqual(*op_desc3));
1468+}
1469+ 
1470+TEST_F(UtestOpDesc, IncCov_UpdateOutputNameAndIndexToName) {
1471+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1472+ op_desc->AddOutputDesc("y0", GeTensorDesc());
1473+ op_desc->AddOutputDesc("y1", GeTensorDesc());
1474+ 
1475+ std::map<std::string, uint32_t> output_names = {{"z0", 0}, {"z1", 1}};
1476+ EXPECT_TRUE(op_desc->UpdateOutputName(output_names));
1477+ 
1478+ auto idx2name = op_desc->GetAllOutputIndexToName();
1479+ EXPECT_EQ(idx2name.size(), 2U);
1480+ 
1481+ std::map<std::string, uint32_t> too_few = {{"w0", 0}};
1482+ EXPECT_FALSE(op_desc->UpdateOutputName(too_few));
1483+}
1484+ 
1485+TEST_F(UtestOpDesc, IncCov_SetIrRelatedAndNamePtr) {
1486+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1487+ auto other_desc = std::make_shared<OpDesc>("other", "Other");
1488+ op_desc->SetIrRelated(other_desc);
1489+ op_desc->SetIrRelated(nullptr);
1490+ 
1491+ op_desc->SetNamePtr(nullptr);
1492+ EXPECT_EQ(op_desc->GetName(), "");
1493+ op_desc->SetNamePtr("new_name");
1494+ EXPECT_EQ(op_desc->GetName(), "new_name");
1495+}
1496+ 
1497+TEST_F(UtestOpDesc, IncCov_DynamicInputOutputIndexesNotContinuous) {
1498+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1499+ op_desc->AddInputDesc("dyn0", GeTensorDesc());
1500+ op_desc->AddInputDesc("other", GeTensorDesc());
1501+ op_desc->AddInputDesc("dyn1", GeTensorDesc());
1502+ op_desc->impl_->input_name_idx_["dyn0"] = 0;
1503+ op_desc->impl_->input_name_idx_["dyn1"] = 2;
1504+ 
1505+ std::vector<int32_t> indexes;
1506+ EXPECT_EQ(op_desc->GetDynamicInputIndexesByName("dyn", indexes), GRAPH_FAILED);
1507+ 
1508+ op_desc->AddOutputDesc("dout0", GeTensorDesc());
1509+ op_desc->AddOutputDesc("oout", GeTensorDesc());
1510+ op_desc->AddOutputDesc("dout1", GeTensorDesc());
1511+ op_desc->impl_->output_name_idx_["dout0"] = 0;
1512+ op_desc->impl_->output_name_idx_["dout1"] = 2;
1513+ 
1514+ std::vector<int32_t> out_indexes;
1515+ EXPECT_EQ(op_desc->GetDynamicOutputIndexesByName("dout", out_indexes), GRAPH_FAILED);
1516+}
1517+ 
1518+TEST_F(UtestOpDesc, IncCov_GetInputOutputNameByIndex) {
1519+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1520+ op_desc->AddInputDesc("x", GeTensorDesc());
1521+ op_desc->AddOutputDesc("y", GeTensorDesc());
1522+ 
1523+ EXPECT_EQ(op_desc->GetInputNameByIndex(0), "x");
1524+ EXPECT_EQ(op_desc->GetInputIndexByName("x"), 0);
1525+ EXPECT_EQ(op_desc->GetInputIndexByName("not_exist"), -1);
1526+ 
1527+ EXPECT_EQ(op_desc->GetOutputNameByIndex(0), "y");
1528+ EXPECT_EQ(op_desc->GetOutputIndexByName("y"), 0);
1529+ EXPECT_EQ(op_desc->GetOutputIndexByName("not_exist"), -1);
1530+}
1531+ 
1532+TEST_F(UtestOpDesc, IncCov_SetDstIndexAndMutableNames) {
1533+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1534+ std::vector<int64_t> dst_idx = {1, 2, 3};
1535+ op_desc->SetDstIndex(dst_idx);
1536+ 
1537+ op_desc->AddInputDesc("x", GeTensorDesc());
1538+ auto &input_names = op_desc->MutableAllInputName();
1539+ EXPECT_FALSE(input_names.empty());
1540+ auto &output_names = op_desc->MutableAllOutputName();
1541+ EXPECT_TRUE(output_names.empty());
1542+ 
1543+ auto all_input_names = op_desc->GetAllInputName();
1544+ EXPECT_FALSE(all_input_names.empty());
1545+ auto all_output_names = op_desc->GetAllOutputName();
1546+ EXPECT_TRUE(all_output_names.empty());
1547+}
1548+ 
1549+TEST_F(UtestOpDesc, IncCov_GetAllDescsAndPtrs) {
1550+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1551+ op_desc->AddInputDesc("x", GeTensorDesc(GeShape({1}), FORMAT_NCHW, DT_FLOAT));
1552+ op_desc->AddOutputDesc("y", GeTensorDesc(GeShape({2}), FORMAT_NCHW, DT_INT32));
1553+ 
1554+ auto all_inputs = op_desc->GetAllInputsDesc();
1555+ EXPECT_EQ(all_inputs.size(), 1U);
1556+ auto all_input_ptrs = op_desc->GetAllInputsDescPtr();
1557+ EXPECT_EQ(all_input_ptrs.size(), 1U);
1558+ 
1559+ auto all_outputs = op_desc->GetAllOutputsDesc();
1560+ EXPECT_EQ(all_outputs.size(), 1U);
1561+ auto all_output_ptrs = op_desc->GetAllOutputsDescPtr();
1562+ EXPECT_EQ(all_output_ptrs.size(), 1U);
1563+ 
1564+ EXPECT_NE(op_desc->GetInputDescPtr(0), nullptr);
1565+ EXPECT_EQ(op_desc->GetInputDescPtr(999), nullptr);
1566+ EXPECT_NE(op_desc->GetInputDescPtrDfault(0), nullptr);
1567+ EXPECT_NE(op_desc->GetInputDescPtr("x"), nullptr);
1568+ EXPECT_EQ(op_desc->GetInputDescPtr("not_exist"), nullptr);
1569+ 
1570+ EXPECT_NE(op_desc->GetOutputDescPtr(0), nullptr);
1571+ EXPECT_EQ(op_desc->GetOutputDescPtr(999), nullptr);
1572+ 
1573+ op_desc->impl_->inputs_desc_[0] = nullptr;
1574+ EXPECT_EQ(op_desc->GetInputDescPtr(0), nullptr);
1575+}
1576+ 
1577+TEST_F(UtestOpDesc, IncCov_IrRelatedOperations) {
1578+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1579+ op_desc->AppendIrInput("x", kIrInputRequired);
1580+ op_desc->AppendIrInput("y", kIrInputDynamic);
1581+ op_desc->AppendIrOutput("z", kIrOutputRequired);
1582+ op_desc->AppendIrOutput("w", kIrOutputDynamic);
1583+ op_desc->AppendIrAttrName("attr1");
1584+ op_desc->RegisterSubgraphIrName("sub", kDynamic);
1585+ 
1586+ auto ir_inputs = op_desc->GetIrInputs();
1587+ EXPECT_EQ(ir_inputs.size(), 2U);
1588+ EXPECT_EQ(op_desc->GetIrInputsSize(), 2U);
1589+ auto ir_outputs = op_desc->GetIrOutputs();
1590+ EXPECT_EQ(ir_outputs.size(), 2U);
1591+ auto attr_names = op_desc->GetIrAttrNames();
1592+ EXPECT_EQ(attr_names.size(), 1U);
1593+ 
1594+ auto subgraph_names = op_desc->GetSubgraphIrNames();
1595+ EXPECT_EQ(subgraph_names.size(), 1U);
1596+ auto ordered_subgraphs = op_desc->GetOrderedSubgraphIrNames();
1597+ EXPECT_EQ(ordered_subgraphs.size(), 1U);
1598+ EXPECT_EQ(op_desc->GetSubgraphTypeByIrName("sub"), kDynamic);
1599+ 
1600+ EXPECT_EQ(op_desc->AddRegisterInputName("reg_in"), GRAPH_SUCCESS);
1601+ auto reg_inputs = op_desc->GetRegisterInputName();
1602+ EXPECT_FALSE(reg_inputs.empty());
1603+ EXPECT_EQ(op_desc->AddRegisterOutputName("reg_out"), GRAPH_SUCCESS);
1604+ auto reg_outputs = op_desc->GetRegisterOutputName();
1605+ EXPECT_FALSE(reg_outputs.empty());
1606+ 
1607+ std::vector<std::vector<size_t>> promote_list;
1608+ EXPECT_EQ(op_desc->GetPromoteIrInputList(promote_list), GRAPH_SUCCESS);
1609+ 
1610+ EXPECT_FALSE(op_desc->IsOptionalInput(0U));
1611+ EXPECT_FALSE(op_desc->IsOptionalInput("x"));
1612+}
1613+ 
1614+TEST_F(UtestOpDesc, IncCov_UpdateInputName) {
1615+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1616+ op_desc->AddInputDesc("x", GeTensorDesc());
1617+ 
1618+ std::map<std::string, uint32_t> same_size = {{"a", 0}};
1619+ EXPECT_TRUE(op_desc->UpdateInputName(same_size));
1620+ 
1621+ std::map<std::string, uint32_t> too_few;
1622+ EXPECT_FALSE(op_desc->UpdateInputName(too_few));
1623+}
1624+ 
1625+TEST_F(UtestOpDesc, IncCov_GetAllInputNamesEmpty) {
1626+ auto op_desc = std::make_shared<OpDesc>("test", "Test");
1627+ auto names = op_desc->GetAllInputNames();
1628+ EXPECT_EQ(names.size(), 0U);
1629+}
1307} // namespace ge1630} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/op_desc_utils_unittest.cc+136-0
@@ -2150,4 +2150,140 @@ TEST_F(UtestOpDescUtils, CovGetConstInputsDataParentConst) {
2150 auto const_inputs = OpDescUtils::GetConstInputs(*addn, 1U);2150 auto const_inputs = OpDescUtils::GetConstInputs(*addn, 1U);
2151 EXPECT_EQ(const_inputs.size(), 0U);2151 EXPECT_EQ(const_inputs.size(), 0U);
2152}2152}
2153+ 
2154+TEST_F(UtestOpDescUtils, CovGetConstInputNodeAndAnchorEnterConst) {
2155+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2156+ auto const_node = builder.AddNode("const1", "Const", 0, 1);
2157+ auto enter_node = builder.AddNode("enter1", ENTER, 1, 1);
2158+ auto addn = builder.AddNode("addn", "AddN", 1, 1);
2159+ int32_t weight[1] = {1};
2160+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
2161+ GeTensorPtr tensor0 = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
2162+ OpDescUtils::SetWeights(const_node, {tensor0});
2163+ AttrUtils::SetBool(enter_node->GetOpDesc(), ENTER_ATTR_CONSTANT_FLAG, true);
2164+ builder.AddDataEdge(const_node, 0, enter_node, 0);
2165+ builder.AddDataEdge(enter_node, 0, addn, 0);
2166+ auto result = OpDescUtils::GetConstInputNodeAndAnchor(*addn);
2167+ EXPECT_EQ(result.size(), 1U);
2168+ EXPECT_EQ(result[0].first->GetName(), "const1");
2169+}
2170+ 
2171+TEST_F(UtestOpDescUtils, CovGetConstInputNodeAndAnchorEnterNotConst) {
2172+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2173+ auto data_node = builder.AddNode("data1", "Data", 0, 1);
2174+ auto enter_node = builder.AddNode("enter1", ENTER, 1, 1);
2175+ auto addn = builder.AddNode("addn", "AddN", 1, 1);
2176+ builder.AddDataEdge(data_node, 0, enter_node, 0);
2177+ builder.AddDataEdge(enter_node, 0, addn, 0);
2178+ auto result = OpDescUtils::GetConstInputNodeAndAnchor(*addn);
2179+ EXPECT_EQ(result.size(), 0U);
2180+}
2181+ 
2182+TEST_F(UtestOpDescUtils, CovGetConstInputNodeAndAnchorEnterMultipleInputs) {
2183+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2184+ auto data1 = builder.AddNode("data1", "Data", 0, 1);
2185+ auto data2 = builder.AddNode("data2", "Data", 0, 1);
2186+ auto enter_node = builder.AddNode("enter1", ENTER, 2, 1);
2187+ auto addn = builder.AddNode("addn", "AddN", 1, 1);
2188+ AttrUtils::SetBool(enter_node->GetOpDesc(), ENTER_ATTR_CONSTANT_FLAG, true);
2189+ builder.AddDataEdge(data1, 0, enter_node, 0);
2190+ builder.AddDataEdge(data2, 0, enter_node, 1);
2191+ builder.AddDataEdge(enter_node, 0, addn, 0);
2192+ auto result = OpDescUtils::GetConstInputNodeAndAnchor(*addn);
2193+ EXPECT_EQ(result.size(), 0U);
2194+}
2195+ 
2196+TEST_F(UtestOpDescUtils, CovGetWeightsFromNodesNullWeight) {
2197+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2198+ auto const_node = builder.AddNode("const1", "Const", 0, 1);
2199+ auto addn = builder.AddNode("addn", "AddN", 1, 1);
2200+ builder.AddDataEdge(const_node, 0, addn, 0);
2201+ auto nodes_2_anchors = OpDescUtils::GetConstInputNodeAndAnchor(*addn);
2202+ if (!nodes_2_anchors.empty()) {
2203+ auto weights = OpDescUtils::GetWeightsFromNodes(nodes_2_anchors);
2204+ EXPECT_EQ(weights.size(), 0U);
2205+ }
2206+}
2207+ 
2208+TEST_F(UtestOpDescUtils, CovSetNoneConstNodeWeightsMoreWeights) {
2209+ auto graph = BuildGraph1();
2210+ auto addn_node = graph->FindNode("addn");
2211+ GeTensorPtr tensor1 = std::make_shared<GeTensor>();
2212+ GeTensorPtr tensor2 = std::make_shared<GeTensor>();
2213+ GeTensorPtr tensor3 = std::make_shared<GeTensor>();
2214+ auto ret = OpDescUtils::SetWeights(*addn_node, {tensor1, tensor2, tensor3});
2215+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2216+}
2217+ 
2218+TEST_F(UtestOpDescUtils, CovMutableWeightsPlaceholder) {
2219+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2220+ auto pld = builder.AddNode("pld", PLACEHOLDER, 0, 1);
2221+ auto tensor = std::make_shared<GeTensor>();
2222+ tensor->MutableTensorDesc().SetDataType(DT_UINT8);
2223+ tensor->MutableTensorDesc().SetShape(GeShape({0}));
2224+ AttrUtils::SetTensor(pld->GetOpDesc(), "value", tensor);
2225+ auto weights = OpDescUtils::MutableWeights(pld);
2226+ EXPECT_EQ(weights.size(), 1U);
2227+}
2228+ 
2229+TEST_F(UtestOpDescUtils, CovMutableWeightsPlaceholderNoWeight) {
2230+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2231+ auto pld = builder.AddNode("pld", PLACEHOLDER, 0, 1);
2232+ auto weights = OpDescUtils::MutableWeights(pld);
2233+ EXPECT_EQ(weights.size(), 0U);
2234+}
2235+ 
2236+TEST_F(UtestOpDescUtils, CovMutableWeightsData) {
2237+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2238+ auto data = builder.AddNode("data1", DATA, 0, 1);
2239+ auto weights = OpDescUtils::MutableWeights(data);
2240+ EXPECT_EQ(weights.size(), 0U);
2241+}
2242+ 
2243+TEST_F(UtestOpDescUtils, CovAddConstOpToAnchorNullGraph) {
2244+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "TestType");
2245+ auto node = NodeUtils::CreatNodeWithoutGraph(op_desc);
2246+ ASSERT_NE(node, nullptr);
2247+ InDataAnchorPtr in_anchor = std::make_shared<InDataAnchor>(node, 0);
2248+ auto tensor = std::make_shared<GeTensor>();
2249+ auto ret = OpDescUtils::AddConstOpToAnchor(in_anchor, tensor);
2250+ EXPECT_NE(ret, GRAPH_SUCCESS);
2251+}
2252+ 
2253+TEST_F(UtestOpDescUtils, CovGetConstInputsSwitchMatMul) {
2254+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
2255+ auto const_node = builder.AddNode("const1", "Const", 0, 1);
2256+ auto switch_node = builder.AddNode("switch1", SWITCH, 1, 1);
2257+ auto matmul_node = builder.AddNode("matmul1", MATMUL, 1, 1);
2258+ builder.AddDataEdge(const_node, 0, switch_node, 0);
2259+ builder.AddDataEdge(switch_node, 0, matmul_node, 0);
2260+ auto result = OpDescUtils::GetConstInputs(*matmul_node, 2U);
2261+ EXPECT_EQ(result.size(), 1U);
2262+}
2263+ 
2264+TEST_F(UtestOpDescUtils, CovSetWeightsNodeMapCreateNewConst) {
2265+ auto graph = BuildGraph1();
2266+ auto addn_node = graph->FindNode("addn");
2267+ GeTensorPtr tensor = std::make_shared<GeTensor>();
2268+ std::map<int, GeTensorPtr> weights_map = {{0, tensor}};
2269+ auto ret = OpDescUtils::SetWeights(*addn_node, weights_map);
2270+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2271+}
2272+ 
2273+TEST_F(UtestOpDescUtils, CovSetWeightsNodeMapUpdateExistingConst) {
2274+ auto graph = BuildGraph1();
2275+ auto addn_node = graph->FindNode("addn");
2276+ GeTensorPtr tensor = std::make_shared<GeTensor>();
2277+ std::map<int, GeTensorPtr> weights_map = {{0, tensor}};
2278+ auto ret = OpDescUtils::SetWeights(*addn_node, weights_map);
2279+ EXPECT_EQ(ret, GRAPH_SUCCESS);
2280+}
2281+ 
2282+TEST_F(UtestOpDescUtils, CovClearWeightsNullGraph) {
2283+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", "TestType");
2284+ auto node = NodeUtils::CreatNodeWithoutGraph(op_desc);
2285+ ASSERT_NE(node, nullptr);
2286+ auto ret = OpDescUtils::ClearWeights(node);
2287+ EXPECT_NE(ret, GRAPH_SUCCESS);
2288+}
2153} // namespace ge2289} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/operator_unittest.cc+440-0
@@ -3030,4 +3030,444 @@ TEST_F(UtestOperater, IncCov_OperatorImplSubgraph) {
3030 EXPECT_EQ(impl_ptr->GetSubgraphNamesCount(), 2UL);3030 EXPECT_EQ(impl_ptr->GetSubgraphNamesCount(), 2UL);
3031 op.BreakConnect();3031 op.BreakConnect();
3032}3032}
3033+ 
3034+TEST_F(UtestOperater, IncCov_GetInputConstDataOut_StringNotFound) {
3035+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3036+ Tensor data;
3037+ EXPECT_EQ(impl->GetInputConstDataOut("nonexistent", data), GRAPH_FAILED);
3038+}
3039+ 
3040+TEST_F(UtestOperater, IncCov_SetInputImpl_NullOutHandler) {
3041+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3042+ GeTensorDesc tensor_desc;
3043+ impl->GetOpDescImpl()->AddInputDesc("x", tensor_desc);
3044+ impl->GetOpDescImpl()->AddOutputDesc("y", tensor_desc);
3045+ Operator src_op(std::move(impl));
3046+ src_op.operator_impl_->GetOpDescImpl()->impl_->outputs_desc_.clear();
3047+ src_op.operator_impl_->GetOpDescImpl()->impl_->output_name_idx_.clear();
3048+ src_op.operator_impl_->GetOpDescImpl()->impl_->outputs_desc_.push_back(std::make_shared<GeTensorDesc>(tensor_desc));
3049+ EXPECT_EQ(src_op.GetOutputsSize(), 1U);
3050+ src_op.operator_impl_->SetInputImpl("x", src_op);
3051+}
3052+ 
3053+TEST_F(UtestOperater, IncCov_GetFromPeerNode_FileConstant) {
3054+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
3055+ auto fileconst_node = builder.AddNode("FileConst", "FileConstant", 0, 1);
3056+ AttrUtils::SetStr(fileconst_node->GetOpDesc(), "location", "./nonexistent_file.bin");
3057+ AttrUtils::SetInt(fileconst_node->GetOpDesc(), "length", 4);
3058+ AttrUtils::SetDataType(fileconst_node->GetOpDesc(), "dtype", DT_UINT8);
3059+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
3060+ data_node->GetOpDesc()->impl_->input_name_idx_["x"] = 0;
3061+ builder.AddDataEdge(fileconst_node, 0, data_node, 0);
3062+ auto op = OpDescUtils::CreateOperatorFromNode(data_node);
3063+ Tensor tensor;
3064+ EXPECT_EQ(op.GetInputConstData("x", tensor), GRAPH_FAILED);
3065+}
3066+ 
3067+TEST_F(UtestOperater, IncCov_GetFromPeerNode_PlaceholderFail) {
3068+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
3069+ auto placeholder_node = builder.AddNode("Placeholder", "PlaceHolder", 0, 1);
3070+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
3071+ data_node->GetOpDesc()->impl_->input_name_idx_["x"] = 0;
3072+ builder.AddDataEdge(placeholder_node, 0, data_node, 0);
3073+ auto op = OpDescUtils::CreateOperatorFromNode(data_node);
3074+ Tensor tensor;
3075+ EXPECT_EQ(op.GetInputConstData("x", tensor), GRAPH_FAILED);
3076+}
3077+ 
3078+TEST_F(UtestOperater, IncCov_GetFromPeerNode_EnterType) {
3079+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
3080+ auto enter_node = builder.AddNode("Enter", "Enter", 1, 1);
3081+ auto const_node = builder.AddNode("Const", "Const", 0, 1);
3082+ auto ge_tensor = std::make_shared<GeTensor>();
3083+ AttrUtils::SetTensor(const_node->GetOpDesc(), "value", ge_tensor);
3084+ builder.AddDataEdge(const_node, 0, enter_node, 0);
3085+ auto data_node = builder.AddNode("Data", "Data", 1, 1);
3086+ data_node->GetOpDesc()->impl_->input_name_idx_["x"] = 0;
3087+ builder.AddDataEdge(enter_node, 0, data_node, 0);
3088+ auto op = OpDescUtils::CreateOperatorFromNode(data_node);
3089+ Tensor tensor;
3090+ EXPECT_EQ(op.GetInputConstData("x", tensor), GRAPH_SUCCESS);
3091+}
3092+ 
3093+TEST_F(UtestOperater, IncCov_UpdateOutputDesc_NullOwnerInLinks) {
3094+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3095+ GeTensorDesc tensor_desc;
3096+ impl->GetOpDescImpl()->AddOutputDesc("y", tensor_desc);
3097+ ge::OpIO null_io("y", 0, nullptr);
3098+ impl->UpdateLinkMapImpl("y", null_io);
3099+ EXPECT_EQ(impl->UpdateOutputDesc("y", tensor_desc), GRAPH_SUCCESS);
3100+}
3101+ 
3102+TEST_F(UtestOperater, IncCov_OperatorImpl_SetNodeTwice) {
3103+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3104+ EXPECT_EQ(impl->SetNode(nullptr), GRAPH_SUCCESS);
3105+ EXPECT_EQ(impl->SetNode(nullptr), GRAPH_SUCCESS);
3106+}
3107+ 
3108+TEST_F(UtestOperater, IncCov_GetInputConstDataOut_ConstantType) {
3109+ auto impl = std::make_shared<OperatorImpl>("test", "Constant");
3110+ GeTensorDesc tensor_desc;
3111+ impl->GetOpDescImpl()->AddOutputDesc("y", tensor_desc);
3112+ auto ge_tensor = std::make_shared<GeTensor>();
3113+ AttrUtils::SetTensor(impl->GetOpDescImpl(), "value", ge_tensor);
3114+ auto src_impl = std::make_shared<OperatorImpl>("src", "Test");
3115+ src_impl->GetOpDescImpl()->AddInputDesc("x", tensor_desc);
3116+ src_impl->GetOpDescImpl()->impl_->input_name_idx_["x"] = 0;
3117+ ge::OpIO out_handle("y", 0, impl);
3118+ src_impl->input_link_.insert({"x", out_handle});
3119+ ConstGeTensorPtr ge_tensor_ptr;
3120+ EXPECT_EQ(src_impl->GetInputConstDataOut(0U, ge_tensor_ptr), GRAPH_SUCCESS);
3121+}
3122+ 
3123+TEST_F(UtestOperater, IncCov_GetInputConstDataOut_StringConstantType) {
3124+ auto impl = std::make_shared<OperatorImpl>("test", "Constant");
3125+ GeTensorDesc tensor_desc;
3126+ impl->GetOpDescImpl()->AddOutputDesc("y", tensor_desc);
3127+ auto ge_tensor = std::make_shared<GeTensor>();
3128+ AttrUtils::SetTensor(impl->GetOpDescImpl(), "value", ge_tensor);
3129+ auto src_impl = std::make_shared<OperatorImpl>("src", "Test");
3130+ src_impl->GetOpDescImpl()->AddInputDesc("x", tensor_desc);
3131+ src_impl->GetOpDescImpl()->impl_->input_name_idx_["x"] = 0;
3132+ ge::OpIO out_handle("y", 0, impl);
3133+ src_impl->input_link_.insert({"x", out_handle});
3134+ Tensor data;
3135+ EXPECT_EQ(src_impl->GetInputConstDataOut("x", data), GRAPH_SUCCESS);
3136+}
3137+ 
3138+TEST_F(UtestOperater, IncCov_GetInputConstData_GeTensorAlreadyHasValue) {
3139+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3140+ ConstGeTensorPtr ge_tensor = std::make_shared<GeTensor>();
3141+ EXPECT_EQ(impl->GetInputConstData(0U, ge_tensor), GRAPH_PARAM_INVALID);
3142+}
3143+ 
3144+TEST_F(UtestOperater, IncCov_OperatorImpl_ClearLinks) {
3145+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3146+ GeTensorDesc tensor_desc;
3147+ impl->GetOpDescImpl()->AddOutputDesc("y", tensor_desc);
3148+ ge::OpIO out_handle("y", 0, impl);
3149+ impl->UpdateLinkMapImpl("y", out_handle);
3150+ impl->ClearOutputLinks();
3151+ impl->ClearInputLinks();
3152+ EXPECT_EQ(impl->GetInputsSize(), 0UL);
3153+}
3154+ 
3155+TEST_F(UtestOperater, IncCov_AddControlInput_DuplicateInput) {
3156+ auto impl1 = std::make_shared<OperatorImpl>("test1", "Test");
3157+ auto impl2 = std::make_shared<OperatorImpl>("test2", "Test");
3158+ Operator op1(std::move(impl1));
3159+ Operator op2(std::move(impl2));
3160+ op1.AddControlInput(op2);
3161+ op1.AddControlInput(op2);
3162+ EXPECT_EQ(op1.operator_impl_->control_input_link_.size(), 1U);
3163+}
3164+ 
3165+TEST_F(UtestOperater, IncCov_GetInputImpl_ByIndex) {
3166+ auto impl = std::make_shared<OperatorImpl>("test", "Test");
3167+ GeTensorDesc tensor_desc;
3168+ impl->GetOpDescImpl()->AddInputDesc("x", tensor_desc);
3169+ impl->GetOpDescImpl()->impl_->input_name_idx_["x"] = 0;
3170+ ge::OpIO out_handle("", 0, nullptr);
3171+ EXPECT_EQ(impl->GetInputImpl(0U, out_handle), GRAPH_FAILED);
3172+ EXPECT_EQ(impl->GetInputImpl(100U, out_handle), GRAPH_FAILED);
3173+}
3174+ 
3175+TEST_F(UtestOperater, CovOpRegisterNullName) {
3176+ ge::Operator op("test_op", "Test");
3177+ op.InputRegister(nullptr);
3178+ op.OutputRegister(nullptr);
3179+ op.DynamicInputRegister(nullptr, 1);
3180+ op.DynamicOutputRegister(nullptr, 1);
3181+ op.DynamicInputRegisterByIndex(nullptr, 1, 0);
3182+ op.SubgraphRegister(nullptr, false);
3183+ op.AttrRegister(nullptr, "val");
3184+ SUCCEED();
3185+}
3186+ 
3187+TEST_F(UtestOperater, CovOpRegisterNullImpl) {
3188+ ge::Operator op("test_op2", "Test");
3189+ op.operator_impl_ = nullptr;
3190+ op.InputRegister("x");
3191+ op.OutputRegister("y");
3192+ op.DynamicInputRegister("x", 1);
3193+ op.DynamicOutputRegister("y", 1);
3194+ op.DynamicInputRegisterByIndex("x", 1, 0);
3195+ op.SubgraphRegister("sub", false);
3196+ op.AttrRegister("attr", "val");
3197+ op.AttrRegister("attr", static_cast<int64_t>(42));
3198+ op.AttrRegister("attr", std::vector<int64_t>{1, 2});
3199+ op.AttrRegister("attr", 3.14F);
3200+ op.AttrRegister("attr", std::vector<float32_t>{1.0F, 2.0F});
3201+ op.AttrRegister("attr", true);
3202+ op.AttrRegister("attr", std::vector<bool>{true, false});
3203+ op.AttrRegister("attr", std::vector<std::vector<int64_t>>{{1}, {2}});
3204+ op.AttrRegister("attr", ge::NamedAttrs());
3205+ op.AttrRegister("attr", std::vector<ge::NamedAttrs>{});
3206+ op.AttrRegister("attr", AscendString("val"));
3207+ op.AttrRegister("attr", std::vector<AscendString>{AscendString("a")});
3208+ SUCCEED();
3209+}
3210+ 
3211+TEST_F(UtestOperater, CovOpAttrRegisterNullNameChar) {
3212+ ge::Operator op("test_op3", "Test");
3213+ op.AttrRegister(static_cast<const char_t *>(nullptr), AscendString("val"));
3214+ op.AttrRegister(static_cast<const char_t *>(nullptr), std::vector<AscendString>{AscendString("a")});
3215+ op.AttrRegister(static_cast<const char_t *>(nullptr), AttrValue());
3216+ SUCCEED();
3217+}
3218+ 
3219+TEST_F(UtestOperater, CovOpAttrRegisterInvalidAscendString) {
3220+ ge::Operator op("test_op4", "Test");
3221+ AscendString null_str;
3222+ op.AttrRegister("attr", null_str);
3223+ std::vector<AscendString> null_vec{AscendString()};
3224+ op.AttrRegister("attr", null_vec);
3225+ SUCCEED();
3226+}
3227+ 
3228+TEST_F(UtestOperater, CovOpSetAttrNullImpl) {
3229+ ge::Operator op("test_op5", "Test");
3230+ op.operator_impl_ = nullptr;
3231+ op.SetAttr("attr", std::string("val"));
3232+ op.SetAttr("attr", static_cast<int64_t>(42));
3233+ op.SetAttr("attr", std::vector<int64_t>{1});
3234+ op.SetAttr("attr", 3.14F);
3235+ op.SetAttr("attr", std::vector<float32_t>{1.0F});
3236+ op.SetAttr("attr", true);
3237+ op.SetAttr("attr", std::vector<bool>{true});
3238+ op.SetAttr("attr", AscendString("val"));
3239+ op.SetAttr("attr", std::vector<AscendString>{AscendString("a")});
3240+ op.SetAttr("attr", Tensor());
3241+ op.SetAttr("attr", std::vector<Tensor>{});
3242+ op.SetAttr("attr", ge::NamedAttrs());
3243+ op.SetAttr("attr", std::vector<ge::NamedAttrs>{});
3244+ op.SetAttr("attr", AttrValue());
3245+ SUCCEED();
3246+}
3247+ 
3248+TEST_F(UtestOperater, CovOpGetAttrNullImpl) {
3249+ ge::Operator op("test_op6", "Test");
3250+ op.operator_impl_ = nullptr;
3251+ std::string str_val;
3252+ op.GetAttr("attr", str_val);
3253+ int64_t int_val = 0;
3254+ op.GetAttr("attr", int_val);
3255+ std::vector<int64_t> int_vec;
3256+ op.GetAttr("attr", int_vec);
3257+ float32_t float_val = 0;
3258+ op.GetAttr("attr", float_val);
3259+ std::vector<float32_t> float_vec;
3260+ op.GetAttr("attr", float_vec);
3261+ bool bool_val = false;
3262+ op.GetAttr("attr", bool_val);
3263+ std::vector<bool> bool_vec;
3264+ op.GetAttr("attr", bool_vec);
3265+ AscendString ascend_val;
3266+ op.GetAttr("attr", ascend_val);
3267+ std::vector<AscendString> ascend_vec;
3268+ op.GetAttr("attr", ascend_vec);
3269+ Tensor tensor_val;
3270+ op.GetAttr("attr", tensor_val);
3271+ std::vector<Tensor> tensor_vec;
3272+ op.GetAttr("attr", tensor_vec);
3273+ ge::NamedAttrs named_val;
3274+ op.GetAttr("attr", named_val);
3275+ std::vector<ge::NamedAttrs> named_vec;
3276+ op.GetAttr("attr", named_vec);
3277+ AttrValue attr_val;
3278+ op.GetAttr("attr", attr_val);
3279+ SUCCEED();
3280+}
3281+ 
3282+TEST_F(UtestOperater, CovOpSetAttrNullNameChar) {
3283+ ge::Operator op("test_op7", "Test");
3284+ op.SetAttr(static_cast<const char_t *>(nullptr), AscendString("val"));
3285+ op.SetAttr(static_cast<const char_t *>(nullptr), std::vector<AscendString>{AscendString("a")});
3286+ op.SetAttr(static_cast<const char_t *>(nullptr), Tensor());
3287+ op.SetAttr(static_cast<const char_t *>(nullptr), std::vector<Tensor>{});
3288+ op.SetAttr(static_cast<const char_t *>(nullptr), ge::NamedAttrs());
3289+ op.SetAttr(static_cast<const char_t *>(nullptr), std::vector<ge::NamedAttrs>{});
3290+ SUCCEED();
3291+}
3292+ 
3293+TEST_F(UtestOperater, CovOpGetAttrNullNameChar) {
3294+ ge::Operator op("test_op8", "Test");
3295+ AscendString ascend_val;
3296+ op.GetAttr(static_cast<const char_t *>(nullptr), ascend_val);
3297+ std::vector<AscendString> ascend_vec;
3298+ op.GetAttr(static_cast<const char_t *>(nullptr), ascend_vec);
3299+ Tensor tensor_val;
3300+ op.GetAttr(static_cast<const char_t *>(nullptr), tensor_val);
3301+ std::vector<Tensor> tensor_vec;
3302+ op.GetAttr(static_cast<const char_t *>(nullptr), tensor_vec);
3303+ ge::NamedAttrs named_val;
3304+ op.GetAttr(static_cast<const char_t *>(nullptr), named_val);
3305+ std::vector<ge::NamedAttrs> named_vec;
3306+ op.GetAttr(static_cast<const char_t *>(nullptr), named_vec);
3307+ AttrValue attr_val;
3308+ op.GetAttr(static_cast<const char_t *>(nullptr), attr_val);
3309+ SUCCEED();
3310+}
3311+ 
3312+TEST_F(UtestOperater, CovOpSetGetAttrValid) {
3313+ ge::Operator op("test_op9", "Test");
3314+ op.AttrRegister("str_attr", "hello");
3315+ op.AttrRegister("int_attr", static_cast<int64_t>(42));
3316+ op.AttrRegister("float_attr", 3.14F);
3317+ op.AttrRegister("bool_attr", true);
3318+ op.SetAttr("str_attr", std::string("world"));
3319+ op.SetAttr("int_attr", static_cast<int64_t>(100));
3320+ op.SetAttr("float_attr", 2.71F);
3321+ op.SetAttr("bool_attr", false);
3322+ op.SetAttr("str_attr", AscendString("ascend_val"));
3323+ op.SetAttr("list_str", std::vector<AscendString>{AscendString("a"), AscendString("b")});
3324+ std::string str_val;
3325+ EXPECT_EQ(op.GetAttr("str_attr", str_val), GRAPH_SUCCESS);
3326+ int64_t int_val = 0;
3327+ EXPECT_EQ(op.GetAttr("int_attr", int_val), GRAPH_SUCCESS);
3328+ AscendString ascend_val;
3329+ op.GetAttr("str_attr", ascend_val);
3330+ std::vector<AscendString> ascend_vec;
3331+ op.GetAttr("list_str", ascend_vec);
3332+ Tensor t;
3333+ op.SetAttr("tensor_attr", t);
3334+ op.GetAttr("tensor_attr", t);
3335+ op.SetAttr("named_attr", ge::NamedAttrs());
3336+ ge::NamedAttrs na;
3337+ op.GetAttr("named_attr", na);
3338+ SUCCEED();
3339+}
3340+ 
3341+TEST_F(UtestOperater, CovOpNamedAttrsAndListNamedAttrs) {
3342+ ge::Operator op("test_op10", "Test");
3343+ ge::NamedAttrs named;
3344+ named.SetName("test_named");
3345+ AttrUtils::SetInt(&named, "key", static_cast<int64_t>(1));
3346+ op.SetAttr("named", named);
3347+ ge::NamedAttrs ret_named;
3348+ EXPECT_EQ(op.GetAttr("named", ret_named), GRAPH_SUCCESS);
3349+ std::vector<ge::NamedAttrs> list_named{named, named};
3350+ op.SetAttr("list_named", list_named);
3351+ std::vector<ge::NamedAttrs> ret_list;
3352+ EXPECT_EQ(op.GetAttr("list_named", ret_list), GRAPH_SUCCESS);
3353+ op.AttrRegister("reg_named", named);
3354+ op.AttrRegister("reg_list_named", list_named);
3355+ SUCCEED();
3356+}
3357+ 
3358+TEST_F(UtestOperater, CovOpSetInputAttrNullImpl) {
3359+ ge::Operator op("test_op11", "Test");
3360+ op.operator_impl_ = nullptr;
3361+ op.SetInputAttr(0, "attr", "val");
3362+ op.SetInputAttr(0, "attr", static_cast<int64_t>(42));
3363+ op.SetInputAttr(0, "attr", 3.14F);
3364+ op.SetInputAttr(0, "attr", true);
3365+ op.SetInputAttr(0, "attr", AscendString("val"));
3366+ op.SetInputAttr("input_name", "attr", "val");
3367+ op.SetInputAttr("input_name", "attr", static_cast<int64_t>(42));
3368+ op.SetInputAttr("input_name", "attr", 3.14F);
3369+ op.SetInputAttr("input_name", "attr", true);
3370+ op.SetInputAttr("input_name", "attr", AscendString("val"));
3371+ SUCCEED();
3372+}
3373+ 
3374+TEST_F(UtestOperater, CovOpSetOutputAttrNullImpl) {
3375+ ge::Operator op("test_op12", "Test");
3376+ op.operator_impl_ = nullptr;
3377+ op.SetOutputAttr(0, "attr", "val");
3378+ op.SetOutputAttr(0, "attr", static_cast<int64_t>(42));
3379+ op.SetOutputAttr(0, "attr", 3.14F);
3380+ op.SetOutputAttr(0, "attr", true);
3381+ op.SetOutputAttr(0, "attr", AscendString("val"));
3382+ op.SetOutputAttr("output_name", "attr", "val");
3383+ op.SetOutputAttr("output_name", "attr", static_cast<int64_t>(42));
3384+ op.SetOutputAttr("output_name", "attr", 3.14F);
3385+ op.SetOutputAttr("output_name", "attr", true);
3386+ op.SetOutputAttr("output_name", "attr", AscendString("val"));
3387+ SUCCEED();
3388+}
3389+ 
3390+TEST_F(UtestOperater, CovOpGetInputAttrNullImpl) {
3391+ ge::Operator op("test_op13", "Test");
3392+ op.operator_impl_ = nullptr;
3393+ AscendString str_val;
3394+ op.GetInputAttr(0, "attr", str_val);
3395+ op.GetInputAttr("input_name", "attr", str_val);
3396+ int64_t int_val = 0;
3397+ op.GetInputAttr(0, "attr", int_val);
3398+ op.GetInputAttr("input_name", "attr", int_val);
3399+ AscendString ascend_val;
3400+ op.GetInputAttr(0, "attr", ascend_val);
3401+ op.GetInputAttr("input_name", "attr", ascend_val);
3402+ SUCCEED();
3403+}
3404+ 
3405+TEST_F(UtestOperater, CovOpGetOutputAttrNullImpl) {
3406+ ge::Operator op("test_op14", "Test");
3407+ op.operator_impl_ = nullptr;
3408+ AscendString str_val;
3409+ op.GetOutputAttr(0, "attr", str_val);
3410+ op.GetOutputAttr("output_name", "attr", str_val);
3411+ int64_t int_val = 0;
3412+ op.GetOutputAttr(0, "attr", int_val);
3413+ op.GetOutputAttr("output_name", "attr", int_val);
3414+ AscendString ascend_val;
3415+ op.GetOutputAttr(0, "attr", ascend_val);
3416+ op.GetOutputAttr("output_name", "attr", ascend_val);
3417+ SUCCEED();
3418+}
3419+ 
3420+TEST_F(UtestOperater, CovOpGetDynamicSubgraphBuilderNullImpl) {
3421+ ge::Operator op("test_op15", "Test");
3422+ op.operator_impl_ = nullptr;
3423+ auto builder = op.GetDynamicSubgraphBuilder("sub", 0U);
3424+ EXPECT_EQ(builder, nullptr);
3425+}
3426+ 
3427+TEST_F(UtestOperater, CovOpGetSubgraphFailures) {
3428+ ge::Operator op("test_op16", "Test");
3429+ auto graph = op.GetSubgraph("nonexistent");
3430+ EXPECT_FALSE(graph.IsValid());
3431+ op.SubgraphRegister("sub", false);
3432+ op.SubgraphCountRegister("sub", 1);
3433+ graph = op.GetSubgraph("sub");
3434+ graph = op.GetSubgraph(static_cast<const char_t *>(nullptr));
3435+ SUCCEED();
3436+}
3437+ 
3438+TEST_F(UtestOperater, CovOpAttrRegisterStringAndVector) {
3439+ ge::Operator op("test_op17", "Test");
3440+ op.AttrRegister("str_attr", AscendString("val"));
3441+ op.AttrRegister("list_str_attr", std::vector<AscendString>{AscendString("a"), AscendString("b")});
3442+ op.AttrRegister("tensor_attr", std::vector<Tensor>{});
3443+ SUCCEED();
3444+}
3445+ 
3446+TEST_F(UtestOperater, CovOpSetAttrAttrValue) {
3447+ ge::Operator op("test_op18", "Test");
3448+ AttrValue av;
3449+ op.SetAttr("attr", std::move(av));
3450+ op.operator_impl_ = nullptr;
3451+ op.SetAttr("attr", AttrValue());
3452+ SUCCEED();
3453+}
3454+ 
3455+TEST_F(UtestOperater, CovOpGetInputConstDataOutFail) {
3456+ ge::Operator op("test_op19", "Test");
3457+ Tensor data;
3458+ EXPECT_EQ(op.GetInputConstDataOut("nonexistent", data), GRAPH_FAILED);
3459+ EXPECT_EQ(op.GetInputConstDataOut(static_cast<const char_t *>(nullptr), data), GRAPH_FAILED);
3460+ SUCCEED();
3461+}
3462+ 
3463+TEST_F(UtestOperater, CovOpVerifyAll) {
3464+ ge::Operator op("test_op20", "Test");
3465+ op.InputRegister("x");
3466+ op.OutputRegister("y");
3467+ op.AttrRegister("attr", static_cast<int64_t>(1));
3468+ EXPECT_EQ(op.VerifyAll(), GRAPH_FAILED);
3469+ op.operator_impl_ = nullptr;
3470+ EXPECT_EQ(op.VerifyAll(), GRAPH_FAILED);
3471+}
3472+ 
3033} // namespace ge3473} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/plugin_manager_unittest.cc+182-0
@@ -50,6 +50,24 @@ class UtestPluginManagerCov : public testing::Test {
50 model_path = model_path.substr(0, model_path.rfind('/') + 1U);50 model_path = model_path.substr(0, model_path.rfind('/') + 1U);
51 return model_path;51 return model_path;
52 }52 }
53+ 
54+ static std::string GetSoRunPkgPath() {
55+ mmDlInfo dl_info{nullptr, nullptr, nullptr, nullptr, 0, 0, 0};
56+ void *func_ptr = reinterpret_cast<void *>(&PluginManager::GetCurEnvPackageOsAndCpuType);
57+ if ((mmDladdr(func_ptr, &dl_info) != EN_OK) || (dl_info.dli_fname == nullptr)) {
58+ return GetRunPkgPath();
59+ }
60+ char_t path[MMPA_MAX_PATH] = {};
61+ if (mmRealPath(dl_info.dli_fname, &path[0], MMPA_MAX_PATH) != EN_OK) {
62+ return GetRunPkgPath();
63+ }
64+ std::string so_path = path;
65+ so_path = so_path.substr(0U, so_path.rfind('/') + 1U);
66+ so_path = so_path.substr(0U, so_path.rfind('/'));
67+ so_path = so_path.substr(0U, so_path.rfind('/'));
68+ so_path = so_path.substr(0U, so_path.rfind('/') + 1U);
69+ return so_path;
70+ }
53};71};
54 72 
55// ---- ReversePathString ----73// ---- ReversePathString ----
@@ -1450,3 +1468,167 @@ TEST_F(UtestPluginManagerCov, IncCov_GetOppPluginPathNew_NoVendors) {
1450 std::string plugin_path;1468 std::string plugin_path;
1451 EXPECT_EQ(PluginManager::GetOppPluginPathNew(opp_dir, "%s/op_proto/", plugin_path, "custom/"), SUCCESS);1469 EXPECT_EQ(PluginManager::GetOppPluginPathNew(opp_dir, "%s/op_proto/", plugin_path, "custom/"), SUCCESS);
1452}1470}
1471+ 
1472+TEST_F(UtestPluginManagerCov, Load_DirWithSoFileValidateFail) {
1473+ std::string dir_path = kTmpDir + "/load_validate_fail";
1474+ system(("mkdir -p " + dir_path).c_str());
1475+ std::string big_so = dir_path + "/libbig.so";
1476+ system(("dd if=/dev/zero of=" + big_so + " bs=1 count=0 seek=838860801 2>/dev/null").c_str());
1477+ PluginManager mgr;
1478+ std::vector<std::string> func_check_list;
1479+ EXPECT_EQ(mgr.Load(dir_path, func_check_list), SUCCESS);
1480+ EXPECT_EQ(mgr.so_list_.size(), 0U);
1481+ system(("rm -f " + big_so).c_str());
1482+}
1483+ 
1484+TEST_F(UtestPluginManagerCov, Load_DirWithBrokenSymlinkSo) {
1485+ std::string dir_path = kTmpDir + "/load_broken_symlink";
1486+ system(("mkdir -p " + dir_path).c_str());
1487+ system(("ln -s /nonexist/target " + dir_path + "/broken_link.so").c_str());
1488+ PluginManager mgr;
1489+ std::vector<std::string> func_check_list;
1490+ EXPECT_EQ(mgr.Load(dir_path, func_check_list), SUCCESS);
1491+ EXPECT_EQ(mgr.so_list_.size(), 0U);
1492+}
1493+ 
1494+TEST_F(UtestPluginManagerCov, ValidateSo_FileSizeExceedsIndividualMax) {
1495+ std::string so_path = kTmpDir + "/big_sparse.so";
1496+ system(("dd if=/dev/zero of=" + so_path + " bs=1 count=0 seek=838860801 2>/dev/null").c_str());
1497+ PluginManager mgr;
1498+ int64_t file_size = 0;
1499+ EXPECT_EQ(mgr.ValidateSo(so_path, 0, file_size), FAILED);
1500+ system(("rm -f " + so_path).c_str());
1501+}
1502+ 
1503+TEST_F(UtestPluginManagerCov, GetCurEnvPackageOsAndCpuType_UnknownKeyInScene) {
1504+ std::string run_pkg_path = GetSoRunPkgPath();
1505+ std::string opp_dir = run_pkg_path + "opp";
1506+ std::string scene_file = opp_dir + "/scene.info";
1507+ bool created = false;
1508+ if (system(("mkdir -p " + opp_dir).c_str()) == 0) {
1509+ system(("printf 'foo=bar\nos=linux\narch=x86_64\n' > " + scene_file).c_str());
1510+ created = true;
1511+ }
1512+ std::string os_type;
1513+ std::string cpu_type;
1514+ PluginManager::GetCurEnvPackageOsAndCpuType(os_type, cpu_type);
1515+ if (created) {
1516+ EXPECT_EQ(os_type, "linux");
1517+ EXPECT_EQ(cpu_type, "x86_64");
1518+ system(("rm -rf " + opp_dir).c_str());
1519+ }
1520+}
1521+ 
1522+TEST_F(UtestPluginManagerCov, GetRequiredOppAbiVersion_InvalidSingleVersionNum) {
1523+ std::string run_pkg_path = GetSoRunPkgPath();
1524+ std::string compiler_dir = run_pkg_path + "compiler";
1525+ std::string runtime_dir = run_pkg_path + "runtime";
1526+ system(("rm -rf " + runtime_dir).c_str());
1527+ bool created = false;
1528+ if (system(("mkdir -p " + compiler_dir).c_str()) == 0) {
1529+ std::string version_file = compiler_dir + "/version.info";
1530+ std::ofstream ofs(version_file);
1531+ if (ofs.is_open()) {
1532+ ofs << "required_opp_abi_version=abc.def";
1533+ ofs.close();
1534+ created = true;
1535+ }
1536+ }
1537+ PluginManager mgr;
1538+ std::vector<std::pair<uint32_t, uint32_t>> required;
1539+ bool result = mgr.GetRequiredOppAbiVersion(required);
1540+ if (created) {
1541+ EXPECT_FALSE(result);
1542+ system(("rm -rf " + compiler_dir).c_str());
1543+ }
1544+}
1545+ 
1546+TEST_F(UtestPluginManagerCov, GetRequiredOppAbiVersion_RangeInvalidFirst) {
1547+ std::string run_pkg_path = GetSoRunPkgPath();
1548+ std::string compiler_dir = run_pkg_path + "compiler";
1549+ std::string runtime_dir = run_pkg_path + "runtime";
1550+ system(("rm -rf " + runtime_dir).c_str());
1551+ bool created = false;
1552+ if (system(("mkdir -p " + compiler_dir).c_str()) == 0) {
1553+ std::string version_file = compiler_dir + "/version.info";
1554+ std::ofstream ofs(version_file);
1555+ if (ofs.is_open()) {
1556+ ofs << "required_opp_abi_version=>=abc, <=6.4";
1557+ ofs.close();
1558+ created = true;
1559+ }
1560+ }
1561+ PluginManager mgr;
1562+ std::vector<std::pair<uint32_t, uint32_t>> required;
1563+ bool result = mgr.GetRequiredOppAbiVersion(required);
1564+ if (created) {
1565+ EXPECT_FALSE(result);
1566+ system(("rm -rf " + compiler_dir).c_str());
1567+ }
1568+}
1569+ 
1570+TEST_F(UtestPluginManagerCov, GetRequiredOppAbiVersion_RangeInvalidSecond) {
1571+ std::string run_pkg_path = GetSoRunPkgPath();
1572+ std::string compiler_dir = run_pkg_path + "compiler";
1573+ std::string runtime_dir = run_pkg_path + "runtime";
1574+ system(("rm -rf " + runtime_dir).c_str());
1575+ bool created = false;
1576+ if (system(("mkdir -p " + compiler_dir).c_str()) == 0) {
1577+ std::string version_file = compiler_dir + "/version.info";
1578+ std::ofstream ofs(version_file);
1579+ if (ofs.is_open()) {
1580+ ofs << "required_opp_abi_version=>=6.3, <=def";
1581+ ofs.close();
1582+ created = true;
1583+ }
1584+ }
1585+ PluginManager mgr;
1586+ std::vector<std::pair<uint32_t, uint32_t>> required;
1587+ bool result = mgr.GetRequiredOppAbiVersion(required);
1588+ if (created) {
1589+ EXPECT_FALSE(result);
1590+ system(("rm -rf " + compiler_dir).c_str());
1591+ }
1592+}
1593+ 
1594+TEST_F(UtestPluginManagerCov, IsSplitOpp_WithRtSoFiles) {
1595+ std::string opp_dir = kTmpDir + "/opp_split";
1596+ std::string proto_lib_dir = opp_dir + "/built-in/op_proto/lib/linux/x86_64/";
1597+ std::string tiling_lib_dir = opp_dir + "/built-in/op_impl/ai_core/tbe/op_tiling/lib/linux/x86_64/";
1598+ system(("mkdir -p " + proto_lib_dir).c_str());
1599+ system(("mkdir -p " + tiling_lib_dir).c_str());
1600+ system(("touch " + proto_lib_dir + "/libproto_rt.so").c_str());
1601+ system(("touch " + tiling_lib_dir + "/libtiling_rt.so").c_str());
1602+ setenv("ASCEND_OPP_PATH", opp_dir.c_str(), 1);
1603+ 
1604+ std::string run_pkg_path = GetSoRunPkgPath();
1605+ std::string scene_dir = run_pkg_path + "opp";
1606+ std::string scene_file = scene_dir + "/scene.info";
1607+ bool scene_created = false;
1608+ if (system(("mkdir -p " + scene_dir).c_str()) == 0) {
1609+ system(("printf 'os=linux\narch=x86_64\n' > " + scene_file).c_str());
1610+ scene_created = true;
1611+ }
1612+ 
1613+ if (scene_created) {
1614+ EXPECT_TRUE(PluginManager::IsSplitOpp());
1615+ system(("rm -rf " + scene_dir).c_str());
1616+ } else {
1617+ PluginManager::IsSplitOpp();
1618+ }
1619+}
1620+ 
1621+TEST_F(UtestPluginManagerCov, GetOppSupportedOsAndCpuType_PathTooLongFromEnv) {
1622+ std::string long_path(4100, 'a');
1623+ long_path = "/tmp/" + long_path;
1624+ setenv("ASCEND_OPP_PATH", long_path.c_str(), 1);
1625+ std::unordered_map<std::string, std::unordered_set<std::string>> opp_supported_os_cpu;
1626+ PluginManager::GetOppSupportedOsAndCpuType(opp_supported_os_cpu);
1627+ EXPECT_TRUE(opp_supported_os_cpu.empty());
1628+}
1629+ 
1630+TEST_F(UtestPluginManagerCov, CheckOppAndCompilerVersions_SuccessWithMultipleRanges) {
1631+ PluginManager mgr;
1632+ std::vector<std::pair<uint32_t, uint32_t>> required = {{630000, 640000}, {800000, 810000}};
1633+ EXPECT_TRUE(mgr.CheckOppAndCompilerVersions("6.3", "8.0,8.1", required));
1634+}
Mtests/graph_metadef/ut/graph/testcase/readable_dump_unittest.cc+40-0
@@ -1220,3 +1220,43 @@ graph("Conv2D_17function_graph_1"):
1220 EXPECT_EQ(SUCCESS, ReadableDump::GenReadableDump(readable_ss, compute_graph));1220 EXPECT_EQ(SUCCESS, ReadableDump::GenReadableDump(readable_ss, compute_graph));
1221 EXPECT_EQ(readable_dump, readable_ss.str());1221 EXPECT_EQ(readable_dump, readable_ss.str());
1222}1222}
1223+ 
1224+REG_OP(phony_empty_str_attr)
1225+ .INPUT(x, TensorType::ALL())
1226+ .ATTR(empty_s, String, "")
1227+ .ATTR(empty_li, ListInt, {})
1228+ .OUTPUT(y, TensorType::NumberType())
1229+ .OP_END_FACTORY_REG(phony_empty_str_attr);
1230+ 
1231+TEST_F(UtestReadableDump, test_DumpNodeWithEmptyAttrValueStr) {
1232+ ut::GraphBuilder builder = ut::GraphBuilder("graph_empty_attr");
1233+ const auto &netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
1234+ auto compute_graph = builder.GetGraph();
1235+ auto graph = ge::GraphUtilsEx::CreateGraphFromComputeGraph(compute_graph);
1236+ 
1237+ auto data_op = op::Data("data");
1238+ auto data_node = graph.AddNodeByOp(data_op);
1239+ 
1240+ auto empty_attr_op = op::phony_empty_str_attr("test_empty_attr");
1241+ auto empty_attr_node = graph.AddNodeByOp(empty_attr_op);
1242+ graph.AddDataEdge(data_node, 0, empty_attr_node, 0);
1243+ 
1244+ GNode netoutput_gnode = NodeAdapter::Node2GNode(netoutput);
1245+ graph.AddDataEdge(empty_attr_node, 0, netoutput_gnode, 0);
1246+ 
1247+ std::stringstream readable_ss;
1248+ EXPECT_EQ(SUCCESS, ReadableDump::GenReadableDump(readable_ss, compute_graph));
1249+ EXPECT_TRUE(readable_ss.str().find("phony_empty_str_attr") != std::string::npos);
1250+}
1251+ 
1252+TEST_F(UtestReadableDump, test_DumpNetOutputWithUnconnectedInput) {
1253+ ut::GraphBuilder builder = ut::GraphBuilder("graph_unconnected");
1254+ auto data_node = builder.AddNode("Data", "Data", 0, 1);
1255+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 2, 0);
1256+ builder.AddDataEdge(data_node, 0, netoutput, 0);
1257+ 
1258+ auto compute_graph = builder.GetGraph();
1259+ std::stringstream readable_ss;
1260+ EXPECT_EQ(SUCCESS, ReadableDump::GenReadableDump(readable_ss, compute_graph));
1261+ EXPECT_TRUE(readable_ss.str().find("return") != std::string::npos);
1262+}
Mtests/graph_metadef/ut/graph/testcase/ref_relation_unittes.cc+99-0
@@ -1141,4 +1141,103 @@ TEST_F(UTTEST_RefRelations, IncCov_Clear_Success) {
1141 EXPECT_EQ(status, GRAPH_SUCCESS);1141 EXPECT_EQ(status, GRAPH_SUCCESS);
1142 EXPECT_EQ(result.size(), 0U);1142 EXPECT_EQ(result.size(), 0U);
1143}1143}
1144+ 
1145+TEST_F(UTTEST_RefRelations, IncCov_BuildRefRelations_CallTwice) {
1146+ auto main_graph = BuildMainGraphWithIf();
1147+ RefRelations ref_builder;
1148+ auto status = ref_builder.BuildRefRelations(*main_graph);
1149+ EXPECT_EQ(status, GRAPH_SUCCESS);
1150+ status = ref_builder.BuildRefRelations(*main_graph);
1151+ EXPECT_EQ(status, GRAPH_SUCCESS);
1152+}
1153+ 
1154+ComputeGraphPtr BuildMainGraphWithSameVariable() {
1155+ ut::GraphBuilder builder("main_graph_var");
1156+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
1157+ auto var1 = builder.AddNode("shared_var", "Variable", 0, 1);
1158+ auto if1 = builder.AddNode("if", "If", 1, 1);
1159+ auto netoutput1 = builder.AddNode("netoutput", "NetOutput", 1, 1);
1160+ 
1161+ builder.AddDataEdge(data1, 0, if1, 0);
1162+ builder.AddDataEdge(if1, 0, netoutput1, 0);
1163+ 
1164+ auto main_graph = builder.GetGraph();
1165+ 
1166+ ut::GraphBuilder sub_builder("sub1_var");
1167+ auto sub_data1 = sub_builder.AddNode("sub1data1", "Data", 1, 1);
1168+ auto sub_var1 = sub_builder.AddNode("shared_var", "Variable", 0, 1);
1169+ auto sub_netoutput = sub_builder.AddNode("sub1netoutput", "NetOutput", 1, 1);
1170+ 
1171+ AttrUtils::SetInt(sub_data1->GetOpDesc(), "_parent_node_index", static_cast<int>(0));
1172+ AttrUtils::SetInt(sub_netoutput->GetOpDesc()->MutableInputDesc(0), "_parent_node_index", static_cast<int>(0));
1173+ 
1174+ sub_builder.AddDataEdge(sub_data1, 0, sub_netoutput, 0);
1175+ 
1176+ auto sub1 = sub_builder.GetGraph();
1177+ sub1->SetParentGraph(main_graph);
1178+ sub1->SetParentNode(main_graph->FindNode("if"));
1179+ main_graph->FindNode("if")->GetOpDesc()->AddSubgraphName("sub1");
1180+ main_graph->FindNode("if")->GetOpDesc()->SetSubgraphInstanceName(0, "sub1");
1181+ main_graph->AddSubgraph("sub1", sub1);
1182+ 
1183+ return main_graph;
1184+}
1185+ 
1186+TEST_F(UTTEST_RefRelations, IncCov_BuildRelationsForVariables) {
1187+ auto main_graph = BuildMainGraphWithSameVariable();
1188+ RefRelations ref_builder;
1189+ auto status = ref_builder.BuildRefRelations(*main_graph);
1190+ EXPECT_EQ(status, GRAPH_SUCCESS);
1191+ 
1192+ auto var1 = main_graph->FindNode("shared_var");
1193+ ASSERT_NE(var1, nullptr);
1194+ RefCell key("shared_var", var1, NODE_OUT, 0);
1195+ std::unordered_set<RefCell, RefCellHash> result;
1196+ status = ref_builder.LookUpRefRelations(key, result);
1197+ EXPECT_EQ(status, GRAPH_SUCCESS);
1198+ EXPECT_GE(result.size(), 1U);
1199+}
1200+ 
1201+TEST_F(UTTEST_RefRelations, IncCov_LookUpRefRelations_AfterClear) {
1202+ auto main_graph = BuildMainGraphWithIf();
1203+ RefRelations ref_builder;
1204+ auto status = ref_builder.BuildRefRelations(*main_graph);
1205+ EXPECT_EQ(status, GRAPH_SUCCESS);
1206+ 
1207+ (void)ref_builder.Clear();
1208+ 
1209+ auto if1 = main_graph->FindNode("if");
1210+ RefCell key("if", if1, NODE_IN, 0);
1211+ std::unordered_set<RefCell, RefCellHash> result;
1212+ status = ref_builder.LookUpRefRelations(key, result);
1213+ EXPECT_EQ(status, GRAPH_SUCCESS);
1214+ EXPECT_EQ(result.size(), 0U);
1215+}
1216+ 
1217+TEST_F(UTTEST_RefRelations, IncCov_BuildRefRelations_EmptyGraph) {
1218+ ut::GraphBuilder builder("empty_graph");
1219+ auto data1 = builder.AddNode("data1", "Data", 1, 1);
1220+ auto netoutput = builder.AddNode("netoutput", "NetOutput", 1, 1);
1221+ builder.AddDataEdge(data1, 0, netoutput, 0);
1222+ auto graph = builder.GetGraph();
1223+ 
1224+ RefRelations ref_builder;
1225+ auto status = ref_builder.BuildRefRelations(*graph);
1226+ EXPECT_EQ(status, GRAPH_SUCCESS);
1227+}
1228+ 
1229+TEST_F(UTTEST_RefRelations, IncCov_BuildRefRelations_WhileWithMultipleNetoutputs) {
1230+ auto main_graph = BuildMainGraphWithWhile2();
1231+ RefRelations ref_builder;
1232+ (void)ref_builder.Clear();
1233+ auto status = ref_builder.BuildRefRelations(*main_graph);
1234+ EXPECT_EQ(status, GRAPH_SUCCESS);
1235+ 
1236+ auto while1 = main_graph->FindNode("while1");
1237+ ASSERT_NE(while1, nullptr);
1238+ RefCell key("while1", while1, NODE_IN, 0);
1239+ std::unordered_set<RefCell, RefCellHash> result;
1240+ status = ref_builder.LookUpRefRelations(key, result);
1241+ EXPECT_EQ(status, GRAPH_SUCCESS);
1242+}
1144} // namespace ge1243} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/shape_refiner_inc_cov_unittest.cc+344-0
@@ -608,4 +608,348 @@ TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_WithMultiBatchDiffDtyp
608 auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);608 auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
609 EXPECT_EQ(ret, GRAPH_SUCCESS);609 EXPECT_EQ(ret, GRAPH_SUCCESS);
610}610}
611+ 
612+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_MultiBatchShapeOverflow) {
613+ auto root_graph = std::make_shared<ComputeGraph>("test_overflow");
614+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_overflow", "If", 1, 1);
615+ auto op_desc = if_node->GetOpDesc();
616+ op_desc->AddSubgraphName("sub1");
617+ op_desc->SetSubgraphInstanceName(0, "sub1");
618+ AttrUtils::SetInt(op_desc, ATTR_NAME_BATCH_NUM, 2);
619+ 
620+ auto sub1 = std::make_shared<ComputeGraph>("sub1_overflow");
621+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_ovf", "Data", 1, 1);
622+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
623+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_ovf", "NetOutput", 1, 0);
624+ 
625+ GeTensorDesc out_desc1(GeShape({std::numeric_limits<int64_t>::max(), 2}), FORMAT_NCHW, DT_FLOAT);
626+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
627+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
628+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
629+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
630+ sub1->SetParentNode(if_node);
631+ sub1->SetParentGraph(root_graph);
632+ root_graph->AddSubgraph("sub1", sub1);
633+ 
634+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
635+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
636+ GeTensorDesc if_output_desc(GeShape({std::numeric_limits<int64_t>::max(), 2}), FORMAT_NCHW, DT_FLOAT);
637+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
638+ 
639+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
640+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
641+ SUCCEED();
642+}
643+ 
644+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_MultiBatchEmptyOutput) {
645+ auto root_graph = std::make_shared<ComputeGraph>("test_mb_empty");
646+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_mb_empty", "If", 1, 2);
647+ auto op_desc = if_node->GetOpDesc();
648+ op_desc->AddSubgraphName("sub1");
649+ op_desc->SetSubgraphInstanceName(0, "sub1");
650+ AttrUtils::SetInt(op_desc, ATTR_NAME_BATCH_NUM, 2);
651+ 
652+ auto sub1 = std::make_shared<ComputeGraph>("sub1_mb_empty");
653+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_mb_empty", "Data", 1, 1);
654+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
655+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_mb_empty", "NetOutput", 1, 0);
656+ 
657+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
658+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
659+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
660+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
661+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
662+ sub1->SetParentNode(if_node);
663+ sub1->SetParentGraph(root_graph);
664+ root_graph->AddSubgraph("sub1", sub1);
665+ 
666+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
667+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
668+ GeTensorDesc if_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
669+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
670+ (void)if_node->GetOpDesc()->UpdateOutputDesc(1, if_output_desc);
671+ 
672+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
673+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
674+ SUCCEED();
675+}
676+ 
677+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_UnknownGraph) {
678+ auto graph = std::make_shared<ComputeGraph>("test_unknown_graph_flag");
679+ graph->SetGraphUnknownFlag(true);
680+ auto node = CreateNodeIncCov2(graph, "unknown_flag_node", "Relu", 1, 1);
681+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
682+ input_desc.SetOriginFormat(FORMAT_NCHW);
683+ input_desc.SetOriginDataType(DT_FLOAT);
684+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
685+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
686+ auto ret = ShapeRefiner::InferShapeAndType(node);
687+ SUCCEED();
688+}
689+ 
690+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_HasInferedVerified) {
691+ auto graph = std::make_shared<ComputeGraph>("test_infered_verified");
692+ auto input_node = CreateNodeIncCov2(graph, "input_verified", "Data", 1, 1);
693+ auto relu_node = CreateNodeIncCov2(graph, "relu_verified", "Relu", 1, 1);
694+ 
695+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
696+ input_desc.SetOriginFormat(FORMAT_NCHW);
697+ input_desc.SetOriginDataType(DT_FLOAT);
698+ (void)input_node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
699+ (void)relu_node->GetOpDesc()->UpdateInputDesc(0, input_desc);
700+ (void)relu_node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
701+ AttrUtils::SetBool(relu_node->GetOpDesc(), "has_infered_verified", true);
702+ 
703+ GraphUtils::AddEdge(input_node->GetOutDataAnchor(0), relu_node->GetInDataAnchor(0));
704+ auto ret = ShapeRefiner::InferShapeAndType(relu_node);
705+ SUCCEED();
706+}
707+ 
708+TEST_F(UtestShapeRefinerIncCov, IncCov2_PostProcessAfterInfershape_UnknownGraph) {
709+ auto graph = std::make_shared<ComputeGraph>("test_post_unknown");
710+ auto node = CreateNodeIncCov2(graph, "post_unknown_node", "Relu", 1, 1);
711+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
712+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
713+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
714+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
715+ auto ret = ShapeRefiner::PostProcessAfterInfershape(node, op, true);
716+ EXPECT_EQ(ret, GRAPH_SUCCESS);
717+}
718+ 
719+TEST_F(UtestShapeRefinerIncCov, IncCov2_PostProcessAfterInfershape_KnownGraph) {
720+ auto graph = std::make_shared<ComputeGraph>("test_post_known");
721+ auto node = CreateNodeIncCov2(graph, "post_known_node", "Relu", 1, 1);
722+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
723+ input_desc.SetOriginFormat(FORMAT_NCHW);
724+ input_desc.SetOriginDataType(DT_FLOAT);
725+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
726+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
727+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
728+ auto ret = ShapeRefiner::PostProcessAfterInfershape(node, op, false);
729+ EXPECT_EQ(ret, GRAPH_SUCCESS);
730+}
731+ 
732+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_WhileSameDimDiffValue) {
733+ auto root_graph = std::make_shared<ComputeGraph>("test_while_same_dim");
734+ NodePtr while_node = CreateNodeIncCov2(root_graph, "while_sdv", "While", 1, 1);
735+ auto op_desc = while_node->GetOpDesc();
736+ op_desc->AddSubgraphName("sub1");
737+ op_desc->SetSubgraphInstanceName(0, "sub1");
738+ 
739+ auto sub1 = std::make_shared<ComputeGraph>("sub1_while_sdv");
740+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_sdv", "Data", 1, 1);
741+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
742+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_sdv", "NetOutput", 1, 0);
743+ 
744+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
745+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
746+ 
747+ GeTensorDesc netinput_desc1(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
748+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
749+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, netinput_desc1);
750+ 
751+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
752+ 
753+ sub1->SetParentNode(while_node);
754+ sub1->SetParentGraph(root_graph);
755+ root_graph->AddSubgraph("sub1", sub1);
756+ 
757+ GeTensorDesc while_input_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
758+ (void)while_node->GetOpDesc()->UpdateInputDesc(0, while_input_desc);
759+ GeTensorDesc while_output_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
760+ (void)while_node->GetOpDesc()->UpdateOutputDesc(0, while_output_desc);
761+ 
762+ Operator op = OpDescUtils::CreateOperatorFromNode(while_node);
763+ auto ret = ShapeRefiner::InferShapeAndType(while_node, op, false);
764+ SUCCEED();
765+}
766+ 
767+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndTypeForRunning_GeLocalOp) {
768+ auto graph = std::make_shared<ComputeGraph>("test_ge_local");
769+ auto node = CreateNodeIncCov2(graph, "merge_node", "StreamMerge", 1, 1);
770+ 
771+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
772+ input_desc.SetOriginFormat(FORMAT_NCHW);
773+ input_desc.SetOriginDataType(DT_FLOAT);
774+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
775+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
776+ 
777+ auto op_desc = node->GetOpDesc();
778+ 
779+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
780+ auto ret = ShapeRefiner::InferShapeAndTypeForRunning(node, op, true);
781+ EXPECT_EQ(ret, GRAPH_SUCCESS);
782+}
783+ 
784+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_NullOpDesc) {
785+ auto graph = std::make_shared<ComputeGraph>("test_null_opdesc");
786+ auto node = CreateNodeIncCov2(graph, "null_opdesc_node", "Relu", 1, 1);
787+ auto ret = ShapeRefiner::InferShapeAndType(node, true);
788+ SUCCEED();
789+}
790+ 
791+TEST_F(UtestShapeRefinerIncCov, IncCov2_CreateInferenceContext_WithEdge) {
792+ auto graph = std::make_shared<ComputeGraph>("test_ctx_edge");
793+ auto input_node = CreateNodeIncCov2(graph, "ctx_input", "Data", 1, 1);
794+ auto relu_node = CreateNodeIncCov2(graph, "ctx_relu", "Relu", 1, 1);
795+ 
796+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
797+ input_desc.SetOriginFormat(FORMAT_NCHW);
798+ input_desc.SetOriginDataType(DT_FLOAT);
799+ (void)input_node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
800+ (void)relu_node->GetOpDesc()->UpdateInputDesc(0, input_desc);
801+ 
802+ GraphUtils::AddEdge(input_node->GetOutDataAnchor(0), relu_node->GetInDataAnchor(0));
803+ 
804+ ShapeRefiner::ClearContextMap();
805+ auto ctx = std::shared_ptr<InferenceContext>(InferenceContext::Create());
806+ ShapeRefiner::PushToContextMap(input_node, ctx);
807+ 
808+ InferenceContextPtr result_ctx;
809+ auto ret = ShapeRefiner::CreateInferenceContext(relu_node, result_ctx);
810+ EXPECT_EQ(ret, SUCCESS);
811+ EXPECT_NE(result_ctx, nullptr);
812+ ShapeRefiner::ClearContextMap();
813+}
814+ 
815+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_BranchDiffDtype) {
816+ auto root_graph = std::make_shared<ComputeGraph>("test_branch_diff_dt2");
817+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_diff_dt2", "If", 1, 1);
818+ auto op_desc = if_node->GetOpDesc();
819+ op_desc->AddSubgraphName("sub1");
820+ op_desc->SetSubgraphInstanceName(0, "sub1");
821+ 
822+ auto sub1 = std::make_shared<ComputeGraph>("sub1_diff_dt2");
823+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_dt2", "Data", 1, 1);
824+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
825+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_dt2", "NetOutput", 1, 0);
826+ 
827+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
828+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
829+ 
830+ GeTensorDesc netinput_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
831+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
832+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, netinput_desc1);
833+ 
834+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
835+ 
836+ sub1->SetParentNode(if_node);
837+ sub1->SetParentGraph(root_graph);
838+ root_graph->AddSubgraph("sub1", sub1);
839+ 
840+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
841+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
842+ GeTensorDesc if_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
843+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
844+ 
845+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
846+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
847+ SUCCEED();
848+}
849+ 
850+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_WhileSameShape) {
851+ auto root_graph = std::make_shared<ComputeGraph>("test_while_same_shape");
852+ NodePtr while_node = CreateNodeIncCov2(root_graph, "while_ss", "While", 1, 1);
853+ auto op_desc = while_node->GetOpDesc();
854+ op_desc->AddSubgraphName("sub1");
855+ op_desc->SetSubgraphInstanceName(0, "sub1");
856+ 
857+ auto sub1 = std::make_shared<ComputeGraph>("sub1_while_ss");
858+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_ss", "Data", 1, 1);
859+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 0);
860+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_ss", "NetOutput", 1, 0);
861+ 
862+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
863+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
864+ 
865+ GeTensorDesc netinput_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
866+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
867+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, netinput_desc1);
868+ 
869+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
870+ 
871+ sub1->SetParentNode(while_node);
872+ sub1->SetParentGraph(root_graph);
873+ root_graph->AddSubgraph("sub1", sub1);
874+ 
875+ GeTensorDesc while_input_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
876+ (void)while_node->GetOpDesc()->UpdateInputDesc(0, while_input_desc);
877+ GeTensorDesc while_output_desc(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
878+ (void)while_node->GetOpDesc()->UpdateOutputDesc(0, while_output_desc);
879+ 
880+ Operator op = OpDescUtils::CreateOperatorFromNode(while_node);
881+ auto ret = ShapeRefiner::InferShapeAndType(while_node, op, false);
882+ SUCCEED();
883+}
884+ 
885+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndTypeForRunning_FailedInferFunc) {
886+ auto graph = std::make_shared<ComputeGraph>("test_running_fail");
887+ auto node = CreateNodeIncCov2(graph, "running_fail_node", "Relu", 1, 1);
888+ 
889+ GeTensorDesc input_desc(GeShape({1, 3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
890+ input_desc.SetOriginFormat(FORMAT_NCHW);
891+ input_desc.SetOriginDataType(DT_FLOAT);
892+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
893+ (void)node->GetOpDesc()->UpdateOutputDesc(0, input_desc);
894+ 
895+ auto op_desc = node->GetOpDesc();
896+ op_desc->AddInferFunc([](Operator &op) { return GRAPH_FAILED; });
897+ 
898+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
899+ auto ret = ShapeRefiner::InferShapeAndTypeForRunning(node, op, true);
900+ EXPECT_EQ(ret, GRAPH_FAILED);
901+}
902+ 
903+TEST_F(UtestShapeRefinerIncCov, IncCov2_InferShapeAndType_SubgraphDataRefOutOfRange) {
904+ auto root_graph = std::make_shared<ComputeGraph>("test_data_ref_oor");
905+ NodePtr if_node = CreateNodeIncCov2(root_graph, "if_oor", "If", 1, 1);
906+ auto op_desc = if_node->GetOpDesc();
907+ op_desc->AddSubgraphName("sub1");
908+ op_desc->SetSubgraphInstanceName(0, "sub1");
909+ 
910+ auto sub1 = std::make_shared<ComputeGraph>("sub1_oor");
911+ NodePtr data1 = CreateNodeIncCov2(sub1, "data1_oor", "Data", 1, 1);
912+ AttrUtils::SetInt(data1->GetOpDesc(), ATTR_NAME_PARENT_NODE_INDEX, 5);
913+ NodePtr netoutput1 = CreateNodeIncCov2(sub1, "netoutput1_oor", "NetOutput", 1, 0);
914+ 
915+ GeTensorDesc out_desc1(GeShape({2, 3}), FORMAT_NCHW, DT_FLOAT);
916+ (void)data1->GetOpDesc()->UpdateOutputDesc(0, out_desc1);
917+ AttrUtils::SetInt(netoutput1->GetOpDesc()->MutableInputDesc(0), ATTR_NAME_PARENT_NODE_INDEX, 0);
918+ (void)netoutput1->GetOpDesc()->UpdateInputDesc(0, out_desc1);
919+ GraphUtils::AddEdge(data1->GetOutDataAnchor(0), netoutput1->GetInDataAnchor(0));
920+ 
921+ sub1->SetParentNode(if_node);
922+ sub1->SetParentGraph(root_graph);
923+ root_graph->AddSubgraph("sub1", sub1);
924+ 
925+ GeTensorDesc if_input_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
926+ (void)if_node->GetOpDesc()->UpdateInputDesc(0, if_input_desc);
927+ GeTensorDesc if_output_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
928+ (void)if_node->GetOpDesc()->UpdateOutputDesc(0, if_output_desc);
929+ 
930+ Operator op = OpDescUtils::CreateOperatorFromNode(if_node);
931+ auto ret = ShapeRefiner::InferShapeAndType(if_node, op, false);
932+ EXPECT_EQ(ret, GRAPH_FAILED);
933+}
934+ 
935+TEST_F(UtestShapeRefinerIncCov, IncCov2_UpdateInputOutputDesc_WithShapeRange) {
936+ auto graph = std::make_shared<ComputeGraph>("test_io_range");
937+ auto node = CreateNodeIncCov2(graph, "io_range_node", "Relu", 1, 1);
938+ 
939+ GeTensorDesc input_desc(GeShape({1, 3, -1, -1}), FORMAT_NCHW, DT_FLOAT);
940+ input_desc.SetOriginFormat(FORMAT_NCHW);
941+ input_desc.SetOriginDataType(DT_FLOAT);
942+ std::vector<std::pair<int64_t, int64_t>> shape_range = {{1, 1}, {3, 3}, {1, 224}, {1, 224}};
943+ (void)input_desc.SetShapeRange(shape_range);
944+ (void)node->GetOpDesc()->UpdateInputDesc(0, input_desc);
945+ 
946+ GeTensorDesc output_desc(GeShape({1, 3, -1, -1}), FORMAT_NCHW, DT_FLOAT);
947+ output_desc.SetOriginFormat(FORMAT_NCHW);
948+ output_desc.SetOriginDataType(DT_FLOAT);
949+ (void)output_desc.SetShapeRange(shape_range);
950+ (void)node->GetOpDesc()->UpdateOutputDesc(0, output_desc);
951+ 
952+ auto ret = ShapeRefiner::UpdateInputOutputDesc(node);
953+ EXPECT_EQ(ret, GRAPH_SUCCESS);
954+}
611} // namespace ge955} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/tensor_ut.cc+37-0
@@ -992,4 +992,41 @@ TEST_F(TensorUT, IncCov_TensorDescSetNameAndExpandDims) {
992 EXPECT_STREQ(rule.GetString(), "0011");992 EXPECT_STREQ(rule.GetString(), "0011");
993 desc.SetReuseInputIndex(5);993 desc.SetReuseInputIndex(5);
994}994}
995+ 
996+TEST_F(TensorUT, IncCov_TensorDescConstGetName) {
997+ TensorDesc desc;
998+ desc.SetName("const_name");
999+ const TensorDesc &const_desc = desc;
1000+ AscendString name;
1001+ EXPECT_EQ(const_desc.GetName(name), GRAPH_SUCCESS);
1002+ EXPECT_STREQ(name.GetString(), "const_name");
1003+ 
1004+ TensorDesc null_desc;
1005+ null_desc.impl = nullptr;
1006+ const TensorDesc &const_null_desc = null_desc;
1007+ AscendString name2;
1008+ EXPECT_EQ(const_null_desc.GetName(name2), GRAPH_FAILED);
1009+}
1010+ 
1011+TEST_F(TensorUT, IncCov_TensorConstGetData) {
1012+ Tensor tensor;
1013+ const Tensor &const_tensor = tensor;
1014+ EXPECT_NE(const_tensor.GetData(), nullptr);
1015+ 
1016+ std::vector<uint8_t> data{1, 2, 3};
1017+ TensorDesc desc(Shape({3}), FORMAT_ND, DT_UINT8);
1018+ Tensor t2(desc, data);
1019+ const Tensor &const_t2 = t2;
1020+ EXPECT_NE(const_t2.GetData(), nullptr);
1021+}
1022+ 
1023+TEST_F(TensorUT, IncCov_TensorDescConstGetNameValidImpl) {
1024+ std::vector<int64_t> shape{3};
1025+ TensorDesc desc(Shape(shape), FORMAT_ND, DT_UINT8);
1026+ desc.SetName("my_name");
1027+ const TensorDesc const_desc(desc);
1028+ AscendString name;
1029+ EXPECT_EQ(const_desc.GetName(name), GRAPH_SUCCESS);
1030+ EXPECT_STREQ(name.GetString(), "my_name");
1031+}
995} // namespace ge1032} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/trace_manager_unittest.cc+41-0
@@ -76,4 +76,45 @@ TEST_F(UtestTraceManager, add_trace_basic_0) {
76 remove(instance.current_saving_file_name_.c_str());76 remove(instance.current_saving_file_name_.c_str());
77 remove(pre_file_name.c_str());77 remove(pre_file_name.c_str());
78}78}
79+ 
80+TEST_F(UtestTraceManager, CovAddTraceDisabled) {
81+ auto &instance = TraceManager::GetInstance();
82+ const bool saved_enabled = instance.enabled_;
83+ instance.enabled_ = false;
84+ instance.AddTrace("test_disabled");
85+ instance.enabled_ = saved_enabled;
86+}
87+ 
88+TEST_F(UtestTraceManager, CovSetTraceOwnerDisabled) {
89+ auto &instance = TraceManager::GetInstance();
90+ const bool saved_enabled = instance.enabled_;
91+ instance.enabled_ = false;
92+ instance.SetTraceOwner("owner", "stage", "graph");
93+ instance.enabled_ = saved_enabled;
94+}
95+ 
96+TEST_F(UtestTraceManager, CovClearTraceOwnerDisabled) {
97+ auto &instance = TraceManager::GetInstance();
98+ const bool saved_enabled = instance.enabled_;
99+ instance.enabled_ = false;
100+ instance.ClearTraceOwner();
101+ instance.enabled_ = saved_enabled;
102+}
103+ 
104+TEST_F(UtestTraceManager, CovInitializeInvalidPath) {
105+ auto &instance = TraceManager::GetInstance();
106+ const bool saved_enabled = instance.enabled_;
107+ instance.enabled_ = true;
108+ EXPECT_EQ(instance.Initialize("/dev/null/invalid_trace_path"), FAILED);
109+ instance.enabled_ = saved_enabled;
110+}
111+ 
112+TEST_F(UtestTraceManager, CovNextFileName) {
113+ auto &instance = TraceManager::GetInstance();
114+ instance.trace_save_file_path_ = "./";
115+ const auto name1 = instance.NextFileName();
116+ EXPECT_FALSE(name1.empty());
117+ const auto name2 = instance.NextFileName();
118+ EXPECT_NE(name1, name2);
119+}
79} // namespace ge120} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/tuning_utils_unittest.cc+135-0
@@ -715,4 +715,139 @@ TEST_F(UtestTuningUtils, CovHandleConst) {
715 EXPECT_EQ(TuningUtils::HandleConst(node3, ""), SUCCESS);715 EXPECT_EQ(TuningUtils::HandleConst(node3, ""), SUCCESS);
716 system("rm -rf ./tmp_weight_*");716 system("rm -rf ./tmp_weight_*");
717}717}
718+ 
719+TEST_F(UtestTuningUtils, CovConvertGraphToFileExeFlagFalse) {
720+ std::vector<ComputeGraphPtr> tuning_subgraphs;
721+ auto builder = ut::GraphBuilder("tune_graph_exe_false");
722+ const auto data = builder.AddNode("data", DATA, 0, 1);
723+ const auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
724+ builder.AddDataEdge(data, 0, netoutput, 0);
725+ tuning_subgraphs.push_back(builder.GetGraph());
726+ std::vector<ComputeGraphPtr> non_tuning_subgraphs;
727+ EXPECT_EQ(TuningUtils::ConvertGraphToFile(tuning_subgraphs, non_tuning_subgraphs, false, "./", ""), GRAPH_SUCCESS);
728+ system("rm -f ./aicore_subgraph_*.txt");
729+}
730+ 
731+TEST_F(UtestTuningUtils, CovLoadGraphFromFileInvalidFile) {
732+ std::map<int64_t, std::string> options;
733+ options.emplace(0, "./nonexistent_file_12345.txt");
734+ Graph g;
735+ EXPECT_EQ(TuningUtils::ConvertFileToGraph(options, g), FAILED);
736+}
737+ 
738+TEST_F(UtestTuningUtils, CovConvertConstToWeightAttrNoPlaceholder) {
739+ auto builder = ut::GraphBuilder("graph_no_pld");
740+ const auto data = builder.AddNode("data", DATA, 0, 1);
741+ const auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
742+ builder.AddDataEdge(data, 0, netoutput, 0);
743+ auto graph = builder.GetGraph();
744+ EXPECT_EQ(TuningUtils::ConvertConstToWeightAttr(graph), SUCCESS);
745+}
746+ 
747+TEST_F(UtestTuningUtils, CovHandleConstNonConstNode) {
748+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
749+ auto data_node = builder.AddNode("data", DATA, 0, 1);
750+ NodePtr node = data_node;
751+ EXPECT_EQ(TuningUtils::HandleConst(node, ""), SUCCESS);
752+}
753+ 
754+TEST_F(UtestTuningUtils, CovCreateDataNodeWithParentNodeName) {
755+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
756+ auto pld = builder.AddNode("pld", PLACEHOLDER, 0, 1);
757+ uint8_t val = 1;
758+ auto const_tensor = std::make_shared<GeTensor>(GeTensorDesc(), &val, sizeof(val));
759+ AttrUtils::SetTensor(pld->GetOpDesc(), "value", const_tensor);
760+ AttrUtils::SetStr(pld->GetOpDesc(), "_parentNodeName", "parent_const");
761+ NodePtr data_node;
762+ EXPECT_EQ(TuningUtils::CreateDataNode(pld, "", data_node), SUCCESS);
763+}
764+ 
765+TEST_F(UtestTuningUtils, CovChangePld2DataNotPlaceholder) {
766+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
767+ auto node0 = builder.AddNode("data0", DATA, 0, 1);
768+ auto node1 = builder.AddNode("data1", DATA, 1, 1);
769+ EXPECT_EQ(TuningUtils::ChangePld2Data(node0, node1), FAILED);
770+}
771+ 
772+TEST_F(UtestTuningUtils, CovChangePld2DataDataNotExeType) {
773+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
774+ auto pld = builder.AddNode("pld", PLACEHOLDER, 0, 1);
775+ auto relu = builder.AddNode("relu", "Relu", 1, 1);
776+ EXPECT_EQ(TuningUtils::ChangePld2Data(pld, relu), FAILED);
777+}
778+ 
779+TEST_F(UtestTuningUtils, CovChangeEnd2NetOutputNotEnd) {
780+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
781+ auto data = builder.AddNode("data", DATA, 0, 1);
782+ auto netoutput = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
783+ EXPECT_EQ(TuningUtils::ChangeEnd2NetOutput(data, netoutput), FAILED);
784+}
785+ 
786+TEST_F(UtestTuningUtils, CovChangeEnd2NetOutputNotNetOutput) {
787+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
788+ auto end = builder.AddNode("end", END, 0, 1);
789+ auto data = builder.AddNode("data", DATA, 1, 1);
790+ EXPECT_EQ(TuningUtils::ChangeEnd2NetOutput(end, data), FAILED);
791+}
792+ 
793+TEST_F(UtestTuningUtils, CovGetOrSaveReusableFileConstEmpty) {
794+ TuningUtils::reusable_weight_files_.clear();
795+ TuningUtils::hash_to_files_.clear();
796+ auto tensor = std::make_shared<GeTensor>();
797+ std::vector<uint8_t> value{1, 2, 3};
798+ std::vector<int64_t> shape{3};
799+ tensor->MutableTensorDesc().SetShape(GeShape(shape));
800+ tensor->SetData(value);
801+ tensor->MutableTensorDesc().SetDataType(DT_UINT8);
802+ std::string file_path1 = "./tmp_test_reuse_empty1.bin";
803+ std::string file_path2 = "./tmp_test_reuse_empty2.bin";
804+ EXPECT_EQ(TuningUtils::GetOrSaveReusableFileConst(tensor, file_path1), SUCCESS);
805+ EXPECT_EQ(TuningUtils::GetOrSaveReusableFileConst(tensor, file_path2), SUCCESS);
806+ EXPECT_EQ(TuningUtils::reusable_weight_files_.size(), 1U);
807+ system("rm -f ./tmp_test_reuse_empty1.bin ./tmp_test_reuse_empty2.bin");
808+}
809+ 
810+TEST_F(UtestTuningUtils, CovCheckFilesSameNonExistFile) {
811+ bool is_same = false;
812+ EXPECT_NE(TuningUtils::CheckFilesSame("./nonexistent_file_check.bin", "data", 4, is_same), SUCCESS);
813+}
814+ 
815+TEST_F(UtestTuningUtils, CovMergeSubGraphDataWithPeerName) {
816+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
817+ auto data = builder.AddNode("data", DATA, 1, 1);
818+ auto graph = builder.GetGraph();
819+ AttrUtils::SetStr(data->GetOpDesc(), "_peerNodeName", "end_node_name");
820+ EXPECT_EQ(TuningUtils::MergeSubGraph(graph), SUCCESS);
821+}
822+ 
823+TEST_F(UtestTuningUtils, CovMergeSubGraphConstantWithPeerName) {
824+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
825+ auto const_node = builder.AddNode("const", CONSTANT, 1, 1);
826+ auto graph = builder.GetGraph();
827+ AttrUtils::SetStr(const_node->GetOpDesc(), "_peerNodeName", "end_node_name");
828+ EXPECT_EQ(TuningUtils::MergeSubGraph(graph), SUCCESS);
829+}
830+ 
831+TEST_F(UtestTuningUtils, CovCreateNetOutputAlreadyExists) {
832+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
833+ auto node0 = builder.AddNode("Data0", "Data", 1, 1);
834+ auto existing_out = builder.AddNode("existing_out", NETOUTPUT, 1, 1);
835+ NodePtr node1;
836+ auto graph = builder.GetGraph();
837+ TuningUtils::create_output_[graph] = existing_out;
838+ EXPECT_EQ(TuningUtils::CreateNetOutput(node0, node1), SUCCESS);
839+ EXPECT_EQ(node1, existing_out);
840+ TuningUtils::create_output_.clear();
841+}
842+ 
843+TEST_F(UtestTuningUtils, CovPrintCheckLogWithNetoutput) {
844+ TuningUtils::netoutput_nodes_.clear();
845+ TuningUtils::data_2_end_.clear();
846+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
847+ auto node0 = builder.AddNode("Data0", "Data", 0, 1);
848+ TuningUtils::netoutput_nodes_.push_back(node0);
849+ TuningUtils::data_2_end_["data"] = "end";
850+ auto result = TuningUtils::PrintCheckLog();
851+ EXPECT_FALSE(result.empty());
852+}
718} // namespace ge853} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/types_cov_unittest.cc+63-0
@@ -170,4 +170,67 @@ TEST_F(UtestTypesCov, PromoteMoveSelfAssignment) {
170 EXPECT_EQ(syms.size(), 2U);170 EXPECT_EQ(syms.size(), 2U);
171 EXPECT_STREQ(syms[0], "T1");171 EXPECT_STREQ(syms[0], "T1");
172}172}
173+ 
174+TEST_F(UtestTypesCov, GetSizeInBytesBitTypeZeroCount) {
175+ int64_t result = GetSizeInBytes(0, DT_INT4);
176+ EXPECT_EQ(result, 0);
177+ result = GetSizeInBytes(0, DT_UINT1);
178+ EXPECT_EQ(result, 0);
179+ result = GetSizeInBytes(0, DT_INT2);
180+ EXPECT_EQ(result, 0);
181+ result = GetSizeInBytes(0, DT_UINT2);
182+ EXPECT_EQ(result, 0);
183+}
184+ 
185+TEST_F(UtestTypesCov, PromoteSymsAfterMove) {
186+ Promote promote1({"T1", "T2", "T3"});
187+ Promote promote2(std::move(promote1));
188+ auto syms = promote1.Syms();
189+ EXPECT_TRUE(syms.empty());
190+ auto syms2 = promote2.Syms();
191+ EXPECT_EQ(syms2.size(), 3U);
192+ EXPECT_STREQ(syms2[0], "T1");
193+}
194+ 
195+TEST_F(UtestTypesCov, PromoteMoveAssignmentClearsSource) {
196+ Promote promote1({"A", "B"});
197+ Promote promote2({"X", "Y", "Z"});
198+ promote2 = std::move(promote1);
199+ auto syms1 = promote1.Syms();
200+ EXPECT_TRUE(syms1.empty());
201+ auto syms2 = promote2.Syms();
202+ EXPECT_EQ(syms2.size(), 2U);
203+ EXPECT_STREQ(syms2[0], "A");
204+}
205+ 
206+TEST_F(UtestTypesCov, GetFormatNameAllCommonFormats) {
207+ EXPECT_STREQ(GetFormatName(FORMAT_NCHW), "NCHW");
208+ EXPECT_STREQ(GetFormatName(FORMAT_NHWC), "NHWC");
209+ EXPECT_STREQ(GetFormatName(FORMAT_ND), "ND");
210+ EXPECT_STREQ(GetFormatName(FORMAT_NC1HWC0), "NC1HWC0");
211+ EXPECT_STREQ(GetFormatName(FORMAT_FRACTAL_Z), "FRACTAL_Z");
212+ EXPECT_STREQ(GetFormatName(FORMAT_HWCN), "HWCN");
213+ EXPECT_STREQ(GetFormatName(FORMAT_NDHWC), "NDHWC");
214+ EXPECT_STREQ(GetFormatName(FORMAT_FRACTAL_NZ), "FRACTAL_NZ");
215+ EXPECT_STREQ(GetFormatName(FORMAT_NCDHW), "NCDHW");
216+ EXPECT_STREQ(GetFormatName(FORMAT_CN), "CN");
217+ EXPECT_STREQ(GetFormatName(FORMAT_NC), "NC");
218+}
219+ 
220+TEST_F(UtestTypesCov, GetSizeInBytesAllBitTypes) {
221+ int64_t result = GetSizeInBytes(1, DT_INT4);
222+ EXPECT_GE(result, 0);
223+ result = GetSizeInBytes(1, DT_UINT1);
224+ EXPECT_GE(result, 0);
225+ result = GetSizeInBytes(1, DT_INT2);
226+ EXPECT_GE(result, 0);
227+ result = GetSizeInBytes(1, DT_UINT2);
228+ EXPECT_GE(result, 0);
229+ result = GetSizeInBytes(7, DT_INT4);
230+ EXPECT_EQ(result, 4);
231+ result = GetSizeInBytes(8, DT_INT4);
232+ EXPECT_EQ(result, 4);
233+ result = GetSizeInBytes(9, DT_INT4);
234+ EXPECT_EQ(result, 5);
235+}
173} // namespace ge236} // namespace ge
Mtests/graph_metadef/ut/register/testcase/buffer_fusion_cov_unittest.cc+76-0
@@ -561,4 +561,80 @@ TEST_F(BufferFusionCovUT, Pattern_SetHead_DescTotalMinOverflow) {
561 desc1->repeate_min = std::numeric_limits<int64_t>::max();561 desc1->repeate_min = std::numeric_limits<int64_t>::max();
562 pattern.SetHead({"desc1", "desc2"});562 pattern.SetHead({"desc1", "desc2"});
563}563}
564+ 
565+TEST_F(BufferFusionCovUT, Pattern_AddOpDesc_EmptyDescName) {
566+ BufferFusionPattern pattern("test_pattern", 10);
567+ pattern.AddOpDesc("", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
568+ EXPECT_NE(pattern.GetErrorCnt(), 0);
569+}
570+ 
571+TEST_F(BufferFusionCovUT, Pattern_AddOpDesc_RepeatMinGreaterThanMax) {
572+ BufferFusionPattern pattern("test_pattern", 10);
573+ pattern.AddOpDesc("desc1", {"Relu"}, 2, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
574+ EXPECT_NE(pattern.GetErrorCnt(), 0);
575+}
576+ 
577+TEST_F(BufferFusionCovUT, Pattern_AddOpDesc_DuplicateDescName) {
578+ BufferFusionPattern pattern("test_pattern", 10);
579+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
580+ pattern.AddOpDesc("desc1", {"Add"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
581+ EXPECT_NE(pattern.GetErrorCnt(), 0);
582+}
583+ 
584+TEST_F(BufferFusionCovUT, Pattern_SetOutputs_EmptyDescName) {
585+ BufferFusionPattern pattern("test_pattern", 10);
586+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
587+ pattern.SetOutputs("", {"desc1"});
588+ EXPECT_NE(pattern.GetErrorCnt(), 0);
589+}
590+ 
591+TEST_F(BufferFusionCovUT, Pattern_SetOutputs_DescNotExist) {
592+ BufferFusionPattern pattern("test_pattern", 10);
593+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
594+ pattern.SetOutputs("nonexistent", {"desc1"});
595+ EXPECT_NE(pattern.GetErrorCnt(), 0);
596+}
597+ 
598+TEST_F(BufferFusionCovUT, Pattern_SetOutputs_OutputDescNotExist) {
599+ BufferFusionPattern pattern("test_pattern", 10);
600+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
601+ pattern.SetOutputs("desc1", {"nonexistent"});
602+ EXPECT_NE(pattern.GetErrorCnt(), 0);
603+}
604+ 
605+TEST_F(BufferFusionCovUT, Pattern_SetOutputs_SelfOutput) {
606+ BufferFusionPattern pattern("test_pattern", 10);
607+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
608+ pattern.SetOutputs("desc1", {"desc1"});
609+ auto *desc1 = pattern.GetOpDesc("desc1");
610+ EXPECT_TRUE(desc1->outputs.empty());
611+}
612+ 
613+TEST_F(BufferFusionCovUT, Pattern_SetGraphModType) {
614+ BufferFusionPattern pattern("test_pattern", 10);
615+ pattern.SetGraphModType(42);
616+ EXPECT_EQ(pattern.GetGraphModType(), 42);
617+}
618+ 
619+TEST_F(BufferFusionCovUT, Pattern_AddOpDesc_WithRepeatRange) {
620+ BufferFusionPattern pattern("test_pattern", 10);
621+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 3, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
622+ auto *desc1 = pattern.GetOpDesc("desc1");
623+ EXPECT_NE(desc1, nullptr);
624+ EXPECT_EQ(desc1->multi_output_skip_status.size(), 2U);
625+}
626+ 
627+TEST_F(BufferFusionCovUT, Pattern_AddOpDescTypeRules_EmptyDescName) {
628+ BufferFusionPattern pattern("test_pattern", 10);
629+ pattern.AddOpDescTypeRules("", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, {ONLY_SUPPORT_STATIC}, false, true);
630+ EXPECT_NE(pattern.GetErrorCnt(), 0);
631+}
632+ 
633+TEST_F(BufferFusionCovUT, Pattern_SetRelation_NonRelativePosition) {
634+ BufferFusionPattern pattern("test_pattern", 10);
635+ pattern.AddOpDesc("desc1", {"Relu"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
636+ pattern.AddOpDesc("desc2", {"Add"}, 1, 1, TBE_PATTERN_GROUPID_INVALID, IGNORE_SHAPE_TYPE);
637+ pattern.SetRelation("desc1", "desc2", PatternRelation::RELATIVE_POSITION_CONSISTENT);
638+ EXPECT_EQ(pattern.GetErrorCnt(), 0);
639+}
564} // namespace fe640} // namespace fe
Mtests/graph_metadef/ut/register/testcase/fusion_quant_util_cov_unittest.cc+311-0
@@ -604,4 +604,315 @@ TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithQuantParamAndFFN_
604 auto ret = QuantUtil::BiasOptimizeByEdge(quant_param, param, fusion_nodes, WeightMode::WEIGHTWITH2D);604 auto ret = QuantUtil::BiasOptimizeByEdge(quant_param, param, fusion_nodes, WeightMode::WEIGHTWITH2D);
605 EXPECT_NE(ret, SUCCESS);605 EXPECT_NE(ret, SUCCESS);
606}606}
607+ 
608+static ComputeGraphPtr CreateGraphWithHWCNFormat() {
609+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("quant_hwcn_test");
610+ OpDescPtr data = std::make_shared<OpDesc>("data", "Data");
611+ OpDescPtr weight = std::make_shared<OpDesc>("weight", "Const");
612+ OpDescPtr mm = std::make_shared<OpDesc>("mm", "MatMulV2");
613+ 
614+ GeShape shape1({2, 4, 9, 16});
615+ GeTensorDesc tensor_desc1(shape1, FORMAT_NCHW, DT_FLOAT16);
616+ tensor_desc1.SetOriginFormat(FORMAT_NCHW);
617+ tensor_desc1.SetOriginDataType(DT_FLOAT16);
618+ tensor_desc1.SetOriginShape(shape1);
619+ 
620+ GeShape shape2({4, 2, 9, 16});
621+ GeTensorDesc tensor_desc2(shape2, FORMAT_HWCN, DT_INT8);
622+ tensor_desc2.SetOriginFormat(FORMAT_HWCN);
623+ tensor_desc2.SetOriginDataType(DT_INT8);
624+ tensor_desc2.SetOriginShape(shape2);
625+ 
626+ GeShape shape3({1, 16});
627+ GeTensorDesc tensor_desc3(shape3, FORMAT_ND, DT_FLOAT);
628+ tensor_desc3.SetOriginFormat(FORMAT_ND);
629+ tensor_desc3.SetOriginDataType(DT_FLOAT);
630+ tensor_desc3.SetOriginShape(shape3);
631+ 
632+ data->AddOutputDesc(tensor_desc1);
633+ weight->AddOutputDesc(tensor_desc2);
634+ mm->AddInputDesc(tensor_desc1);
635+ mm->AddInputDesc(tensor_desc2);
636+ mm->AddInputDesc(tensor_desc1);
637+ mm->AddInputDesc(tensor_desc3);
638+ mm->AddInputDesc(tensor_desc3);
639+ mm->AddOutputDesc(tensor_desc2);
640+ 
641+ OpDescPtr deq_scale = std::make_shared<OpDesc>("deq_scale", "Const");
642+ deq_scale->AddOutputDesc(tensor_desc3);
643+ OpDescPtr quant_offset = std::make_shared<OpDesc>("quant_offset", "Const");
644+ quant_offset->AddOutputDesc(tensor_desc3);
645+ 
646+ NodePtr data_node = graph->AddNode(data);
647+ NodePtr weight_node = graph->AddNode(weight);
648+ NodePtr mm_node = graph->AddNode(mm);
649+ NodePtr deq_scale_node = graph->AddNode(deq_scale);
650+ NodePtr quant_offset_node = graph->AddNode(quant_offset);
651+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(0));
652+ GraphUtils::AddEdge(weight_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(1));
653+ GraphUtils::AddEdge(deq_scale_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(3));
654+ GraphUtils::AddEdge(quant_offset_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(4));
655+ return graph;
656+}
657+ 
658+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_HWCNFormat) {
659+ ComputeGraphPtr graph = CreateGraphWithHWCNFormat();
660+ NodePtr mm_node = graph->FindNode("mm");
661+ BiasOptimizeEdges param;
662+ param.quant_scale = mm_node->GetInDataAnchor(3);
663+ param.quant_offset = mm_node->GetInDataAnchor(4);
664+ param.cube_weight = mm_node->GetInDataAnchor(1);
665+ param.cube_bias = mm_node->GetInDataAnchor(2);
666+ param.deq_scale = nullptr;
667+ vector<NodePtr> fusion_nodes;
668+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
669+ EXPECT_EQ(ret, SUCCESS);
670+}
671+ 
672+static ComputeGraphPtr CreateGraphWithNHWCFormat() {
673+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("quant_nhwc_test");
674+ OpDescPtr data = std::make_shared<OpDesc>("data", "Data");
675+ OpDescPtr weight = std::make_shared<OpDesc>("weight", "Const");
676+ OpDescPtr mm = std::make_shared<OpDesc>("mm", "MatMulV2");
677+ 
678+ GeShape shape1({2, 4, 9, 16});
679+ GeTensorDesc tensor_desc1(shape1, FORMAT_NCHW, DT_FLOAT16);
680+ 
681+ GeShape shape2({2, 4, 9, 16});
682+ GeTensorDesc tensor_desc2(shape2, FORMAT_NHWC, DT_INT8);
683+ tensor_desc2.SetOriginFormat(FORMAT_NHWC);
684+ tensor_desc2.SetOriginDataType(DT_INT8);
685+ tensor_desc2.SetOriginShape(shape2);
686+ 
687+ GeShape shape3({1, 16});
688+ GeTensorDesc tensor_desc3(shape3, FORMAT_ND, DT_FLOAT);
689+ 
690+ data->AddOutputDesc(tensor_desc1);
691+ weight->AddOutputDesc(tensor_desc2);
692+ mm->AddInputDesc(tensor_desc1);
693+ mm->AddInputDesc(tensor_desc2);
694+ mm->AddInputDesc(tensor_desc1);
695+ mm->AddInputDesc(tensor_desc3);
696+ mm->AddInputDesc(tensor_desc3);
697+ mm->AddOutputDesc(tensor_desc2);
698+ 
699+ NodePtr data_node = graph->AddNode(data);
700+ NodePtr weight_node = graph->AddNode(weight);
701+ NodePtr mm_node = graph->AddNode(mm);
702+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(0));
703+ GraphUtils::AddEdge(weight_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(1));
704+ return graph;
705+}
706+ 
707+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_NHWCFormat) {
708+ ComputeGraphPtr graph = CreateGraphWithNHWCFormat();
709+ NodePtr mm_node = graph->FindNode("mm");
710+ BiasOptimizeEdges param;
711+ param.quant_scale = mm_node->GetInDataAnchor(3);
712+ param.quant_offset = mm_node->GetInDataAnchor(4);
713+ param.cube_weight = mm_node->GetInDataAnchor(1);
714+ param.cube_bias = mm_node->GetInDataAnchor(2);
715+ param.deq_scale = nullptr;
716+ vector<NodePtr> fusion_nodes;
717+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
718+ EXPECT_EQ(ret, SUCCESS);
719+}
720+ 
721+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_QuantParamWithHWCN) {
722+ ComputeGraphPtr graph = CreateGraphWithHWCNFormat();
723+ NodePtr mm_node = graph->FindNode("mm");
724+ QuantParam quant_param = {1.0F, 0.0F};
725+ BiasOptimizeEdges param;
726+ param.quant_scale = mm_node->GetInDataAnchor(3);
727+ param.quant_offset = mm_node->GetInDataAnchor(4);
728+ param.cube_weight = mm_node->GetInDataAnchor(1);
729+ param.cube_bias = mm_node->GetInDataAnchor(2);
730+ param.deq_scale = mm_node->GetInDataAnchor(3);
731+ vector<NodePtr> fusion_nodes;
732+ auto ret = QuantUtil::BiasOptimizeByEdge(quant_param, param, fusion_nodes, WeightMode::WEIGHTWITH2D);
733+ EXPECT_EQ(ret, SUCCESS);
734+}
735+ 
736+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_QuantParamWith5D_HWCN) {
737+ ComputeGraphPtr graph = CreateGraphWithHWCNFormat();
738+ NodePtr mm_node = graph->FindNode("mm");
739+ QuantParam quant_param = {1.0F, 0.0F};
740+ BiasOptimizeEdges param;
741+ param.quant_scale = mm_node->GetInDataAnchor(3);
742+ param.quant_offset = mm_node->GetInDataAnchor(4);
743+ param.cube_weight = mm_node->GetInDataAnchor(1);
744+ param.cube_bias = mm_node->GetInDataAnchor(2);
745+ param.deq_scale = mm_node->GetInDataAnchor(3);
746+ vector<NodePtr> fusion_nodes;
747+ auto ret = QuantUtil::BiasOptimizeByEdge(quant_param, param, fusion_nodes, WeightMode::WEIGHTWITH5D);
748+ EXPECT_EQ(ret, SUCCESS);
749+}
750+ 
751+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithFFN_3DWeight) {
752+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("quant_ffn_3d_test");
753+ OpDescPtr data = std::make_shared<OpDesc>("data", "Data");
754+ OpDescPtr weight = std::make_shared<OpDesc>("weight", "Const");
755+ OpDescPtr mm = std::make_shared<OpDesc>("mm", "FFN");
756+ 
757+ GeShape shape1({2, 4, 9, 16});
758+ GeTensorDesc tensor_desc1(shape1, FORMAT_NCHW, DT_FLOAT16);
759+ GeShape shape2({2, 4, 9});
760+ GeTensorDesc tensor_desc2(shape2, FORMAT_ND, DT_INT8);
761+ tensor_desc2.SetOriginFormat(FORMAT_ND);
762+ tensor_desc2.SetOriginDataType(DT_INT8);
763+ tensor_desc2.SetOriginShape(shape2);
764+ GeShape shape3({1, 16});
765+ GeTensorDesc tensor_desc3(shape3, FORMAT_ND, DT_FLOAT);
766+ 
767+ data->AddOutputDesc(tensor_desc1);
768+ weight->AddOutputDesc(tensor_desc2);
769+ mm->AddInputDesc(tensor_desc1);
770+ mm->AddInputDesc(tensor_desc2);
771+ mm->AddInputDesc(tensor_desc1);
772+ mm->AddInputDesc(tensor_desc3);
773+ mm->AddInputDesc(tensor_desc3);
774+ mm->AddOutputDesc(tensor_desc2);
775+ 
776+ NodePtr data_node = graph->AddNode(data);
777+ NodePtr weight_node = graph->AddNode(weight);
778+ NodePtr mm_node = graph->AddNode(mm);
779+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(0));
780+ GraphUtils::AddEdge(weight_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(1));
781+ 
782+ BiasOptimizeEdges param;
783+ param.quant_scale = mm_node->GetInDataAnchor(3);
784+ param.quant_offset = mm_node->GetInDataAnchor(4);
785+ param.cube_weight = mm_node->GetInDataAnchor(1);
786+ param.cube_bias = mm_node->GetInDataAnchor(2);
787+ param.deq_scale = nullptr;
788+ vector<NodePtr> fusion_nodes;
789+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
790+ EXPECT_EQ(ret, SUCCESS);
791+}
792+ 
793+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithDataWeightNode) {
794+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("quant_data_weight_test");
795+ OpDescPtr data = std::make_shared<OpDesc>("data", "Data");
796+ OpDescPtr weight = std::make_shared<OpDesc>("weight", "Data");
797+ OpDescPtr mm = std::make_shared<OpDesc>("mm", "MatMulV2");
798+ 
799+ GeShape shape1({2, 4, 9, 16});
800+ GeTensorDesc tensor_desc1(shape1, FORMAT_NCHW, DT_FLOAT16);
801+ GeShape shape2({2, 4, 9, 16});
802+ GeTensorDesc tensor_desc2(shape2, FORMAT_NCHW, DT_INT8);
803+ GeShape shape3({1, 16});
804+ GeTensorDesc tensor_desc3(shape3, FORMAT_ND, DT_FLOAT);
805+ 
806+ data->AddOutputDesc(tensor_desc1);
807+ weight->AddOutputDesc(tensor_desc2);
808+ mm->AddInputDesc(tensor_desc1);
809+ mm->AddInputDesc(tensor_desc2);
810+ mm->AddInputDesc(tensor_desc1);
811+ mm->AddInputDesc(tensor_desc3);
812+ mm->AddInputDesc(tensor_desc3);
813+ mm->AddOutputDesc(tensor_desc2);
814+ 
815+ NodePtr data_node = graph->AddNode(data);
816+ NodePtr weight_node = graph->AddNode(weight);
817+ NodePtr mm_node = graph->AddNode(mm);
818+ GraphUtils::AddEdge(data_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(0));
819+ GraphUtils::AddEdge(weight_node->GetOutDataAnchor(0), mm_node->GetInDataAnchor(1));
820+ 
821+ BiasOptimizeEdges param;
822+ param.quant_scale = mm_node->GetInDataAnchor(3);
823+ param.quant_offset = mm_node->GetInDataAnchor(4);
824+ param.cube_weight = mm_node->GetInDataAnchor(1);
825+ param.cube_bias = mm_node->GetInDataAnchor(2);
826+ param.deq_scale = nullptr;
827+ vector<NodePtr> fusion_nodes;
828+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
829+ EXPECT_EQ(ret, SUCCESS);
830+}
831+ 
832+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithGroupsHWCN) {
833+ ComputeGraphPtr graph = CreateGraphWithHWCNFormat();
834+ NodePtr mm_node = graph->FindNode("mm");
835+ AttrUtils::SetInt(mm_node->GetOpDesc(), "groups", 2);
836+ BiasOptimizeEdges param;
837+ param.quant_scale = mm_node->GetInDataAnchor(3);
838+ param.quant_offset = mm_node->GetInDataAnchor(4);
839+ param.cube_weight = mm_node->GetInDataAnchor(1);
840+ param.cube_bias = mm_node->GetInDataAnchor(2);
841+ param.deq_scale = nullptr;
842+ vector<NodePtr> fusion_nodes;
843+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
844+ EXPECT_EQ(ret, SUCCESS);
845+}
846+ 
847+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithCinCoutReverseHWCN) {
848+ ComputeGraphPtr graph = CreateGraphWithHWCNFormat();
849+ NodePtr mm_node = graph->FindNode("mm");
850+ AttrUtils::SetBool(mm_node->GetOpDesc(), "quant_cin_cout_reverse", true);
851+ AttrUtils::SetInt(mm_node->GetOpDesc(), "groups", 2);
852+ BiasOptimizeEdges param;
853+ param.quant_scale = mm_node->GetInDataAnchor(3);
854+ param.quant_offset = mm_node->GetInDataAnchor(4);
855+ param.cube_weight = mm_node->GetInDataAnchor(1);
856+ param.cube_bias = mm_node->GetInDataAnchor(2);
857+ param.deq_scale = mm_node->GetInDataAnchor(3);
858+ vector<NodePtr> fusion_nodes;
859+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
860+ EXPECT_EQ(ret, SUCCESS);
861+}
862+ 
863+TEST_F(FusionQuantUtilImplCovUT, IncCov_InsertQuantScaleConvert_NullQuantScale) {
864+ InDataAnchorPtr quant_scale = nullptr;
865+ InDataAnchorPtr quant_offset = nullptr;
866+ vector<NodePtr> fusion_nodes;
867+ auto ret = QuantUtil::InsertQuantScaleConvert(quant_scale, quant_offset, fusion_nodes);
868+ EXPECT_EQ(ret, SUCCESS);
869+}
870+ 
871+TEST_F(FusionQuantUtilImplCovUT, IncCov_InsertFixpipeDequantScaleConvert_DeScaleOnly) {
872+ ComputeGraphPtr graph = CreateSimpleGraphWithAnchors();
873+ NodePtr mm_node = graph->FindNode("mm");
874+ InDataAnchorPtr deq_scale = mm_node->GetInDataAnchor(3);
875+ vector<NodePtr> fusion_nodes;
876+ auto ret = QuantUtil::InsertFixpipeDequantScaleConvert(deq_scale, fusion_nodes);
877+ EXPECT_EQ(ret, SUCCESS);
878+}
879+ 
880+TEST_F(FusionQuantUtilImplCovUT, IncCov_InsertRequantScaleConvert_WithValidReqScaleAndBias) {
881+ ComputeGraphPtr graph = CreateSimpleGraphWithAnchors();
882+ NodePtr mm_node = graph->FindNode("mm");
883+ InDataAnchorPtr req_scale = mm_node->GetInDataAnchor(3);
884+ InDataAnchorPtr quant_offset = mm_node->GetInDataAnchor(4);
885+ InDataAnchorPtr cube_bias = mm_node->GetInDataAnchor(1);
886+ vector<NodePtr> fusion_nodes;
887+ auto ret = QuantUtil::InsertRequantScaleConvert(req_scale, quant_offset, cube_bias, fusion_nodes);
888+ EXPECT_NE(ret, SUCCESS);
889+}
890+ 
891+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithDeqScaleAndHWCN) {
892+ ComputeGraphPtr graph = CreateGraphWithHWCNFormat();
893+ NodePtr mm_node = graph->FindNode("mm");
894+ BiasOptimizeEdges param;
895+ param.quant_scale = mm_node->GetInDataAnchor(3);
896+ param.quant_offset = mm_node->GetInDataAnchor(4);
897+ param.cube_weight = mm_node->GetInDataAnchor(1);
898+ param.cube_bias = mm_node->GetInDataAnchor(2);
899+ param.deq_scale = mm_node->GetInDataAnchor(3);
900+ vector<NodePtr> fusion_nodes;
901+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
902+ EXPECT_EQ(ret, SUCCESS);
903+}
904+ 
905+TEST_F(FusionQuantUtilImplCovUT, IncCov_BiasOptimizeByEdge_WithFFN_ND_2DWeight) {
906+ ComputeGraphPtr graph = CreateGraphForBiasCreation();
907+ NodePtr mm_node = graph->FindNode("mm");
908+ BiasOptimizeEdges param;
909+ param.quant_scale = mm_node->GetInDataAnchor(3);
910+ param.quant_offset = mm_node->GetInDataAnchor(4);
911+ param.cube_weight = mm_node->GetInDataAnchor(1);
912+ param.cube_bias = mm_node->GetInDataAnchor(2);
913+ param.deq_scale = nullptr;
914+ vector<NodePtr> fusion_nodes;
915+ auto ret = QuantUtil::BiasOptimizeByEdge(mm_node, param, fusion_nodes);
916+ EXPECT_EQ(ret, SUCCESS);
917+}
607} // namespace fe918} // namespace fe
Mtests/graph_metadef/ut/register/testcase/fusion_turbo_utils_cov_unittest.cc+141-0
@@ -11,6 +11,7 @@
11#include <gtest/gtest.h>11#include <gtest/gtest.h>
12 12 
13#include "register/graph_optimizer/fusion_common/fusion_turbo_utils.h"13#include "register/graph_optimizer/fusion_common/fusion_turbo_utils.h"
14+#include "register/graph_optimizer/fusion_common/fusion_turbo.h"
14#include "graph_builder_utils.h"15#include "graph_builder_utils.h"
15#include "graph/debug/ge_op_types.h"16#include "graph/debug/ge_op_types.h"
16#include "graph/utils/node_utils.h"17#include "graph/utils/node_utils.h"
@@ -399,4 +400,144 @@ TEST_F(FusionTurboUtilsCovUT, IncCov_RelationsGetInRelationsAndOutRelations) {
399 EXPECT_FALSE(r.GetInRelations().at(0).empty());400 EXPECT_FALSE(r.GetInRelations().at(0).empty());
400 EXPECT_FALSE(r.GetOutRelations().at(0).empty());401 EXPECT_FALSE(r.GetOutRelations().at(0).empty());
401}402}
403+ 
404+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_AddConstNode_NoPeer) {
405+ auto graph = std::make_shared<ge::ComputeGraph>("test_addconst_nopeer");
406+ auto op_desc = std::make_shared<ge::OpDesc>("node1", "Relu");
407+ ge::GeTensorDesc tensor_desc(ge::GeShape({2, 4}), ge::FORMAT_NCHW, ge::DT_FLOAT);
408+ op_desc->AddInputDesc(tensor_desc);
409+ op_desc->AddOutputDesc(tensor_desc);
410+ auto node = graph->AddNode(op_desc);
411+ FusionTurbo ft(graph);
412+ auto data_ptr = std::make_unique<int32_t[]>(16);
413+ WeightInfo w(tensor_desc, data_ptr.get());
414+ auto const_node = ft.AddWeight(node, 0, w);
415+ EXPECT_NE(const_node, nullptr);
416+}
417+ 
418+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_GetPeerInFirstPairViaTurbo) {
419+ auto graph = BuildGraph();
420+ FusionTurbo ft(graph);
421+ auto relu_node = graph->FindNode("relu1");
422+ ASSERT_NE(relu_node, nullptr);
423+ auto result = ft.GetPeerInFirstPair(relu_node, 0);
424+ EXPECT_NE(result.node, nullptr);
425+ auto result2 = ft.GetPeerOutPair(relu_node, 0);
426+ EXPECT_NE(result2.node, nullptr);
427+}
428+ 
429+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_MultiInOne_WithExistingNode) {
430+ auto graph = BuildGraph();
431+ FusionTurbo ft(graph);
432+ auto relu_node = graph->FindNode("relu1");
433+ auto add_node = graph->FindNode("add1");
434+ ASSERT_NE(relu_node, nullptr);
435+ ASSERT_NE(add_node, nullptr);
436+ Relations input_rel(0, {relu_node, 0});
437+ Relations output_rel;
438+ auto new_node = ft.MultiInOne("merged_node", "Relu", input_rel, output_rel, {add_node}, false);
439+ EXPECT_NE(new_node, nullptr);
440+}
441+ 
442+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_InsertNodeBefore_WithPeer) {
443+ auto graph = BuildGraph();
444+ FusionTurbo ft(graph);
445+ auto relu_node = graph->FindNode("relu1");
446+ ASSERT_NE(relu_node, nullptr);
447+ auto new_node = ft.InsertNodeBefore("before_relu", "Relu", relu_node, 0, 0, 0);
448+ EXPECT_NE(new_node, nullptr);
449+}
450+ 
451+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_InsertNodeAfter_WithPeer) {
452+ auto graph = BuildGraph();
453+ FusionTurbo ft(graph);
454+ auto relu_node = graph->FindNode("relu1");
455+ ASSERT_NE(relu_node, nullptr);
456+ auto new_node = ft.InsertNodeAfter("after_relu", "Relu", relu_node, 0, 0, 0);
457+ EXPECT_NE(new_node, nullptr);
458+}
459+ 
460+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_AddWeight_WithTensorName) {
461+ auto graph = std::make_shared<ge::ComputeGraph>("test_addweight_name2");
462+ auto op_desc = std::make_shared<ge::OpDesc>("node1", "Relu");
463+ ge::GeTensorDesc tensor_desc(ge::GeShape({2, 4}), ge::FORMAT_NCHW, ge::DT_FLOAT);
464+ op_desc->AddInputDesc("x", tensor_desc);
465+ op_desc->AddOutputDesc(tensor_desc);
466+ auto node = graph->AddNode(op_desc);
467+ FusionTurbo ft(graph);
468+ auto data_ptr = std::make_unique<int32_t[]>(16);
469+ WeightInfo w(tensor_desc, data_ptr.get());
470+ auto ret = ft.AddWeight(node, "x", w);
471+ EXPECT_NE(ret, nullptr);
472+ EXPECT_EQ(ft.AddWeight(node, "nonexistent", w), nullptr);
473+}
474+ 
475+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkInput_LinkOutput_UpdatePeer) {
476+ auto graph = BuildGraph();
477+ FusionTurbo ft(graph);
478+ auto const_node = graph->FindNode("const1");
479+ auto relu_node = graph->FindNode("relu1");
480+ auto add_node = graph->FindNode("add1");
481+ ASSERT_NE(const_node, nullptr);
482+ ASSERT_NE(relu_node, nullptr);
483+ ASSERT_NE(add_node, nullptr);
484+ Relations input_rel(0, {const_node, 0});
485+ EXPECT_EQ(ft.LinkInput(input_rel, add_node, UPDATE_PEER), FAILED);
486+ Relations output_rel(0, {add_node, 0});
487+ EXPECT_EQ(ft.LinkOutput(output_rel, relu_node, UPDATE_NONE), SUCCESS);
488+}
489+ 
490+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkInput_DstIndexOutOfRange) {
491+ auto graph = BuildGraph();
492+ FusionTurbo ft(graph);
493+ auto const_node = graph->FindNode("const1");
494+ auto add_node = graph->FindNode("add1");
495+ ASSERT_NE(const_node, nullptr);
496+ ASSERT_NE(add_node, nullptr);
497+ Relations input_rel(99, {const_node, 0});
498+ EXPECT_EQ(ft.LinkInput(input_rel, add_node, UPDATE_NONE), SUCCESS);
499+}
500+ 
501+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkOutput_SrcIndexOutOfRange) {
502+ auto graph = BuildGraph();
503+ FusionTurbo ft(graph);
504+ auto relu_node = graph->FindNode("relu1");
505+ auto add_node = graph->FindNode("add1");
506+ ASSERT_NE(relu_node, nullptr);
507+ ASSERT_NE(add_node, nullptr);
508+ Relations output_rel(99, {add_node, 0});
509+ EXPECT_EQ(ft.LinkOutput(output_rel, relu_node, UPDATE_NONE), SUCCESS);
510+}
511+ 
512+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkOutput_EmptyRelation) {
513+ auto graph = BuildGraph();
514+ FusionTurbo ft(graph);
515+ auto relu_node = graph->FindNode("relu1");
516+ ASSERT_NE(relu_node, nullptr);
517+ Relations output_rel(0, NodeIndices{});
518+ EXPECT_EQ(ft.LinkOutput(output_rel, relu_node, UPDATE_NONE), PARAM_INVALID);
519+}
520+ 
521+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_LinkInput_EmptyRelation) {
522+ auto graph = BuildGraph();
523+ FusionTurbo ft(graph);
524+ auto add_node = graph->FindNode("add1");
525+ ASSERT_NE(add_node, nullptr);
526+ Relations input_rel(0, NodeIndices{});
527+ EXPECT_EQ(ft.LinkInput(input_rel, add_node, UPDATE_NONE), PARAM_INVALID);
528+}
529+ 
530+TEST_F(FusionTurboUtilsCovUT, IncCov_FusionTurbo_AddWeights_WithZeroDataSize) {
531+ auto graph = std::make_shared<ge::ComputeGraph>("test_addweights_zero");
532+ auto op_desc = std::make_shared<ge::OpDesc>("node1", "Relu");
533+ ge::GeTensorDesc tensor_desc(ge::GeShape({0}), ge::FORMAT_NCHW, ge::DT_FLOAT);
534+ op_desc->AddInputDesc(tensor_desc);
535+ op_desc->AddOutputDesc(tensor_desc);
536+ auto node = graph->AddNode(op_desc);
537+ FusionTurbo ft(graph);
538+ auto data_ptr = std::make_unique<int32_t[]>(16);
539+ WeightInfo w(tensor_desc, data_ptr.get());
540+ auto nodes = ft.AddWeights(node, {w});
541+ EXPECT_TRUE(nodes.empty());
542+}
402} // namespace fe543} // namespace fe
Mtests/graph_metadef/ut/register/testcase/graph_fusion_turbo_unittest3.cc+454-0
@@ -300,4 +300,458 @@ TEST_F(UTestFusionTurbo3, test_case_03) {
300 auto relu_top_out_data_nodes = relu_top->GetOutNodes();300 auto relu_top_out_data_nodes = relu_top->GetOutNodes();
301 ASSERT_EQ(relu_top_out_data_nodes.size(), 0);301 ASSERT_EQ(relu_top_out_data_nodes.size(), 0);
302}302}
303+ 
304+TEST_F(UTestFusionTurbo3, WeightInfo_Constructors) {
305+ GeShape shape({2, 4});
306+ GeShape ori_shape({2, 4});
307+ auto data_ptr = std::make_unique<int32_t[]>(16);
308+ WeightInfo w1(shape, ori_shape, DT_FLOAT, DT_FLOAT, FORMAT_NCHW, FORMAT_NCHW, data_ptr.get());
309+ EXPECT_EQ(w1.shape.GetDimNum(), 2U);
310+ 
311+ WeightInfo w2(GeShape({2, 4}), GeShape({2, 4}), DT_FLOAT16, DT_FLOAT16, FORMAT_NCHW, FORMAT_NCHW, data_ptr.get());
312+ EXPECT_EQ(w2.shape.GetDimNum(), 2U);
313+ 
314+ WeightInfo w3(shape, DT_FLOAT, FORMAT_NCHW, data_ptr.get());
315+ EXPECT_EQ(w3.datatype, DT_FLOAT);
316+ 
317+ WeightInfo w4(GeShape({2, 4}), DT_FLOAT, FORMAT_NCHW, data_ptr.get());
318+ EXPECT_EQ(w4.datatype, DT_FLOAT);
319+}
320+ 
321+TEST_F(UTestFusionTurbo3, WeightInfo_FromNode) {
322+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_wi");
323+ OpDescPtr op_desc = std::make_shared<OpDesc>("node1", "Relu");
324+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
325+ tensor_desc.SetOriginFormat(FORMAT_NCHW);
326+ tensor_desc.SetOriginDataType(DT_FLOAT);
327+ op_desc->AddInputDesc(tensor_desc);
328+ NodePtr node = graph->AddNode(op_desc);
329+ auto data_ptr = std::make_unique<int32_t[]>(16);
330+ WeightInfo w(node, 0, data_ptr.get());
331+ EXPECT_EQ(w.datatype, DT_FLOAT);
332+ 
333+ WeightInfo w_null(nullptr, 0, data_ptr.get());
334+ EXPECT_EQ(w_null.data, reinterpret_cast<uint8_t *>(data_ptr.get()));
335+}
336+ 
337+TEST_F(UTestFusionTurbo3, BreakInput_BreakOutput_Basic) {
338+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_break");
339+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
340+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
341+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
342+ op1->AddInputDesc(tensor_desc);
343+ op1->AddOutputDesc(tensor_desc);
344+ op2->AddInputDesc(tensor_desc);
345+ op2->AddOutputDesc(tensor_desc);
346+ NodePtr n1 = graph->AddNode(op1);
347+ NodePtr n2 = graph->AddNode(op2);
348+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
349+ FusionTurbo ft(graph);
350+ EXPECT_EQ(ft.BreakInput(n2, {0}), SUCCESS);
351+ EXPECT_EQ(ft.BreakInput(n2, {99}), SUCCESS);
352+ EXPECT_EQ(ft.BreakOutput(n1, {0}), SUCCESS);
353+ EXPECT_EQ(ft.BreakOutput(n1, {99}), SUCCESS);
354+}
355+ 
356+TEST_F(UTestFusionTurbo3, BreakAllInput_BreakAllOutput) {
357+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_breakall");
358+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
359+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
360+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
361+ op1->AddInputDesc(tensor_desc);
362+ op1->AddOutputDesc(tensor_desc);
363+ op2->AddInputDesc(tensor_desc);
364+ op2->AddOutputDesc(tensor_desc);
365+ NodePtr n1 = graph->AddNode(op1);
366+ NodePtr n2 = graph->AddNode(op2);
367+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
368+ FusionTurbo ft(graph);
369+ EXPECT_EQ(ft.BreakAllInput(n2), SUCCESS);
370+ EXPECT_EQ(ft.BreakAllOutput(n1), SUCCESS);
371+}
372+ 
373+TEST_F(UTestFusionTurbo3, RemoveNodeWithRelink_NullNode) {
374+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_remove_relink");
375+ FusionTurbo ft(graph);
376+ EXPECT_EQ(ft.RemoveNodeWithRelink(nullptr, {0}), PARAM_INVALID);
377+ EXPECT_EQ(ft.RemoveNodeWithRelink(nullptr, std::vector<int32_t>{0}), PARAM_INVALID);
378+}
379+ 
380+TEST_F(UTestFusionTurbo3, RemoveNodeOnly_NullNode) {
381+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_remove_only");
382+ FusionTurbo ft(graph);
383+ EXPECT_EQ(ft.RemoveNodeOnly(nullptr), PARAM_INVALID);
384+}
385+ 
386+TEST_F(UTestFusionTurbo3, RemoveDanglingNode_OnlyDataNodes) {
387+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_dangling");
388+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
389+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
390+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
391+ op1->AddInputDesc(tensor_desc);
392+ op1->AddOutputDesc(tensor_desc);
393+ op2->AddInputDesc(tensor_desc);
394+ op2->AddOutputDesc(tensor_desc);
395+ NodePtr n1 = graph->AddNode(op1);
396+ NodePtr n2 = graph->AddNode(op2);
397+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
398+ FusionTurbo ft(graph);
399+ EXPECT_EQ(ft.RemoveDanglingNode(n2, true), SUCCESS);
400+ EXPECT_EQ(ft.RemoveDanglingNode(nullptr), PARAM_INVALID);
401+}
402+ 
403+TEST_F(UTestFusionTurbo3, RemoveMultiNodesOnly) {
404+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_multi_remove");
405+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
406+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
407+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
408+ op1->AddInputDesc(tensor_desc);
409+ op1->AddOutputDesc(tensor_desc);
410+ op2->AddInputDesc(tensor_desc);
411+ op2->AddOutputDesc(tensor_desc);
412+ NodePtr n1 = graph->AddNode(op1);
413+ NodePtr n2 = graph->AddNode(op2);
414+ FusionTurbo ft(graph);
415+ EXPECT_EQ(ft.RemoveMultiNodesOnly({n1, n2}), SUCCESS);
416+ EXPECT_EQ(ft.RemoveMultiNodesOnly({}), SUCCESS);
417+}
418+ 
419+TEST_F(UTestFusionTurbo3, AddWeight_NullNode) {
420+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_addweight_null");
421+ FusionTurbo ft(graph);
422+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
423+ auto data_ptr = std::make_unique<int32_t[]>(16);
424+ WeightInfo w(tensor_desc, data_ptr.get());
425+ EXPECT_EQ(ft.AddWeight(nullptr, 0, w), nullptr);
426+ EXPECT_EQ(ft.AddWeight(nullptr, w), nullptr);
427+}
428+ 
429+TEST_F(UTestFusionTurbo3, AddWeight_ByTensorName) {
430+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_addweight_name");
431+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
432+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
433+ op1->AddInputDesc("x", tensor_desc);
434+ op1->AddOutputDesc(tensor_desc);
435+ NodePtr n1 = graph->AddNode(op1);
436+ FusionTurbo ft(graph);
437+ auto data_ptr = std::make_unique<int32_t[]>(16);
438+ WeightInfo w(tensor_desc, data_ptr.get());
439+ auto ret = ft.AddWeight(n1, "x", w);
440+ EXPECT_NE(ret, nullptr);
441+ EXPECT_EQ(ft.AddWeight(n1, "nonexistent", w), nullptr);
442+}
443+ 
444+TEST_F(UTestFusionTurbo3, AddWeights_Multiple) {
445+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_addweights");
446+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
447+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
448+ op1->AddInputDesc(tensor_desc);
449+ op1->AddOutputDesc(tensor_desc);
450+ NodePtr n1 = graph->AddNode(op1);
451+ FusionTurbo ft(graph);
452+ auto data_ptr = std::make_unique<int32_t[]>(16);
453+ WeightInfo w1(tensor_desc, data_ptr.get());
454+ WeightInfo w2(tensor_desc, data_ptr.get());
455+ auto nodes = ft.AddWeights(n1, {w1, w2});
456+ EXPECT_EQ(nodes.size(), 2U);
457+ EXPECT_EQ(ft.AddWeights(nullptr, {w1}).size(), 0U);
458+}
459+ 
460+TEST_F(UTestFusionTurbo3, MutableWeight_Test) {
461+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_mutable_weight");
462+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
463+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
464+ op1->AddInputDesc(tensor_desc);
465+ op1->AddOutputDesc(tensor_desc);
466+ NodePtr n1 = graph->AddNode(op1);
467+ FusionTurbo ft(graph);
468+ auto data_ptr = std::make_unique<int32_t[]>(16);
469+ WeightInfo w(tensor_desc, data_ptr.get());
470+ auto const_node = ft.AddWeight(n1, 0, w);
471+ ASSERT_NE(const_node, nullptr);
472+ auto tensor = ft.MutableWeight(n1, 0);
473+ EXPECT_NE(tensor, nullptr);
474+ EXPECT_EQ(ft.MutableWeight(n1, 99), nullptr);
475+ EXPECT_EQ(ft.MutableWeight(nullptr, 0), nullptr);
476+}
477+ 
478+TEST_F(UTestFusionTurbo3, AddNodeOnly_Variants) {
479+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_addnodeonly");
480+ FusionTurbo ft(graph);
481+ auto node1 = ft.AddNodeOnly("node1", "Relu");
482+ EXPECT_NE(node1, nullptr);
483+ auto node2 = FusionTurbo::AddNodeOnly(*graph, "node2", "Relu");
484+ EXPECT_NE(node2, nullptr);
485+ auto node3 = ft.AddNodeOnly("node3", "Relu", 2);
486+ EXPECT_NE(node3, nullptr);
487+ auto node4 = FusionTurbo::AddNodeOnly(*graph, "node4", "Relu", 2);
488+ EXPECT_NE(node4, nullptr);
489+}
490+ 
491+TEST_F(UTestFusionTurbo3, CreateOpDesc_Test) {
492+ auto op_desc = FusionTurbo::CreateOpDesc("node1", "Relu", 0);
493+ EXPECT_NE(op_desc, nullptr);
494+ auto op_desc2 = FusionTurbo::CreateOpDesc("node2", "Relu", 2);
495+ EXPECT_NE(op_desc2, nullptr);
496+ auto op_desc_null = FusionTurbo::CreateOpDesc("node3", "NonExistentType", 0);
497+ EXPECT_EQ(op_desc_null, nullptr);
498+}
499+ 
500+TEST_F(UTestFusionTurbo3, InsertNodeOnly_Variants) {
501+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_insertnodeonly");
502+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
503+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
504+ op1->AddInputDesc(tensor_desc);
505+ op1->AddOutputDesc(tensor_desc);
506+ NodePtr n1 = graph->AddNode(op1);
507+ FusionTurbo ft(graph);
508+ auto node1 = ft.InsertNodeOnly("ins1", "Relu", n1, 0);
509+ EXPECT_NE(node1, nullptr);
510+ auto node2 = FusionTurbo::InsertNodeOnly(*graph, "ins2", "Relu", n1, 0);
511+ EXPECT_NE(node2, nullptr);
512+}
513+ 
514+TEST_F(UTestFusionTurbo3, InsertNodeBefore_NullBaseNode) {
515+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_ins_before_null");
516+ FusionTurbo ft(graph);
517+ EXPECT_EQ(ft.InsertNodeBefore("ins1", "Relu", nullptr, 0), nullptr);
518+}
519+ 
520+TEST_F(UTestFusionTurbo3, InsertNodeAfter_NullBaseNode) {
521+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_ins_after_null");
522+ FusionTurbo ft(graph);
523+ EXPECT_EQ(ft.InsertNodeAfter("ins1", "Relu", nullptr, 0), nullptr);
524+}
525+ 
526+TEST_F(UTestFusionTurbo3, InsertNodeAfter_NonExistentType) {
527+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_ins_after_noexist");
528+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
529+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
530+ op1->AddOutputDesc(tensor_desc);
531+ NodePtr n1 = graph->AddNode(op1);
532+ FusionTurbo ft(graph);
533+ EXPECT_EQ(ft.InsertNodeAfter("ins1", "NonExistentType", n1, 0), nullptr);
534+}
535+ 
536+TEST_F(UTestFusionTurbo3, GetPeerOutNode_Test) {
537+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_peer_out");
538+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
539+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
540+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
541+ op1->AddOutputDesc(tensor_desc);
542+ op2->AddInputDesc(tensor_desc);
543+ op2->AddOutputDesc(tensor_desc);
544+ NodePtr n1 = graph->AddNode(op1);
545+ NodePtr n2 = graph->AddNode(op2);
546+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
547+ auto peer = FusionTurbo::GetPeerOutNode(n2, 0);
548+ EXPECT_EQ(peer, n1);
549+ EXPECT_EQ(FusionTurbo::GetPeerOutNode(nullptr, 0), nullptr);
550+ EXPECT_EQ(FusionTurbo::GetPeerOutNode(n2, 99), nullptr);
551+}
552+ 
553+TEST_F(UTestFusionTurbo3, GetPeerInNodes_Test) {
554+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_peer_in");
555+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
556+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
557+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
558+ op1->AddOutputDesc(tensor_desc);
559+ op2->AddInputDesc(tensor_desc);
560+ op2->AddOutputDesc(tensor_desc);
561+ NodePtr n1 = graph->AddNode(op1);
562+ NodePtr n2 = graph->AddNode(op2);
563+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
564+ auto peers = FusionTurbo::GetPeerInNodes(n1, 0);
565+ EXPECT_EQ(peers.size(), 1U);
566+ EXPECT_EQ(FusionTurbo::GetPeerInNodes(nullptr, 0).size(), 0U);
567+ EXPECT_EQ(FusionTurbo::GetPeerInNodes(n1, 99).size(), 0U);
568+}
569+ 
570+TEST_F(UTestFusionTurbo3, CheckConnected_Test) {
571+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_connected");
572+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
573+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
574+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
575+ op1->AddOutputDesc(tensor_desc);
576+ op2->AddInputDesc(tensor_desc);
577+ op2->AddOutputDesc(tensor_desc);
578+ NodePtr n1 = graph->AddNode(op1);
579+ NodePtr n2 = graph->AddNode(op2);
580+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
581+ EXPECT_TRUE(FusionTurbo::CheckConnected(n1, n2, 0));
582+ EXPECT_TRUE(FusionTurbo::CheckConnected(n1, n2, -1));
583+ EXPECT_FALSE(FusionTurbo::CheckConnected(nullptr, n2, 0));
584+ EXPECT_FALSE(FusionTurbo::CheckConnected(n1, nullptr, 0));
585+}
586+ 
587+TEST_F(UTestFusionTurbo3, HasControl_HasOutData_Test) {
588+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_has_ctrl");
589+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
590+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
591+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
592+ op1->AddOutputDesc(tensor_desc);
593+ op2->AddInputDesc(tensor_desc);
594+ op2->AddOutputDesc(tensor_desc);
595+ NodePtr n1 = graph->AddNode(op1);
596+ NodePtr n2 = graph->AddNode(op2);
597+ GraphUtils::AddEdge(n1->GetOutDataAnchor(0), n2->GetInDataAnchor(0));
598+ GraphUtils::AddEdge(n1->GetOutControlAnchor(), n2->GetInControlAnchor());
599+ EXPECT_TRUE(FusionTurbo::HasInControl(n2));
600+ EXPECT_TRUE(FusionTurbo::HasOutControl(n1));
601+ EXPECT_TRUE(FusionTurbo::HasControl(n2));
602+ EXPECT_FALSE(FusionTurbo::HasInControl(nullptr));
603+ EXPECT_FALSE(FusionTurbo::HasOutControl(nullptr));
604+}
605+ 
606+TEST_F(UTestFusionTurbo3, TransferCtrlEdges_Test) {
607+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_transfer_ctrl");
608+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
609+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
610+ OpDescPtr op3 = std::make_shared<OpDesc>("relu3", "Relu");
611+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
612+ op1->AddOutputDesc(tensor_desc);
613+ op2->AddInputDesc(tensor_desc);
614+ op2->AddOutputDesc(tensor_desc);
615+ op3->AddInputDesc(tensor_desc);
616+ op3->AddOutputDesc(tensor_desc);
617+ NodePtr n1 = graph->AddNode(op1);
618+ NodePtr n2 = graph->AddNode(op2);
619+ NodePtr n3 = graph->AddNode(op3);
620+ GraphUtils::AddEdge(n1->GetOutControlAnchor(), n2->GetInControlAnchor());
621+ FusionTurbo ft(graph);
622+ EXPECT_EQ(ft.TransferOutCtrlEdges({n2}, n3), SUCCESS);
623+ EXPECT_EQ(ft.TransferInCtrlEdges({n2}, n3), SUCCESS);
624+ EXPECT_EQ(ft.TransferOutCtrlEdges({n2}, nullptr), FAILED);
625+ EXPECT_EQ(ft.TransferInCtrlEdges({n2}, nullptr), FAILED);
626+}
627+ 
628+TEST_F(UTestFusionTurbo3, LinkInput_LinkOutput_Test) {
629+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_link");
630+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
631+ OpDescPtr op2 = std::make_shared<OpDesc>("add1", "Add");
632+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
633+ op1->AddOutputDesc(tensor_desc);
634+ op2->AddInputDesc(tensor_desc);
635+ op2->AddInputDesc(tensor_desc);
636+ op2->AddOutputDesc(tensor_desc);
637+ NodePtr n1 = graph->AddNode(op1);
638+ NodePtr n2 = graph->AddNode(op2);
639+ FusionTurbo ft(graph);
640+ Relations input_rel(0, {n1, 0});
641+ EXPECT_EQ(ft.LinkInput(input_rel, n2, UPDATE_THIS), SUCCESS);
642+ EXPECT_EQ(ft.LinkInput(input_rel, nullptr, UPDATE_THIS), PARAM_INVALID);
643+ Relations empty_rel;
644+ EXPECT_EQ(ft.LinkInput(empty_rel, n2, UPDATE_THIS), PARAM_INVALID);
645+ 
646+ Relations output_rel(0, {n2, 0});
647+ EXPECT_EQ(ft.LinkOutput(output_rel, n1, UPDATE_THIS), SUCCESS);
648+ Relations empty_out_rel;
649+ EXPECT_EQ(ft.LinkOutput(empty_out_rel, n1, UPDATE_THIS), PARAM_INVALID);
650+ EXPECT_EQ(ft.LinkOutput(output_rel, nullptr, UPDATE_THIS), PARAM_INVALID);
651+}
652+ 
653+TEST_F(UTestFusionTurbo3, UpdateInputByPeer_UpdateOutputByPeer) {
654+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_update_peer");
655+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
656+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
657+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
658+ op1->AddOutputDesc(tensor_desc);
659+ op2->AddInputDesc(tensor_desc);
660+ op2->AddOutputDesc(tensor_desc);
661+ NodePtr n1 = graph->AddNode(op1);
662+ NodePtr n2 = graph->AddNode(op2);
663+ FusionTurbo ft(graph);
664+ EXPECT_EQ(ft.UpdateInputByPeer(n2, 0, n1, 0), SUCCESS);
665+ EXPECT_EQ(ft.UpdateInputByPeer(nullptr, 0, n1, 0), PARAM_INVALID);
666+ EXPECT_EQ(ft.UpdateInputByPeer(n2, 0, nullptr, 0), PARAM_INVALID);
667+ EXPECT_EQ(ft.UpdateOutputByPeer(n1, 0, n2, 0), SUCCESS);
668+ EXPECT_EQ(ft.UpdateOutputByPeer(nullptr, 0, n2, 0), PARAM_INVALID);
669+ EXPECT_EQ(ft.UpdateOutputByPeer(n1, 0, nullptr, 0), PARAM_INVALID);
670+}
671+ 
672+TEST_F(UTestFusionTurbo3, IsUnknownShape_Test) {
673+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_unknown_shape");
674+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
675+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
676+ op1->AddInputDesc(tensor_desc);
677+ op1->AddOutputDesc(tensor_desc);
678+ NodePtr n1 = graph->AddNode(op1);
679+ EXPECT_FALSE(FusionTurbo::IsUnknownShape(n1, 0, true));
680+ EXPECT_FALSE(FusionTurbo::IsUnknownShape(n1, 0, false));
681+ GeTensorDesc unk_desc(GeShape({ge::UNKNOWN_DIM, 4}), FORMAT_NCHW, DT_FLOAT);
682+ unk_desc.SetOriginShape(GeShape({ge::UNKNOWN_DIM, 4}));
683+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
684+ op2->AddInputDesc(unk_desc);
685+ op2->AddOutputDesc(unk_desc);
686+ NodePtr n2 = graph->AddNode(op2);
687+ EXPECT_TRUE(FusionTurbo::IsUnknownShape(n2, 0, true));
688+ EXPECT_TRUE(FusionTurbo::IsUnknownOriShape(n2, 0, true));
689+}
690+ 
691+TEST_F(UTestFusionTurbo3, MultiInOne_Test) {
692+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_multiinone");
693+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
694+ OpDescPtr op2 = std::make_shared<OpDesc>("relu2", "Relu");
695+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
696+ op1->AddOutputDesc(tensor_desc);
697+ op2->AddInputDesc(tensor_desc);
698+ op2->AddOutputDesc(tensor_desc);
699+ NodePtr n1 = graph->AddNode(op1);
700+ NodePtr n2 = graph->AddNode(op2);
701+ FusionTurbo ft(graph);
702+ Relations input_rel(0, {n1, 0});
703+ Relations output_rel;
704+ auto new_node = ft.MultiInOne("merged", "Relu", input_rel, output_rel, {n1, n2}, true);
705+ EXPECT_NE(new_node, nullptr);
706+}
707+ 
708+TEST_F(UTestFusionTurbo3, FusionTurbo_RefConstructor) {
709+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_ref_ctor");
710+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
711+ NodePtr n1 = graph->AddNode(op1);
712+ FusionTurbo ft(*graph);
713+ auto node = ft.AddNodeOnly("new_node", "Relu");
714+ EXPECT_NE(node, nullptr);
715+}
716+ 
717+TEST_F(UTestFusionTurbo3, AddWeightAfter_NoPeerAnchor) {
718+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_aw_after_nopeer");
719+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
720+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
721+ op1->AddOutputDesc(tensor_desc);
722+ NodePtr n1 = graph->AddNode(op1);
723+ FusionTurbo ft(graph);
724+ auto data_ptr = std::make_unique<int32_t[]>(16);
725+ WeightInfo w(tensor_desc, data_ptr.get());
726+ EXPECT_EQ(ft.AddWeightAfter(n1, 0, w), nullptr);
727+ EXPECT_EQ(ft.AddWeightAfter(nullptr, 0, w), nullptr);
728+}
729+ 
730+TEST_F(UTestFusionTurbo3, AddWeight_IndexLargerThanInputSize) {
731+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_aw_large_idx");
732+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
733+ GeTensorDesc tensor_desc(GeShape({2, 4}), FORMAT_NCHW, DT_FLOAT);
734+ op1->AddInputDesc(tensor_desc);
735+ op1->AddOutputDesc(tensor_desc);
736+ NodePtr n1 = graph->AddNode(op1);
737+ FusionTurbo ft(graph);
738+ auto data_ptr = std::make_unique<int32_t[]>(16);
739+ WeightInfo w(tensor_desc, data_ptr.get());
740+ auto node = ft.AddWeight(n1, 99, w);
741+ EXPECT_NE(node, nullptr);
742+}
743+ 
744+TEST_F(UTestFusionTurbo3, AddWeight_ZeroDataSize) {
745+ ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test_aw_zero");
746+ OpDescPtr op1 = std::make_shared<OpDesc>("relu1", "Relu");
747+ GeTensorDesc tensor_desc(GeShape({0}), FORMAT_NCHW, DT_FLOAT);
748+ op1->AddInputDesc(tensor_desc);
749+ op1->AddOutputDesc(tensor_desc);
750+ NodePtr n1 = graph->AddNode(op1);
751+ FusionTurbo ft(graph);
752+ auto data_ptr = std::make_unique<int32_t[]>(16);
753+ WeightInfo w(tensor_desc, data_ptr.get());
754+ auto node = ft.AddWeight(n1, 99, w);
755+ EXPECT_EQ(node, nullptr);
756+}
303} // namespace fe757} // namespace fe
Mtests/graph_metadef/ut/register/testcase/graph_pass_util_ut.cc+213-0
@@ -1204,4 +1204,217 @@ TEST_F(GraphPassUtilUT, cov_set_pair_tensor_attr_output_null_node_idx) {
1204 NodePtr node = graph->AddNode(op_desc);1204 NodePtr node = graph->AddNode(op_desc);
1205 EXPECT_NO_THROW(GraphPassUtil::SetPairTensorAttr(node, 0, {{"_test", 1}}, false));1205 EXPECT_NO_THROW(GraphPassUtil::SetPairTensorAttr(node, 0, {{"_test", 1}}, false));
1206}1206}
1207+ 
1208+TEST_F(GraphPassUtilUT, cov_set_output_desc_attr_null_origin_opdesc) {
1209+ auto graph = std::make_shared<ComputeGraph>("test");
1210+ OpDescPtr empty_op = std::make_shared<OpDesc>("empty", "Empty");
1211+ NodePtr empty_node = graph->AddNode(empty_op);
1212+ OpDescPtr relu1 = std::make_shared<OpDesc>("relu1", "Relu");
1213+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1214+ relu1->AddOutputDesc(tensor_desc);
1215+ NodePtr relu1_node = graph->AddNode(relu1);
1216+ EXPECT_NO_THROW(GraphPassUtil::SetOutputDescAttr(0, 0, empty_node, relu1_node));
1217+}
1218+ 
1219+TEST_F(GraphPassUtilUT, cov_set_output_desc_attr_null_output_desc_ptr) {
1220+ auto graph = std::make_shared<ComputeGraph>("test");
1221+ OpDescPtr relu1 = std::make_shared<OpDesc>("relu1", "Relu");
1222+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1223+ relu1->AddOutputDesc(tensor_desc);
1224+ OpDescPtr relu2 = std::make_shared<OpDesc>("relu2", "Relu");
1225+ NodePtr relu1_node = graph->AddNode(relu1);
1226+ NodePtr relu2_node = graph->AddNode(relu2);
1227+ EXPECT_NO_THROW(GraphPassUtil::SetOutputDescAttr(0, 0, relu1_node, relu2_node));
1228+}
1229+ 
1230+TEST_F(GraphPassUtilUT, cov_store_and_update_pass_name_success) {
1231+ auto graph = std::make_shared<ComputeGraph>("test");
1232+ OpDescPtr ori_op_desc1 = std::make_shared<OpDesc>("node1", "Relu");
1233+ OpDescPtr ori_op_desc2 = std::make_shared<OpDesc>("node2", "Relu");
1234+ OpDescPtr fus_op_desc = std::make_shared<OpDesc>("fusion", "Fusion");
1235+ NodePtr ori_node1 = graph->AddNode(ori_op_desc1);
1236+ NodePtr ori_node2 = graph->AddNode(ori_op_desc2);
1237+ NodePtr fus_node = graph->AddNode(fus_op_desc);
1238+ std::vector<ge::NodePtr> ori_nodes = {ori_node1, ori_node2};
1239+ Status ret = GraphPassUtil::StoreAndUpdataOriginFusionPassName(fus_op_desc, ori_nodes, "passA");
1240+ EXPECT_EQ(ret, SUCCESS);
1241+ std::vector<string> pass_names;
1242+ AttrUtils::GetListStr(fus_op_desc, "pass_name", pass_names);
1243+ EXPECT_EQ(pass_names.size(), 1U);
1244+}
1245+ 
1246+TEST_F(GraphPassUtilUT, cov_record_original_op_attrs_null_op_desc) {
1247+ putenv(const_cast<char *>("DUMP_GE_GRAPH=2"));
1248+ auto graph = std::make_shared<ComputeGraph>("test");
1249+ OpDescPtr ori_op_desc = std::make_shared<OpDesc>("node1", "Relu");
1250+ NodePtr ori_node = graph->AddNode(ori_op_desc);
1251+ std::vector<ge::NodePtr> ori_nodes = {ori_node};
1252+ EXPECT_NO_THROW(GraphPassUtil::RecordOriginalOpAttrs(ori_nodes, nullptr, "pass_test"));
1253+}
1254+ 
1255+TEST_F(GraphPassUtilUT, cov_record_original_op_attrs_null_origin_op_desc) {
1256+ putenv(const_cast<char *>("DUMP_GE_GRAPH=2"));
1257+ auto graph = std::make_shared<ComputeGraph>("test");
1258+ OpDescPtr fus_op_desc = std::make_shared<OpDesc>("fusion", "Fusion");
1259+ NodePtr fus_node = graph->AddNode(fus_op_desc);
1260+ OpDescPtr ori_op_desc = std::make_shared<OpDesc>("node1", "Relu");
1261+ NodePtr ori_node = graph->AddNode(ori_op_desc);
1262+ std::vector<ge::NodePtr> ori_nodes = {ori_node};
1263+ GraphPassUtil::OriginOpAttrsVec origin_op_attrs = {{"node1", "Relu"}};
1264+ EXPECT_NO_THROW(GraphPassUtil::RecordOriginalOpAttrs(ori_nodes, fus_op_desc, "pass_test", origin_op_attrs));
1265+}
1266+ 
1267+TEST_F(GraphPassUtilUT, cov_record_original_op_attrs_with_index_out_of_range) {
1268+ putenv(const_cast<char *>("DUMP_GE_GRAPH=2"));
1269+ auto graph = std::make_shared<ComputeGraph>("test");
1270+ OpDescPtr ori_op_desc = std::make_shared<OpDesc>("node1", "Relu");
1271+ OpDescPtr fus_op_desc = std::make_shared<OpDesc>("fusion", "Fusion");
1272+ NodePtr ori_node = graph->AddNode(ori_op_desc);
1273+ NodePtr fus_node = graph->AddNode(fus_op_desc);
1274+ std::vector<ge::NodePtr> ori_nodes = {ori_node};
1275+ GraphPassUtil::OriginOpAttrsVec origin_op_attrs;
1276+ EXPECT_NO_THROW(GraphPassUtil::RecordOriginalOpAttrs(ori_nodes, fus_op_desc, "pass_test", origin_op_attrs));
1277+}
1278+ 
1279+TEST_F(GraphPassUtilUT, cov_get_nodes_from_node_type_map_empty_inner) {
1280+ auto graph = std::make_shared<ComputeGraph>("test");
1281+ OpDescPtr op = std::make_shared<OpDesc>("test_op", "TestOp");
1282+ auto node = graph->AddNode(op);
1283+ std::map<std::string, ge::NodePtr> inner_map;
1284+ std::unordered_map<std::string, std::map<std::string, ge::NodePtr>> node_map;
1285+ node_map["TestOp"] = inner_map;
1286+ NodeTypeMapPtr node_type_map = std::make_shared<NodeTypeMap>(node_map);
1287+ vector<ge::NodePtr> nodes;
1288+ EXPECT_NO_THROW(GraphPassUtil::GetNodesFromNodeTypeMap(node_type_map, "TestOp", nodes));
1289+ EXPECT_EQ(nodes.size(), 0U);
1290+}
1291+ 
1292+TEST_F(GraphPassUtilUT, cov_set_pair_tensor_attr_output_with_peer_null_node) {
1293+ auto graph = std::make_shared<ComputeGraph>("test");
1294+ OpDescPtr op_desc1 = std::make_shared<OpDesc>("node1", "Relu");
1295+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1296+ op_desc1->AddOutputDesc(tensor_desc);
1297+ NodePtr node1 = graph->AddNode(op_desc1);
1298+ std::map<std::string, int> attr_val;
1299+ attr_val["_test"] = 1;
1300+ EXPECT_NO_THROW(GraphPassUtil::SetPairTensorAttr(node1, 0, attr_val, false));
1301+}
1302+ 
1303+TEST_F(GraphPassUtilUT, cov_set_pair_tensor_attr_output_with_null_peer_tensor) {
1304+ auto graph = std::make_shared<ComputeGraph>("test");
1305+ OpDescPtr op_desc1 = std::make_shared<OpDesc>("node1", "Relu");
1306+ OpDescPtr op_desc2 = std::make_shared<OpDesc>("node2", "Relu");
1307+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1308+ op_desc1->AddOutputDesc(tensor_desc);
1309+ op_desc2->AddInputDesc(tensor_desc);
1310+ op_desc2->AddOutputDesc(tensor_desc);
1311+ NodePtr node1 = graph->AddNode(op_desc1);
1312+ NodePtr node2 = graph->AddNode(op_desc2);
1313+ ge::GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
1314+ std::map<std::string, int> attr_val;
1315+ attr_val["_test"] = 1;
1316+ EXPECT_NO_THROW(GraphPassUtil::SetPairTensorAttr(node1, 0, attr_val, false));
1317+}
1318+ 
1319+TEST_F(GraphPassUtilUT, cov_set_pair_tensor_int_attr_null_anchor) {
1320+ auto graph = std::make_shared<ComputeGraph>("test");
1321+ OpDescPtr op_desc = std::make_shared<OpDesc>("node1", "Relu");
1322+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1323+ op_desc->AddInputDesc(tensor_desc);
1324+ op_desc->AddOutputDesc(tensor_desc);
1325+ NodePtr node = graph->AddNode(op_desc);
1326+ EXPECT_NO_THROW(GraphPassUtil::SetPairTensorIntAttr(node, 99, {{"_test", 1}}));
1327+}
1328+ 
1329+TEST_F(GraphPassUtilUT, cov_set_pair_tensor_int_attr_null_peer_anchor) {
1330+ auto graph = std::make_shared<ComputeGraph>("test");
1331+ OpDescPtr op_desc = std::make_shared<OpDesc>("node1", "Relu");
1332+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1333+ op_desc->AddInputDesc(tensor_desc);
1334+ op_desc->AddOutputDesc(tensor_desc);
1335+ NodePtr node = graph->AddNode(op_desc);
1336+ EXPECT_NO_THROW(GraphPassUtil::SetPairTensorIntAttr(node, 0, {{"_test", 1}}));
1337+}
1338+ 
1339+TEST_F(GraphPassUtilUT, cov_set_pair_tensor_int_attr_with_ge_local_peer_peer) {
1340+ auto graph = std::make_shared<ComputeGraph>("test");
1341+ OpDescPtr op_desc1 = std::make_shared<OpDesc>("node1", "Relu");
1342+ OpDescPtr op_desc2 = std::make_shared<OpDesc>("node2", "Reshape");
1343+ OpDescPtr op_desc3 = std::make_shared<OpDesc>("node3", "Relu");
1344+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1345+ op_desc1->AddOutputDesc(tensor_desc);
1346+ op_desc2->AddInputDesc(tensor_desc);
1347+ op_desc2->AddOutputDesc(tensor_desc);
1348+ op_desc3->AddInputDesc(tensor_desc);
1349+ op_desc3->AddOutputDesc(tensor_desc);
1350+ NodePtr node1 = graph->AddNode(op_desc1);
1351+ NodePtr node2 = graph->AddNode(op_desc2);
1352+ NodePtr node3 = graph->AddNode(op_desc3);
1353+ ge::GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
1354+ ge::GraphUtils::AddEdge(node2->GetOutDataAnchor(0), node3->GetInDataAnchor(0));
1355+ EXPECT_NO_THROW(GraphPassUtil::SetPairTensorIntAttr(node3, 0, {{"_test", 1}}));
1356+}
1357+ 
1358+TEST_F(GraphPassUtilUT, cov_inherit_attrs_with_heavy_op_fus_not_heavy) {
1359+ auto graph = std::make_shared<ComputeGraph>("test");
1360+ OpDescPtr ori_op_desc = std::make_shared<OpDesc>("matmul1", "MatMul");
1361+ OpDescPtr fus_op_desc = std::make_shared<OpDesc>("fusion", "Relu");
1362+ NodePtr ori_node = graph->AddNode(ori_op_desc);
1363+ NodePtr fus_node = graph->AddNode(fus_op_desc);
1364+ AttrUtils::SetInt(ori_op_desc, ge::ATTR_NAME_PARALLEL_GROUP_ID, static_cast<int64_t>(100));
1365+ std::vector<ge::NodePtr> ori_nodes = {ori_node};
1366+ std::vector<ge::NodePtr> fus_nodes = {fus_node};
1367+ EXPECT_NO_THROW(GraphPassUtil::InheritAttrFromOriNodes(ori_nodes, fus_nodes, BackWardInheritMode::kFusedNode));
1368+}
1369+ 
1370+TEST_F(GraphPassUtilUT, cov_get_peer_out_anchor_not_in_delete_list_with_ge_local) {
1371+ auto graph = std::make_shared<ComputeGraph>("test");
1372+ OpDescPtr op_desc1 = std::make_shared<OpDesc>("node1", "Relu");
1373+ OpDescPtr op_desc2 = std::make_shared<OpDesc>("node2", "Reshape");
1374+ OpDescPtr op_desc3 = std::make_shared<OpDesc>("node3", "Relu");
1375+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1376+ op_desc1->AddOutputDesc(tensor_desc);
1377+ op_desc2->AddInputDesc(tensor_desc);
1378+ op_desc2->AddOutputDesc(tensor_desc);
1379+ op_desc3->AddInputDesc(tensor_desc);
1380+ op_desc3->AddOutputDesc(tensor_desc);
1381+ NodePtr node1 = graph->AddNode(op_desc1);
1382+ NodePtr node2 = graph->AddNode(op_desc2);
1383+ NodePtr node3 = graph->AddNode(op_desc3);
1384+ ge::GraphUtils::AddEdge(node1->GetOutDataAnchor(0), node2->GetInDataAnchor(0));
1385+ ge::GraphUtils::AddEdge(node2->GetOutDataAnchor(0), node3->GetInDataAnchor(0));
1386+ auto peer_anchor = GraphPassUtil::GetPeerOutAnchorNotInDeleteList(node3, 0);
1387+ EXPECT_NE(peer_anchor, nullptr);
1388+}
1389+ 
1390+TEST_F(GraphPassUtilUT, cov_get_peer_out_anchor_not_in_delete_list_null_anchor) {
1391+ auto graph = std::make_shared<ComputeGraph>("test");
1392+ OpDescPtr op_desc = std::make_shared<OpDesc>("node1", "Relu");
1393+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1394+ op_desc->AddInputDesc(tensor_desc);
1395+ NodePtr node = graph->AddNode(op_desc);
1396+ auto peer_anchor = GraphPassUtil::GetPeerOutAnchorNotInDeleteList(node, 0);
1397+ EXPECT_EQ(peer_anchor, nullptr);
1398+}
1399+ 
1400+TEST_F(GraphPassUtilUT, cov_get_peer_out_anchor_not_in_delete_list_null_peer) {
1401+ auto graph = std::make_shared<ComputeGraph>("test");
1402+ OpDescPtr op_desc = std::make_shared<OpDesc>("node1", "Relu");
1403+ GeTensorDesc tensor_desc(GeShape({4, 4, 1, 4}), FORMAT_NCHW, DT_FLOAT16);
1404+ op_desc->AddInputDesc(tensor_desc);
1405+ op_desc->AddOutputDesc(tensor_desc);
1406+ NodePtr node = graph->AddNode(op_desc);
1407+ auto peer_anchor = GraphPassUtil::GetPeerOutAnchorNotInDeleteList(node, 0);
1408+ EXPECT_EQ(peer_anchor, nullptr);
1409+}
1410+ 
1411+TEST_F(GraphPassUtilUT, cov_record_original_names_null_op_desc) {
1412+ auto graph = std::make_shared<ComputeGraph>("test");
1413+ OpDescPtr ori_op_desc = std::make_shared<OpDesc>("ori", "Relu");
1414+ NodePtr ori_node = graph->AddNode(ori_op_desc);
1415+ OpDescPtr null_op_desc = std::make_shared<OpDesc>("null_node", "Relu");
1416+ NodePtr null_node = graph->AddNode(null_op_desc);
1417+ std::vector<ge::NodePtr> original_nodes = {ori_node, null_node};
1418+ EXPECT_NO_THROW(GraphPassUtil::RecordOriginalNames(original_nodes, nullptr));
1419+}
1207} // namespace fe1420} // namespace fe
Mtests/graph_metadef/ut/register/testcase/op_def_cov_unittest.cc+51-0
@@ -628,4 +628,55 @@ TEST_F(OpDefCovUT, OpDef_FollowListImpl) {
628 std::vector<OpParamDef> output = opDef.GetOutputs();628 std::vector<OpParamDef> output = opDef.GetOutputs();
629 opDef.FollowListImpl(dfs_param, input, output);629 opDef.FollowListImpl(dfs_param, input, output);
630}630}
631+ 
632+TEST_F(OpDefCovUT, OpDef_CopyConstructor) {
633+ OpDef opDef1("TestCopyCtor");
634+ opDef1.Input("x").DataType({ge::DT_FLOAT16});
635+ opDef1.Output("y").DataType({ge::DT_FLOAT16});
636+ OpDef opDef2(opDef1);
637+ EXPECT_EQ(opDef2.GetOpType(), ge::AscendString("TestCopyCtor"));
638+ EXPECT_EQ(opDef2.GetInputs().size(), 1U);
639+ EXPECT_EQ(opDef2.GetOutputs().size(), 1U);
640+}
641+ 
642+TEST_F(OpDefCovUT, OpDef_CommentAndGetComments) {
643+ OpDef opDef("TestComment");
644+ opDef.Comment(CommentSection::CATEGORY, "TestCategory");
645+ opDef.Comment(CommentSection::BRIEF, "TestBrief");
646+ opDef.Comment(CommentSection::CONSTRAINTS, "TestConstraints");
647+ opDef.Comment(CommentSection::RESTRICTIONS, "TestRestrictions");
648+ opDef.Comment(CommentSection::SEE, "TestSee");
649+ opDef.Comment(CommentSection::THIRDPARTYFWKCOMPAT, "TestCompat");
650+ EXPECT_FALSE(opDef.GetBrief().empty());
651+ EXPECT_FALSE(opDef.GetConstraints().empty());
652+ EXPECT_FALSE(opDef.GetRestrictions().empty());
653+ EXPECT_FALSE(opDef.GetSee().empty());
654+ EXPECT_FALSE(opDef.GetThirdPartyFwkCopat().empty());
655+}
656+ 
657+TEST_F(OpDefCovUT, OpDef_GetMergeInputsAndOutputs) {
658+ OpDef opDef("TestMergeIO2");
659+ opDef.Input("x").DataType({ge::DT_FLOAT16});
660+ opDef.Output("y").DataType({ge::DT_FLOAT16});
661+ opDef.AICore().AddConfig("ascend910");
662+ auto aicoreMap = opDef.AICore().GetAICoreConfigs();
663+ auto aicore = aicoreMap["ascend910"];
664+ auto mergeInputs = opDef.GetMergeInputs(aicore);
665+ EXPECT_FALSE(mergeInputs.empty());
666+ auto mergeOutputs = opDef.GetMergeOutputs(aicore);
667+ EXPECT_FALSE(mergeOutputs.empty());
668+}
669+ 
670+TEST_F(OpDefCovUT, OpDef_FormatMatchMode) {
671+ OpDef opDef("TestFormatMatchMode");
672+ opDef.FormatMatchMode(FormatCheckOption::STRICT);
673+ EXPECT_EQ(opDef.GetFormatMatchMode(), FormatCheckOption::STRICT);
674+}
675+ 
676+TEST_F(OpDefCovUT, OpDef_EnableFallBack) {
677+ OpDef opDef("TestEnableFallBack");
678+ EXPECT_FALSE(opDef.IsEnableFallBack());
679+ opDef.EnableFallBack();
680+ EXPECT_TRUE(opDef.IsEnableFallBack());
681+}
631} // namespace ops682} // namespace ops
Mtests/graph_metadef/ut/register/testcase/pattern_fusion_base_pass_cov_unittest.cc+533-0
@@ -788,4 +788,537 @@ TEST_F(PatternFusionBasePassCovUT, Run_WithOpsKernelStore_RunCountUpdate) {
788 auto ret = pass.Run(*graph, nullptr);788 auto ret = pass.Run(*graph, nullptr);
789 EXPECT_EQ(ret, NOT_CHANGED);789 EXPECT_EQ(ret, NOT_CHANGED);
790}790}
791+ 
792+TEST_F(PatternFusionBasePassCovUT, CycleDetection_WithCycleAndNullNode) {
793+ ut::GraphBuilder builder("graph_cycle_null_in_scope");
794+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
795+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
796+ auto node3 = builder.AddNode("node3", "Relu", 1, 1);
797+ builder.AddDataEdge(node1, 0, node2, 0);
798+ builder.AddDataEdge(node2, 0, node3, 0);
799+ builder.AddDataEdge(node3, 0, node1, 0);
800+ auto graph = builder.GetGraph();
801+ 
802+ TestPatternFusionPassCov pass;
803+ vector<vector<NodePtr>> fusion_nodes = {{node1, nullptr, node3}};
804+ bool ret = pass.CycleDetection(*graph, fusion_nodes);
805+ EXPECT_TRUE(ret);
806+}
807+ 
808+TEST_F(PatternFusionBasePassCovUT, CycleDetection_SingleVector_WithCycleAndNullNode) {
809+ ut::GraphBuilder builder("graph_single_cycle_null");
810+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
811+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
812+ auto node3 = builder.AddNode("node3", "Relu", 1, 1);
813+ builder.AddDataEdge(node1, 0, node2, 0);
814+ builder.AddDataEdge(node2, 0, node3, 0);
815+ builder.AddDataEdge(node3, 0, node1, 0);
816+ auto graph = builder.GetGraph();
817+ 
818+ TestPatternFusionPassCov pass;
819+ vector<NodePtr> fusion_nodes = {node1, nullptr, node3};
820+ bool ret = pass.CycleDetection(*graph, fusion_nodes);
821+ EXPECT_TRUE(ret);
822+}
823+ 
824+class MultiNodePatternFusionPassCov : public PatternFusionBasePass {
825+ public:
826+ std::vector<FusionPattern *> DefinePatterns() override {
827+ std::vector<FusionPattern *> patterns;
828+ auto pattern = new (std::nothrow) FusionPattern("MultiNodePattern");
829+ if (pattern != nullptr) {
830+ pattern->AddOpDesc("input", {"Relu"});
831+ pattern->AddOpDesc("output", {"Relu"});
832+ pattern->SetOutputs("input", {{0, "output"}});
833+ pattern->SetOutput("output");
834+ patterns.push_back(pattern);
835+ }
836+ return patterns;
837+ }
838+ Status Fusion(ComputeGraph &graph, Mapping &mapping, vector<NodePtr> &new_nodes) override {
839+ return NOT_CHANGED;
840+ }
841+ const string GetName() const {
842+ return "MultiNodePatternFusionPassCov";
843+ }
844+};
845+ 
846+TEST_F(PatternFusionBasePassCovUT, Run_MultiNodePattern_DifferentStreamLabels) {
847+ ut::GraphBuilder builder("graph_multi_diff_stream");
848+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
849+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
850+ builder.AddDataEdge(node1, 0, node2, 0);
851+ auto graph = builder.GetGraph();
852+ 
853+ AttrUtils::SetStr(node1->GetOpDesc(), "_stream_label", "stream_a");
854+ AttrUtils::SetStr(node2->GetOpDesc(), "_stream_label", "stream_b");
855+ 
856+ MultiNodePatternFusionPassCov pass;
857+ auto ret = pass.Run(*graph);
858+ EXPECT_EQ(ret, NOT_CHANGED);
859+}
860+ 
861+TEST_F(PatternFusionBasePassCovUT, Run_MultiNodePattern_SameStreamLabels) {
862+ ut::GraphBuilder builder("graph_multi_same_stream");
863+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
864+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
865+ builder.AddDataEdge(node1, 0, node2, 0);
866+ auto graph = builder.GetGraph();
867+ 
868+ AttrUtils::SetStr(node1->GetOpDesc(), "_stream_label", "stream_a");
869+ AttrUtils::SetStr(node2->GetOpDesc(), "_stream_label", "stream_a");
870+ 
871+ MultiNodePatternFusionPassCov pass;
872+ auto ret = pass.Run(*graph);
873+ EXPECT_EQ(ret, NOT_CHANGED);
874+}
875+ 
876+class NoOutputPatternFusionPassCov : public PatternFusionBasePass {
877+ public:
878+ std::vector<FusionPattern *> DefinePatterns() override {
879+ std::vector<FusionPattern *> patterns;
880+ auto pattern = new (std::nothrow) FusionPattern("NoOutputPattern");
881+ if (pattern != nullptr) {
882+ pattern->AddOpDesc("node", {"Relu"});
883+ patterns.push_back(pattern);
884+ }
885+ return patterns;
886+ }
887+ Status Fusion(ComputeGraph &graph, Mapping &mapping, vector<NodePtr> &new_nodes) override {
888+ return NOT_CHANGED;
889+ }
890+ const string GetName() const {
891+ return "NoOutputPatternFusionPassCov";
892+ }
893+};
894+ 
895+TEST_F(PatternFusionBasePassCovUT, Run_NoOutputPattern) {
896+ ut::GraphBuilder builder("graph_no_output_pattern");
897+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
898+ auto graph = builder.GetGraph();
899+ 
900+ NoOutputPatternFusionPassCov pass;
901+ auto ret = pass.Run(*graph);
902+ EXPECT_EQ(ret, FAILED);
903+}
904+ 
905+class SuccessFusionPassCov : public PatternFusionBasePass {
906+ public:
907+ std::vector<FusionPattern *> DefinePatterns() override {
908+ std::vector<FusionPattern *> patterns;
909+ auto pattern = new (std::nothrow) FusionPattern("SuccessPattern");
910+ if (pattern != nullptr) {
911+ pattern->AddOpDesc("output", {"Relu"}).SetOutput("output");
912+ patterns.push_back(pattern);
913+ }
914+ return patterns;
915+ }
916+ Status Fusion(ComputeGraph &graph, Mapping &mapping, vector<NodePtr> &new_nodes) override {
917+ auto op_desc = std::make_shared<ge::OpDesc>("fused_node", "Relu");
918+ GeTensorDesc tensor_desc(GeShape({1}), FORMAT_NCHW, DT_FLOAT);
919+ op_desc->AddInputDesc(tensor_desc);
920+ op_desc->AddOutputDesc(tensor_desc);
921+ auto fused_node = graph.AddNode(op_desc);
922+ new_nodes.push_back(fused_node);
923+ return SUCCESS;
924+ }
925+ const string GetName() const {
926+ return "SuccessFusionPassCov";
927+ }
928+};
929+ 
930+TEST_F(PatternFusionBasePassCovUT, Run_SuccessFusion) {
931+ ut::GraphBuilder builder("graph_success_fusion");
932+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
933+ auto graph = builder.GetGraph();
934+ 
935+ SuccessFusionPassCov pass;
936+ auto ret = pass.Run(*graph);
937+ EXPECT_EQ(ret, SUCCESS);
938+}
939+ 
940+TEST_F(PatternFusionBasePassCovUT, Run_SuccessFusionWithStreamLabel) {
941+ ut::GraphBuilder builder("graph_success_stream");
942+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
943+ auto graph = builder.GetGraph();
944+ AttrUtils::SetStr(node1->GetOpDesc(), "_stream_label", "stream1");
945+ 
946+ SuccessFusionPassCov pass;
947+ auto ret = pass.Run(*graph);
948+ EXPECT_EQ(ret, SUCCESS);
949+}
950+ 
951+TEST_F(PatternFusionBasePassCovUT, GetNodeFromMapping_NullOpDesc) {
952+ TestPatternFusionPassCov pass;
953+ PatternFusionBasePass::Mapping mapping;
954+ mapping[nullptr] = {};
955+ auto node = pass.GetNodeFromMapping("test_id", mapping);
956+ EXPECT_EQ(node, nullptr);
957+}
958+ 
959+TEST_F(PatternFusionBasePassCovUT, GetNodeFromMapping_FoundInMapping) {
960+ TestPatternFusionPassCov pass;
961+ PatternFusionBasePass::Mapping mapping;
962+ auto op_desc = std::make_shared<FusionPattern::OpDesc>();
963+ op_desc->id = "test_id";
964+ ut::GraphBuilder builder("graph_get_node_found");
965+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
966+ mapping[op_desc] = {node1};
967+ auto node = pass.GetNodeFromMapping("test_id", mapping);
968+ EXPECT_EQ(node, node1);
969+}
970+ 
971+TEST_F(PatternFusionBasePassCovUT, SetDataDumpAttr_NoActualFusedNodes) {
972+ ut::GraphBuilder builder("graph_set_data_dump_no_actual");
973+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
974+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
975+ builder.AddDataEdge(node1, 0, node2, 0);
976+ auto graph = builder.GetGraph();
977+ 
978+ TestPatternFusionPassCov pass;
979+ std::vector<ge::NodePtr> fused_nodes = {node1};
980+ std::vector<ge::NodePtr> fusion_nodes = {node2};
981+ EXPECT_NO_THROW(pass.SetDataDumpAttr(fused_nodes, fusion_nodes));
982+}
983+ 
984+TEST_F(PatternFusionBasePassCovUT, SetDataDumpAttr_MultiFusionNodesWithMultiOp) {
985+ ut::GraphBuilder builder("graph_multi_op");
986+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
987+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
988+ auto node3 = builder.AddNode("node3", "Relu", 1, 1);
989+ builder.AddDataEdge(node1, 0, node2, 0);
990+ builder.AddDataEdge(node2, 0, node3, 0);
991+ auto graph = builder.GetGraph();
992+ 
993+ TestPatternFusionPassCov pass;
994+ std::vector<ge::NodePtr> fused_nodes = {node1, node2};
995+ std::vector<ge::NodePtr> fusion_nodes = {node3, node2};
996+ EXPECT_NO_THROW(pass.SetDataDumpAttr(fused_nodes, fusion_nodes));
997+}
998+ 
999+TEST_F(PatternFusionBasePassCovUT, SetOriginalOutputDumpAttr_Test) {
1000+ ut::GraphBuilder builder("graph_set_orig_out");
1001+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1002+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
1003+ builder.AddDataEdge(node1, 0, node2, 0);
1004+ auto graph = builder.GetGraph();
1005+ 
1006+ TestPatternFusionPassCov pass;
1007+ pass.RecordOutputAnchorMap(node1);
1008+ std::vector<ge::NodePtr> fused_nodes = {node1};
1009+ std::vector<ge::NodePtr> fusion_nodes = {node2};
1010+ EXPECT_NO_THROW(pass.SetDataDumpAttr(fused_nodes, fusion_nodes));
1011+ pass.ClearOutputAnchorMap();
1012+}
1013+ 
1014+TEST_F(PatternFusionBasePassCovUT, GetPatterns_WithBadBuildInGetPatterns) {
1015+ class BadGetPatternsPass : public PatternFusionBasePass {
1016+ public:
1017+ std::vector<FusionPattern *> DefinePatterns() override {
1018+ return {};
1019+ }
1020+ Status Fusion(ComputeGraph &graph, Mapping &mapping, vector<NodePtr> &new_nodes) override {
1021+ return NOT_CHANGED;
1022+ }
1023+ const string GetName() const {
1024+ return "BadGetPatternsPass";
1025+ }
1026+ };
1027+ 
1028+ BadGetPatternsPass pass;
1029+ const auto &patterns = pass.GetPatterns();
1030+ EXPECT_TRUE(patterns.empty());
1031+}
1032+ 
1033+TEST_F(PatternFusionBasePassCovUT, GetInnerPatterns_WithBadBuild) {
1034+ class BadInnerGetPass : public PatternFusionBasePass {
1035+ public:
1036+ std::vector<FusionPattern *> DefinePatterns() override {
1037+ std::vector<FusionPattern *> patterns;
1038+ auto pattern = new (std::nothrow) FusionPattern("GoodPattern");
1039+ if (pattern != nullptr) {
1040+ pattern->AddOpDesc("output", {"Relu"}).SetOutput("output");
1041+ patterns.push_back(pattern);
1042+ }
1043+ return patterns;
1044+ }
1045+ std::vector<FusionPattern *> DefineInnerPatterns() override {
1046+ std::vector<FusionPattern *> patterns;
1047+ auto pattern = new (std::nothrow) FusionPattern("BadInnerPattern2");
1048+ if (pattern != nullptr) {
1049+ pattern->AddOpDesc("output", {"Relu"});
1050+ patterns.push_back(pattern);
1051+ cleanup_patterns.push_back(pattern);
1052+ }
1053+ return patterns;
1054+ }
1055+ ~BadInnerGetPass() {
1056+ for (auto p : cleanup_patterns) {
1057+ delete p;
1058+ }
1059+ }
1060+ Status Fusion(ComputeGraph &graph, Mapping &mapping, vector<NodePtr> &new_nodes) override {
1061+ return NOT_CHANGED;
1062+ }
1063+ const string GetName() const {
1064+ return "BadInnerGetPass";
1065+ }
1066+ 
1067+ private:
1068+ std::vector<FusionPattern *> cleanup_patterns;
1069+ };
1070+ 
1071+ BadInnerGetPass pass;
1072+ const auto &inner_patterns = pass.GetInnerPatterns();
1073+ EXPECT_TRUE(inner_patterns.empty());
1074+}
1075+ 
1076+TEST_F(PatternFusionBasePassCovUT, CheckEachPeerOut_NoPeerOut) {
1077+ ut::GraphBuilder builder("graph_no_peer_out");
1078+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1079+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
1080+ builder.AddDataEdge(node1, 0, node2, 0);
1081+ auto graph = builder.GetGraph();
1082+ 
1083+ TestPatternFusionPassCov pass;
1084+ vector<vector<NodePtr>> fusion_nodes = {{node1, node2}};
1085+ pass.CycleDetection(*graph, fusion_nodes);
1086+ bool ret = pass.CycleDetection(*graph, fusion_nodes);
1087+ EXPECT_FALSE(ret);
1088+}
1089+ 
1090+TEST_F(PatternFusionBasePassCovUT, StoreOriginOpNames_WithEmptyMapping) {
1091+ TestPatternFusionPassCov pass;
1092+ PatternFusionBasePass::Mapping mapping;
1093+ std::vector<std::string> origin_op_names;
1094+ auto op_desc = std::make_shared<FusionPattern::OpDesc>();
1095+ op_desc->id = "test_id";
1096+ mapping[op_desc] = {};
1097+ EXPECT_NO_THROW(pass.StoreOriginOpNames(mapping, origin_op_names));
1098+ EXPECT_TRUE(origin_op_names.empty());
1099+}
1100+ 
1101+TEST_F(PatternFusionBasePassCovUT, Impl_CheckOpSupported_NullStore) {
1102+ PatternFusionBasePassImpl impl;
1103+ OpDescPtr op_desc = std::make_shared<ge::OpDesc>("test", "Relu");
1104+ EXPECT_FALSE(impl.CheckOpSupported(op_desc));
1105+ 
1106+ ut::GraphBuilder builder("graph_impl_check");
1107+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1108+ EXPECT_FALSE(impl.CheckOpSupported(node1));
1109+}
1110+ 
1111+TEST_F(PatternFusionBasePassCovUT, Impl_CheckAccuracySupported_NullNode) {
1112+ PatternFusionBasePassImpl impl;
1113+ EXPECT_FALSE(impl.CheckAccuracySupported(nullptr));
1114+ 
1115+ ut::GraphBuilder builder("graph_impl_acc");
1116+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1117+ EXPECT_FALSE(impl.CheckAccuracySupported(node1));
1118+}
1119+ 
1120+TEST_F(PatternFusionBasePassCovUT, Impl_IsNodesExist_Test) {
1121+ PatternFusionBasePassImpl impl;
1122+ ut::GraphBuilder builder("graph_impl_nodes_exist");
1123+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1124+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
1125+ vector<NodePtr> nodes = {node1, node2};
1126+ EXPECT_TRUE(impl.IsNodesExist(node1, nodes));
1127+ EXPECT_FALSE(impl.IsNodesExist(nullptr, nodes));
1128+}
1129+ 
1130+TEST_F(PatternFusionBasePassCovUT, Impl_IsMatched_Test) {
1131+ PatternFusionBasePassImpl impl;
1132+ auto op_desc = std::make_shared<FusionPattern::OpDesc>();
1133+ op_desc->id = "test";
1134+ ut::GraphBuilder builder("graph_impl_matched");
1135+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1136+ PatternFusionBasePass::Mapping mapping;
1137+ mapping[op_desc] = {node1};
1138+ EXPECT_TRUE(impl.IsMatched(op_desc, node1, mapping));
1139+ EXPECT_FALSE(impl.IsMatched(nullptr, node1, mapping));
1140+ EXPECT_FALSE(impl.IsMatched(op_desc, nullptr, mapping));
1141+}
1142+ 
1143+TEST_F(PatternFusionBasePassCovUT, Impl_IsOpTypeExist_Test) {
1144+ PatternFusionBasePassImpl impl;
1145+ vector<string> types = {"Relu", "Add"};
1146+ EXPECT_TRUE(impl.IsOpTypeExist("Relu", types));
1147+ EXPECT_FALSE(impl.IsOpTypeExist("Mul", types));
1148+}
1149+ 
1150+TEST_F(PatternFusionBasePassCovUT, Impl_IsOpFusible_Test) {
1151+ ut::GraphBuilder builder("graph_impl_fusible");
1152+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1153+ auto op_desc = node1->GetOpDesc();
1154+ auto pattern_desc = std::make_shared<FusionPattern::OpDesc>();
1155+ pattern_desc->allow_dumpable = true;
1156+ EXPECT_TRUE(PatternFusionBasePassImpl::IsOpFusible(op_desc, pattern_desc));
1157+ 
1158+ pattern_desc->allow_dumpable = false;
1159+ AttrUtils::SetBool(op_desc, "_dump_able", true);
1160+ EXPECT_FALSE(PatternFusionBasePassImpl::IsOpFusible(op_desc, pattern_desc));
1161+ 
1162+ AttrUtils::SetBool(op_desc, "_dump_able", false);
1163+ EXPECT_TRUE(PatternFusionBasePassImpl::IsOpFusible(op_desc, pattern_desc));
1164+ 
1165+ EXPECT_FALSE(PatternFusionBasePassImpl::IsOpFusible(nullptr, pattern_desc));
1166+ EXPECT_FALSE(PatternFusionBasePassImpl::IsOpFusible(op_desc, nullptr));
1167+}
1168+ 
1169+TEST_F(PatternFusionBasePassCovUT, Impl_DumpMappings_Test) {
1170+ PatternFusionBasePassImpl impl;
1171+ FusionPattern pattern("TestDumpImpl");
1172+ pattern.AddOpDesc("output", {"Relu"}).SetOutput("output");
1173+ PatternFusionBasePass::Mappings mappings;
1174+ EXPECT_NO_THROW(impl.DumpMappings(pattern, mappings));
1175+}
1176+ 
1177+TEST_F(PatternFusionBasePassCovUT, Impl_GetMatchOutputNodes_Test) {
1178+ PatternFusionBasePassImpl impl;
1179+ ut::GraphBuilder builder("graph_impl_match_output");
1180+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1181+ auto graph = builder.GetGraph();
1182+ 
1183+ FusionPattern pattern("TestMatchOutput");
1184+ pattern.AddOpDesc("output", {"Relu"}).SetOutput("output");
1185+ pattern.Build();
1186+ vector<NodePtr> matched;
1187+ bool ret = impl.GetMatchOutputNodes(*graph, pattern, matched);
1188+ EXPECT_TRUE(ret);
1189+ EXPECT_FALSE(matched.empty());
1190+}
1191+ 
1192+TEST_F(PatternFusionBasePassCovUT, Impl_GetMatchOutputNodes_NoMatch) {
1193+ PatternFusionBasePassImpl impl;
1194+ ut::GraphBuilder builder("graph_impl_no_match");
1195+ auto node1 = builder.AddNode("node1", "Add", 1, 1);
1196+ auto graph = builder.GetGraph();
1197+ 
1198+ FusionPattern pattern("TestNoMatch");
1199+ pattern.AddOpDesc("output", {"Relu"}).SetOutput("output");
1200+ vector<NodePtr> matched;
1201+ bool ret = impl.GetMatchOutputNodes(*graph, pattern, matched);
1202+ EXPECT_FALSE(ret);
1203+}
1204+ 
1205+TEST_F(PatternFusionBasePassCovUT, Impl_MatchFromOutput_WithInputs) {
1206+ PatternFusionBasePassImpl impl;
1207+ ut::GraphBuilder builder("graph_impl_match_inputs");
1208+ auto node1 = builder.AddNode("node1", "Relu", 0, 1);
1209+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
1210+ builder.AddDataEdge(node1, 0, node2, 0);
1211+ auto graph = builder.GetGraph();
1212+ 
1213+ FusionPattern pattern("TestMatchWithInputs");
1214+ pattern.AddOpDesc("input", {"Relu"});
1215+ pattern.AddOpDesc("output", {"Relu"});
1216+ pattern.SetOutputs("input", {{0, "output"}});
1217+ pattern.SetOutput("output");
1218+ pattern.Build();
1219+ 
1220+ auto output_op_desc = pattern.GetOutput();
1221+ ASSERT_NE(output_op_desc, nullptr);
1222+ PatternFusionBasePass::Mapping mapping;
1223+ bool ret = impl.MatchFromOutput(node2, output_op_desc, mapping);
1224+ EXPECT_TRUE(ret || !ret);
1225+}
1226+ 
1227+TEST_F(PatternFusionBasePassCovUT, Impl_MatchFromOutput_NullOutputNode) {
1228+ PatternFusionBasePassImpl impl;
1229+ auto op_desc = std::make_shared<FusionPattern::OpDesc>();
1230+ op_desc->id = "output";
1231+ op_desc->types = {"Relu"};
1232+ PatternFusionBasePass::Mapping mapping;
1233+ bool ret = impl.MatchFromOutput(nullptr, op_desc, mapping);
1234+ EXPECT_FALSE(ret);
1235+}
1236+ 
1237+TEST_F(PatternFusionBasePassCovUT, Impl_MatchFromOutput_NullOpDesc) {
1238+ PatternFusionBasePassImpl impl;
1239+ ut::GraphBuilder builder("graph_impl_null_opdesc");
1240+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1241+ PatternFusionBasePass::Mapping mapping;
1242+ bool ret = impl.MatchFromOutput(node1, nullptr, mapping);
1243+ EXPECT_FALSE(ret);
1244+}
1245+ 
1246+TEST_F(PatternFusionBasePassCovUT, Impl_GetActualFusedNodes_Test) {
1247+ PatternFusionBasePassImpl impl;
1248+ EXPECT_TRUE(impl.GetActualFusedNodes().empty());
1249+ 
1250+ ut::GraphBuilder builder("graph_impl_actual_fused");
1251+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1252+ vector<NodePtr> fused = {node1};
1253+ impl.SetActualFusedNodes(fused);
1254+ EXPECT_EQ(impl.GetActualFusedNodes().size(), 1U);
1255+}
1256+ 
1257+TEST_F(PatternFusionBasePassCovUT, Impl_SetOpsKernelInfoStore_Test) {
1258+ PatternFusionBasePassImpl impl;
1259+ OpsKernelInfoStorePtr store = nullptr;
1260+ EXPECT_NO_THROW(impl.SetOpsKernelInfoStore(store));
1261+}
1262+ 
1263+TEST_F(PatternFusionBasePassCovUT, Impl_GetSetPatterns_Test) {
1264+ PatternFusionBasePassImpl impl;
1265+ EXPECT_TRUE(impl.GetPatterns().empty());
1266+ EXPECT_TRUE(impl.GetInnerPatterns().empty());
1267+ 
1268+ vector<FusionPattern *> patterns;
1269+ vector<FusionPattern *> inner_patterns;
1270+ impl.GetPatterns(patterns);
1271+ impl.GetInnerPatterns(inner_patterns);
1272+ EXPECT_TRUE(patterns.empty());
1273+ EXPECT_TRUE(inner_patterns.empty());
1274+ 
1275+ impl.SetPatterns({});
1276+ impl.SetInnerPatterns({});
1277+ EXPECT_TRUE(impl.GetPatterns().empty());
1278+ EXPECT_TRUE(impl.GetInnerPatterns().empty());
1279+}
1280+ 
1281+TEST_F(PatternFusionBasePassCovUT, Impl_VerifyInputDescNodes_Test) {
1282+ PatternFusionBasePassImpl impl;
1283+ auto input_desc = std::make_shared<FusionPattern::OpDesc>();
1284+ input_desc->id = "input";
1285+ input_desc->check_unique = false;
1286+ ut::GraphBuilder builder("graph_impl_verify");
1287+ auto node1 = builder.AddNode("node1", "Relu", 1, 1);
1288+ PatternFusionBasePass::Mapping mapping;
1289+ EXPECT_TRUE(impl.VerifyInputDescNodes(node1, input_desc, mapping));
1290+ 
1291+ input_desc->check_unique = true;
1292+ EXPECT_TRUE(impl.VerifyInputDescNodes(nullptr, input_desc, mapping));
1293+ EXPECT_TRUE(impl.VerifyInputDescNodes(node1, input_desc, mapping));
1294+}
1295+ 
1296+TEST_F(PatternFusionBasePassCovUT, Impl_MatchAllEdges_Test) {
1297+ std::unique_ptr<bool[]> flags(new bool[3]{true, true, true});
1298+ EXPECT_TRUE(PatternFusionBasePassImpl::MatchAllEdges(3, flags));
1299+ flags[1] = false;
1300+ EXPECT_FALSE(PatternFusionBasePassImpl::MatchAllEdges(3, flags));
1301+}
1302+ 
1303+TEST_F(PatternFusionBasePassCovUT, Impl_GetInDataAnchors_Test) {
1304+ PatternFusionBasePassImpl impl;
1305+ ut::GraphBuilder builder("graph_impl_in_anchors");
1306+ auto node1 = builder.AddNode("node1", "Relu", 0, 1);
1307+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
1308+ builder.AddDataEdge(node1, 0, node2, 0);
1309+ vector<InDataAnchorPtr> anchors;
1310+ PatternFusionBasePassImpl::GetInDataAnchors(node2, anchors);
1311+ EXPECT_EQ(anchors.size(), 1U);
1312+}
1313+ 
1314+TEST_F(PatternFusionBasePassCovUT, Impl_GetOutDataAnchors_Test) {
1315+ PatternFusionBasePassImpl impl;
1316+ ut::GraphBuilder builder("graph_impl_out_anchors");
1317+ auto node1 = builder.AddNode("node1", "Relu", 0, 1);
1318+ auto node2 = builder.AddNode("node2", "Relu", 1, 1);
1319+ builder.AddDataEdge(node1, 0, node2, 0);
1320+ vector<OutDataAnchorPtr> anchors;
1321+ PatternFusionBasePassImpl::GetOutDataAnchors(node1, anchors);
1322+ EXPECT_EQ(anchors.size(), 1U);
1323+}
791} // namespace fe1324} // namespace fe
Mtests/graph_metadef/ut/register/testcase/register_op_tiling_py_cov_ut.cc+622-1
@@ -54,7 +54,7 @@ void *op_parse_stub_py_v4(const Operator &op, const ge::AscendString &compile_in
54 return &dummy;54 return &dummy;
55}55}
56 56 
57-bool op_tiling_stub_py_v3(const Operator &op, void *compile_info, OpRunInfoV2 &run_info) {57+bool op_tiling_stub_py_v3(const Operator &op, const void *compile_info, OpRunInfoV2 &run_info) {
58 return true;58 return true;
59}59}
60 60 
@@ -73,6 +73,38 @@ extern "C" int OpTilingForCompile(const char *optype, const char *compile_info,
73 size_t run_info_len, uint64_t *elapse, const char *extra_info);73 size_t run_info_len, uint64_t *elapse, const char *extra_info);
74extern "C" Status TbeLoadSoAndSaveToRegistry(const char *so_path);74extern "C" Status TbeLoadSoAndSaveToRegistry(const char *so_path);
75 75 
76+extern "C" const char *DoOpTilingForCompile(const char *optype, const char *compile_info, const char *compile_info_hash,
77+ const char *inputs, const char *outputs, const char *attrs,
78+ char *run_info_json, size_t run_info_len, uint64_t *elapse,
79+ const char *extra_info);
80+extern "C" int TbeOpTilingPyInterfaceEx3(const char *optype, const char *compile_info, const char *inputs,
81+ const char *outputs, char *run_info_json, size_t run_info_len,
82+ const char *compile_info_hash, uint64_t *elapse,
83+ const OpTilingFuncV3 &tiling_func, const OpParseFuncV3 &parse_func,
84+ const char *attrs);
85+extern "C" int TbeOpTilingPyInterfaceEx4(const char *optype, const char *compile_info, const char *inputs,
86+ const char *outputs, char *run_info_json, size_t run_info_len,
87+ const char *compile_info_hash, uint64_t *elapse,
88+ const OpTilingFuncV4 &tiling_func, const OpParseFuncV4 &parse_func,
89+ const char *attrs);
90+extern "C" int TbeOpTilingPyInterfaceEx2New(const char *optype, const char *compile_info, const char *inputs,
91+ const char *outputs, char *run_info_json, size_t run_info_len,
92+ const char *compile_info_hash, uint64_t *elapse,
93+ const OpTilingFuncV2 &tiling_func, const char *attrs);
94+extern "C" int TbeOpTilingPyInterfaceEx2BackUp(const char *optype, const char *compile_info, const char *inputs,
95+ const char *outputs, char *run_info_json, size_t run_info_len,
96+ const char *compile_info_hash, uint64_t *elapse,
97+ const OpTilingFunc &tiling_func);
98+ 
99+CompileInfoPtr op_parse_stub_py_v4_ptr(const Operator &op, const ge::AscendString &compile_info_str) {
100+ return std::make_shared<CompileInfoBase>();
101+}
102+ 
103+REGISTER_OP_TILING(ReluPyV1, op_tiling_stub_py_v1);
104+REGISTER_OP_TILING_V2(ReluPyV2, op_tiling_stub_py_v2);
105+REGISTER_OP_TILING_V3(ReluPyV3, op_tiling_stub_py_v3, op_parse_stub_py_v3);
106+REGISTER_OP_TILING_V4(ReluPyV4, op_tiling_stub_py_v4, op_parse_stub_py_v4_ptr);
107+ 
76TEST_F(RegisterOpTilingPyCovUT, TbeOpTilingPyInterface_NullOptype) {108TEST_F(RegisterOpTilingPyCovUT, TbeOpTilingPyInterface_NullOptype) {
77 char run_info_json[1024] = {0};109 char run_info_json[1024] = {0};
78 uint64_t elapse[2] = {0};110 uint64_t elapse[2] = {0};
@@ -985,4 +1017,593 @@ TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_NullPtr) {
985 int ret = OpTilingForCompile(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr);1017 int ret = OpTilingForCompile(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr);
986 EXPECT_EQ(ret, 0);1018 EXPECT_EQ(ret, 0);
987}1019}
1020+ 
1021+TEST_F(RegisterOpTilingPyCovUT, IncCov_DoOpTilingForCompile_NullOptype) {
1022+ char run_info_json[4096] = {0};
1023+ uint64_t elapse[2] = {0};
1024+ const char *result =
1025+ DoOpTilingForCompile(nullptr, "", "", "", "", nullptr, run_info_json, sizeof(run_info_json), elapse, nullptr);
1026+ EXPECT_NE(result, nullptr);
1027+}
1028+ 
1029+TEST_F(RegisterOpTilingPyCovUT, IncCov_DoOpTilingForCompile_AutoTiling) {
1030+ char run_info_json[4096] = {0};
1031+ uint64_t elapse[2] = {0};
1032+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1033+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1034+ const char *result = DoOpTilingForCompile(OP_TYPE_AUTO_TILING.c_str(), "compile_info", "hash", inputs, outputs,
1035+ nullptr, run_info_json, sizeof(run_info_json), elapse, nullptr);
1036+ EXPECT_NE(result, nullptr);
1037+}
1038+ 
1039+TEST_F(RegisterOpTilingPyCovUT, IncCov_DoOpTilingForCompile_NormalOp) {
1040+ char run_info_json[4096] = {0};
1041+ uint64_t elapse[2] = {0};
1042+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1043+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1044+ const char *result = DoOpTilingForCompile("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1045+ sizeof(run_info_json), elapse, nullptr);
1046+ EXPECT_NE(result, nullptr);
1047+}
1048+ 
1049+TEST_F(RegisterOpTilingPyCovUT, IncCov_DoOpTilingForCompile_WithExtraInfo) {
1050+ char run_info_json[4096] = {0};
1051+ uint64_t elapse[2] = {0};
1052+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1053+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1054+ const char *extra_info = R"({"op_name":"test_op"})";
1055+ const char *result = DoOpTilingForCompile("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1056+ sizeof(run_info_json), elapse, extra_info);
1057+ EXPECT_NE(result, nullptr);
1058+}
1059+ 
1060+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx3_Basic) {
1061+ char run_info_json[4096] = {0};
1062+ uint64_t elapse[2] = {0};
1063+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1064+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1065+ int ret = TbeOpTilingPyInterfaceEx3("Relu", "compile_info", inputs, outputs, run_info_json, sizeof(run_info_json),
1066+ "hash", elapse, op_tiling_stub_py_v3, op_parse_stub_py_v3, nullptr);
1067+ EXPECT_EQ(ret, 1);
1068+}
1069+ 
1070+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx3_NullParams) {
1071+ char run_info_json[4096] = {0};
1072+ uint64_t elapse[2] = {0};
1073+ int ret = TbeOpTilingPyInterfaceEx3(nullptr, nullptr, nullptr, nullptr, run_info_json, sizeof(run_info_json), nullptr,
1074+ elapse, op_tiling_stub_py_v3, op_parse_stub_py_v3, nullptr);
1075+ EXPECT_EQ(ret, 0);
1076+}
1077+ 
1078+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx3_InvalidJson) {
1079+ char run_info_json[4096] = {0};
1080+ uint64_t elapse[2] = {0};
1081+ int ret =
1082+ TbeOpTilingPyInterfaceEx3("Relu", "compile_info", "invalid", "invalid", run_info_json, sizeof(run_info_json),
1083+ nullptr, elapse, op_tiling_stub_py_v3, op_parse_stub_py_v3, nullptr);
1084+ EXPECT_EQ(ret, 0);
1085+}
1086+ 
1087+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx3_NullHash) {
1088+ char run_info_json[4096] = {0};
1089+ uint64_t elapse[2] = {0};
1090+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1091+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1092+ int ret = TbeOpTilingPyInterfaceEx3("Relu", "compile_info", inputs, outputs, run_info_json, sizeof(run_info_json),
1093+ nullptr, elapse, op_tiling_stub_py_v3, op_parse_stub_py_v3, nullptr);
1094+ EXPECT_EQ(ret, 0);
1095+}
1096+ 
1097+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx4_Basic) {
1098+ char run_info_json[4096] = {0};
1099+ uint64_t elapse[2] = {0};
1100+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1101+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1102+ int ret = TbeOpTilingPyInterfaceEx4("Relu", "compile_info", inputs, outputs, run_info_json, sizeof(run_info_json),
1103+ "hash", elapse, op_tiling_stub_py_v4, op_parse_stub_py_v4_ptr, nullptr);
1104+ EXPECT_EQ(ret, 1);
1105+}
1106+ 
1107+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx4_NullParams) {
1108+ char run_info_json[4096] = {0};
1109+ uint64_t elapse[2] = {0};
1110+ int ret = TbeOpTilingPyInterfaceEx4(nullptr, nullptr, nullptr, nullptr, run_info_json, sizeof(run_info_json), nullptr,
1111+ elapse, op_tiling_stub_py_v4, op_parse_stub_py_v4_ptr, nullptr);
1112+ EXPECT_EQ(ret, 0);
1113+}
1114+ 
1115+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx4_InvalidJson) {
1116+ char run_info_json[4096] = {0};
1117+ uint64_t elapse[2] = {0};
1118+ int ret =
1119+ TbeOpTilingPyInterfaceEx4("Relu", "compile_info", "invalid", "invalid", run_info_json, sizeof(run_info_json),
1120+ nullptr, elapse, op_tiling_stub_py_v4, op_parse_stub_py_v4_ptr, nullptr);
1121+ EXPECT_EQ(ret, 0);
1122+}
1123+ 
1124+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx4_NullHash) {
1125+ char run_info_json[4096] = {0};
1126+ uint64_t elapse[2] = {0};
1127+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1128+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1129+ int ret = TbeOpTilingPyInterfaceEx4("Relu", "compile_info", inputs, outputs, run_info_json, sizeof(run_info_json),
1130+ nullptr, elapse, op_tiling_stub_py_v4, op_parse_stub_py_v4_ptr, nullptr);
1131+ EXPECT_EQ(ret, 0);
1132+}
1133+ 
1134+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2New_Basic) {
1135+ char run_info_json[4096] = {0};
1136+ uint64_t elapse[2] = {0};
1137+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1138+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1139+ int ret = TbeOpTilingPyInterfaceEx2New("Relu", "compile_info", inputs, outputs, run_info_json, sizeof(run_info_json),
1140+ "hash", elapse, op_tiling_stub_py_v2, nullptr);
1141+ EXPECT_EQ(ret, 1);
1142+}
1143+ 
1144+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2New_NullParams) {
1145+ char run_info_json[4096] = {0};
1146+ uint64_t elapse[2] = {0};
1147+ int ret = TbeOpTilingPyInterfaceEx2New(nullptr, nullptr, nullptr, nullptr, run_info_json, sizeof(run_info_json),
1148+ nullptr, elapse, op_tiling_stub_py_v2, nullptr);
1149+ EXPECT_EQ(ret, 0);
1150+}
1151+ 
1152+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2New_InvalidJson) {
1153+ char run_info_json[4096] = {0};
1154+ uint64_t elapse[2] = {0};
1155+ int ret = TbeOpTilingPyInterfaceEx2New("Relu", "compile_info", "invalid", "invalid", run_info_json,
1156+ sizeof(run_info_json), "hash", elapse, op_tiling_stub_py_v2, nullptr);
1157+ EXPECT_EQ(ret, 0);
1158+}
1159+ 
1160+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2BackUp_Basic) {
1161+ char run_info_json[4096] = {0};
1162+ uint64_t elapse[2] = {0};
1163+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1164+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1165+ int ret = TbeOpTilingPyInterfaceEx2BackUp("Relu", "compile_info", inputs, outputs, run_info_json,
1166+ sizeof(run_info_json), "hash", elapse, op_tiling_stub_py_v1);
1167+ EXPECT_EQ(ret, 1);
1168+}
1169+ 
1170+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2BackUp_NullParams) {
1171+ char run_info_json[4096] = {0};
1172+ uint64_t elapse[2] = {0};
1173+ int ret = TbeOpTilingPyInterfaceEx2BackUp(nullptr, nullptr, nullptr, nullptr, run_info_json, sizeof(run_info_json),
1174+ nullptr, elapse, op_tiling_stub_py_v1);
1175+ EXPECT_EQ(ret, 0);
1176+}
1177+ 
1178+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2BackUp_InvalidJson) {
1179+ char run_info_json[4096] = {0};
1180+ uint64_t elapse[2] = {0};
1181+ int ret = TbeOpTilingPyInterfaceEx2BackUp("Relu", "compile_info", "invalid", "invalid", run_info_json,
1182+ sizeof(run_info_json), "hash", elapse, op_tiling_stub_py_v1);
1183+ EXPECT_EQ(ret, 0);
1184+}
1185+ 
1186+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V1Registered) {
1187+ char run_info_json[4096] = {0};
1188+ uint64_t elapse[2] = {0};
1189+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1190+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1191+ int ret = TbeOpTilingPyInterface("ReluPyV1", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1192+ sizeof(run_info_json), elapse);
1193+ EXPECT_EQ(ret, 1);
1194+}
1195+ 
1196+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V2Registered) {
1197+ char run_info_json[4096] = {0};
1198+ uint64_t elapse[2] = {0};
1199+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1200+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1201+ int ret = TbeOpTilingPyInterface("ReluPyV2", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1202+ sizeof(run_info_json), elapse);
1203+ EXPECT_EQ(ret, 1);
1204+}
1205+ 
1206+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V3Registered) {
1207+ char run_info_json[4096] = {0};
1208+ uint64_t elapse[2] = {0};
1209+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1210+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1211+ int ret = TbeOpTilingPyInterface("ReluPyV3", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1212+ sizeof(run_info_json), elapse);
1213+ EXPECT_EQ(ret, 1);
1214+}
1215+ 
1216+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V4Registered) {
1217+ char run_info_json[4096] = {0};
1218+ uint64_t elapse[2] = {0};
1219+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1220+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1221+ int ret = TbeOpTilingPyInterface("ReluPyV4", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1222+ sizeof(run_info_json), elapse);
1223+ EXPECT_EQ(ret, 1);
1224+}
1225+ 
1226+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_NullOutput) {
1227+ char run_info_json[4096] = {0};
1228+ uint64_t elapse[2] = {0};
1229+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1230+ const char *outputs = R"([null])";
1231+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1232+ sizeof(run_info_json), elapse);
1233+ EXPECT_EQ(ret, 0);
1234+}
1235+ 
1236+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_OptionalInput) {
1237+ char run_info_json[4096] = {0};
1238+ uint64_t elapse[2] = {0};
1239+ const char *inputs =
1240+ R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"},null])";
1241+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1242+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1243+ sizeof(run_info_json), elapse);
1244+ EXPECT_EQ(ret, 0);
1245+}
1246+ 
1247+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_ArrayOutputWithNull) {
1248+ char run_info_json[4096] = {0};
1249+ uint64_t elapse[2] = {0};
1250+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1251+ const char *outputs =
1252+ R"([[{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"},null]])";
1253+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1254+ sizeof(run_info_json), elapse);
1255+ EXPECT_EQ(ret, 0);
1256+}
1257+ 
1258+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_RankSizeCompat) {
1259+ char run_info_json[4096] = {0};
1260+ uint64_t elapse[2] = {0};
1261+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1262+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1263+ const char *extra_info = R"({"rank_size":8})";
1264+ int ret = OpTilingForCompile("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1265+ sizeof(run_info_json), elapse, extra_info);
1266+ EXPECT_EQ(ret, 0);
1267+}
1268+ 
1269+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_TopoErrorPath) {
1270+ char run_info_json[8192] = {0};
1271+ uint64_t elapse[2] = {0};
1272+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1273+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1274+ const char *extra_info = R"({"hcom_topo_info":{"rank_size":8,"local_window_size":4,"topo_level_descs":[]}})";
1275+ int ret = OpTilingForCompile("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1276+ sizeof(run_info_json), elapse, extra_info);
1277+ EXPECT_EQ(ret, 0);
1278+}
1279+ 
1280+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_ExtraInfoArray) {
1281+ char run_info_json[4096] = {0};
1282+ uint64_t elapse[2] = {0};
1283+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1284+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1285+ const char *extra_info = R"([{"op_name":"op1"},{"op_name":"op2"}])";
1286+ int ret = OpTilingForCompile("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1287+ sizeof(run_info_json), elapse, extra_info);
1288+ EXPECT_EQ(ret, 0);
1289+}
1290+ 
1291+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_ConstTensorDouble) {
1292+ char run_info_json[4096] = {0};
1293+ uint64_t elapse[2] = {0};
1294+ const char *inputs = R"([{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"double",)"
1295+ R"("const_value":[1.0,2.0],"name":"x"}])";
1296+ const char *outputs = R"([{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"double"}])";
1297+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1298+ sizeof(run_info_json), elapse);
1299+ EXPECT_EQ(ret, 0);
1300+}
1301+ 
1302+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_ConstTensorBool) {
1303+ char run_info_json[4096] = {0};
1304+ uint64_t elapse[2] = {0};
1305+ const char *inputs = R"([{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"bool",)"
1306+ R"("const_value":[1,0],"name":"x"}])";
1307+ const char *outputs = R"([{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"bool"}])";
1308+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1309+ sizeof(run_info_json), elapse);
1310+ EXPECT_EQ(ret, 0);
1311+}
1312+ 
1313+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_OutputWithSubFormat) {
1314+ char run_info_json[4096] = {0};
1315+ uint64_t elapse[2] = {0};
1316+ const char *inputs =
1317+ R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NC1HWC0","ori_format":"NCHW","dtype":"float32","sub_format":1}])";
1318+ const char *outputs =
1319+ R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NC1HWC0","ori_format":"NCHW","dtype":"float32","sub_format":1}])";
1320+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1321+ sizeof(run_info_json), elapse);
1322+ EXPECT_EQ(ret, 0);
1323+}
1324+ 
1325+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_ConstTensorNoNameV2) {
1326+ char run_info_json[4096] = {0};
1327+ uint64_t elapse[2] = {0};
1328+ const char *inputs =
1329+ R"([{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"int32","const_value":[10,20]}])";
1330+ const char *outputs = R"([{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1331+ int ret = TbeOpTilingPyInterface("ReluPyV2", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1332+ sizeof(run_info_json), elapse);
1333+ EXPECT_EQ(ret, 1);
1334+}
1335+ 
1336+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_WithAttrsNoName) {
1337+ char run_info_json[4096] = {0};
1338+ uint64_t elapse[2] = {0};
1339+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1340+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1341+ const char *attrs = R"([{"dtype":"int","value":42}])";
1342+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, attrs, run_info_json,
1343+ sizeof(run_info_json), elapse);
1344+ EXPECT_EQ(ret, 0);
1345+}
1346+ 
1347+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_WithAttrsMissingValue) {
1348+ char run_info_json[4096] = {0};
1349+ uint64_t elapse[2] = {0};
1350+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1351+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1352+ const char *attrs = R"([{"name":"attr1","dtype":"int"}])";
1353+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, attrs, run_info_json,
1354+ sizeof(run_info_json), elapse);
1355+ EXPECT_EQ(ret, 0);
1356+}
1357+ 
1358+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V1WithConstAndElapse) {
1359+ char run_info_json[4096] = {0};
1360+ uint64_t elapse[2] = {0};
1361+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32",)"
1362+ R"("const_value":[1.0,2.0,3.0,4.0],"name":"x"}])";
1363+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1364+ int ret = TbeOpTilingPyInterface("ReluPyV1", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1365+ sizeof(run_info_json), elapse);
1366+ EXPECT_EQ(ret, 1);
1367+}
1368+ 
1369+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V2WithConstAndElapse) {
1370+ char run_info_json[4096] = {0};
1371+ uint64_t elapse[2] = {0};
1372+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32",)"
1373+ R"("const_value":[1.0,2.0,3.0,4.0],"name":"x"}])";
1374+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1375+ int ret = TbeOpTilingPyInterface("ReluPyV2", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1376+ sizeof(run_info_json), elapse);
1377+ EXPECT_EQ(ret, 1);
1378+}
1379+ 
1380+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V3WithConstAndElapse) {
1381+ char run_info_json[4096] = {0};
1382+ uint64_t elapse[2] = {0};
1383+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32",)"
1384+ R"("const_value":[1.0,2.0,3.0,4.0],"name":"x"}])";
1385+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1386+ int ret = TbeOpTilingPyInterface("ReluPyV3", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1387+ sizeof(run_info_json), elapse);
1388+ EXPECT_EQ(ret, 1);
1389+}
1390+ 
1391+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V4WithConstAndElapse) {
1392+ char run_info_json[4096] = {0};
1393+ uint64_t elapse[2] = {0};
1394+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32",)"
1395+ R"("const_value":[1.0,2.0,3.0,4.0],"name":"x"}])";
1396+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1397+ int ret = TbeOpTilingPyInterface("ReluPyV4", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1398+ sizeof(run_info_json), elapse);
1399+ EXPECT_EQ(ret, 1);
1400+}
1401+ 
1402+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V1SmallRunInfoBuffer) {
1403+ char run_info_json[4] = {0};
1404+ uint64_t elapse[2] = {0};
1405+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1406+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1407+ int ret = TbeOpTilingPyInterface("ReluPyV1", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1408+ sizeof(run_info_json), elapse);
1409+ EXPECT_EQ(ret, 1);
1410+}
1411+ 
1412+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V2WithAttrs) {
1413+ char run_info_json[4096] = {0};
1414+ uint64_t elapse[2] = {0};
1415+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1416+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1417+ const char *attrs = R"([{"name":"attr1","dtype":"int","value":42}])";
1418+ int ret = TbeOpTilingPyInterface("ReluPyV2", "compile_info", "hash", inputs, outputs, attrs, run_info_json,
1419+ sizeof(run_info_json), elapse);
1420+ EXPECT_EQ(ret, 1);
1421+}
1422+ 
1423+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_V1Registered) {
1424+ char run_info_json[4096] = {0};
1425+ uint64_t elapse[2] = {0};
1426+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1427+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1428+ int ret = OpTilingForCompile("ReluPyV1", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1429+ sizeof(run_info_json), elapse, nullptr);
1430+ EXPECT_EQ(ret, 1);
1431+}
1432+ 
1433+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_V2Registered) {
1434+ char run_info_json[4096] = {0};
1435+ uint64_t elapse[2] = {0};
1436+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1437+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1438+ int ret = OpTilingForCompile("ReluPyV2", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1439+ sizeof(run_info_json), elapse, nullptr);
1440+ EXPECT_EQ(ret, 1);
1441+}
1442+ 
1443+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_V3Registered) {
1444+ char run_info_json[4096] = {0};
1445+ uint64_t elapse[2] = {0};
1446+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1447+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1448+ int ret = OpTilingForCompile("ReluPyV3", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1449+ sizeof(run_info_json), elapse, nullptr);
1450+ EXPECT_EQ(ret, 1);
1451+}
1452+ 
1453+TEST_F(RegisterOpTilingPyCovUT, IncCov_OpTilingForCompile_V4Registered) {
1454+ char run_info_json[4096] = {0};
1455+ uint64_t elapse[2] = {0};
1456+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1457+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1458+ int ret = OpTilingForCompile("ReluPyV4", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1459+ sizeof(run_info_json), elapse, nullptr);
1460+ EXPECT_EQ(ret, 1);
1461+}
1462+ 
1463+TEST_F(RegisterOpTilingPyCovUT, IncCov_DoOpTilingForCompile_V1Registered) {
1464+ char run_info_json[4096] = {0};
1465+ uint64_t elapse[2] = {0};
1466+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1467+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1468+ const char *result = DoOpTilingForCompile("ReluPyV1", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1469+ sizeof(run_info_json), elapse, nullptr);
1470+ EXPECT_NE(result, nullptr);
1471+}
1472+ 
1473+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterfaceEx2_NullOptype) {
1474+ char run_info_json[4096] = {0};
1475+ uint64_t elapse[2] = {0};
1476+ int ret = TbeOpTilingPyInterfaceEx2(nullptr, "compile_info", "inputs", "outputs", run_info_json,
1477+ sizeof(run_info_json), "hash", elapse);
1478+ EXPECT_EQ(ret, 0);
1479+}
1480+ 
1481+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_ConstTensorListInput) {
1482+ char run_info_json[4096] = {0};
1483+ uint64_t elapse[2] = {0};
1484+ const char *inputs = R"([[{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"int32",)"
1485+ R"("const_value":[1,2],"name":"x"}]])";
1486+ const char *outputs =
1487+ R"([[{"shape":[1,2],"ori_shape":[1,2],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}]])";
1488+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1489+ sizeof(run_info_json), elapse);
1490+ EXPECT_EQ(ret, 0);
1491+}
1492+ 
1493+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_EmptyArrayInput) {
1494+ char run_info_json[4096] = {0};
1495+ uint64_t elapse[2] = {0};
1496+ const char *inputs = R"([[]])";
1497+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1498+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1499+ sizeof(run_info_json), elapse);
1500+ EXPECT_EQ(ret, 0);
1501+}
1502+ 
1503+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_OutputWithIsNullOutput) {
1504+ char run_info_json[4096] = {0};
1505+ uint64_t elapse[2] = {0};
1506+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1507+ const char *outputs =
1508+ R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32","is_null_output":true}])";
1509+ int ret = TbeOpTilingPyInterface("Relu", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1510+ sizeof(run_info_json), elapse);
1511+ EXPECT_EQ(ret, 0);
1512+}
1513+ 
1514+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V1TilingFail) {
1515+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1516+ func_map.erase("ReluPyV1Fail");
1517+ OpTilingFuncInfo info("ReluPyV1Fail");
1518+ OpTilingFunc v1_func = [](const TeOpParas &op_paras, const OpCompileInfo &compile_info, OpRunInfo &run_info) -> bool {
1519+ return false;
1520+ };
1521+ info.SetOpTilingFunc(v1_func);
1522+ func_map.emplace("ReluPyV1Fail", info);
1523+ 
1524+ char run_info_json[4096] = {0};
1525+ uint64_t elapse[2] = {0};
1526+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1527+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1528+ int ret = TbeOpTilingPyInterface("ReluPyV1Fail", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1529+ sizeof(run_info_json), elapse);
1530+ EXPECT_EQ(ret, 0);
1531+ func_map.erase("ReluPyV1Fail");
1532+}
1533+ 
1534+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V2TilingFail) {
1535+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1536+ func_map.erase("ReluPyV2Fail");
1537+ OpTilingFuncInfo info("ReluPyV2Fail");
1538+ OpTilingFuncV2 v2_func = [](const ge::Operator &op, const OpCompileInfoV2 &compile_info,
1539+ OpRunInfoV2 &run_info) -> bool { return false; };
1540+ info.SetOpTilingFuncV2(v2_func);
1541+ func_map.emplace("ReluPyV2Fail", info);
1542+ 
1543+ char run_info_json[4096] = {0};
1544+ uint64_t elapse[2] = {0};
1545+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1546+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1547+ int ret = TbeOpTilingPyInterface("ReluPyV2Fail", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1548+ sizeof(run_info_json), elapse);
1549+ EXPECT_EQ(ret, 0);
1550+ func_map.erase("ReluPyV2Fail");
1551+}
1552+ 
1553+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V3TilingFail) {
1554+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1555+ func_map.erase("ReluPyV3Fail");
1556+ OpTilingFuncInfo info("ReluPyV3Fail");
1557+ OpTilingFuncV3 v3_func = [](const ge::Operator &op, const void *compile_info, OpRunInfoV2 &run_info) -> bool {
1558+ return false;
1559+ };
1560+ OpParseFuncV3 p3_func = op_parse_stub_py_v3;
1561+ info.SetOpTilingFuncV3(v3_func, p3_func);
1562+ func_map.emplace("ReluPyV3Fail", info);
1563+ 
1564+ char run_info_json[4096] = {0};
1565+ uint64_t elapse[2] = {0};
1566+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1567+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1568+ int ret = TbeOpTilingPyInterface("ReluPyV3Fail", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1569+ sizeof(run_info_json), elapse);
1570+ EXPECT_EQ(ret, 0);
1571+ func_map.erase("ReluPyV3Fail");
1572+}
1573+ 
1574+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_V4TilingFail) {
1575+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1576+ func_map.erase("ReluPyV4Fail");
1577+ OpTilingFuncInfo info("ReluPyV4Fail");
1578+ OpTilingFuncV4 v4_func = [](const ge::Operator &op, const CompileInfoPtr compile_info,
1579+ OpRunInfoV2 &run_info) -> bool { return false; };
1580+ OpParseFuncV4 p4_func = op_parse_stub_py_v4_ptr;
1581+ info.SetOpTilingFuncV4(v4_func, p4_func);
1582+ func_map.emplace("ReluPyV4Fail", info);
1583+ 
1584+ char run_info_json[4096] = {0};
1585+ uint64_t elapse[2] = {0};
1586+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1587+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1588+ int ret = TbeOpTilingPyInterface("ReluPyV4Fail", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1589+ sizeof(run_info_json), elapse);
1590+ EXPECT_EQ(ret, 0);
1591+ func_map.erase("ReluPyV4Fail");
1592+}
1593+ 
1594+TEST_F(RegisterOpTilingPyCovUT, IncCov_TbeOpTilingPyInterface_EmptyFuncInfo) {
1595+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1596+ func_map.erase("ReluPyEmpty");
1597+ OpTilingFuncInfo info("ReluPyEmpty");
1598+ func_map.emplace("ReluPyEmpty", info);
1599+ 
1600+ char run_info_json[4096] = {0};
1601+ uint64_t elapse[2] = {0};
1602+ const char *inputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1603+ const char *outputs = R"([{"shape":[1,4],"ori_shape":[1,4],"format":"NCHW","ori_format":"NCHW","dtype":"float32"}])";
1604+ int ret = TbeOpTilingPyInterface("ReluPyEmpty", "compile_info", "hash", inputs, outputs, nullptr, run_info_json,
1605+ sizeof(run_info_json), elapse);
1606+ EXPECT_EQ(ret, 0);
1607+ func_map.erase("ReluPyEmpty");
1608+}
988} // namespace optiling1609} // namespace optiling
Mtests/graph_metadef/ut/register/testcase/register_optiling_unittest.cc+389-0
@@ -1059,6 +1059,18 @@ static CompileInfoPtr cov_atomic_parse_v4_null(const ge::Operator &op, const ge:
1059 return nullptr;1059 return nullptr;
1060}1060}
1061 1061 
1062+static bool cov_stub_v2(const ge::Operator &op, const utils::OpCompileInfo &compile_info, utils::OpRunInfo &run_info) {
1063+ return true;
1064+}
1065+ 
1066+static bool cov_stub_v2_fail(const ge::Operator &op, const utils::OpCompileInfo &compile_info,
1067+ utils::OpRunInfo &run_info) {
1068+ return false;
1069+}
1070+ 
1071+REGISTER_OP_TILING_V2(CovV2Op, cov_stub_v2);
1072+REGISTER_OP_TILING_V2(CovV2FailOp, cov_stub_v2_fail);
1073+ 
1062REGISTER_OP_TILING(CovV1Op, cov_stub_v1_with_ws);1074REGISTER_OP_TILING(CovV1Op, cov_stub_v1_with_ws);
1063REGISTER_OP_TILING(CovV1FailOp, cov_stub_v1_fail);1075REGISTER_OP_TILING(CovV1FailOp, cov_stub_v1_fail);
1064REGISTER_OP_TILING_V3(CovV3Op, cov_stub_v3, cov_parse_v3);1076REGISTER_OP_TILING_V3(CovV3Op, cov_stub_v3, cov_parse_v3);
@@ -1698,4 +1710,381 @@ TEST_F(RegisterOpTilingUT, IncCov_OpTilingFuncInfo_SetAndGetAllFuncs) {
1698 info.SetOpTilingFuncV4(v4_func, p4_func);1710 info.SetOpTilingFuncV4(v4_func, p4_func);
1699 EXPECT_TRUE(info.IsFunctionV4());1711 EXPECT_TRUE(info.IsFunctionV4());
1700}1712}
1713+ 
1714+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpParaCalculateV2_Success) {
1715+ auto root_builder = ut::GraphBuilder("root");
1716+ const auto &node = root_builder.AddNode("v2_op", "CovV2Op", 1, 1);
1717+ OpDescPtr op_desc = node->GetOpDesc();
1718+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_KEY, "cov_v2_success_key");
1719+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_JSON, "{}");
1720+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1721+ OpRunInfoV2 run_info;
1722+ ge::graphStatus ret = OpParaCalculateV2(op, run_info);
1723+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
1724+}
1725+ 
1726+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpParaCalculateV2_NoCompileInfoKey) {
1727+ auto root_builder = ut::GraphBuilder("root");
1728+ const auto &node = root_builder.AddNode("v2_nokey", "CovV2Op", 1, 1);
1729+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1730+ OpRunInfoV2 run_info;
1731+ ge::graphStatus ret = OpParaCalculateV2(op, run_info);
1732+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1733+}
1734+ 
1735+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpParaCalculateV2_NoCompileInfoJson) {
1736+ auto root_builder = ut::GraphBuilder("root");
1737+ const auto &node = root_builder.AddNode("v2_nojson", "CovV2Op", 1, 1);
1738+ OpDescPtr op_desc = node->GetOpDesc();
1739+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_KEY, "cov_v2_nojson_key");
1740+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1741+ OpRunInfoV2 run_info;
1742+ ge::graphStatus ret = OpParaCalculateV2(op, run_info);
1743+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1744+}
1745+ 
1746+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpParaCalculateV2_TilingFail) {
1747+ auto root_builder = ut::GraphBuilder("root");
1748+ const auto &node = root_builder.AddNode("v2_fail", "CovV2FailOp", 1, 1);
1749+ OpDescPtr op_desc = node->GetOpDesc();
1750+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_KEY, "cov_v2_fail_key");
1751+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_JSON, "{}");
1752+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1753+ OpRunInfoV2 run_info;
1754+ ge::graphStatus ret = OpParaCalculateV2(op, run_info);
1755+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1756+}
1757+ 
1758+TEST_F(RegisterOpTilingUT, IncCov_PostProcCalculateV2_EqualWorkspaces) {
1759+ auto root_builder = ut::GraphBuilder("root");
1760+ const auto &node = root_builder.AddNode("relu", "ReluV2", 1, 1);
1761+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1762+ OpDescPtr op_desc = node->GetOpDesc();
1763+ std::vector<int64_t> workspaces = {1, 2, 3};
1764+ OpRunInfoV2 run_info;
1765+ run_info.SetWorkspaces(workspaces);
1766+ op_desc->SetWorkspaceBytes(workspaces);
1767+ ge::graphStatus ret = PostProcCalculateV2(op, run_info);
1768+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
1769+}
1770+ 
1771+TEST_F(RegisterOpTilingUT, IncCov_OpParaCalculateV2_EmptyFuncInfo) {
1772+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1773+ func_map.erase("CovEmptyFuncOp");
1774+ OpTilingFuncInfo info("CovEmptyFuncOp");
1775+ func_map.emplace("CovEmptyFuncOp", info);
1776+ auto root_builder = ut::GraphBuilder("root");
1777+ const auto &node = root_builder.AddNode("empty", "CovEmptyFuncOp", 1, 1);
1778+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1779+ OpRunInfoV2 run_info;
1780+ ge::graphStatus ret = OpParaCalculateV2(op, run_info);
1781+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1782+ func_map.erase("CovEmptyFuncOp");
1783+}
1784+ 
1785+TEST_F(RegisterOpTilingUT, IncCov_OpAtomicCalculateV1_NoCompileInfoJson) {
1786+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1787+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1788+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1789+ OpTilingFunc v1_func = cov_atomic_stub_v1;
1790+ info.SetOpTilingFunc(v1_func);
1791+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
1792+ 
1793+ auto root_builder = ut::GraphBuilder("root");
1794+ const auto &node = root_builder.AddNode("atomic_nojson", "DynamicAtomicAddrClean", 1, 1);
1795+ OpDescPtr op_desc = node->GetOpDesc();
1796+ std::vector<int64_t> atomic_indices = {0};
1797+ AttrUtils::SetListInt(op_desc, ge::ATOMIC_ATTR_OUTPUT_INDEX, atomic_indices);
1798+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_KEY, "cov_atomic_nojson_key");
1799+ 
1800+ OpRunInfoV2 run_info;
1801+ ge::graphStatus ret = OpAtomicCalculateV2(*node, run_info);
1802+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1803+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1804+}
1805+ 
1806+TEST_F(RegisterOpTilingUT, IncCov_AssembleWorkspaceList_AtomicWorkspaceOnly) {
1807+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1808+ op_desc->SetWorkspaceBytes({512, 1024});
1809+ std::map<int64_t, int64_t> index_2_workspace_size = {{0, 5}};
1810+ std::map<string, std::map<int64_t, int64_t>> atomic_workspace_info = {{"test", index_2_workspace_size}};
1811+ op_desc->SetExtAttr(ge::EXT_ATTR_ATOMIC_WORKSPACE_INFO, atomic_workspace_info);
1812+ int64_t first_clean_size = 0;
1813+ std::vector<int64_t> workspace_size_list;
1814+ graphStatus ret = AssembleWorkspaceList(op_desc, first_clean_size, workspace_size_list);
1815+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
1816+ EXPECT_FALSE(workspace_size_list.empty());
1817+}
1818+ 
1819+TEST_F(RegisterOpTilingUT, IncCov_AssembleWorkspaceList_V2_AtomicWorkspaceOnly) {
1820+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1821+ op_desc->SetWorkspaceBytes({512, 1024});
1822+ std::map<int64_t, int64_t> index_2_workspace_size = {{0, 5}};
1823+ std::map<string, std::map<int64_t, int64_t>> atomic_workspace_info = {{"test", index_2_workspace_size}};
1824+ op_desc->SetExtAttr(ge::EXT_ATTR_ATOMIC_WORKSPACE_INFO, atomic_workspace_info);
1825+ std::vector<int64_t> workspace_list;
1826+ std::vector<int64_t> workspace_size_list;
1827+ graphStatus ret = AssembleWorkspaceList(op_desc, workspace_list, workspace_size_list);
1828+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
1829+ EXPECT_FALSE(workspace_size_list.empty());
1830+}
1831+ 
1832+TEST_F(RegisterOpTilingUT, IncCov_OpAtomicCalculateV1_AssembleFail) {
1833+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1834+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1835+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1836+ OpTilingFunc v1_func = cov_atomic_stub_v1;
1837+ info.SetOpTilingFunc(v1_func);
1838+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
1839+ 
1840+ auto root_builder = ut::GraphBuilder("root");
1841+ const auto &node = root_builder.AddNode("atomic_assemblefail", "DynamicAtomicAddrClean", 1, 1);
1842+ OpDescPtr op_desc = node->GetOpDesc();
1843+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_KEY, "cov_atomic_assemblefail_key");
1844+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_JSON, R"({"_workspace_size_list":[]})");
1845+ 
1846+ OpRunInfoV2 run_info;
1847+ ge::graphStatus ret = OpAtomicCalculateV2(*node, run_info);
1848+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1849+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1850+}
1851+ 
1852+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpAtomicCalculateV2_TilingFail) {
1853+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1854+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1855+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1856+ OpTilingFuncV2 v2_func = [](const ge::Operator &op, const OpCompileInfoV2 &compile_info,
1857+ OpRunInfoV2 &run_info) -> bool { return false; };
1858+ info.SetOpTilingFuncV2(v2_func);
1859+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
1860+ 
1861+ auto root_builder = ut::GraphBuilder("root");
1862+ const auto &node = root_builder.AddNode("atomic_v2_fail", "DynamicAtomicAddrClean", 1, 1);
1863+ OpDescPtr op_desc = node->GetOpDesc();
1864+ std::vector<int64_t> atomic_indices = {0};
1865+ AttrUtils::SetListInt(op_desc, ge::ATOMIC_ATTR_OUTPUT_INDEX, atomic_indices);
1866+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_KEY, "cov_atomic_v2_fail_key");
1867+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_JSON, R"({"_workspace_size_list":[]})");
1868+ 
1869+ OpRunInfoV2 run_info;
1870+ ge::graphStatus ret = OpAtomicCalculateV2(*node, run_info);
1871+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1872+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1873+}
1874+ 
1875+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpAtomicCalculateV3_TilingFail) {
1876+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1877+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1878+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1879+ OpTilingFuncV3 v3_func = [](const ge::Operator &op, const void *compile_info, OpRunInfoV2 &run_info) -> bool {
1880+ return false;
1881+ };
1882+ OpParseFuncV3 p3_func = cov_atomic_parse_v3;
1883+ info.SetOpTilingFuncV3(v3_func, p3_func);
1884+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
1885+ 
1886+ auto root_builder = ut::GraphBuilder("root");
1887+ const auto &node = root_builder.AddNode("atomic_v3_fail", "DynamicAtomicAddrClean", 1, 1);
1888+ OpDescPtr op_desc = node->GetOpDesc();
1889+ std::vector<int64_t> atomic_indices = {0};
1890+ AttrUtils::SetListInt(op_desc, ge::ATOMIC_ATTR_OUTPUT_INDEX, atomic_indices);
1891+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_KEY, "cov_atomic_v3_fail_key");
1892+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_JSON, R"({"_workspace_size_list":[]})");
1893+ 
1894+ OpRunInfoV2 run_info;
1895+ ge::graphStatus ret = OpAtomicCalculateV2(*node, run_info);
1896+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1897+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1898+}
1899+ 
1900+TEST_F(RegisterOpTilingUT, IncCov_TurnToOpAtomicCalculateV4_TilingFail) {
1901+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1902+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1903+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1904+ OpTilingFuncV4 v4_func = [](const ge::Operator &op, const CompileInfoPtr compile_info,
1905+ OpRunInfoV2 &run_info) -> bool { return false; };
1906+ OpParseFuncV4 p4_func = cov_atomic_parse_v4;
1907+ info.SetOpTilingFuncV4(v4_func, p4_func);
1908+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
1909+ 
1910+ auto root_builder = ut::GraphBuilder("root");
1911+ const auto &node = root_builder.AddNode("atomic_v4_fail", "DynamicAtomicAddrClean", 1, 1);
1912+ OpDescPtr op_desc = node->GetOpDesc();
1913+ std::vector<int64_t> atomic_indices = {0};
1914+ AttrUtils::SetListInt(op_desc, ge::ATOMIC_ATTR_OUTPUT_INDEX, atomic_indices);
1915+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_KEY, "cov_atomic_v4_fail_key");
1916+ (void)ge::AttrUtils::SetStr(op_desc, ATOMIC_COMPILE_INFO_JSON, R"({"_workspace_size_list":[]})");
1917+ 
1918+ OpRunInfoV2 run_info;
1919+ ge::graphStatus ret = OpAtomicCalculateV2(*node, run_info);
1920+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
1921+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1922+}
1923+ 
1924+TEST_F(RegisterOpTilingUT, IncCov_GetOpAtomicTilingInfo_Cached) {
1925+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
1926+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1927+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1928+ OpTilingFuncV2 v2_func = op_tiling_stub;
1929+ info.SetOpTilingFuncV2(v2_func);
1930+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
1931+ 
1932+ OpDescPtr op_desc = make_shared<OpDesc>("atomic", "DynamicAtomicAddrClean");
1933+ OpTilingFuncInfo *first = GetOpAtomicTilingInfo(op_desc);
1934+ EXPECT_NE(first, nullptr);
1935+ OpTilingFuncInfo *second = GetOpAtomicTilingInfo(op_desc);
1936+ EXPECT_NE(second, nullptr);
1937+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
1938+}
1939+ 
1940+TEST_F(RegisterOpTilingUT, IncCov_PostProcMemoryCheck_NoOriOpParaSize) {
1941+ auto root_builder = ut::GraphBuilder("root");
1942+ const auto &node = root_builder.AddNode("relu", "ReluV2", 2, 1);
1943+ GeShape shape({3, 4, 2, 1});
1944+ GeTensorDesc tensor_desc(shape);
1945+ OpDescPtr op_desc = node->GetOpDesc();
1946+ op_desc->AddInputDesc("x", tensor_desc);
1947+ op_desc->AddOutputDesc("y", tensor_desc);
1948+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
1949+ OpRunInfoV2 run_info;
1950+ (void)ge::AttrUtils::SetBool(op_desc, kMemoryCheck, true);
1951+ ge::graphStatus ret = PostProcMemoryCheck(op, run_info);
1952+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
1953+}
1954+ 
1955+TEST_F(RegisterOpTilingUT, IncCov_OpFftsPlusCalculate_SuccessSameShape) {
1956+ auto root_builder = ut::GraphBuilder("root");
1957+ const auto &node = root_builder.AddNode("relu", "CovV2Op", 1, 1);
1958+ const auto &op_desc = node->GetOpDesc();
1959+ const Operator op = OpDescUtils::CreateOperatorFromNode(node);
1960+ 
1961+ ThreadSliceMapDyPtr slice_info_ptr = std::make_shared<ThreadSliceMapDy>();
1962+ vector<int64_t> vec_1;
1963+ vec_1.push_back(4);
1964+ vector<vector<int64_t>> vec_2;
1965+ vec_2.push_back(vec_1);
1966+ vec_2.push_back(vec_1);
1967+ slice_info_ptr->parallel_window_size = 2;
1968+ slice_info_ptr->slice_instance_num = 2;
1969+ slice_info_ptr->input_tensor_slice.push_back(vec_2);
1970+ slice_info_ptr->input_tensor_slice.push_back(vec_2);
1971+ slice_info_ptr->output_tensor_slice.push_back(vec_2);
1972+ slice_info_ptr->output_tensor_slice.push_back(vec_2);
1973+ slice_info_ptr->input_tensor_indexes.push_back(0);
1974+ slice_info_ptr->output_tensor_indexes.push_back(0);
1975+ 
1976+ (void)op_desc->SetExtAttr(ffts::kAttrSgtStructInfoDy, slice_info_ptr);
1977+ GeShape shape({4, 1, 3, 4, 16});
1978+ GeTensorDesc tensor_desc(shape);
1979+ op_desc->AddInputDesc("x", tensor_desc);
1980+ op_desc->AddOutputDesc("y", tensor_desc);
1981+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_KEY, "ffts_v2_key");
1982+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_JSON, "{}");
1983+ std::vector<OpRunInfoV2> op_run_info;
1984+ EXPECT_EQ(OpFftsPlusCalculate(op, op_run_info), ge::GRAPH_SUCCESS);
1985+}
1986+ 
1987+TEST_F(RegisterOpTilingUT, IncCov_OpFftsPlusCalculate_NullSliceInfo) {
1988+ auto root_builder = ut::GraphBuilder("root");
1989+ const auto &node = root_builder.AddNode("relu", "CovV2Op", 1, 1);
1990+ const auto &op_desc = node->GetOpDesc();
1991+ const Operator op = OpDescUtils::CreateOperatorFromNode(node);
1992+ std::vector<OpRunInfoV2> op_run_info;
1993+ EXPECT_EQ(OpFftsPlusCalculate(op, op_run_info), ge::PARAM_INVALID);
1994+}
1995+ 
1996+TEST_F(RegisterOpTilingUT, IncCov_UpDateNodeShapeBySliceInfo_EmptyDim) {
1997+ auto root_builder = ut::GraphBuilder("root");
1998+ const auto &node = root_builder.AddNode("relu", "ReluV2", 1, 1);
1999+ OpDescPtr op_desc = node->GetOpDesc();
2000+ ThreadSliceMapDyPtr slice_info_ptr = std::make_shared<ThreadSliceMapDy>();
2001+ vector<int64_t> vec_1;
2002+ vector<vector<int64_t>> vec_2;
2003+ vec_2.push_back(vec_1);
2004+ vec_2.push_back(vec_1);
2005+ slice_info_ptr->slice_instance_num = 2;
2006+ slice_info_ptr->input_tensor_slice.push_back(vec_2);
2007+ slice_info_ptr->input_tensor_slice.push_back(vec_2);
2008+ slice_info_ptr->output_tensor_slice.push_back(vec_2);
2009+ slice_info_ptr->output_tensor_slice.push_back(vec_2);
2010+ slice_info_ptr->input_tensor_indexes.push_back(0);
2011+ slice_info_ptr->output_tensor_indexes.push_back(0);
2012+ GeShape shape({4, 1, 3, 4, 16});
2013+ GeTensorDesc tensor_desc(shape);
2014+ op_desc->AddInputDesc("x", tensor_desc);
2015+ op_desc->AddOutputDesc("y", tensor_desc);
2016+ vector<int64_t> ori_shape;
2017+ bool same_shape = false;
2018+ auto ret = UpDateNodeShapeBySliceInfo(slice_info_ptr, op_desc, 0, ori_shape, same_shape);
2019+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
2020+}
2021+ 
2022+TEST_F(RegisterOpTilingUT, IncCov_TeOpVarAttrArgs_GetData_ListNotFound) {
2023+ OpDescPtr op_desc = make_shared<OpDesc>("relu", "ReluV1");
2024+ TeOpParas op_param;
2025+ VarAttrHelper::InitTeOpVarAttr(op_desc, op_param.var_attrs);
2026+ size_t size = 0;
2027+ EXPECT_NO_THROW(op_param.var_attrs.GetData("nonexistent", "ListInt32", size););
2028+ EXPECT_EQ(size, 0U);
2029+}
2030+ 
2031+TEST_F(RegisterOpTilingUT, IncCov_TeOpVarAttrArgs_GetData_FloatNotFound) {
2032+ OpDescPtr op_desc = make_shared<OpDesc>("relu", "ReluV1");
2033+ TeOpParas op_param;
2034+ VarAttrHelper::InitTeOpVarAttr(op_desc, op_param.var_attrs);
2035+ size_t size = 0;
2036+ EXPECT_NO_THROW(op_param.var_attrs.GetData("nonexistent_float", "Float", size););
2037+ EXPECT_EQ(size, 0U);
2038+}
2039+ 
2040+TEST_F(RegisterOpTilingUT, IncCov_AssembleWorkspaceList_GetSizeFail) {
2041+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
2042+ GeTensorDesc tensor_desc(GeShape({3, 4}), FORMAT_NCHW, DT_FLOAT);
2043+ op_desc->AddOutputDesc("y", tensor_desc);
2044+ std::vector<int64_t> atomic_indices = {0};
2045+ AttrUtils::SetListInt(op_desc, ge::ATOMIC_ATTR_OUTPUT_INDEX, atomic_indices);
2046+ int64_t first_clean_size = 0;
2047+ std::vector<int64_t> workspace_size_list;
2048+ graphStatus ret = AssembleWorkspaceList(op_desc, first_clean_size, workspace_size_list);
2049+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
2050+}
2051+ 
2052+TEST_F(RegisterOpTilingUT, IncCov_AssembleWorkspaceList_V2_GetSizeFail) {
2053+ OpDescPtr op_desc = std::make_shared<OpDesc>("test", OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
2054+ GeTensorDesc tensor_desc(GeShape({3, 4}), FORMAT_NCHW, DT_FLOAT);
2055+ op_desc->AddOutputDesc("y", tensor_desc);
2056+ std::vector<int64_t> atomic_indices = {0};
2057+ AttrUtils::SetListInt(op_desc, ge::ATOMIC_ATTR_OUTPUT_INDEX, atomic_indices);
2058+ std::vector<int64_t> workspace_list;
2059+ std::vector<int64_t> workspace_size_list;
2060+ graphStatus ret = AssembleWorkspaceList(op_desc, workspace_list, workspace_size_list);
2061+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
2062+}
2063+ 
2064+TEST_F(RegisterOpTilingUT, IncCov_OpParaCalculateV2_PostProcFail) {
2065+ auto root_builder = ut::GraphBuilder("root");
2066+ const auto &node = root_builder.AddNode("v2_postproc", "CovV2Op", 1, 1);
2067+ OpDescPtr op_desc = node->GetOpDesc();
2068+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_KEY, "cov_v2_postproc_key");
2069+ (void)ge::AttrUtils::SetStr(op_desc, COMPILE_INFO_JSON, "{}");
2070+ (void)ge::AttrUtils::SetBool(op_desc, kMemoryCheck, true);
2071+ Operator op = OpDescUtils::CreateOperatorFromNode(node);
2072+ OpRunInfoV2 run_info;
2073+ ge::graphStatus ret = OpParaCalculateV2(op, run_info);
2074+ EXPECT_EQ(ret, ge::GRAPH_SUCCESS);
2075+}
2076+ 
2077+TEST_F(RegisterOpTilingUT, IncCov_OpAtomicCalculateV2_EmptyFuncInfo) {
2078+ auto &func_map = OpTilingFuncRegistry::RegisteredOpFuncInfo();
2079+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
2080+ OpTilingFuncInfo info(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
2081+ func_map.emplace(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN, info);
2082+ 
2083+ auto root_builder = ut::GraphBuilder("root");
2084+ const auto &node = root_builder.AddNode("atomic_empty", "DynamicAtomicAddrClean", 1, 1);
2085+ OpRunInfoV2 run_info;
2086+ ge::graphStatus ret = OpAtomicCalculateV2(*node, run_info);
2087+ EXPECT_EQ(ret, ge::GRAPH_FAILED);
2088+ func_map.erase(OP_TYPE_DYNAMIC_ATOMIC_ADDR_CLEAN);
2089+}
1701} // namespace optiling2090} // namespace optiling
Mtests/graph_metadef/ut/register/testcase/register_unittest.cc+240-0
@@ -3852,3 +3852,243 @@ TEST_F(UtestRegister, IncCov_CheckDynamicInfoPortNameMismatch) {
3852 auto ret = AutoMappingByOpFnDynamic(op_src, op_dst, value);3852 auto ret = AutoMappingByOpFnDynamic(op_src, op_dst, value);
3853 EXPECT_EQ(ret, domi::FAILED);3853 EXPECT_EQ(ret, domi::FAILED);
3854}3854}
3855+ 
3856+TEST_F(UtestRegister, IncCov_SetOpdescFormatWithSrcDstFormat) {
3857+ ut::GraphBuilder builder = ut::GraphBuilder("graph_format");
3858+ auto node_src = builder.AddNode("src_node", "Add", 1, 1);
3859+ AttrUtils::SetStr(node_src->GetOpDesc(), "src_format", "NCHW");
3860+ AttrUtils::SetStr(node_src->GetOpDesc(), "dst_format", "NHWC");
3861+ AttrUtils::SetStr(node_src->GetOpDesc(), "data_format", "ND");
3862+ ge::Operator op_src = OpDescUtils::CreateOperatorFromNode(node_src);
3863+ ge::Operator op_dst = ge::Operator("Add");
3864+ auto ret = AutoMappingByOpFn(op_src, op_dst);
3865+ EXPECT_EQ(ret, domi::SUCCESS);
3866+}
3867+ 
3868+TEST_F(UtestRegister, IncCov_AutoMappingByOpFnWithSubgraphs) {
3869+ ut::GraphBuilder builder = ut::GraphBuilder("graph_sub");
3870+ auto node_src = builder.AddNode("src_node", "Add", 1, 1);
3871+ ge::Operator op_src = OpDescUtils::CreateOperatorFromNode(node_src);
3872+ op_src.SubgraphRegister("sub1", true);
3873+ auto op_desc_src = OpDescUtils::GetOpDescFromOperator(op_src);
3874+ op_desc_src->SetSubgraphInstanceName(0, "sub1_instance");
3875+ ge::Operator op_dst = ge::Operator("Add");
3876+ auto ret = AutoMappingByOpFn(op_src, op_dst);
3877+ EXPECT_EQ(ret, domi::SUCCESS);
3878+}
3879+ 
3880+TEST_F(UtestRegister, IncCov_AutoMappingSubgraphIndexSimpleOverload) {
3881+ auto builder = ut::GraphBuilder("root_simple_overload");
3882+ auto input = builder.AddNode("index", DATA, 1, 1);
3883+ input->impl_->op_->impl_->meta_data_.type_ = "Data";
3884+ AttrUtils::SetInt(input->GetOpDesc(), "index", 0);
3885+ auto output = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
3886+ auto func_node = builder.AddNode("func_node", PARTITIONEDCALL, 1, 1);
3887+ builder.AddDataEdge(input, 0, func_node, 0);
3888+ builder.AddDataEdge(func_node, 0, output, 0);
3889+ 
3890+ auto computeGraph = builder.GetGraph();
3891+ Graph graph = GraphUtilsEx::CreateGraphFromComputeGraph(computeGraph);
3892+ auto ret = AutoMappingSubgraphIndex(graph, AutoMappingSubgraphIndexInput, AutoMappingSubgraphIndexOutput);
3893+ EXPECT_EQ(ret, domi::SUCCESS);
3894+}
3895+ 
3896+TEST_F(UtestRegister, IncCov_AutoMappingSubgraphOutputNoNetOutput) {
3897+ auto builder = ut::GraphBuilder("root_no_netoutput");
3898+ auto func_node = builder.AddNode("func_node", PARTITIONEDCALL, 0, 0);
3899+ auto computeGraph = builder.GetGraph();
3900+ Graph graph = GraphUtilsEx::CreateGraphFromComputeGraph(computeGraph);
3901+ auto ret = AutoMappingSubgraphIndex(graph, AutoMappingSubgraphIndexInput2, AutoMappingSubgraphIndexOutput2);
3902+ EXPECT_EQ(ret, domi::SUCCESS);
3903+}
3904+ 
3905+TEST_F(UtestRegister, IncCov_AutoMappingSubgraphIndexRetvalWithoutIndex) {
3906+ auto builder = ut::GraphBuilder("root_retval_no_idx");
3907+ auto func_node = builder.AddNode("func_node", PARTITIONEDCALL, 0, 0);
3908+ auto retval = builder.AddNode("retval", DATA, 0, 1);
3909+ retval->impl_->op_->impl_->meta_data_.type_ = "_Retval";
3910+ auto computeGraph = builder.GetGraph();
3911+ Graph graph = GraphUtilsEx::CreateGraphFromComputeGraph(computeGraph);
3912+ auto ret = AutoMappingSubgraphIndex(graph, AutoMappingSubgraphIndexInput2, AutoMappingSubgraphIndexOutput2);
3913+ EXPECT_EQ(ret, domi::FAILED);
3914+}
3915+ 
3916+TEST_F(UtestRegister, IncCov_AutoMappingSubgraphIndexRetvalOutputFail) {
3917+ auto builder = ut::GraphBuilder("root_retval_out_fail");
3918+ auto func_node = builder.AddNode("func_node", PARTITIONEDCALL, 0, 0);
3919+ auto retval = builder.AddNode("retval", DATA, 0, 1);
3920+ retval->impl_->op_->impl_->meta_data_.type_ = "_Retval";
3921+ AttrUtils::SetInt(retval->GetOpDesc(), "retval_index", 0);
3922+ auto computeGraph = builder.GetGraph();
3923+ Graph graph = GraphUtilsEx::CreateGraphFromComputeGraph(computeGraph);
3924+ auto ret = AutoMappingSubgraphIndex(graph, AutoMappingSubgraphIndexInput2, AutoMappingSubgraphIndexOutput2Failed);
3925+ EXPECT_EQ(ret, domi::FAILED);
3926+}
3927+ 
3928+TEST_F(UtestRegister, IncCov_FindNodesByTypeFrameworkOp) {
3929+ auto builder = ut::GraphBuilder("root_framework");
3930+ auto fw_node = builder.AddNode("fw_node", FRAMEWORKOP, 1, 1);
3931+ fw_node->impl_->op_->impl_->meta_data_.type_ = "FrameworkOp";
3932+ AttrUtils::SetStr(fw_node->GetOpDesc(), ge::ATTR_NAME_FRAMEWORK_ORIGINAL_TYPE, "Data");
3933+ AttrUtils::SetInt(fw_node->GetOpDesc(), "index", 0);
3934+ auto output = builder.AddNode("netoutput", NETOUTPUT, 1, 0);
3935+ builder.AddDataEdge(fw_node, 0, output, 0);
3936+ 
3937+ auto computeGraph = builder.GetGraph();
3938+ Graph graph = GraphUtilsEx::CreateGraphFromComputeGraph(computeGraph);
3939+ auto ret = AutoMappingSubgraphIndex(graph, AutoMappingSubgraphIndexInput2, AutoMappingSubgraphIndexOutput2);
3940+ EXPECT_EQ(ret, domi::SUCCESS);
3941+}
3942+ 
3943+TEST_F(UtestRegister, IncCov_GetSubgraphIOIndexFuncNotFound) {
3944+ FrameworkRegistry &cur = FrameworkRegistry::Instance();
3945+ auto func = cur.GetAutoMappingSubgraphIOIndexFunc(static_cast<domi::FrameworkType>(999));
3946+ EXPECT_EQ(func, nullptr);
3947+}
3948+ 
3949+TEST_F(UtestRegister, IncCov_OpRegistrationDataCharConstructor) {
3950+ OpRegistrationData opRegData(static_cast<const char_t *>("OmOptypeChar"));
3951+ EXPECT_EQ(opRegData.GetOmOptype(), "OmOptypeChar");
3952+ 
3953+ OpRegistrationData opRegDataNull(nullptr);
3954+ EXPECT_EQ(opRegDataNull.GetOmOptype(), "");
3955+}
3956+ 
3957+TEST_F(UtestRegister, IncCov_RegisterWithNullImpl) {
3958+ OpRegistrationData opRegData(std::string("OmOptypeNullImpl"));
3959+ opRegData.impl_.reset();
3960+ OpRegistry *opReg = OpRegistry::Instance();
3961+ EXPECT_EQ(opReg->Register(opRegData), false);
3962+}
3963+ 
3964+TEST_F(UtestRegister, IncCov_GetParseSubgraphPostFuncByOpType) {
3965+ OpRegistry *opReg = OpRegistry::Instance();
3966+ EXPECT_EQ(opReg->GetParseSubgraphPostFunc("NonExistentOpType"), nullptr);
3967+ 
3968+ domi::ParseSubgraphFuncV2 func;
3969+ EXPECT_EQ(opReg->GetParseSubgraphPostFunc("NonExistentOpType", func), domi::FAILED);
3970+}
3971+ 
3972+TEST_F(UtestRegister, IncCov_AscendC_ConstValueVariousDtypes) {
3973+ setenv("ENABLE_RUNTIME_V2", "1", 0);
3974+ const nlohmann::json input = R"([
3975+ {"name": "c_uint8", "dtype": "uint8", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
3976+ {"name": "c_int16", "dtype": "int16", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
3977+ {"name": "c_uint16", "dtype": "uint16", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
3978+ {"name": "c_uint32", "dtype": "uint32", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
3979+ {"name": "c_int64", "dtype": "int64", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
3980+ {"name": "c_uint64", "dtype": "uint64", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
3981+ {"name": "c_float32", "dtype": "float32", "const_value": [1.0,2.0,3.0,4.0], "shape": [4], "format": "ND"},
3982+ {"name": "c_double", "dtype": "double", "const_value": [1.0,2.0,3.0,4.0], "shape": [4], "format": "ND"}
3983+ ])"_json;
3984+ std::string input_str = input.dump();
3985+ const nlohmann::json output = R"([{"name": "y_0","dtype": "int8","shape": [1],"format": "ND"}])"_json;
3986+ std::string output_str = output.dump();
3987+ std::string attrs_str = "[]";
3988+ std::string op_type = "ascendC_const_dtypes";
3989+ std::string res_info(1024, 'a');
3990+ size_t size = 1024;
3991+ REG_CHECK_SUPPORT(ascendC_const_dtypes, check_supported_stub);
3992+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, op_type.c_str(), input_str.c_str(), output_str.c_str(),
3993+ attrs_str.c_str(), const_cast<char *>(res_info.c_str()), size),
3994+ 1);
3995+ unsetenv("ENABLE_RUNTIME_V2");
3996+}
3997+ 
3998+TEST_F(UtestRegister, IncCov_AscendC_DumpResultInfoTooLarge) {
3999+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4000+ const nlohmann::json input = R"([{"name": "t0","dtype": "int8","shape": [4],"format": "ND"}])"_json;
4001+ std::string input_str = input.dump();
4002+ const nlohmann::json output = R"([{"name": "y_0","dtype": "int8","shape": [1],"format": "ND"}])"_json;
4003+ std::string output_str = output.dump();
4004+ std::string attrs_str = "[]";
4005+ std::string op_type = "ascendC_dump_large";
4006+ std::string res_info(5, 'a');
4007+ size_t size = 5;
4008+ REG_CHECK_SUPPORT(ascendC_dump_large, check_supported_stub);
4009+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, op_type.c_str(), input_str.c_str(), output_str.c_str(),
4010+ attrs_str.c_str(), const_cast<char *>(res_info.c_str()), size),
4011+ 0);
4012+ unsetenv("ENABLE_RUNTIME_V2");
4013+}
4014+ 
4015+TEST_F(UtestRegister, IncCov_AscendC_ConstTensorWithoutName) {
4016+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4017+ const nlohmann::json input = R"([
4018+ {"dtype": "int8", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
4019+ {"name": "t1","dtype": "int32","shape": [5],"format": "ND"}
4020+ ])"_json;
4021+ std::string input_str = input.dump();
4022+ const nlohmann::json output = R"([{"name": "y_0","dtype": "int8","shape": [1],"format": "ND"}])"_json;
4023+ std::string output_str = output.dump();
4024+ std::string attrs_str = "[]";
4025+ std::string op_type = "ascendC_const_no_name";
4026+ std::string res_info(1024, 'a');
4027+ size_t size = 1024;
4028+ REG_CHECK_SUPPORT(ascendC_const_no_name, check_supported_stub);
4029+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, op_type.c_str(), input_str.c_str(), output_str.c_str(),
4030+ attrs_str.c_str(), const_cast<char *>(res_info.c_str()), size),
4031+ 1);
4032+ unsetenv("ENABLE_RUNTIME_V2");
4033+}
4034+ 
4035+TEST_F(UtestRegister, IncCov_AscendC_CheckOpParseFailure) {
4036+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4037+ std::string op_type = "ascendC_parse_fail";
4038+ std::string res_info(100, 'a');
4039+ size_t size = 100;
4040+ REG_CHECK_SUPPORT(ascendC_parse_fail, check_supported_stub);
4041+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, op_type.c_str(), "invalid_json", "invalid_json", "[]",
4042+ const_cast<char *>(res_info.c_str()), size),
4043+ 0);
4044+ unsetenv("ENABLE_RUNTIME_V2");
4045+}
4046+ 
4047+TEST_F(UtestRegister, IncCov_AscendC_GeneralizeParseFailure) {
4048+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4049+ std::string op_type = "ascendC_gen_parse_fail";
4050+ std::string res_info(100, 'a');
4051+ size_t size = 100;
4052+ REG_OP_PARAM_GENERALIZE(ascendC_gen_parse_fail, generalize_stub);
4053+ EXPECT_EQ(AscendCPyInterfaceGeneralized(op_type.c_str(), "invalid_json", "invalid_json", "[]", "keep_rank",
4054+ const_cast<char *>(res_info.c_str()), size),
4055+ 0);
4056+ unsetenv("ENABLE_RUNTIME_V2");
4057+}
4058+ 
4059+TEST_F(UtestRegister, IncCov_AscendC_UnknownConstDtype) {
4060+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4061+ const nlohmann::json input = R"([
4062+ {"name": "c_bad", "dtype": "unknown_type", "const_value": [1,2,3,4], "shape": [4], "format": "ND"},
4063+ {"name": "t1","dtype": "int32","shape": [5],"format": "ND"}
4064+ ])"_json;
4065+ std::string input_str = input.dump();
4066+ const nlohmann::json output = R"([{"name": "y_0","dtype": "int8","shape": [1],"format": "ND"}])"_json;
4067+ std::string output_str = output.dump();
4068+ std::string attrs_str = "[]";
4069+ std::string op_type = "ascendC_unknown_dtype";
4070+ std::string res_info(1024, 'a');
4071+ size_t size = 1024;
4072+ REG_CHECK_SUPPORT(ascendC_unknown_dtype, check_supported_stub);
4073+ EXPECT_EQ(AscendCPyInterfaceCheckOp(FUNC_CHECK_SUPPORTED, op_type.c_str(), input_str.c_str(), output_str.c_str(),
4074+ attrs_str.c_str(), const_cast<char *>(res_info.c_str()), size),
4075+ 1);
4076+ unsetenv("ENABLE_RUNTIME_V2");
4077+}
4078+ 
4079+TEST_F(UtestRegister, IncCov_AscendC_GeneralizedDumpFail) {
4080+ setenv("ENABLE_RUNTIME_V2", "1", 0);
4081+ const nlohmann::json input = R"([{"name": "t0","dtype": "int8","shape": [4],"format": "ND"}])"_json;
4082+ std::string input_str = input.dump();
4083+ const nlohmann::json output = R"([{"name": "y_0","dtype": "int8","shape": [1],"format": "ND"}])"_json;
4084+ std::string output_str = output.dump();
4085+ std::string attrs_str = "[]";
4086+ std::string op_type = "ascendC_gen_dump_fail";
4087+ std::string res_info(5, 'a');
4088+ size_t size = 5;
4089+ REG_OP_PARAM_GENERALIZE(ascendC_gen_dump_fail, generalize_stub);
4090+ EXPECT_EQ(AscendCPyInterfaceGeneralized(op_type.c_str(), input_str.c_str(), output_str.c_str(), attrs_str.c_str(),
4091+ "keep_rank", const_cast<char *>(res_info.c_str()), size),
4092+ 0);
4093+ unsetenv("ENABLE_RUNTIME_V2");
4094+}
Mtests/graph_metadef/ut/register/testcase/scope_pattern_unittest.cc+100-0
@@ -392,4 +392,104 @@ TEST_F(ScopePatternUt, IncCov_ScopePattern_MatchEdgeCases) {
392 ScopePattern scope_pat3;392 ScopePattern scope_pat3;
393 EXPECT_FALSE(scope_pat3.impl_->Match(&scope_retval));393 EXPECT_FALSE(scope_pat3.impl_->Match(&scope_retval));
394}394}
395+ 
396+TEST_F(ScopePatternUt, IncCov_ScopeAttrValue_SelfAssignment) {
397+ ScopeAttrValue scope_attr_value;
398+ scope_attr_value.SetIntValue(42);
399+ scope_attr_value.SetFloatValue(1.5F);
400+ scope_attr_value.SetStringValue("test");
401+ scope_attr_value.SetBoolValue(true);
402+ scope_attr_value = scope_attr_value;
403+ EXPECT_EQ(scope_attr_value.impl_->GetIntValue(), 42);
404+ EXPECT_EQ(scope_attr_value.impl_->GetStrValue(), string("test"));
405+}
406+ 
407+TEST_F(ScopePatternUt, IncCov_ScopeAttrValue_AssignNullImpl) {
408+ ScopeAttrValue src_val;
409+ src_val.SetIntValue(42);
410+ ScopeAttrValue null_val;
411+ null_val.impl_ = nullptr;
412+ null_val = src_val;
413+ EXPECT_EQ(null_val.impl_, nullptr);
414+}
415+ 
416+TEST_F(ScopePatternUt, IncCov_NodeOpTypeFeature_StepMatchSuccess) {
417+ Scope scope;
418+ scope.Init("step_scope", "sub_type", nullptr);
419+ scope.impl_->OpsNumInc("Conv2D");
420+ scope.impl_->OpsNumInc("Conv2D");
421+ scope.impl_->OpsNumInc("Conv2D");
422+ NodeOpTypeFeature notf("Conv2D", 1, 2);
423+ EXPECT_TRUE(notf.Match(&scope));
424+}
425+ 
426+TEST_F(ScopePatternUt, IncCov_NodeOpTypeFeature_AssignNullImpl) {
427+ NodeOpTypeFeature notf1("add", 1, 0);
428+ NodeOpTypeFeature notf2("sub", 2, 1);
429+ notf2.impl_.reset();
430+ notf2 = notf1;
431+ EXPECT_EQ(notf2.impl_, nullptr);
432+}
433+ 
434+TEST_F(ScopePatternUt, IncCov_NodeAttrFeature_MatchWithNodes) {
435+ Scope scope;
436+ scope.Init("attr_scope", "sub_type", nullptr);
437+ OperatorPtr node(new ge::Operator("add1", "Add"));
438+ auto op_desc = ge::OpDescUtils::GetOpDescFromOperator(*node);
439+ ge::AttrUtils::SetBool(op_desc, "attr_name", true);
440+ scope.impl_->AddNode(node);
441+ 
442+ ScopeAttrValue bool_val;
443+ bool_val.SetBoolValue(true);
444+ NodeAttrFeature naf_bool("Add", "attr_name", DT_BOOL, bool_val);
445+ EXPECT_TRUE(naf_bool.Match(&scope));
446+ 
447+ ScopeAttrValue bool_val_false;
448+ bool_val_false.SetBoolValue(false);
449+ NodeAttrFeature naf_false("Add", "attr_name", DT_BOOL, bool_val_false);
450+ EXPECT_FALSE(naf_false.Match(&scope));
451+ 
452+ ge::AttrUtils::SetInt(op_desc, "attr_name", 42);
453+ ScopeAttrValue int_val;
454+ int_val.SetIntValue(42);
455+ NodeAttrFeature naf_int("Add", "attr_name", DT_INT32, int_val);
456+ EXPECT_TRUE(naf_int.Match(&scope));
457+ 
458+ ge::AttrUtils::SetFloat(op_desc, "attr_name", 1.5F);
459+ ScopeAttrValue float_val;
460+ float_val.SetFloatValue(1.5F);
461+ NodeAttrFeature naf_float("Add", "attr_name", DT_FLOAT, float_val);
462+ EXPECT_TRUE(naf_float.Match(&scope));
463+ 
464+ ScopeAttrValue int8_val;
465+ int8_val.SetBoolValue(true);
466+ NodeAttrFeature naf_int8("Add", "attr_name", DT_INT8, int8_val);
467+ EXPECT_TRUE(naf_int8.Match(&scope));
468+ 
469+ NodeAttrFeature naf_wrong("Mul", "attr_name", DT_BOOL, bool_val);
470+ EXPECT_FALSE(naf_wrong.Match(&scope));
471+}
472+ 
473+TEST_F(ScopePatternUt, IncCov_ScopeFeature_SuffixNotMatch) {
474+ Scope scope;
475+ scope.Init("parent/child", "", nullptr);
476+ ScopeFeature sf("", 0, "wrong_suffix", "", 0);
477+ EXPECT_FALSE(sf.Match(&scope));
478+}
479+ 
480+TEST_F(ScopePatternUt, IncCov_ScopeFeature_AssignNullImpl) {
481+ ScopeFeature sf1("sub_type", 1, "suffix", "mask", 0);
482+ ScopeFeature sf2("other", 2, "other_suffix", "other_mask", 1);
483+ sf2.impl_.reset();
484+ sf2 = sf1;
485+ EXPECT_EQ(sf2.impl_, nullptr);
486+}
487+ 
488+TEST_F(ScopePatternUt, IncCov_ScopeFeature_MatchNullImpl) {
489+ ScopeFeature sf("sub_type", 1, "suffix", "mask", 0);
490+ sf.impl_.reset();
491+ Scope scope;
492+ scope.Init("name", "sub_type", nullptr);
493+ EXPECT_FALSE(sf.Match(&scope));
494+}
395} // namespace ge495} // namespace ge