!441 increase ut testcase

Merge pull request !441 from jwx930962/st_parser

tests/ut/parser/testcase/caffe_parser_testcase/caffe_model/custom.proto

@@ -0,0 +1,18 @@
+syntax = "proto2";
+package domi::caffe;
+
+message FillerParameter {
+    optional string type = 1 [default = 'constant'];
+    optional float value = 2 [default = 0];
+    optional float min = 3 [default = 0];
+    optional float max = 4 [default = 1];
+    optional float mean = 5 [default = 0];
+    optional float std = 6 [default = 1];
+    optional int32 sparse = 7 [default = 1];
+    enum VarianceNorm {
+        FAN_IN = 0;
+        FAN_OUT = 1;
+        AVERAGE = 2;
+    }
+    optional VarianceNorm variance_norm = 8 [default = FAN_IN];
+}

tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc

@@ -42,6 +42,12 @@
 #undef protected
 #undef private
 
+#include <google/protobuf/compiler/importer.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/text_format.h>
+#include <google/protobuf/dynamic_message.h>
+
 using namespace domi::caffe;
 using namespace ge;
 
@@ -262,23 +268,32 @@ TEST_F(UtestCaffeParser, acl_caffe_parser) {
   EXPECT_EQ(ret, GRAPH_FAILED);
 }
 
-TEST_F(UtestCaffeParser, modelparser_parsefrommemory_success)
+TEST_F(UtestCaffeParser, ParseFromMemory_success)
 {
   std::string caseDir = __FILE__;
   std::size_t idx = caseDir.find_last_of("/");
   caseDir = caseDir.substr(0, idx);
   std::string modelFile = caseDir + "/caffe_model/caffe_add.pbtxt";
+  std::string weight_file = caseDir + "/caffe_model/caffe_add.caffemodel";
 
   const char* tmp_tf_pb_model = modelFile.c_str();
+  const char* tmp_tf_weight_model = weight_file.c_str();
   ge::Graph graph;
 
+  Status ret = ge::aclgrphParseCaffe(modelFile.c_str(), weight_file.c_str(), graph);
   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);
   CaffeModelParser modelParser;
-  MemBuffer* memBuffer = ParerUTestsUtils::MemBufferFromFile(tmp_tf_pb_model);
-  auto ret = modelParser.ParseFromMemory((char*)memBuffer->data, memBuffer->size, compute_graph);
-  free(memBuffer->data);
-  delete memBuffer;
+  MemBuffer* memBuffer1 = ParerUTestsUtils::MemBufferFromFile(tmp_tf_pb_model);
+  ret = modelParser.ParseFromMemory((char*)memBuffer1->data, memBuffer1->size, compute_graph);
   EXPECT_EQ(ret, GRAPH_FAILED);
+
+  CaffeWeightsParser weigthParser;
+  MemBuffer* memBuffer2 = ParerUTestsUtils::MemBufferFromFile(tmp_tf_weight_model);
+  ret = weigthParser.ParseFromMemory((char*)memBuffer2->data, memBuffer2->size, compute_graph);
+  free(memBuffer1->data);
+  free(memBuffer2->data);
+  delete memBuffer1;
+  delete memBuffer2;
 }
 
 TEST_F(UtestCaffeParser, caffe_parser_to_json) {
@@ -324,7 +339,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::GeTensor>(ge_tensor_desc);
   ge::OpDescPtr opDef = std::make_shared<ge::OpDesc>("","");
   auto node_tmp = GenNodeFromOpDesc(opDef);
@@ -335,12 +350,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;
 }
 
@@ -413,6 +429,20 @@ TEST_F(UtestCaffeParser, CaffeWeightsParser_Parse_test)
   graph = std::make_shared<ComputeGraph>("test");
   ret = weightParser.Parse(file, graph);
   EXPECT_EQ(ret, FAILED);
+
+  std::string caffe_proto = case_dir + "/../../../../metadef/proto/caffe/";
+  std::string custom_proto = case_dir + "/caffe_model/";
+  ge::GetParserContext().caffe_proto_path.assign(caffe_proto);
+  ge::GetParserContext().custom_proto_path.assign(custom_proto);
+  ret = weightParser.Parse(file, graph);
+  EXPECT_EQ(ret, FAILED);
+
+  custom_proto = case_dir + "/caffe_models/";
+  caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
+  ge::GetParserContext().caffe_proto_path.assign(caffe_proto);
+  ge::GetParserContext().custom_proto_path.assign(custom_proto);
+  ret = weightParser.Parse(file, graph);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
 TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseWeightByFusionProto_test)
@@ -677,6 +707,13 @@ TEST_F(UtestCaffeParser, CaffeModelParser_CustomProtoParse_test)
 
   Status ret = modelParser.CustomProtoParse(model_path, custom_proto, caffe_proto, operators);
   EXPECT_EQ(ret, PARAM_INVALID);
+
+  model_file = case_dir + "/caffe_model/caffe_add.pbtxt";
+  custom_proto = case_dir + "/../../../../../metadef/proto/caffe/caffe.proto";
+  model_path = model_file.c_str();
+  std::string caffe_proto_path = case_dir + "/../../../../../metadef/proto/caffe/caffe.proto";
+  ret = modelParser.CustomProtoParse(model_path, custom_proto, caffe_proto_path, operators);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
 TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseGraph_test)
@@ -738,6 +775,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)
@@ -752,6 +799,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<ge::OpDesc>("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)
@@ -766,6 +819,23 @@ TEST_F(UtestCaffeParser, CaffeWeightsParser_ConvertLayerParameter_test)
 
   Status ret = weightParser.ConvertLayerParameter(layer, compute_graph);
   EXPECT_EQ(ret, SUCCESS);
+
+  std::string case_dir = __FILE__;
+  case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
+  std::string caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
+  google::protobuf::compiler::DiskSourceTree sourceTree;
+  sourceTree.MapPath("project_root", caffe_proto);
+  google::protobuf::compiler::Importer importer(&sourceTree, nullptr);
+  importer.Import("project_root/caffe.proto");
+
+  auto descriptor = importer.pool()->FindMessageTypeByName("domi.caffe.LayerParameter");
+  google::protobuf::DynamicMessageFactory factory;
+  const google::protobuf::Message *proto = factory.GetPrototype(descriptor);
+  const google::protobuf::Message *message = proto->New();
+
+  ret = weightParser.ConvertLayerParameter(layer, compute_graph);
+  EXPECT_EQ(ret, SUCCESS);
+  delete message;
 }
 
 TEST_F(UtestCaffeParser, CaffeWeightsParser_CheckLayersSize_test)
@@ -914,4 +984,190 @@ 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<ge::OpDesc>("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<ge::OpDesc>("","");
+
+  Status ret = opParser.ParseParams(lay0, opDef);
+  EXPECT_EQ(ret, SUCCESS);
+
+  ge::NodePtr node;
+  ret = opParser.ParseWeights(lay0, node);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(UtestCaffeParser, CaffeModelParser_FindShareParamLayers_test)
+{
+  CaffeModelParser modelParser;
+  std::map<std::string, std::vector<std::string>> layer_params_map;
+  std::vector<std::string> 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);
+  std::string case_dir = __FILE__;
+  case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
+  std::string caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
+  google::protobuf::compiler::DiskSourceTree sourceTree;
+  sourceTree.MapPath("project_root", caffe_proto);
+  google::protobuf::compiler::Importer importer(&sourceTree, nullptr);
+  importer.Import("project_root/caffe.proto");
+
+  auto descriptor = importer.pool()->FindMessageTypeByName("domi.caffe.LayerParameter");
+  google::protobuf::DynamicMessageFactory factory;
+  const google::protobuf::Message *proto = factory.GetPrototype(descriptor);
+  const google::protobuf::Message *message = proto->New();
+
+  Status ret = weightParser.ParseLayerParameter(descriptor, message, compute_graph);
+  delete message;
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(UtestCaffeParser, CaffeModelParser_ParseLayerParameter_test)
+{
+  CaffeModelParser modelParser;
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer = net.add_layer();
+  layer->set_name("Abs");
+  layer->set_type("AbsVal");
+
+  vector<ge::Operator> operators;
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Data", "Input");
+  ge::Operator op_src = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_src);
+  operators.emplace_back(op_src);
+
+  std::string case_dir = __FILE__;
+  case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
+  std::string caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
+  google::protobuf::compiler::DiskSourceTree sourceTree;
+  sourceTree.MapPath("project_root", caffe_proto);
+  google::protobuf::compiler::Importer importer(&sourceTree, nullptr);
+  importer.Import("project_root/caffe.proto");
+
+  auto descriptor = importer.pool()->FindMessageTypeByName("domi.caffe.LayerParameter");
+  google::protobuf::DynamicMessageFactory factory;
+  const google::protobuf::Message *proto = factory.GetPrototype(descriptor);
+  const google::protobuf::Message *message = proto->New();
+  Status ret = modelParser.ParseLayerParameter(descriptor, message, operators);
+  EXPECT_EQ(ret, SUCCESS);
+  delete message;
+}
+
+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<std::string, std::string> 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_ReorderInput_test)
+{
+  CaffeModelParser modelParser;
+
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer1 = net.add_layer();
+  layer1->set_name("Abs");
+  layer1->set_type("AbsVal");
+
+  domi::caffe::LayerParameter *layer2 = net.add_layer();
+  layer2->set_name("Data");
+  layer2->set_type("Input");
+  modelParser.ReorderInput(net);
+}
+
 } // namespace ge

tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc

@@ -15,6 +15,9 @@
  */
 
 #include <gtest/gtest.h>
+
+#define protected public
+#define private public
 #include <iostream>
 #include "parser/common/op_parser_factory.h"
 #include "graph/operator_reg.h"
@@ -24,6 +27,20 @@
 #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"
+#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"
+#include "parser/common/parser_fp16_t.h"
+#undef protected
+#undef private
+
+#include <dlfcn.h>
+using namespace domi;
+using namespace testing;
+using namespace ge;
 
 namespace ge {
 class UtestAclGraphParser : public testing::Test {
@@ -94,4 +111,235 @@ 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;
+  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<std::string, std::pair<int, string>> caffe_op_identifier_map;
+  std::map<std::string, std::pair<int, string>> 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<int, std::pair<string, string>> caffe_op_identifier_map;
+  std::map<int, std::pair<string, string>> 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 = "../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)
+{
+  Status ret;
+  ProtoFileParser op;
+  int identifier = 0;
+  std::string 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)
+{
+  Status ret;
+  ProtoFileParser op;
+  std::string dest_line;
+  std::map<int, std::pair<string, string>> identifier_op_map;
+  std::map<std::string, std::pair<int, string>> op_identifier_map;
+  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);
+}
+
+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);
+}
+
+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<std::pair<std::string, GraphPass *>> 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);
+}
+
+TEST_F(UtestAclGraphParser, test_operatoreq)
+{
+  float f_val1= 2139095000.2;
+  ge::parser::fp16_t fp16_1,fp16_2;
+  fp16_1.operator=(fp16_2);
+  fp16_1.operator=(f_val1);
+
+  float f_val2= 0.0000112;
+  fp16_1.operator=(f_val2);
+
+  float f_val3= 0.0000000299;
+  fp16_1.operator=(f_val3);
+
+  float f_val4= 0.00000000299;
+  fp16_1.operator=(f_val4);
+
+  uint32_t  u_val1 = 4095;
+  fp16_1.operator=(u_val1);
+
+  uint16_t u16_val1 = 4095;
+  fp16_1.operator=(u16_val1);
+
+  int16_t int_val1 = 0;
+  fp16_1.operator=(int_val1);
+
+  int16_t int_val2 = -32767;
+  fp16_1.operator=(int_val2);
+
+  int32_t i_val = -0x7FFFFFFF;
+  fp16_1.operator=(i_val);
+
+  parser::fp16_t fp16;
+  fp16.operator=(f_val1);
+  float f = fp16; //float();
+  double d = fp16;
+  int8_t int8 = fp16;
+  uint8_t uint8 = fp16;
+  uint16_t uint16 = fp16;
+  int32_t int32 = fp16;
+  uint32_t uint32 = fp16;
+  int64_t int64 = fp16;
+  uint64_t uint64 = fp16;
+
+  (void)f;
+  (void)d;
+  (void)int8;
+  (void)uint8;
+  (void)uint8;
+  (void)uint16;
+  (void)int32;
+  (void)uint32;
+  (void)int64;
+  (void)uint64;
+
+  parser::fp16_t val;
+  val.val = 0x7C00;
+  val.IsInf();
+
+  val.val = 0xFC00;
+  val.IsInf();
+
+  parser::fp16_t fp16_3, fp16_4;
+  fp16_3.val = 1;
+  fp16_4.val = 2;
+  fp16_4.operator/(fp16_3);
+
+  fp16.val = 21504;
+  int16_t int16 = fp16;
+  int8 = fp16;
+}
+
 } // namespace ge

tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc

@@ -373,4 +373,53 @@ 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);
+}
+
+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

tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc

@@ -97,9 +97,20 @@ struct DelTransposeInfo {
   int inputIdx;
 };
 
+/*
+  message=1,LayerParameter=1
+  optional =1 repeated =1 required =1
+  */
+
 Status GetTransposeInfo(GraphDef *graph_def, std::map<std::string, std::string> &softmaxInfo,
                         std::map<std::string, DelTransposeInfo> &transposeInfo);
 
+Status EraseTransposeNode(std::map<std::string, std::string> &softmaxInfo,
+                          std::map<std::string, DelTransposeInfo> &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 +3740,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 +4015,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,6 +4035,10 @@ 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);
@@ -4020,16 +4046,22 @@ TEST_F(UtestTensorflowParser, tensorflow_FP16_parser_test)
   fp16.operator=(ui16_val);
   ui16_val = 1;
   fp16.operator=(ui16_val);
+  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 +4650,63 @@ TEST_F(UtestTensorflowParser, tensorflow_GetTransposeInfo)
   delete graph;
 }
 
+TEST_F(UtestTensorflowParser, tensorflow_EraseTransposeNode)
+{
+  Status ret;
+  DelTransposeInfo info;
+  std::map<std::string, std::string> 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<std::string, DelTransposeInfo> 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