increase parser ut

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

@@ -38,6 +38,7 @@
 #include "parser/caffe/caffe_op_parser.h"
 #include "graph/operator_reg.h"
 #include "parser/common/acl_graph_parser_util.h"
+#include "parser/caffe/caffe_reshape_parser.h"
 #undef protected
 #undef private
 
@@ -269,7 +270,6 @@ TEST_F(UtestCaffeParser, modelparser_parsefrommemory_success)
   std::string modelFile = caseDir + "/caffe_model/caffe_add.pbtxt";
 
   const char* tmp_tf_pb_model = modelFile.c_str();
-  printf("------------model_file:%s---------------------\n", tmp_tf_pb_model);
   ge::Graph graph;
 
   ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);
@@ -648,6 +648,18 @@ TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_test)
   EXPECT_EQ(ret, FAILED);
 }
 
+TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_test2)
+{
+  CaffeModelParser modelParser;
+  domi::caffe::NetParameter net;
+  net.add_input("111");
+  bool input_data_flag = true;
+
+  net.add_input_shape();
+  Status ret = modelParser.ParseInput(net, input_data_flag);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
 TEST_F(UtestCaffeParser, CaffeModelParser_CustomProtoParse_test)
 {
   CaffeModelParser modelParser;
@@ -806,4 +818,100 @@ TEST_F(UtestCaffeParser, CaffeWeightsParser_CheckNodes_test)
   EXPECT_EQ(ret, SUCCESS);
 }
 
+TEST_F(UtestCaffeParser, CaffeModelParser_RemapTopNameByLayer_test)
+{
+  CaffeModelParser model_parser;
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer = net.add_layer();
+  layer->set_name("Abs");
+  layer->set_type("AbsVal");
+
+  std::string top_name = "Abs";
+  int index = 1;
+
+  model_parser.RemapTopNameByLayer(*layer, top_name, index);
+}
+
+TEST_F(UtestCaffeParser, CaffeModelParser_SaveDataLayerTops_test)
+{
+  CaffeModelParser model_parser;
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer = net.add_layer();
+  layer->set_name("Abs");
+  layer->set_type("AbsVal");
+
+  Status ret = model_parser.SaveDataLayerTops(*layer);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(UtestCaffeParser, CaffeModelParser_ReadCaffeModelFromText_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.ReadCaffeModelFromText(model_path, &net);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(UtestCaffeParser, CaffeReshapeParser_ParseParams_test)
+{
+  CaffeReshapeParser reshapeParser;
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer = net.add_layer();
+  domi::caffe::ReshapeParameter* reshape_param = layer->mutable_reshape_param();
+  layer->add_bottom("bottom");
+  layer->add_top("top");
+
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Abs", "AbsVal");
+  Status ret = reshapeParser.ParseParams(layer, op_desc_src);
+  EXPECT_EQ(ret, FAILED);
+
+  domi::caffe::BlobShape *blob_shape = reshape_param->mutable_shape();
+  blob_shape->add_dim(2);
+  blob_shape->add_dim(3);
+  reshape_param->set_axis(0);
+  reshape_param->set_num_axes(-1);
+  ret = reshapeParser.ParseParams(layer, op_desc_src);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(UtestCaffeParser, CaffeReshapeParser_ParseWeights_test)
+{
+  CaffeReshapeParser reshapeParser;
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer = net.add_layer();
+  domi::caffe::ReshapeParameter* reshape_param = layer->mutable_reshape_param();
+  layer->add_bottom("bottom");
+  layer->add_top("top");
+
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Abs", "AbsVal");
+  Status ret = reshapeParser.ParseWeights(layer, op_desc_src);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(UtestCaffeParser, CaffeModelParser_ParseOpParam_test)
+{
+  CaffeModelParser modelParser;
+
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *layer = net.add_layer();
+  layer->set_name("AbsVal");
+  layer->set_type("AbsVal");
+
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Abs", "AbsVal");
+
+  std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::CAFFE);
+  std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("Abs");
+
+  Status ret = modelParser.ParseOpParam(*layer, op_desc_src, op_parser);
+  EXPECT_EQ(ret, PARAM_INVALID);
+}
+
 } // namespace ge

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

@@ -242,4 +242,77 @@ TEST_F(UtestOnnxParser, OnnxModelParser_ConvertToGeDataType_test)
   EXPECT_EQ(ret, ge::DataType::DT_UNDEFINED);
 }
 
+TEST_F(UtestOnnxParser, OnnxModelParser_ParseConvertData_test)
+{
+  OnnxConstantParser constant_parser;
+  ge::onnx::TensorProto tensor_proto;
+  tensor_proto.set_data_type(ge::DataType::DT_UNDEFINED);
+
+  ge::Tensor tensor;
+  int count = 1;
+
+  Status ret = constant_parser.ParseConvertData(tensor_proto, tensor, count);
+  EXPECT_EQ(ret, FAILED);
+
+  tensor_proto.set_data_type(OnnxDataType::INT32);
+  count = 0;
+  ret = constant_parser.ParseConvertData(tensor_proto, tensor, count);
+  EXPECT_EQ(ret, SUCCESS);
+
+  tensor_proto.set_data_type(OnnxDataType::BFLOAT16);
+  count = 1;
+  ret = constant_parser.ParseConvertData(tensor_proto, tensor, count);
+  EXPECT_EQ(ret, FAILED);
+
+  tensor_proto.set_data_type(OnnxDataType::STRING);
+  ret = constant_parser.ParseConvertData(tensor_proto, tensor, count);
+  EXPECT_EQ(ret, FAILED);
+
+  tensor_proto.set_raw_data("Test");
+  ret = constant_parser.ParseConvertData(tensor_proto, tensor, count);
+  EXPECT_EQ(ret, SUCCESS);
+
+  tensor_proto.set_data_type(OnnxDataType::FLOAT);
+  ret = constant_parser.ParseConvertData(tensor_proto, tensor, count);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(UtestOnnxParser, OnnxConstantParser_ParseConvertTensor_test)
+{
+  OnnxConstantParser constant_parser;
+  ge::onnx::NodeProto input_node;
+  ge::onnx::AttributeProto *attribute = input_node.add_attribute();
+  attribute->set_name("attribute");
+  attribute->set_type(onnx::AttributeProto::AttributeType(1));
+  attribute->set_f(1.0);
+  ge::onnx::TensorProto *attribute_tensor = attribute->mutable_t();
+  attribute_tensor->set_data_type(1);
+  attribute_tensor->add_dims(4);
+
+  ge::Tensor tensor;
+  Status ret = constant_parser.ParseConvertTensor(*attribute_tensor, tensor);
+  EXPECT_EQ(ret, FAILED);
+
+  attribute_tensor->add_dims(-1);
+  ret = constant_parser.ParseConvertTensor(*attribute_tensor, tensor);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(UtestOnnxParser, OnnxConstantParser_ParseConvertDataType_test)
+{
+  OnnxConstantParser constant_parser;
+  ge::onnx::NodeProto input_node;
+  ge::onnx::AttributeProto *attribute = input_node.add_attribute();
+  attribute->set_name("attribute");
+  attribute->set_type(onnx::AttributeProto::AttributeType(1));
+  attribute->set_f(1.0);
+  ge::onnx::TensorProto *attribute_tensor = attribute->mutable_t();
+  attribute_tensor->set_data_type(OnnxDataType::BFLOAT16);
+  attribute_tensor->add_dims(4);
+
+  ge::Tensor tensor;
+  Status ret = constant_parser.ParseConvertDataType(*attribute_tensor, tensor);
+  EXPECT_EQ(ret, FAILED);
+}
+
 } // namespace ge

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

@@ -1655,6 +1655,14 @@ TEST_F(UtestTensorflowParser, parse_AddScopeInnerNode)
   // can't find in scope_inner_node_map
   ret = modelParser.AddScopeInnerNode(&modelParser, compute_graph, &graph_mutex, node_def);
   EXPECT_EQ(ret, PARAM_INVALID);
+
+  std::string msg = "FastrcnnPredictions";
+  ge::Operator *op = new Operator(); 
+  modelParser.scope_inner_node_map_.insert({msg, op});
+  // can't find in scope_inner_node_map
+  ret = modelParser.AddScopeInnerNode(&modelParser, compute_graph, &graph_mutex, node_def);
+  EXPECT_EQ(ret, PARAM_INVALID);
+  delete op;
   delete node_def;
 }
 
@@ -1905,6 +1913,61 @@ TEST_F(UtestTensorflowParser, tensorflow_enter_test) {
   std::string modelFile = caseDir + "/tensorflow_model/test_enter.pb";
   auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph);
   EXPECT_EQ(status, SUCCESS);
+
+  TensorFlowEnterParser enterParser;
+  ge::OpDescPtr op_dest = make_shared<ge::OpDesc>("Enter", ge::parser::ENTER);
+  NodeDef* node_def = initNodeDef();
+  node_def->set_name("Enter");
+  Status ret = enterParser.ParseParams(node_def, op_dest);
+  EXPECT_EQ(ret, FAILED);
+
+  static const string KEY_SHAPE_LIST = "key_shape_list";
+  static const string KEY_TENSOR_LIST = "key_tensor_list";
+  static const string KEY_DEFAULT = "key_default";
+
+  google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = node_def->mutable_attr();
+  domi::tensorflow::AttrValue dtype_attr_value;
+  dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);
+  (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value;
+
+  //设置strides属性
+  domi::tensorflow::AttrValue axis_attr_value;
+  ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list();
+  list->add_i(1);
+  list->add_i(2);
+  (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value;
+
+  domi::tensorflow::AttrValue value;
+  domi::tensorflow::AttrValue df_attr_value;
+  df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);
+
+  domi::tensorflow::AttrValue pad_attr_value;
+  pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);
+
+  domi::tensorflow::AttrValue shape;
+  shape.mutable_list()->add_i((int64)32);
+  shape.mutable_list()->add_i((int64)32);
+  shape.mutable_list()->add_i((int64)14);
+  
+  static const string KEY_TYPE_LIST = "key_type_list";
+  const std::string ENTER_ATTR_FRAME_NAME = "frame_name";
+  const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc";
+  static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;
+  value.clear_value();
+  value.mutable_list()->add_type(VALUE_TYPE);
+  TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def);
+
+  value.clear_value();
+  domi::tensorflow::NameAttrList name_attr_list;
+  name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});
+  name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});
+  name_attr_list.mutable_attr()->insert({"serialize_shape", shape});
+  *(value.mutable_list()->add_func()) = name_attr_list;
+
+  node_def->mutable_attr()->insert({ge::ENTER_ATTR_FRAME_NAME, value});
+  node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});
+  ret = enterParser.ParseParams(node_def, op_dest);
+  EXPECT_EQ(ret, FAILED);
 }
 
 TEST_F(UtestTensorflowParser, tensorflow_VariableV2_test) {
@@ -4231,4 +4294,45 @@ TEST_F(UtestTensorflowParser, parser_UppdateInputMap_test)
   delete graph;
 }
 
+TEST_F(UtestTensorflowParser, tensorflow_ConstOpNeedUpdate)
+{
+  NodeDef *transpose_node = initNodeDef();
+  TensorFlowModelParser modelParser;
+  modelParser.nodedef_map_["arg1"] = transpose_node;
+  bool ret = modelParser.ConstOpNeedUpdate("arg1");
+  ASSERT_EQ(ret, true);
+
+  ge::OpNodeContext op_node_context;
+  op_node_context.input_map["pre_node_a"].push_back({0, 0});
+  op_node_context.input_map["pre_node_ctrl_in"].push_back({-1, -1}); // ctrl edges
+  op_node_context.output_map["post_node_b"].push_back({0, 0});
+  op_node_context.output_map["post_node_c"].push_back({1, 0});
+  op_node_context.output_map["post_node_d"].push_back({-1, -1});
+  op_node_context.output_map["_Retval"].push_back({0, 1});
+  modelParser.op_node_context_map_["arg1"] = op_node_context;
+  ret = modelParser.ConstOpNeedUpdate("arg1");
+  ASSERT_EQ(ret, true);
+
+  transpose_node->set_op("NULL");
+  modelParser.nodedef_map_["arg2"] = transpose_node;
+  ret = modelParser.ConstOpNeedUpdate("arg2");
+  ASSERT_EQ(ret, true);
+  delete transpose_node;
+}
+
+TEST_F(UtestTensorflowParser, tensorflow_IsFusionOpChild)
+{
+  TensorFlowModelParser modelParser;
+  ge::ScopeFusionOpInfo info;
+  info.node_name = "node_name";
+  info.fusion_node_name = "fusion_node_name";
+  info.fusion_op_type = "fusion_op_type";
+  info.description = "description";
+  info.scope_pass = "scope_pass";
+
+  modelParser.fusion_op_children_["argv1"] = info;
+  bool ret = modelParser.IsFusionOpChild("argv1", &info);
+  ASSERT_EQ(ret, true);
+}
+
 } // namespace ge