Star759
487
代码
代码
Issues35
Pull Requests120
Actions
项目讨论
Wiki
分析
Star759
487
已合并
feat: 增补UT覆盖率 #4126
likun104创建于 7月24日
feat: 增补UT覆盖率 #4126
已合并
likun104创建于 7月24日
从likun104/gebr_update_coverage_02合入到cann/gedevelop
共 29 个文件变更+4628-3
Mtests/dflow/udf/st/testcase/built_in/time_batch_flow_func_stest.cpp+1-1
@@ -479,7 +479,7 @@ TEST_F(TimeBatchFlowFuncSTest, timebatch_with_flag_and_batch_dim_3_drop_remainde
479 }479 }
480 std::vector<void *> outs_mbuf_ptr(in_out_num, nullptr);480 std::vector<void *> outs_mbuf_ptr(in_out_num, nullptr);
481 std::vector<bool> get_out(in_out_num, false);481 std::vector<bool> get_out(in_out_num, false);
482- constexpr uint64_t kMaxWaitInMs = 500;482+ constexpr uint64_t kMaxWaitInMs = 5 * 1000;
483 uint64_t wait_in_ms = 0;483 uint64_t wait_in_ms = 0;
484 int32_t get_out_num = 0;484 int32_t get_out_num = 0;
485 while (wait_in_ms < kMaxWaitInMs) {485 while (wait_in_ms < kMaxWaitInMs) {
Mtests/ge/ut/ge/common/dataslice_unittest.cc+269-0
@@ -527,4 +527,273 @@ TEST_F(DataSlice, ValidateAxisIndex_failed) {
527 const std::vector<std::vector<int64_t>> slice_info_new = {{1}};527 const std::vector<std::vector<int64_t>> slice_info_new = {{1}};
528 EXPECT_EQ(false, DataSliceAdapter::ValidateAxisIndex(from_axis_new, slice_info_new, to_axis, cur_tensor_range));528 EXPECT_EQ(false, DataSliceAdapter::ValidateAxisIndex(from_axis_new, slice_info_new, to_axis, cur_tensor_range));
529}529}
530+ 
531+TEST_F(DataSlice, Cov_PrintOp) {
532+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
533+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
534+ output_desc.SetOriginShape(ge::GeShape({10, 20}));
535+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
536+ ge::AttrUtils::SetStr(output_desc, ge::ATTR_NAME_RESHAPE_INFER_TYPE, "NH");
537+ op_desc->AddOutputDesc("output0", output_desc);
538+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
539+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
540+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
541+ ge::AttrUtils::SetStr(input_desc0, ge::ATTR_NAME_RESHAPE_INFER_TYPE, "NH");
542+ op_desc->AddInputDesc("input0", input_desc0);
543+ EXPECT_NO_THROW(DataSliceAdapter::PrintOp(op_desc));
544+}
545+ 
546+TEST_F(DataSlice, Cov_PrintAxis_WithOri) {
547+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
548+ op_desc->AddOutputDesc("output", GeTensorDesc());
549+ AxisTypeInfo info;
550+ info.SetAxisType(AxisType::ELEMENTWISE);
551+ info.SetRelateInputs({{0, {0}}});
552+ info.SetRelateOutputs({{0, {0}}});
553+ info.SetOriRelateInputs({{0, {1}}});
554+ info.SetOriRelateOutputs({{0, {1}}});
555+ EXPECT_NO_THROW(DataSliceAdapter::PrintAxis(op_desc, {info}, "test_type", true));
556+}
557+ 
558+TEST_F(DataSlice, Cov_PrintAxis_WithoutOri) {
559+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
560+ op_desc->AddOutputDesc("output", GeTensorDesc());
561+ AxisTypeInfo info;
562+ info.SetAxisType(AxisType::ELEMENTWISE);
563+ info.SetRelateInputs({{0, {0}}});
564+ info.SetRelateOutputs({{0, {0}}});
565+ EXPECT_NO_THROW(DataSliceAdapter::PrintAxis(op_desc, {info}, "test_type", false));
566+}
567+ 
568+TEST_F(DataSlice, Cov_PrintSlice) {
569+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
570+ op_desc->AddOutputDesc("output", GeTensorDesc());
571+ DataSliceAdapter::DataSliceType slice_info = {{{0, 10}, {20, 30}}, {{0, 5}}};
572+ EXPECT_NO_THROW(DataSliceAdapter::PrintSlice(op_desc, slice_info, "input", "test_tag"));
573+}
574+ 
575+TEST_F(DataSlice, Cov_PrintSlice_Empty) {
576+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
577+ op_desc->AddOutputDesc("output", GeTensorDesc());
578+ DataSliceAdapter::DataSliceType slice_info;
579+ EXPECT_NO_THROW(DataSliceAdapter::PrintSlice(op_desc, slice_info, "output", "empty_tag"));
580+}
581+ 
582+TEST_F(DataSlice, Cov_CheckOriInfo_True) {
583+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
584+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
585+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
586+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
587+ op_desc->AddOutputDesc("output0", output_desc);
588+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
589+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
590+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
591+ op_desc->AddInputDesc("input0", input_desc0);
592+ EXPECT_TRUE(DataSliceAdapter::CheckOriInfo(op_desc));
593+}
594+ 
595+TEST_F(DataSlice, Cov_CheckOriInfo_False_NoOrigin) {
596+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
597+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
598+ op_desc->AddOutputDesc("output0", output_desc);
599+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
600+ op_desc->AddInputDesc("input0", input_desc0);
601+ EXPECT_FALSE(DataSliceAdapter::CheckOriInfo(op_desc));
602+}
603+ 
604+TEST_F(DataSlice, Cov_TransAxisInfo_Elementwise) {
605+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
606+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
607+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
608+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
609+ op_desc->AddOutputDesc("output0", output_desc);
610+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
611+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
612+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
613+ op_desc->AddInputDesc("input0", input_desc0);
614+ std::vector<AxisTypeInfo> axis_type_vec;
615+ AxisTypeInfo info;
616+ info.SetAxisType(AxisType::ELEMENTWISE);
617+ info.SetRelateInputs({{0, {1}}});
618+ info.SetRelateOutputs({{0, {1}}});
619+ axis_type_vec.push_back(info);
620+ EXPECT_NO_THROW(DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec));
621+}
622+ 
623+TEST_F(DataSlice, Cov_TransAxisInfo_ReduceMean) {
624+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
625+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
626+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
627+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
628+ op_desc->AddOutputDesc("output0", output_desc);
629+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
630+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
631+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
632+ op_desc->AddInputDesc("input0", input_desc0);
633+ std::vector<AxisTypeInfo> axis_type_vec;
634+ AxisTypeInfo info;
635+ info.SetAxisType(AxisType::REDUCEMEAN);
636+ info.SetRelateInputs({{0, {1}}});
637+ info.SetRelateOutputs({{0, {1}}});
638+ axis_type_vec.push_back(info);
639+ EXPECT_NO_THROW(DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec));
640+}
641+ 
642+TEST_F(DataSlice, Cov_TransAxisInfo_SlidingWindow) {
643+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
644+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
645+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
646+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
647+ op_desc->AddOutputDesc("output0", output_desc);
648+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
649+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
650+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
651+ op_desc->AddInputDesc("input0", input_desc0);
652+ std::vector<AxisTypeInfo> axis_type_vec;
653+ AxisTypeInfo info;
654+ info.SetAxisType(AxisType::SLIDINGWINDOW);
655+ info.SetRelateInputs({{0, {1}}});
656+ info.SetRelateOutputs({{0, {1}}});
657+ axis_type_vec.push_back(info);
658+ EXPECT_NO_THROW(DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec));
659+}
660+ 
661+TEST_F(DataSlice, Cov_TransAxisInfo_Unsplit) {
662+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
663+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
664+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
665+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
666+ op_desc->AddOutputDesc("output0", output_desc);
667+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
668+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
669+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
670+ op_desc->AddInputDesc("input0", input_desc0);
671+ std::vector<AxisTypeInfo> axis_type_vec;
672+ AxisTypeInfo info;
673+ info.SetAxisType(AxisType::UNSPLIT);
674+ info.SetRelateInputs({{0, {1}}});
675+ info.SetRelateOutputs({{0, {1}}});
676+ axis_type_vec.push_back(info);
677+ EXPECT_NO_THROW(DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec));
678+}
679+ 
680+TEST_F(DataSlice, Cov_TransAxisInfo_UnknownType) {
681+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
682+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
683+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
684+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
685+ op_desc->AddOutputDesc("output0", output_desc);
686+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
687+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
688+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
689+ op_desc->AddInputDesc("input0", input_desc0);
690+ std::vector<AxisTypeInfo> axis_type_vec;
691+ AxisTypeInfo info;
692+ info.SetAxisType(static_cast<AxisType>(999));
693+ info.SetRelateInputs({{0, {1}}});
694+ info.SetRelateOutputs({{0, {1}}});
695+ axis_type_vec.push_back(info);
696+ EXPECT_NO_THROW(DataSliceAdapter::TransAxisInfo(op_desc, axis_type_vec));
697+}
698+ 
699+TEST_F(DataSlice, Cov_GetOriOutputSlice) {
700+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
701+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
702+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
703+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
704+ op_desc->AddOutputDesc("output0", output_desc);
705+ AxisTypeInfo info;
706+ info.SetAxisType(AxisType::ELEMENTWISE);
707+ info.SetOriRelateInputs({{0, {0}}});
708+ info.SetOriRelateOutputs({{0, {0}}});
709+ DataSliceAdapter::DataSliceType ori_output_slice;
710+ auto ret = DataSliceAdapter::GetOriOutputSlice(op_desc, info, ori_output_slice);
711+ EXPECT_EQ(ret, SUCCESS);
712+}
713+ 
714+TEST_F(DataSlice, Cov_GetCurInputSlice) {
715+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
716+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
717+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
718+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
719+ op_desc->AddInputDesc("input0", input_desc0);
720+ AxisTypeInfo info;
721+ info.SetAxisType(AxisType::ELEMENTWISE);
722+ info.SetOriRelateInputs({{0, {0}}});
723+ info.SetOriRelateOutputs({{0, {0}}});
724+ DataSliceAdapter::DataSliceType ori_input_slice;
725+ DataSliceAdapter::DataSliceType cur_input_slice;
726+ auto ret = DataSliceAdapter::GetCurInputSlice(op_desc, info, ori_input_slice, cur_input_slice);
727+ EXPECT_EQ(ret, SUCCESS);
728+}
729+ 
730+TEST_F(DataSlice, Cov_SetOriOpInfoAndSetCurOpInfo) {
731+ OpDescPtr op_desc = std::make_shared<OpDesc>("Add", "Add");
732+ GeTensorDesc output_desc(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
733+ output_desc.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
734+ output_desc.SetOriginFormat(ge::Format::FORMAT_NHWC);
735+ op_desc->AddOutputDesc("output0", output_desc);
736+ GeTensorDesc input_desc0(ge::GeShape({10, 3, 20, 30, 16}), ge::Format::FORMAT_NC1HWC0);
737+ input_desc0.SetOriginShape(ge::GeShape({10, 20, 30, 40}));
738+ input_desc0.SetOriginFormat(ge::Format::FORMAT_NHWC);
739+ op_desc->AddInputDesc("input0", input_desc0);
740+ std::vector<std::pair<Format, GeShape>> cache_input_info;
741+ std::vector<std::pair<Format, GeShape>> cache_output_info;
742+ EXPECT_NO_THROW(DataSliceAdapter::SetOriOpInfo(op_desc, cache_input_info, cache_output_info));
743+ EXPECT_NO_THROW(DataSliceAdapter::SetCurOpInfo(op_desc, cache_input_info, cache_output_info));
744+}
745+ 
746+TEST_F(DataSlice, Cov_GetTmpAxisTypeInfo) {
747+ AxisTypeInfo info;
748+ info.SetAxisType(AxisType::ELEMENTWISE);
749+ info.SetRelateInputs({{0, {0}}});
750+ info.SetRelateOutputs({{0, {0}}});
751+ info.SetOriRelateInputs({{0, {1}}});
752+ info.SetOriRelateOutputs({{0, {1}}});
753+ auto tmp = DataSliceAdapter::GetTmpAxisTypeInfo(info);
754+ EXPECT_EQ(tmp.GetAxisType(), AxisType::ELEMENTWISE);
755+}
756+ 
757+TEST_F(DataSlice, Cov_DataSliceHelper_InferAxisSlice_Unsplit) {
758+ OpDescPtr op_desc = std::make_shared<OpDesc>("Cast", "Cast");
759+ op_desc->AddOutputDesc("output", GeTensorDesc());
760+ op_desc->AddInputDesc("input", GeTensorDesc());
761+ AxisTypeInfo axis_type_info;
762+ axis_type_info.SetAxisType(AxisType::UNSPLIT);
763+ CutInfo input_cut_info{0, {0}};
764+ axis_type_info.AddInputCutInfo(input_cut_info);
765+ CutInfo output_cut_info{0, {0}};
766+ axis_type_info.AddOutputCutInfo(output_cut_info);
767+ Status ret = DataSliceHelper::InferAxisSlice(op_desc, axis_type_info);
768+ EXPECT_EQ(ret, SUCCESS);
769+}
770+ 
771+TEST_F(DataSlice, Cov_DataSliceElementwiseImpl_EmptyOutput) {
772+ OpDescPtr op_desc = std::make_shared<OpDesc>("Cast", "Cast");
773+ op_desc->AddOutputDesc("output", GeTensorDesc());
774+ op_desc->AddInputDesc("input", GeTensorDesc());
775+ AxisTypeInfo axis_type_info;
776+ axis_type_info.SetAxisType(AxisType::ELEMENTWISE);
777+ CutInfo input_cut_info{0, {0}};
778+ axis_type_info.AddInputCutInfo(input_cut_info);
779+ CutInfo output_cut_info{0, {0}};
780+ axis_type_info.AddOutputCutInfo(output_cut_info);
781+ DataSliceType out_data_slice;
782+ DataSliceType in_data_slice;
783+ Operator op_proxy = OpDescUtils::CreateOperatorFromOpDesc(op_desc);
784+ DataSliceElementwiseImpl impl;
785+ auto ret = impl.InferAxisSlice(op_proxy, axis_type_info, out_data_slice, in_data_slice);
786+ EXPECT_NE(ret, SUCCESS);
787+}
788+ 
789+TEST_F(DataSlice, Cov_DataSliceElementwiseImpl_NullOpDesc) {
790+ OpDescPtr null_op_desc = nullptr;
791+ AxisTypeInfo axis_type_info;
792+ DataSliceType out_data_slice;
793+ DataSliceType in_data_slice;
794+ DataSliceElementwiseImpl impl;
795+ Operator op_proxy;
796+ auto ret = impl.InferAxisSlice(op_proxy, axis_type_info, out_data_slice, in_data_slice);
797+ EXPECT_NE(ret, SUCCESS);
798+}
530} // namespace ge799} // namespace ge
Mtests/ge/ut/ge/graph/passes/folding_kernel/gather_v2_kernel_unittest.cc+102-0
@@ -1118,3 +1118,105 @@ TEST_F(UtestGraphPassesFoldingKernelGatherV2Kernel, AxisNotScalarFail) {
1118 ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);1118 ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);
1119 EXPECT_NE(ge::SUCCESS, status);1119 EXPECT_NE(ge::SUCCESS, status);
1120}1120}
1121+ 
1122+TEST_F(UtestGraphPassesFoldingKernelGatherV2Kernel, CovAxisInvalidDataType) {
1123+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("GatherV2", "GatherV2");
1124+ 
1125+ vector<int64_t> x_shape = {3};
1126+ vector<int64_t> indices_shape = {2};
1127+ GeTensorDesc tensor_desc_x(GeShape(x_shape), FORMAT_NHWC, DT_INT32);
1128+ GeTensorDesc tensor_desc_indices(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1129+ GeTensorDesc tensor_desc_axis(GeShape(), FORMAT_NHWC, DT_FLOAT);
1130+ 
1131+ op_desc_ptr->AddInputDesc(0, tensor_desc_x);
1132+ op_desc_ptr->AddInputDesc(1, tensor_desc_indices);
1133+ op_desc_ptr->AddInputDesc(2, tensor_desc_axis);
1134+ 
1135+ vector<int32_t> data_vec_0 = {1, 2, 3};
1136+ vector<int32_t> data_vec_1 = {0, 1};
1137+ vector<float> axis_vec = {0.0f};
1138+ GeTensorDesc tensor_desc_0(GeShape(x_shape), FORMAT_NHWC, DT_INT32);
1139+ GeTensorDesc tensor_desc_1(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1140+ GeTensorDesc tensor_desc_2(GeShape(), FORMAT_NHWC, DT_FLOAT);
1141+ ConstGeTensorPtr tensor_0 =
1142+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
1143+ ConstGeTensorPtr tensor_1 =
1144+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
1145+ ConstGeTensorPtr tensor_2 =
1146+ std::make_shared<GeTensor>(tensor_desc_2, (uint8_t *)axis_vec.data(), axis_vec.size() * sizeof(float));
1147+ 
1148+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2};
1149+ vector<GeTensorPtr> outputs;
1150+ 
1151+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(GATHERV2);
1152+ ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);
1153+ EXPECT_NE(ge::SUCCESS, status);
1154+}
1155+ 
1156+TEST_F(UtestGraphPassesFoldingKernelGatherV2Kernel, CovAxisExceedFourDims) {
1157+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("GatherV2", "GatherV2");
1158+ 
1159+ vector<int64_t> x_shape = {2, 2, 2, 2, 3};
1160+ vector<int64_t> indices_shape = {2};
1161+ GeTensorDesc tensor_desc_x(GeShape(x_shape), FORMAT_NHWC, DT_INT32);
1162+ GeTensorDesc tensor_desc_indices(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1163+ GeTensorDesc tensor_desc_axis(GeShape(), FORMAT_NHWC, DT_INT32);
1164+ 
1165+ op_desc_ptr->AddInputDesc(0, tensor_desc_x);
1166+ op_desc_ptr->AddInputDesc(1, tensor_desc_indices);
1167+ op_desc_ptr->AddInputDesc(2, tensor_desc_axis);
1168+ 
1169+ vector<int32_t> data_vec_0(48, 1);
1170+ vector<int32_t> data_vec_1 = {0, 1};
1171+ vector<int32_t> axis_vec = {4};
1172+ GeTensorDesc tensor_desc_0(GeShape(x_shape), FORMAT_NHWC, DT_INT32);
1173+ GeTensorDesc tensor_desc_1(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1174+ GeTensorDesc tensor_desc_2(GeShape(), FORMAT_NHWC, DT_INT32);
1175+ ConstGeTensorPtr tensor_0 =
1176+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
1177+ ConstGeTensorPtr tensor_1 =
1178+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
1179+ ConstGeTensorPtr tensor_2 =
1180+ std::make_shared<GeTensor>(tensor_desc_2, (uint8_t *)axis_vec.data(), axis_vec.size() * sizeof(int32_t));
1181+ 
1182+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2};
1183+ vector<GeTensorPtr> outputs;
1184+ 
1185+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(GATHERV2);
1186+ ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);
1187+ EXPECT_NE(ge::SUCCESS, status);
1188+}
1189+ 
1190+TEST_F(UtestGraphPassesFoldingKernelGatherV2Kernel, CovOutputZeroDim) {
1191+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("GatherV2", "GatherV2");
1192+ 
1193+ vector<int64_t> x_shape = {3, 0};
1194+ vector<int64_t> indices_shape = {1};
1195+ GeTensorDesc tensor_desc_x(GeShape(x_shape), FORMAT_NHWC, DT_INT32);
1196+ GeTensorDesc tensor_desc_indices(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1197+ GeTensorDesc tensor_desc_axis(GeShape(), FORMAT_NHWC, DT_INT32);
1198+ 
1199+ op_desc_ptr->AddInputDesc(0, tensor_desc_x);
1200+ op_desc_ptr->AddInputDesc(1, tensor_desc_indices);
1201+ op_desc_ptr->AddInputDesc(2, tensor_desc_axis);
1202+ 
1203+ vector<int32_t> data_vec_0 = {1, 2, 3, 4, 5, 6};
1204+ vector<int32_t> data_vec_1 = {0};
1205+ vector<int32_t> axis_vec = {0};
1206+ GeTensorDesc tensor_desc_0(GeShape(x_shape), FORMAT_NHWC, DT_INT32);
1207+ GeTensorDesc tensor_desc_1(GeShape(indices_shape), FORMAT_NHWC, DT_INT32);
1208+ GeTensorDesc tensor_desc_2(GeShape(), FORMAT_NHWC, DT_INT32);
1209+ ConstGeTensorPtr tensor_0 =
1210+ std::make_shared<GeTensor>(tensor_desc_0, (uint8_t *)data_vec_0.data(), data_vec_0.size() * sizeof(int32_t));
1211+ ConstGeTensorPtr tensor_1 =
1212+ std::make_shared<GeTensor>(tensor_desc_1, (uint8_t *)data_vec_1.data(), data_vec_1.size() * sizeof(int32_t));
1213+ ConstGeTensorPtr tensor_2 =
1214+ std::make_shared<GeTensor>(tensor_desc_2, (uint8_t *)axis_vec.data(), axis_vec.size() * sizeof(int32_t));
1215+ 
1216+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2};
1217+ vector<GeTensorPtr> outputs;
1218+ 
1219+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(GATHERV2);
1220+ ge::Status status = kernel->Compute(op_desc_ptr, input, outputs);
1221+ EXPECT_NE(ge::SUCCESS, status);
1222+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/slice_d_kernel_unittest.cc+250-0
@@ -201,3 +201,253 @@ TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CheckOutputDims1) {
201 Status status = slice_d_kernel.CheckOutputDims(output_dims, op_desc_ptr);201 Status status = slice_d_kernel.CheckOutputDims(output_dims, op_desc_ptr);
202 EXPECT_EQ(SUCCESS, status);202 EXPECT_EQ(SUCCESS, status);
203}203}
204+ 
205+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovComputeSuccess) {
206+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
207+ GeTensorDesc input_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
208+ op_desc_ptr->AddInputDesc(0, input_desc);
209+ GeTensorDesc output_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
210+ op_desc_ptr->AddOutputDesc(output_desc);
211+ 
212+ vector<int64_t> offsets = {1};
213+ vector<int64_t> sizes = {2};
214+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
215+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
216+ 
217+ vector<int32_t> data_vec = {1, 2, 3, 4};
218+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
219+ ConstGeTensorPtr tensor =
220+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
221+ 
222+ vector<ConstGeTensorPtr> input = {tensor};
223+ vector<GeTensorPtr> outputs;
224+ 
225+ SliceDKernel slice_d_kernel;
226+ Status status = slice_d_kernel.Compute(op_desc_ptr, input, outputs);
227+ EXPECT_EQ(SUCCESS, status);
228+ EXPECT_EQ(outputs.size(), 1);
229+}
230+ 
231+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovComputeSizeMinusOne) {
232+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
233+ GeTensorDesc input_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
234+ op_desc_ptr->AddInputDesc(0, input_desc);
235+ GeTensorDesc output_desc(GeShape({3}), FORMAT_NCHW, DT_INT32);
236+ op_desc_ptr->AddOutputDesc(output_desc);
237+ 
238+ vector<int64_t> offsets = {1};
239+ vector<int64_t> sizes = {-1};
240+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
241+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
242+ 
243+ vector<int32_t> data_vec = {1, 2, 3, 4};
244+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
245+ ConstGeTensorPtr tensor =
246+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
247+ 
248+ vector<ConstGeTensorPtr> input = {tensor};
249+ vector<GeTensorPtr> outputs;
250+ 
251+ SliceDKernel slice_d_kernel;
252+ Status status = slice_d_kernel.Compute(op_desc_ptr, input, outputs);
253+ EXPECT_EQ(SUCCESS, status);
254+}
255+ 
256+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovComputeZeroDim) {
257+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
258+ GeTensorDesc input_desc(GeShape({4, 0}), FORMAT_NCHW, DT_INT32);
259+ op_desc_ptr->AddInputDesc(0, input_desc);
260+ GeTensorDesc output_desc(GeShape({2, 0}), FORMAT_NCHW, DT_INT32);
261+ op_desc_ptr->AddOutputDesc(output_desc);
262+ 
263+ vector<int64_t> offsets = {1, 0};
264+ vector<int64_t> sizes = {2, 0};
265+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
266+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
267+ 
268+ vector<int32_t> data_vec = {1, 2, 3, 4};
269+ GeTensorDesc tensor_desc(GeShape({4, 0}), FORMAT_NCHW, DT_INT32);
270+ ConstGeTensorPtr tensor =
271+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
272+ 
273+ vector<ConstGeTensorPtr> input = {tensor};
274+ vector<GeTensorPtr> outputs;
275+ 
276+ SliceDKernel slice_d_kernel;
277+ Status status = slice_d_kernel.Compute(op_desc_ptr, input, outputs);
278+ EXPECT_EQ(SUCCESS, status);
279+}
280+ 
281+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovComputeSizeOverflow) {
282+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
283+ GeTensorDesc input_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
284+ op_desc_ptr->AddInputDesc(0, input_desc);
285+ GeTensorDesc output_desc(GeShape({3}), FORMAT_NCHW, DT_INT32);
286+ op_desc_ptr->AddOutputDesc(output_desc);
287+ 
288+ vector<int64_t> offsets = {2};
289+ vector<int64_t> sizes = {3};
290+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
291+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
292+ 
293+ vector<int32_t> data_vec = {1, 2, 3, 4};
294+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
295+ ConstGeTensorPtr tensor =
296+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
297+ 
298+ vector<ConstGeTensorPtr> input = {tensor};
299+ vector<GeTensorPtr> outputs;
300+ 
301+ SliceDKernel slice_d_kernel;
302+ Status status = slice_d_kernel.Compute(op_desc_ptr, input, outputs);
303+ EXPECT_EQ(NOT_CHANGED, status);
304+}
305+ 
306+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovSliceDCheckNullTensor) {
307+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
308+ GeTensorDesc input_desc;
309+ op_desc_ptr->AddInputDesc(0, input_desc);
310+ GeTensorDesc output_desc;
311+ op_desc_ptr->AddOutputDesc(output_desc);
312+ 
313+ vector<ConstGeTensorPtr> input = {nullptr};
314+ 
315+ SliceDKernel slice_d_kernel;
316+ std::vector<int64_t> begin_list;
317+ std::vector<int64_t> size_list;
318+ Status status = slice_d_kernel.SliceDCheck(op_desc_ptr, input, begin_list, size_list);
319+ EXPECT_EQ(PARAM_INVALID, status);
320+}
321+ 
322+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovSliceDCheckZeroData) {
323+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
324+ GeTensorDesc input_desc(GeShape(), FORMAT_NCHW, DT_INT32);
325+ op_desc_ptr->AddInputDesc(0, input_desc);
326+ GeTensorDesc output_desc;
327+ op_desc_ptr->AddOutputDesc(output_desc);
328+ 
329+ vector<int64_t> offsets = {0};
330+ vector<int64_t> sizes = {1};
331+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
332+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
333+ 
334+ GeTensorDesc tensor_desc(GeShape(), FORMAT_NCHW, DT_INT32);
335+ ConstGeTensorPtr tensor = std::make_shared<GeTensor>(tensor_desc);
336+ 
337+ vector<ConstGeTensorPtr> input = {tensor};
338+ 
339+ SliceDKernel slice_d_kernel;
340+ std::vector<int64_t> begin_list;
341+ std::vector<int64_t> size_list;
342+ Status status = slice_d_kernel.SliceDCheck(op_desc_ptr, input, begin_list, size_list);
343+ EXPECT_EQ(PARAM_INVALID, status);
344+}
345+ 
346+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovSliceDCheckGetBeginFail) {
347+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
348+ GeTensorDesc input_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
349+ op_desc_ptr->AddInputDesc(0, input_desc);
350+ GeTensorDesc output_desc;
351+ op_desc_ptr->AddOutputDesc(output_desc);
352+ 
353+ vector<int64_t> sizes = {2};
354+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
355+ 
356+ vector<int32_t> data_vec = {1, 2, 3, 4};
357+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
358+ ConstGeTensorPtr tensor =
359+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
360+ 
361+ vector<ConstGeTensorPtr> input = {tensor};
362+ 
363+ SliceDKernel slice_d_kernel;
364+ std::vector<int64_t> begin_list;
365+ std::vector<int64_t> size_list;
366+ Status status = slice_d_kernel.SliceDCheck(op_desc_ptr, input, begin_list, size_list);
367+ EXPECT_EQ(PARAM_INVALID, status);
368+}
369+ 
370+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovSliceDCheckGetSizeFail) {
371+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
372+ GeTensorDesc input_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
373+ op_desc_ptr->AddInputDesc(0, input_desc);
374+ GeTensorDesc output_desc;
375+ op_desc_ptr->AddOutputDesc(output_desc);
376+ 
377+ vector<int64_t> offsets = {1};
378+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
379+ 
380+ vector<int32_t> data_vec = {1, 2, 3, 4};
381+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
382+ ConstGeTensorPtr tensor =
383+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
384+ 
385+ vector<ConstGeTensorPtr> input = {tensor};
386+ 
387+ SliceDKernel slice_d_kernel;
388+ std::vector<int64_t> begin_list;
389+ std::vector<int64_t> size_list;
390+ Status status = slice_d_kernel.SliceDCheck(op_desc_ptr, input, begin_list, size_list);
391+ EXPECT_EQ(PARAM_INVALID, status);
392+}
393+ 
394+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovSliceDCheckDimMismatch) {
395+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
396+ GeTensorDesc input_desc(GeShape({4, 2}), FORMAT_NCHW, DT_INT32);
397+ op_desc_ptr->AddInputDesc(0, input_desc);
398+ GeTensorDesc output_desc;
399+ op_desc_ptr->AddOutputDesc(output_desc);
400+ 
401+ vector<int64_t> offsets = {0};
402+ vector<int64_t> sizes = {2};
403+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
404+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
405+ 
406+ vector<int32_t> data_vec = {1, 2, 3, 4, 5, 6, 7, 8};
407+ GeTensorDesc tensor_desc(GeShape({4, 2}), FORMAT_NCHW, DT_INT32);
408+ ConstGeTensorPtr tensor =
409+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
410+ 
411+ vector<ConstGeTensorPtr> input = {tensor};
412+ 
413+ SliceDKernel slice_d_kernel;
414+ std::vector<int64_t> begin_list;
415+ std::vector<int64_t> size_list;
416+ Status status = slice_d_kernel.SliceDCheck(op_desc_ptr, input, begin_list, size_list);
417+ EXPECT_EQ(PARAM_INVALID, status);
418+}
419+ 
420+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovSliceDCheckDimOutOfRange) {
421+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
422+ GeTensorDesc input_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
423+ op_desc_ptr->AddInputDesc(0, input_desc);
424+ GeTensorDesc output_desc;
425+ op_desc_ptr->AddOutputDesc(output_desc);
426+ 
427+ vector<int64_t> offsets = {-1};
428+ vector<int64_t> sizes = {2};
429+ AttrUtils::SetListInt(op_desc_ptr, "offsets", offsets);
430+ AttrUtils::SetListInt(op_desc_ptr, "size", sizes);
431+ 
432+ vector<int32_t> data_vec = {1, 2, 3, 4};
433+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_INT32);
434+ ConstGeTensorPtr tensor =
435+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
436+ 
437+ vector<ConstGeTensorPtr> input = {tensor};
438+ 
439+ SliceDKernel slice_d_kernel;
440+ std::vector<int64_t> begin_list;
441+ std::vector<int64_t> size_list;
442+ Status status = slice_d_kernel.SliceDCheck(op_desc_ptr, input, begin_list, size_list);
443+ EXPECT_EQ(PARAM_INVALID, status);
444+}
445+ 
446+TEST_F(UtestGraphPassesFoldingKernelSliceDKernel, CovCheckOutputDimsAllNonPositive) {
447+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("SLICED", SLICED);
448+ std::vector<int64_t> output_dims = {0, -1, 0};
449+ 
450+ SliceDKernel slice_d_kernel;
451+ Status status = slice_d_kernel.CheckOutputDims(output_dims, op_desc_ptr);
452+ EXPECT_EQ(NOT_CHANGED, status);
453+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/slice_kernel_unittest.cc+228-0
@@ -458,3 +458,231 @@ TEST_F(UtestFoldingSliceKernel, InputCheckFailed) {
458 ret = slice_kerel.Compute(node->GetOpDesc(), input, v_output);458 ret = slice_kerel.Compute(node->GetOpDesc(), input, v_output);
459 EXPECT_EQ(NOT_CHANGED, ret);459 EXPECT_EQ(NOT_CHANGED, ret);
460}460}
461+ 
462+TEST_F(UtestFoldingSliceKernel, CovSliceInt32BeginSizeSuccess) {
463+ vector<int64_t> dims_vec_x = {4};
464+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
465+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_INT32);
466+ ConstGeTensorPtr tensor_x =
467+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
468+ 
469+ vector<int64_t> dims_vec_begin = {1};
470+ vector<int32_t> data_vec_begin = {1};
471+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_INT32);
472+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
473+ data_vec_begin.size() * sizeof(int32_t));
474+ 
475+ vector<int64_t> dims_vec_size = {1};
476+ vector<int32_t> data_vec_size = {2};
477+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_INT32);
478+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
479+ data_vec_size.size() * sizeof(int32_t));
480+ 
481+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
482+ 
483+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
484+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
485+ 
486+ SliceKernel slice_kernel;
487+ vector<GeTensorPtr> outputs;
488+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
489+ EXPECT_EQ(SUCCESS, ret);
490+ EXPECT_EQ(outputs.size(), 1);
491+ auto ret_shape = outputs.at(0)->GetTensorDesc().GetShape();
492+ EXPECT_EQ(ret_shape.GetDim(0), 2);
493+}
494+ 
495+TEST_F(UtestFoldingSliceKernel, CovSliceInt32NegativeSize) {
496+ vector<int64_t> dims_vec_x = {4};
497+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
498+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_INT32);
499+ ConstGeTensorPtr tensor_x =
500+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
501+ 
502+ vector<int64_t> dims_vec_begin = {1};
503+ vector<int32_t> data_vec_begin = {1};
504+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_INT32);
505+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
506+ data_vec_begin.size() * sizeof(int32_t));
507+ 
508+ vector<int64_t> dims_vec_size = {1};
509+ vector<int32_t> data_vec_size = {-1};
510+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_INT32);
511+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
512+ data_vec_size.size() * sizeof(int32_t));
513+ 
514+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
515+ 
516+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
517+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
518+ 
519+ SliceKernel slice_kernel;
520+ vector<GeTensorPtr> outputs;
521+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
522+ EXPECT_EQ(SUCCESS, ret);
523+ EXPECT_EQ(outputs.size(), 1);
524+ auto ret_shape = outputs.at(0)->GetTensorDesc().GetShape();
525+ EXPECT_EQ(ret_shape.GetDim(0), 3);
526+}
527+ 
528+TEST_F(UtestFoldingSliceKernel, CovSliceRankMismatch) {
529+ vector<int64_t> dims_vec_x = {4};
530+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
531+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_INT32);
532+ ConstGeTensorPtr tensor_x =
533+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
534+ 
535+ vector<int64_t> dims_vec_begin = {2};
536+ vector<int32_t> data_vec_begin = {0, 1};
537+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_INT32);
538+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
539+ data_vec_begin.size() * sizeof(int32_t));
540+ 
541+ vector<int64_t> dims_vec_size = {2};
542+ vector<int32_t> data_vec_size = {1, 1};
543+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_INT32);
544+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
545+ data_vec_size.size() * sizeof(int32_t));
546+ 
547+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
548+ 
549+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
550+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
551+ 
552+ SliceKernel slice_kernel;
553+ vector<GeTensorPtr> outputs;
554+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
555+ EXPECT_EQ(NOT_CHANGED, ret);
556+}
557+ 
558+TEST_F(UtestFoldingSliceKernel, CovSliceNullInputTensor) {
559+ vector<ConstGeTensorPtr> input = {nullptr, nullptr, nullptr};
560+ 
561+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
562+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
563+ 
564+ SliceKernel slice_kernel;
565+ vector<GeTensorPtr> outputs;
566+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
567+ EXPECT_EQ(NOT_CHANGED, ret);
568+}
569+ 
570+TEST_F(UtestFoldingSliceKernel, CovSliceUnsupportedXType) {
571+ vector<int64_t> dims_vec_x = {4};
572+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
573+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_STRING);
574+ ConstGeTensorPtr tensor_x =
575+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
576+ 
577+ vector<int64_t> dims_vec_begin = {1};
578+ vector<int32_t> data_vec_begin = {1};
579+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_INT32);
580+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
581+ data_vec_begin.size() * sizeof(int32_t));
582+ 
583+ vector<int64_t> dims_vec_size = {1};
584+ vector<int32_t> data_vec_size = {2};
585+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_INT32);
586+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
587+ data_vec_size.size() * sizeof(int32_t));
588+ 
589+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
590+ 
591+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
592+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
593+ 
594+ SliceKernel slice_kernel;
595+ vector<GeTensorPtr> outputs;
596+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
597+ EXPECT_EQ(NOT_CHANGED, ret);
598+}
599+ 
600+TEST_F(UtestFoldingSliceKernel, CovSliceUnsupportedBeginType) {
601+ vector<int64_t> dims_vec_x = {4};
602+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
603+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_INT32);
604+ ConstGeTensorPtr tensor_x =
605+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
606+ 
607+ vector<int64_t> dims_vec_begin = {1};
608+ vector<int32_t> data_vec_begin = {1};
609+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_FLOAT);
610+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
611+ data_vec_begin.size() * sizeof(int32_t));
612+ 
613+ vector<int64_t> dims_vec_size = {1};
614+ vector<int32_t> data_vec_size = {2};
615+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_INT32);
616+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
617+ data_vec_size.size() * sizeof(int32_t));
618+ 
619+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
620+ 
621+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
622+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
623+ 
624+ SliceKernel slice_kernel;
625+ vector<GeTensorPtr> outputs;
626+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
627+ EXPECT_EQ(NOT_CHANGED, ret);
628+}
629+ 
630+TEST_F(UtestFoldingSliceKernel, CovSliceUnsupportedSizeType) {
631+ vector<int64_t> dims_vec_x = {4};
632+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
633+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_INT32);
634+ ConstGeTensorPtr tensor_x =
635+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
636+ 
637+ vector<int64_t> dims_vec_begin = {1};
638+ vector<int32_t> data_vec_begin = {1};
639+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_INT32);
640+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
641+ data_vec_begin.size() * sizeof(int32_t));
642+ 
643+ vector<int64_t> dims_vec_size = {1};
644+ vector<int32_t> data_vec_size = {2};
645+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_FLOAT);
646+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
647+ data_vec_size.size() * sizeof(int32_t));
648+ 
649+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
650+ 
651+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
652+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
653+ 
654+ SliceKernel slice_kernel;
655+ vector<GeTensorPtr> outputs;
656+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
657+ EXPECT_EQ(NOT_CHANGED, ret);
658+}
659+ 
660+TEST_F(UtestFoldingSliceKernel, CovSliceAllOutputNonPositive) {
661+ vector<int64_t> dims_vec_x = {4};
662+ vector<int32_t> data_vec_x = {1, 2, 3, 4};
663+ GeTensorDesc tensor_desc_x(GeShape(dims_vec_x), FORMAT_NCHW, DT_INT32);
664+ ConstGeTensorPtr tensor_x =
665+ std::make_shared<GeTensor>(tensor_desc_x, (uint8_t *)data_vec_x.data(), data_vec_x.size() * sizeof(int32_t));
666+ 
667+ vector<int64_t> dims_vec_begin = {1};
668+ vector<int32_t> data_vec_begin = {0};
669+ GeTensorDesc tensor_desc_begin(GeShape(dims_vec_begin), FORMAT_NCHW, DT_INT32);
670+ ConstGeTensorPtr tensor_begin = std::make_shared<GeTensor>(tensor_desc_begin, (uint8_t *)data_vec_begin.data(),
671+ data_vec_begin.size() * sizeof(int32_t));
672+ 
673+ vector<int64_t> dims_vec_size = {1};
674+ vector<int32_t> data_vec_size = {0};
675+ GeTensorDesc tensor_desc_size(GeShape(dims_vec_size), FORMAT_NCHW, DT_INT32);
676+ ConstGeTensorPtr tensor_size = std::make_shared<GeTensor>(tensor_desc_size, (uint8_t *)data_vec_size.data(),
677+ data_vec_size.size() * sizeof(int32_t));
678+ 
679+ vector<ConstGeTensorPtr> input = {tensor_x, tensor_begin, tensor_size};
680+ 
681+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("slice", "Slice");
682+ op_desc_ptr->AddOutputDesc(GeTensorDesc(GeShape({4}), FORMAT_NCHW, DT_INT32));
683+ 
684+ SliceKernel slice_kernel;
685+ vector<GeTensorPtr> outputs;
686+ auto ret = slice_kernel.Compute(op_desc_ptr, input, outputs);
687+ EXPECT_EQ(NOT_CHANGED, ret);
688+}
Mtests/ge/ut/ge/graph/passes/folding_kernel/strided_slice_kernel_unittest.cc+457-0
@@ -578,3 +578,460 @@ TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, Test17) {
578 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);578 shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
579 EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);579 EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
580}580}
581+ 
582+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovSuccessInt64Stride) {
583+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
584+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
585+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
586+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
587+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
588+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
589+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
590+ 
591+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
592+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
593+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
594+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
595+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
596+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
597+ 
598+ vector<int32_t> x_data = {1, 2, 3, 4, 5, 6};
599+ GeTensorDesc x_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
600+ ConstGeTensorPtr tensor_0 =
601+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
602+ 
603+ vector<int64_t> begin_data = {0, 0};
604+ vector<int64_t> end_data = {2, 2};
605+ vector<int64_t> stride_data = {1, 1};
606+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT64);
607+ ConstGeTensorPtr tensor_1 =
608+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int64_t));
609+ ConstGeTensorPtr tensor_2 =
610+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int64_t));
611+ ConstGeTensorPtr tensor_3 =
612+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int64_t));
613+ 
614+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
615+ vector<GeTensorPtr> outputs;
616+ 
617+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
618+ EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
619+}
620+ 
621+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovSuccessInt32Stride) {
622+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
623+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
624+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
625+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
626+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
627+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
628+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
629+ 
630+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
631+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
632+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
633+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
634+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
635+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
636+ 
637+ vector<int32_t> x_data = {1, 2, 3, 4, 5, 6};
638+ GeTensorDesc x_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
639+ ConstGeTensorPtr tensor_0 =
640+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
641+ 
642+ vector<int32_t> begin_data = {0, 0};
643+ vector<int32_t> end_data = {2, 2};
644+ vector<int32_t> stride_data = {1, 1};
645+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
646+ ConstGeTensorPtr tensor_1 =
647+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
648+ ConstGeTensorPtr tensor_2 =
649+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
650+ ConstGeTensorPtr tensor_3 =
651+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
652+ 
653+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
654+ vector<GeTensorPtr> outputs;
655+ 
656+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
657+ EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
658+}
659+ 
660+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovNullOpDesc) {
661+ OpDescPtr op_desc_ptr = nullptr;
662+ 
663+ vector<int32_t> data_vec = {1, 2, 3, 4};
664+ GeTensorDesc tensor_desc(GeShape({2, 2}), FORMAT_NCHW, DT_INT32);
665+ ConstGeTensorPtr tensor_0 =
666+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
667+ ConstGeTensorPtr tensor_1 =
668+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
669+ ConstGeTensorPtr tensor_2 =
670+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
671+ ConstGeTensorPtr tensor_3 =
672+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
673+ 
674+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
675+ vector<GeTensorPtr> outputs;
676+ 
677+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
678+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
679+}
680+ 
681+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovMissingAttr) {
682+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
683+ 
684+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
685+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
686+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
687+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
688+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
689+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
690+ 
691+ vector<int32_t> data_vec = {1, 2, 3, 4, 5, 6};
692+ GeTensorDesc tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
693+ ConstGeTensorPtr tensor_0 =
694+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
695+ ConstGeTensorPtr tensor_1 =
696+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
697+ ConstGeTensorPtr tensor_2 =
698+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
699+ ConstGeTensorPtr tensor_3 =
700+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
701+ 
702+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
703+ vector<GeTensorPtr> outputs;
704+ 
705+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
706+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
707+}
708+ 
709+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovInputSizeMismatch) {
710+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
711+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
712+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
713+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
714+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
715+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
716+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
717+ 
718+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
719+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
720+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
721+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
722+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
723+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
724+ 
725+ vector<int32_t> data_vec = {1, 2, 3, 4, 5, 6};
726+ GeTensorDesc tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
727+ ConstGeTensorPtr tensor_0 =
728+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
729+ ConstGeTensorPtr tensor_1 =
730+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
731+ ConstGeTensorPtr tensor_2 =
732+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
733+ 
734+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2};
735+ vector<GeTensorPtr> outputs;
736+ 
737+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
738+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
739+}
740+ 
741+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovDataTypeMismatch) {
742+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
743+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
744+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
745+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
746+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
747+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
748+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
749+ 
750+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
751+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
752+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
753+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
754+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
755+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
756+ 
757+ vector<int32_t> x_data = {1, 2, 3, 4, 5, 6};
758+ GeTensorDesc x_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
759+ ConstGeTensorPtr tensor_0 =
760+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
761+ 
762+ vector<int32_t> begin_data = {0, 0};
763+ vector<int64_t> end_data = {2, 2};
764+ vector<int32_t> stride_data = {1, 1};
765+ GeTensorDesc begin_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
766+ GeTensorDesc end_desc(GeShape({2}), FORMAT_NCHW, DT_INT64);
767+ ConstGeTensorPtr tensor_1 =
768+ std::make_shared<GeTensor>(begin_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
769+ ConstGeTensorPtr tensor_2 =
770+ std::make_shared<GeTensor>(end_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int64_t));
771+ ConstGeTensorPtr tensor_3 =
772+ std::make_shared<GeTensor>(begin_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
773+ 
774+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
775+ vector<GeTensorPtr> outputs;
776+ 
777+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
778+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
779+}
780+ 
781+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovUnsupportedXType) {
782+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
783+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
784+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
785+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
786+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
787+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
788+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
789+ 
790+ GeTensorDesc dims_tensor_desc(GeShape({2, 2}), FORMAT_NCHW, DT_INT32);
791+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
792+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
793+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
794+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
795+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
796+ 
797+ vector<int32_t> x_data = {1, 2, 3, 4};
798+ GeTensorDesc x_desc(GeShape({2, 2}), FORMAT_NCHW, DT_STRING);
799+ ConstGeTensorPtr tensor_0 =
800+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
801+ 
802+ vector<int32_t> begin_data = {0, 0};
803+ vector<int32_t> end_data = {2, 2};
804+ vector<int32_t> stride_data = {1, 1};
805+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
806+ ConstGeTensorPtr tensor_1 =
807+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
808+ ConstGeTensorPtr tensor_2 =
809+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
810+ ConstGeTensorPtr tensor_3 =
811+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
812+ 
813+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
814+ vector<GeTensorPtr> outputs;
815+ 
816+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
817+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
818+}
819+ 
820+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovZeroDataSize) {
821+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
822+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
823+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
824+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
825+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
826+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
827+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
828+ 
829+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
830+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
831+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
832+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
833+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
834+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
835+ 
836+ GeTensorDesc tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
837+ ConstGeTensorPtr tensor_0 = std::make_shared<GeTensor>(tensor_desc);
838+ ConstGeTensorPtr tensor_1 = std::make_shared<GeTensor>(tensor_desc);
839+ ConstGeTensorPtr tensor_2 = std::make_shared<GeTensor>(tensor_desc);
840+ ConstGeTensorPtr tensor_3 = std::make_shared<GeTensor>(tensor_desc);
841+ 
842+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
843+ vector<GeTensorPtr> outputs;
844+ 
845+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
846+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
847+}
848+ 
849+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovSizeMismatch) {
850+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
851+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
852+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
853+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
854+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
855+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
856+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
857+ 
858+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
859+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
860+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
861+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
862+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
863+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
864+ 
865+ vector<int32_t> x_data = {1, 2, 3, 4, 5, 6};
866+ GeTensorDesc x_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
867+ ConstGeTensorPtr tensor_0 =
868+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
869+ 
870+ vector<int32_t> begin_data = {0};
871+ vector<int32_t> end_data = {2, 2};
872+ vector<int32_t> stride_data = {1};
873+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
874+ ConstGeTensorPtr tensor_1 =
875+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
876+ ConstGeTensorPtr tensor_2 =
877+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
878+ ConstGeTensorPtr tensor_3 =
879+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
880+ 
881+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
882+ vector<GeTensorPtr> outputs;
883+ 
884+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
885+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
886+}
887+ 
888+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovInvalidEllipsisMask) {
889+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
890+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
891+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
892+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 3);
893+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
894+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
895+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
896+ 
897+ GeTensorDesc dims_tensor_desc(GeShape({2, 2}), FORMAT_NCHW, DT_INT32);
898+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
899+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
900+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
901+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
902+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
903+ 
904+ vector<int32_t> data_vec = {1, 2, 3, 4};
905+ GeTensorDesc tensor_desc(GeShape({2, 2}), FORMAT_NCHW, DT_INT32);
906+ ConstGeTensorPtr tensor_0 =
907+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
908+ ConstGeTensorPtr tensor_1 =
909+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
910+ ConstGeTensorPtr tensor_2 =
911+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
912+ ConstGeTensorPtr tensor_3 =
913+ std::make_shared<GeTensor>(tensor_desc, (uint8_t *)data_vec.data(), data_vec.size() * sizeof(int32_t));
914+ 
915+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
916+ vector<GeTensorPtr> outputs;
917+ 
918+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
919+ EXPECT_NE(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
920+}
921+ 
922+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovShrinkAxisMask) {
923+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
924+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
925+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
926+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
927+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
928+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 1);
929+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
930+ 
931+ GeTensorDesc dims_tensor_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
932+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
933+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
934+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
935+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
936+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
937+ 
938+ vector<int32_t> x_data = {1, 2, 3, 4, 5, 6};
939+ GeTensorDesc x_desc(GeShape({2, 3}), FORMAT_NCHW, DT_INT32);
940+ ConstGeTensorPtr tensor_0 =
941+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
942+ 
943+ vector<int32_t> begin_data = {0, 0};
944+ vector<int32_t> end_data = {1, 2};
945+ vector<int32_t> stride_data = {1, 1};
946+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
947+ ConstGeTensorPtr tensor_1 =
948+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
949+ ConstGeTensorPtr tensor_2 =
950+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
951+ ConstGeTensorPtr tensor_3 =
952+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
953+ 
954+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
955+ vector<GeTensorPtr> outputs;
956+ 
957+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
958+ EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
959+}
960+ 
961+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovNewAxisMask) {
962+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
963+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
964+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
965+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 0);
966+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 1);
967+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
968+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
969+ 
970+ GeTensorDesc dims_tensor_desc(GeShape({3}), FORMAT_NCHW, DT_INT32);
971+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
972+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
973+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
974+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
975+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
976+ 
977+ vector<int32_t> x_data = {1, 2, 3};
978+ GeTensorDesc x_desc(GeShape({3}), FORMAT_NCHW, DT_INT32);
979+ ConstGeTensorPtr tensor_0 =
980+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
981+ 
982+ vector<int32_t> begin_data = {0};
983+ vector<int32_t> end_data = {3};
984+ vector<int32_t> stride_data = {1};
985+ GeTensorDesc idx_desc(GeShape({1}), FORMAT_NCHW, DT_INT32);
986+ ConstGeTensorPtr tensor_1 =
987+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
988+ ConstGeTensorPtr tensor_2 =
989+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
990+ ConstGeTensorPtr tensor_3 =
991+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
992+ 
993+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
994+ vector<GeTensorPtr> outputs;
995+ 
996+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
997+ EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
998+}
999+ 
1000+TEST_F(UtestGraphPassesFoldingKernelStridedSliceKernel, CovEllipsisMaskExpand) {
1001+ OpDescPtr op_desc_ptr = std::make_shared<OpDesc>("StridedSlice", "StridedSlice");
1002+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_BEGIN_MASK, 0);
1003+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_END_MASK, 0);
1004+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_ELLIPSIS_MASK, 1);
1005+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_NEW_AXIS_MASK, 0);
1006+ AttrUtils::SetInt(op_desc_ptr, STRIDE_SLICE_ATTR_SHRINK_AXIS_MASK, 0);
1007+ AttrUtils::SetInt(op_desc_ptr, ATTR_NAME_T, 0);
1008+ 
1009+ GeTensorDesc dims_tensor_desc(GeShape({2, 3, 4}), FORMAT_NCHW, DT_INT32);
1010+ op_desc_ptr->AddInputDesc(0, dims_tensor_desc);
1011+ op_desc_ptr->AddInputDesc(1, dims_tensor_desc);
1012+ op_desc_ptr->AddInputDesc(2, dims_tensor_desc);
1013+ op_desc_ptr->AddInputDesc(3, dims_tensor_desc);
1014+ op_desc_ptr->AddOutputDesc(dims_tensor_desc);
1015+ 
1016+ vector<int32_t> x_data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
1017+ GeTensorDesc x_desc(GeShape({2, 3, 4}), FORMAT_NCHW, DT_INT32);
1018+ ConstGeTensorPtr tensor_0 =
1019+ std::make_shared<GeTensor>(x_desc, (uint8_t *)x_data.data(), x_data.size() * sizeof(int32_t));
1020+ 
1021+ vector<int32_t> begin_data = {0, 1};
1022+ vector<int32_t> end_data = {2, 2};
1023+ vector<int32_t> stride_data = {1, 1};
1024+ GeTensorDesc idx_desc(GeShape({2}), FORMAT_NCHW, DT_INT32);
1025+ ConstGeTensorPtr tensor_1 =
1026+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)begin_data.data(), begin_data.size() * sizeof(int32_t));
1027+ ConstGeTensorPtr tensor_2 =
1028+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)end_data.data(), end_data.size() * sizeof(int32_t));
1029+ ConstGeTensorPtr tensor_3 =
1030+ std::make_shared<GeTensor>(idx_desc, (uint8_t *)stride_data.data(), stride_data.size() * sizeof(int32_t));
1031+ 
1032+ vector<ConstGeTensorPtr> input = {tensor_0, tensor_1, tensor_2, tensor_3};
1033+ vector<GeTensorPtr> outputs;
1034+ 
1035+ shared_ptr<Kernel> kernel = KernelFactory::Instance().Create(STRIDEDSLICE);
1036+ EXPECT_EQ(kernel->Compute(op_desc_ptr, input, outputs), ge::SUCCESS);
1037+}
Mtests/graph_metadef/ut/graph/testcase/buffer_unittest.cc+141-0
@@ -152,4 +152,145 @@ TEST_F(BufferUT, CreateCopyFrom2) {
152 EXPECT_EQ(memcmp(buf1.GetData(), second_buf, sizeof(second_buf)), 0);152 EXPECT_EQ(memcmp(buf1.GetData(), second_buf, sizeof(second_buf)), 0);
153 EXPECT_EQ(memcmp(buf.GetData(), first_buf, sizeof(first_buf)), 0);153 EXPECT_EQ(memcmp(buf.GetData(), first_buf, sizeof(first_buf)), 0);
154}154}
155+ 
156+TEST_F(BufferUT, Cov_DefaultConstructor) {
157+ Buffer buf;
158+ EXPECT_EQ(buf.GetSize(), 0UL);
159+ EXPECT_EQ(buf.GetData(), nullptr);
160+ EXPECT_EQ(buf.data(), nullptr);
161+ EXPECT_EQ(buf.size(), 0UL);
162+}
163+ 
164+TEST_F(BufferUT, Cov_CopyConstructor) {
165+ uint8_t data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
166+ Buffer buf1 = Buffer::CopyFrom(data, sizeof(data));
167+ Buffer buf2(buf1);
168+ EXPECT_EQ(buf2.GetSize(), 10UL);
169+ EXPECT_EQ(memcmp(buf2.GetData(), data, sizeof(data)), 0);
170+}
171+ 
172+TEST_F(BufferUT, Cov_SizeConstructorWithDefaultVal) {
173+ Buffer buf(10, 0xAB);
174+ EXPECT_EQ(buf.GetSize(), 10UL);
175+ for (size_t i = 0; i < 10; ++i) {
176+ EXPECT_EQ(buf[i], 0xAB);
177+ }
178+}
179+ 
180+TEST_F(BufferUT, Cov_GetDataMutable) {
181+ uint8_t data[5] = {1, 2, 3, 4, 5};
182+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
183+ uint8_t *mutable_data = buf.GetData();
184+ ASSERT_NE(mutable_data, nullptr);
185+ mutable_data[0] = 99;
186+ EXPECT_EQ(buf[0], 99);
187+}
188+ 
189+TEST_F(BufferUT, Cov_GetDataMutable_EmptyBuffer) {
190+ Buffer buf;
191+ EXPECT_EQ(buf.GetData(), nullptr);
192+}
193+ 
194+TEST_F(BufferUT, Cov_GetDataConst_NullBuffer) {
195+ Buffer buf;
196+ const Buffer &const_buf = buf;
197+ EXPECT_EQ(const_buf.GetData(), nullptr);
198+}
199+ 
200+TEST_F(BufferUT, Cov_GetSize_EmptyBuffer) {
201+ Buffer buf;
202+ EXPECT_EQ(buf.GetSize(), 0UL);
203+}
204+ 
205+TEST_F(BufferUT, Cv_GetSize_BufferWithSize) {
206+ Buffer buf(50);
207+ EXPECT_EQ(buf.GetSize(), 50UL);
208+}
209+ 
210+TEST_F(BufferUT, Cov_ClearBuffer) {
211+ uint8_t data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
212+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
213+ EXPECT_EQ(buf.GetSize(), 10UL);
214+ buf.ClearBuffer();
215+ EXPECT_EQ(buf.GetSize(), 0UL);
216+}
217+ 
218+TEST_F(BufferUT, Cov_Clear_EmptyBuffer) {
219+ Buffer buf;
220+ buf.clear();
221+ EXPECT_EQ(buf.size(), 0UL);
222+}
223+ 
224+TEST_F(BufferUT, Cov_OperatorIndex_InBounds) {
225+ uint8_t data[5] = {10, 20, 30, 40, 50};
226+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
227+ EXPECT_EQ(buf[0], 10);
228+ EXPECT_EQ(buf[4], 50);
229+}
230+ 
231+TEST_F(BufferUT, Cov_OperatorIndex_OutOfBounds) {
232+ Buffer buf(5);
233+ EXPECT_EQ(buf[100], 0xffU);
234+}
235+ 
236+TEST_F(BufferUT, Cov_OperatorIndex_EmptyBuffer) {
237+ Buffer buf;
238+ EXPECT_EQ(buf[0], 0xffU);
239+}
240+ 
241+TEST_F(BufferUT, Cov_OperatorAssign_SelfAssign) {
242+ uint8_t data[5] = {1, 2, 3, 4, 5};
243+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
244+ buf = buf;
245+ EXPECT_EQ(buf.GetSize(), 5UL);
246+ EXPECT_EQ(buf[0], 1);
247+}
248+ 
249+TEST_F(BufferUT, Cov_DataAlias) {
250+ uint8_t data[5] = {1, 2, 3, 4, 5};
251+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
252+ EXPECT_EQ(buf.data(), buf.GetData());
253+}
254+ 
255+TEST_F(BufferUT, Cov_SizeAlias) {
256+ Buffer buf(42);
257+ EXPECT_EQ(buf.size(), buf.GetSize());
258+}
259+ 
260+TEST_F(BufferUT, Cov_ClearAlias) {
261+ uint8_t data[5] = {1, 2, 3, 4, 5};
262+ Buffer buf = Buffer::CopyFrom(data, sizeof(data));
263+ buf.clear();
264+ EXPECT_EQ(buf.size(), 0UL);
265+}
266+ 
267+TEST_F(BufferUT, Cov_BufferUtils_CreateCopyFromData) {
268+ uint8_t data[5] = {1, 2, 3, 4, 5};
269+ Buffer buf = BufferUtils::CreateCopyFrom(data, sizeof(data));
270+ EXPECT_EQ(buf.GetSize(), 5UL);
271+ EXPECT_EQ(memcmp(buf.GetData(), data, sizeof(data)), 0);
272+}
273+ 
274+TEST_F(BufferUT, Cov_BufferUtils_CreateCopyFromBuffer) {
275+ uint8_t data[5] = {1, 2, 3, 4, 5};
276+ Buffer buf1 = BufferUtils::CreateCopyFrom(data, sizeof(data));
277+ Buffer buf2 = BufferUtils::CreateCopyFrom(buf1);
278+ EXPECT_EQ(buf2.GetSize(), 5UL);
279+ EXPECT_EQ(memcmp(buf2.GetData(), data, sizeof(data)), 0);
280+ buf2.GetData()[0] = 99;
281+ EXPECT_EQ(buf1[0], 1);
282+}
283+ 
284+TEST_F(BufferUT, Cov_CopyFrom_NullData) {
285+ Buffer buf = Buffer::CopyFrom(nullptr, 100);
286+ EXPECT_EQ(buf.GetSize(), 0UL);
287+}
288+ 
289+TEST_F(BufferUT, Cov_DefaultValConstructor) {
290+ Buffer buf(20, 0x42);
291+ EXPECT_EQ(buf.GetSize(), 20UL);
292+ for (size_t i = 0; i < 20; ++i) {
293+ EXPECT_EQ(buf[i], 0x42);
294+ }
295+}
155} // namespace ge296} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/constant_utils_unittest.cc+48-0
@@ -218,4 +218,52 @@ TEST_F(UtestConstantUtils, TestGetWeightFromFile) {
218 ASSERT_EQ(weight->GetTensorDesc().GetShape().GetDims(), shape);218 ASSERT_EQ(weight->GetTensorDesc().GetShape().GetDims(), shape);
219 system("rm -rf ./weight.bin");219 system("rm -rf ./weight.bin");
220}220}
221+ 
222+TEST_F(UtestConstantUtils, CovGetWeightIndexNotFound) {
223+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
224+ const auto &shape_node = builder.AddNode("shape_node", "Shape", 1, 1);
225+ AttrUtils::SetBool(shape_node->GetOpDesc(), ATTR_NAME_POTENTIAL_CONST, true);
226+ AttrUtils::SetListInt(shape_node->GetOpDesc(), ATTR_NAME_POTENTIAL_WEIGHT_INDICES, {0});
227+ ge::GeTensorPtr tensor = std::make_shared<GeTensor>();
228+ AttrUtils::SetListTensor(shape_node->GetOpDesc(), ATTR_NAME_POTENTIAL_WEIGHT, {tensor});
229+ ConstGeTensorPtr weight;
230+ EXPECT_FALSE(ConstantUtils::GetWeight(shape_node->GetOpDesc(), 1, weight));
231+}
232+ 
233+TEST_F(UtestConstantUtils, CovMutableWeightNotPotentialConst) {
234+ auto op_desc = std::make_shared<OpDesc>("test", "Relu");
235+ GeTensorPtr weight;
236+ EXPECT_FALSE(ConstantUtils::MutableWeight(op_desc, 0, weight));
237+}
238+ 
239+TEST_F(UtestConstantUtils, CovMutableWeightInvalidPotential) {
240+ auto op_desc = std::make_shared<OpDesc>("test", "Shape");
241+ AttrUtils::SetBool(op_desc, ATTR_NAME_POTENTIAL_CONST, true);
242+ GeTensorPtr weight;
243+ EXPECT_FALSE(ConstantUtils::MutableWeight(op_desc, 0, weight));
244+}
245+ 
246+TEST_F(UtestConstantUtils, CovMutableWeightIndexNotFound) {
247+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
248+ const auto &shape_node = builder.AddNode("shape_node", "Shape", 1, 1);
249+ AttrUtils::SetBool(shape_node->GetOpDesc(), ATTR_NAME_POTENTIAL_CONST, true);
250+ AttrUtils::SetListInt(shape_node->GetOpDesc(), ATTR_NAME_POTENTIAL_WEIGHT_INDICES, {0});
251+ ge::GeTensorPtr tensor = std::make_shared<GeTensor>();
252+ AttrUtils::SetListTensor(shape_node->GetOpDesc(), ATTR_NAME_POTENTIAL_WEIGHT, {tensor});
253+ GeTensorPtr weight;
254+ EXPECT_FALSE(ConstantUtils::MutableWeight(shape_node->GetOpDesc(), 1, weight));
255+}
256+ 
257+TEST_F(UtestConstantUtils, CovSetWeightNotPotentialConst) {
258+ auto op_desc = std::make_shared<OpDesc>("test", "Relu");
259+ ge::GeTensorPtr tensor = std::make_shared<GeTensor>();
260+ EXPECT_FALSE(ConstantUtils::SetWeight(op_desc, 0, tensor));
261+}
262+ 
263+TEST_F(UtestConstantUtils, CovSetWeightInvalidPotential) {
264+ auto op_desc = std::make_shared<OpDesc>("test", "Shape");
265+ AttrUtils::SetBool(op_desc, ATTR_NAME_POTENTIAL_CONST, true);
266+ ge::GeTensorPtr tensor = std::make_shared<GeTensor>();
267+ EXPECT_FALSE(ConstantUtils::SetWeight(op_desc, 0, tensor));
268+}
221} // namespace ge269} // namespace ge
Atests/graph_metadef/ut/graph/testcase/cov_utils_misc_unittest.cc+80-0
@@ -0,0 +1,80 @@
1+#include <gtest/gtest.h>
2+#include <thread>
3+#include <chrono>
4+#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"
8+#include "graph/utils/graph_utils.h"
9+ 
10+namespace ge {
11+ 
12+class CovUtilsMiscTest : public testing::Test {
13+ protected:
14+ void SetUp() {}
15+ void TearDown() {}
16+};
17+ 
18+TEST_F(CovUtilsMiscTest, CovGraphThreadPoolConstructorAndDestructor) {
19+ GraphThreadPool pool(2U);
20+ SUCCEED();
21+}
22+ 
23+TEST_F(CovUtilsMiscTest, CovGraphThreadPoolZeroSize) {
24+ GraphThreadPool pool(0U);
25+ SUCCEED();
26+}
27+ 
28+TEST_F(CovUtilsMiscTest, CovGraphThreadPoolSubmitTask) {
29+ GraphThreadPool pool(2U);
30+ std::atomic<int> counter(0);
31+ pool.commit([&counter]() { counter++; });
32+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
33+ EXPECT_EQ(counter.load(), 1);
34+}
35+ 
36+TEST_F(CovUtilsMiscTest, CovMultiThreadGraphBuilderConstructor) {
37+ MultiThreadGraphBuilder builder(2);
38+ SUCCEED();
39+}
40+ 
41+TEST_F(CovUtilsMiscTest, CovMultiThreadGraphBuilderSingleThread) {
42+ MultiThreadGraphBuilder builder(1);
43+ ge::Graph graph("test");
44+ std::vector<ge::Operator> inputs;
45+ auto &result = builder.SetInputs(inputs, graph);
46+ SUCCEED();
47+}
48+ 
49+TEST_F(CovUtilsMiscTest, CovMultiThreadGraphBuilderMultiThread) {
50+ MultiThreadGraphBuilder builder(2);
51+ ge::Graph graph("test");
52+ std::vector<ge::Operator> inputs;
53+ auto &result = builder.SetInputs(inputs, graph);
54+ SUCCEED();
55+}
56+ 
57+TEST_F(CovUtilsMiscTest, CovTypeUtilsAscendStringToDataType) {
58+ ge::AscendString str("DT_FLOAT");
59+ DataType dt = TypeUtils::AscendStringToDataType(str);
60+ EXPECT_EQ(dt, DT_FLOAT);
61+}
62+ 
63+TEST_F(CovUtilsMiscTest, CovTypeUtilsFormatToAscendString) {
64+ AscendString result = TypeUtils::FormatToAscendString(FORMAT_NCHW);
65+ EXPECT_NE(result.GetString(), nullptr);
66+}
67+ 
68+TEST_F(CovUtilsMiscTest, CovTypeUtilsAscendStringToFormat) {
69+ AscendString str("NCHW");
70+ Format fmt = TypeUtils::AscendStringToFormat(str);
71+ EXPECT_EQ(fmt, FORMAT_NCHW);
72+}
73+ 
74+TEST_F(CovUtilsMiscTest, CovTypeUtilsDataFormatToFormat) {
75+ AscendString str("NCHW");
76+ Format fmt = TypeUtils::DataFormatToFormat(str);
77+ SUCCEED();
78+}
79+ 
80+} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/cycle_detector_unittest.cc+69-0
@@ -421,3 +421,72 @@ TEST_F(UtestCycleDetector, ConnectionMatrixCoverage_00) {
421 EXPECT_FALSE(has_cycle);421 EXPECT_FALSE(has_cycle);
422 detector->Update(graph, fusion_nodes);422 detector->Update(graph, fusion_nodes);
423}423}
424+ 
425+TEST_F(UtestCycleDetector, CovConnectionMatrixSetConnectivity) {
426+ auto builder = ut::GraphBuilder("root");
427+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
428+ const auto &node2 = builder.AddNode("node2", "Relu", 1, 1);
429+ const auto &node3 = builder.AddNode("node3", "Relu", 1, 1);
430+ builder.AddDataEdge(node1, 0, node2, 0);
431+ builder.AddDataEdge(node2, 0, node3, 0);
432+ auto graph = builder.GetGraph();
433+ 
434+ ConnectionMatrix matrix(graph);
435+ matrix.Generate(graph);
436+ auto inputs = node3->GetInAllNodes();
437+ matrix.SetConnectivity(inputs, node3);
438+ EXPECT_TRUE(matrix.IsConnected(node1, node3));
439+}
440+ 
441+TEST_F(UtestCycleDetector, CovConnectionMatrixUpdateGraphMismatch) {
442+ auto builder1 = ut::GraphBuilder("graph1");
443+ const auto &node1 = builder1.AddNode("node1", "Relu", 1, 1);
444+ auto graph1 = builder1.GetGraph();
445+ 
446+ auto builder2 = ut::GraphBuilder("graph2");
447+ const auto &node2 = builder2.AddNode("node2", "Relu", 1, 1);
448+ auto graph2 = builder2.GetGraph();
449+ 
450+ ConnectionMatrix matrix(graph1);
451+ matrix.Generate(graph1);
452+ std::vector<NodePtr> fusion_nodes = {node1};
453+ matrix.Update(graph2, fusion_nodes);
454+ SUCCEED();
455+}
456+ 
457+TEST_F(UtestCycleDetector, CovCycleDetectorUpdateNullConnectivity) {
458+ auto builder = ut::GraphBuilder("root");
459+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
460+ auto graph = builder.GetGraph();
461+ 
462+ CycleDetectorPtr detector = GraphUtils::CreateCycleDetector(graph);
463+ EXPECT_NE(detector, nullptr);
464+ std::vector<NodePtr> fusion_nodes = {node1};
465+ detector->Update(graph, fusion_nodes);
466+ SUCCEED();
467+}
468+ 
469+TEST_F(UtestCycleDetector, CovCycleDetectorExpandAndUpdate) {
470+ auto builder = ut::GraphBuilder("root");
471+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
472+ const auto &node2 = builder.AddNode("node2", "Relu", 1, 1);
473+ builder.AddDataEdge(node1, 0, node2, 0);
474+ auto graph = builder.GetGraph();
475+ 
476+ CycleDetectorPtr detector = GraphUtils::CreateCycleDetector(graph);
477+ EXPECT_NE(detector, nullptr);
478+ std::vector<NodePtr> fusion_nodes = {node1, node2};
479+ detector->ExpandAndUpdate(fusion_nodes, "fused_node");
480+ SUCCEED();
481+}
482+ 
483+TEST_F(UtestCycleDetector, CovCycleDetectorExpandAndUpdateNullConnectivity) {
484+ auto builder = ut::GraphBuilder("root");
485+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
486+ auto graph = builder.GetGraph();
487+ 
488+ auto detector = std::make_shared<CycleDetector>();
489+ std::vector<NodePtr> fusion_nodes = {node1};
490+ detector->ExpandAndUpdate(fusion_nodes, "fused_node");
491+ SUCCEED();
492+}
Mtests/graph_metadef/ut/graph/testcase/ffts_graph_utils_unittest.cc+51-0
@@ -543,4 +543,55 @@ TEST_F(UtestFftsGraphUtils, Calculate_nullptr_node) {
543 std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;543 std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
544 ASSERT_TRUE(FftsGraphUtils::Calculate(node, nullptr, node_value, graph_value, 1).empty());544 ASSERT_TRUE(FftsGraphUtils::Calculate(node, nullptr, node_value, graph_value, 1).empty());
545}545}
546+ 
547+TEST_F(UtestFftsGraphUtils, CovGraphPartitionEmptyUnsupported) {
548+ auto builder = ut::GraphBuilder("root");
549+ auto graph = builder.GetGraph();
550+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*graph, {}), SUCCESS);
551+}
552+ 
553+TEST_F(UtestFftsGraphUtils, CovGraphPartitionNoNodeToClip) {
554+ ComputeGraphPtr graph;
555+ ComputeGraphPtr subgraph;
556+ BuildGraphForSplit_without_func_node(graph, subgraph);
557+ auto builder = ut::GraphBuilder("other");
558+ const auto &other_node = builder.AddNode("other", "Relu", 1, 1);
559+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*subgraph, {other_node}), SUCCESS);
560+}
561+ 
562+TEST_F(UtestFftsGraphUtils, CovGraphPartitionNoParentNode) {
563+ auto builder = ut::GraphBuilder("root");
564+ builder.AddNode("node1", "Relu", 1, 1);
565+ auto graph = builder.GetGraph();
566+ const auto &calc_func = [](const NodePtr &n) { return std::vector<uint32_t>{1}; };
567+ ASSERT_EQ(FftsGraphUtils::GraphPartition(*graph, calc_func, {8}), PARAM_INVALID);
568+}
569+ 
570+TEST_F(UtestFftsGraphUtils, CovCalculateValueSizeMismatch) {
571+ auto builder = ut::GraphBuilder("root");
572+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
573+ const auto &node2 = builder.AddNode("node2", "Relu", 1, 1);
574+ auto graph = builder.GetGraph();
575+ const auto &calc_func = [](const NodePtr &n) {
576+ if (n->GetName() == "node1") {
577+ return std::vector<uint32_t>{1};
578+ }
579+ return std::vector<uint32_t>{1, 2};
580+ };
581+ std::map<NodePtr, std::vector<uint32_t>> node_value;
582+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
583+ ASSERT_EQ(FftsGraphUtils::Calculate(graph, calc_func, node_value, graph_value, 1), GRAPH_FAILED);
584+}
585+ 
586+TEST_F(UtestFftsGraphUtils, CovIsValueInvalid) {
587+ auto builder = ut::GraphBuilder("root");
588+ const auto &node1 = builder.AddNode("node1", "Relu", 1, 1);
589+ auto graph = builder.GetGraph();
590+ std::map<NodePtr, std::vector<uint32_t>> node_value;
591+ node_value[node1] = {1, 2};
592+ std::map<ComputeGraphPtr, std::vector<uint32_t>> graph_value;
593+ graph_value[graph] = {1, 2};
594+ std::vector<uint32_t> upper_limit = {8};
595+ ASSERT_FALSE(FftsGraphUtils::IsValueValid(graph, upper_limit, node_value, graph_value));
596+}
546} // namespace ge597} // namespace ge
Atests/graph_metadef/ut/graph/testcase/ge_ir_utils_cov_unittest.cc+621-0
@@ -0,0 +1,621 @@
1+/**
2+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include <gtest/gtest.h>
12+ 
13+#include "graph/utils/ge_ir_utils.h"
14+#include "graph/utils/attr_utils.h"
15+#include "graph/compute_graph.h"
16+#include "graph/op_desc.h"
17+#include "graph/utils/graph_utils.h"
18+#include "graph/model.h"
19+#include "graph/node.h"
20+#include "graph/ge_tensor.h"
21+#include "graph_builder_utils.h"
22+#include "graph/normal_graph/node_impl.h"
23+#include "graph/debug/ge_op_types.h"
24+#include "test_std_structs.h"
25+ 
26+namespace ge {
27+class GeIrUtilsCov : public testing::Test {
28+ protected:
29+ void SetUp() {}
30+ 
31+ void TearDown() {}
32+};
33+ 
34+namespace {
35+ComputeGraphPtr BuildCovGraph() {
36+ ut::GraphBuilder builder("cov_graph");
37+ auto data = builder.AddNode("data1", "Data", 1, 1);
38+ auto add = builder.AddNode("add1", "Add", 2, 1);
39+ auto netoutput = builder.AddNode("netoutput1", "NetOutput", 1, 0);
40+ builder.AddDataEdge(data, 0, add, 0);
41+ builder.AddDataEdge(data, 0, add, 1);
42+ builder.AddDataEdge(add, 0, netoutput, 0);
43+ auto graph = builder.GetGraph();
44+ graph->AddInputNode(data);
45+ graph->AddOutputNode(netoutput);
46+ return graph;
47+}
48+ 
49+ComputeGraphPtr BuildCovGraphWithAttrs() {
50+ ut::GraphBuilder builder("cov_graph_attrs");
51+ auto data = builder.AddNode("data1", "Data", 1, 1);
52+ auto const1 = builder.AddNode("const1", "Const", 0, 1);
53+ auto add = builder.AddNode("add1", "Add", 2, 1);
54+ auto netoutput = builder.AddNode("netoutput1", "NetOutput", 1, 0);
55+ 
56+ GeTensorDesc const_td(GeShape({1, 1, 224, 224}), FORMAT_NCHW, DT_FLOAT);
57+ GeTensor tensor(const_td);
58+ std::vector<float> tensor_data(224 * 224, 1.0F);
59+ tensor.SetData(reinterpret_cast<uint8_t *>(tensor_data.data()), sizeof(float) * tensor_data.size());
60+ AttrUtils::SetTensor(const1->GetOpDesc(), "value", tensor);
61+ 
62+ AttrUtils::SetInt(add->GetOpDesc(), "int_attr", 42);
63+ AttrUtils::SetFloat(add->GetOpDesc(), "float_attr", 3.14F);
64+ AttrUtils::SetStr(add->GetOpDesc(), "str_attr", "hello");
65+ AttrUtils::SetBool(add->GetOpDesc(), "bool_attr", true);
66+ AttrUtils::SetListInt(add->GetOpDesc(), "list_int_attr", {1, 2, 3});
67+ AttrUtils::SetListFloat(add->GetOpDesc(), "list_float_attr", {1.0F, 2.0F});
68+ AttrUtils::SetListStr(add->GetOpDesc(), "list_str_attr", {"a", "b"});
69+ AttrUtils::SetListBool(add->GetOpDesc(), "list_bool_attr", {true, false});
70+ 
71+ builder.AddDataEdge(data, 0, add, 0);
72+ builder.AddDataEdge(const1, 0, add, 1);
73+ builder.AddDataEdge(add, 0, netoutput, 0);
74+ auto graph = builder.GetGraph();
75+ graph->AddInputNode(data);
76+ graph->AddOutputNode(netoutput);
77+ return graph;
78+}
79+ 
80+ComputeGraphPtr BuildCovGraphWithSubgraph() {
81+ auto root_builder = ut::GraphBuilder("root_graph");
82+ auto parent = root_builder.AddNode("parent", PARTITIONEDCALL, 0, 1);
83+ auto netoutput = root_builder.AddNode("netoutput", NETOUTPUT, 1, 0);
84+ root_builder.AddDataEdge(parent, 0, netoutput, 0);
85+ auto root_graph = root_builder.GetGraph();
86+ 
87+ auto sub_builder = ut::GraphBuilder("sub_graph");
88+ auto sub_const = sub_builder.AddNode("sub_const", "Const", 0, 1);
89+ auto sub_netoutput = sub_builder.AddNode("sub_netoutput", NETOUTPUT, 1, 0);
90+ sub_builder.AddDataEdge(sub_const, 0, sub_netoutput, 0);
91+ auto sub_graph = sub_builder.GetGraph();
92+ sub_graph->SetParentNode(parent);
93+ sub_graph->SetParentGraph(root_graph);
94+ parent->GetOpDesc()->AddSubgraphName("f");
95+ parent->GetOpDesc()->SetSubgraphInstanceName(0, "sub_graph");
96+ root_graph->AddSubGraph(sub_graph);
97+ 
98+ return root_graph;
99+}
100+} // namespace
101+ 
102+TEST_F(GeIrUtilsCov, ConvertGeModelToModelProtoSuccess) {
103+ auto compute_graph = BuildCovGraphWithAttrs();
104+ ge::Model model("test_model", "");
105+ model.SetGraph(compute_graph);
106+ onnx::ModelProto model_proto;
107+ EXPECT_TRUE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto));
108+ EXPECT_EQ(model_proto.producer_name(), "test_model");
109+ EXPECT_TRUE(model_proto.has_graph());
110+ EXPECT_GT(model_proto.graph().node_size(), 0);
111+}
112+ 
113+TEST_F(GeIrUtilsCov, ConvertGeModelToModelProtoNullGraph) {
114+ ge::Model model("empty_model", "");
115+ onnx::ModelProto model_proto;
116+ EXPECT_FALSE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto));
117+}
118+ 
119+TEST_F(GeIrUtilsCov, ConvertGeModelToModelProtoWithDumpLevel) {
120+ auto compute_graph = BuildCovGraph();
121+ ge::Model model("dump_model", "");
122+ model.SetGraph(compute_graph);
123+ onnx::ModelProto model_proto;
124+ EXPECT_TRUE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto, DumpLevel::DUMP_ALL));
125+ EXPECT_GT(model_proto.graph().node_size(), 0);
126+}
127+ 
128+TEST_F(GeIrUtilsCov, ConvertGeModelToModelProtoWithDumpNoDesc) {
129+ auto compute_graph = BuildCovGraph();
130+ ge::Model model("dump_nodesc_model", "");
131+ model.SetGraph(compute_graph);
132+ onnx::ModelProto model_proto;
133+ EXPECT_TRUE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto, DumpLevel::DUMP_WITH_OUT_DESC));
134+ EXPECT_GT(model_proto.graph().node_size(), 0);
135+}
136+ 
137+TEST_F(GeIrUtilsCov, ConvertGeModelToModelProtoWithSubgraph) {
138+ auto compute_graph = BuildCovGraphWithSubgraph();
139+ ge::Model model("subgraph_model", "");
140+ model.SetGraph(compute_graph);
141+ onnx::ModelProto model_proto;
142+ EXPECT_TRUE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto));
143+ EXPECT_GT(model_proto.graph().node_size(), 0);
144+}
145+ 
146+TEST_F(GeIrUtilsCov, EncodeDataTypeAllTypes) {
147+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_INT64), onnx::TensorProto_DataType_INT64);
148+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_FLOAT), onnx::TensorProto_DataType_FLOAT);
149+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_INT32), onnx::TensorProto_DataType_INT32);
150+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_FLOAT16), onnx::TensorProto_DataType_FLOAT16);
151+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_BOOL), onnx::TensorProto_DataType_BOOL);
152+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_DOUBLE), onnx::TensorProto_DataType_DOUBLE);
153+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_UINT8), onnx::TensorProto_DataType_UINT8);
154+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_INT8), onnx::TensorProto_DataType_INT8);
155+ EXPECT_EQ(OnnxUtils::EncodeDataType(DT_DUAL), onnx::TensorProto_DataType_UNDEFINED);
156+}
157+ 
158+TEST_F(GeIrUtilsCov, ParseNameAndIndexValid) {
159+ std::string node_name;
160+ int32_t idx = -1;
161+ EXPECT_TRUE(OnnxUtils::ParseNameAndIndex("node1:0", node_name, idx));
162+ EXPECT_EQ(node_name, "node1");
163+ EXPECT_EQ(idx, 0);
164+ 
165+ EXPECT_TRUE(OnnxUtils::ParseNameAndIndex("node2:5", node_name, idx));
166+ EXPECT_EQ(node_name, "node2");
167+ EXPECT_EQ(idx, 5);
168+}
169+ 
170+TEST_F(GeIrUtilsCov, ParseNameAndIndexNoColon) {
171+ std::string node_name;
172+ int32_t idx = -1;
173+ EXPECT_FALSE(OnnxUtils::ParseNameAndIndex("node_no_colon", node_name, idx));
174+}
175+ 
176+TEST_F(GeIrUtilsCov, DecodeAttributeStrings) {
177+ onnx::AttributeProto attr_proto;
178+ attr_proto.set_name("test_strings");
179+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRINGS);
180+ attr_proto.add_strings("value1");
181+ attr_proto.add_strings("value2");
182+ std::vector<std::string> strings;
183+ OnnxUtils::DecodeAttribute(attr_proto, strings);
184+ EXPECT_EQ(strings.size(), 2U);
185+ EXPECT_EQ(strings[0], "value1");
186+ EXPECT_EQ(strings[1], "value2");
187+}
188+ 
189+TEST_F(GeIrUtilsCov, DecodeAttributeString) {
190+ onnx::AttributeProto attr_proto;
191+ attr_proto.set_name("test_string");
192+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
193+ attr_proto.set_s("hello_world");
194+ std::string value;
195+ OnnxUtils::DecodeAttribute(attr_proto, value);
196+ EXPECT_EQ(value, "hello_world");
197+}
198+ 
199+TEST_F(GeIrUtilsCov, DecodeAttributeInts) {
200+ onnx::AttributeProto attr_proto;
201+ attr_proto.set_name("test_ints");
202+ attr_proto.set_type(onnx::AttributeProto_AttributeType_INTS);
203+ attr_proto.add_ints(10);
204+ attr_proto.add_ints(20);
205+ attr_proto.add_ints(30);
206+ std::vector<int64_t> ints;
207+ OnnxUtils::DecodeAttribute(attr_proto, ints);
208+ EXPECT_EQ(ints.size(), 3U);
209+ EXPECT_EQ(ints[0], 10);
210+ EXPECT_EQ(ints[1], 20);
211+ EXPECT_EQ(ints[2], 30);
212+}
213+ 
214+TEST_F(GeIrUtilsCov, DecodeAttributeInt) {
215+ onnx::AttributeProto attr_proto;
216+ attr_proto.set_name("test_int");
217+ attr_proto.set_type(onnx::AttributeProto_AttributeType_INT);
218+ attr_proto.set_i(99);
219+ int64_t value = 0;
220+ OnnxUtils::DecodeAttribute(attr_proto, value);
221+ EXPECT_EQ(value, 99);
222+}
223+ 
224+TEST_F(GeIrUtilsCov, DecodeAttributeWrongType) {
225+ onnx::AttributeProto attr_proto;
226+ attr_proto.set_name("wrong_type");
227+ attr_proto.set_type(onnx::AttributeProto_AttributeType_FLOAT);
228+ std::vector<std::string> strings;
229+ strings.push_back("existing");
230+ OnnxUtils::DecodeAttribute(attr_proto, strings);
231+ EXPECT_EQ(strings.size(), 1U);
232+ 
233+ std::vector<int64_t> ints;
234+ ints.push_back(1);
235+ OnnxUtils::DecodeAttribute(attr_proto, ints);
236+ EXPECT_EQ(ints.size(), 1U);
237+ 
238+ int64_t val = 5;
239+ OnnxUtils::DecodeAttribute(attr_proto, val);
240+ EXPECT_EQ(val, 5);
241+ 
242+ std::string str = "orig";
243+ OnnxUtils::DecodeAttribute(attr_proto, str);
244+ EXPECT_EQ(str, "orig");
245+}
246+ 
247+TEST_F(GeIrUtilsCov, IsEqualTemplate) {
248+ EXPECT_TRUE(IsEqual(1, 1, "int_equal"));
249+ EXPECT_FALSE(IsEqual(1, 2, "int_not_equal"));
250+ EXPECT_TRUE(IsEqual(std::string("abc"), std::string("abc"), "str_equal"));
251+ EXPECT_FALSE(IsEqual(std::string("abc"), std::string("xyz"), "str_not_equal"));
252+}
253+ 
254+TEST_F(GeIrUtilsCov, EncodeNodeSuccess) {
255+ auto graph = BuildCovGraphWithAttrs();
256+ auto add_node = graph->FindNode("add1");
257+ ASSERT_NE(add_node, nullptr);
258+ onnx::NodeProto node_proto;
259+ EXPECT_TRUE(OnnxUtils::EncodeNode(add_node, &node_proto));
260+ EXPECT_EQ(node_proto.name(), "add1");
261+ EXPECT_TRUE(node_proto.op_type().find("Add") != std::string::npos);
262+}
263+ 
264+TEST_F(GeIrUtilsCov, EncodeNodeNullPtr) {
265+ NodePtr null_node;
266+ onnx::NodeProto node_proto;
267+ EXPECT_FALSE(OnnxUtils::EncodeNode(null_node, &node_proto));
268+}
269+ 
270+TEST_F(GeIrUtilsCov, EncodeGraphSuccess) {
271+ auto graph = BuildCovGraph();
272+ onnx::GraphProto graph_proto;
273+ EXPECT_TRUE(OnnxUtils::EncodeGraph(graph, &graph_proto));
274+ EXPECT_EQ(graph_proto.name(), "cov_graph");
275+ EXPECT_GT(graph_proto.node_size(), 0);
276+}
277+ 
278+TEST_F(GeIrUtilsCov, EncodeGraphNullPtr) {
279+ ConstComputeGraphPtr null_graph;
280+ onnx::GraphProto graph_proto;
281+ EXPECT_FALSE(OnnxUtils::EncodeGraph(null_graph, &graph_proto));
282+}
283+ 
284+TEST_F(GeIrUtilsCov, EncodeNodeLinkSuccess) {
285+ auto graph = BuildCovGraph();
286+ auto netoutput = graph->FindNode("netoutput1");
287+ ASSERT_NE(netoutput, nullptr);
288+ onnx::NodeProto node_proto;
289+ EXPECT_TRUE(OnnxUtils::EncodeNodeLink(netoutput, &node_proto));
290+ EXPECT_GT(node_proto.input_size(), 0);
291+}
292+ 
293+TEST_F(GeIrUtilsCov, EncodeNodeDescSuccess) {
294+ auto graph = BuildCovGraphWithAttrs();
295+ auto add_node = graph->FindNode("add1");
296+ ASSERT_NE(add_node, nullptr);
297+ onnx::NodeProto node_proto;
298+ EXPECT_TRUE(OnnxUtils::EncodeNodeDesc(add_node, &node_proto));
299+ bool found_id = false;
300+ for (const auto &attr : node_proto.attribute()) {
301+ if (attr.name() == "id") {
302+ found_id = true;
303+ break;
304+ }
305+ }
306+ EXPECT_TRUE(found_id);
307+}
308+ 
309+TEST_F(GeIrUtilsCov, DecodeNodeDescSuccess) {
310+ auto graph = BuildCovGraphWithAttrs();
311+ auto add_node = graph->FindNode("add1");
312+ ASSERT_NE(add_node, nullptr);
313+ onnx::NodeProto node_proto;
314+ node_proto.set_name("decoded_node");
315+ node_proto.set_op_type("ge:Add");
316+ 
317+ onnx::AttributeProto *nums_in = node_proto.add_attribute();
318+ nums_in->set_name("input_desc_nums");
319+ nums_in->set_type(onnx::AttributeProto_AttributeType_INT);
320+ nums_in->set_i(2);
321+ 
322+ onnx::AttributeProto *nums_out = node_proto.add_attribute();
323+ nums_out->set_name("output_desc_nums");
324+ nums_out->set_type(onnx::AttributeProto_AttributeType_INT);
325+ nums_out->set_i(1);
326+ 
327+ OpDescPtr op_desc = std::make_shared<OpDesc>();
328+ EXPECT_TRUE(OnnxUtils::DecodeNodeDesc(&node_proto, op_desc));
329+ EXPECT_EQ(op_desc->GetName(), "decoded_node");
330+ EXPECT_EQ(op_desc->GetType(), "Add");
331+}
332+ 
333+TEST_F(GeIrUtilsCov, DecodeNodeDescFailNoColon) {
334+ onnx::NodeProto node_proto;
335+ node_proto.set_name("bad_node");
336+ node_proto.set_op_type("NoPrefix");
337+ OpDescPtr op_desc = std::make_shared<OpDesc>();
338+ EXPECT_FALSE(OnnxUtils::DecodeNodeDesc(&node_proto, op_desc));
339+}
340+ 
341+TEST_F(GeIrUtilsCov, DecodeNodeDescNullParams) {
342+ OpDescPtr op_desc;
343+ onnx::NodeProto node_proto;
344+ EXPECT_FALSE(OnnxUtils::DecodeNodeDesc(nullptr, op_desc));
345+ EXPECT_FALSE(OnnxUtils::DecodeNodeDesc(&node_proto, op_desc));
346+}
347+ 
348+TEST_F(GeIrUtilsCov, DecodeNodeLinkImpDataEdgeSuccess) {
349+ ut::GraphBuilder builder("test_link");
350+ auto node1 = builder.AddNode("src_node", "Data", 1, 1);
351+ auto node2 = builder.AddNode("dst_node", "NetOutput", 1, 0);
352+ OnnxUtils::NodeLinkInfo item("src_node", 0, node2, 0, "dst_node");
353+ EXPECT_TRUE(OnnxUtils::DecodeNodeLinkImp(item, node1));
354+}
355+ 
356+TEST_F(GeIrUtilsCov, DecodeNodeLinkImpNullNode) {
357+ NodePtr null_node;
358+ OnnxUtils::NodeLinkInfo item("src", 0, null_node, 0, "dst");
359+ EXPECT_FALSE(OnnxUtils::DecodeNodeLinkImp(item, null_node));
360+}
361+ 
362+TEST_F(GeIrUtilsCov, DecodeNodeLinkImpDataAnchorFail) {
363+ ut::GraphBuilder builder("test_link_fail");
364+ auto node1 = builder.AddNode("src_node", "Data", 1, 1);
365+ auto node2 = builder.AddNode("dst_node", "NetOutput", 1, 0);
366+ OnnxUtils::NodeLinkInfo item("src_node", 5, node2, 0, "dst_node");
367+ EXPECT_FALSE(OnnxUtils::DecodeNodeLinkImp(item, node1));
368+}
369+ 
370+TEST_F(GeIrUtilsCov, DecodeNodeLinkImpControlEdgeSuccess) {
371+ ut::GraphBuilder builder("test_ctrl");
372+ auto node1 = builder.AddNode("src_node", "Data", 1, 1);
373+ auto node2 = builder.AddNode("dst_node", "NetOutput", 1, 0);
374+ OnnxUtils::NodeLinkInfo item("src_node", -1, node2, 0, "dst_node");
375+ EXPECT_TRUE(OnnxUtils::DecodeNodeLinkImp(item, node1));
376+}
377+ 
378+TEST_F(GeIrUtilsCov, DecodeGraphSuccess) {
379+ auto graph = BuildCovGraph();
380+ ge::Model model("decode_model", "");
381+ model.SetGraph(graph);
382+ onnx::ModelProto model_proto;
383+ ASSERT_TRUE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto));
384+ 
385+ ComputeGraphPtr decoded_graph;
386+ EXPECT_TRUE(OnnxUtils::DecodeGraph(0, model_proto.graph(), decoded_graph));
387+ ASSERT_NE(decoded_graph, nullptr);
388+}
389+ 
390+TEST_F(GeIrUtilsCov, DecodeGraphMaxDepth) {
391+ onnx::GraphProto graph_proto;
392+ ComputeGraphPtr graph;
393+ EXPECT_FALSE(OnnxUtils::DecodeGraph(20, graph_proto, graph));
394+}
395+ 
396+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeFloat) {
397+ onnx::NodeProto node_proto;
398+ std::pair<const std::string, ge::GeAttrValue> attr_pair("float_attr", ge::GeAttrValue());
399+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
400+ AttrUtils::SetFloat(op_desc, "float_attr", 1.5F);
401+ GeAttrValue attr_value;
402+ op_desc->GetAttr("float_attr", attr_value);
403+ std::pair<const std::string, ge::GeAttrValue> pair("float_attr", attr_value);
404+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
405+ EXPECT_EQ(node_proto.attribute_size(), 1);
406+ EXPECT_EQ(node_proto.attribute(0).name(), "float_attr");
407+ EXPECT_EQ(node_proto.attribute(0).type(), onnx::AttributeProto_AttributeType_FLOAT);
408+ EXPECT_FLOAT_EQ(node_proto.attribute(0).f(), 1.5F);
409+}
410+ 
411+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeInt) {
412+ onnx::NodeProto node_proto;
413+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
414+ AttrUtils::SetInt(op_desc, "int_attr", 42);
415+ GeAttrValue attr_value;
416+ op_desc->GetAttr("int_attr", attr_value);
417+ std::pair<const std::string, ge::GeAttrValue> pair("int_attr", attr_value);
418+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
419+ EXPECT_EQ(node_proto.attribute_size(), 1);
420+ EXPECT_EQ(node_proto.attribute(0).name(), "int_attr");
421+ EXPECT_EQ(node_proto.attribute(0).type(), onnx::AttributeProto_AttributeType_INT);
422+ EXPECT_EQ(node_proto.attribute(0).i(), 42);
423+}
424+ 
425+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeString) {
426+ onnx::NodeProto node_proto;
427+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
428+ AttrUtils::SetStr(op_desc, "str_attr", "test_value");
429+ GeAttrValue attr_value;
430+ op_desc->GetAttr("str_attr", attr_value);
431+ std::pair<const std::string, ge::GeAttrValue> pair("str_attr", attr_value);
432+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
433+ EXPECT_EQ(node_proto.attribute_size(), 1);
434+ EXPECT_EQ(node_proto.attribute(0).name(), "str_attr");
435+ EXPECT_EQ(node_proto.attribute(0).type(), onnx::AttributeProto_AttributeType_STRING);
436+ EXPECT_EQ(node_proto.attribute(0).s(), "test_value");
437+}
438+ 
439+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeListInt) {
440+ onnx::NodeProto node_proto;
441+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
442+ AttrUtils::SetListInt(op_desc, "list_int_attr", {1, 2, 3});
443+ GeAttrValue attr_value;
444+ op_desc->GetAttr("list_int_attr", attr_value);
445+ std::pair<const std::string, ge::GeAttrValue> pair("list_int_attr", attr_value);
446+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
447+ EXPECT_EQ(node_proto.attribute_size(), 1);
448+ EXPECT_EQ(node_proto.attribute(0).name(), "list_int_attr");
449+ EXPECT_EQ(node_proto.attribute(0).type(), onnx::AttributeProto_AttributeType_INTS);
450+ EXPECT_EQ(node_proto.attribute(0).ints_size(), 3);
451+}
452+ 
453+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeListFloat) {
454+ onnx::NodeProto node_proto;
455+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
456+ AttrUtils::SetListFloat(op_desc, "list_float_attr", {1.0F, 2.0F});
457+ GeAttrValue attr_value;
458+ op_desc->GetAttr("list_float_attr", attr_value);
459+ std::pair<const std::string, ge::GeAttrValue> pair("list_float_attr", attr_value);
460+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
461+ EXPECT_EQ(node_proto.attribute_size(), 1);
462+ EXPECT_EQ(node_proto.attribute(0).name(), "list_float_attr");
463+ EXPECT_EQ(node_proto.attribute(0).type(), onnx::AttributeProto_AttributeType_FLOATS);
464+ EXPECT_EQ(node_proto.attribute(0).floats_size(), 2);
465+}
466+ 
467+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeListString) {
468+ onnx::NodeProto node_proto;
469+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
470+ AttrUtils::SetListStr(op_desc, "list_str_attr", {"a", "b"});
471+ GeAttrValue attr_value;
472+ op_desc->GetAttr("list_str_attr", attr_value);
473+ std::pair<const std::string, ge::GeAttrValue> pair("list_str_attr", attr_value);
474+ OnnxUtils::AddAttrProtoFromAttribute(pair, &node_proto);
475+ EXPECT_EQ(node_proto.attribute_size(), 1);
476+ EXPECT_EQ(node_proto.attribute(0).name(), "list_str_attr");
477+ EXPECT_EQ(node_proto.attribute(0).type(), onnx::AttributeProto_AttributeType_STRINGS);
478+ EXPECT_EQ(node_proto.attribute(0).strings_size(), 2);
479+}
480+ 
481+TEST_F(GeIrUtilsCov, AddAttrProtoFromAttributeNullNodeProto) {
482+ std::pair<const std::string, ge::GeAttrValue> pair("attr", ge::GeAttrValue());
483+ OnnxUtils::AddAttrProtoFromAttribute(pair, nullptr);
484+ SUCCEED();
485+}
486+ 
487+TEST_F(GeIrUtilsCov, AddAttrProtoNullNodeProto) {
488+ float val = 1.0F;
489+ OnnxUtils::AddAttrProto(nullptr, onnx::AttributeProto_AttributeType_FLOAT, "test", &val);
490+ SUCCEED();
491+}
492+ 
493+TEST_F(GeIrUtilsCov, AddAttrProtoFloat) {
494+ onnx::NodeProto node_proto;
495+ float val = 3.14F;
496+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_FLOAT, "float_attr", &val);
497+ EXPECT_EQ(node_proto.attribute_size(), 1);
498+ EXPECT_FLOAT_EQ(node_proto.attribute(0).f(), 3.14F);
499+}
500+ 
501+TEST_F(GeIrUtilsCov, AddAttrProtoInt) {
502+ onnx::NodeProto node_proto;
503+ int64_t val = 100;
504+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_INT, "int_attr", &val);
505+ EXPECT_EQ(node_proto.attribute_size(), 1);
506+ EXPECT_EQ(node_proto.attribute(0).i(), 100);
507+}
508+ 
509+TEST_F(GeIrUtilsCov, AddAttrProtoString) {
510+ onnx::NodeProto node_proto;
511+ std::string val = "test_str";
512+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_STRING, "str_attr", &val);
513+ EXPECT_EQ(node_proto.attribute_size(), 1);
514+ EXPECT_EQ(node_proto.attribute(0).s(), "test_str");
515+}
516+ 
517+TEST_F(GeIrUtilsCov, AddAttrProtoFloats) {
518+ onnx::NodeProto node_proto;
519+ std::vector<float> val = {1.0F, 2.0F, 3.0F};
520+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_FLOATS, "floats_attr", &val);
521+ EXPECT_EQ(node_proto.attribute_size(), 1);
522+ EXPECT_EQ(node_proto.attribute(0).floats_size(), 3);
523+}
524+ 
525+TEST_F(GeIrUtilsCov, AddAttrProtoInts) {
526+ onnx::NodeProto node_proto;
527+ std::vector<int64_t> val = {10, 20, 30};
528+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_INTS, "ints_attr", &val);
529+ EXPECT_EQ(node_proto.attribute_size(), 1);
530+ EXPECT_EQ(node_proto.attribute(0).ints_size(), 3);
531+}
532+ 
533+TEST_F(GeIrUtilsCov, AddAttrProtoStrings) {
534+ onnx::NodeProto node_proto;
535+ std::vector<std::string> val = {"a", "b"};
536+ OnnxUtils::AddAttrProto(&node_proto, onnx::AttributeProto_AttributeType_STRINGS, "strings_attr", &val);
537+ EXPECT_EQ(node_proto.attribute_size(), 1);
538+ EXPECT_EQ(node_proto.attribute(0).strings_size(), 2);
539+}
540+ 
541+TEST_F(GeIrUtilsCov, AddAttrProtoUnsupportedType) {
542+ onnx::NodeProto node_proto;
543+ int64_t val = 1;
544+ OnnxUtils::AddAttrProto(&node_proto, static_cast<onnx::AttributeProto_AttributeType>(999), "unsupported", &val);
545+ EXPECT_EQ(node_proto.attribute_size(), 1);
546+}
547+ 
548+TEST_F(GeIrUtilsCov, DecodeNodeAttributeForOpInDesc) {
549+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
550+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
551+ op_desc->AddInputDesc(tensor_desc);
552+ 
553+ onnx::AttributeProto attr_proto;
554+ attr_proto.set_name("input_desc_dtype:0");
555+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
556+ attr_proto.set_s("DT_INT32");
557+ OnnxUtils::DecodeNodeAttributeForOpInAndOutDesc(attr_proto, "input_desc_dtype", 0, op_desc);
558+ EXPECT_EQ(op_desc->GetInputDesc(0).GetDataType(), DT_INT32);
559+}
560+ 
561+TEST_F(GeIrUtilsCov, DecodeNodeAttributeForOpOutDesc) {
562+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
563+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
564+ op_desc->AddOutputDesc(tensor_desc);
565+ 
566+ onnx::AttributeProto attr_proto;
567+ attr_proto.set_name("output_desc_dtype:0");
568+ attr_proto.set_type(onnx::AttributeProto_AttributeType_STRING);
569+ attr_proto.set_s("DT_INT32");
570+ OnnxUtils::DecodeNodeAttributeForOpOutDesc(attr_proto, "output_desc_dtype", 0, op_desc);
571+ EXPECT_EQ(op_desc->GetOutputDesc(0).GetDataType(), DT_INT32);
572+}
573+ 
574+TEST_F(GeIrUtilsCov, DecodeNodeAttributeForOpDescStreamId) {
575+ auto op_desc = std::make_shared<OpDesc>("test_op", "Relu");
576+ onnx::AttributeProto attr_proto;
577+ attr_proto.set_name("stream_id");
578+ attr_proto.set_type(onnx::AttributeProto_AttributeType_INT);
579+ attr_proto.set_i(7);
580+ OnnxUtils::DecodeNodeAttributeForOpDesc(attr_proto, op_desc);
581+ EXPECT_EQ(op_desc->GetStreamId(), 7);
582+}
583+ 
584+TEST_F(GeIrUtilsCov, DecodeNodeAttributeForOpDescNullPtr) {
585+ OpDescPtr null_op;
586+ onnx::AttributeProto attr_proto;
587+ OnnxUtils::DecodeNodeAttributeForOpDesc(attr_proto, null_op);
588+ SUCCEED();
589+}
590+ 
591+TEST_F(GeIrUtilsCov, EncodeValueInfoSuccess) {
592+ auto graph = BuildCovGraph();
593+ auto data_node = graph->FindNode("data1");
594+ ASSERT_NE(data_node, nullptr);
595+ onnx::ValueInfoProto value_info;
596+ OnnxUtils::EncodeValueInfo(data_node, &value_info);
597+ EXPECT_EQ(value_info.name(), "data1");
598+}
599+ 
600+TEST_F(GeIrUtilsCov, EncodeValueInfoNullPtr) {
601+ NodePtr null_node;
602+ onnx::ValueInfoProto value_info;
603+ OnnxUtils::EncodeValueInfo(null_node, &value_info);
604+ SUCCEED();
605+}
606+ 
607+TEST_F(GeIrUtilsCov, AddInputAndOutputNodesForGraphSuccess) {
608+ auto graph = BuildCovGraph();
609+ ge::Model model("test", "");
610+ model.SetGraph(graph);
611+ onnx::ModelProto model_proto;
612+ ASSERT_TRUE(OnnxUtils::ConvertGeModelToModelProto(model, model_proto));
613+ 
614+ ComputeGraphPtr new_graph = std::make_shared<ComputeGraph>("new_graph");
615+ std::map<std::string, NodePtr> node_map;
616+ for (const auto &node : graph->GetDirectNode()) {
617+ node_map[node->GetName()] = node;
618+ }
619+ EXPECT_TRUE(OnnxUtils::AddInputAndOutputNodesForGraph(model_proto.graph(), new_graph, node_map));
620+}
621+} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/graph_utils_unittest.cc+109-0
@@ -5472,4 +5472,113 @@ TEST_F(UtestGraphUtils, PostProcess_RecordOriginalNamesWhenNotExists) {
5472 EXPECT_EQ(node1->GetName(), "test_owner/node1");5472 EXPECT_EQ(node1->GetName(), "test_owner/node1");
5473 EXPECT_EQ(node2->GetName(), "test_owner/node2");5473 EXPECT_EQ(node2->GetName(), "test_owner/node2");
5474}5474}
5475+ 
5476+TEST_F(UtestGraphUtils, CovGraphUtilsExInferShapeInNeedVerifyFail) {
5477+ ut::GraphBuilder builder = ut::GraphBuilder("test_graph");
5478+ auto node = builder.AddNode("cast", "Cast", 1, 1, FORMAT_NCHW, DT_FLOAT, {4});
5479+ AttrUtils::SetBool(node->GetOpDesc(), NEED_INFER, true);
5480+ auto graph = builder.GetGraph();
5481+ EXPECT_EQ(GraphUtilsEx::InferShapeInNeed(graph), GRAPH_FAILED);
5482+}
5483+ 
5484+TEST_F(UtestGraphUtils, CovGraphUtilsExInferShapeInNeedNoInferFunc) {
5485+ ut::GraphBuilder builder = ut::GraphBuilder("test_graph");
5486+ auto data = builder.AddNode("data", "Data", 1, 1, FORMAT_NCHW, DT_FLOAT, {4});
5487+ auto cast = builder.AddNode("cast", "Cast", 1, 1, FORMAT_NCHW, DT_FLOAT, {4});
5488+ AttrUtils::SetBool(cast->GetOpDesc(), NEED_INFER, true);
5489+ builder.AddDataEdge(data, 0, cast, 0);
5490+ auto graph = builder.GetGraph();
5491+ EXPECT_EQ(GraphUtilsEx::InferShapeInNeed(graph), GRAPH_SUCCESS);
5492+}
5493+ 
5494+TEST_F(UtestGraphUtils, CovGraphUtilsExInferShapeInNeedInferFail) {
5495+ ut::GraphBuilder builder = ut::GraphBuilder("test_graph");
5496+ auto data = builder.AddNode("data", "Data", 1, 1, FORMAT_NCHW, DT_FLOAT, {4});
5497+ auto cast = builder.AddNode("cast", "Cast", 1, 1, FORMAT_NCHW, DT_FLOAT, {4});
5498+ AttrUtils::SetBool(cast->GetOpDesc(), NEED_INFER, true);
5499+ const auto stub_func = [](Operator &op) { return GRAPH_FAILED; };
5500+ cast->GetOpDesc()->AddInferFunc(stub_func);
5501+ builder.AddDataEdge(data, 0, cast, 0);
5502+ auto graph = builder.GetGraph();
5503+ EXPECT_EQ(GraphUtilsEx::InferShapeInNeed(graph), GRAPH_FAILED);
5504+}
5505+ 
5506+TEST_F(UtestGraphUtils, CovGraphUtilsExCopyGraphWithParent) {
5507+ auto parent_cg = std::make_shared<ComputeGraph>("parent");
5508+ auto sub_cg = std::make_shared<ComputeGraph>("sub");
5509+ sub_cg->SetParentGraph(parent_cg);
5510+ Graph src_graph = GraphUtilsEx::CreateGraphFromComputeGraph(sub_cg);
5511+ Graph dst_graph("dst");
5512+ EXPECT_EQ(GraphUtilsEx::CopyGraph(src_graph, dst_graph), GRAPH_FAILED);
5513+}
5514+ 
5515+TEST_F(UtestGraphUtils, CovMoveNodeToGraphSuccess) {
5516+ auto builder = ut::GraphBuilder("src");
5517+ const auto &node = builder.AddNode("node1", "Relu", 1, 1);
5518+ auto src_graph = builder.GetGraph();
5519+ auto dst_graph = std::make_shared<ComputeGraph>("dst");
5520+ auto ret = GraphUtils::MoveNodeToGraph(node, *dst_graph);
5521+ EXPECT_EQ(ret, GRAPH_SUCCESS);
5522+ EXPECT_EQ(src_graph->GetDirectNodesSize(), 0U);
5523+ EXPECT_EQ(dst_graph->GetDirectNodesSize(), 1U);
5524+}
5525+ 
5526+TEST_F(UtestGraphUtils, CovMoveNodeToGraphNullNode) {
5527+ auto dst_graph = std::make_shared<ComputeGraph>("dst");
5528+ NodePtr null_node = nullptr;
5529+ auto ret = GraphUtils::MoveNodeToGraph(null_node, *dst_graph);
5530+ EXPECT_NE(ret, GRAPH_SUCCESS);
5531+}
5532+ 
5533+TEST_F(UtestGraphUtils, CovWriteProtoToOStreamSuccess) {
5534+ onnx::ModelProto model_proto;
5535+ model_proto.set_producer_name("test");
5536+ std::ostringstream os;
5537+ auto ret = GraphUtils::WriteProtoToOStream(model_proto, os);
5538+ EXPECT_EQ(ret, SUCCESS);
5539+ EXPECT_FALSE(os.str().empty());
5540+}
5541+ 
5542+TEST_F(UtestGraphUtils, CovWriteReadableDumpToOStreamSuccess) {
5543+ std::stringstream readable_ss;
5544+ readable_ss << "test readable dump content";
5545+ std::ostringstream os;
5546+ auto ret = GraphUtils::WriteReadableDumpToOStream(readable_ss, os);
5547+ EXPECT_EQ(ret, SUCCESS);
5548+ EXPECT_EQ(os.str(), "test readable dump content");
5549+}
5550+ 
5551+TEST_F(UtestGraphUtils, CovWriteReadableDumpToOStreamBadStream) {
5552+ std::stringstream readable_ss;
5553+ readable_ss << "test";
5554+ std::ostringstream os;
5555+ os.setstate(std::ios::failbit);
5556+ auto ret = GraphUtils::WriteReadableDumpToOStream(readable_ss, os);
5557+ EXPECT_NE(ret, SUCCESS);
5558+}
5559+ 
5560+TEST_F(UtestGraphUtils, CovDumpGEGraphByPathInt64Overload) {
5561+ auto builder = ut::GraphBuilder("root");
5562+ const auto &node = builder.AddNode("node1", "Relu", 1, 1);
5563+ auto graph = builder.GetGraph();
5564+ auto ret =
5565+ GraphUtils::DumpGEGraphByPath(graph, "./test_graph_int64.txt", static_cast<int64_t>(ge::DumpLevel::NO_DUMP));
5566+ EXPECT_EQ(ret, GRAPH_SUCCESS);
5567+ system("rm -f ./test_graph_int64.txt");
5568+}
5569+ 
5570+TEST_F(UtestGraphUtils, CovWriteReadableDumpToTextFile) {
5571+ std::stringstream readable_ss;
5572+ readable_ss << "test readable dump to file";
5573+ GraphUtils::WriteReadableDumpToTextFile(readable_ss, "./test_readable_dump_cov.txt");
5574+ SUCCEED();
5575+ system("rm -f ./test_readable_dump_cov.txt");
5576+}
5577+ 
5578+TEST_F(UtestGraphUtils, CovWriteProtoToTextFileInvalidPath) {
5579+ onnx::ModelProto model_proto;
5580+ model_proto.set_producer_name("test");
5581+ GraphUtils::WriteProtoToTextFile(model_proto, "/nonexistent_dir/cov_test.txt");
5582+ SUCCEED();
5583+}
5475} // namespace ge5584} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/node_utils_unittest.cc+71-0
@@ -1154,4 +1154,75 @@ TEST_F(UtestNodeUtils, Verify_noneed_update_output_name) {
1154 1154 
1155 EXPECT_EQ(data_node->GetOpDesc()->GetAllOutputName().cbegin()->first, "yy");1155 EXPECT_EQ(data_node->GetOpDesc()->GetAllOutputName().cbegin()->first, "yy");
1156}1156}
1157+ 
1158+TEST_F(UtestNodeUtils, CovGetParentNode) {
1159+ ut::GraphBuilder builder = ut::GraphBuilder("root");
1160+ const auto &node = builder.AddNode("node1", "Relu", 1, 1);
1161+ auto parent = NodeUtils::GetParentNode(node);
1162+ EXPECT_EQ(parent, nullptr);
1163+}
1164+ 
1165+TEST_F(UtestNodeUtils, CovGetParentNodeNullPtr) {
1166+ NodePtr null_node;
1167+ auto parent = NodeUtils::GetParentNode(null_node);
1168+ EXPECT_EQ(parent, nullptr);
1169+}
1170+ 
1171+TEST_F(UtestNodeUtils, CovGetParentNodeWithSubgraph) {
1172+ auto root_builder = ut::GraphBuilder("root_graph");
1173+ const auto &parent_node = root_builder.AddNode("parent", PARTITIONEDCALL, 0, 1);
1174+ const auto &netoutput = root_builder.AddNode("netoutput", NETOUTPUT, 1, 0);
1175+ root_builder.AddDataEdge(parent_node, 0, netoutput, 0);
1176+ auto root_graph = root_builder.GetGraph();
1177+ 
1178+ auto sub_builder = ut::GraphBuilder("sub_graph");
1179+ const auto &sub_data = sub_builder.AddNode("sub_data", "Data", 1, 1);
1180+ const auto &sub_netoutput = sub_builder.AddNode("sub_netoutput", NETOUTPUT, 1, 0);
1181+ sub_builder.AddDataEdge(sub_data, 0, sub_netoutput, 0);
1182+ auto sub_graph = sub_builder.GetGraph();
1183+ sub_graph->SetParentNode(parent_node);
1184+ sub_graph->SetParentGraph(root_graph);
1185+ parent_node->GetOpDesc()->AddSubgraphName("f");
1186+ parent_node->GetOpDesc()->SetSubgraphInstanceName(0, "sub_graph");
1187+ root_graph->AddSubGraph(sub_graph);
1188+ 
1189+ auto result = NodeUtils::GetParentNode(sub_data);
1190+ EXPECT_NE(result, nullptr);
1191+ EXPECT_EQ(result->GetName(), "parent");
1192+}
1193+ 
1194+TEST_F(UtestNodeUtils, CovRemoveSubgraphsOnNode) {
1195+ auto root_builder = ut::GraphBuilder("root_graph");
1196+ const auto &parent_node = root_builder.AddNode("parent", PARTITIONEDCALL, 0, 1);
1197+ const auto &netoutput = root_builder.AddNode("netoutput", NETOUTPUT, 1, 0);
1198+ root_builder.AddDataEdge(parent_node, 0, netoutput, 0);
1199+ auto root_graph = root_builder.GetGraph();
1200+ 
1201+ auto sub_builder = ut::GraphBuilder("sub_graph");
1202+ const auto &sub_const = sub_builder.AddNode("sub_const", "Const", 0, 1);
1203+ const auto &sub_netoutput = sub_builder.AddNode("sub_netoutput", NETOUTPUT, 1, 0);
1204+ sub_builder.AddDataEdge(sub_const, 0, sub_netoutput, 0);
1205+ auto sub_graph = sub_builder.GetGraph();
1206+ sub_graph->SetParentNode(parent_node);
1207+ sub_graph->SetParentGraph(root_graph);
1208+ parent_node->GetOpDesc()->AddSubgraphName("f");
1209+ parent_node->GetOpDesc()->SetSubgraphInstanceName(0, "sub_graph");
1210+ root_graph->AddSubgraph(sub_graph->GetName(), sub_graph);
1211+ 
1212+ EXPECT_EQ(NodeUtils::RemoveSubgraphsOnNode(parent_node), GRAPH_SUCCESS);
1213+ const auto &names = parent_node->GetOpDesc()->GetSubgraphInstanceNames();
1214+ EXPECT_EQ(names.size(), 1U);
1215+ EXPECT_EQ(names[0], "");
1216+}
1217+ 
1218+TEST_F(UtestNodeUtils, CovRemoveSubgraphsOnNodeNoSubgraph) {
1219+ ut::GraphBuilder builder = ut::GraphBuilder("root");
1220+ const auto &node = builder.AddNode("node1", "Relu", 1, 1);
1221+ EXPECT_EQ(NodeUtils::RemoveSubgraphsOnNode(node), GRAPH_SUCCESS);
1222+}
1223+ 
1224+TEST_F(UtestNodeUtils, CovRemoveSubgraphsOnNodeNullPtr) {
1225+ NodePtr null_node;
1226+ EXPECT_NE(NodeUtils::RemoveSubgraphsOnNode(null_node), GRAPH_SUCCESS);
1227+}
1157} // namespace ge1228} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/op_desc_unittest.cc+36-0
@@ -1112,4 +1112,40 @@ TEST_F(UtestOpDesc, TestGetOrderedSubgraphs) {
1112 EXPECT_EQ("static_graph", subgraph_pair[1].first);1112 EXPECT_EQ("static_graph", subgraph_pair[1].first);
1113 EXPECT_EQ(kStatic, subgraph_pair[1].second);1113 EXPECT_EQ(kStatic, subgraph_pair[1].second);
1114}1114}
1115+ 
1116+TEST_F(UtestOpDesc, CovNodeShapeTransUtilsInputReshapeType) {
1117+ auto op_desc = std::make_shared<OpDesc>("test", "Relu");
1118+ GeTensorDesc input_desc(GeShape({3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1119+ input_desc.SetOriginFormat(FORMAT_ND);
1120+ op_desc->AddInputDesc(input_desc);
1121+ AttrUtils::SetStr(op_desc->MutableInputDesc(0), ATTR_NAME_RESHAPE_INFER_TYPE, "C");
1122+ NodeShapeTransUtils trans_utils(op_desc);
1123+ EXPECT_TRUE(trans_utils.Init());
1124+ EXPECT_TRUE(trans_utils.CatchFormatAndShape());
1125+ EXPECT_TRUE(trans_utils.UpdateFormatAndShape());
1126+}
1127+ 
1128+TEST_F(UtestOpDesc, CovNodeShapeTransUtilsOutputFormatMismatch) {
1129+ auto op_desc = std::make_shared<OpDesc>("test", "Relu");
1130+ GeTensorDesc output_desc(GeShape({3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1131+ output_desc.SetOriginFormat(FORMAT_ND);
1132+ op_desc->AddOutputDesc(output_desc);
1133+ NodeShapeTransUtils trans_utils(op_desc);
1134+ EXPECT_TRUE(trans_utils.Init());
1135+ EXPECT_TRUE(trans_utils.CatchFormatAndShape());
1136+ op_desc->MutableOutputDesc(0)->SetFormat(FORMAT_HWCN);
1137+ EXPECT_FALSE(trans_utils.UpdateFormatAndShape());
1138+}
1139+ 
1140+TEST_F(UtestOpDesc, CovNodeShapeTransUtilsOutputReshapeType) {
1141+ auto op_desc = std::make_shared<OpDesc>("test", "Relu");
1142+ GeTensorDesc output_desc(GeShape({3, 224, 224}), FORMAT_NCHW, DT_FLOAT);
1143+ output_desc.SetOriginFormat(FORMAT_ND);
1144+ op_desc->AddOutputDesc(output_desc);
1145+ AttrUtils::SetStr(op_desc->MutableOutputDesc(0), ATTR_NAME_RESHAPE_INFER_TYPE, "C");
1146+ NodeShapeTransUtils trans_utils(op_desc);
1147+ EXPECT_TRUE(trans_utils.Init());
1148+ EXPECT_TRUE(trans_utils.CatchFormatAndShape());
1149+ EXPECT_TRUE(trans_utils.UpdateFormatAndShape());
1150+}
1115} // namespace ge1151} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/op_desc_utils_unittest.cc+125-0
@@ -1497,4 +1497,129 @@ TEST_F(UtestOpDescUtils, CreateConstOpWithCopy) {
1497 EXPECT_TRUE(ConstantUtils::GetWeight(const_op_desc, 0UL, weight) == true);1497 EXPECT_TRUE(ConstantUtils::GetWeight(const_op_desc, 0UL, weight) == true);
1498 EXPECT_TRUE(weight->GetData().GetData() != const_tensor_ptr->GetData().GetData());1498 EXPECT_TRUE(weight->GetData().GetData() != const_tensor_ptr->GetData().GetData());
1499}1499}
1500+ 
1501+TEST_F(UtestOpDescUtils, CovGetConstInputsEnterNode) {
1502+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
1503+ auto const_node = builder.AddNode("const1", "Const", 0, 1);
1504+ auto enter_node = builder.AddNode("enter1", ENTER, 1, 1);
1505+ auto addn = builder.AddNode("addn", "AddN", 1, 1);
1506+ int32_t weight[1] = {1};
1507+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
1508+ GeTensorPtr tensor0 = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
1509+ OpDescUtils::SetWeights(const_node, {tensor0});
1510+ AttrUtils::SetBool(enter_node->GetOpDesc(), ENTER_ATTR_CONSTANT_FLAG, true);
1511+ builder.AddDataEdge(const_node, 0, enter_node, 0);
1512+ builder.AddDataEdge(enter_node, 0, addn, 0);
1513+ auto graph = builder.GetGraph();
1514+ auto const_input_nodes = OpDescUtils::GetConstInputNode(*addn);
1515+ EXPECT_TRUE((const_input_nodes.size() == 0U) || (const_input_nodes.size() == 1U));
1516+ EXPECT_EQ(const_input_nodes[0]->GetName(), const_node->GetName());
atomgit-bot
atomgit-botatomgit-bot7月24日

🔴 Critical

测试 CovGetConstInputsEnterNode 中，第 1515 行的 EXPECT_TRUE 允许 const_input_nodes.size() 为 0 或 1，但第 1516 行无条件访问 const_input_nodes[0]。当 GetConstInputNode 返回空 vector 时（size == 0），第 1515 行断言通过，但第 1516 行发生越界访问，导致未定义行为（可能 crash）。

合约链：OpDescUtils::GetConstInputNode(*addn) 返回 vector<NodePtr> → 其 size 可能为 0（第 1515 行允许此情况）→ const_input_nodes[0] 在 size=0 时越界。

修复方向：将索引访问 const_input_nodes[0] 放入 size=1 的条件分支内，或使用 ASSERT_EQ(const_input_nodes.size(), 1U) 确保安全后再访问。

建议：将 EXPECT_TRUE((... == 0U) || (... == 1U)) 替换为 EXPECT_EQ(const_input_nodes.size(), 1U)，然后使用 ASSERT_EQ 确保安全后再访问索引 0。如果 size=0 也是合理的返回值，则应将索引访问放入条件分支中。

likedislike
不准确？
1517+ auto const_inputs = OpDescUtils::GetConstInputs(addn);
1518+ EXPECT_EQ(const_inputs.size(), 0U);
1519+}
1520+ 
1521+TEST_F(UtestOpDescUtils, CovGetConstInputsNullNode) {
1522+ ge::ConstNodePtr null_node;
1523+ auto const_inputs = OpDescUtils::GetConstInputs(null_node);
1524+ EXPECT_EQ(const_inputs.size(), 0U);
1525+}
1526+ 
1527+TEST_F(UtestOpDescUtils, CovIsNonConstInput) {
1528+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
1529+ auto data = builder.AddNode("data", "Data", 1, 1);
1530+ auto addn = builder.AddNode("addn", "AddN", 1, 1);
1531+ builder.AddDataEdge(data, 0, addn, 0);
1532+ auto graph = builder.GetGraph();
1533+ EXPECT_EQ(OpDescUtils::IsNonConstInput(addn, 0), true);
1534+ EXPECT_EQ(OpDescUtils::IsNonConstInput(addn, 5), false);
1535+ ge::ConstNodePtr null_node;
1536+ EXPECT_EQ(OpDescUtils::IsNonConstInput(null_node, 0), false);
1537+}
1538+ 
1539+TEST_F(UtestOpDescUtils, CovGetNonConstInputTensorDesc) {
1540+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
1541+ auto data = builder.AddNode("data", "Data", 1, 1);
1542+ auto const1 = builder.AddNode("const1", "Const", 0, 1);
1543+ auto addn = builder.AddNode("addn", "AddN", 2, 1);
1544+ int32_t weight[1] = {1};
1545+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
1546+ GeTensorPtr tensor0 = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
1547+ OpDescUtils::SetWeights(const1, {tensor0});
1548+ builder.AddDataEdge(data, 0, addn, 0);
1549+ builder.AddDataEdge(const1, 0, addn, 1);
1550+ auto graph = builder.GetGraph();
1551+ auto desc = OpDescUtils::GetNonConstInputTensorDesc(addn, 0);
1552+ EXPECT_EQ(desc.GetDataType(), DT_FLOAT);
1553+ size_t index = 999U;
1554+ EXPECT_TRUE(OpDescUtils::GetNonConstInputIndex(addn, 0, index));
1555+ EXPECT_EQ(index, 0U);
1556+}
1557+ 
1558+TEST_F(UtestOpDescUtils, CovGetWeightsEmpty) {
1559+ auto op_desc = std::make_shared<OpDesc>("test", "Relu");
1560+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
1561+ op_desc->AddInputDesc(tensor_desc);
1562+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
1563+ auto node = builder.AddNode("relu1", "Relu", 1, 1);
1564+ auto weights = OpDescUtils::GetWeights(node);
1565+ EXPECT_EQ(weights.size(), 0U);
1566+ ge::ConstNodePtr null_node;
1567+ auto weights2 = OpDescUtils::GetWeights(null_node);
1568+ EXPECT_EQ(weights2.size(), 0U);
1569+}
1570+ 
1571+TEST_F(UtestOpDescUtils, CovCopyOpDesc) {
1572+ auto op_desc = std::make_shared<OpDesc>("test_copy", "Relu");
1573+ GeTensorDesc tensor_desc(GeShape({4}), FORMAT_NCHW, DT_FLOAT);
1574+ op_desc->AddInputDesc(tensor_desc);
1575+ op_desc->AddOutputDesc(tensor_desc);
1576+ AttrUtils::SetInt(op_desc, "test_attr", 100);
1577+ auto copied = OpDescUtils::CopyOpDesc(op_desc);
1578+ EXPECT_NE(copied, nullptr);
1579+ EXPECT_EQ(copied->GetName(), "test_copy");
1580+ EXPECT_EQ(copied->GetType(), "Relu");
1581+ EXPECT_EQ(copied->GetInputsSize(), 1U);
1582+ EXPECT_EQ(copied->GetOutputsSize(), 1U);
1583+ int64_t val = 0;
1584+ AttrUtils::GetInt(copied, "test_attr", val);
1585+ EXPECT_EQ(val, 100);
1586+}
1587+ 
1588+TEST_F(UtestOpDescUtils, CovGetNonConstInputsSize) {
1589+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
1590+ auto data = builder.AddNode("data", "Data", 1, 1);
1591+ auto const1 = builder.AddNode("const1", "Const", 0, 1);
1592+ auto addn = builder.AddNode("addn", "AddN", 2, 1);
1593+ int32_t weight[1] = {1};
1594+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
1595+ GeTensorPtr tensor0 = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
1596+ OpDescUtils::SetWeights(const1, {tensor0});
1597+ builder.AddDataEdge(data, 0, addn, 0);
1598+ builder.AddDataEdge(const1, 0, addn, 1);
1599+ auto graph = builder.GetGraph();
1600+ auto size = OpDescUtils::GetNonConstInputsSize(addn);
1601+ EXPECT_EQ(size, 1U);
1602+ ge::ConstNodePtr null_node;
1603+ auto size2 = OpDescUtils::GetNonConstInputsSize(null_node);
1604+ EXPECT_EQ(size2, 0U);
1605+}
1606+ 
1607+TEST_F(UtestOpDescUtils, CovGetNonConstTensorDesc) {
1608+ ut::GraphBuilder builder = ut::GraphBuilder("cov_graph");
1609+ auto data = builder.AddNode("data", "Data", 1, 1);
1610+ auto const1 = builder.AddNode("const1", "Const", 0, 1);
1611+ auto addn = builder.AddNode("addn", "AddN", 2, 1);
1612+ int32_t weight[1] = {1};
1613+ GeTensorDesc weight_desc(GeShape({1}), FORMAT_NHWC, DT_INT32);
1614+ GeTensorPtr tensor0 = std::make_shared<GeTensor>(weight_desc, (uint8_t *)weight, sizeof(weight));
1615+ OpDescUtils::SetWeights(const1, {tensor0});
1616+ builder.AddDataEdge(data, 0, addn, 0);
1617+ builder.AddDataEdge(const1, 0, addn, 1);
1618+ auto graph = builder.GetGraph();
1619+ auto descs = OpDescUtils::GetNonConstTensorDesc(addn);
1620+ EXPECT_EQ(descs.size(), 1U);
1621+ ge::ConstNodePtr null_node;
1622+ auto descs2 = OpDescUtils::GetNonConstTensorDesc(null_node);
1623+ EXPECT_EQ(descs2.size(), 0U);
1624+}
1500} // namespace ge1625} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/profiler_unittest.cc+34-0
@@ -301,5 +301,39 @@ TEST_F(ProfilerUt, BeyondMaxRecordsNum) {
301 EXPECT_EQ(lines.size(), profiling::kMaxRecordNum + 3);301 EXPECT_EQ(lines.size(), profiling::kMaxRecordNum + 3);
302}302}
303*/303*/
304+ 
305+TEST_F(ProfilerUt, CovUpdateHashByIndexBeyondMax) {
306+ auto p = Profiler::Create();
307+ p->RegisterString(0, "Node1");
308+ p->UpdateHashByIndex(kMaxStrIndex, 0x123);
309+ auto s = p->GetStringHashes();
310+ EXPECT_EQ(s[0].hash == 0U, true);
311+}
312+ 
313+TEST_F(ProfilerUt, CovRegisterStringHashBeyondMax) {
314+ auto p = Profiler::Create();
315+ p->RegisterStringHash(kMaxStrIndex, 0x123, "TestNode");
316+ SUCCEED();
317+}
318+ 
319+TEST_F(ProfilerUt, CovRecordBeyondMax) {
320+ auto p = Profiler::Create();
321+ p->Record(0, 1, 2, EventType::kEventStart, std::chrono::system_clock::now());
322+ for (int64_t i = 0; i < profiling::kMaxRecordNum + 10; ++i) {
323+ p->Record(0, 1, 2, EventType::kEventStart, std::chrono::system_clock::now());
324+ }
325+ EXPECT_EQ(p->GetRecordNum(), profiling::kMaxRecordNum + 11);
326+ struct NullBuf : std::streambuf {
327+ int_type overflow(int_type c) override {
328+ return c;
329+ }
330+ std::streamsize xsputn(const char_type *, std::streamsize n) override {
331+ return n;
332+ }
333+ } null_buf;
334+ std::ostream os(&null_buf);
335+ p->Dump(os);
336+ SUCCEED();
337+}
304} // namespace profiling338} // namespace profiling
305} // namespace ge339} // namespace ge
Atests/graph_metadef/ut/graph/testcase/tensor_value_utils_unittest.cc+207-0
@@ -0,0 +1,207 @@
1+#include <gtest/gtest.h>
2+#include <vector>
3+#include "graph/tensor.h"
4+#include "graph/ge_tensor.h"
5+#include "graph/utils/tensor_value_utils.h"
6+#include "graph/utils/tensor_adapter.h"
7+ 
8+namespace ge {
9+ 
10+class TensorValueUtilsTest : public testing::Test {
11+ protected:
12+ void SetUp() {}
13+ void TearDown() {}
14+};
15+ 
16+TEST_F(TensorValueUtilsTest, CovConvertFloat) {
17+ std::vector<float> data = {1.0f, 2.0f, 3.0f};
18+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_FLOAT);
19+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(float));
20+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", true);
21+ EXPECT_NE(result.find("1"), std::string::npos);
22+}
23+ 
24+TEST_F(TensorValueUtilsTest, CovConvertInt32) {
25+ std::vector<int32_t> data = {10, 20, 30};
26+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_INT32);
27+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(int32_t));
28+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_INT32, ",", true);
29+ EXPECT_NE(result.find("10"), std::string::npos);
30+}
31+ 
32+TEST_F(TensorValueUtilsTest, CovConvertInt64) {
33+ std::vector<int64_t> data = {100, 200};
34+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_INT64);
35+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(int64_t));
36+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_INT64, ",", true);
37+ EXPECT_NE(result.find("100"), std::string::npos);
38+}
39+ 
40+TEST_F(TensorValueUtilsTest, CovConvertDouble) {
41+ std::vector<double> data = {1.5, 2.5};
42+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_DOUBLE);
43+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(double));
44+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_DOUBLE, ",", true);
45+ EXPECT_NE(result.find("1.5"), std::string::npos);
46+}
47+ 
48+TEST_F(TensorValueUtilsTest, CovConvertBool) {
49+ bool data[] = {true, false};
50+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_BOOL);
51+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data), 2U * sizeof(bool));
52+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_BOOL, ",", true);
53+ EXPECT_NE(result.find("true"), std::string::npos);
54+}
55+ 
56+TEST_F(TensorValueUtilsTest, CovConvertFp16) {
57+ uint16_t fp16_data[2] = {0x3C00, 0x4000};
58+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_FLOAT16);
59+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(fp16_data), 2U * sizeof(uint16_t));
60+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT16, ",", true);
61+ EXPECT_NE(result.find("1"), std::string::npos);
62+}
63+ 
64+TEST_F(TensorValueUtilsTest, CovConvertFp16NoSkip) {
65+ uint16_t fp16_data[3] = {0x3C00, 0x4000, 0x4200};
66+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_FLOAT16);
67+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(fp16_data), 3U * sizeof(uint16_t));
68+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT16, ",", false);
69+ EXPECT_NE(result.find("1"), std::string::npos);
70+}
71+ 
72+TEST_F(TensorValueUtilsTest, CovConvertFp16Infinity) {
73+ uint16_t fp16_data[2] = {0x7C00, 0xFC00};
74+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_FLOAT16);
75+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(fp16_data), 2U * sizeof(uint16_t));
76+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT16, ",", true);
77+ EXPECT_NE(result.find("inf"), std::string::npos);
78+}
79+ 
80+TEST_F(TensorValueUtilsTest, CovConvertFp16NaN) {
81+ uint16_t fp16_data[1] = {0x7E00};
82+ TensorDesc desc(Shape({1}), FORMAT_NCHW, DT_FLOAT16);
83+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(fp16_data), 1U * sizeof(uint16_t));
84+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT16, ",", true);
85+ EXPECT_NE(result.find("nan"), std::string::npos);
86+}
87+ 
88+TEST_F(TensorValueUtilsTest, CovConvertFp16Denormalized) {
89+ uint16_t fp16_data[2] = {0x0001, 0x0200};
90+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_FLOAT16);
91+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(fp16_data), 2U * sizeof(uint16_t));
92+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT16, ",", true);
93+ EXPECT_NE(result.find("["), std::string::npos);
94+}
95+ 
96+TEST_F(TensorValueUtilsTest, CovConvertFp16Zero) {
97+ uint16_t fp16_data[2] = {0x0000, 0x8000};
98+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_FLOAT16);
99+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(fp16_data), 2U * sizeof(uint16_t));
100+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT16, ",", true);
101+ EXPECT_NE(result.find("0"), std::string::npos);
102+}
103+ 
104+TEST_F(TensorValueUtilsTest, CovConvertUnsupportedType) {
105+ TensorDesc desc(Shape({1}), FORMAT_NCHW, DT_STRING);
106+ Tensor tensor(desc);
107+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_STRING, ",", true);
108+ EXPECT_EQ(result, "<not_supported>");
109+}
110+ 
111+TEST_F(TensorValueUtilsTest, CovConvertEmptyTensor) {
112+ TensorDesc desc(Shape({0}), FORMAT_NCHW, DT_FLOAT);
113+ Tensor tensor(desc);
114+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", true);
115+ EXPECT_EQ(result, "<empty>");
116+}
117+ 
118+TEST_F(TensorValueUtilsTest, CovConvertNullData) {
119+ GeTensor ge_tensor(GeTensorDesc(GeShape({2}), FORMAT_NCHW, DT_FLOAT));
120+ ge_tensor.SetData(std::shared_ptr<AlignedPtr>(), 10U);
121+ Tensor tensor = TensorAdapter::AsTensor(ge_tensor);
122+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", true);
123+ EXPECT_EQ(result, "<invalid>");
124+}
125+ 
126+TEST_F(TensorValueUtilsTest, CovConvertUnalignedData) {
127+ uint8_t data[3] = {1, 2, 3};
128+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_UINT8);
129+ Tensor tensor(desc, data, 3U);
130+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", true);
131+ EXPECT_EQ(result, "<invalid>");
132+}
133+ 
134+TEST_F(TensorValueUtilsTest, CovConvertUint8) {
135+ std::vector<uint8_t> data = {1, 2, 3};
136+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_UINT8);
137+ Tensor tensor(desc, data.data(), data.size() * sizeof(uint8_t));
138+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_UINT8, ",", true);
139+ EXPECT_NE(result.find("1"), std::string::npos);
140+}
141+ 
142+TEST_F(TensorValueUtilsTest, CovConvertInt8) {
143+ std::vector<int8_t> data = {1, 2, 3};
144+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_INT8);
145+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(int8_t));
146+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_INT8, ",", true);
147+ EXPECT_NE(result.find("1"), std::string::npos);
148+}
149+ 
150+TEST_F(TensorValueUtilsTest, CovConvertInt16) {
151+ std::vector<int16_t> data = {1, 2};
152+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_INT16);
153+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(int16_t));
154+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_INT16, ",", true);
155+ EXPECT_NE(result.find("1"), std::string::npos);
156+}
157+ 
158+TEST_F(TensorValueUtilsTest, CovConvertUint16) {
159+ std::vector<uint16_t> data = {1, 2};
160+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_UINT16);
161+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(uint16_t));
162+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_UINT16, ",", true);
163+ EXPECT_NE(result.find("1"), std::string::npos);
164+}
165+ 
166+TEST_F(TensorValueUtilsTest, CovConvertUint32) {
167+ std::vector<uint32_t> data = {1, 2};
168+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_UINT32);
169+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(uint32_t));
170+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_UINT32, ",", true);
171+ EXPECT_NE(result.find("1"), std::string::npos);
172+}
173+ 
174+TEST_F(TensorValueUtilsTest, CovConvertUint64) {
175+ std::vector<uint64_t> data = {1, 2};
176+ TensorDesc desc(Shape({2}), FORMAT_NCHW, DT_UINT64);
177+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(uint64_t));
178+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_UINT64, ",", true);
179+ EXPECT_NE(result.find("1"), std::string::npos);
180+}
181+ 
182+TEST_F(TensorValueUtilsTest, CovConvertSingleElement) {
183+ std::vector<float> data = {42.0f};
184+ TensorDesc desc(Shape({1}), FORMAT_NCHW, DT_FLOAT);
185+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(float));
186+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", true);
187+ EXPECT_NE(result.find("42"), std::string::npos);
188+}
189+ 
190+TEST_F(TensorValueUtilsTest, CovConvertManyElementsSkip) {
191+ std::vector<float> data = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
192+ TensorDesc desc(Shape({8}), FORMAT_NCHW, DT_FLOAT);
193+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(float));
194+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", true);
195+ EXPECT_NE(result.find("..."), std::string::npos);
196+}
197+ 
198+TEST_F(TensorValueUtilsTest, CovConvertNoSkipFloat) {
199+ std::vector<float> data = {1.0f, 2.0f, 3.0f};
200+ TensorDesc desc(Shape({3}), FORMAT_NCHW, DT_FLOAT);
201+ Tensor tensor(desc, reinterpret_cast<const uint8_t *>(data.data()), data.size() * sizeof(float));
202+ std::string result = TensorValueUtils::ConvertTensorValue(tensor, DT_FLOAT, ",", false);
203+ EXPECT_NE(result.find("1"), std::string::npos);
204+ EXPECT_NE(result.find("3"), std::string::npos);
205+}
206+ 
207+} // namespace ge
Mtests/graph_metadef/ut/graph/testcase/tuning_utils_unittest.cc+89-0
@@ -626,4 +626,93 @@ TEST_F(UtestTuningUtils, WeightExternalizationAndRecover) {
626 system("rm -rf ./aicore_subgraph_*");626 system("rm -rf ./aicore_subgraph_*");
627 system("rm -rf ./subgraph_*");627 system("rm -rf ./subgraph_*");
628}628}
629+ 
630+TEST_F(UtestTuningUtils, CovGenerateFileConstPath) {
631+ auto builder = ut::GraphBuilder("root");
632+ const auto &node = builder.AddNode("const0", CONSTANT, 0, 1);
633+ auto op_desc = node->GetOpDesc();
634+ EXPECT_FALSE(TuningUtils::GenerateFileConstPath("", op_desc).empty());
635+ EXPECT_FALSE(TuningUtils::GenerateFileConstPath("./", op_desc).empty());
636+ AttrUtils::SetStr(op_desc, "_parentNodeName", "parent");
637+ EXPECT_FALSE(TuningUtils::GenerateFileConstPath("", op_desc).empty());
638+}
639+ 
640+TEST_F(UtestTuningUtils, CovGetOrSaveReusableFileConst) {
641+ TuningUtils::reusable_weight_files_.clear();
642+ TuningUtils::hash_to_files_.clear();
643+ auto tensor = std::make_shared<GeTensor>();
644+ std::vector<uint8_t> value{1, 2, 3};
645+ std::vector<int64_t> shape{3};
646+ tensor->MutableTensorDesc().SetShape(GeShape(shape));
647+ tensor->SetData(value);
648+ tensor->MutableTensorDesc().SetDataType(DT_UINT8);
649+ std::string file_path = "./tmp_test_reusable.bin";
650+ EXPECT_EQ(TuningUtils::GetOrSaveReusableFileConst(tensor, file_path), SUCCESS);
651+ std::string file_path2 = "./tmp_test_reusable2.bin";
652+ EXPECT_EQ(TuningUtils::GetOrSaveReusableFileConst(tensor, file_path2), SUCCESS);
653+ system("rm -f ./tmp_test_reusable.bin ./tmp_test_reusable2.bin");
654+}
655+ 
656+TEST_F(UtestTuningUtils, CovCheckFilesSame) {
657+ std::string file_path = "./tmp_test_check_same.bin";
658+ std::vector<uint8_t> data = {1, 2, 3, 4, 5};
659+ std::ofstream ofs(file_path, std::ios::binary);
660+ ofs.write(reinterpret_cast<const char *>(data.data()), data.size());
661+ ofs.close();
662+ bool is_same = false;
663+ EXPECT_EQ(TuningUtils::CheckFilesSame(file_path, reinterpret_cast<const char *>(data.data()), data.size(), is_same),
664+ SUCCESS);
665+ EXPECT_TRUE(is_same);
666+ std::vector<uint8_t> diff_data = {1, 2, 3, 4, 6};
667+ bool is_same2 = false;
668+ EXPECT_EQ(TuningUtils::CheckFilesSame(file_path, reinterpret_cast<const char *>(diff_data.data()), diff_data.size(),
669+ is_same2),
670+ SUCCESS);
671+ EXPECT_FALSE(is_same2);
672+ std::vector<uint8_t> short_data = {1, 2, 3};
673+ bool is_same3 = false;
674+ EXPECT_EQ(TuningUtils::CheckFilesSame(file_path, reinterpret_cast<const char *>(short_data.data()), short_data.size(),
675+ is_same3),
676+ SUCCESS);
677+ EXPECT_FALSE(is_same3);
678+ system("rm -f ./tmp_test_check_same.bin");
679+}
680+ 
681+TEST_F(UtestTuningUtils, CovCreateDataNodeEmptyWeight) {
682+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
683+ auto pld = builder.AddNode("pld", PLACEHOLDER, 0, 1);
684+ auto empty_tensor = std::make_shared<GeTensor>();
685+ empty_tensor->MutableTensorDesc().SetDataType(DT_UINT8);
686+ empty_tensor->MutableTensorDesc().SetShape(GeShape({0}));
687+ EXPECT_EQ(ge::AttrUtils::SetTensor(pld->GetOpDesc(), "value", empty_tensor), true);
688+ NodePtr data_node;
689+ EXPECT_EQ(TuningUtils::CreateDataNode(pld, "", data_node), SUCCESS);
690+}
691+ 
692+TEST_F(UtestTuningUtils, CovHandleConst) {
693+ TuningUtils::reusable_weight_files_.clear();
694+ TuningUtils::hash_to_files_.clear();
695+ ut::GraphBuilder builder = ut::GraphBuilder("graph");
696+ auto const_node = builder.AddNode("const0", CONSTANT, 0, 1);
697+ ge::GeTensorPtr tensor = std::make_shared<GeTensor>();
698+ std::vector<uint8_t> value{1, 2, 3};
699+ std::vector<int64_t> shape{3};
700+ tensor->MutableTensorDesc().SetShape(GeShape(shape));
701+ tensor->SetData(value);
702+ tensor->MutableTensorDesc().SetDataType(DT_UINT8);
703+ EXPECT_EQ(ge::OpDescUtils::SetWeights(const_node, {tensor}), 0);
704+ NodePtr node = const_node;
705+ EXPECT_EQ(TuningUtils::HandleConst(node, ""), SUCCESS);
706+ auto const_node2 = builder.AddNode("const1", CONSTANT, 0, 1);
707+ auto empty_tensor = std::make_shared<GeTensor>();
708+ empty_tensor->MutableTensorDesc().SetDataType(DT_UINT8);
709+ empty_tensor->MutableTensorDesc().SetShape(GeShape({0}));
710+ EXPECT_EQ(ge::OpDescUtils::SetWeights(const_node2, {empty_tensor}), 0);
711+ NodePtr node2 = const_node2;
712+ EXPECT_EQ(TuningUtils::HandleConst(node2, ""), SUCCESS);
713+ auto relu_node = builder.AddNode("relu", "Relu", 1, 1);
714+ NodePtr node3 = relu_node;
715+ EXPECT_EQ(TuningUtils::HandleConst(node3, ""), SUCCESS);
716+ system("rm -rf ./tmp_weight_*");
717+}
629} // namespace ge718} // namespace ge