diff --git a/tests/depends/ops_stub/ops_stub.h b/tests/depends/ops_stub/ops_stub.h
index 2a261a8..2675cf2 100644
--- a/tests/depends/ops_stub/ops_stub.h
+++ b/tests/depends/ops_stub/ops_stub.h
@@ -286,6 +286,19 @@ REG_OP(Mul)
                            DT_COMPLEX64, DT_COMPLEX128}))
     .OP_END_FACTORY_REG(Mul)
 
+REG_OP(Pooling)
+    .INPUT(x, TensorType({DT_FLOAT16, DT_FLOAT32, DT_INT8}))
+    .OUTPUT(y, TensorType({DT_FLOAT16, DT_FLOAT32, DT_INT32}))
+    .ATTR(mode, Int, 0)                 // 0:max pooling or 1:avg pooling
+    .ATTR(global_pooling, Bool, false)
+    .ATTR(window, ListInt, {1,1})       // kernel size
+    .ATTR(stride, ListInt, {1,1})       // stride size
+    .ATTR(pad, ListInt, {0,0,0,0})      // pad size
+    .ATTR(dilation, ListInt, {1,1,1,1})
+    .ATTR(ceil_mode, Int, 0)
+    .ATTR(data_format, String, "NCHW")
+    .OP_END_FACTORY_REG(Pooling)
+
 // for plugin
 static Status ParseParamsStub(const google::protobuf::Message* op_src, ge::Operator& op_dest) {
   return SUCCESS;
@@ -380,20 +393,22 @@ REGISTER_CUSTOM_OP("Add")
       .OriginOpType("Add")
       .ParseParamsFn(ParseParamsStub);
 
-
 REGISTER_CUSTOM_OP("PartitionedCall")
     .FrameworkType(domi::ONNX)
     .OriginOpType({"ai.onnx::9::Clip"})
     .ParseParamsFn(ParseParamsClipV9Stub)
     .ParseOpToGraphFn(ParseOpToGraphClipV9Stub);
+
 REGISTER_CUSTOM_OP("TensorArray")
     .FrameworkType(domi::TENSORFLOW)
     .OriginOpType("TensorArrayV3")
+    .ParseParamsByOperatorFn(ParseParamByOpFuncStub)
     .ParseParamsFn(ParseParamsStub);
 
 REGISTER_CUSTOM_OP("TensorArrayWrite")
     .FrameworkType(domi::TENSORFLOW)
     .OriginOpType("TensorArrayWriteV3")
+    .ParseParamsByOperatorFn(ParseParamByOpFuncStub)
     .ParseParamsFn(ParseParamsStub);
 
 REGISTER_CUSTOM_OP("DynamicRNN")
diff --git a/tests/st/CMakeLists.txt b/tests/st/CMakeLists.txt
index 34e6e0c..5273022 100644
--- a/tests/st/CMakeLists.txt
+++ b/tests/st/CMakeLists.txt
@@ -368,6 +368,7 @@ target_compile_definitions(st_parser PRIVATE
 target_link_libraries(st_parser
     $<BUILD_INTERFACE:intf_pub>
     st_parser_proto
+    json
     -Wl,--whole-archive st_parser_common -Wl,--no-whole-archive
     st_parser_graph st_parser_register error_manager_stub mmpa_stub attr_util_stub
     gtest gtest_main slog_stub ascend_protobuf c_sec  -lrt -ldl -lgcov
diff --git a/tests/st/testcase/origin_models/test.json b/tests/st/testcase/origin_models/test.json
index 1eecef9..d1dbcc4 100644
--- a/tests/st/testcase/origin_models/test.json
+++ b/tests/st/testcase/origin_models/test.json
@@ -3,6 +3,12 @@
     {
       "attr": [
         {
+          "key": "dtype",
+          "value": {
+            "type": "DT_HALF"
+          }
+        },
+        {
           "key": "shape",
           "value": {
             "shape": {
@@ -13,12 +19,6 @@
               ]
             }
           }
-        },
-        {
-          "key": "dtype",
-          "value": {
-            "type": "DT_HALF"
-          }
         }
       ],
       "name": "Placeholder",
@@ -27,6 +27,12 @@
     {
       "attr": [
         {
+          "key": "dtype",
+          "value": {
+            "type": "DT_HALF"
+          }
+        },
+        {
           "key": "shape",
           "value": {
             "shape": {
@@ -37,12 +43,6 @@
               ]
             }
           }
-        },
-        {
-          "key": "dtype",
-          "value": {
-            "type": "DT_HALF"
-          }
         }
       ],
       "name": "Placeholder_1",
diff --git a/tests/st/testcase/test_tensorflow_parser.cc b/tests/st/testcase/test_tensorflow_parser.cc
index ae0ca2b..bae85ba 100644
--- a/tests/st/testcase/test_tensorflow_parser.cc
+++ b/tests/st/testcase/test_tensorflow_parser.cc
@@ -46,6 +46,18 @@
 #include "parser/tensorflow/graph_functiondef.h"
 #include "parser/tensorflow/graph_optimizer.h"
 #include "cce/dnn_base_def.hpp"
+#include "parser/tensorflow/scope/scope_pass_manager.h"
+#include "parser/tensorflow/tensorflow_util.h"
+#include "compute_graph_impl.h"
+#include "parser/tensorflow/tensorflow_enter_parser.h"
+#include "parser/common/op_def/ir_pb_converter.h"
+#include "parser/common/tuple.h"
+#include "common/op_def/frameworkop_op.h"
+#include "common/op_def/shape_n_op.h"
+#include "common/op_def/var_is_initialized_op_op.h"
+#include "common/op_def/fill_op.h"
+#include "common/convert/pb2json.h"
+#include "common/convert/message2operator.h"
 #undef protected
 #undef private
 
@@ -72,6 +84,36 @@ class STestTensorflowParser : public testing::Test {
   void RegisterCustomOp();
 };
 
+class TestOperator : public ParserOperator
+{
+public:
+    TestOperator()
+      : ParserOperator("test")
+    {
+    }
+
+    ~TestOperator()
+    {
+    }
+};
+
+class ScopeTestPass : public ScopeBasePass {
+ protected:
+  vector<ScopeFusionPatterns> DefinePatterns() {
+    vector<ScopeFusionPatterns> patterns_list;
+    return patterns_list;
+  };
+  string PassName() {
+    return "test";
+  };
+  Status LastMatchScopesAndOPs(shared_ptr<ScopeGraph> &scope_graph, vector<ScopesResult> &results) {
+    return domi::SUCCESS;
+  };
+  void GenerateFusionResult(const vector<Scope *> &scopes, FusionScopesResult *fusion_rlt) {
+    return;
+  };
+};
+
 static Status ParseParams(const google::protobuf::Message* op_src, ge::Operator& op_dest) {
   return SUCCESS;
 }
@@ -85,7 +127,6 @@ void STestTensorflowParser::RegisterCustomOp() {
   .FrameworkType(domi::TENSORFLOW)
   .OriginOpType("Add")
   .ParseParamsFn(ParseParams);
-
   std::vector<OpRegistrationData> reg_datas = domi::OpRegistry::Instance()->registrationDatas;
   for (auto reg_data : reg_datas) {
     OpRegistrationTbe::Instance()->Finalize(reg_data);
@@ -95,8 +136,7 @@ void STestTensorflowParser::RegisterCustomOp() {
 }
 
 namespace {
-  NodeDef* AddNode(GraphDef& graph, string type, string name)
-  {
+  NodeDef* AddNode(GraphDef& graph, string type, string name) {
     NodeDef* nodeDef = graph.add_node();
     nodeDef->set_op(type);
     nodeDef->set_name(name);
@@ -111,8 +151,7 @@ namespace {
     return nodeDef;
   }
 
-  void AddInput(NodeDef* src, NodeDef* dst, int srcIndex)
-  {
+  void AddInput(NodeDef* src, NodeDef* dst, int srcIndex) {
     if(srcIndex == -1){
         dst->add_input("^"+src->name());
     } else {
@@ -149,49 +188,47 @@ namespace {
     }
   }
 
-  NodeDef *initNodeDef()
-  {
-      NodeDef * nodeDef = new NodeDef();
-      nodeDef->set_op("Const");
-      ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = nodeDef->mutable_attr();
-
-      //设置 T属性
-      domi::tensorflow::AttrValue t_attr_value;
-      t_attr_value.set_type(domi::tensorflow::DT_INT32);
-      (*node_attr_map)[TENSORFLOW_ATTR_T] = t_attr_value;
-
-      domi::tensorflow::AttrValue dtype_attr_value;
-      dtype_attr_value.set_type(domi::tensorflow::DT_INT32);
-      (*node_attr_map)[TENSORFLOW_ATTR_DTYPE] = dtype_attr_value;
-
-      // out_put
-      domi::tensorflow::AttrValue outputs_attr_value;
-      ::tensorflow::AttrValue_ListValue* list = outputs_attr_value.mutable_list();
-      list->add_s("MatMul");
-      (*node_attr_map)[TENSORFLOW_ATTR_OUTPUT_OP] = outputs_attr_value;
-
-      // 设置 tensor 属性
-      domi::tensorflow::AttrValue value_attr_value;
-      tensorflow::TensorProto* tensor = value_attr_value.mutable_tensor();
-      tensorflow::TensorShapeProto* tensor_shape = tensor->mutable_tensor_shape();
-      tensor_shape->clear_dim();
-      tensor_shape->add_dim()->set_size(4);
-      tensor_shape->add_dim()->set_size(6);
-      tensor->set_dtype(domi::tensorflow::DT_INT32);
-
-      float *addr = new float[24];
-      for (int32_t i = 0; i < 24; i++) {
-          *(addr + i) = 1.0 + i;
-      }
-      tensor->set_tensor_content((void *)addr, 24 * sizeof(float));
+  NodeDef *initNodeDef() {
+    NodeDef * nodeDef = new NodeDef();
+    nodeDef->set_op("Const");
+    ::google::protobuf::Map<std::string, tensorflow::AttrValue >* node_attr_map = nodeDef->mutable_attr();
+
+    //设置 T属性
+    domi::tensorflow::AttrValue t_attr_value;
+    t_attr_value.set_type(domi::tensorflow::DT_INT32);
+    (*node_attr_map)[TENSORFLOW_ATTR_T] = t_attr_value;
+
+    domi::tensorflow::AttrValue dtype_attr_value;
+    dtype_attr_value.set_type(domi::tensorflow::DT_INT32);
+    (*node_attr_map)[TENSORFLOW_ATTR_DTYPE] = dtype_attr_value;
+
+    // out_put
+    domi::tensorflow::AttrValue outputs_attr_value;
+    ::tensorflow::AttrValue_ListValue* list = outputs_attr_value.mutable_list();
+    list->add_s("MatMul");
+    (*node_attr_map)[TENSORFLOW_ATTR_OUTPUT_OP] = outputs_attr_value;
+
+    // 设置 tensor 属性
+    domi::tensorflow::AttrValue value_attr_value;
+    tensorflow::TensorProto* tensor = value_attr_value.mutable_tensor();
+    tensorflow::TensorShapeProto* tensor_shape = tensor->mutable_tensor_shape();
+    tensor_shape->clear_dim();
+    tensor_shape->add_dim()->set_size(4);
+    tensor_shape->add_dim()->set_size(6);
+    tensor->set_dtype(domi::tensorflow::DT_INT32);
+
+    float *addr = new float[24];
+    for (int32_t i = 0; i < 24; i++) {
+        *(addr + i) = 1.0 + i;
+    }
+    tensor->set_tensor_content((void *)addr, 24 * sizeof(float));
 
-      (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
-      delete[] addr;
-      return nodeDef;
+    (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
+    delete[] addr;
+    return nodeDef;
   }
 
-  NodeDef * initOpNodeDef_VariableV2()
-  {
+  NodeDef * initOpNodeDef_VariableV2() {
     NodeDef * nodeDef = new NodeDef();
     nodeDef->set_op("VariableV2");
     google::protobuf::Map<std::string, tensorflow::AttrValue > *node_attr_map = nodeDef->mutable_attr();
@@ -251,8 +288,7 @@ namespace {
     return nodeDef;
   }
 
-  NodeDef *initOpNodeDef_TemporaryVariable()
-  {
+  NodeDef *initOpNodeDef_TemporaryVariable() {
     NodeDef * nodeDef = new NodeDef();
     nodeDef->set_op("TemporaryVariable");
     google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = nodeDef->mutable_attr();
@@ -306,56 +342,55 @@ namespace {
     return nodeDef;
   }
 
-  NodeDef *fusioninitNodeDef(int index)
-  {
-      NodeDef * nodeDef = new NodeDef();
-      ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = nodeDef->mutable_attr();
-
-      //设置 type属性
-      domi::tensorflow::AttrValue dtype_attr_value ;
-
-      if (index == 0) {
-          dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);
-      } else if (index == 1) {
-          dtype_attr_value.set_type(domi::tensorflow::DT_INT32);
-      } else if (index == 2) {
-          dtype_attr_value.set_type(tensorflow::DT_HALF);
-      }
-      (*node_attr_map)[ge::TENSORFLOW_ATTR_DTYPE] = dtype_attr_value;
-      //设置data_format属性
-      domi::tensorflow::AttrValue df_attr_value;
-      df_attr_value.set_s(TENSORFLOWF_TENSOR_NCHW);
-      (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value;
-
-      // 设置 tensor 属性
-      domi::tensorflow::AttrValue value_attr_value;
-      ::tensorflow::TensorProto* tensor = value_attr_value.mutable_tensor();
-      ::tensorflow::TensorShapeProto* tensor_shape = tensor->mutable_tensor_shape();
-      tensor_shape->clear_dim();
-      ::tensorflow::TensorShapeProto_Dim* dim = tensor_shape->add_dim();
-      dim->set_name("tensor dim");
-      dim->set_size(1);
-
-      if (index == 0) {
-          tensor->set_dtype(domi::tensorflow::DT_FLOAT);
-          float *addr = new float[1];
-          *addr = 1.0;
-          tensor->set_tensor_content((void *)addr, sizeof(float));
-          (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
-          delete[] addr;
-      } else if (index == 1) {
-          tensor->set_dtype(domi::tensorflow::DT_INT32);
-          int32_t *addr = new int32_t[1];
-          *addr = 1;
-          tensor->set_tensor_content((void *)addr, sizeof(int32_t));
-          (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
-          delete[] addr;
-      } else if (index == 2) {
-          tensor->set_dtype(tensorflow::DT_HALF);
-          tensor->add_half_val(1);
-          (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
-      }
-      return nodeDef;
+  NodeDef *fusioninitNodeDef(int index) {
+    NodeDef *nodeDef = new NodeDef();
+    google::protobuf::Map<std::string, tensorflow::AttrValue> *node_attr_map = nodeDef->mutable_attr();
+
+    //设置 type属性
+    domi::tensorflow::AttrValue dtype_attr_value ;
+
+    if (index == 0) {
+        dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT);
+    } else if (index == 1) {
+        dtype_attr_value.set_type(domi::tensorflow::DT_INT32);
+    } else if (index == 2) {
+        dtype_attr_value.set_type(tensorflow::DT_HALF);
+    }
+    (*node_attr_map)[ge::TENSORFLOW_ATTR_DTYPE] = dtype_attr_value;
+    //设置data_format属性
+    domi::tensorflow::AttrValue df_attr_value;
+    df_attr_value.set_s(TENSORFLOWF_TENSOR_NCHW);
+    (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value;
+
+    // 设置 tensor 属性
+    domi::tensorflow::AttrValue value_attr_value;
+    ::tensorflow::TensorProto* tensor = value_attr_value.mutable_tensor();
+    ::tensorflow::TensorShapeProto* tensor_shape = tensor->mutable_tensor_shape();
+    tensor_shape->clear_dim();
+    ::tensorflow::TensorShapeProto_Dim* dim = tensor_shape->add_dim();
+    dim->set_name("tensor dim");
+    dim->set_size(1);
+
+    if (index == 0) {
+        tensor->set_dtype(domi::tensorflow::DT_FLOAT);
+        float *addr = new float[1];
+        *addr = 1.0;
+        tensor->set_tensor_content((void *)addr, sizeof(float));
+        (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
+        delete[] addr;
+    } else if (index == 1) {
+        tensor->set_dtype(domi::tensorflow::DT_INT32);
+        int32_t *addr = new int32_t[1];
+        *addr = 1;
+        tensor->set_tensor_content((void *)addr, sizeof(int32_t));
+        (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
+        delete[] addr;
+    } else if (index == 2) {
+        tensor->set_dtype(tensorflow::DT_HALF);
+        tensor->add_half_val(1);
+        (*node_attr_map)[TENSORFLOW_ATTR_VALUE] = value_attr_value;
+    }
+    return nodeDef;
   }
 
   NodeDef *MallocNodeDef(const string &name, const string &type) {
@@ -371,7 +406,7 @@ namespace {
     NodeDef* pre_node_a = MallocNodeDef("pre_node_a", "Const");
     EXPECT_NE(pre_node_a, nullptr);
     {
-      ::google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = pre_node_a->mutable_attr();
+      google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = pre_node_a->mutable_attr();
       tensorflow::AttrValue attr_dtype;
       attr_dtype.set_type(tensorflow::DT_FLOAT);
       (*node_attr_map)["dtype"] = attr_dtype;
@@ -683,6 +718,15 @@ namespace {
     }
     (*attr)[ge::ATTR_NAME_INPUT_TENSOR_DESC] = input_attr_value;
   }
+
+  NodeDef* AddGraphNode(GraphDef *graph, string name, string optype, string input) 
+  {
+    NodeDef * node_def = graph->add_node();
+    node_def->set_name(name);
+    node_def->set_op(optype);
+    node_def->add_input(input);
+    return node_def;
+  }
 }
 
 namespace {
@@ -772,7 +816,6 @@ static MemBuffer* MemBufferFromFile(const char *path)
     return membuf;
 }
 
-
 ///        placeholder0  placeholder1
 ///          |       /\  /\       |
 ///          |      /  \/  \      |
@@ -797,6 +840,8 @@ void CreateGraphDef(domi::tensorflow::GraphDef &graph_def) {
   auto add2 = graph_def.add_node();
   auto retval0 = graph_def.add_node();
   auto retval1 = graph_def.add_node();
+  auto softmax0 = graph_def.add_node();
+  auto softmax1 = graph_def.add_node();
 
   // 2. set info
   placeholder0->set_name("placeholder0");
@@ -821,6 +866,16 @@ void CreateGraphDef(domi::tensorflow::GraphDef &graph_def) {
   retval1->set_name("retval1");
   retval1->set_op("_RetVal");
 
+  retval0->set_name("retval0");
+  retval0->set_op("_RetVal");
+  retval1->set_name("retval1");
+  retval1->set_op("_RetVal");
+
+  softmax0->set_name("Softmax0");
+  softmax0->set_op("Softmax");
+  softmax1->set_name("Softmax1");
+  softmax1->set_op("Softmax");
+
   // 3. add edges
   add0->add_input("placeholder0");
   add0->add_input("placeholder1");
@@ -840,6 +895,9 @@ void CreateGraphDef(domi::tensorflow::GraphDef &graph_def) {
 
   retval0->add_input("add2:0");
   retval1->add_input("add1:0");
+
+  softmax0->add_input("add3:0");
+  softmax0->add_input("add2:0");
 }
 
 TEST_F(STestTensorflowParser, tensorflow_parser_success) {
@@ -1168,8 +1226,6 @@ TEST_F(STestTensorflowParser, parse_AutoMappingByOp) {
   static const float VALUE_FLOAT = 1.0;
   static const bool VALUE_BOOL = true;
   static const  domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT;
-
-  std::cout << "test data_type value_type: " << (int64_t)VALUE_TYPE << std::endl;
   static const string VALUE_NAME = "test_name";
   ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();
   NodeDef node_def;
@@ -1344,7 +1400,7 @@ TEST_F(STestTensorflowParser, parse_AddScopeInnerNode)
   EXPECT_EQ(ret, SUCCESS);
 
   std::mutex graph_mutex;
-  tensorflow::NodeDef *node_def = new NodeDef();
+  tensorflow::NodeDef *node_def = initNodeDef();
   node_def->set_name("FastrcnnPredictions");
   node_def->set_op("FastrcnnPredictions");
   // can't find in scope_inner_node_map
@@ -1451,7 +1507,7 @@ TEST_F(STestTensorflowParser, tensorflow_reshpae_test) {
   TensorFlowReshapeParser parser;
   NodeDef * nodeDef = new NodeDef();
   ge::OpDescPtr opdef_ = make_shared<::ge::OpDesc>("","");
-  google::protobuf::Map<std::string, tensorflow::AttrValue >* attr_map = nodeDef->mutable_attr();
+  google::protobuf::Map<std::string, tensorflow::AttrValue > *attr_map = nodeDef->mutable_attr();
   domi::tensorflow::AttrValue tshape_attr_value;
   tshape_attr_value.set_type(domi::tensorflow::DT_INT32);
   (*attr_map)[TENSORFLOW_ATTR_TSHAPE] = tshape_attr_value;
@@ -1505,7 +1561,7 @@ TEST_F(STestTensorflowParser, tensorflow_squeeze_test) {
   (*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);
+  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);
@@ -1535,6 +1591,13 @@ TEST_F(STestTensorflowParser, tensorflow_squeeze_test) {
   ret = parser.ParseParams(nodeDef2, opDef);
   EXPECT_EQ(domi::SUCCESS, ret);
 
+  GeTensorDesc ge_desc;
+  ge_desc.SetFormat(ge::FORMAT_C1HWNCoC0);
+  ge_desc.SetDataType(ge::DT_FLOAT);
+  ge_desc.SetShape(GeShape({1,1,1,1,1,1}));
+  ret = parser.ParseDesc(value, ge_desc);
+  EXPECT_EQ(ret, SUCCESS);
+
   delete nodeDef2;
   delete nodeDef_axis_dims;
   delete nodeDef_dim;
@@ -1594,6 +1657,61 @@ TEST_F(STestTensorflowParser, tensorflow_enter_test) {
   std::string modelFile = caseDir + "/origin_models/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(STestTensorflowParser, tensorflow_VariableV2_test) {
@@ -1803,6 +1921,54 @@ TEST_F(STestTensorflowParser, tensorflow_CheckOpShapeDim_test)
   TensorFlowModelParser parser;
   Status ret = parser.CheckOpShapeDim(node_def, dims, valid);
   EXPECT_EQ(ret, SUCCESS);
+
+  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 ATTR_NAME_INPUT_TENSOR_DESC  = "input_tensor_desc";
+  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::ATTR_NAME_INPUT_TENSOR_DESC, value});
+  node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});
+  ret = parser.CheckOpShapeDim(node_def, dims, valid);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
 TEST_F(STestTensorflowParser, tensorflow_Scope_pass_test)
@@ -1881,9 +2047,57 @@ TEST_F(STestTensorflowParser, tensorflow_arg_parser_test)
   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);
   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);
   EXPECT_EQ(ret, SUCCESS);
+
+  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 ATTR_NAME_INPUT_TENSOR_DESC  = "input_tensor_desc";
+  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::ATTR_NAME_INPUT_TENSOR_DESC, value});
+  node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});
+  ret = tensorflow_op_parser->ParseParams(node_def, op_dest);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
-TEST_F(STestTensorflowParser, tensorflow_frameworkop_parser_test)
+TEST_F(STestTensorflowParser, tensorflow_frameworkop_parser_test1)
 {
   TensorFlowCustomParserAdapter parser;
   ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();
@@ -1900,6 +2114,66 @@ TEST_F(STestTensorflowParser, tensorflow_frameworkop_parser_test)
   EXPECT_EQ(ret, PARAM_INVALID);
 }
 
+TEST_F(STestTensorflowParser, tensorflow_frameworkop_parser_test2)
+{
+  TensorFlowCustomParserAdapter parser;
+  ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>();
+  NodeDef *node_def = initNodeDef();
+  node_def->set_name("FrameworkOp");
+  node_def->set_op("_Retval");
+  TensorFlowModelParser modelParser;
+  std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);
+  std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("FrameworkOp");
+  shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);
+  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 ATTR_NAME_INPUT_TENSOR_DESC  = "ATTR_NAME_FRAMEWORK_OP_DEF";
+  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::ATTR_NAME_INPUT_TENSOR_DESC, value});
+  node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value});
+  Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
 TEST_F(STestTensorflowParser, tensorflow_reshape_parser_test)
 {
   TensorFlowCustomParserAdapter parser;
@@ -1911,6 +2185,41 @@ TEST_F(STestTensorflowParser, tensorflow_reshape_parser_test)
   shared_ptr<TensorFlowOpParser> tensorflow_op_parser = std::dynamic_pointer_cast<TensorFlowOpParser>(op_parser);
   Status ret = tensorflow_op_parser->ParseParams(node_def, op_dest);
   EXPECT_EQ(ret, SUCCESS);
+
+  NodeDef * nodeDef = new NodeDef();
+  nodeDef->set_op("Reshape");
+  google::protobuf::Map< ::std::string, ::tensorflow::AttrValue >* node_attr_map = nodeDef->mutable_attr();
+  domi::tensorflow::AttrValue attr_value;
+  attr_value.mutable_list()->add_i((int64)32);
+  attr_value.mutable_list()->add_i((int64)32);
+  attr_value.mutable_list()->add_i((int64)14);
+
+  domi::tensorflow::AttrValue df_attr_value2;
+  df_attr_value2.set_s(TENSORFLOWF_TENSOR_NHWC);
+  (*node_attr_map)[TENSORFLOW_ATTR_DATA_FORMAT] = df_attr_value2;
+  domi::tensorflow::AttrValue df_attr_value;
+  df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC);
+
+  //设置padding属性
+  domi::tensorflow::AttrValue pad_attr_value2;
+  pad_attr_value2.set_s(TENSORFLOWF_OP_PADDING_SAME);
+  (*node_attr_map)[TENSORFLOW_ATTR_PADDING] = pad_attr_value2;
+  domi::tensorflow::AttrValue pad_attr_value;
+  pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT);
+
+  domi::tensorflow::NameAttrList name_attr_list;
+  name_attr_list.mutable_attr()->insert({"serialize_shape", attr_value});
+  name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value});
+  name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value});
+  *(attr_value.mutable_list()->add_func()) = name_attr_list;
+
+  GeTensorDesc ge_desc;
+  ge_desc.SetFormat(ge::FORMAT_C1HWNCoC0);
+  ge_desc.SetDataType(ge::DT_FLOAT);
+  ge_desc.SetShape(GeShape({1,1,1,1,1,1}));
+  TensorFlowReshapeParser reshapeParser;
+  ret = reshapeParser.ParseDesc(attr_value, ge_desc);
+  EXPECT_EQ(ret, SUCCESS);
 }
 
 TEST_F(STestTensorflowParser, tensorflow_DefunToPartitionedCall_parser_test)
@@ -1918,28 +2227,77 @@ TEST_F(STestTensorflowParser, tensorflow_DefunToPartitionedCall_parser_test)
   TensorFlowModelParser parser;
   NodeDef *node_def = initNodeDef();
   node_def->set_name("ShapeN");
-  ge::OpDescPtr op = make_shared<ge::OpDesc>("constant", ge::parser::CONSTANT);
+  ge::OpDescPtr op = make_shared<ge::OpDesc>("ShapeN", ge::parser::PARTITIONEDCALL);
   Status ret = parser.DefunToPartitionedCall(node_def, op);
   EXPECT_EQ(ret, FAILED);
-}
 
-TEST_F(STestTensorflowParser, tensorflow_TransNodeToOpDesc_parser_test)
-{
-  TensorFlowModelParser parser;
-  NodeDef *node_def = initNodeDef();
-  node_def->set_name("ge::parser::DATA");
-  std::string op_type = "ge::parser::DATA";
-  ge::OpDescPtr op = make_shared<ge::OpDesc>("constant", ge::parser::CONSTANT);
-  Status ret = parser.TransNodeToOpDesc(node_def, op, op_type);
-  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";
 
-domi::Status fusion_parse_param_by_op(const std::vector<ge::Operator> &op_src, ge::Operator &op) {
-  return domi::SUCCESS;
-}
+  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;
 
-TEST_F(STestTensorflowParser, Fusion_node_parse_params_success) {
-  ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
+  //设置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";
+  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({"_disable_call_shape_inference", value});
+  node_def->mutable_attr()->insert({"_disable_call_shape_inference", value});
+  std::string fusion_op_name = "pre_node_a";
+  GenOriginContext(&parser, fusion_op_name);
+  node_def->set_name("pre_node_a");
+  ret = parser.DefunToPartitionedCall(node_def, op);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_TransNodeToOpDesc_parser_test)
+{
+  TensorFlowModelParser parser;
+  NodeDef *node_def = initNodeDef();
+  node_def->set_name("ge::parser::DATA");
+  std::string op_type = "ge::parser::DATA";
+  ge::OpDescPtr op = make_shared<ge::OpDesc>("constant", ge::parser::CONSTANT);
+  Status ret = parser.TransNodeToOpDesc(node_def, op, op_type);
+  EXPECT_EQ(ret, FAILED);
+}
+
+domi::Status fusion_parse_param_by_op(const std::vector<ge::Operator> &op_src, ge::Operator &op) {
+  return domi::SUCCESS;
+}
+
+TEST_F(STestTensorflowParser, Fusion_node_parse_params_success) {
+  ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
 
   ModelParserFactory* factory = ModelParserFactory::Instance();
   shared_ptr<ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);
@@ -1954,14 +2312,14 @@ TEST_F(STestTensorflowParser, Fusion_node_parse_params_success) {
   shared_ptr<OpParser> fusion_op_parser = op_parser->CreateFusionOpParser("FusionCustom");
 
   ge::ComputeGraphPtr graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
-  ge::OpDescPtr op = std::make_shared<ge::OpDesc>("data", "FusionCustom");
-  ge::NodePtr node = std::make_shared<ge::Node>(op, graph);
+  ge::OpDescPtr op1 = std::make_shared<ge::OpDesc>("data", "FusionCustom");
+  ge::NodePtr node1 = std::make_shared<ge::Node>(op1, graph);
 
   vector<const NodeDef *> node_defs;
   node_defs.push_back(&node_def);
 
   tensorflow_parser.fusion_op_nodedef_map_["data"] = node_defs;
-  Status ret = tensorflow_parser.FusionNodeParseParams(fusion_op_parser, &node_def, node);
+  Status ret = tensorflow_parser.FusionNodeParseParams(fusion_op_parser, &node_def, node1);
   EXPECT_EQ(domi::SUCCESS, ret);
 }
 
@@ -2406,4 +2764,617 @@ TEST_F(STestTensorflowParser, tensorflow_optimizer_snapshot_no_retval_test) {
   EXPECT_EQ(FAILED, ret);
 }
 
+TEST_F(STestTensorflowParser, tensorflow_RemoveInputs_test)
+{
+  tensorflow::GraphDef graph_def;
+  tensorflow::NodeDef *node_def = initNodeDef();
+  node_def->set_name("OP");
+  node_def->add_input("OP/Input_1");
+   node_def->add_input("OP/Input_2");
+  std::set<uint32_t> remove_index_set;
+  std::map<std::string, NodeDef *> all_node_map;
+  TensorFlowModelParser model_parser;
+  Status ret = model_parser.RemoveInputs(&graph_def, node_def, remove_index_set, all_node_map);
+  EXPECT_EQ(ret, SUCCESS);
+
+  remove_index_set.emplace(0);
+  ret = model_parser.RemoveInputs(&graph_def, node_def, remove_index_set, all_node_map);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_UpdateInnerNodeContext_test)
+{
+  std::string fusion_op_name = "post_node_a";
+  std::vector<std::string> inner_nodes_name;
+  inner_nodes_name.emplace_back("post_node_a");
+  TensorFlowModelParser model_parser;
+  Status ret = model_parser.UpdateInnerNodeContext(fusion_op_name, inner_nodes_name);
+  EXPECT_EQ(ret, INTERNAL_ERROR);
+
+  GenOriginContext(&model_parser, fusion_op_name);
+  ret = model_parser.UpdateInnerNodeContext(fusion_op_name, inner_nodes_name);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_UpdateInnerInputMap_test)
+{
+  string fusion_op_name = "post_node_a";
+  OpNodeContext fusion_context;
+  std::vector<std::string> inner_nodes_name;
+  inner_nodes_name.emplace_back("post_node_a");
+  std::set<string> fusion_input_nodes;
+  fusion_input_nodes.insert("post_node_a");
+  TensorFlowModelParser model_parser;
+  GenOriginContext(&model_parser, fusion_op_name);
+  model_parser.UpdateInnerInputMap(fusion_op_name, fusion_context, inner_nodes_name, fusion_input_nodes);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_UpdateInnerOutputMap_test)
+{
+  string fusion_op_name = "post_node_a";
+  OpNodeContext fusion_context;
+  std::vector<std::string> inner_nodes_name;
+  inner_nodes_name.emplace_back("post_node_a");
+  std::set<string> fusion_output_nodes;
+  fusion_output_nodes.insert("post_node_a");
+  TensorFlowModelParser model_parser;
+  GenOriginContext(&model_parser, fusion_op_name);
+  model_parser.UpdateInnerOutputMap(fusion_op_name, fusion_context, inner_nodes_name, fusion_output_nodes);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_ScopePassManager_AddPass_test)
+{
+  ScopePassManager passmanager;
+  tensorflow::GraphDef *graph = new tensorflow::GraphDef();
+  shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);
+
+  unique_ptr<ScopeBasePass> pass;
+  pass.reset(new ScopeTestPass());
+
+  EXPECT_EQ(ge::SUCCESS, passmanager.AddPass(pass));
+  EXPECT_NE(ge::SUCCESS, passmanager.Run(scope_graph));
+
+  delete graph;
+  graph = nullptr;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_CheckAttrHasType_test1)
+{
+  tensorflow::AttrValue attr_value;
+  attr_value.mutable_list();
+  Status ret = TensorFlowUtil::CheckAttrHasType(attr_value, "int");
+  EXPECT_EQ(FAILED, ret);
+
+  attr_value.set_type(DT_INVALID);
+  ret = TensorFlowUtil::CheckAttrHasType(attr_value, "type");
+  EXPECT_EQ(FAILED, ret);
+
+  tensorflow::AttrValue attr_value2;
+  AttrValue_ListValue *list = attr_value2.mutable_list();
+  list->add_type(tensorflow::DT_FLOAT);
+  list->add_type((tensorflow::DataType)30);
+  ret = TensorFlowUtil::CheckAttrHasType(attr_value2, "list(type)");
+  EXPECT_EQ(FAILED, ret);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_CheckAttrHasType_test2)
+{
+  tensorflow::AttrValue attr_value;
+  AttrValue_ListValue * list = attr_value.mutable_list();
+  list->add_type(tensorflow::DT_FLOAT);
+  list->add_type(tensorflow::DT_INVALID);
+  Status ret = TensorFlowUtil::CheckAttrHasType(attr_value, "list(type)");
+  EXPECT_EQ(FAILED, ret);
+
+  attr_value.set_placeholder("test");
+  ret = TensorFlowUtil::CheckAttrHasType(attr_value, "");
+  EXPECT_EQ(FAILED, ret);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_TransTensorDescriptor_test)
+{
+  tensorflow::AttrValue attr_value;
+  AttrValue_ListValue *list = attr_value.mutable_list();
+  list->add_type(tensorflow::DT_FLOAT);
+
+  ParserOperator op;
+  uint32_t io = TENSORFLOW_NORMAL_INPUT_TENSOR_FLAG;
+  std::string type = ge::parser::FUSEDBATCHNORMGRAD;
+  Status ret = TensorFlowUtil::TransTensorDescriptor(attr_value, &op, io, type);
+  EXPECT_EQ(ret, SUCCESS);
+
+  io = TENSORFLOW_NORMAL_OUTPUT_TENSOR_FLAG;
+  ret = TensorFlowUtil::TransTensorDescriptor(attr_value, &op, io, type);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_GraphDefOptimizeDestroyTemporaryVariable_test)
+{
+  tensorflow::GraphDef *graph_def = nullptr;
+  tensorflow::NodeDef *nodeCurrent = initNodeDef();
+  TensorFlowModelParser model_parser;
+  Status ret = model_parser.GraphDefOptimizeDestroyTemporaryVariable(graph_def, nodeCurrent);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_GetFunctionProto_test)
+{
+  std::cout << __FILE__ << std::endl;
+  std::string caseDir = __FILE__;
+  std::size_t idx = caseDir.find_last_of("/");
+  caseDir = caseDir.substr(0, idx);
+  std::string file = caseDir + "/origin_models/test_enter.pb";
+  domi::tensorflow::GraphDefLibrary graph_def_library;
+  TensorFlowModelParser model_parser;
+  Status ret = model_parser.GetFunctionProto(file, graph_def_library);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_GetNodeFormat_test)
+{
+  NodeDef *node_def1 = initNodeDef();
+  node_def1->set_op("NoOp");
+  node_def1->set_name("NoOp");
+
+  NodeDef *node_def2 = initNodeDef();
+  node_def2->set_op("Add");
+  node_def2->set_name("Add0");
+  TfTranspose pred_transpose = TO_NCHW;
+  domiTensorFormat_t format = domi::DOMI_TENSOR_NC1HWC0;
+  std::set<const NodeDef *> visited_node;
+  visited_node.emplace(node_def2);
+  TensorFlowModelParser model_parser;
+  Status ret = model_parser.GetNodeFormat(node_def1, pred_transpose, format, visited_node);
+  EXPECT_EQ(ret, FAILED);
+  delete node_def1;
+  delete node_def2;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_GetFormatTranspose_test)
+{
+  NodeDef *transpose_node = initNodeDef();
+  transpose_node->set_op("Transpose");
+  TfTranspose transpose_direc = NO_TRANSPOSE;
+  TensorFlowModelParser modelParser;
+  Status ret = modelParser.GetFormatTranspose(transpose_node, transpose_direc);
+  EXPECT_EQ(ret, FAILED);
+
+  ge::TensorFlowModelParser parser;
+  GraphDef graph;
+  auto arg0 = AddNode(graph, "_Arg", "arg0");
+  auto snapshot0 = AddNode(graph, "Snapshot", "snapshot0");
+  auto ret0 = AddNode(graph, "_Retval", "retval0");
+
+  auto arg1 = AddNode(graph, "_Arg", "arg1");
+  auto snapshot1 = AddNode(graph, "Snapshot", "snapshot1");
+  auto ret1 = AddNode(graph, "_Retval", "retval1");
+
+  auto arg2 = AddNode(graph, "_Arg", "arg2");
+  auto snapshot2 = AddNode(graph, "Snapshot", "snapshot2");
+  auto ret2 = AddNode(graph, "_Retval", "retval2");
+
+  AddInput(arg0, snapshot0, 0);
+  AddInput(snapshot0, ret0, 0);
+  AddInput(arg1, snapshot1, 0);
+  AddInput(snapshot1, ret1, 0);
+  AddInput(arg2, snapshot2, 0);
+  AddInput(snapshot2, ret2, 0);
+  AddInput(snapshot0, snapshot1, -1);
+  AddInput(snapshot1, snapshot2, -1);
+
+  ASSERT_EQ(parser.GraphDefOptimize(&graph), domi::SUCCESS);
+  ASSERT_EQ(ret1->input_size(), 2);
+  ret = modelParser.GetFormatTranspose(ret1, transpose_direc);
+  EXPECT_EQ(ret, SUCCESS);
+  delete transpose_node;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_GetTensorflowGraphInOutMap_test)
+{
+  TensorFlowModelParser model_parser;
+  tensorflow::GraphDef *graph = new tensorflow::GraphDef();
+  tensorflow::NodeDef *node_input = graph->add_node();
+  node_input->set_name("name_input");
+  node_input->set_op("op_input");
+
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Sigmoid5", "Sigmoid", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Sigmoid6", "Sigmoid", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Sigmoid7", "Sigmoid", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Mul5", "Mul", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Mul6", "Mul", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Mul7", "Mul", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Relu5", "Relu", "node_input");
+  AddGraphNode(graph, "t_lstm/t_lstm_cell/Relu6", "Relu", "node_input");
+  Status ret = model_parser.GetTensorflowGraphInOutMap(graph);
+  EXPECT_EQ(ret, SUCCESS);
+  delete graph;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_RemoveIsolateNode_test)
+{
+  TensorFlowModelParser model_parser;
+  tensorflow::GraphDef graph;
+  CreateGraphDef(graph);
+  Status ret = model_parser.RemoveIsolateNode(&graph);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_AddNodeToGraphAndMarkFormat_test)
+{
+  TensorFlowModelParser model_parser;
+  ComputeGraphPtr graph = make_shared<ge::ComputeGraph>("default");
+  std::vector<std::string> op_node_name_list = {"Const", "placeholder0"};
+  GenOriginNodeDef(&model_parser, op_node_name_list);
+  Status ret = model_parser.AddNodeToGraphAndMarkFormat(graph, op_node_name_list);
+  EXPECT_EQ(ret, INTERNAL_ERROR);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_ParserNodeDef1_test)
+{
+  ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
+
+  ModelParserFactory* factory = ModelParserFactory::Instance();
+  shared_ptr<ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);
+  ASSERT_TRUE(NULL != model_parser);
+  TensorFlowModelParser tensorflow_parser;
+  tensorflow_parser.adaptedOpTypeMap_["test_name"] = "POOLING";
+  std::mutex graphMutex;
+  tensorflow::GraphDef *graph = new tensorflow::GraphDef();
+  ScopePassManager passmanager;
+  shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);
+
+  domi::tensorflow::NodeDef node_def;
+  node_def.set_name("test_name");
+  node_def.set_op("POOLING");
+  error_message::Context error_context;
+  Status ret = ge::TensorFlowModelParser::ParseNodeDef(&tensorflow_parser, compute_graph, &graphMutex, scope_graph, &node_def, error_context);
+  EXPECT_EQ(FAILED, ret);
+  delete graph;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_ParserNodeDef2_test)
+{
+  ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
+
+  ModelParserFactory* factory = ModelParserFactory::Instance();
+  shared_ptr<ModelParser> model_parser= factory->CreateModelParser(domi::TENSORFLOW);
+  ASSERT_TRUE(NULL != model_parser);
+  TensorFlowModelParser tensorflow_parser;
+  tensorflow_parser.adaptedOpTypeMap_["Pooling"] = "Pooling";
+  std::mutex graphMutex;
+  tensorflow::GraphDef *graph = new tensorflow::GraphDef();
+  ScopePassManager passmanager;
+  shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);
+
+  REGISTER_CUSTOM_OP("Pooling")
+    .FrameworkType(domi::TENSORFLOW)
+    .OriginOpType("Pooling")
+    .ParseParamsFn(ParseParams)
+    .ImplyType(ImplyType::TVM);
+  register_tbe_op();
+  domi::tensorflow::NodeDef node_def;
+  node_def.set_name("Pooling");
+  node_def.set_op("Pooling");
+  error_message::Context error_context;
+  Status ret = ge::TensorFlowModelParser::ParseNodeDef(&tensorflow_parser, compute_graph, &graphMutex, scope_graph, &node_def, error_context);
+  EXPECT_EQ(FAILED, ret);
+  delete graph;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_AddExternalGraph_test)
+{
+  TensorFlowModelParser modelParser;
+  ge::ComputeGraphPtr subGraph = std::make_shared<ge::ComputeGraph>("default");
+  std::string inputNodeType = "DATA";
+  MakeDagGraph(subGraph, inputNodeType);
+  Status ret = modelParser.AddExternalGraph(subGraph);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_AddFmkNode_test)
+{
+  TensorFlowModelParser model_parser;
+  ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
+  tensorflow::GraphDef *graphDef = new (std::nothrow) tensorflow::GraphDef();
+  ScopePassManager pass_manager;
+  std::shared_ptr<ScopeGraph> scope_graph = pass_manager.BuildScopeGraph(graphDef);
+  std::vector<std::string> op_node_name_list = {"Const", "placeholder0"};
+  GenOriginNodeDef(&model_parser, op_node_name_list);
+  Status ret = model_parser.AddFmkNode(compute_graph, scope_graph, op_node_name_list, false);
+  EXPECT_EQ(ret, PARAM_INVALID);
+  delete graphDef;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_OptimizeConstNodes4CustomOp_test)
+{
+  TensorFlowModelParser model_parser;
+  tensorflow::GraphDef graph_def;
+  CreateGraphDef(graph_def);
+  Status ret = model_parser.OptimizeConstNodes4CustomOp(&graph_def);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_ParseOpParams_test)
+{
+  TensorFlowModelParser model_parser;
+  tensorflow::NodeDef *node_def = initNodeDef();
+  node_def->set_name("Pooling");
+  node_def->set_op("Pooling");
+  ge::OpDescPtr op = std::make_shared<ge::OpDesc>();
+  std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::TENSORFLOW);
+  std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("Pooling");
+  Status ret = model_parser.ParseOpParams(node_def, op, op_parser);
+  EXPECT_EQ(ret, FAILED);
+
+  node_def->set_name("TensorArrayWrite");
+  node_def->set_op("TensorArrayWriteV3");
+  op_parser = factory->CreateOpParser("TensorArrayWrite");
+  ret = model_parser.ParseOpParams(node_def, op, op_parser);
+  EXPECT_EQ(ret, SUCCESS);
+  delete node_def;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_AddFusionInnerNodeDef_test)
+{
+  TensorFlowModelParser model_parser;
+  ge::ComputeGraphPtr compute_graph = std::make_shared<ge::ComputeGraph>(GRAPH_DEFAULT_NAME);
+  tensorflow::GraphDef *graphDef = new (std::nothrow) tensorflow::GraphDef();
+  ScopePassManager pass_manager;
+  std::shared_ptr<ScopeGraph> scope_graph = pass_manager.BuildScopeGraph(graphDef);
+  std::vector<std::string> op_node_name_list = {"Const", "placeholder0"};
+  FusionScopesResult *fusion_scope_rlt = new (std::nothrow) FusionScopesResult();
+  fusion_scope_rlt->Init();
+  fusion_scope_rlt->SetName("FusionCustom");
+  auto &impl_scope_graph = scope_graph->impl_;
+  std::string scope_name = fusion_scope_rlt->Name();
+  impl_scope_graph->fusion_results_.insert(std::make_pair(scope_name, fusion_scope_rlt));
+  std::string fusion_op_name = "FusionCustom";
+  GenOriginNodeDef(&model_parser, op_node_name_list);
+  GenFusionScopesResult(scope_graph, fusion_scope_rlt, fusion_op_name);
+  Status ret = model_parser.AddFusionInnerNodeDef(scope_graph, fusion_op_name, op_node_name_list);
+  EXPECT_EQ(ret, INTERNAL_ERROR);
+  delete graphDef;
+}
+
+TEST_F(STestTensorflowParser, Scope_pass_test)
+{
+  ScopePassManager passmanager;
+  tensorflow::GraphDef *graph = new tensorflow::GraphDef();
+  shared_ptr<ScopeGraph> scope_graph = passmanager.BuildScopeGraph(graph);
+  EXPECT_NE(nullptr, scope_graph);
+
+  unique_ptr<ScopeBasePass> pass;
+  pass.reset(new ScopeTestPass());
+  EXPECT_EQ(domi::SUCCESS, passmanager.AddPass(pass));
+  scope_graph = passmanager.BuildScopeGraph(graph);
+  EXPECT_NE(nullptr, scope_graph);
+  delete graph;
+}
+
+TEST_F(STestTensorflowParser, operator_attr_set_and_get)
+{
+  TestOperator test_operator;
+  test_operator.Name("test_op");
+  EXPECT_EQ("test_op" , test_operator.GetName());
+
+  test_operator.Input(test_operator, 0);
+  test_operator.Input(test_operator, 1);
+  test_operator.GetOpAttrs();
+
+  int64_t pad = 1;
+  test_operator.Attr("pad", pad);
+  EXPECT_EQ(pad , test_operator.GetIntAttr("pad"));
+
+  bool bool_value = true;
+  test_operator.Attr("bool_value", bool_value);
+  EXPECT_EQ(bool_value , test_operator.GetBoolAttr("bool_value"));
+
+  float float_value = true;
+  test_operator.Attr("float_value", float_value);
+  EXPECT_EQ(float_value , test_operator.GetFloatAttr("float_value"));
+
+  std::string str_value = "test_string";
+  test_operator.Attr("str_value", str_value);
+  EXPECT_EQ(str_value , test_operator.GetStringAttr("str_value"));
+
+  BoolTuple boollist_value{true, false};
+  test_operator.Attr("boollist_value", boollist_value);
+  BoolTuple get_boollist_value = test_operator.GetBoolTupleAttr("boollist_value");
+  EXPECT_EQ(boollist_value[0] , get_boollist_value[0]);
+
+  StringTuple strlist_value{"a", "b"};
+  test_operator.Attr("strlist_value", strlist_value);
+  StringTuple get_strlist_value = test_operator.GetStringTupleAttr("strlist_value");
+  EXPECT_EQ(strlist_value[0] , get_strlist_value[0]);
+
+  int64_t num = 1;
+  IntTuple intlist{num, num};
+  test_operator.Attr("intlist", intlist);
+  IntTuple get_intlist = test_operator.GetIntTupleAttr("intlist");
+  EXPECT_EQ(intlist[0] , get_intlist[0]);
+
+  FloatTuple floatlist{1.1, 1.1};
+  test_operator.Attr("floatlist", floatlist);
+  FloatTuple get_floatlist = test_operator.GetFloatTupleAttr("floatlist");
+  EXPECT_EQ(floatlist[0] , get_floatlist[0]);
+
+  ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();
+  ParserOperator *op = &test_operator;
+  Status ret = ConvertToOpDesc(*op, op_desc);
+  EXPECT_EQ(domi::SUCCESS , ret);
+
+  TestOperator test_operator_1;
+  ParserOperator *op_convert = &test_operator_1;
+  ret = ConvertFromOpDesc(op_desc, *op_convert);
+  EXPECT_EQ(domi::SUCCESS , ret);
+
+  op_desc = nullptr;
+  ret = ConvertFromOpDesc(op_desc, *op_convert);
+  EXPECT_EQ(FAILED , ret);
+
+  ret = ConvertToOpDesc(*op, op_desc);
+  EXPECT_EQ(FAILED, ret);
+}
+
+TEST_F(STestTensorflowParser, success_frameworkop_get)
+{
+  FrameworkOpOperator *frameworkOp=new FrameworkOpOperator();
+  int64_t index = 1;
+  std::string opdef_string = "tensorflow_parser";
+  frameworkOp->GetFrameworkType();
+  frameworkOp->GetNodeDefPkg();
+  frameworkOp->FuncDefPkg("func");
+  frameworkOp->Index(index);
+  frameworkOp->TfOpDef(opdef_string);
+  EXPECT_EQ(SUCCESS, SUCCESS);
+  delete frameworkOp;
+}
+
+TEST_F(STestTensorflowParser, op_set_get_success)
+{
+  ConstantOperator op;
+  vector<int64_t> v;
+  op.VectorAttr("key", v);
+  op.GetDType();
+}
+
+TEST_F(STestTensorflowParser, success_argop_get)
+{
+  ArgOpOperator *argOp=new ArgOpOperator();
+  int64_t index = 1;
+  argOp->Index(index);
+  argOp->GetIndex();
+  EXPECT_EQ(domi::SUCCESS, SUCCESS);
+  delete argOp;
+}
+
+TEST_F(STestTensorflowParser, success_operator)
+{
+  ParserOperator tfOperator;
+  ParserOperator in_op;
+  uint32_t index = 0;
+  std::string type = "add";
+  std::string key = "Add";
+  std::vector<int64_t> value;
+  int64_t tmp = 0;
+  value.emplace_back(tmp);
+  tfOperator.Input(in_op, index);
+  tfOperator.Type(type);
+  tfOperator.AttrVector(key, value);
+}
+
+TEST_F(STestTensorflowParser, success_shapen_get)
+{
+  ShapeNOperator *shapen =new ShapeNOperator();
+  shapen->GetInType();
+  shapen->GetInType();
+  shapen->GetOutType();
+  EXPECT_EQ(domi::SUCCESS, domi::SUCCESS);
+  delete shapen;
+}
+
+TEST_F(STestTensorflowParser, success_VarIsInitializedOpOperator_get)
+{
+  VarIsInitializedOpOperator op;
+  op.Name("x");
+  std::vector<int64_t> value;
+  op.VectorAttr("key", value);
+}
+
+TEST_F(STestTensorflowParser, success_variable_op_get)
+{
+  VariableOperator op;
+  uint32_t mem_type = 1;
+  op.Name("x");
+  std::vector<int64_t> value;
+  op.Placement("shared_name");
+  op.MemType(mem_type);
+}
+
+TEST_F(STestTensorflowParser, param_success_get)
+{
+  FillOperator* fillOp=new FillOperator();
+  fillOp->GetDataType();
+  fillOp->GetAlpha();
+  fillOp->GetBeta();
+  EXPECT_EQ(domi::SUCCESS, domi::SUCCESS);
+  delete fillOp;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_Message2Operator_ParseOperatorAttrs_test)
+{
+  Message2Operator mess2Op;
+  tensorflow::NodeDef *node_def = initNodeDef();
+  int depth = 6;
+  ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>();
+  ge::Operator ops = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc);
+  Status ret = mess2Op.ParseOperatorAttrs(node_def, depth, ops);
+  EXPECT_EQ(ret, FAILED);
+
+  depth = 4;
+  ret = mess2Op.ParseOperatorAttrs(node_def, depth, ops);
+  EXPECT_EQ(ret, SUCCESS);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_Pb2Json_RepeatedEnum2Json_test)
+{
+  Pb2Json toJson;
+  ProtobufEnumValueDescriptor *enum_value_desc = new google::protobuf::EnumValueDescriptor();
+  bool enum2str = true;
+  Json json;
+  ProtobufFieldDescriptor *field = nullptr;
+  toJson.RepeatedEnum2Json(enum_value_desc, enum2str, json);
+  toJson.Enum2Json(enum_value_desc, field, enum2str, json);
+
+  enum2str = false;
+  toJson.RepeatedEnum2Json(enum_value_desc, enum2str, json);
+  delete enum_value_desc;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_Pb2Json_TypeBytes2String_test)
+{
+  Pb2Json toJson;
+  std::string field_name = "offset";
+  std::string type_bytes = "offset";
+  toJson.TypeBytes2String(field_name, type_bytes);
+
+  field_name = "test";
+  toJson.TypeBytes2String(field_name, type_bytes);
+}
+
+TEST_F(STestTensorflowParser, tensorflow_Pb2Json_RepeatedMessage2Json_test)
+{
+  Pb2Json toJson;
+  tensorflow::NodeDef *node_def = initNodeDef();
+  ProtobufFieldDescriptor *field = new google::protobuf::FieldDescriptor();
+  ProtobufReflection *reflection = nullptr;
+  set<string> black_fields;
+  black_fields.emplace("offset");
+  Json json;
+  bool enum2str = true;
+  toJson.RepeatedMessage2Json((*node_def), field, reflection, black_fields, json, enum2str);
+  delete field;
+}
+
+TEST_F(STestTensorflowParser, tensorflow_Pb2Json_OneField2Json_test)
+{
+  Pb2Json toJson;
+  tensorflow::NodeDef *node_def = initNodeDef();
+  ProtobufFieldDescriptor *field = new google::protobuf::FieldDescriptor();
+  ProtobufReflection *reflection = nullptr;
+  set<string> black_fields;
+  black_fields.emplace("offset");
+  Json json;
+  bool enum2str = true;
+
+  Message2Operator mess2Op;
+  int depth = 4;
+  ge::OpDescPtr op_desc = std::make_shared<ge::OpDesc>("FusionCustom", "FusionCustom");
+  ge::Operator ops = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc);
+  field->CppTypeName(google::protobuf::FieldDescriptor::CPPTYPE_ENUM);
+  mess2Op.ParseField(reflection, node_def, field, depth, ops);
+  toJson.OneField2Json((*node_def), field, reflection, black_fields, json, enum2str);
+  delete field;
+}
+
 } // namespace ge