wangwei
/
parser
Not watched
1
0
Fork 0
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

Pre Merge pull request !438 from jwx930962/st_parser

pull/438/MERGE
jwx930962 Gitee 4 years ago
parent
afd18fbc3f 09f17be3bf
commit
3372aa8ecc
4 changed files with 507 additions and 6 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +192
    -5
      tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc
  2. +176
    -0
      tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc
  3. +49
    -0
      tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc
  4. +90
    -1
      tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc

+ 192
- 5
tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc View File

@@ -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

+ 176
- 0
tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc View File

@@ -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

+ 49
- 0
tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc View File

@@ -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

+ 90
- 1
tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc View File

@@ -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

Write Preview
Loading…
Cancel
Save