IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed legacy API from common frontend and shared tests (#19583)

Browse Source 
* Removed legacy API from common frontend and shared tests

* Fixed build
This commit is contained in:
Ilya Churaev
2023-09-06 12:24:18 +04:00
committed by GitHub
parent bd66971dd6
commit 7a4e765600
24 changed files with 112 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/frontends/common/include/openvino/frontend/extension/op.hpp
View File

@@ -94,7 +94,7 @@ inline std::shared_ptr<ov::Node> create_ov_node_by_name(const std::string& ov_ty
"name ",
op_name);
}
return std::shared_ptr<ngraph::Node>(opset.create(op_name));
return std::shared_ptr<ov::Node>(opset.create(op_name));
}
// One-to-one operation mapping for OVOpType != void which means OV type is specified by OVOpType

2
src/frontends/onnx/tests/load_from.cpp
View File

@@ -43,7 +43,7 @@ TEST_P(FrontEndLoadFromTest, testLoadFromStreamAndPassPath) {
ASSERT_NO_THROW(m_inputModel = m_frontEnd->load(is, path)) << "Could not load the model";
ASSERT_NE(m_inputModel, nullptr);
std::shared_ptr<ngraph::Function> function;
std::shared_ptr<ov::Model> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel)) << "Could not convert the model to OV representation";
ASSERT_NE(function, nullptr);
}

2
src/frontends/tests/frontend/shared/include/basic_api.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
using BasicTestParam = std::tuple<std::string, // FrontEnd name
std::string, // Base path to models

4
src/frontends/tests/frontend/shared/include/conversion_extension.hpp
View File

@@ -6,8 +6,8 @@
#include <gtest/gtest.h>
#include <openvino/frontend/extension/conversion.hpp>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/extension/conversion.hpp"
#include "openvino/frontend/manager.hpp"
struct ConversionExtensionFEParam {
std::string m_frontEndName;

2
src/frontends/tests/frontend/shared/include/convert_model.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
using ConvertParam = std::tuple<std::string, // FrontEnd name
std::string, // Base path to models

2
src/frontends/tests/frontend/shared/include/cut_specific_model.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
struct CutModelParam {
std::string m_frontEndName;

2
src/frontends/tests/frontend/shared/include/library_extension.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
struct FrontendLibraryExtensionTestParams {
std::string m_frontEndName;

2
src/frontends/tests/frontend/shared/include/load_from.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
struct LoadFromFEParam {
std::string m_frontEndName;

4
src/frontends/tests/frontend/shared/include/op_extension.hpp
View File

@@ -6,8 +6,8 @@
#include <gtest/gtest.h>
#include <openvino/frontend/extension/op.hpp>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/extension/op.hpp"
#include "openvino/frontend/manager.hpp"
struct OpExtensionFEParam {
std::string m_frontEndName;

2
src/frontends/tests/frontend/shared/include/op_fuzzy.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
using FuzzyOpTestParam = std::tuple<std::string, // FrontEnd name
std::string, // Base path to models

6
src/frontends/tests/frontend/shared/include/partial_shape.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
struct BaseFEParam {
BaseFEParam() {}
@@ -20,8 +20,8 @@ struct BaseFEParam {
struct PartShape {
std::string m_modelName;
std::string m_tensorName;
ngraph::PartialShape m_oldPartialShape;
ngraph::PartialShape m_newPartialShape;
ov::PartialShape m_oldPartialShape;
ov::PartialShape m_newPartialShape;
};
using PartialShapeParam = std::tuple<BaseFEParam, PartShape>;

2
src/frontends/tests/frontend/shared/include/set_element_type.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
struct SetTypeFEParam {
std::string m_frontEndName;

2
src/frontends/tests/frontend/shared/include/telemetry.hpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include <openvino/frontend/manager.hpp>
#include "openvino/frontend/manager.hpp"
class TelemetryMock {
public:

1
src/frontends/tests/frontend/shared/include/utils.hpp
View File

@@ -10,7 +10,6 @@
#include "common_test_utils/file_utils.hpp"
#include "file_utils.h"
#include "ngraph/util.hpp"
#include "openvino/util/env_util.hpp"
#include "openvino/util/file_util.hpp"

7
src/frontends/tests/frontend/shared/src/basic_api.cpp
View File

@@ -6,7 +6,6 @@
#include "utils.hpp"
using namespace ngraph;
using namespace ov::frontend;
std::string FrontEndBasicTest::getTestCaseName(const testing::TestParamInfo<BasicTestParam>& obj) {
@@ -32,9 +31,9 @@ void FrontEndBasicTest::doLoadFromFile() {
TEST_P(FrontEndBasicTest, testLoadFromFile) {
ASSERT_NO_THROW(doLoadFromFile());
ASSERT_EQ(m_frontEnd->get_name(), m_feName);
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
ASSERT_NE(model, nullptr);
}
TEST_P(FrontEndBasicTest, testInputModel_getInputsOutputs) {

8
src/frontends/tests/frontend/shared/src/conversion.cpp
View File

@@ -2,13 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <openvino/frontend/extension/conversion.hpp>
#include <openvino/frontend/extension/decoder_transformation.hpp>
#include <openvino/op/util/framework_node.hpp>
#include <openvino/opsets/opset8.hpp>
#include "openvino/frontend/extension/conversion.hpp"
#include "common_test_utils/file_utils.hpp"
#include "conversion_extension.hpp"
#include "openvino/frontend/extension/decoder_transformation.hpp"
#include "openvino/op/util/framework_node.hpp"
#include "openvino/opsets/opset8.hpp"
#include "utils.hpp"
using namespace ov::frontend;

31
src/frontends/tests/frontend/shared/src/convert_model.cpp
View File

@@ -8,7 +8,6 @@
#include "openvino/pass/visualize_tree.hpp"
#include "utils.hpp"
using namespace ngraph;
using namespace ov::frontend;
std::string FrontEndConvertModelTest::getTestCaseName(const testing::TestParamInfo<ConvertParam>& obj) {
@@ -38,37 +37,37 @@ void FrontEndConvertModelTest::doLoadFromFile() {
TEST_P(FrontEndConvertModelTest, test_convert_partially_equal_convert) {
ASSERT_NO_THROW(doLoadFromFile());
std::shared_ptr<ngraph::Function> function_ref;
ASSERT_NO_THROW(function_ref = m_frontEnd->convert(m_inputModel));
ASSERT_NE(function_ref, nullptr);
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert_partially(m_inputModel));
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model_ref;
ASSERT_NO_THROW(model_ref = m_frontEnd->convert(m_inputModel));
ASSERT_NE(model_ref, nullptr);
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert_partially(m_inputModel));
ASSERT_NE(model, nullptr);
FunctionsComparator func_comparator = FunctionsComparator::with_default();
// TODO: enable name comparison for tf when TransposeSinking is fixed, ticket 68960
if (m_frontEnd->get_name() != "tf" && m_frontEnd->get_name() != "tflite") {
func_comparator.enable(FunctionsComparator::NAMES);
}
const FunctionsComparator::Result res = func_comparator(function, function_ref);
const FunctionsComparator::Result res = func_comparator(model, model_ref);
ASSERT_TRUE(res.valid) << res.message;
}
TEST_P(FrontEndConvertModelTest, test_decode_convert_equal_convert) {
ASSERT_NO_THROW(doLoadFromFile());
std::shared_ptr<ngraph::Function> function_ref;
ASSERT_NO_THROW(function_ref = m_frontEnd->convert(m_inputModel));
ASSERT_NE(function_ref, nullptr);
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->decode(m_inputModel));
ASSERT_NO_THROW(m_frontEnd->convert(function));
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model_ref;
ASSERT_NO_THROW(model_ref = m_frontEnd->convert(m_inputModel));
ASSERT_NE(model_ref, nullptr);
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->decode(m_inputModel));
ASSERT_NO_THROW(m_frontEnd->convert(model));
ASSERT_NE(model, nullptr);
FunctionsComparator func_comparator = FunctionsComparator::with_default();
// TODO: enable name comparison for tf when TransposeSinking is fixed, ticket 68960
if (m_frontEnd->get_name() != "tf" && m_frontEnd->get_name() != "tflite") {
func_comparator.enable(FunctionsComparator::NAMES);
}
const FunctionsComparator::Result res = func_comparator(function, function_ref);
const FunctionsComparator::Result res = func_comparator(model, model_ref);
ASSERT_TRUE(res.valid) << res.message;
}

60
src/frontends/tests/frontend/shared/src/cut_specific_model.cpp
View File

@@ -4,10 +4,10 @@
#include "cut_specific_model.hpp"
#include "ngraph/opsets/opset7.hpp"
#include "openvino/core/model.hpp"
#include "openvino/op/constant.hpp"
#include "utils.hpp"
using namespace ngraph;
using namespace ov::frontend;
static std::string joinStrings(const std::vector<std::string>& strings) {
@@ -100,15 +100,15 @@ TEST_P(FrontEndCutModelTest, testOverrideOutputs) {
TEST_P(FrontEndCutModelTest, testOldInputs) {
ASSERT_NO_THROW(doLoadFromFile());
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
// Ensure that it contains expected old inputs
for (const auto& name : m_param.m_oldInputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) != ops.end())
<< "Name not found:" << name;
@@ -117,14 +117,14 @@ TEST_P(FrontEndCutModelTest, testOldInputs) {
TEST_P(FrontEndCutModelTest, testOldOutputs) {
ASSERT_NO_THROW(doLoadFromFile());
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
// Ensure that it contains expected old outputs
for (const auto& name : m_param.m_oldOutputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) != ops.end())
<< "Name not found:" << name;
@@ -137,15 +137,15 @@ TEST_P(FrontEndCutModelTest, testNewInputs_func) {
ASSERT_NO_THROW(newPlaces = constructNewInputs());
ASSERT_NO_THROW(m_inputModel->override_all_inputs(newPlaces));
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
// Ensure that it doesn't contain old inputs
for (const auto& name : m_param.m_oldInputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) == ops.end())
<< "Name shall not exist:" << name;
@@ -155,7 +155,7 @@ TEST_P(FrontEndCutModelTest, testNewInputs_func) {
for (const auto& name : m_param.m_newInputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) != ops.end())
<< "Name not found:" << name;
@@ -168,15 +168,15 @@ TEST_P(FrontEndCutModelTest, testNewOutputs_func) {
ASSERT_NO_THROW(newPlaces = constructNewOutputs());
ASSERT_NO_THROW(m_inputModel->override_all_outputs(newPlaces));
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
// Ensure that it doesn't contain old outputs
for (const auto& name : m_param.m_oldOutputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) == ops.end())
<< "Name shall not exist:" << name;
@@ -186,7 +186,7 @@ TEST_P(FrontEndCutModelTest, testNewOutputs_func) {
for (const auto& name : m_param.m_newOutputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) != ops.end())
<< "Name not found:" << name;
@@ -200,15 +200,15 @@ TEST_P(FrontEndCutModelTest, testExtractSubgraph) {
ASSERT_NO_THROW(newOutputs = constructNewOutputs());
ASSERT_NO_THROW(m_inputModel->extract_subgraph(newInputs, newOutputs));
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
// Ensure that it doesn't contain expected old outputs
for (const auto& name : m_param.m_oldOutputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) == ops.end())
<< "Name shall not exist:" << name;
@@ -218,7 +218,7 @@ TEST_P(FrontEndCutModelTest, testExtractSubgraph) {
for (const auto& name : m_param.m_newOutputs) {
EXPECT_TRUE(std::find_if(ops.begin(),
ops.end(),
[&](const std::shared_ptr<ngraph::Node>& node) {
[&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
}) != ops.end())
<< "Name not found:" << name;
@@ -231,16 +231,16 @@ TEST_P(FrontEndCutModelTest, testSetTensorValue) {
ASSERT_NO_THROW(place = m_inputModel->get_place_by_tensor_name(m_param.m_tensorValueName));
ASSERT_NO_THROW(m_inputModel->set_tensor_value(place, &m_param.m_tensorValue[0]));
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
auto const_name = m_param.m_tensorValueName;
auto const_node_it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ngraph::Node>& node) {
auto const_node_it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(const_name) != std::string::npos;
});
ASSERT_TRUE(const_node_it != ops.end()) << "Name shall exist:" << const_name;
auto data = std::dynamic_pointer_cast<opset7::Constant>(*const_node_it)->get_vector<float>();
auto data = std::dynamic_pointer_cast<ov::op::v0::Constant>(*const_node_it)->get_vector<float>();
EXPECT_EQ(data.size(), m_param.m_tensorValue.size()) << "Data size must be equal to expected size";
EXPECT_TRUE(std::equal(data.begin(), data.end(), m_param.m_tensorValue.begin())) << "Data must be equal";
}

1
src/frontends/tests/frontend/shared/src/library_extension.cpp
View File

@@ -4,7 +4,6 @@
#include "library_extension.hpp"
#include <common_test_utils/graph_comparator.hpp>
#include <ostream>
#include "common_test_utils/file_utils.hpp"

25
src/frontends/tests/frontend/shared/src/load_from.cpp
View File

@@ -9,7 +9,6 @@
#include "openvino/core/runtime_attribute.hpp"
#include "utils.hpp"
using namespace ngraph;
using namespace ov::frontend;
std::string FrontEndLoadFromTest::getTestCaseName(const testing::TestParamInfo<LoadFromFEParam>& obj) {
@@ -35,9 +34,9 @@ TEST_P(FrontEndLoadFromTest, testLoadFromFilePath) {
ASSERT_NO_THROW(m_inputModel = m_frontEnd->load(model_path));
ASSERT_NE(m_inputModel, nullptr);
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
ASSERT_NE(model, nullptr);
}
TEST_P(FrontEndLoadFromTest, testLoadFromFilePathWithExplicitVariants) {
@@ -71,9 +70,9 @@ TEST_P(FrontEndLoadFromTest, testLoadFromTwoFiles) {
ASSERT_NO_THROW(m_inputModel = m_frontEnd->load(model_path, weights_path));
ASSERT_NE(m_inputModel, nullptr);
std::shared_ptr<ngraph::Function> function;
function = m_frontEnd->convert(m_inputModel);
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model;
model = m_frontEnd->convert(m_inputModel);
ASSERT_NE(model, nullptr);
}
TEST_P(FrontEndLoadFromTest, testLoadFromStream) {
@@ -89,9 +88,9 @@ TEST_P(FrontEndLoadFromTest, testLoadFromStream) {
ASSERT_NO_THROW(m_inputModel = m_frontEnd->load(is));
ASSERT_NE(m_inputModel, nullptr);
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
ASSERT_NE(model, nullptr);
}
TEST_P(FrontEndLoadFromTest, testLoadFromTwoStreams) {
@@ -111,7 +110,7 @@ TEST_P(FrontEndLoadFromTest, testLoadFromTwoStreams) {
ASSERT_NO_THROW(m_inputModel = m_frontEnd->load(model_is, weights_is));
ASSERT_NE(m_inputModel, nullptr);
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
ASSERT_NE(model, nullptr);
}

7
src/frontends/tests/frontend/shared/src/op_extension.cpp
View File

@@ -4,12 +4,7 @@
#include "op_extension.hpp"
#include <openvino/frontend/extension/decoder_transformation.hpp>
#include <openvino/frontend/extension/op.hpp>
#include <openvino/op/util/framework_node.hpp>
#include <openvino/opsets/opset8.hpp>
#include <openvino/runtime/core.hpp>
#include "openvino/runtime/core.hpp"
#include "utils.hpp"
using namespace ov::frontend;

35
src/frontends/tests/frontend/shared/src/op_fuzzy.cpp
View File

@@ -10,10 +10,6 @@
#include "common_test_utils/test_control.hpp"
#include "utils.hpp"
using namespace ngraph;
using namespace InferenceEngine;
using namespace ngraph;
using namespace ov::frontend;
std::string FrontEndFuzzyOpTest::getTestCaseName(const testing::TestParamInfo<FuzzyOpTestParam>& obj) {
@@ -59,46 +55,45 @@ static std::string getModelFolder(const std::string& modelFile) {
return modelFile.substr(0, found);
};
void FrontEndFuzzyOpTest::runConvertedModel(const std::shared_ptr<ngraph::Function> function,
const std::string& modelFile) {
void FrontEndFuzzyOpTest::runConvertedModel(const std::shared_ptr<ov::Model> model, const std::string& modelFile) {
auto modelFolder = getModelFolder(modelFile);
// run test
auto testCase = ov::test::TestCase(function, "CPU");
auto testCase = ov::test::TestCase(model, "CPU");
const auto parameters = function->get_parameters();
const auto parameters = model->get_parameters();
for (size_t i = 0; i < parameters.size(); i++) {
// read input npy file
std::string dataFile = modelFolder + "/input" + std::to_string((parameters.size() - 1) - i) + ".npy";
cnpy::NpyArray input = cnpy::npy_load(dataFile);
auto input_dtype = parameters[i]->get_element_type();
if (input_dtype == element::f32) {
if (input_dtype == ov::element::f32) {
addInputOutput<float>(input, testCase, true);
} else if (input_dtype == element::i32) {
} else if (input_dtype == ov::element::i32) {
addInputOutput<int32_t>(input, testCase, true);
} else if (input_dtype == element::i64) {
} else if (input_dtype == ov::element::i64) {
addInputOutput<int64_t>(input, testCase, true);
} else if (input_dtype == element::boolean) {
} else if (input_dtype == ov::element::boolean) {
addInputOutput<bool>(input, testCase, true);
} else {
throw std::runtime_error("not supported dtype in" + input_dtype.get_type_name());
}
}
const auto results = function->get_results();
const auto results = model->get_results();
bool useFloatTest = false;
for (size_t i = 0; i < results.size(); i++) {
// read expected output npy file
std::string dataFile = modelFolder + "/output" + std::to_string(i) + ".npy";
cnpy::NpyArray output = cnpy::npy_load(dataFile);
auto outputDtype = results[i]->get_element_type();
if (outputDtype == element::f32) {
if (outputDtype == ov::element::f32) {
addInputOutput<float>(output, testCase, false);
useFloatTest = true;
} else if (outputDtype == element::i32) {
} else if (outputDtype == ov::element::i32) {
addInputOutput<int32_t>(output, testCase, false);
} else if (outputDtype == element::i64) {
} else if (outputDtype == ov::element::i64) {
addInputOutput<int64_t>(output, testCase, false);
} else {
throw std::runtime_error("not supported dtype out " + outputDtype.get_type_name());
@@ -117,10 +112,10 @@ TEST_P(FrontEndFuzzyOpTest, testOpFuzzy) {
ASSERT_NO_THROW(doLoadFromFile());
// convert
std::shared_ptr<ngraph::Function> function;
function = m_frontEnd->convert(m_inputModel);
ASSERT_NE(function, nullptr);
std::shared_ptr<ov::Model> model;
model = m_frontEnd->convert(m_inputModel);
ASSERT_NE(model, nullptr);
// run
runConvertedModel(function, m_modelFile);
runConvertedModel(model, m_modelFile);
}

19
src/frontends/tests/frontend/shared/src/partial_shape.cpp
View File

@@ -6,7 +6,6 @@
#include "utils.hpp"
using namespace ngraph;
using namespace ov::frontend;
std::string FrontEndPartialShapeTest::getTestCaseName(const testing::TestParamInfo<PartialShapeParam>& obj) {
@@ -40,10 +39,10 @@ void FrontEndPartialShapeTest::doLoadFromFile() {
TEST_P(FrontEndPartialShapeTest, testCheckOldPartialShape) {
ASSERT_NO_THROW(doLoadFromFile());
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
auto it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ngraph::Node>& node) {
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
auto it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(m_partShape.m_tensorName) != std::string::npos;
});
ASSERT_NE(it, ops.end());
@@ -56,12 +55,12 @@ TEST_P(FrontEndPartialShapeTest, testSetNewPartialShape) {
Place::Ptr place;
ASSERT_NO_THROW(place = m_inputModel->get_place_by_tensor_name(m_partShape.m_tensorName));
ASSERT_NE(place, nullptr);
ASSERT_NO_THROW(m_inputModel->set_partial_shape(place, PartialShape{m_partShape.m_newPartialShape}));
ASSERT_NO_THROW(m_inputModel->set_partial_shape(place, ov::PartialShape{m_partShape.m_newPartialShape}));
std::shared_ptr<ngraph::Function> function;
ASSERT_NO_THROW(function = m_frontEnd->convert(m_inputModel));
auto ops = function->get_ordered_ops();
auto it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ngraph::Node>& node) {
std::shared_ptr<ov::Model> model;
ASSERT_NO_THROW(model = m_frontEnd->convert(m_inputModel));
auto ops = model->get_ordered_ops();
auto it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(m_partShape.m_tensorName) != std::string::npos;
});
ASSERT_NE(it, ops.end());

13
src/frontends/tests/frontend/shared/src/set_element_type.cpp
View File

@@ -6,7 +6,6 @@
#include "utils.hpp"
using namespace ngraph;
using namespace ov::frontend;
std::string FrontEndElementTypeTest::getTestCaseName(const testing::TestParamInfo<SetTypeFEParam>& obj) {
@@ -38,14 +37,14 @@ TEST_P(FrontEndElementTypeTest, testSetElementType) {
ASSERT_NE(place, nullptr);
auto name = place->get_names()[0];
ASSERT_NO_THROW(m_inputModel->set_element_type(place, element::f16));
ASSERT_NO_THROW(m_inputModel->set_element_type(place, ov::element::f16));
std::shared_ptr<ngraph::Function> function;
function = m_frontEnd->convert(m_inputModel);
auto ops = function->get_ordered_ops();
auto it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ngraph::Node>& node) {
std::shared_ptr<ov::Model> model;
model = m_frontEnd->convert(m_inputModel);
auto ops = model->get_ordered_ops();
auto it = std::find_if(ops.begin(), ops.end(), [&](const std::shared_ptr<ov::Node>& node) {
return node->get_friendly_name().find(name) != std::string::npos;
});
ASSERT_NE(it, ops.end());
EXPECT_EQ((*it)->get_output_element_type(0), element::f16);
EXPECT_EQ((*it)->get_output_element_type(0), ov::element::f16);
}