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

!441 increase ut testcase 

Merge pull request !441 from jwx930962/st_parser
pull/439/MERGE
i-robot Gitee 3 years ago
parent
afd18fbc3f e1c0745308
commit
c8b4d54b71
5 changed files with 672 additions and 10 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +18
    -0
      tests/ut/parser/testcase/caffe_parser_testcase/caffe_model/custom.proto
  2. +266
    -10
      tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc
  3. +248
    -0
      tests/ut/parser/testcase/common/acl_graph_parser_unittest.cc
  4. +49
    -0
      tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc
  5. +91
    -0
      tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc

+ 18
- 0
tests/ut/parser/testcase/caffe_parser_testcase/caffe_model/custom.proto View File

@@ -0,0 +1,18 @@
syntax = "proto2";
package domi::caffe;

message FillerParameter {
optional string type = 1 [default = 'constant'];
optional float value = 2 [default = 0];
optional float min = 3 [default = 0];
optional float max = 4 [default = 1];
optional float mean = 5 [default = 0];
optional float std = 6 [default = 1];
optional int32 sparse = 7 [default = 1];
enum VarianceNorm {
FAN_IN = 0;
FAN_OUT = 1;
AVERAGE = 2;
}
optional VarianceNorm variance_norm = 8 [default = FAN_IN];
}

+ 266
- 10
tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc View File

@@ -42,6 +42,12 @@
#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>
#include <google/protobuf/dynamic_message.h>

using namespace domi::caffe;
using namespace ge;

@@ -262,23 +268,32 @@ TEST_F(UtestCaffeParser, acl_caffe_parser) {
EXPECT_EQ(ret, GRAPH_FAILED);
}

TEST_F(UtestCaffeParser, modelparser_parsefrommemory_success)
TEST_F(UtestCaffeParser, ParseFromMemory_success)
{
std::string caseDir = __FILE__;
std::size_t idx = caseDir.find_last_of("/");
caseDir = caseDir.substr(0, idx);
std::string modelFile = caseDir + "/caffe_model/caffe_add.pbtxt";
std::string weight_file = caseDir + "/caffe_model/caffe_add.caffemodel";

const char* tmp_tf_pb_model = modelFile.c_str();
const char* tmp_tf_weight_model = weight_file.c_str();
ge::Graph graph;

Status ret = ge::aclgrphParseCaffe(modelFile.c_str(), weight_file.c_str(), graph);
ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph);
CaffeModelParser modelParser;
MemBuffer* memBuffer = ParerUTestsUtils::MemBufferFromFile(tmp_tf_pb_model);
auto ret = modelParser.ParseFromMemory((char*)memBuffer->data, memBuffer->size, compute_graph);
free(memBuffer->data);
delete memBuffer;
MemBuffer* memBuffer1 = ParerUTestsUtils::MemBufferFromFile(tmp_tf_pb_model);
ret = modelParser.ParseFromMemory((char*)memBuffer1->data, memBuffer1->size, compute_graph);
EXPECT_EQ(ret, GRAPH_FAILED);

CaffeWeightsParser weigthParser;
MemBuffer* memBuffer2 = ParerUTestsUtils::MemBufferFromFile(tmp_tf_weight_model);
ret = weigthParser.ParseFromMemory((char*)memBuffer2->data, memBuffer2->size, compute_graph);
free(memBuffer1->data);
free(memBuffer2->data);
delete memBuffer1;
delete memBuffer2;
}

TEST_F(UtestCaffeParser, caffe_parser_to_json) {
@@ -324,7 +339,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 +350,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;
}

@@ -413,6 +429,20 @@ TEST_F(UtestCaffeParser, CaffeWeightsParser_Parse_test)
graph = std::make_shared<ComputeGraph>("test");
ret = weightParser.Parse(file, graph);
EXPECT_EQ(ret, FAILED);

std::string caffe_proto = case_dir + "/../../../../metadef/proto/caffe/";
std::string custom_proto = case_dir + "/caffe_model/";
ge::GetParserContext().caffe_proto_path.assign(caffe_proto);
ge::GetParserContext().custom_proto_path.assign(custom_proto);
ret = weightParser.Parse(file, graph);
EXPECT_EQ(ret, FAILED);

custom_proto = case_dir + "/caffe_models/";
caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
ge::GetParserContext().caffe_proto_path.assign(caffe_proto);
ge::GetParserContext().custom_proto_path.assign(custom_proto);
ret = weightParser.Parse(file, graph);
EXPECT_EQ(ret, SUCCESS);
}

TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseWeightByFusionProto_test)
@@ -677,6 +707,13 @@ TEST_F(UtestCaffeParser, CaffeModelParser_CustomProtoParse_test)

Status ret = modelParser.CustomProtoParse(model_path, custom_proto, caffe_proto, operators);
EXPECT_EQ(ret, PARAM_INVALID);

model_file = case_dir + "/caffe_model/caffe_add.pbtxt";
custom_proto = case_dir + "/../../../../../metadef/proto/caffe/caffe.proto";
model_path = model_file.c_str();
std::string caffe_proto_path = case_dir + "/../../../../../metadef/proto/caffe/caffe.proto";
ret = modelParser.CustomProtoParse(model_path, custom_proto, caffe_proto_path, operators);
EXPECT_EQ(ret, SUCCESS);
}

TEST_F(UtestCaffeParser, CaffeWeightsParser_ParseGraph_test)
@@ -738,6 +775,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 +799,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)
@@ -766,6 +819,23 @@ TEST_F(UtestCaffeParser, CaffeWeightsParser_ConvertLayerParameter_test)

Status ret = weightParser.ConvertLayerParameter(layer, compute_graph);
EXPECT_EQ(ret, SUCCESS);

std::string case_dir = __FILE__;
case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
std::string caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
google::protobuf::compiler::DiskSourceTree sourceTree;
sourceTree.MapPath("project_root", caffe_proto);
google::protobuf::compiler::Importer importer(&sourceTree, nullptr);
importer.Import("project_root/caffe.proto");

auto descriptor = importer.pool()->FindMessageTypeByName("domi.caffe.LayerParameter");
google::protobuf::DynamicMessageFactory factory;
const google::protobuf::Message *proto = factory.GetPrototype(descriptor);
const google::protobuf::Message *message = proto->New();

ret = weightParser.ConvertLayerParameter(layer, compute_graph);
EXPECT_EQ(ret, SUCCESS);
delete message;
}

TEST_F(UtestCaffeParser, CaffeWeightsParser_CheckLayersSize_test)
@@ -914,4 +984,190 @@ 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);
std::string case_dir = __FILE__;
case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
std::string caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
google::protobuf::compiler::DiskSourceTree sourceTree;
sourceTree.MapPath("project_root", caffe_proto);
google::protobuf::compiler::Importer importer(&sourceTree, nullptr);
importer.Import("project_root/caffe.proto");

auto descriptor = importer.pool()->FindMessageTypeByName("domi.caffe.LayerParameter");
google::protobuf::DynamicMessageFactory factory;
const google::protobuf::Message *proto = factory.GetPrototype(descriptor);
const google::protobuf::Message *message = proto->New();

Status ret = weightParser.ParseLayerParameter(descriptor, message, compute_graph);
delete message;
EXPECT_EQ(ret, SUCCESS);
}

TEST_F(UtestCaffeParser, CaffeModelParser_ParseLayerParameter_test)
{
CaffeModelParser modelParser;
domi::caffe::NetParameter net;
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);

std::string case_dir = __FILE__;
case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
std::string caffe_proto = case_dir + "/../../../../../metadef/proto/caffe/";
google::protobuf::compiler::DiskSourceTree sourceTree;
sourceTree.MapPath("project_root", caffe_proto);
google::protobuf::compiler::Importer importer(&sourceTree, nullptr);
importer.Import("project_root/caffe.proto");

auto descriptor = importer.pool()->FindMessageTypeByName("domi.caffe.LayerParameter");
google::protobuf::DynamicMessageFactory factory;
const google::protobuf::Message *proto = factory.GetPrototype(descriptor);
const google::protobuf::Message *message = proto->New();
Status ret = modelParser.ParseLayerParameter(descriptor, message, operators);
EXPECT_EQ(ret, SUCCESS);
delete message;
}

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_ReorderInput_test)
{
CaffeModelParser modelParser;

domi::caffe::NetParameter net;
domi::caffe::LayerParameter *layer1 = net.add_layer();
layer1->set_name("Abs");
layer1->set_type("AbsVal");

domi::caffe::LayerParameter *layer2 = net.add_layer();
layer2->set_name("Data");
layer2->set_type("Input");
modelParser.ReorderInput(net);
}

} // namespace ge

+ 248
- 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,20 @@
#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"
#include "parser/common/parser_fp16_t.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 +111,235 @@ 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);
}

TEST_F(UtestAclGraphParser, test_operatoreq)
{
float f_val1= 2139095000.2;
ge::parser::fp16_t fp16_1,fp16_2;
fp16_1.operator=(fp16_2);
fp16_1.operator=(f_val1);

float f_val2= 0.0000112;
fp16_1.operator=(f_val2);

float f_val3= 0.0000000299;
fp16_1.operator=(f_val3);

float f_val4= 0.00000000299;
fp16_1.operator=(f_val4);

uint32_t u_val1 = 4095;
fp16_1.operator=(u_val1);

uint16_t u16_val1 = 4095;
fp16_1.operator=(u16_val1);

int16_t int_val1 = 0;
fp16_1.operator=(int_val1);

int16_t int_val2 = -32767;
fp16_1.operator=(int_val2);

int32_t i_val = -0x7FFFFFFF;
fp16_1.operator=(i_val);

parser::fp16_t fp16;
fp16.operator=(f_val1);
float f = fp16; //float();
double d = fp16;
int8_t int8 = fp16;
uint8_t uint8 = fp16;
uint16_t uint16 = fp16;
int32_t int32 = fp16;
uint32_t uint32 = fp16;
int64_t int64 = fp16;
uint64_t uint64 = fp16;

(void)f;
(void)d;
(void)int8;
(void)uint8;
(void)uint8;
(void)uint16;
(void)int32;
(void)uint32;
(void)int64;
(void)uint64;

parser::fp16_t val;
val.val = 0x7C00;
val.IsInf();

val.val = 0xFC00;
val.IsInf();

parser::fp16_t fp16_3, fp16_4;
fp16_3.val = 1;
fp16_4.val = 2;
fp16_4.operator/(fp16_3);

fp16.val = 21504;
int16_t int16 = fp16;
int8 = fp16;
}

} // 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

+ 91
- 0
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,6 +4035,10 @@ 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);
@@ -4020,16 +4046,22 @@ TEST_F(UtestTensorflowParser, tensorflow_FP16_parser_test)
fp16.operator=(ui16_val);
ui16_val = 1;
fp16.operator=(ui16_val);
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 +4650,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