Pre Merge pull request !438 from jwx930962/st_parser

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

@@ -42,6 +42,11 @@
 #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>
+
 using namespace domi::caffe;
 using namespace ge;
 
@@ -324,7 +329,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 +340,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;
 }
 
@@ -738,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)
@@ -752,6 +768,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)
@@ -914,4 +936,169 @@ 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);
+  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<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);
+
+  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<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_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<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);
+
+  CaffeModelParser modelParser;
+  modelParser.ParseNetModelByCustomProto(weight_path, fusion_proto_path, fusion_proto_name, operators);
+}
+
 } // 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,19 @@
 #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"
+#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 +110,164 @@ 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);
+}
+
 } // 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,23 +4035,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 +4648,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