increase ut testcase

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::GeTensor>(ge_tensor_desc);
   ge::OpDescPtr opDef = std::make_shared<ge::OpDesc>("","");
   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<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 +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<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);
+}
+
 } // 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,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<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 = "/dev/null";
+  ge::ProtoFileParser op;
+  std::ofstream write_tmp;
+  ret = op.ProtoFileParser::AddCustomAndConflictLayer(custom_proto_file, write_tmp);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+
 } // namespace ge

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

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

@@ -100,6 +100,12 @@ struct DelTransposeInfo {
 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 +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<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