From b3f17b4cebb01da5e12e29877f8c63d98ff0009b Mon Sep 17 00:00:00 2001 From: jwx930962 Date: Tue, 21 Dec 2021 16:49:03 +0800 Subject: [PATCH 1/3] increase ut testcase --- .../caffe_parser_unittest.cc | 82 ++++++++++++++++-- .../common/acl_graph_parser_unittest.cc | 50 +++++++++++ .../onnx_parser_unittest.cc | 14 +++ .../tensorflow_parser_unittest.cc | 86 ++++++++++++++++++- 4 files changed, 226 insertions(+), 6 deletions(-) diff --git a/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc b/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc index 4b32e98..9dbaa1f 100644 --- a/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc +++ b/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc @@ -324,7 +324,7 @@ TEST_F(UtestCaffeParser, caffe_parser_ParseParamsForDummyData_test) TEST_F(UtestCaffeParser, convertWeights_success) { CaffeOpParser parser; - ge::GeTensorDesc ge_tensor_desc = ge::GeTensorDesc(); + ge::GeTensorDesc ge_tensor_desc = ge::GeTensorDesc(); ge::GeTensorPtr weight = std::make_shared(ge_tensor_desc); ge::OpDescPtr opDef = std::make_shared("",""); auto node_tmp = GenNodeFromOpDesc(opDef); @@ -335,12 +335,13 @@ TEST_F(UtestCaffeParser, convertWeights_success) blob->add_data(1); blob->add_data(1); - domi::caffe::BlobShape *shap = blob->mutable_shape(); - shap->add_dim(1); - shap->add_dim(2); + domi::caffe::BlobShape *shap1 = blob->mutable_shape(); + shap1->add_dim(1); + shap1->add_dim(2); + shap1->add_dim(-1); Status ret = parser.ConvertWeight(*blob, "", weight); - EXPECT_EQ(domi::SUCCESS, ret); + EXPECT_EQ(FAILED, ret); delete layer; } @@ -752,6 +753,12 @@ TEST_F(UtestCaffeParser, CaffeModelParser_AddTensorDescToOpDesc_test) Status ret = model_parser.AddTensorDescToOpDesc(op_desc_src, *layer); EXPECT_EQ(ret, SUCCESS); + + op_desc_src = std::make_shared("Abs", "YoloDetectionOutput"); + layer->set_type("YoloDetectionOutput"); + layer->add_top("top"); + ret = model_parser.AddTensorDescToOpDesc(op_desc_src, *layer); + EXPECT_EQ(ret, SUCCESS); } TEST_F(UtestCaffeParser, CaffeWeightsParser_ConvertLayerParameter_test) @@ -914,4 +921,69 @@ TEST_F(UtestCaffeParser, CaffeModelParser_ParseOpParam_test) EXPECT_EQ(ret, PARAM_INVALID); } +TEST_F(UtestCaffeParser, CaffeModelParser_AddNode_test) +{ + CaffeModelParser modelParser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("AbsVal"); + layer->set_type("DetectionOutput"); + ge::ComputeGraphPtr compute_graph = build_graph(true); + + Status ret = modelParser.AddNode(*layer, compute_graph); + EXPECT_EQ(ret, FAILED); + + layer->set_type("ProposalLayer"); + ret = modelParser.AddNode(*layer, compute_graph); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_CheckValidLayer_test) +{ + CaffeModelParser modelParser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + layer->add_include(); + bool ret = modelParser.CheckValidLayer(*layer); + EXPECT_EQ(ret, false); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_ParseProto_test) +{ + CaffeModelParser modelParser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + ge::ComputeGraphPtr compute_graph = build_graph(true); + + Status ret = modelParser.ParseProto(&net, compute_graph); + EXPECT_EQ(ret, SUCCESS); + + domi::GetGraphCallback callback; + ret = modelParser.ParseProtoWithSubgraph(&net, callback, compute_graph); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestCaffeParser, CaffeOpParser_ParseParams_test) +{ + CaffeOpParser opParser; + domi::caffe::NetParameter net; + ge::OpDescPtr op_desc_src = std::make_shared("Data", "Input"); + domi::caffe::LayerParameter* lay0 = net.add_layer(); + lay0->set_name("conv"); + lay0->set_type(ge::parser::DUMMY_DATA); + + ge::OpDescPtr opDef = std::make_shared("",""); + + Status ret = opParser.ParseParams(lay0, opDef); + EXPECT_EQ(ret, SUCCESS); + + ge::NodePtr node; + ret = opParser.ParseWeights(lay0, node); + EXPECT_EQ(ret, SUCCESS); +} + } // namespace ge diff --git a/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc b/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc index 68269b8..5631b10 100644 --- a/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc +++ b/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc @@ -15,6 +15,9 @@ */ #include + +#define protected public +#define private public #include #include "parser/common/op_parser_factory.h" #include "graph/operator_reg.h" @@ -24,6 +27,9 @@ #include "external/parser/onnx_parser.h" #include "ut/parser/parser_ut_utils.h" #include "external/ge/ge_api_types.h" +#include "parser/common/proto_file_parser.h" +#undef protected +#undef private namespace ge { class UtestAclGraphParser : public testing::Test { @@ -94,4 +100,48 @@ TEST_F(UtestAclGraphParser, test_parse_acl_output_nodes) { EXPECT_EQ(ge::GetParserContext().user_out_tensors.size(), 2); } + +TEST_F(UtestAclGraphParser, test_CheckConflictOp) +{ + ge::ProtoFileParser op; + char *caffe_proto_file = "/dev/null"; + char *custom_proto_file = "/dev/null"; + std::map> caffe_op_identifier_map; + std::map> custom_op_identifier_map; + custom_op_identifier_map.insert(std::make_pair("ge", std::make_pair(1, "ge"))); + caffe_op_identifier_map.insert(std::make_pair("ge", std::make_pair(1, "ge"))); + op.CheckConflictOp(caffe_proto_file, custom_proto_file, caffe_op_identifier_map, custom_op_identifier_map); + + caffe_op_identifier_map.clear(); + caffe_op_identifier_map.insert(std::make_pair("ge", std::make_pair(2, "ge"))); + op.CheckConflictOp(caffe_proto_file, custom_proto_file, caffe_op_identifier_map, custom_op_identifier_map); +} + +TEST_F(UtestAclGraphParser, test_CheckConflictIdentifier) +{ + ge::ProtoFileParser op; + char *caffe_proto_file = "/dev/null"; + char *custom_proto_file = "/dev/null"; + std::map> caffe_op_identifier_map; + std::map> custom_op_identifier_map; + custom_op_identifier_map.insert(std::make_pair(1, std::make_pair("ge", "ge"))); + caffe_op_identifier_map.insert(std::make_pair(1, std::make_pair("ge", "ge"))); + op.CheckConflictIdentifier(caffe_proto_file, custom_proto_file, caffe_op_identifier_map, custom_op_identifier_map); + + caffe_op_identifier_map.clear(); + caffe_op_identifier_map.insert(std::make_pair(1, std::make_pair("acl", "ge"))); + op.CheckConflictIdentifier(caffe_proto_file, custom_proto_file, caffe_op_identifier_map, custom_op_identifier_map); +} + +TEST_F(UtestAclGraphParser, test_AddCustomAndConflictLayer) +{ + Status ret; + char *custom_proto_file = "/dev/null"; + ge::ProtoFileParser op; + std::ofstream write_tmp; + ret = op.ProtoFileParser::AddCustomAndConflictLayer(custom_proto_file, write_tmp); + EXPECT_EQ(ret, SUCCESS); +} + + } // namespace ge \ No newline at end of file diff --git a/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc b/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc index 3fa0261..864b3c2 100644 --- a/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc +++ b/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc @@ -373,4 +373,18 @@ TEST_F(UtestOnnxParser, onnx_test_TransNodeToOperator) EXPECT_EQ(ret, SUCCESS); } +TEST_F(UtestOnnxParser, onnx_test_ModelParseToGraph) +{ + OnnxModelParser modelParser; + ge::onnx::ModelProto model_proto; + ge::onnx::OperatorSetIdProto* op_st = model_proto.add_opset_import(); + op_st->set_domain("ai.onnx"); + op_st->set_version(11); + + ge::Graph root_graph; + + Status ret = modelParser.ModelParseToGraph(model_proto, root_graph); + EXPECT_EQ(ret, FAILED); +} + } // namespace ge diff --git a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc index feff339..8d15701 100644 --- a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc +++ b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc @@ -100,6 +100,12 @@ struct DelTransposeInfo { Status GetTransposeInfo(GraphDef *graph_def, std::map &softmaxInfo, std::map &transposeInfo); +Status EraseTransposeNode(std::map &softmaxInfo, + std::map &transposeInfo); + +Status ComputeArgRange(const domi::tensorflow::NodeDef &node_def, const domi::tensorflow::OpDef::ArgDef &arg_def, + int *num); + class UtestTensorflowParser : public testing::Test { protected: void SetUp() { @@ -3729,6 +3735,9 @@ TEST_F(UtestTensorflowParser, input_proto_real_path_success) { std::ofstream write_tmp; ret = proto_file_parser.AddCustomAndConflictMessage(custom_proto_path, write_tmp); EXPECT_EQ(ret, FAILED); + + ret = proto_file_parser.AddCustomAndConflictLayer(custom_proto_path, write_tmp); + EXPECT_EQ(ret, FAILED); } TEST_F(UtestTensorflowParser, all_success) @@ -4001,9 +4010,17 @@ TEST_F(UtestTensorflowParser, tensorflow_FP16_parser_test) float f_val = 0.1; fp16.operator=(f_val); + f_val = 1000000.5; + fp16.operator=(f_val); + f_val = 0.00001; + fp16.operator=(f_val); double d_val = 0.2; fp16.operator=(d_val); + d_val = 200000.2; + fp16.operator=(d_val); + d_val = 0.00002; + fp16.operator=(d_val); int8_t i_val = 1; fp16.operator=(i_val); @@ -4013,23 +4030,31 @@ TEST_F(UtestTensorflowParser, tensorflow_FP16_parser_test) int16_t i_vals = 1; fp16.operator=(i_vals); + i_vals = 5000; + fp16.operator=(i_vals); + i_vals = 0; + fp16.operator=(i_vals); uint16_t ui16_val = 1; fp16.operator=(ui16_val); ui16_val = 0; fp16.operator=(ui16_val); - ui16_val = 1; + ui16_val = 5000; fp16.operator=(ui16_val); int32_t i32_val = 0; fp16.operator=(i32_val); i32_val = 1; fp16.operator=(i32_val); + i32_val = 5000; + fp16.operator=(i32_val); uint32_t ui32_val = 0; fp16.operator=(ui32_val); ui32_val = 1; fp16.operator=(ui32_val); + ui32_val = 5000; + fp16.operator=(ui32_val); } TEST_F(UtestTensorflowParser, tensorflow_AclParserInitialize_test) @@ -4618,4 +4643,63 @@ TEST_F(UtestTensorflowParser, tensorflow_GetTransposeInfo) delete graph; } +TEST_F(UtestTensorflowParser, tensorflow_EraseTransposeNode) +{ + Status ret; + DelTransposeInfo info; + std::map softmaxInfo = {{"Softmax", "Softmax"}}; + + info.node_def = new NodeDef(); + info.nextNodeDef = new NodeDef(); + info.node_def->add_input("ge"); + info.nextNodeDef->add_input("ge"); + info.nextNodeDef->set_name("ge"); + info.inputIdx = 0; + + std::map transposeInfo = {{"Softmax", info}}; + + ret = EraseTransposeNode(softmaxInfo, transposeInfo); + EXPECT_EQ(ret, FAILED); + + delete info.node_def; + delete info.nextNodeDef; +} + +TEST_F(UtestTensorflowParser, tensorflow_GetUniqueName) +{ + string name_ge = "ge", name_ge_1 = "ge_0", name_ge_2 = "ge_1"; + NameMapHelper helper; + helper.used_names_.insert(name_ge); + helper.used_names_.insert(name_ge_1); + string ret = helper.GetUniqueName(name_ge); + EXPECT_EQ(ret, name_ge_2); +} + +TEST_F(UtestTensorflowParser, tensorflow_UniqueInputOrOutputName) +{ + string name; + NameMapHelper helper; + string ret = helper.UniqueInputOrOutputName(name); + EXPECT_EQ(ret, "unknown"); +} + +TEST_F(UtestTensorflowParser, tensorflow_Renormalize) +{ + string name = "ge"; + NameMapHelper helper; + helper.name_mapping_.insert(std::make_pair("ge", "ge")); + string ret = helper.Renormalize(name); + EXPECT_EQ(ret, "ge"); +} + +TEST_F(UtestTensorflowParser, tensorflow_ComputeArgRange) +{ + domi::Status ret; + domi::tensorflow::NodeDef node_def; + domi::tensorflow::OpDef::ArgDef arg_def; + int num; + ret = ComputeArgRange(node_def, arg_def, &num); + EXPECT_EQ(ret, domi::INTERNAL_ERROR); +} + } // namespace ge From ed4c99de028259c0796d8b80118d577761b1d39a Mon Sep 17 00:00:00 2001 From: jwx930962 Date: Tue, 21 Dec 2021 20:26:15 +0800 Subject: [PATCH 2/3] ut testcase --- .../common/acl_graph_parser_unittest.cc | 85 +++++++++++++++++-- 1 file changed, 80 insertions(+), 5 deletions(-) diff --git a/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc b/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc index 5631b10..bd071a4 100644 --- a/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc +++ b/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc @@ -28,9 +28,14 @@ #include "ut/parser/parser_ut_utils.h" #include "external/ge/ge_api_types.h" #include "parser/common/proto_file_parser.h" +#include "omg/parser/parser_factory.h" +#include "parser/caffe/caffe_parser.h" #undef protected #undef private +using namespace domi; +using namespace testing; + namespace ge { class UtestAclGraphParser : public testing::Test { protected: @@ -104,8 +109,9 @@ TEST_F(UtestAclGraphParser, test_parse_acl_output_nodes) { TEST_F(UtestAclGraphParser, test_CheckConflictOp) { ge::ProtoFileParser op; - char *caffe_proto_file = "/dev/null"; - char *custom_proto_file = "/dev/null"; + std::string custom_file = "/dev/null"; + const char *caffe_proto_file = custom_file.c_str(); + const char *custom_proto_file = custom_file.c_str(); std::map> caffe_op_identifier_map; std::map> custom_op_identifier_map; custom_op_identifier_map.insert(std::make_pair("ge", std::make_pair(1, "ge"))); @@ -120,8 +126,9 @@ TEST_F(UtestAclGraphParser, test_CheckConflictOp) TEST_F(UtestAclGraphParser, test_CheckConflictIdentifier) { ge::ProtoFileParser op; - char *caffe_proto_file = "/dev/null"; - char *custom_proto_file = "/dev/null"; + std::string custom_file = "/dev/null"; + const char *caffe_proto_file = custom_file.c_str(); + const char *custom_proto_file = custom_file.c_str(); std::map> caffe_op_identifier_map; std::map> custom_op_identifier_map; custom_op_identifier_map.insert(std::make_pair(1, std::make_pair("ge", "ge"))); @@ -136,12 +143,80 @@ TEST_F(UtestAclGraphParser, test_CheckConflictIdentifier) TEST_F(UtestAclGraphParser, test_AddCustomAndConflictLayer) { Status ret; - char *custom_proto_file = "/dev/null"; + std::string custom_file = "/dev/null"; + const char *custom_proto_file = custom_file.c_str(); ge::ProtoFileParser op; std::ofstream write_tmp; ret = op.ProtoFileParser::AddCustomAndConflictLayer(custom_proto_file, write_tmp); EXPECT_EQ(ret, SUCCESS); } +TEST_F(UtestAclGraphParser, test_FindConflictLine) +{ + Status ret; + ProtoFileParser op; + int identifier = 0; + std::string dest_line; + std::string file = "../parser/caffe/caffe_parser.h"; + const char *proto_file = file.c_str(); + ret = op.FindConflictLine(proto_file, identifier, dest_line); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestAclGraphParser, test_ParseProtoFile) +{ + Status ret; + ProtoFileParser op; + std::string dest_line; + std::map> identifier_op_map; + std::map> op_identifier_map; + string proto_file = "../parser/caffe/caffe_parser.h"; + ret = op.ParseProtoFile(proto_file, identifier_op_map, op_identifier_map); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestAclGraphParser, test_AddCustomAndConflictMessage) +{ + Status ret; + ProtoFileParser op; + std::ofstream write_tmp; + std::string file = "../parser/caffe/caffe_parser.h"; + const char *proto_file = file.c_str(); + ret = op.AddCustomAndConflictMessage(proto_file, write_tmp); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestAclGraphParser, test_RecordProtoMessage) +{ + Status ret; + ProtoFileParser op; + std::string file = "../parser/caffe/caffe_parser.h"; + const char *proto_file = file.c_str(); + ret = op.RecordProtoMessage(proto_file); + EXPECT_EQ(ret, SUCCESS); +} + + +TEST_F(UtestAclGraphParser, test_WriteCaffeProtoFile) +{ + Status ret; + ProtoFileParser op; + std::string file = "../parser/caffe/caffe_parser.h"; + const char *proto_file = file.c_str(); + std::ifstream read_caffe("../parser/caffe/caffe_parser.h", std::ifstream::in); + std::ofstream write_tmp("/dev/null", std::ifstream::in); + ret = op.WriteCaffeProtoFile(proto_file, read_caffe, write_tmp); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestAclGraphParser, test_CreatProtoFile) +{ + Status ret; + ProtoFileParser op; + op.fusion_proto_path = "/ge/ge/ge/ge.c"; + ret = op.CreatProtoFile(); + EXPECT_EQ(ret, FAILED); +} + } // namespace ge \ No newline at end of file From 09f17be3bfd99c77f7e4f4570def18f5ad18d3aa Mon Sep 17 00:00:00 2001 From: jwx930962 Date: Wed, 22 Dec 2021 17:58:59 +0800 Subject: [PATCH 3/3] increase ut testcase --- .../caffe_parser_unittest.cc | 115 ++++++++++++++++++ .../common/acl_graph_parser_unittest.cc | 71 +++++++++-- .../onnx_parser_unittest.cc | 35 ++++++ .../tensorflow_parser_unittest.cc | 5 + 4 files changed, 216 insertions(+), 10 deletions(-) diff --git a/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc b/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc index 9dbaa1f..1b56c38 100644 --- a/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc +++ b/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc @@ -42,6 +42,11 @@ #undef protected #undef private +#include +#include +#include +#include + using namespace domi::caffe; using namespace ge; @@ -739,6 +744,16 @@ TEST_F(UtestCaffeParser, CaffeModelParser_GetCustomOp_test) Status ret = model_parser.GetCustomOp(*layer, operators); EXPECT_EQ(ret, SUCCESS); + + ge::Operator ops2("Conv", "Convolution"); + model_parser.custom_operator_.push_back(ops2); + ret = model_parser.GetCustomOp(*layer, operators); + EXPECT_EQ(ret, SUCCESS); + + ge::Operator ops("Data", "Input"); + model_parser.custom_operator_.push_back(ops); + ret = model_parser.GetCustomOp(*layer, operators); + EXPECT_EQ(ret, SUCCESS); } TEST_F(UtestCaffeParser, CaffeModelParser_AddTensorDescToOpDesc_test) @@ -986,4 +1001,104 @@ TEST_F(UtestCaffeParser, CaffeOpParser_ParseParams_test) EXPECT_EQ(ret, SUCCESS); } +TEST_F(UtestCaffeParser, CaffeModelParser_FindShareParamLayers_test) +{ + CaffeModelParser modelParser; + std::map> layer_params_map; + std::vector layer_params; + layer_params.emplace_back("Conv"); + layer_params.emplace_back("Data"); + layer_params.emplace_back("Abs"); + layer_params_map.insert(std::make_pair("Abs", layer_params)); + layer_params_map.insert(std::make_pair("Data", layer_params)); + layer_params_map.insert(std::make_pair("Conv", layer_params)); + + Status ret = modelParser.FindShareParamLayers(layer_params_map); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseLayerParameter_test) +{ + CaffeWeightsParser weightParser; + + domi::caffe::NetParameter net; + GetParserContext().type = domi::CAFFE; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + + ge::ComputeGraphPtr compute_graph = build_graph(true); + const google::protobuf::Descriptor *descriptor = net.GetDescriptor(); + + Status ret = weightParser.ParseLayerParameter(descriptor, &net, compute_graph); + EXPECT_EQ(ret, PARAM_INVALID); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_ParseLayerParameter_test) +{ + CaffeModelParser modelParser; + domi::caffe::NetParameter net; + GetParserContext().type = domi::CAFFE; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + + vector operators; + ge::OpDescPtr op_desc_src = std::make_shared("Data", "Input"); + ge::Operator op_src = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_src); + operators.emplace_back(op_src); + + const google::protobuf::Descriptor *descriptor = net.GetDescriptor(); + Status ret = modelParser.ParseLayerParameter(descriptor, &net, operators); + EXPECT_EQ(ret, PARAM_INVALID); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_ReadModelWithoutWarning_test) +{ + CaffeModelParser modelParser; + std::string case_dir = __FILE__; + case_dir = case_dir.substr(0, case_dir.find_last_of("/")); + std::string model_file = case_dir + "/caffe_model/caffe.pbtxt"; + const char *model_path = model_file.c_str(); + + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + + Status ret = modelParser.ReadModelWithoutWarning(model_path, &net); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_AddBlobsToMap_test) +{ + CaffeModelParser modelParser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + std::map inplace_blob_name_remapping{{"bottom", "AbsVal"}}; + + layer->add_top("top"); + layer->add_bottom("bottom"); + modelParser.AddBlobsToMap(*layer, inplace_blob_name_remapping); +} + +TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseWeightByFusionProto_test2) +{ + std::string case_dir = __FILE__; + case_dir = case_dir.substr(0, case_dir.find_last_of("/")); + std::string model_file = case_dir + "/caffe_model/caffe_abs.pbtxt"; + const char *weight_path = model_file.c_str(); + std::string fusion_proto_path = case_dir + "/caffe_model/custom.proto"; + string fusion_proto_name = "domi.caffe.NetParameter"; + vector operators; + ge::OpDescPtr op_desc_src = std::make_shared("Data", "Input"); + ge::Operator op_src = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_src); + operators.emplace_back(op_src); + + CaffeModelParser modelParser; + modelParser.ParseNetModelByCustomProto(weight_path, fusion_proto_path, fusion_proto_name, operators); +} + } // namespace ge diff --git a/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc b/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc index bd071a4..862744c 100644 --- a/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc +++ b/tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc @@ -30,11 +30,16 @@ #include "parser/common/proto_file_parser.h" #include "omg/parser/parser_factory.h" #include "parser/caffe/caffe_parser.h" +#include "register/register.h" +#include "parser/common/pass_manager.h" +#include "parser/common/tbe_plugin_loader.h" #undef protected #undef private +#include using namespace domi; using namespace testing; +using namespace ge; namespace ge { class UtestAclGraphParser : public testing::Test { @@ -119,16 +124,15 @@ TEST_F(UtestAclGraphParser, test_CheckConflictOp) op.CheckConflictOp(caffe_proto_file, custom_proto_file, caffe_op_identifier_map, custom_op_identifier_map); caffe_op_identifier_map.clear(); - caffe_op_identifier_map.insert(std::make_pair("ge", std::make_pair(2, "ge"))); + caffe_op_identifier_map.insert(std::make_pair("ge", std::make_pair(2, "ge"))); op.CheckConflictOp(caffe_proto_file, custom_proto_file, caffe_op_identifier_map, custom_op_identifier_map); } TEST_F(UtestAclGraphParser, test_CheckConflictIdentifier) { ge::ProtoFileParser op; - std::string custom_file = "/dev/null"; - const char *caffe_proto_file = custom_file.c_str(); - const char *custom_proto_file = custom_file.c_str(); + char *caffe_proto_file = "/dev/null"; + char *custom_proto_file = "/dev/null"; std::map> caffe_op_identifier_map; std::map> custom_op_identifier_map; custom_op_identifier_map.insert(std::make_pair(1, std::make_pair("ge", "ge"))); @@ -143,12 +147,15 @@ TEST_F(UtestAclGraphParser, test_CheckConflictIdentifier) TEST_F(UtestAclGraphParser, test_AddCustomAndConflictLayer) { Status ret; - std::string custom_file = "/dev/null"; - const char *custom_proto_file = custom_file.c_str(); + char *custom_proto_file = "../parser/caffe/caffe_parser.h"; ge::ProtoFileParser op; std::ofstream write_tmp; ret = op.ProtoFileParser::AddCustomAndConflictLayer(custom_proto_file, write_tmp); EXPECT_EQ(ret, SUCCESS); + + custom_proto_file = "/dev/ge"; + ret = op.ProtoFileParser::AddCustomAndConflictLayer(custom_proto_file, write_tmp); + EXPECT_EQ(ret, FAILED); } TEST_F(UtestAclGraphParser, test_FindConflictLine) @@ -157,10 +164,14 @@ TEST_F(UtestAclGraphParser, test_FindConflictLine) ProtoFileParser op; int identifier = 0; std::string dest_line; - std::string file = "../parser/caffe/caffe_parser.h"; - const char *proto_file = file.c_str(); - ret = op.FindConflictLine(proto_file, identifier, dest_line); + string search_string("message=1,LayerParameter=1"); + string search_string1("optional=1 repeated=2 required=3 "); + ret = op.FindConflictLine("../tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc", identifier, dest_line); EXPECT_EQ(ret, FAILED); + + identifier = 1; + ret = op.FindConflictLine("../tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc", identifier, dest_line); + EXPECT_EQ(ret, SUCCESS); } TEST_F(UtestAclGraphParser, test_ParseProtoFile) @@ -170,7 +181,7 @@ TEST_F(UtestAclGraphParser, test_ParseProtoFile) std::string dest_line; std::map> identifier_op_map; std::map> op_identifier_map; - string proto_file = "../parser/caffe/caffe_parser.h"; + string proto_file = "../tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc"; ret = op.ParseProtoFile(proto_file, identifier_op_map, op_identifier_map); EXPECT_EQ(ret, SUCCESS); } @@ -218,5 +229,45 @@ TEST_F(UtestAclGraphParser, test_CreatProtoFile) EXPECT_EQ(ret, FAILED); } +TEST_F(UtestAclGraphParser, test_Finalize) +{ + bool ret; + bool is_train = true; + ge::OpRegistrationTbe op; + ge::OpRegistrationData reg_data("c"); + ret = op.Finalize(reg_data, is_train); + EXPECT_EQ(ret, false); +} + +TEST_F(UtestAclGraphParser, test_WriteProtoFile) +{ + Status ret; + ProtoFileParser op; + char *caffe_proto_file = "/dev/null"; + char *custom_proto_file = "/ge/ge/ge/ge.c"; + ret = op.WriteProtoFile(caffe_proto_file, custom_proto_file); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestAclGraphParser, test_GraphPasses) +{ + std::vector> v; + ge::parser::PassManager manager; + v = manager.GraphPasses(); +} + +TEST_F(UtestAclGraphParser, test_ClearHandles_) +{ + Status ret; + TBEPluginLoader loader; + void *handle = dlopen("/lib/libdmmp.so", RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE); + if (handle == nullptr) { + return; + } + loader.handles_vec_.push_back(handle); + dlclose(handle); + ret = loader.ClearHandles_(); + EXPECT_EQ(ret, SUCCESS); +} } // namespace ge \ No newline at end of file diff --git a/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc b/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc index 864b3c2..0b50fd3 100644 --- a/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc +++ b/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc @@ -387,4 +387,39 @@ TEST_F(UtestOnnxParser, onnx_test_ModelParseToGraph) EXPECT_EQ(ret, FAILED); } +TEST_F(UtestOnnxParser, onnx_test_ParseFromMemory) +{ + OnnxModelParser modelParser; + char *data = nullptr; + uint32_t size = 1; + ge::Graph graph; + + Status ret = modelParser.ParseFromMemory(data, size, graph); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestOnnxParser, onnx_test_Parse) +{ + OnnxModelParser modelParser; + const char *file = nullptr; + ge::Graph graph; + + Status ret = modelParser.Parse(file, graph); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestOnnxParser, onnx_test_GetModelFromMemory) +{ + OnnxModelParser modelParser; + const char *data = "ut/parser/testcase/onnx_parser_testcase"; + uint32_t size = 1; + ge::onnx::ModelProto model_proto; + + Status ret = modelParser.GetModelFromMemory(data, size, model_proto); + EXPECT_EQ(ret, FAILED); + + ret = modelParser.GetModelFromFile(data, model_proto); + EXPECT_EQ(ret, FAILED); +} + } // namespace ge diff --git a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc index 8d15701..e9b837e 100644 --- a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc +++ b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc @@ -97,6 +97,11 @@ struct DelTransposeInfo { int inputIdx; }; +/* + message=1,LayerParameter=1 + optional =1 repeated =1 required =1 + */ + Status GetTransposeInfo(GraphDef *graph_def, std::map &softmaxInfo, std::map &transposeInfo);