diff --git a/src/core/tests/type_prop/ceiling.cpp b/src/core/tests/type_prop/ceiling.cpp index dd7ccbba943..b9425a9fb14 100644 --- a/src/core/tests/type_prop/ceiling.cpp +++ b/src/core/tests/type_prop/ceiling.cpp @@ -4,6 +4,6 @@ #include "unary_ops.hpp" -using Type = ::testing::Types; +using Type = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_ceiling, UnaryOperator, Type); diff --git a/src/core/tests/type_prop/clamp.cpp b/src/core/tests/type_prop/clamp.cpp index d21daf5532b..9e85571928f 100644 --- a/src/core/tests/type_prop/clamp.cpp +++ b/src/core/tests/type_prop/clamp.cpp @@ -2,74 +2,82 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/clamp.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "openvino/op/constant.hpp" +#include "openvino/op/gather.hpp" +#include "openvino/op/reshape.hpp" +#include "openvino/op/shape_of.hpp" using namespace std; -using namespace ngraph; TEST(type_prop, clamp_basic_f32) { - auto data = make_shared(element::f32, Shape{1, 32, 32}); - auto clamp = make_shared(data, 0.0, 2.1); + auto data = make_shared(ov::element::f32, ov::Shape{1, 32, 32}); + auto clamp = make_shared(data, 0.0, 2.1); - ASSERT_EQ(clamp->get_element_type(), element::f32); + ASSERT_EQ(clamp->get_element_type(), ov::element::f32); ASSERT_EQ(clamp->get_min(), 0.0); ASSERT_EQ(clamp->get_max(), 2.1); - ASSERT_EQ(clamp->get_output_shape(0), (Shape{1, 32, 32})); + ASSERT_EQ(clamp->get_output_shape(0), (ov::Shape{1, 32, 32})); } TEST(type_prop, clamp_basic_i32) { - auto data = make_shared(element::i32, Shape{1, 32, 32}); - auto clamp = make_shared(data, 0.0, 2.1); + auto data = make_shared(ov::element::i32, ov::Shape{1, 32, 32}); + auto clamp = make_shared(data, 0.0, 2.1); - ASSERT_EQ(clamp->get_element_type(), element::i32); + ASSERT_EQ(clamp->get_element_type(), ov::element::i32); ASSERT_EQ(clamp->get_min(), 0.0); ASSERT_EQ(clamp->get_max(), 2.1); - ASSERT_EQ(clamp->get_output_shape(0), (Shape{1, 32, 32})); + ASSERT_EQ(clamp->get_output_shape(0), (ov::Shape{1, 32, 32})); } TEST(type_prop, clamp_shape_static_rank) { - auto data = make_shared(element::f16, PartialShape{Dimension::dynamic(), Dimension::dynamic(), 32}); - auto clamp = make_shared(data, -2.1, 2.1); + auto data = + make_shared(ov::element::f16, + ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 32}); + auto clamp = make_shared(data, -2.1, 2.1); - ASSERT_EQ(clamp->get_element_type(), element::f16); + ASSERT_EQ(clamp->get_element_type(), ov::element::f16); ASSERT_EQ(clamp->get_min(), -2.1); ASSERT_EQ(clamp->get_max(), 2.1); - ASSERT_EQ(clamp->get_output_partial_shape(0), (PartialShape{Dimension::dynamic(), Dimension::dynamic(), 32})); + ASSERT_EQ(clamp->get_output_partial_shape(0), + (ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 32})); } TEST(type_prop, clamp_shape_dynamic) { - auto data = make_shared(element::u16, PartialShape::dynamic()); - auto clamp = make_shared(data, 1.5, 15.0); + auto data = make_shared(ov::element::u16, ov::PartialShape::dynamic()); + auto clamp = make_shared(data, 1.5, 15.0); - ASSERT_EQ(clamp->get_element_type(), element::u16); + ASSERT_EQ(clamp->get_element_type(), ov::element::u16); ASSERT_EQ(clamp->get_min(), 1.5); ASSERT_EQ(clamp->get_max(), 15.0); - ASSERT_EQ(clamp->get_output_partial_shape(0), (PartialShape::dynamic())); + ASSERT_EQ(clamp->get_output_partial_shape(0), (ov::PartialShape::dynamic())); } TEST(type_prop, clamp_evaluate_bounds) { - auto param = make_shared(element::f32, PartialShape{Dimension(1, 8), 2, 3}); - auto shape_of = make_shared(param); - auto gather = make_shared(shape_of, - op::Constant::create(element::i64, {3}, {2, 1, 0}), - op::Constant::create(element::i64, {}, {0})); - auto clamp = make_shared(gather, 0, 5); - auto r = make_shared(param, clamp, false); + auto param = make_shared(ov::element::f32, ov::PartialShape{ov::Dimension(1, 8), 2, 3}); + auto shape_of = make_shared(param); + auto gather = make_shared(shape_of, + ov::op::v0::Constant::create(ov::element::i64, {3}, {2, 1, 0}), + ov::op::v0::Constant::create(ov::element::i64, {}, {0})); + auto clamp = make_shared(gather, 0, 5); + auto r = make_shared(param, clamp, false); - ASSERT_EQ(r->get_element_type(), element::f32); - ASSERT_EQ(r->get_output_partial_shape(0), PartialShape({3, 2, Dimension(1, 5)})); + ASSERT_EQ(r->get_element_type(), ov::element::f32); + ASSERT_EQ(r->get_output_partial_shape(0), ov::PartialShape({3, 2, ov::Dimension(1, 5)})); } TEST(type_prop, clamp_invalid_element_type) { - auto data = make_shared(element::boolean, Shape{2, 2}); + auto data = make_shared(ov::element::boolean, ov::Shape{2, 2}); try { - auto clamp = make_shared(data, 0.5, 5.5); + auto clamp = make_shared(data, 0.5, 5.5); // Input element type is boolean FAIL() << "Invalid boolean element type for input not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Input element type must be numeric"); } catch (...) { FAIL() << "Numeric element type node validation check failed for unexpected reason"; @@ -77,23 +85,23 @@ TEST(type_prop, clamp_invalid_element_type) { } TEST(type_prop, clamp_equal_attributes) { - auto data = make_shared(element::f64, Shape{2, 2}); + auto data = make_shared(ov::element::f64, ov::Shape{2, 2}); - auto clamp = make_shared(data, 1.0, 1.0); - ASSERT_EQ(clamp->get_element_type(), element::f64); + auto clamp = make_shared(data, 1.0, 1.0); + ASSERT_EQ(clamp->get_element_type(), ov::element::f64); ASSERT_EQ(clamp->get_min(), 1.0); ASSERT_EQ(clamp->get_max(), 1.0); - ASSERT_EQ(clamp->get_output_shape(0), (Shape{2, 2})); + ASSERT_EQ(clamp->get_output_shape(0), (ov::Shape{2, 2})); } TEST(type_prop, clamp_invalid_attributes) { - auto data = make_shared(element::f64, Shape{2, 2}); + auto data = make_shared(ov::element::f64, ov::Shape{2, 2}); try { - auto clamp = make_shared(data, 2.0, 1.0); + auto clamp = make_shared(data, 2.0, 1.0); // Attribute 'max' not greater than 'min' FAIL() << "Attribute 'min' bigger than 'max' not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Attribute 'min' must be less or equal than 'max'"); } catch (...) { FAIL() << "'min' and 'max' attributes node validation check failed for unexpected reason"; diff --git a/src/core/tests/type_prop/concat.cpp b/src/core/tests/type_prop/concat.cpp index 5a33eacc2ac..22bdb3bf26a 100644 --- a/src/core/tests/type_prop/concat.cpp +++ b/src/core/tests/type_prop/concat.cpp @@ -2,39 +2,43 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/concat.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gmock/gmock.h" -#include "ngraph/ngraph.hpp" #include "openvino/core/dimension_tracker.hpp" +#include "openvino/op/broadcast.hpp" +#include "openvino/op/convert.hpp" +#include "openvino/op/shape_of.hpp" #include "openvino/pass/graph_rewrite.hpp" using namespace std; -using namespace ngraph; using namespace testing; TEST(type_prop, concat_deduce) { // Deduce type - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::f32, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 4}); - auto c = make_shared(NodeVector{param0, param1, param2}, 1); - EXPECT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{2, 12, 4})); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 4}); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); + EXPECT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 12, 4})); } TEST(type_prop, concat_deduce_wrong_rank) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::f32, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, - Shape{ - 2, - 2, - }); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, + ov::Shape{ + 2, + 2, + }); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Deduced type should disagree with specified type"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -44,14 +48,14 @@ TEST(type_prop, concat_deduce_wrong_rank) { } TEST(type_prop, concat_deduce_wrong_shape) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::f32, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 5}); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 5}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Deduced type should disagree with specified type"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -61,14 +65,14 @@ TEST(type_prop, concat_deduce_wrong_shape) { } TEST(type_prop, concat_deduce_axis_oob) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::f32, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 5}); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 5}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 3); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 3); // Should have thrown, so fail if it didn't FAIL() << "Deduced type should disagree with specified type"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Concatenation axis (3) is out of bounds")); } catch (...) { FAIL() << "Deduced type check failed for unexpected reason"; @@ -77,23 +81,23 @@ TEST(type_prop, concat_deduce_axis_oob) { TEST(type_prop, concat_deduce_axis_barely_in_bounds) { // Deduce type - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::f32, Shape{2, 3, 8}); - auto param2 = make_shared(element::f32, Shape{2, 3, 12}); - auto c = make_shared(NodeVector{param0, param1, param2}, 2); - EXPECT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{2, 3, 24})); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{2, 3, 8}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 3, 12}); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 2); + EXPECT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 3, 24})); } TEST(type_prop, concat_deduce_elem_type_mismatch) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::i32, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 4}); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::i32, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 4}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Deduced type should disagree with specified type"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types are inconsistent")); } catch (...) { FAIL() << "Deduced type check failed for unexpected reason"; @@ -101,24 +105,24 @@ TEST(type_prop, concat_deduce_elem_type_mismatch) { } TEST(type_prop, concat_partial_et_consistent) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::dynamic, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 4}); - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::dynamic, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 4}); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); - EXPECT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{2, 12, 4})); + EXPECT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 12, 4})); } TEST(type_prop, concat_partial_et_inconsistent) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::dynamic, Shape{2, 7, 4}); - auto param2 = make_shared(element::i32, Shape{2, 2, 4}); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::dynamic, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::i32, ov::Shape{2, 2, 4}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Inconsistent element types not detected (some dynamic)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument element types are inconsistent")); } catch (...) { FAIL() << "Deduced type check failed for unexpected reason"; @@ -126,15 +130,17 @@ TEST(type_prop, concat_partial_et_inconsistent) { } TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_rank_inconsistent) { - auto param0 = make_shared(element::f32, PartialShape{2, Dimension::dynamic(), 3}); - auto param1 = make_shared(element::f32, PartialShape::dynamic()); - auto param2 = make_shared(element::f32, PartialShape{2, 3, Dimension::dynamic(), 4}); + auto param0 = + make_shared(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3}); + auto param1 = make_shared(ov::element::f32, ov::PartialShape::dynamic()); + auto param2 = + make_shared(ov::element::f32, ov::PartialShape{2, 3, ov::Dimension::dynamic(), 4}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Inconsistent ranks not detected (some args rank-dynamic, some args rank-static " "dynamic)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -144,15 +150,17 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_rank } TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims_inconsistent) { - auto param0 = make_shared(element::f32, PartialShape{2, Dimension::dynamic(), 3}); - auto param1 = make_shared(element::f32, PartialShape::dynamic()); - auto param2 = make_shared(element::f32, PartialShape{3, 3, Dimension::dynamic()}); + auto param0 = + make_shared(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3}); + auto param1 = make_shared(ov::element::f32, ov::PartialShape::dynamic()); + auto param2 = + make_shared(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " "rank-static dynamic)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -162,16 +170,20 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims } TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims_intransitively_inconsistent) { - auto param0 = make_shared(element::f32, PartialShape{2, Dimension::dynamic(), 3}); - auto param1 = make_shared(element::f32, PartialShape::dynamic()); - auto param2 = make_shared(element::f32, PartialShape{Dimension::dynamic(), 3, Dimension::dynamic()}); - auto param3 = make_shared(element::f32, PartialShape{3, 3, Dimension::dynamic()}); + auto param0 = + make_shared(ov::element::f32, ov::PartialShape{2, ov::Dimension::dynamic(), 3}); + auto param1 = make_shared(ov::element::f32, ov::PartialShape::dynamic()); + auto param2 = + make_shared(ov::element::f32, + ov::PartialShape{ov::Dimension::dynamic(), 3, ov::Dimension::dynamic()}); + auto param3 = + make_shared(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()}); try { - auto c = make_shared(NodeVector{param0, param1, param2, param3}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2, param3}, 1); // Should have thrown, so fail if it didn't FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " "rank-static dynamic)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -181,16 +193,17 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_dynamic_dims } TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_with_concat_axis_static_dims_inconsistent) { - auto param0 = make_shared(element::f32, PartialShape{2, 2, 3}); - auto param1 = make_shared(element::f32, PartialShape::dynamic()); - auto param2 = make_shared(element::f32, PartialShape{3, 3, Dimension::dynamic()}); + auto param0 = make_shared(ov::element::f32, ov::PartialShape{2, 2, 3}); + auto param1 = make_shared(ov::element::f32, ov::PartialShape::dynamic()); + auto param2 = + make_shared(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " "rank-static dynamic)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -200,24 +213,28 @@ TEST(type_prop, concat_partial_some_rank_dynamic_others_rank_static_with_concat_ } TEST(type_prop, concat_partial_all_static_with_concat_axis_static_compatible_result_static) { - auto param0 = make_shared(element::f32, PartialShape{2, 2, 3}); - auto param1 = make_shared(element::f32, PartialShape{Dimension::dynamic(), 4, 3}); - auto param2 = make_shared(element::f32, PartialShape{2, 3, Dimension::dynamic()}); - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto param0 = make_shared(ov::element::f32, ov::PartialShape{2, 2, 3}); + auto param1 = + make_shared(ov::element::f32, ov::PartialShape{ov::Dimension::dynamic(), 4, 3}); + auto param2 = + make_shared(ov::element::f32, ov::PartialShape{2, 3, ov::Dimension::dynamic()}); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); - ASSERT_EQ(c->get_shape(), (Shape{2, 9, 3})); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 9, 3})); } TEST(type_prop, concat_partial_all_static_with_concat_axis_static_dims_incompatible) { - auto param0 = make_shared(element::f32, PartialShape{2, 2, 3}); - auto param1 = make_shared(element::f32, PartialShape{Dimension::dynamic(), 4, 3}); - auto param2 = make_shared(element::f32, PartialShape{3, 3, Dimension::dynamic()}); + auto param0 = make_shared(ov::element::f32, ov::PartialShape{2, 2, 3}); + auto param1 = + make_shared(ov::element::f32, ov::PartialShape{ov::Dimension::dynamic(), 4, 3}); + auto param2 = + make_shared(ov::element::f32, ov::PartialShape{3, 3, ov::Dimension::dynamic()}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, 1); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, 1); // Should have thrown, so fail if it didn't FAIL() << "Inconsistent dimensions not detected (some args rank-dynamic, some args " "rank-static dynamic)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Argument shapes are inconsistent; they must have the same rank, and must " "have equal dimension everywhere except on the concatenation axis")); @@ -227,26 +244,26 @@ TEST(type_prop, concat_partial_all_static_with_concat_axis_static_dims_incompati } TEST(type_prop, concat_partial_negative_axis_correct) { - auto param0 = make_shared(element::f32, Shape{3, 2, 4}); - auto param1 = make_shared(element::f32, Shape{7, 2, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 4}); + auto param0 = make_shared(ov::element::f32, ov::Shape{3, 2, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{7, 2, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 4}); - auto c = make_shared(NodeVector{param0, param1, param2}, -3); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, -3); - EXPECT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{12, 2, 4})); + EXPECT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{12, 2, 4})); } TEST(type_prop, concat_partial_negative_axis_incorrect) { - auto param0 = make_shared(element::f32, Shape{2, 3, 4}); - auto param1 = make_shared(element::f32, Shape{2, 7, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 4}); + auto param0 = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{2, 7, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 4}); try { - auto c = make_shared(NodeVector{param0, param1, param2}, -4); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, -4); // Should have thrown, so fail if it didn't FAIL() << "Incorrect negative axis value not detected (out of bounds)"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Concatenation axis (-1) is out of bounds")); } catch (...) { FAIL() << "Deduced type check failed for unexpected reason"; @@ -255,26 +272,26 @@ TEST(type_prop, concat_partial_negative_axis_incorrect) { /** \brief Test uses evaluate lower/upper and label of concat op. */ TEST(type_prop, concat_dynamic_value_and_label_propagation) { - Dimension marked_0 = Dimension(3); + ov::Dimension marked_0 = ov::Dimension(3); ov::DimensionTracker::set_label(marked_0, 10); - PartialShape target_0 = PartialShape{marked_0, 4}; + ov::PartialShape target_0 = ov::PartialShape{marked_0, 4}; - Dimension marked_1 = Dimension(5); + ov::Dimension marked_1 = ov::Dimension(5); ov::DimensionTracker::set_label(marked_1, 15); - PartialShape target_1 = PartialShape{4, marked_1, 9}; + ov::PartialShape target_1 = ov::PartialShape{4, marked_1, 9}; - auto param = make_shared(element::f32, Shape{1}); - auto param_0 = make_shared(element::f32, target_0); - auto shape_0 = make_shared(param_0); + auto param = make_shared(ov::element::f32, ov::Shape{1}); + auto param_0 = make_shared(ov::element::f32, target_0); + auto shape_0 = make_shared(param_0); - auto param_1 = make_shared(element::f32, target_1); - auto shape_1 = make_shared(param_1); + auto param_1 = make_shared(ov::element::f32, target_1); + auto shape_1 = make_shared(param_1); - auto five = op::Constant::create(element::i64, {1}, {5}); - auto target_shape = std::make_shared(OutputVector{shape_0, five, shape_1}, 0); + auto five = ov::op::v0::Constant::create(ov::element::i64, {1}, {5}); + auto target_shape = std::make_shared(ov::OutputVector{shape_0, five, shape_1}, 0); - auto bc = make_shared(param, target_shape); - EXPECT_EQ(bc->get_shape(), (Shape{3, 4, 5, 4, 5, 9})); + auto bc = make_shared(param, target_shape); + EXPECT_EQ(bc->get_shape(), (ov::Shape{3, 4, 5, 4, 5, 9})); const auto& output_shape = bc->get_output_partial_shape(0); const auto labels = get_shape_labels(output_shape); @@ -283,30 +300,30 @@ TEST(type_prop, concat_dynamic_value_and_label_propagation) { /** \brief Test uses evaluate lower/upper and label of concat op. */ TEST(type_prop, concat_dynamic_value_and_label_propagation_1) { - Dimension marked_0 = Dimension(3); + ov::Dimension marked_0 = ov::Dimension(3); ov::DimensionTracker::set_label(marked_0, 1000); - PartialShape target_0 = PartialShape{marked_0, 4}; + ov::PartialShape target_0 = ov::PartialShape{marked_0, 4}; - Dimension marked_1 = Dimension(5); + ov::Dimension marked_1 = ov::Dimension(5); ov::DimensionTracker::set_label(marked_1, 1500); - PartialShape target_1 = PartialShape{4, marked_1, 9}; + ov::PartialShape target_1 = ov::PartialShape{4, marked_1, 9}; - auto param = make_shared(element::f32, Shape{1}); - auto param_0 = make_shared(element::f32, target_0); - auto shape_0 = make_shared(param_0); - auto convert_0 = make_shared(shape_0, element::i8); + auto param = make_shared(ov::element::f32, ov::Shape{1}); + auto param_0 = make_shared(ov::element::f32, target_0); + auto shape_0 = make_shared(param_0); + auto convert_0 = make_shared(shape_0, ov::element::i8); - auto param_1 = make_shared(element::f32, target_1); - auto shape_1 = make_shared(param_1); - auto convert_1 = make_shared(shape_1, element::i8); + auto param_1 = make_shared(ov::element::f32, target_1); + auto shape_1 = make_shared(param_1); + auto convert_1 = make_shared(shape_1, ov::element::i8); - auto five = op::Constant::create(element::i8, {1}, {5}); - auto target_shape = std::make_shared(OutputVector{convert_0, five, convert_1}, 0); + auto five = ov::op::v0::Constant::create(ov::element::i8, {1}, {5}); + auto target_shape = std::make_shared(ov::OutputVector{convert_0, five, convert_1}, 0); - auto convert = make_shared(target_shape, element::i64); + auto convert = std::make_shared(target_shape, ov::element::i64); - auto bc = make_shared(param, target_shape); - EXPECT_EQ(bc->get_shape(), (Shape{3, 4, 5, 4, 5, 9})); + auto bc = make_shared(param, target_shape); + EXPECT_EQ(bc->get_shape(), (ov::Shape{3, 4, 5, 4, 5, 9})); const auto& output_shape = bc->get_output_partial_shape(0); const auto labels = get_shape_labels(output_shape); @@ -314,20 +331,20 @@ TEST(type_prop, concat_dynamic_value_and_label_propagation_1) { } TEST(type_prop, concat_interval_dimensions) { - auto param0 = make_shared(element::f32, Shape{3, 2, 4}); - auto param1 = make_shared(element::f32, Shape{7, 2, 4}); - auto param2 = make_shared(element::f32, Shape{2, 2, 4}); + auto param0 = make_shared(ov::element::f32, ov::Shape{3, 2, 4}); + auto param1 = make_shared(ov::element::f32, ov::Shape{7, 2, 4}); + auto param2 = make_shared(ov::element::f32, ov::Shape{2, 2, 4}); - auto c = make_shared(NodeVector{param0, param1, param2}, -3); + auto c = make_shared(ov::NodeVector{param0, param1, param2}, -3); - EXPECT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{12, 2, 4})); + EXPECT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{12, 2, 4})); } -using PartialShapeVector = std::vector; -using ConcatTestParams = std::tuple; +using ConcatTestParams = std::tuple>; class ConcatTest : public TestWithParam { @@ -340,73 +357,75 @@ protected: std::forward_as_tuple(input_shapes, std::tie(axis, exp_shape)) = GetParam(); for (const auto& shape : input_shapes) { - params.make(element::f32, shape); + params.make(ov::element::f32, shape); } - c = make_shared(params.get(), axis); + c = make_shared(params.get(), axis); } - PartialShape exp_shape; - std::shared_ptr c; + ov::PartialShape exp_shape; + std::shared_ptr c; }; -const auto shapes_with_interval_dim = Values(PartialShapeVector{(PartialShape::dynamic()), - {2, Dimension(2, 5), 3, 1}, - {2, 4, 3, Dimension(1, 4)}, +const auto shapes_with_interval_dim = Values(PartialShapeVector{(ov::PartialShape::dynamic()), + {2, ov::Dimension(2, 5), 3, 1}, + {2, 4, 3, ov::Dimension(1, 4)}, {2, 4, 3, 1}}); -INSTANTIATE_TEST_SUITE_P(type_prop_interval_dim_mixed_ranks, - ConcatTest, - Combine(shapes_with_interval_dim, - Values(std::make_tuple(1, PartialShape({2, Dimension(10, -1), 3, 1})), // axis 1 - std::make_tuple(-1, PartialShape({2, 4, 3, Dimension(3, -1)})), // axis 2 - std::make_tuple(2, PartialShape({2, 4, Dimension(9, -1), 1})) // axis 3 - )), - PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P( + type_prop_interval_dim_mixed_ranks, + ConcatTest, + Combine(shapes_with_interval_dim, + Values(std::make_tuple(1, ov::PartialShape({2, ov::Dimension(10, -1), 3, 1})), // axis 1 + std::make_tuple(-1, ov::PartialShape({2, 4, 3, ov::Dimension(3, -1)})), // axis 2 + std::make_tuple(2, ov::PartialShape({2, 4, ov::Dimension(9, -1), 1})) // axis 3 + )), + PrintToStringParamName()); -const auto shapes_all_dynamic_ranks = Values(PartialShapeVector{(PartialShape::dynamic()), - (PartialShape::dynamic()), - (PartialShape::dynamic()), - (PartialShape::dynamic())}); +const auto shapes_all_dynamic_ranks = Values(PartialShapeVector{(ov::PartialShape::dynamic()), + (ov::PartialShape::dynamic()), + (ov::PartialShape::dynamic()), + (ov::PartialShape::dynamic())}); INSTANTIATE_TEST_SUITE_P(type_prop_dynamic_ranks_against_axis_range, ConcatTest, Combine(shapes_all_dynamic_ranks, - Combine(Range(-4, 4), Values(PartialShape::dynamic()))), + Combine(Range(-4, 4), Values(ov::PartialShape::dynamic()))), PrintToStringParamName()); const auto shapes_static_dynamic_ranks = - Values(PartialShapeVector{PartialShape({4, 2, Dimension::dynamic(), 3}), - PartialShape::dynamic(), - PartialShape({4, 2, Dimension::dynamic(), Dimension::dynamic()})}); + Values(PartialShapeVector{ov::PartialShape({4, 2, ov::Dimension::dynamic(), 3}), + ov::PartialShape::dynamic(), + ov::PartialShape({4, 2, ov::Dimension::dynamic(), ov::Dimension::dynamic()})}); -INSTANTIATE_TEST_SUITE_P(type_prop_mixed_ranks_and_dims, - ConcatTest, - Combine(shapes_static_dynamic_ranks, - Values( - // concat all dynamic dims - std::make_tuple(2, PartialShape({4, 2, Dimension::dynamic(), 3})), - // concat dynamic and interval dim - std::make_tuple(1, PartialShape({4, Dimension(4, -1), Dimension::dynamic(), 3})))), - PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P( + type_prop_mixed_ranks_and_dims, + ConcatTest, + Combine(shapes_static_dynamic_ranks, + Values( + // concat all dynamic dims + std::make_tuple(2, ov::PartialShape({4, 2, ov::Dimension::dynamic(), 3})), + // concat dynamic and interval dim + std::make_tuple(1, ov::PartialShape({4, ov::Dimension(4, -1), ov::Dimension::dynamic(), 3})))), + PrintToStringParamName()); -INSTANTIATE_TEST_SUITE_P(type_prop_1d_shapes, - ConcatTest, - Values( - // concat all dynamic dims - std::make_tuple(PartialShapeVector{{-1}, {-1}, {-1}}, - std::make_tuple(0, PartialShape({-1}))), - // concat dynamic and not matching static dims - std::make_tuple(PartialShapeVector{{3}, PartialShape::dynamic(), {2}}, - std::make_tuple(0, PartialShape({Dimension(5, -1)}))), - // concat all static dim - std::make_tuple(PartialShapeVector{{3}, {3}, {3}}, std::make_tuple(0, PartialShape({9}))), - // concat dynamic and interval dim - std::make_tuple(PartialShapeVector{{3}, {Dimension::dynamic()}, {Dimension(3, 4)}}, - std::make_tuple(0, PartialShape({Dimension(6, -1)})))), - PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P( + type_prop_1d_shapes, + ConcatTest, + Values( + // concat all dynamic dims + std::make_tuple(PartialShapeVector{{-1}, {-1}, {-1}}, std::make_tuple(0, ov::PartialShape({-1}))), + // concat dynamic and not matching static dims + std::make_tuple(PartialShapeVector{{3}, ov::PartialShape::dynamic(), {2}}, + std::make_tuple(0, ov::PartialShape({ov::Dimension(5, -1)}))), + // concat all static dim + std::make_tuple(PartialShapeVector{{3}, {3}, {3}}, std::make_tuple(0, ov::PartialShape({9}))), + // concat dynamic and interval dim + std::make_tuple(PartialShapeVector{{3}, {ov::Dimension::dynamic()}, {ov::Dimension(3, 4)}}, + std::make_tuple(0, ov::PartialShape({ov::Dimension(6, -1)})))), + PrintToStringParamName()); -/** \brief Shape propagation no exception. */ +/** \brief ov::Shape propagation no exception. */ TEST_P(ConcatTest, partial_shape_propagation) { ASSERT_EQ(c->get_default_output().get_partial_shape(), exp_shape); } diff --git a/src/core/tests/type_prop/constant.cpp b/src/core/tests/type_prop/constant.cpp index 3f66749581b..2a70b44444d 100644 --- a/src/core/tests/type_prop/constant.cpp +++ b/src/core/tests/type_prop/constant.cpp @@ -2,43 +2,44 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/constant.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; TEST(type_prop, scalar_constant_deduce_float32) { - auto c = op::Constant::create(element::f32, Shape{}, {208}); - ASSERT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{})); + auto c = ov::op::v0::Constant::create(ov::element::f32, ov::Shape{}, {208}); + ASSERT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{})); } TEST(type_prop, scalar_constant_deduce_bool) { - auto c = op::Constant::create(element::boolean, Shape{}, {1}); - ASSERT_EQ(c->get_element_type(), element::boolean); - ASSERT_EQ(c->get_shape(), (Shape{})); + auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{}, {1}); + ASSERT_EQ(c->get_element_type(), ov::element::boolean); + ASSERT_EQ(c->get_shape(), (ov::Shape{})); } TEST(type_prop, tensor_constant_deduce_float32) { - auto c = op::Constant::create(element::f32, Shape{2, 2}, {208, 208, 208, 208}); - ASSERT_EQ(c->get_element_type(), element::f32); - ASSERT_EQ(c->get_shape(), (Shape{2, 2})); + auto c = ov::op::v0::Constant::create(ov::element::f32, ov::Shape{2, 2}, {208, 208, 208, 208}); + ASSERT_EQ(c->get_element_type(), ov::element::f32); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 2})); } TEST(type_prop, tensor_constant_deduce_bool) { - auto c = op::Constant::create(element::boolean, Shape{2, 2}, {1, 1, 1, 1}); - ASSERT_EQ(c->get_element_type(), element::boolean); - ASSERT_EQ(c->get_shape(), (Shape{2, 2})); + auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{2, 2}, {1, 1, 1, 1}); + ASSERT_EQ(c->get_element_type(), ov::element::boolean); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 2})); } TEST(type_prop, tensor_constant_bad_count) { try { - auto c = op::Constant::create(element::boolean, Shape{2, 2}, {1, 1, 1}); + auto c = ov::op::v0::Constant::create(ov::element::boolean, ov::Shape{2, 2}, {1, 1, 1}); // Should have thrown, so fail if it didn't FAIL() << "Incorrect number of literals not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Did not get the expected number of literals for a " "constant of shape [2,2] (got 3, expected 1 or 4)")); @@ -48,7 +49,7 @@ TEST(type_prop, tensor_constant_bad_count) { } TEST(type_prop, constant_zero_elements_one_string) { - auto c = make_shared(element::i64, Shape{2, 0, 2, 2}, std::vector{"42"}); - ASSERT_EQ(c->get_element_type(), element::i64); - ASSERT_EQ(c->get_shape(), (Shape{2, 0, 2, 2})); + auto c = make_shared(ov::element::i64, ov::Shape{2, 0, 2, 2}, std::vector{"42"}); + ASSERT_EQ(c->get_element_type(), ov::element::i64); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 0, 2, 2})); } diff --git a/src/core/tests/type_prop/convert.cpp b/src/core/tests/type_prop/convert.cpp index d3c9b3df61b..e48257b84cc 100644 --- a/src/core/tests/type_prop/convert.cpp +++ b/src/core/tests/type_prop/convert.cpp @@ -2,36 +2,39 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/convert.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" #include "openvino/core/dimension_tracker.hpp" +#include "openvino/op/broadcast.hpp" +#include "openvino/op/shape_of.hpp" using namespace std; -using namespace ngraph; TEST(type_prop, convert_deduce) { // Deduce type - auto param = make_shared(element::f32, Shape{2, 3, 4}); - auto c = make_shared(param, element::i32); - ASSERT_EQ(c->get_element_type(), element::i32); - ASSERT_EQ(c->get_shape(), (Shape{2, 3, 4})); + auto param = make_shared(ov::element::f32, ov::Shape{2, 3, 4}); + auto c = make_shared(param, ov::element::i32); + ASSERT_EQ(c->get_element_type(), ov::element::i32); + ASSERT_EQ(c->get_shape(), (ov::Shape{2, 3, 4})); } TEST(type_prop, convert_dynamic_value_and_label_propagation) { - Dimension marked_0 = Dimension(3); + ov::Dimension marked_0 = ov::Dimension(3); ov::DimensionTracker::set_label(marked_0, 500); - PartialShape target_0 = PartialShape{marked_0, 4}; + ov::PartialShape target_0 = ov::PartialShape{marked_0, 4}; - auto param = make_shared(element::f32, Shape{1}); - auto param_0 = make_shared(element::f32, target_0); - auto shape_0 = make_shared(param_0); + auto param = make_shared(ov::element::f32, ov::Shape{1}); + auto param_0 = make_shared(ov::element::f32, target_0); + auto shape_0 = make_shared(param_0); - auto convert_0 = make_shared(shape_0, element::i8); - auto convert_1 = make_shared(convert_0, element::i64); + auto convert_0 = make_shared(shape_0, ov::element::i8); + auto convert_1 = make_shared(convert_0, ov::element::i64); - auto bc = make_shared(param, convert_1); - ASSERT_EQ(bc->get_shape(), (Shape{3, 4})); + auto bc = make_shared(param, convert_1); + ASSERT_EQ(bc->get_shape(), (ov::Shape{3, 4})); const auto& output_shape = bc->get_output_partial_shape(0); ASSERT_EQ(ov::DimensionTracker::get_label(output_shape[0]), 500); diff --git a/src/core/tests/type_prop/convert_color_i420_base.hpp b/src/core/tests/type_prop/convert_color_i420_base.hpp index 5dfad93cf97..0ec9f7c50e0 100644 --- a/src/core/tests/type_prop/convert_color_i420_base.hpp +++ b/src/core/tests/type_prop/convert_color_i420_base.hpp @@ -2,11 +2,12 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" #include "openvino/op/op.hpp" #include "openvino/opsets/opset8.hpp" diff --git a/src/core/tests/type_prop/convert_color_nv12_base.hpp b/src/core/tests/type_prop/convert_color_nv12_base.hpp index 64eee26f13f..c4b6aa42079 100644 --- a/src/core/tests/type_prop/convert_color_nv12_base.hpp +++ b/src/core/tests/type_prop/convert_color_nv12_base.hpp @@ -2,10 +2,11 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" #include "openvino/op/op.hpp" #include "openvino/opsets/opset8.hpp" diff --git a/src/core/tests/type_prop/convolution.cpp b/src/core/tests/type_prop/convolution.cpp index 4a589f7f896..2ee5280b5cf 100644 --- a/src/core/tests/type_prop/convolution.cpp +++ b/src/core/tests/type_prop/convolution.cpp @@ -2,284 +2,291 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" #include "convolution_shape_inference.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; using namespace testing; TEST(type_prop, convolution_v1_partial_rank) { - PartialShape data_batch_shape{PartialShape::dynamic()}; - PartialShape filters_shape{PartialShape::dynamic()}; - Strides window_movement_strides{1, 1}; - Strides window_dilation_strides{1, 1}; - CoordinateDiff padding_below{0, 0}; - CoordinateDiff padding_above{0, 0}; + ov::PartialShape data_batch_shape{ov::PartialShape::dynamic()}; + ov::PartialShape filters_shape{ov::PartialShape::dynamic()}; + ov::Strides window_movement_strides{1, 1}; + ov::Strides window_dilation_strides{1, 1}; + ov::CoordinateDiff padding_below{0, 0}; + ov::CoordinateDiff padding_above{0, 0}; - auto param0 = make_shared(element::f32, data_batch_shape); - auto param1 = make_shared(element::f32, filters_shape); + auto param0 = make_shared(ov::element::f32, data_batch_shape); + auto param1 = make_shared(ov::element::f32, filters_shape); - auto conv = make_shared(param0, - param1, - window_movement_strides, - padding_below, - padding_above, - window_dilation_strides); + auto conv = make_shared(param0, + param1, + window_movement_strides, + padding_below, + padding_above, + window_dilation_strides); - EXPECT_EQ(conv->get_output_partial_shape(0), PartialShape({-1, -1, {1, -1}, {1, -1}})); + EXPECT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({-1, -1, {1, -1}, {1, -1}})); } TEST(type_prop, convolution_v1_partial_auto_padding_same) { - PartialShape data_batch_shape{1, 1, 5, 5}; - PartialShape filters_shape{1, 1, 3, 3}; + ov::PartialShape data_batch_shape{1, 1, 5, 5}; + ov::PartialShape filters_shape{1, 1, 3, 3}; set_shape_labels(data_batch_shape, 10); set_shape_labels(filters_shape, 20); - Strides strides{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_LOWER; + ov::Strides strides{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_LOWER; - auto data_batch = make_shared(element::f32, data_batch_shape); - auto filters = make_shared(element::f32, filters_shape); + auto data_batch = make_shared(ov::element::f32, data_batch_shape); + auto filters = make_shared(ov::element::f32, filters_shape); auto conv = - make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); + make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); - EXPECT_EQ(conv->get_output_partial_shape(0), (PartialShape{1, 1, 5, 5})); + EXPECT_EQ(conv->get_output_partial_shape(0), (ov::PartialShape{1, 1, 5, 5})); EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label)); - EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{1, 1})); - EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1})); + EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{1, 1})); + EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1})); } TEST(type_prop, convolution_v1_partial_auto_padding_same_nc_dims_dynamic_same_lower) { - PartialShape data_batch_shape{Dimension::dynamic(), Dimension::dynamic(), 5, 5}; - PartialShape filters_shape{1, 1, 3, 3}; + ov::PartialShape data_batch_shape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5}; + ov::PartialShape filters_shape{1, 1, 3, 3}; set_shape_labels(data_batch_shape, 10); set_shape_labels(filters_shape, 20); - Strides strides{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_LOWER; + ov::Strides strides{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_LOWER; - auto data_batch = make_shared(element::f32, data_batch_shape); - auto filters = make_shared(element::f32, filters_shape); + auto data_batch = make_shared(ov::element::f32, data_batch_shape); + auto filters = make_shared(ov::element::f32, filters_shape); auto conv = - make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); + make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); - EXPECT_EQ(conv->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), 1, 5, 5})); + EXPECT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({ov::Dimension::dynamic(), 1, 5, 5})); EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label)); - EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{1, 1})); - EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1})); + EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{1, 1})); + EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1})); } TEST(type_prop, convolution_v1_partial_auto_padding_same_nc_dims_dynamic_same_upper) { - const PartialShape data_batch_shape{Dimension::dynamic(), Dimension::dynamic(), 5, 5}; - const PartialShape filters_shape{1, 1, 2, 2}; - Strides strides{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_UPPER; + const ov::PartialShape data_batch_shape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5}; + const ov::PartialShape filters_shape{1, 1, 2, 2}; + ov::Strides strides{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_UPPER; - auto data_batch = make_shared(element::f32, data_batch_shape); - auto filters = make_shared(element::f32, filters_shape); + auto data_batch = make_shared(ov::element::f32, data_batch_shape); + auto filters = make_shared(ov::element::f32, filters_shape); auto conv = - make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); + make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); - ASSERT_EQ(conv->get_output_partial_shape(0), PartialShape({Dimension::dynamic(), 1, 5, 5})); - ASSERT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); - ASSERT_EQ(conv->get_pads_end(), (CoordinateDiff{1, 1})); + ASSERT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({ov::Dimension::dynamic(), 1, 5, 5})); + ASSERT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0})); + ASSERT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{1, 1})); } TEST(type_prop, convolution_v1_partial_auto_padding_same_spatial_dims_dynamic) { - PartialShape data_batch_shape{1, 1, Dimension::dynamic(), {3, 5}}; - PartialShape filters_shape{1, 1, 3, 3}; + ov::PartialShape data_batch_shape{1, 1, ov::Dimension::dynamic(), {3, 5}}; + ov::PartialShape filters_shape{1, 1, 3, 3}; set_shape_labels(data_batch_shape, 10); set_shape_labels(filters_shape, 20); - Strides strides{2, 2}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_LOWER; + ov::Strides strides{2, 2}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_LOWER; - auto data_batch = make_shared(element::f32, data_batch_shape); - auto filters = make_shared(element::f32, filters_shape); + auto data_batch = make_shared(ov::element::f32, data_batch_shape); + auto filters = make_shared(ov::element::f32, filters_shape); auto conv = - make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); + make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); - EXPECT_EQ(conv->get_output_partial_shape(0), PartialShape({1, 1, Dimension::dynamic(), {2, 3}})); + EXPECT_EQ(conv->get_output_partial_shape(0), ov::PartialShape({1, 1, ov::Dimension::dynamic(), {2, 3}})); EXPECT_THAT(get_shape_labels(conv->get_output_partial_shape(0)), ElementsAre(10, 20, ov::no_label, ov::no_label)); - EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); - EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0})); + EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0})); + EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0})); } TEST(type_prop, convolution_v1_partial_data_shape_dynamic) { - const PartialShape data_batch_shape{PartialShape::dynamic()}; - const PartialShape filters_shape{1, 1, 3, 3}; - Strides strides{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_LOWER; + const ov::PartialShape data_batch_shape{ov::PartialShape::dynamic()}; + const ov::PartialShape filters_shape{1, 1, 3, 3}; + ov::Strides strides{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_LOWER; - auto data_batch = make_shared(element::f32, data_batch_shape); - auto filters = make_shared(element::f32, filters_shape); + auto data_batch = make_shared(ov::element::f32, data_batch_shape); + auto filters = make_shared(ov::element::f32, filters_shape); auto conv = - make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); + make_shared(data_batch, filters, strides, pads_begin, pads_end, dilations, auto_pad); EXPECT_EQ(conv->get_output_partial_shape(0), - PartialShape({Dimension::dynamic(), 1, Dimension::dynamic(), Dimension::dynamic()})); - EXPECT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); - EXPECT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0})); + ov::PartialShape({ov::Dimension::dynamic(), 1, ov::Dimension::dynamic(), ov::Dimension::dynamic()})); + EXPECT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0})); + EXPECT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0})); } -class TypePropConvolutionV1Test : public TypePropOpTest { +class TypePropConvolutionV1Test : public TypePropOpTest { protected: - CoordinateDiff empty_pad{}; + ov::CoordinateDiff empty_pad{}; }; TEST_F(TypePropConvolutionV1Test, default_ctor) { - const auto data = make_shared(element::f32, PartialShape{1, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); + const auto data = make_shared(ov::element::f32, ov::PartialShape{1, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); const auto op = make_op(); - op->set_arguments(OutputVector{data, filters}); + op->set_arguments(ov::OutputVector{data, filters}); op->set_strides({1, 3}); op->set_dilations({1, 2}); op->set_pads_begin({2, 2}); op->set_pads_end({2, 2}); - op->set_auto_pad(op::PadType::EXPLICIT); + op->set_auto_pad(ov::op::PadType::EXPLICIT); op->validate_and_infer_types(); EXPECT_EQ(op->get_input_size(), 2); EXPECT_EQ(op->get_output_size(), 1); - EXPECT_EQ(op->get_strides(), Strides({1, 3})); - EXPECT_EQ(op->get_dilations(), Strides({1, 2})); - EXPECT_EQ(op->get_pads_begin(), CoordinateDiff({2, 2})); - EXPECT_EQ(op->get_pads_end(), CoordinateDiff({2, 2})); - EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({1, 2, 6, 1})); + EXPECT_EQ(op->get_strides(), ov::Strides({1, 3})); + EXPECT_EQ(op->get_dilations(), ov::Strides({1, 2})); + EXPECT_EQ(op->get_pads_begin(), ov::CoordinateDiff({2, 2})); + EXPECT_EQ(op->get_pads_end(), ov::CoordinateDiff({2, 2})); + EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({1, 2, 6, 1})); } TEST_F(TypePropConvolutionV1Test, data_dynamic_rank_filters_2d) { - const auto data = make_shared(element::f32, PartialShape::dynamic()); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape::dynamic()); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1, 1}; - auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_UPPER); + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_UPPER); EXPECT_THAT(op->get_pads_begin(), ElementsAre(0, 0)); EXPECT_THAT(op->get_pads_end(), ElementsAre(0, 0)); - EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({-1, 2, -1, -1})); + EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({-1, 2, -1, -1})); } TEST_F(TypePropConvolutionV1Test, data_rank_to_low) { - const auto data = make_shared(element::f32, PartialShape{2, 3}); - const auto filters = make_shared(element::f32, PartialShape{2, 3}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Expected a 3D, 4D or 5D tensor for the input")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Expected a 3D, 4D or 5D tensor for the input")); } TEST_F(TypePropConvolutionV1Test, data_rank_to_high) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4, 4, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4, 4, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Expected a 3D, 4D or 5D tensor for the input")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Expected a 3D, 4D or 5D tensor for the input")); } TEST_F(TypePropConvolutionV1Test, data_and_filters_rank_not_compatible) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Data batch and filters rank do not match")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Data batch and filters rank do not match")); } TEST_F(TypePropConvolutionV1Test, data_and_filters_channel_number_not_compatible) { - const auto data = make_shared(element::f32, PartialShape{2, 2, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 2, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Data batch channel count (2) does not match filter input channel count (3)")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Data batch channel count (2) does not match filter input channel count (3)")); } TEST_F(TypePropConvolutionV1Test, strides_not_defined_only_for_spatial_dims) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 1, 1}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 1, 1}; + const auto dilations = ov::Strides{1, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Strides should be defined for all and only spatial dimensions.")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Strides should be defined for all and only spatial dimensions.")); } TEST_F(TypePropConvolutionV1Test, dilations_not_defined_only_for_spatial_dims) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Dilations should be defined for all and only spatial dimensions.")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Dilations should be defined for all and only spatial dimensions.")); } TEST_F(TypePropConvolutionV1Test, strides_has_zeros) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 0}; - const auto dilations = Strides{1, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 0}; + const auto dilations = ov::Strides{1, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Strides has zero dimension")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Strides has zero dimension")); } TEST_F(TypePropConvolutionV1Test, dilations_has_zeros) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{0, 1}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{0, 1}; - OV_EXPECT_THROW(auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, op::PadType::SAME_LOWER), - NodeValidationFailure, - HasSubstr("Filter dilations has zero dimension")); + OV_EXPECT_THROW( + auto op = make_op(data, filters, strides, empty_pad, empty_pad, dilations, ov::op::PadType::SAME_LOWER), + ov::NodeValidationFailure, + HasSubstr("Filter dilations has zero dimension")); } TEST_F(TypePropConvolutionV1Test, pads_not_defined_for_spatial_only) { - const auto data = make_shared(element::f32, PartialShape{2, 3, 5, 5}); - const auto filters = make_shared(element::f32, PartialShape{2, 3, 4, 4}); - const auto strides = Strides{1, 1}; - const auto dilations = Strides{1, 1}; - const auto pads_begin = CoordinateDiff{2, 2}; - const auto pads_end = CoordinateDiff{2, 2, 2}; + const auto data = make_shared(ov::element::f32, ov::PartialShape{2, 3, 5, 5}); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{2, 3, 4, 4}); + const auto strides = ov::Strides{1, 1}; + const auto dilations = ov::Strides{1, 1}; + const auto pads_begin = ov::CoordinateDiff{2, 2}; + const auto pads_end = ov::CoordinateDiff{2, 2, 2}; OV_EXPECT_THROW(auto op = make_op(data, filters, strides, pads_begin, pads_end, dilations), - NodeValidationFailure, + ov::NodeValidationFailure, HasSubstr("Pads begin and end should be defined for all and only spatial dimensions.")); } diff --git a/src/core/tests/type_prop/convolution_backprop_data.cpp b/src/core/tests/type_prop/convolution_backprop_data.cpp index 5828ae13960..bce3b5ffde8 100644 --- a/src/core/tests/type_prop/convolution_backprop_data.cpp +++ b/src/core/tests/type_prop/convolution_backprop_data.cpp @@ -1,499 +1,508 @@ -//***************************************************************************** // Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -//***************************************************************************** + +#include #include "common_test_utils/type_prop.hpp" #include "convolution_shape_inference.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; using namespace testing; // ---------------------------- v1 ---------------------------- TEST(type_prop, convolution_backprop_data_partial_auto_padding_upper) { - const Shape shape1{1, 512, 1, 37}; - const Shape shape2{512, 256, 1, 1}; - const Shape shape3{2}; - Strides strides{1, 2}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_UPPER; + const ov::Shape shape1{1, 512, 1, 37}; + const ov::Shape shape2{512, 256, 1, 1}; + const ov::Shape shape3{2}; + ov::Strides strides{1, 2}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_UPPER; - auto in1 = make_shared(element::f32, shape1); - auto in2 = make_shared(element::f32, shape2); + auto in1 = make_shared(ov::element::f32, shape1); + auto in2 = make_shared(ov::element::f32, shape2); std::vector data = {1, 74}; - element::Type type = element::i64; - auto in3 = make_shared(type, shape3, data); + ov::element::Type type = ov::element::i64; + auto in3 = make_shared(type, shape3, data); - auto conv = - make_shared(in1, in2, in3, strides, pads_begin, pads_end, dilations, auto_pad); + auto conv = make_shared(in1, + in2, + in3, + strides, + pads_begin, + pads_end, + dilations, + auto_pad); conv->validate_and_infer_types(); - ASSERT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); - ASSERT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0})); + ASSERT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0})); + ASSERT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0})); } TEST(type_prop, convolution_backprop_data_partial_auto_padding_lower) { - const Shape shape1{1, 512, 1, 37}; - const Shape shape2{512, 256, 1, 1}; - const Shape shape3{2}; - Strides strides{1, 2}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - Strides dilations{1, 1}; - const auto auto_pad = op::PadType::SAME_LOWER; + const ov::Shape shape1{1, 512, 1, 37}; + const ov::Shape shape2{512, 256, 1, 1}; + const ov::Shape shape3{2}; + ov::Strides strides{1, 2}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::Strides dilations{1, 1}; + const auto auto_pad = ov::op::PadType::SAME_LOWER; - auto in1 = make_shared(element::f32, shape1); - auto in2 = make_shared(element::f32, shape2); + auto in1 = make_shared(ov::element::f32, shape1); + auto in2 = make_shared(ov::element::f32, shape2); std::vector data = {1, 74}; - element::Type type = element::i64; - auto in3 = make_shared(type, shape3, data); + ov::element::Type type = ov::element::i64; + auto in3 = make_shared(type, shape3, data); - auto conv = - make_shared(in1, in2, in3, strides, pads_begin, pads_end, dilations, auto_pad); + auto conv = make_shared(in1, + in2, + in3, + strides, + pads_begin, + pads_end, + dilations, + auto_pad); conv->validate_and_infer_types(); - ASSERT_EQ(conv->get_pads_begin(), (CoordinateDiff{0, 0})); - ASSERT_EQ(conv->get_pads_end(), (CoordinateDiff{0, 0})); + ASSERT_EQ(conv->get_pads_begin(), (ov::CoordinateDiff{0, 0})); + ASSERT_EQ(conv->get_pads_end(), (ov::CoordinateDiff{0, 0})); } TEST(type_prop, convolution_backprop_data_auto_pad_explicit_with_output_padding) { - PartialShape data_pshape{1, 16, 2, 2}; - PartialShape filters_pshape{16, 6, 3, 3}; + ov::PartialShape data_pshape{1, 16, 2, 2}; + ov::PartialShape filters_pshape{16, 6, 3, 3}; set_shape_labels(data_pshape, 10); set_shape_labels(filters_pshape, 20); - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; - const CoordinateDiff output_padding{1, 1}; - const op::PadType auto_pad = op::PadType::EXPLICIT; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; + const ov::CoordinateDiff output_padding{1, 1}; + const ov::op::PadType auto_pad = ov::op::PadType::EXPLICIT; - const element::Type_t inputs_et = element::f16; - auto data = make_shared(inputs_et, data_pshape); - auto filters = make_shared(inputs_et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - strides, - padding_begin, - padding_end, - dilations, - auto_pad, - output_padding); + const ov::element::Type_t inputs_et = ov::element::f16; + auto data = make_shared(inputs_et, data_pshape); + auto filters = make_shared(inputs_et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + strides, + padding_begin, + padding_end, + dilations, + auto_pad, + output_padding); EXPECT_THAT(get_shape_labels(conv_backprop->get_output_partial_shape(0)), ElementsAre(10, 21, ov::no_label, ov::no_label)); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{1, 6, 4, 4})); - ASSERT_EQ(conv_backprop->get_pads_begin(), (CoordinateDiff{1, 1})); - ASSERT_EQ(conv_backprop->get_pads_end(), (CoordinateDiff{1, 1})); - ASSERT_EQ(conv_backprop->get_output_padding(), (CoordinateDiff{1, 1})); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), ov::PartialShape(ov::PartialShape{1, 6, 4, 4})); + ASSERT_EQ(conv_backprop->get_pads_begin(), (ov::CoordinateDiff{1, 1})); + ASSERT_EQ(conv_backprop->get_pads_end(), (ov::CoordinateDiff{1, 1})); + ASSERT_EQ(conv_backprop->get_output_padding(), (ov::CoordinateDiff{1, 1})); } TEST(type_prop, convolution_backprop_data_auto_pad_same_with_output_padding_and_output_shape) { - const PartialShape data_pshape{1, 16, 2, 2}; - const PartialShape filters_pshape{16, 6, 3, 3}; + const ov::PartialShape data_pshape{1, 16, 2, 2}; + const ov::PartialShape filters_pshape{16, 6, 3, 3}; - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; - const CoordinateDiff output_padding{1, 1}; - const op::PadType auto_pad = op::PadType::SAME_LOWER; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; + const ov::CoordinateDiff output_padding{1, 1}; + const ov::op::PadType auto_pad = ov::op::PadType::SAME_LOWER; - const element::Type_t inputs_et = element::f16; - auto data = make_shared(inputs_et, data_pshape); - auto filters = make_shared(inputs_et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - strides, - padding_begin, - padding_end, - dilations, - auto_pad, - output_padding); + const ov::element::Type_t inputs_et = ov::element::f16; + auto data = make_shared(inputs_et, data_pshape); + auto filters = make_shared(inputs_et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + strides, + padding_begin, + padding_end, + dilations, + auto_pad, + output_padding); - EXPECT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{1, 6, 3, 3})); - EXPECT_EQ(conv_backprop->get_pads_begin(), (CoordinateDiff{1, 1})); - EXPECT_EQ(conv_backprop->get_pads_end(), (CoordinateDiff{2, 2})); - EXPECT_EQ(conv_backprop->get_output_padding(), (CoordinateDiff{1, 1})); + EXPECT_EQ(conv_backprop->get_output_partial_shape(0), ov::PartialShape(ov::PartialShape{1, 6, 3, 3})); + EXPECT_EQ(conv_backprop->get_pads_begin(), (ov::CoordinateDiff{1, 1})); + EXPECT_EQ(conv_backprop->get_pads_end(), (ov::CoordinateDiff{2, 2})); + EXPECT_EQ(conv_backprop->get_output_padding(), (ov::CoordinateDiff{1, 1})); } TEST(type_prop, convolution_backprop_data_output_shape_as_const) { - const PartialShape data_pshape{1, 16, 5, 5}; - const PartialShape filters_pshape{16, 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{1, 16, 5, 5}; + const ov::PartialShape filters_pshape{16, 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}, - op::PadType::SAME_UPPER); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}, + ov::op::PadType::SAME_UPPER); - EXPECT_EQ(conv_backprop->get_element_type(), element::f32); - EXPECT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{1, 2, 3, 3})); - EXPECT_EQ(conv_backprop->get_strides(), (Strides{1, 1})); - EXPECT_EQ(conv_backprop->get_dilations(), (Strides{1, 1})); - EXPECT_EQ(conv_backprop->get_pads_begin(), (CoordinateDiff{2, 2})); - EXPECT_EQ(conv_backprop->get_pads_end(), (CoordinateDiff{2, 2})); - EXPECT_EQ(conv_backprop->get_output_padding(), (CoordinateDiff{0, 0})); - EXPECT_EQ(conv_backprop->get_auto_pad(), op::PadType::SAME_UPPER); + EXPECT_EQ(conv_backprop->get_element_type(), ov::element::f32); + EXPECT_EQ(conv_backprop->get_output_partial_shape(0), ov::PartialShape(ov::PartialShape{1, 2, 3, 3})); + EXPECT_EQ(conv_backprop->get_strides(), (ov::Strides{1, 1})); + EXPECT_EQ(conv_backprop->get_dilations(), (ov::Strides{1, 1})); + EXPECT_EQ(conv_backprop->get_pads_begin(), (ov::CoordinateDiff{2, 2})); + EXPECT_EQ(conv_backprop->get_pads_end(), (ov::CoordinateDiff{2, 2})); + EXPECT_EQ(conv_backprop->get_output_padding(), (ov::CoordinateDiff{0, 0})); + EXPECT_EQ(conv_backprop->get_auto_pad(), ov::op::PadType::SAME_UPPER); } TEST(type_prop, convolution_backprop_data_output_shape_as_param) { - const PartialShape data_pshape{1, 16, 5, 5}; - const PartialShape filters_pshape{16, 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{1, 16, 5, 5}; + const ov::PartialShape filters_pshape{16, 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = make_shared(element::i64, Shape{2}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}, - op::PadType::SAME_UPPER); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = make_shared(ov::element::i64, ov::Shape{2}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}, + ov::op::PadType::SAME_UPPER); - EXPECT_EQ(conv_backprop->get_element_type(), element::f32); - EXPECT_EQ(conv_backprop->get_auto_pad(), op::PadType::SAME_UPPER); + EXPECT_EQ(conv_backprop->get_element_type(), ov::element::f32); + EXPECT_EQ(conv_backprop->get_auto_pad(), ov::op::PadType::SAME_UPPER); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{1, 2, Dimension::dynamic(), Dimension::dynamic()})); + ov::PartialShape(ov::PartialShape{1, 2, ov::Dimension::dynamic(), ov::Dimension::dynamic()})); } TEST(type_prop, convolution_backprop_data_with_output_shape_dyn_static_ranks_data_nc_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), Dimension::dynamic(), 5, 5}; - const PartialShape filters_pshape{16, 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 5, 5}; + const ov::PartialShape filters_pshape{16, 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}, - op::PadType::SAME_UPPER); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}, + ov::op::PadType::SAME_UPPER); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{Dimension::dynamic(), 2, 3, 3})); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 2, 3, 3})); } TEST(type_prop, convolution_backprop_data_with_output_shape_dyn_static_ranks_filters_cin_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), 16, 5, 5}; - const PartialShape filters_pshape{Dimension::dynamic(), 6, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), 16, 5, 5}; + const ov::PartialShape filters_pshape{ov::Dimension::dynamic(), 6, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}, - op::PadType::SAME_UPPER); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}, + ov::op::PadType::SAME_UPPER); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{Dimension::dynamic(), 6, 3, 3})); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 6, 3, 3})); } TEST(type_prop, convolution_backprop_data_with_output_shape_dyn_static_ranks_filters_cin_cout_dyn) { - PartialShape data_pshape{Dimension::dynamic(), 16, 5, 5}; - PartialShape filters_pshape{Dimension::dynamic(), Dimension::dynamic(), 3, 3}; + ov::PartialShape data_pshape{ov::Dimension::dynamic(), 16, 5, 5}; + ov::PartialShape filters_pshape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 3, 3}; set_shape_labels(data_pshape, 10); set_shape_labels(filters_pshape, 20); - const element::Type_t et = element::f32; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}, - op::PadType::SAME_UPPER); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}, + ov::op::PadType::SAME_UPPER); EXPECT_THAT(get_shape_labels(conv_backprop->get_output_partial_shape(0)), ElementsAre(10, 21, ov::no_label, ov::no_label)); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), Dimension::dynamic(), 3, 3})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 3, 3})); } TEST(type_prop, convolution_backprop_data_dyn_static_ranks_data_nc_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), Dimension::dynamic(), 224, 224}; - const PartialShape filters_pshape{5, 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 224, 224}; + const ov::PartialShape filters_pshape{5, 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + make_shared(data, filters, strides, padding_begin, padding_end, dilations); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), 2, 447, 447})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 2, 447, 447})); } TEST(type_prop, convolution_backprop_data_dyn_static_ranks_filters_cin_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), 20, 224, 224}; - const PartialShape filters_pshape{Dimension::dynamic(), 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), 20, 224, 224}; + const ov::PartialShape filters_pshape{ov::Dimension::dynamic(), 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + make_shared(data, filters, strides, padding_begin, padding_end, dilations); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), 2, 447, 447})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 2, 447, 447})); } TEST(type_prop, convolution_backprop_data_dyn_static_ranks_filters_cin_cout_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), 20, 224, 224}; - const PartialShape filters_pshape{Dimension::dynamic(), Dimension::dynamic(), 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), 20, 224, 224}; + const ov::PartialShape filters_pshape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 3, 3}; + const ov::element::Type_t et = ov::element::f32; - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + make_shared(data, filters, strides, padding_begin, padding_end, dilations); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), Dimension::dynamic(), 447, 447})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 447, 447})); } TEST(type_prop, convolution_backprop_data_dyn_static_ranks_data_spatial_dims_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), 4, Dimension::dynamic(), 224}; - const PartialShape filters_pshape{4, 16, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), 4, ov::Dimension::dynamic(), 224}; + const ov::PartialShape filters_pshape{4, 16, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + make_shared(data, filters, strides, padding_begin, padding_end, dilations); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), 16, Dimension(1, -1), 447})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 16, ov::Dimension(1, -1), 447})); } TEST(type_prop, convolution_backprop_data_dyn_static_ranks_filters_spatial_dims_dyn) { - const PartialShape data_pshape{Dimension::dynamic(), 4, 224, 224}; - const PartialShape filters_pshape{4, 16, 3, Dimension::dynamic()}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::Dimension::dynamic(), 4, 224, 224}; + const ov::PartialShape filters_pshape{4, 16, 3, ov::Dimension::dynamic()}; + const ov::element::Type_t et = ov::element::f32; - const Strides strides{2, 2}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; + const ov::Strides strides{2, 2}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + make_shared(data, filters, strides, padding_begin, padding_end, dilations); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), 16, 447, Dimension(445, -1)})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 16, 447, ov::Dimension(445, -1)})); } TEST(type_prop, convolution_backprop_data_with_output_shape_dyn_data_batch) { - const PartialShape data_pshape{PartialShape::dynamic()}; - const PartialShape filters_pshape{16, 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::PartialShape::dynamic()}; + const ov::PartialShape filters_pshape{16, 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{Dimension::dynamic(), 2, 3, 3})); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 2, 3, 3})); } TEST(type_prop, convolution_backprop_data_with_output_shape_dyn_filters) { - const PartialShape data_pshape{1, 16, Dimension::dynamic(), Dimension::dynamic()}; - const PartialShape filters_pshape{PartialShape::dynamic()}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{1, 16, ov::Dimension::dynamic(), ov::Dimension::dynamic()}; + const ov::PartialShape filters_pshape{ov::PartialShape::dynamic()}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape{1, Dimension::dynamic(), 3, 3})); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), + ov::PartialShape(ov::PartialShape{1, ov::Dimension::dynamic(), 3, 3})); } TEST(type_prop, convolution_backprop_data_with_output_shape_as_const_dyn_data_and_filters) { - const PartialShape data_pshape{PartialShape::dynamic()}; - const PartialShape filters_pshape{PartialShape::dynamic()}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::PartialShape::dynamic()}; + const ov::PartialShape filters_pshape{ov::PartialShape::dynamic()}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(element::i64, Shape{3}, {3, 3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {3, 3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), Dimension::dynamic(), 3, 3, 3})); + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), ov::Dimension::dynamic(), 3, 3, 3})); } TEST(type_prop, convolution_backprop_data_with_output_shape_as_param_dyn_data_and_filters) { - const PartialShape data_pshape{PartialShape::dynamic()}; - const PartialShape filters_pshape{PartialShape::dynamic()}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::PartialShape::dynamic()}; + const ov::PartialShape filters_pshape{ov::PartialShape::dynamic()}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = make_shared(element::i64, Shape{3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = make_shared(ov::element::i64, ov::Shape{3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape::dynamic(5))); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), ov::PartialShape(ov::PartialShape::dynamic(5))); } TEST(type_prop, convolution_backprop_data_shape_dyn_data) { - const PartialShape data_pshape{PartialShape::dynamic()}; - const PartialShape filters_pshape{4, 2, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::PartialShape::dynamic()}; + const ov::PartialShape filters_pshape{4, 2, 3, 3}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{Dimension::dynamic(), 2, Dimension(3, -1), Dimension(3, -1)})); + ASSERT_EQ( + conv_backprop->get_output_partial_shape(0), + ov::PartialShape(ov::PartialShape{ov::Dimension::dynamic(), 2, ov::Dimension(3, -1), ov::Dimension(3, -1)})); } TEST(type_prop, convolution_backprop_data_shape_dyn_filters) { - const PartialShape data_pshape{1, 4, 224, 224}; // [N, C_IN, H, W] - const PartialShape filters_pshape{PartialShape::dynamic()}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{1, 4, 224, 224}; // [N, C_IN, H, W] + const ov::PartialShape filters_pshape{ov::PartialShape::dynamic()}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); ASSERT_EQ(conv_backprop->get_output_partial_shape(0), - PartialShape(PartialShape{1, Dimension::dynamic(), Dimension(224, -1), Dimension(224, -1)})); + ov::PartialShape( + ov::PartialShape{1, ov::Dimension::dynamic(), ov::Dimension(224, -1), ov::Dimension(224, -1)})); } TEST(type_prop, convolution_backprop_data_dyn_data_and_filters) { - const PartialShape data_pshape{PartialShape::dynamic()}; - const PartialShape filters_pshape{PartialShape::dynamic()}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{ov::PartialShape::dynamic()}; + const ov::PartialShape filters_pshape{ov::PartialShape::dynamic()}; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); - ASSERT_EQ(conv_backprop->get_output_partial_shape(0), PartialShape(PartialShape::dynamic())); + ASSERT_EQ(conv_backprop->get_output_partial_shape(0), ov::PartialShape(ov::PartialShape::dynamic())); } TEST(type_prop, convolution_backprop_data_invalid_et_inputs) { - const PartialShape data_pshape{1, 16, 5, 5}; - const PartialShape filters_pshape{16, 6, 3, 3}; + const ov::PartialShape data_pshape{1, 16, 5, 5}; + const ov::PartialShape filters_pshape{16, 6, 3, 3}; - const Strides strides{1, 1}; - const Strides dilations{1, 1}; - const CoordinateDiff padding_begin{1, 1}; - const CoordinateDiff padding_end{1, 1}; + const ov::Strides strides{1, 1}; + const ov::Strides dilations{1, 1}; + const ov::CoordinateDiff padding_begin{1, 1}; + const ov::CoordinateDiff padding_end{1, 1}; try { - const element::Type_t data_et = element::f16; - const element::Type_t filters_et = element::i64; + const ov::element::Type_t data_et = ov::element::f16; + const ov::element::Type_t filters_et = ov::element::i64; - auto data = make_shared(data_et, data_pshape); - auto filters = make_shared(filters_et, filters_pshape); - auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + auto data = make_shared(data_et, data_pshape); + auto filters = make_shared(filters_et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + strides, + padding_begin, + padding_end, + dilations); FAIL() << "Invalid element type of inputs not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Element types for data batch and filters do not match"); } catch (...) { FAIL() << "Element types of data batch and filters validation check failed for unexpected " @@ -501,14 +510,18 @@ TEST(type_prop, convolution_backprop_data_invalid_et_inputs) { } try { - const element::Type_t input_et = element::boolean; + const ov::element::Type_t input_et = ov::element::boolean; - auto data = make_shared(input_et, data_pshape); - auto filters = make_shared(input_et, filters_pshape); - auto conv_backprop = - make_shared(data, filters, strides, padding_begin, padding_end, dilations); + auto data = make_shared(input_et, data_pshape); + auto filters = make_shared(input_et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + strides, + padding_begin, + padding_end, + dilations); FAIL() << "Invalid element type of inputs not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Element type of inputs must be numeric"); } catch (...) { FAIL() << "Numeric element types of data batch and filters validation check failed for " @@ -516,22 +529,22 @@ TEST(type_prop, convolution_backprop_data_invalid_et_inputs) { } try { - const element::Type_t et = element::f32; + const ov::element::Type_t et = ov::element::f32; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto output_shape = op::Constant::create(et, Shape{2}, {3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}, - op::PadType::SAME_UPPER); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto output_shape = ov::op::v0::Constant::create(et, ov::Shape{2}, {3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}, + ov::op::PadType::SAME_UPPER); // output shape input element type must be of integer type FAIL() << "Invalid element type of output_shape input not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Element type for output shape should be of integer type"); } catch (...) { FAIL() << "Element type of output_shape input validation check failed for unexpected reason"; @@ -539,23 +552,23 @@ TEST(type_prop, convolution_backprop_data_invalid_et_inputs) { } TEST(type_prop, convolution_backprop_data_invalid_input_ranks) { - const element::Type_t input_et = element::f32; + const ov::element::Type_t input_et = ov::element::f32; // data and filters don't have same rank try { - const PartialShape data_pshape{1, 20, 224, 224, 224}; - const PartialShape filters_pshape{20, 10, 3, 3}; + const ov::PartialShape data_pshape{1, 20, 224, 224, 224}; + const ov::PartialShape filters_pshape{20, 10, 3, 3}; - auto data = make_shared(input_et, data_pshape); - auto filters = make_shared(input_et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(input_et, data_pshape); + auto filters = make_shared(input_et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); FAIL() << "Incompatible input ranks not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Data batch and filters rank do not match"); } catch (...) { FAIL() << "Rank validation check of inputs failed for unexpected reason"; @@ -563,19 +576,19 @@ TEST(type_prop, convolution_backprop_data_invalid_input_ranks) { // data and filters don't have spatial dimensions try { - const PartialShape data_pshape{1, 20}; - const PartialShape filters_pshape{20, 10}; + const ov::PartialShape data_pshape{1, 20}; + const ov::PartialShape filters_pshape{20, 10}; - auto data = make_shared(input_et, data_pshape); - auto filters = make_shared(input_et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(input_et, data_pshape); + auto filters = make_shared(input_et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); FAIL() << "Incompatible input ranks not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Expected a 3D, 4D or 5D tensor for the input. Got:"); } catch (...) { FAIL() << "Rank validation check of inputs failed for unexpected reason"; @@ -583,41 +596,41 @@ TEST(type_prop, convolution_backprop_data_invalid_input_ranks) { // data and filters have 4 spatial dimensions (not supported) try { - const PartialShape data_pshape{1, 20, 224, 224, 224, 224}; - const PartialShape filters_pshape{20, 10, 3, 3, 3, 3}; + const ov::PartialShape data_pshape{1, 20, 224, 224, 224, 224}; + const ov::PartialShape filters_pshape{20, 10, 3, 3, 3, 3}; - auto data = make_shared(input_et, data_pshape); - auto filters = make_shared(input_et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(input_et, data_pshape); + auto filters = make_shared(input_et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); FAIL() << "Incompatible input ranks not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Expected a 3D, 4D or 5D tensor for the input. Got:"); } catch (...) { FAIL() << "Rank validation check of inputs failed for unexpected reason"; } try { - const PartialShape data_pshape{1, 16, 5, 5}; - const PartialShape filters_shape{16, 2, 3, 3}; + const ov::PartialShape data_pshape{1, 16, 5, 5}; + const ov::PartialShape filters_shape{16, 2, 3, 3}; - auto data = make_shared(input_et, data_pshape); - auto filters = make_shared(input_et, filters_shape); - auto output_shape = op::Constant::create(element::i64, Shape{3, 1}, {3, 3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(input_et, data_pshape); + auto filters = make_shared(input_et, filters_shape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3, 1}, {3, 3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); // output_shape has rank 2, should be rank 1 FAIL() << "Incompatible rank of output shape optional input not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Input delivering output shape must have rank 1")); } catch (...) { FAIL() << "Output shape rank validation check failed for unexpected reason."; @@ -625,22 +638,22 @@ TEST(type_prop, convolution_backprop_data_invalid_input_ranks) { } TEST(type_prop, convolution_backprop_data_invalid_input_channel_dims) { - const PartialShape data_pshape{1, 32, 5, 5}; - const PartialShape filters_pshape{16, 20, 3, 3}; - const element::Type_t inputs_et = element::f32; + const ov::PartialShape data_pshape{1, 32, 5, 5}; + const ov::PartialShape filters_pshape{16, 20, 3, 3}; + const ov::element::Type_t inputs_et = ov::element::f32; - Strides strides{1, 1}; - Strides dilations{1, 1}; - CoordinateDiff padding{2, 2}; + ov::Strides strides{1, 1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff padding{2, 2}; - auto data = make_shared(inputs_et, data_pshape); - auto filters = make_shared(inputs_et, filters_pshape); + auto data = make_shared(inputs_et, data_pshape); + auto filters = make_shared(inputs_et, filters_pshape); try { auto conv_backprop = - make_shared(data, filters, strides, padding, padding, dilations); + make_shared(data, filters, strides, padding, padding, dilations); // data input shape does not have correct dimension C_IN FAIL() << "Incompatibile input shapes not detected."; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING( error.what(), std::string("Data batch channel count (32) does not match filter input channel count (16)")); @@ -650,24 +663,24 @@ TEST(type_prop, convolution_backprop_data_invalid_input_channel_dims) { } TEST(type_prop, convolution_backprop_data_invalid_output_shape_spatial_dims) { - const PartialShape data_pshape{1, 16, 5, 5}; - const PartialShape filters_shape{16, 2, 3, 3}; - const element::Type_t inputs_et = element::f32; + const ov::PartialShape data_pshape{1, 16, 5, 5}; + const ov::PartialShape filters_shape{16, 2, 3, 3}; + const ov::element::Type_t inputs_et = ov::element::f32; try { - auto data = make_shared(inputs_et, data_pshape); - auto filters = make_shared(inputs_et, filters_shape); - auto output_shape = op::Constant::create(element::i64, Shape{3}, {3, 3, 3}); - auto conv_backprop = make_shared(data, - filters, - output_shape, - Strides{}, - CoordinateDiff{}, - CoordinateDiff{}, - Strides{}); + auto data = make_shared(inputs_et, data_pshape); + auto filters = make_shared(inputs_et, filters_shape); + auto output_shape = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{3}, {3, 3, 3}); + auto conv_backprop = make_shared(data, + filters, + output_shape, + ov::Strides{}, + ov::CoordinateDiff{}, + ov::CoordinateDiff{}, + ov::Strides{}); // output_shape has invalid spatial dimensions (should be 2) FAIL() << "Incompatible output shape optional input not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), std::string("Output shape should be defined for all and only spatial dimensions.")); } catch (...) { @@ -676,39 +689,39 @@ TEST(type_prop, convolution_backprop_data_invalid_output_shape_spatial_dims) { } TEST(type_prop, convolution_backprop_data_invalid_conv_param_spatial_dims) { - const PartialShape data_pshape{1, 20, 224, 224}; - const PartialShape filters_pshape{20, 10, 3, 3}; - const element::Type_t et = element::f32; + const ov::PartialShape data_pshape{1, 20, 224, 224}; + const ov::PartialShape filters_pshape{20, 10, 3, 3}; + const ov::element::Type_t et = ov::element::f32; // invalid strides spatial dimensions try { - Strides strides{1, 1, 1}; - Strides dilations{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; + ov::Strides strides{1, 1, 1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, ov::PartialShape::dynamic()); auto conv_backprop = - make_shared(data, filters, strides, pads_begin, pads_end, dilations); + make_shared(data, filters, strides, pads_begin, pads_end, dilations); FAIL() << "Invalid strides spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Strides should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Strides spatial dimensions validation check failed for unexpected reason"; } try { - Strides strides{1}; - Strides dilations{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; + ov::Strides strides{1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; - auto data = make_shared(et, PartialShape::dynamic()); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, ov::PartialShape::dynamic()); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, pads_begin, pads_end, dilations); + make_shared(data, filters, strides, pads_begin, pads_end, dilations); FAIL() << "Invalid strides spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Strides should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Strides spatial dimensions validation check failed for unexpected reason"; @@ -716,33 +729,33 @@ TEST(type_prop, convolution_backprop_data_invalid_conv_param_spatial_dims) { // invalid dilations spatial dimensions try { - Strides strides{1, 1}; - Strides dilations{1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; + ov::Strides strides{1, 1}; + ov::Strides dilations{1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, ov::PartialShape::dynamic()); auto conv_backprop = - make_shared(data, filters, strides, pads_begin, pads_end, dilations); + make_shared(data, filters, strides, pads_begin, pads_end, dilations); FAIL() << "Invalid dilations spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Dilations should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Dilations spatial dimensions validation check failed for unexpected reason"; } try { - Strides strides{1, 1}; - Strides dilations{1, 1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; + ov::Strides strides{1, 1}; + ov::Strides dilations{1, 1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; - auto data = make_shared(et, PartialShape::dynamic()); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, ov::PartialShape::dynamic()); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, pads_begin, pads_end, dilations); + make_shared(data, filters, strides, pads_begin, pads_end, dilations); FAIL() << "Invalid dilations spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Dilations should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Dilations spatial dimensions validation check failed for unexpected reason"; @@ -750,33 +763,33 @@ TEST(type_prop, convolution_backprop_data_invalid_conv_param_spatial_dims) { // invalid padding spatial dimensions try { - Strides strides{1, 1}; - Strides dilations{1, 1}; - CoordinateDiff pads_begin{0, 0, 0}; - CoordinateDiff pads_end{0, 0}; + ov::Strides strides{1, 1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff pads_begin{0, 0, 0}; + ov::CoordinateDiff pads_end{0, 0}; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, ov::PartialShape::dynamic()); auto conv_backprop = - make_shared(data, filters, strides, pads_begin, pads_end, dilations); + make_shared(data, filters, strides, pads_begin, pads_end, dilations); FAIL() << "Invalid padding spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Pads begin and end should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Padding spatial dimensions validation check failed for unexpected reason"; } try { - Strides strides{1, 1}; - Strides dilations{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0}; + ov::Strides strides{1, 1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0}; - auto data = make_shared(et, PartialShape::dynamic()); - auto filters = make_shared(et, filters_pshape); + auto data = make_shared(et, ov::PartialShape::dynamic()); + auto filters = make_shared(et, filters_pshape); auto conv_backprop = - make_shared(data, filters, strides, pads_begin, pads_end, dilations); + make_shared(data, filters, strides, pads_begin, pads_end, dilations); FAIL() << "Invalid padding spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Pads begin and end should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Padding spatial dimensions validation check failed for unexpected reason"; @@ -784,49 +797,49 @@ TEST(type_prop, convolution_backprop_data_invalid_conv_param_spatial_dims) { // invalid output padding spatial dimensions try { - Strides strides{1, 1}; - Strides dilations{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - CoordinateDiff output_padding{0, 0, 0}; - op::PadType auto_pad = op::PadType::EXPLICIT; + ov::Strides strides{1, 1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::CoordinateDiff output_padding{0, 0, 0}; + ov::op::PadType auto_pad = ov::op::PadType::EXPLICIT; - auto data = make_shared(et, data_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); - auto conv_backprop = make_shared(data, - filters, - strides, - pads_begin, - pads_end, - dilations, - auto_pad, - output_padding); + auto data = make_shared(et, data_pshape); + auto filters = make_shared(et, ov::PartialShape::dynamic()); + auto conv_backprop = make_shared(data, + filters, + strides, + pads_begin, + pads_end, + dilations, + auto_pad, + output_padding); FAIL() << "Invalid output padding spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Output padding should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Output padding spatial dimensions validation check failed for unexpected reason"; } try { - Strides strides{1, 1}; - Strides dilations{1, 1}; - CoordinateDiff pads_begin{0, 0}; - CoordinateDiff pads_end{0, 0}; - CoordinateDiff output_padding{0}; - op::PadType auto_pad = op::PadType::EXPLICIT; + ov::Strides strides{1, 1}; + ov::Strides dilations{1, 1}; + ov::CoordinateDiff pads_begin{0, 0}; + ov::CoordinateDiff pads_end{0, 0}; + ov::CoordinateDiff output_padding{0}; + ov::op::PadType auto_pad = ov::op::PadType::EXPLICIT; - auto data = make_shared(et, PartialShape::dynamic()); - auto filters = make_shared(et, filters_pshape); - auto conv_backprop = make_shared(data, - filters, - strides, - pads_begin, - pads_end, - dilations, - auto_pad, - output_padding); + auto data = make_shared(et, ov::PartialShape::dynamic()); + auto filters = make_shared(et, filters_pshape); + auto conv_backprop = make_shared(data, + filters, + strides, + pads_begin, + pads_end, + dilations, + auto_pad, + output_padding); FAIL() << "Invalid output padding spatial dimensions not detected"; - } catch (const NodeValidationFailure& error) { + } catch (const ov::NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), "Output padding should be defined for all and only spatial dimensions."); } catch (...) { FAIL() << "Output padding spatial dimensions validation check failed for unexpected reason"; @@ -834,59 +847,59 @@ TEST(type_prop, convolution_backprop_data_invalid_conv_param_spatial_dims) { } TEST(type_prop, convolution_back_prop_data_default_constructed) { - const auto data = make_shared(element::f32, PartialShape::dynamic()); - const auto filters = make_shared(element::f32, PartialShape{1, 1, 1, 3, 3}); - const auto out_spatial = op::Constant::create(element::i32, Shape{3}, {5, 4, 10}); + const auto data = make_shared(ov::element::f32, ov::PartialShape::dynamic()); + const auto filters = make_shared(ov::element::f32, ov::PartialShape{1, 1, 1, 3, 3}); + const auto out_spatial = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{3}, {5, 4, 10}); - const auto op = make_shared(); - op->set_arguments(OutputVector{data, filters, out_spatial}); + const auto op = make_shared(); + op->set_arguments(ov::OutputVector{data, filters, out_spatial}); op->set_strides({1, 1, 1}); op->set_dilations({1, 1, 1}); op->set_pads_begin({2, 2, 2}); op->set_pads_end({2, 2, 2}); - op->set_auto_pad(op::PadType::EXPLICIT); + op->set_auto_pad(ov::op::PadType::EXPLICIT); op->validate_and_infer_types(); EXPECT_EQ(op->get_input_size(), 3); EXPECT_EQ(op->get_output_size(), 1); - EXPECT_EQ(op->get_strides(), Strides({1, 1, 1})); - EXPECT_EQ(op->get_dilations(), Strides({1, 1, 1})); - EXPECT_EQ(op->get_pads_begin(), CoordinateDiff({2, 2, 2})); - EXPECT_EQ(op->get_pads_end(), CoordinateDiff({2, 2, 2})); - EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({-1, 1, 5, 4, 10})); + EXPECT_EQ(op->get_strides(), ov::Strides({1, 1, 1})); + EXPECT_EQ(op->get_dilations(), ov::Strides({1, 1, 1})); + EXPECT_EQ(op->get_pads_begin(), ov::CoordinateDiff({2, 2, 2})); + EXPECT_EQ(op->get_pads_end(), ov::CoordinateDiff({2, 2, 2})); + EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({-1, 1, 5, 4, 10})); } TEST(type_prop, convolution_back_prop_data_interval_shapes_output_shape_as_shape_of) { - PartialShape data_pshape{{1, 3}, {2, 6}, {1, 5}, {3, 10}, {20, 100}}; - PartialShape filters_pshape{{2, 3}, {1, 3}, 3, 3, 3}; - PartialShape out_spatial_pshape{3, {2, 4}, 3}; + ov::PartialShape data_pshape{{1, 3}, {2, 6}, {1, 5}, {3, 10}, {20, 100}}; + ov::PartialShape filters_pshape{{2, 3}, {1, 3}, 3, 3, 3}; + ov::PartialShape out_spatial_pshape{3, {2, 4}, 3}; set_shape_labels(data_pshape, 10); set_shape_labels(filters_pshape, 20); set_shape_labels(out_spatial_pshape, 30); - const element::Type_t et = element::f32; - Strides strides{1, 2, 1}; - Strides dilations{1, 1, 1}; - CoordinateDiff pads_begin{0, 2, 1}; - CoordinateDiff pads_end{0, 0, 0}; - const auto auto_pad = op::PadType::SAME_LOWER; + const ov::element::Type_t et = ov::element::f32; + ov::Strides strides{1, 2, 1}; + ov::Strides dilations{1, 1, 1}; + ov::CoordinateDiff pads_begin{0, 2, 1}; + ov::CoordinateDiff pads_end{0, 0, 0}; + const auto auto_pad = ov::op::PadType::SAME_LOWER; - auto data_batch = make_shared(et, data_pshape); - auto filters = make_shared(et, filters_pshape); - auto out_spatial = make_shared(element::i32, out_spatial_pshape); - auto spatial_shape_of = std::make_shared(out_spatial); + auto data_batch = make_shared(et, data_pshape); + auto filters = make_shared(et, filters_pshape); + auto out_spatial = make_shared(ov::element::i32, out_spatial_pshape); + auto spatial_shape_of = std::make_shared(out_spatial); - const auto op = make_shared(data_batch, - filters, - spatial_shape_of, - strides, - pads_begin, - pads_end, - dilations, - auto_pad); + const auto op = make_shared(data_batch, + filters, + spatial_shape_of, + strides, + pads_begin, + pads_end, + dilations, + auto_pad); EXPECT_THAT(get_shape_labels(op->get_output_partial_shape(0)), ElementsAre(10, 21, 30, 31, 32)); - EXPECT_EQ(op->get_output_partial_shape(0), PartialShape({{1, 3}, {1, 3}, 3, {2, 4}, 3})); - EXPECT_EQ(op->get_pads_begin(), (CoordinateDiff{0, 0, 0})); - EXPECT_EQ(op->get_pads_end(), (CoordinateDiff{0, 0, 0})); + EXPECT_EQ(op->get_output_partial_shape(0), ov::PartialShape({{1, 3}, {1, 3}, 3, {2, 4}, 3})); + EXPECT_EQ(op->get_pads_begin(), (ov::CoordinateDiff{0, 0, 0})); + EXPECT_EQ(op->get_pads_end(), (ov::CoordinateDiff{0, 0, 0})); } diff --git a/src/core/tests/type_prop/cos.cpp b/src/core/tests/type_prop/cos.cpp index 22c872be772..3b23d69397f 100644 --- a/src/core/tests/type_prop/cos.cpp +++ b/src/core/tests/type_prop/cos.cpp @@ -4,6 +4,6 @@ #include "unary_ops.hpp" -using Type = ::testing::Types; +using Type = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_cos, UnaryOperator, Type); diff --git a/src/core/tests/type_prop/cosh.cpp b/src/core/tests/type_prop/cosh.cpp index 2f8cda94424..7c85f9a03e4 100644 --- a/src/core/tests/type_prop/cosh.cpp +++ b/src/core/tests/type_prop/cosh.cpp @@ -4,6 +4,6 @@ #include "unary_ops.hpp" -using Type = ::testing::Types; +using Type = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_cosh, UnaryOperator, Type); diff --git a/src/core/tests/type_prop/ctc_greedy_decoder.cpp b/src/core/tests/type_prop/ctc_greedy_decoder.cpp index 087bdd17b14..84df9ab1d71 100644 --- a/src/core/tests/type_prop/ctc_greedy_decoder.cpp +++ b/src/core/tests/type_prop/ctc_greedy_decoder.cpp @@ -2,13 +2,15 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/ctc_greedy_decoder.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" #include "openvino/core/dimension_tracker.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, ctc_greedy_decoder_default_constructor) { @@ -16,10 +18,10 @@ TEST(type_prop, ctc_greedy_decoder_default_constructor) { PartialShape seq_mask_shape{100, 3}; PartialShape expected_shape{3, 100, 1, 1}; - auto op = make_shared(); + auto op = make_shared(); - auto data = make_shared(element::f32, data_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto data = make_shared(element::f32, data_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); op->set_arguments(OutputVector{data, seq_mask}); op->set_ctc_merge_repeated(false); @@ -38,9 +40,9 @@ TEST(type_prop, ctc_greedy_decoder_static_shapes) { PartialShape logits_shape{100, 3, 1200}; PartialShape seq_mask_shape{100, 3}; Shape out_shape{3, 100, 1, 1}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_shape(), out_shape); } @@ -53,9 +55,9 @@ TEST(type_prop, ctc_greedy_decoder_interval_labeled_dims_all) { set_shape_labels(data_shape, 10); set_shape_labels(seq_mask_shape, 20); - auto data = make_shared(element::f32, data_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, data_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); const auto& out_shape = op->get_output_partial_shape(0); EXPECT_EQ(op->get_element_type(), element::f32); @@ -70,9 +72,9 @@ TEST(type_prop, ctc_greedy_decoder_interval_labeled_dims_data) { set_shape_labels(data_shape, 10); - auto data = make_shared(element::f32, data_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, data_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); const auto& out_shape = op->get_output_partial_shape(0); EXPECT_EQ(op->get_element_type(), element::f32); @@ -87,9 +89,9 @@ TEST(type_prop, ctc_greedy_decoder_interval_labeled_dims_mask) { set_shape_labels(seq_mask_shape, 20); - auto data = make_shared(element::f32, data_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, data_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); const auto& out_shape = op->get_output_partial_shape(0); EXPECT_EQ(op->get_output_element_type(0), element::f32); @@ -101,9 +103,9 @@ TEST(type_prop, ctc_greedy_decoder_output_static_shape1) { PartialShape logits_shape{Dimension::dynamic(), 3, 1200}; PartialShape seq_mask_shape{100, 3}; Shape out_shape{3, 100, 1, 1}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); EXPECT_EQ(op->get_output_element_type(0), element::f32); EXPECT_EQ(op->get_shape(), out_shape); @@ -113,9 +115,9 @@ TEST(type_prop, ctc_greedy_decoder_output_static_shape2) { PartialShape logits_shape{Dimension::dynamic(), 3, 1200}; PartialShape seq_mask_shape{100, Dimension::dynamic()}; Shape out_shape{3, 100, 1, 1}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); EXPECT_EQ(op->get_element_type(), element::f32); EXPECT_EQ(op->get_shape(), out_shape); } @@ -124,9 +126,9 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_shapes) { PartialShape logits_shape{Dimension::dynamic(), Dimension::dynamic(), 1200}; PartialShape seq_mask_shape{Dimension::dynamic(), Dimension::dynamic()}; PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); EXPECT_EQ(op->get_element_type(), element::f32); ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape)); } @@ -135,9 +137,9 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_ranks1) { PartialShape logits_shape = PartialShape::dynamic(); PartialShape seq_mask_shape{100, Dimension::dynamic()}; PartialShape out_shape{Dimension::dynamic(), 100, 1, 1}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); EXPECT_EQ(op->get_element_type(), element::f32); ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape)); } @@ -146,9 +148,9 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_ranks2) { PartialShape logits_shape = PartialShape::dynamic(); PartialShape seq_mask_shape = PartialShape::dynamic(); PartialShape out_shape{Dimension::dynamic(), Dimension::dynamic(), 1, 1}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); - auto op = make_shared(data, seq_mask, false); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto op = make_shared(data, seq_mask, false); EXPECT_EQ(op->get_element_type(), element::f32); ASSERT_TRUE(op->get_output_partial_shape(0).same_scheme(out_shape)); } @@ -156,11 +158,11 @@ TEST(type_prop, ctc_greedy_decoder_dynamic_ranks2) { TEST(type_prop, ctc_greedy_decoder_incorrect_rank) { PartialShape logits_shape{Dimension::dynamic(), 3, 1200, 5}; PartialShape seq_mask_shape{100, 3}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); try { - auto op = make_shared(data, seq_mask, false); + auto op = make_shared(data, seq_mask, false); // Should have thrown, so fail if it didn't FAIL() << "Incorrect indices rank"; } catch (const NodeValidationFailure& error) { @@ -173,11 +175,11 @@ TEST(type_prop, ctc_greedy_decoder_incorrect_rank) { TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) { PartialShape logits_shape{Dimension::dynamic(), 3, 1200}; PartialShape seq_mask_shape{100, 3, 2}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); try { - auto op = make_shared(data, seq_mask, false); + auto op = make_shared(data, seq_mask, false); // Should have thrown, so fail if it didn't FAIL() << "Incorrect indices rank"; } catch (const NodeValidationFailure& error) { @@ -190,11 +192,11 @@ TEST(type_prop, ctc_greedy_decoder_incorrect_rank2) { TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) { PartialShape logits_shape{100, 4, 1200}; PartialShape seq_mask_shape{100, 3}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); try { - auto op = make_shared(data, seq_mask, false); + auto op = make_shared(data, seq_mask, false); // Should have thrown, so fail if it didn't FAIL() << "Incorrect indices rank"; } catch (const NodeValidationFailure& error) { @@ -207,11 +209,11 @@ TEST(type_prop, ctc_greedy_decoder_mismatched_dim1) { TEST(type_prop, ctc_greedy_decoder_mismatched_dim2) { PartialShape logits_shape{101, 3, 1200}; PartialShape seq_mask_shape{100, 3}; - auto data = make_shared(element::f32, logits_shape); - auto seq_mask = make_shared(element::f32, seq_mask_shape); + auto data = make_shared(element::f32, logits_shape); + auto seq_mask = make_shared(element::f32, seq_mask_shape); try { - auto op = make_shared(data, seq_mask, false); + auto op = make_shared(data, seq_mask, false); // Should have thrown, so fail if it didn't FAIL() << "Incorrect indices rank"; } catch (const NodeValidationFailure& error) { diff --git a/src/core/tests/type_prop/ctc_greedy_decoder_seq_len.cpp b/src/core/tests/type_prop/ctc_greedy_decoder_seq_len.cpp index 33da35be39f..827f6888b41 100644 --- a/src/core/tests/type_prop/ctc_greedy_decoder_seq_len.cpp +++ b/src/core/tests/type_prop/ctc_greedy_decoder_seq_len.cpp @@ -2,8 +2,9 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" #include "openvino/core/dimension_tracker.hpp" #include "openvino/op/ops.hpp" diff --git a/src/core/tests/type_prop/ctc_loss.cpp b/src/core/tests/type_prop/ctc_loss.cpp index 422bd868337..1d50b041926 100644 --- a/src/core/tests/type_prop/ctc_loss.cpp +++ b/src/core/tests/type_prop/ctc_loss.cpp @@ -2,9 +2,10 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" #include "openvino/opsets/opset10.hpp" using namespace std; diff --git a/src/core/tests/type_prop/cum_sum.cpp b/src/core/tests/type_prop/cum_sum.cpp index 066451960dc..bf5b96e726f 100644 --- a/src/core/tests/type_prop/cum_sum.cpp +++ b/src/core/tests/type_prop/cum_sum.cpp @@ -2,15 +2,18 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "openvino/op/cum_sum.hpp" -using namespace ngraph; +#include + +#include "common_test_utils/type_prop.hpp" +#include "openvino/op/constant.hpp" + +using namespace ov; TEST(type_prop, cum_sum_op_default_attributes_no_axis_input) { PartialShape data_shape{2, 4}; - auto A = std::make_shared(element::f32, data_shape); + auto A = std::make_shared(element::f32, data_shape); auto cum_sum = std::make_shared(A); EXPECT_EQ(cum_sum->is_exclusive(), false); @@ -22,8 +25,8 @@ TEST(type_prop, cum_sum_op_default_attributes_no_axis_input) { TEST(type_prop, cum_sum_op_default_attributes_with_axis_param) { PartialShape data_shape{2, 4}; - auto A = std::make_shared(element::f32, data_shape); - auto axis = std::make_shared(element::i32, PartialShape{}); + auto A = std::make_shared(element::f32, data_shape); + auto axis = std::make_shared(element::i32, PartialShape{}); auto cum_sum = std::make_shared(A, axis); EXPECT_EQ(cum_sum->is_exclusive(), false); @@ -35,8 +38,8 @@ TEST(type_prop, cum_sum_op_default_attributes_with_axis_param) { TEST(type_prop, cum_sum_op_default_attributes_with_axis_const) { PartialShape data_shape{2, 4}; - auto A = std::make_shared(element::f32, data_shape); - auto axis = op::Constant::create(element::i32, Shape{}, {1}); + auto A = std::make_shared(element::f32, data_shape); + auto axis = ov::op::v0::Constant::create(element::i32, Shape{}, {1}); auto cum_sum = std::make_shared(A, axis); EXPECT_EQ(cum_sum->is_exclusive(), false); @@ -48,8 +51,8 @@ TEST(type_prop, cum_sum_op_default_attributes_with_axis_const) { TEST(type_prop, cum_sum_op_custom_attributes) { PartialShape data_shape{2, 4}; - auto A = std::make_shared(element::f32, data_shape); - auto axis = std::make_shared(element::i32, PartialShape{}); + auto A = std::make_shared(element::f32, data_shape); + auto axis = std::make_shared(element::i32, PartialShape{}); bool exclusive = true; bool reverse = true; auto cum_sum = std::make_shared(A, axis, exclusive, reverse); @@ -73,8 +76,8 @@ TEST(type_prop, cum_sum_op_data_shapes) { for (auto& shape : input_shpes) { try { - auto axis = std::make_shared(element::i32, PartialShape{}); - auto A = std::make_shared(element::f32, shape); + auto axis = std::make_shared(element::i32, PartialShape{}); + auto A = std::make_shared(element::f32, shape); auto cum_sum = std::make_shared(A, axis); EXPECT_EQ(cum_sum->get_output_partial_shape(0), shape); @@ -89,8 +92,8 @@ TEST(type_prop, cum_sum_op_incorrect_axis_shapes) { std::vector incorrect_axis_shpes{{1}, {1, 1}, {2}}; for (auto& shape : incorrect_axis_shpes) { try { - auto axis = std::make_shared(element::i32, shape); - auto A = std::make_shared(element::f32, data_shape); + auto axis = std::make_shared(element::i32, shape); + auto A = std::make_shared(element::f32, data_shape); auto cum_sum = std::make_shared(A, axis); } catch (...) { FAIL() << "CumSum axis input shape validation shouldn't throw for backward compatibility"; @@ -115,8 +118,8 @@ TEST(type_prop, cum_sum_op_element_types) { for (auto& et : element_types) { try { - auto axis = std::make_shared(element::i32, PartialShape{}); - auto A = std::make_shared(et, data_shape); + auto axis = std::make_shared(element::i32, PartialShape{}); + auto A = std::make_shared(et, data_shape); EXPECT_NO_THROW(const auto unused = std::make_shared(A, axis)); } catch (...) { @@ -132,8 +135,8 @@ TEST(type_prop, cum_sum_op_incorrect_axis_element_type) { for (auto& et : element_types) { try { - auto axis = std::make_shared(et, PartialShape{}); - auto A = std::make_shared(element::f32, data_shape); + auto axis = std::make_shared(et, PartialShape{}); + auto A = std::make_shared(element::f32, data_shape); auto cum_sum = std::make_shared(A, axis); FAIL() << "Invalid element type of axis input not detected"; diff --git a/src/core/tests/type_prop/deformable_convolution.cpp b/src/core/tests/type_prop/deformable_convolution.cpp index 813d86b3b61..5b9bf65409e 100644 --- a/src/core/tests/type_prop/deformable_convolution.cpp +++ b/src/core/tests/type_prop/deformable_convolution.cpp @@ -2,12 +2,15 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/deformable_convolution.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "openvino/core/coordinate_diff.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, deformable_convolution_partial_auto_padding_same) { @@ -27,9 +30,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same) { const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -62,9 +65,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same_lower_data_batc const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -95,9 +98,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same_upper_data_batc const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -128,9 +131,9 @@ TEST(type_prop, deformable_convolution_partial_auto_padding_same_spatial_dims_dy const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -159,9 +162,9 @@ TEST(type_prop, deformable_convolution_data_batch_dynamic) { const int64_t group = 2; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -193,9 +196,9 @@ TEST(type_prop, deformable_convolution_offsets_dynamic) { const int64_t group = 2; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -225,9 +228,9 @@ TEST(type_prop, deformable_convolution_auto_pad_same_filters_dynamic) { const int64_t group = 2; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -257,9 +260,9 @@ TEST(type_prop, deformable_convolution_deformable_data_batch_and_filters_dynamic const int64_t group = 2; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -287,9 +290,9 @@ TEST(type_prop, deformable_convolution_deformable_all_inputs_dynamic) { const int64_t group = 2; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, dyn_pshape); - auto offsets = make_shared(et, dyn_pshape); - auto filters = make_shared(et, dyn_pshape); + auto data_batch = make_shared(et, dyn_pshape); + auto offsets = make_shared(et, dyn_pshape); + auto filters = make_shared(et, dyn_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -318,9 +321,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) { element::Type_t boolean_et = element::boolean; try { - auto data_batch = make_shared(element::f16, data_batch_pshape); - auto offsets = make_shared(float_et, offsets_pshape); - auto filters = make_shared(float_et, filters_pshape); + auto data_batch = make_shared(element::f16, data_batch_pshape); + auto offsets = make_shared(float_et, offsets_pshape); + auto filters = make_shared(float_et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -339,9 +342,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) { } try { - auto data_batch = make_shared(float_et, data_batch_pshape); - auto offsets = make_shared(float_et, offsets_pshape); - auto filters = make_shared(element::f16, filters_pshape); + auto data_batch = make_shared(float_et, data_batch_pshape); + auto offsets = make_shared(float_et, offsets_pshape); + auto filters = make_shared(element::f16, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -360,9 +363,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) { } try { - auto data_batch = make_shared(float_et, data_batch_pshape); - auto offsets = make_shared(element::f16, offsets_pshape); - auto filters = make_shared(float_et, filters_pshape); + auto data_batch = make_shared(float_et, data_batch_pshape); + auto offsets = make_shared(element::f16, offsets_pshape); + auto filters = make_shared(float_et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -381,9 +384,9 @@ TEST(type_prop, deformable_convolution_invalid_et_inputs) { } try { - auto data_batch = make_shared(boolean_et, data_batch_pshape); - auto offsets = make_shared(boolean_et, offsets_pshape); - auto filters = make_shared(boolean_et, filters_pshape); + auto data_batch = make_shared(boolean_et, data_batch_pshape); + auto offsets = make_shared(boolean_et, offsets_pshape); + auto filters = make_shared(boolean_et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -410,9 +413,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) { const PartialShape offsets_pshape{1, 4, 4, 4}; const PartialShape filters_pshape{4, 4, 3, 3}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -434,9 +437,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) { const PartialShape offsets_pshape{1, 4, 4, 4, 4}; const PartialShape filters_pshape{4, 4, 3, 3}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -458,9 +461,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) { const PartialShape offsets_pshape{1, 4, 4, 4}; const PartialShape filters_pshape{4, 4, 3, 3, 3}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -482,9 +485,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) { const PartialShape offsets_pshape{1, 4, 4, 4, 4}; const PartialShape filters_pshape{4, 4, 3, 3, 3}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -506,9 +509,9 @@ TEST(type_prop, deformable_convolution_invalid_input_ranks) { const PartialShape offsets_pshape{1, 4, 4}; const PartialShape filters_pshape{4, 4, 3}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -539,9 +542,9 @@ TEST(type_prop, deformable_convolution_invalid_groups) { const int64_t group = 0; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -578,9 +581,9 @@ TEST(type_prop, deformable_convolution_invalid_deformable_groups) { const int64_t group = 4; const int64_t deformable_group = 0; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -618,9 +621,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_channels_dim) { const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -660,9 +663,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_channels_dim) { const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -698,9 +701,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_batch_dim) { const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -737,9 +740,9 @@ TEST(type_prop, deformable_convolution_invalid_data_batch_channels_dim_with_grou const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -776,9 +779,9 @@ TEST(type_prop, deformable_convolution_invalid_filters_channels_dim_with_group) const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -815,9 +818,9 @@ TEST(type_prop, deformable_convolution_incompatible_data_batch_and_filters_chann const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -856,9 +859,9 @@ TEST(type_prop, deformable_convolution_invalid_offsets_spatial_dims) { const int64_t group = 4; const int64_t deformable_group = 2; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); try { auto deformable_conv = make_shared(data_batch, @@ -893,9 +896,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) { CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_end{0, 0}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, PartialShape::dynamic()); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -915,9 +918,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) { CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_end{0, 0}; - auto data_batch = make_shared(et, PartialShape::dynamic()); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, PartialShape::dynamic()); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -939,9 +942,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) { CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_end{0, 0}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, PartialShape::dynamic()); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -961,9 +964,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) { CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_end{0, 0}; - auto data_batch = make_shared(et, PartialShape::dynamic()); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, PartialShape::dynamic()); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -985,9 +988,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) { CoordinateDiff pads_begin{0, 0, 0}; CoordinateDiff pads_end{0, 0}; - auto data_batch = make_shared(et, data_batch_pshape); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, PartialShape::dynamic()); + auto data_batch = make_shared(et, data_batch_pshape); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, PartialShape::dynamic()); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -1007,9 +1010,9 @@ TEST(type_prop, deformable_convolution_invalid_conv_param_spatial_dims) { CoordinateDiff pads_begin{0, 0}; CoordinateDiff pads_end{0}; - auto data_batch = make_shared(et, PartialShape::dynamic()); - auto offsets = make_shared(et, offsets_pshape); - auto filters = make_shared(et, filters_pshape); + auto data_batch = make_shared(et, PartialShape::dynamic()); + auto offsets = make_shared(et, offsets_pshape); + auto filters = make_shared(et, filters_pshape); auto deformable_conv = make_shared(data_batch, offsets, filters, @@ -1031,9 +1034,9 @@ protected: }; TEST_F(TypePropDeformableConvolutionV1Test, default_ctor) { - const auto data = make_shared(element::f32, PartialShape{1, 4, 5, 5}); - const auto offsets = make_shared(element::f32, PartialShape{1, 36, 7, 2}); - const auto filters = make_shared(element::f32, PartialShape{4, 1, 3, 3}); + const auto data = make_shared(element::f32, PartialShape{1, 4, 5, 5}); + const auto offsets = make_shared(element::f32, PartialShape{1, 36, 7, 2}); + const auto filters = make_shared(element::f32, PartialShape{4, 1, 3, 3}); const auto op = make_op(); op->set_arguments(OutputVector{data, offsets, filters}); @@ -1067,9 +1070,9 @@ TEST_F(TypePropDeformableConvolutionV1Test, interval_shapes) { const element::Type_t et = element::f32; const auto auto_pad = op::PadType::EXPLICIT; - const auto data_batch = make_shared(et, data_batch_pshape); - const auto offsets = make_shared(et, offsets_shape); - const auto filters = make_shared(et, filters_pshape); + const auto data_batch = make_shared(et, data_batch_pshape); + const auto offsets = make_shared(et, offsets_shape); + const auto filters = make_shared(et, filters_pshape); const auto op = make_op(data_batch, offsets, filters, Strides{}, empty_pad, empty_pad, Strides{}, auto_pad, 4, 2); EXPECT_THAT(get_shape_labels(op->get_output_partial_shape(0)), ElementsAre(10, 30, ov::no_label, ov::no_label)); diff --git a/src/core/tests/type_prop/deformable_convolution_opset8.cpp b/src/core/tests/type_prop/deformable_convolution_opset8.cpp index cb674a59e0f..4f0fdef78be 100644 --- a/src/core/tests/type_prop/deformable_convolution_opset8.cpp +++ b/src/core/tests/type_prop/deformable_convolution_opset8.cpp @@ -2,13 +2,13 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" #include "openvino/opsets/opset8.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace ov::opset8; using namespace testing; diff --git a/src/core/tests/type_prop/deformable_psroi_pooling.cpp b/src/core/tests/type_prop/deformable_psroi_pooling.cpp index 9ec92166803..46a9ae3c27d 100644 --- a/src/core/tests/type_prop/deformable_psroi_pooling.cpp +++ b/src/core/tests/type_prop/deformable_psroi_pooling.cpp @@ -2,12 +2,14 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/deformable_psroi_pooling.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, deformable_psroi_pooling_default_ctor) { @@ -16,8 +18,8 @@ TEST(type_prop, deformable_psroi_pooling_default_ctor) { const auto rois_dim = 30; - auto input_data = make_shared(element::f32, PartialShape{2, 4, 64, 56}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_data = make_shared(element::f32, PartialShape{2, 4, 64, 56}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); auto op = make_shared(); @@ -38,11 +40,11 @@ TEST(type_prop, deformable_psroi_pooling_interval_labels) { const auto rois_dim = Dimension(15, 30); - auto input_data = make_shared(element::f32, PartialShape{2, 4, 64, 56}); + auto input_data = make_shared(element::f32, PartialShape{2, 4, 64, 56}); auto coords_shape = PartialShape{rois_dim, 5}; set_shape_labels(coords_shape, 20); - auto input_coords = make_shared(element::f32, coords_shape); + auto input_coords = make_shared(element::f32, coords_shape); auto op = make_shared(input_data, input_coords, output_dim, spatial_scale, group_size); @@ -60,8 +62,8 @@ TEST(type_prop, deformable_psroi_pooling_no_offsets_group_size_3) { const auto rois_dim = 300; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); auto def_psroi_pool = make_shared(input_data, input_coords, output_dim, spatial_scale, group_size); @@ -79,9 +81,10 @@ TEST(type_prop, deformable_psroi_pooling_group_size_3) { const auto rois_dim = 300; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); - auto input_offsets = make_shared(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_offsets = + make_shared(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); auto def_psroi_pool = make_shared(input_data, input_coords, @@ -108,9 +111,10 @@ TEST(type_prop, deformable_psroi_pooling_group_size_7) { const auto rois_dim = 300; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); - auto input_offsets = make_shared(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_offsets = + make_shared(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); auto def_psroi_pool = make_shared(input_data, input_coords, @@ -135,8 +139,8 @@ TEST(type_prop, deformable_psroi_pooling_dynamic_rois) { const auto rois_dim = Dimension(100, 200); - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); auto def_psroi_pool = make_shared(input_data, input_coords, output_dim, spatial_scale, group_size); @@ -152,8 +156,8 @@ TEST(type_prop, deformable_psroi_pooling_fully_dynamic) { const auto rois_dim = Dimension::dynamic(); - auto input_data = make_shared(element::f32, PartialShape::dynamic()); - auto input_coords = make_shared(element::f32, PartialShape::dynamic()); + auto input_data = make_shared(element::f32, PartialShape::dynamic()); + auto input_coords = make_shared(element::f32, PartialShape::dynamic()); auto def_psroi_pool = make_shared(input_data, input_coords, output_dim, spatial_scale, group_size); @@ -169,8 +173,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_group_size) { try { const int64_t group_size = 0; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); auto def_psroi_pool = make_shared(input_data, input_coords, output_dim, @@ -193,8 +197,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_output_dim) { try { const int64_t output_dim = -882; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); auto def_psroi_pool = make_shared(input_data, input_coords, output_dim, @@ -218,9 +222,10 @@ TEST(type_prop, deformable_psroi_pooling_invalid_data_input_rank) { const auto rois_dim = 300; - auto input_data = make_shared(element::f32, PartialShape{7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); - auto input_offsets = make_shared(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); + auto input_data = make_shared(element::f32, PartialShape{7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_offsets = + make_shared(element::f32, PartialShape{rois_dim, 2, part_size, part_size}); try { auto def_psroi_pool = make_shared(input_data, @@ -251,8 +256,8 @@ TEST(type_prop, deformable_psroi_pooling_invalid_box_coordinates_rank) { const auto rois_dim = 300; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{2, rois_dim, 5}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{2, rois_dim, 5}); try { auto def_psroi_pool = make_shared(input_data, input_coords, @@ -277,9 +282,10 @@ TEST(type_prop, deformable_psroi_pooling_invalid_offstes_rank) { const auto rois_dim = 300; - auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); - auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); - auto input_offsets = make_shared(element::f32, PartialShape{2, rois_dim, 2, part_size, part_size}); + auto input_data = make_shared(element::f32, PartialShape{2, 7938, 63, 38}); + auto input_coords = make_shared(element::f32, PartialShape{rois_dim, 5}); + auto input_offsets = + make_shared(element::f32, PartialShape{2, rois_dim, 2, part_size, part_size}); try { auto def_psroi_pool = make_shared(input_data, input_coords, diff --git a/src/core/tests/type_prop/depth_to_space.cpp b/src/core/tests/type_prop/depth_to_space.cpp index 2b19151d8cc..5562094caba 100644 --- a/src/core/tests/type_prop/depth_to_space.cpp +++ b/src/core/tests/type_prop/depth_to_space.cpp @@ -2,19 +2,23 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/depth_to_space.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "ngraph/util.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, depth_to_space_input_interval_shape_block_first_5D_when_depth_is_static) { auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}}; set_shape_labels(a_shape, 10); - auto A = make_shared(element::f32, a_shape); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); + auto A = make_shared(element::f32, a_shape); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); EXPECT_EQ(depth_to_space->get_output_element_type(0), element::f32); EXPECT_EQ(depth_to_space->get_output_partial_shape(0), @@ -26,8 +30,9 @@ TEST(type_prop, depth_to_space_input_interval_shape_block_first_5D_when_depth_is TEST(type_prop, depth_to_space_input_interval_shape_default_block_size) { auto a_shape = PartialShape{{2, 10}, 24, {3, 7}, {423, 3000}, {235, 1345}}; set_shape_labels(a_shape, 10); - auto A = make_shared(element::f32, a_shape); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); + auto A = make_shared(element::f32, a_shape); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); EXPECT_EQ(depth_to_space->get_output_element_type(0), element::f32); EXPECT_EQ(depth_to_space->get_output_partial_shape(0), a_shape); @@ -37,61 +42,71 @@ TEST(type_prop, depth_to_space_input_interval_shape_default_block_size) { OPENVINO_SUPPRESS_DEPRECATED_START TEST(type_prop, depth_to_space_output_dynamicshape_block_first_5D_when_depth_is_dynamic) { - auto A = - make_shared(element::f32, PartialShape{{2, 10}, {81, 82}, {3, 7}, {423, 3000}, {235, 1345}}); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 3); + auto A = make_shared(element::f32, + PartialShape{{2, 10}, {81, 82}, {3, 7}, {423, 3000}, {235, 1345}}); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 3); - ASSERT_EQ( - depth_to_space->get_output_partial_shape(0), - (PartialShape{{2, 10}, {ceil_div(81, 27), 82 / 27}, {3 * 3, 7 * 3}, {423 * 3, 3000 * 3}, {235 * 3, 1345 * 3}})); + ASSERT_EQ(depth_to_space->get_output_partial_shape(0), + (PartialShape{{2, 10}, + {ngraph::ceil_div(81, 27), 82 / 27}, + {3 * 3, 7 * 3}, + {423 * 3, 3000 * 3}, + {235 * 3, 1345 * 3}})); } TEST(type_prop, depth_to_space_output_shape_block_first_4D) { - auto A = make_shared(element::f32, Shape{1, 128, 8, 8}); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 8); + auto A = make_shared(element::f32, Shape{1, 128, 8, 8}); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 8); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 64, 64})); } TEST(type_prop, depth_to_space_output_shape_block_first_4D_2) { - auto A = make_shared(element::f32, Shape{1, 12, 1080, 1616}); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); + auto A = make_shared(element::f32, Shape{1, 12, 1080, 1616}); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616})); } TEST(type_prop, depth_to_space_output_shape_block_first_5D) { - auto A = make_shared(element::f32, Shape{1, 16, 3, 1080, 1616}); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); + auto A = make_shared(element::f32, Shape{1, 16, 3, 1080, 1616}); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616})); } TEST(type_prop, depth_to_space_output_shape_depth_first_4D) { - auto A = make_shared(element::f32, Shape{1, 12, 1080, 1616}); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); + auto A = make_shared(element::f32, Shape{1, 12, 1080, 1616}); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 3, 2 * 1080, 2 * 1616})); } TEST(type_prop, depth_to_space_output_shape_depth_first_5D) { - auto A = make_shared(element::f32, Shape{1, 16, 3, 1080, 1616}); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); + auto A = make_shared(element::f32, Shape{1, 16, 3, 1080, 1616}); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_shape(), (Shape{1, 2, 2 * 3, 2 * 1080, 2 * 1616})); } TEST(type_prop, depth_to_space_input_rank_not_supported) { - auto A = make_shared(element::f32, Shape{1, 8}); + auto A = make_shared(element::f32, Shape{1, 8}); try { - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); FAIL() << "Not supported input shape for DepthToSpace exception not thrown"; - } catch (const ngraph_error& error) { + } catch (const ov::Exception& error) { EXPECT_HAS_SUBSTRING(error.what(), "The input tensor with rank lower than 3 is not supported (input rank: 2)"); } catch (...) { FAIL() << "DepthToSpace decomposition failed for unexpected reason"; @@ -99,11 +114,12 @@ TEST(type_prop, depth_to_space_input_rank_not_supported) { } TEST(type_prop, depth_to_space_blocksize_not_matched) { - auto A = make_shared(element::f32, Shape{1, 7, 4, 4}); + auto A = make_shared(element::f32, Shape{1, 7, 4, 4}); try { - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); FAIL() << "Not matched blocksize for DepthToSpace exception not thrown"; - } catch (const ngraph_error& error) { + } catch (const ov::Exception& error) { EXPECT_HAS_SUBSTRING(error.what(), "Dimension value: [ 7, 7] must be a multiple of divisor: 4"); } catch (...) { FAIL() << "DepthToSpace decomposition failed for unexpected reason"; @@ -111,16 +127,17 @@ TEST(type_prop, depth_to_space_blocksize_not_matched) { } TEST(type_prop, depth_to_space_dynamic_shape_static_rank) { - auto A = make_shared(element::f32, PartialShape::dynamic(4)); - auto depth_to_space = make_shared(A, op::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); + auto A = make_shared(element::f32, PartialShape::dynamic(4)); + auto depth_to_space = + make_shared(A, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_output_partial_shape(0), PartialShape::dynamic(4)); } TEST(type_prop, depth_to_space_dynamic_shape_dynamic_rank) { - auto A = make_shared(element::f32, PartialShape::dynamic()); - auto depth_to_space = make_shared(A, "depth_first", 2); + auto A = make_shared(element::f32, PartialShape::dynamic()); + auto depth_to_space = make_shared(A, "depth_first", 2); ASSERT_EQ(depth_to_space->get_element_type(), element::f32); ASSERT_EQ(depth_to_space->get_output_partial_shape(0), PartialShape::dynamic()); @@ -128,16 +145,16 @@ TEST(type_prop, depth_to_space_dynamic_shape_dynamic_rank) { TEST(type_prop, depth_to_space_default_ctor) { const auto a_shape = PartialShape{{2, 10}, 27, {0, 54}, {9, -1}}; - const auto A = make_shared(element::u32, a_shape); + const auto A = make_shared(element::u32, a_shape); - const auto depth_to_space = make_shared(); + const auto depth_to_space = make_shared(); depth_to_space->set_block_size(3); - depth_to_space->set_mode(op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); + depth_to_space->set_mode(ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); depth_to_space->set_argument(0, A); depth_to_space->validate_and_infer_types(); EXPECT_EQ(depth_to_space->get_block_size(), 3); - EXPECT_EQ(depth_to_space->get_mode(), op::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); + EXPECT_EQ(depth_to_space->get_mode(), ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST); EXPECT_EQ(depth_to_space->get_input_size(), 1); EXPECT_EQ(depth_to_space->get_output_size(), 1); EXPECT_EQ(depth_to_space->get_output_element_type(0), element::u32); diff --git a/src/core/tests/type_prop/detection_output.cpp b/src/core/tests/type_prop/detection_output.cpp index 02361b12547..ea73870dfdc 100644 --- a/src/core/tests/type_prop/detection_output.cpp +++ b/src/core/tests/type_prop/detection_output.cpp @@ -2,31 +2,31 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "ngraph/op/detection_output.hpp" +#include "openvino/op/detection_output.hpp" + +#include #include #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" #include "openvino/core/dimension_tracker.hpp" #include "openvino/util/common_util.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; // ------------------------------ V0 ------------------------------ -std::shared_ptr create_detection_output(PartialShape box_logits_shape, - PartialShape class_preds_shape, - PartialShape proposals_shape, - PartialShape aux_class_preds_shape, - PartialShape aux_box_preds_shape, - const op::DetectionOutputAttrs& attrs, - element::Type input_type, - element::Type proposals_type, - bool set_labels = false) { +std::shared_ptr create_detection_output(PartialShape box_logits_shape, + PartialShape class_preds_shape, + PartialShape proposals_shape, + PartialShape aux_class_preds_shape, + PartialShape aux_box_preds_shape, + const ov::op::v0::DetectionOutput::Attributes& attrs, + element::Type input_type, + element::Type proposals_type, + bool set_labels = false) { if (set_labels) { // The labels are set for all of the shapes, // but the output dimension is always a product of multiplication, so labels are not preserved @@ -37,25 +37,30 @@ std::shared_ptr create_detection_output(PartialShape box_lo set_shape_labels(aux_box_preds_shape, 50); } - auto box_logits = make_shared(input_type, box_logits_shape); - auto class_preds = make_shared(input_type, class_preds_shape); - auto proposals = make_shared(proposals_type, proposals_shape); - auto aux_class_preds = make_shared(input_type, aux_class_preds_shape); - auto aux_box_preds = make_shared(input_type, aux_box_preds_shape); - return make_shared(box_logits, class_preds, proposals, aux_class_preds, aux_box_preds, attrs); + auto box_logits = make_shared(input_type, box_logits_shape); + auto class_preds = make_shared(input_type, class_preds_shape); + auto proposals = make_shared(proposals_type, proposals_shape); + auto aux_class_preds = make_shared(input_type, aux_class_preds_shape); + auto aux_box_preds = make_shared(input_type, aux_box_preds_shape); + return make_shared(box_logits, + class_preds, + proposals, + aux_class_preds, + aux_box_preds, + attrs); } TEST(type_prop_layers, detection_output_v0_default_ctor) { auto op = make_shared(); auto input_type = element::f32; - auto box_logits = make_shared(input_type, PartialShape{4, 20}); - auto class_preds = make_shared(input_type, PartialShape{4, 10}); - auto proposals = make_shared(input_type, PartialShape{4, 2, 20}); - auto ad_class_preds = make_shared(input_type, PartialShape{4, 10}); - auto ad_box_preds = make_shared(input_type, PartialShape{4, 20}); + auto box_logits = make_shared(input_type, PartialShape{4, 20}); + auto class_preds = make_shared(input_type, PartialShape{4, 10}); + auto proposals = make_shared(input_type, PartialShape{4, 2, 20}); + auto ad_class_preds = make_shared(input_type, PartialShape{4, 10}); + auto ad_box_preds = make_shared(input_type, PartialShape{4, 20}); - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = 7; attrs.num_classes = 2; @@ -80,7 +85,7 @@ TEST(type_prop_layers, detection_output_v0_default_ctor) { } TEST(type_prop_layers, detection_output_basic) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -97,7 +102,7 @@ TEST(type_prop_layers, detection_output_basic) { } TEST(type_prop_layers, detection_output_interval_labeled_keep_top_k) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {60}; attrs.num_classes = 3; attrs.normalized = true; @@ -118,7 +123,7 @@ TEST(type_prop_layers, detection_output_interval_labeled_keep_top_k) { } TEST(type_prop_layers, detection_output_interval_labeled_top_k) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = 80; attrs.num_classes = 3; @@ -140,7 +145,7 @@ TEST(type_prop_layers, detection_output_interval_labeled_top_k) { } TEST(type_prop_layers, detection_output_interval_labeled_negative_both_topk) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = -1; attrs.num_classes = 3; @@ -162,7 +167,7 @@ TEST(type_prop_layers, detection_output_interval_labeled_negative_both_topk) { } TEST(type_prop_layers, detection_output_v0_f16) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -179,7 +184,7 @@ TEST(type_prop_layers, detection_output_v0_f16) { } TEST(type_prop_layers, detection_f16_with_proposals_f32) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -196,7 +201,7 @@ TEST(type_prop_layers, detection_f16_with_proposals_f32) { } TEST(type_prop_layers, detection_output_v0_not_normalized) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = false; @@ -213,7 +218,7 @@ TEST(type_prop_layers, detection_output_v0_not_normalized) { } TEST(type_prop_layers, detection_output_v0_negative_keep_top_k) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = -1; attrs.normalized = true; @@ -231,7 +236,7 @@ TEST(type_prop_layers, detection_output_v0_negative_keep_top_k) { } TEST(type_prop_layers, detection_output_v0_no_share_location) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = -1; attrs.normalized = true; @@ -250,7 +255,7 @@ TEST(type_prop_layers, detection_output_v0_no_share_location) { } TEST(type_prop_layers, detection_output_v0_calculated_num_prior_boxes) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = -1; attrs.normalized = true; @@ -269,7 +274,7 @@ TEST(type_prop_layers, detection_output_v0_calculated_num_prior_boxes) { } TEST(type_prop_layers, detection_output_v0_top_k) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.top_k = 7; attrs.normalized = true; @@ -288,7 +293,7 @@ TEST(type_prop_layers, detection_output_v0_top_k) { TEST(type_prop_layers, detection_output_v0_all_dynamic_shapes) { PartialShape dyn_shape = PartialShape::dynamic(); - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 1; auto op = create_detection_output(dyn_shape, @@ -304,7 +309,7 @@ TEST(type_prop_layers, detection_output_v0_all_dynamic_shapes) { } TEST(type_prop_layers, detection_output_v0_dynamic_batch) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -327,17 +332,21 @@ void detection_output_invalid_data_type_test(element::Type box_logits_et, element::Type aux_box_preds_et, const std::string& expected_msg) { try { - auto box_logits = make_shared(box_logits_et, Shape{4, 20}); - auto class_preds = make_shared(class_preds_et, Shape{4, 10}); - auto proposals = make_shared(proposals_et, Shape{4, 2, 20}); - auto aux_class_preds = make_shared(aux_class_preds_et, Shape{4, 10}); - auto aux_box_preds = make_shared(aux_box_preds_et, Shape{4, 20}); - op::DetectionOutputAttrs attrs; + auto box_logits = make_shared(box_logits_et, Shape{4, 20}); + auto class_preds = make_shared(class_preds_et, Shape{4, 10}); + auto proposals = make_shared(proposals_et, Shape{4, 2, 20}); + auto aux_class_preds = make_shared(aux_class_preds_et, Shape{4, 10}); + auto aux_box_preds = make_shared(aux_box_preds_et, Shape{4, 20}); + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; - auto op = - make_shared(box_logits, class_preds, proposals, aux_class_preds, aux_box_preds, attrs); + auto op = make_shared(box_logits, + class_preds, + proposals, + aux_class_preds, + aux_box_preds, + attrs); FAIL() << "Exception expected"; } catch (const NodeValidationFailure& error) { EXPECT_HAS_SUBSTRING(error.what(), expected_msg); @@ -385,7 +394,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_data_type) { TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) { { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -407,7 +416,7 @@ TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) { } { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -433,7 +442,7 @@ TEST(type_prop_layers, detection_output_v0_mismatched_batch_size) { TEST(type_prop_layers, detection_output_v0_invalid_ranks) { { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -454,7 +463,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_ranks) { } { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -475,7 +484,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_ranks) { } { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {200}; attrs.num_classes = 2; attrs.normalized = true; @@ -500,7 +509,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) { // share_location = true { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -526,7 +535,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) { // share_location = false { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = false; @@ -553,7 +562,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_box_logits_shape) { TEST(type_prop_layers, detection_output_v0_invalid_class_preds_shape) { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; auto op = create_detection_output(Shape{4, 12}, @@ -578,7 +587,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) { // variance_encoded_in_target = false { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -604,7 +613,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) { // variance_encoded_in_target = true { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -630,7 +639,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) { // normalized = false { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -656,7 +665,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_proposals_shape) { // normalized = true { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -685,7 +694,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_class_preds) { // invalid batch size { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -711,7 +720,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_class_preds) { // invalid 2nd dimension { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -741,7 +750,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_box_preds) { // invalid batch size { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -767,7 +776,7 @@ TEST(type_prop_layers, detection_output_v0_invalid_aux_box_preds) { // invalid 2nd dimension { try { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.num_classes = 3; attrs.share_location = true; @@ -808,9 +817,9 @@ std::shared_ptr create_detection_output_v8(PartialShape set_shape_labels(proposals_shape, 30); } - auto box_logits = make_shared(input_type, box_logits_shape); - auto class_preds = make_shared(input_type, class_preds_shape); - auto proposals = make_shared(input_type, proposals_shape); + auto box_logits = make_shared(input_type, box_logits_shape); + auto class_preds = make_shared(input_type, class_preds_shape); + auto proposals = make_shared(input_type, proposals_shape); return make_shared(box_logits, class_preds, proposals, attrs); } @@ -832,11 +841,11 @@ std::shared_ptr create_detection_output2_v8(PartialShap set_shape_labels(aux_box_preds_shape, 50); } - auto box_logits = make_shared(input_type, box_logits_shape); - auto class_preds = make_shared(input_type, class_preds_shape); - auto proposals = make_shared(input_type, proposals_shape); - auto aux_class_preds = make_shared(input_type, aux_class_preds_shape); - auto aux_box_preds = make_shared(input_type, aux_box_preds_shape); + auto box_logits = make_shared(input_type, box_logits_shape); + auto class_preds = make_shared(input_type, class_preds_shape); + auto proposals = make_shared(input_type, proposals_shape); + auto aux_class_preds = make_shared(input_type, aux_class_preds_shape); + auto aux_box_preds = make_shared(input_type, aux_box_preds_shape); return make_shared(box_logits, class_preds, proposals, @@ -1128,11 +1137,11 @@ TEST(type_prop_layers, detection_output_v8_default_ctor) { compute_reference_output_shape(attrs.keep_top_k, attrs.top_k, N, num_classes, num_prior_boxes); auto input_type = element::f32; - auto box_logits = make_shared(input_type, box_logits_shape); - auto class_preds = make_shared(input_type, class_preds_shape); - auto proposals = make_shared(input_type, proposals_shape); - auto ad_class_preds = make_shared(input_type, ad_class_preds_shape); - auto ad_box_preds = make_shared(input_type, box_logits_shape); + auto box_logits = make_shared(input_type, box_logits_shape); + auto class_preds = make_shared(input_type, class_preds_shape); + auto proposals = make_shared(input_type, proposals_shape); + auto ad_class_preds = make_shared(input_type, ad_class_preds_shape); + auto ad_box_preds = make_shared(input_type, box_logits_shape); auto op = make_shared(); op->set_attrs(attrs); @@ -1146,7 +1155,7 @@ TEST(type_prop_layers, detection_output_v8_default_ctor) { } TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_true_shareloc_true) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes @@ -1163,7 +1172,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz } TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_false_shareloc_true) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = false; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes @@ -1180,7 +1189,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz } TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_false_shareloc_false) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = false; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = false; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes @@ -1197,7 +1206,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz } TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normalized_true_shareloc_false) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = false; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes @@ -1213,7 +1222,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_num_prior_boxes_normaliz } TEST(type_prop_layers, detection_output_v8_incompatible_dynamic_num_prior_boxes_normalized_true_shareloc_true) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes @@ -1230,7 +1239,7 @@ TEST(type_prop_layers, detection_output_v8_incompatible_dynamic_num_prior_boxes_ } TEST(type_prop_layers, detection_output_v8_dynamic_range_num_prior_boxes_normalized_true_shareloc_true) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes @@ -1245,7 +1254,7 @@ TEST(type_prop_layers, detection_output_v8_dynamic_range_num_prior_boxes_normali } TEST(type_prop_layers, detection_output_v8_dynamic_num_prior_boxes_normalized_true_shareloc_true) { - op::DetectionOutputAttrs attrs; + ov::op::v0::DetectionOutput::Attributes attrs; attrs.keep_top_k = {-1}; attrs.normalized = true; // If true, prior_box_size = 4, otherwise prior_box_size = 5 attrs.share_location = true; // If true, num_loc_classes = 1, otherwise num_loc_classes = num_classes diff --git a/src/core/tests/type_prop/dft.cpp b/src/core/tests/type_prop/dft.cpp index e9a284436c1..60ec77ee03e 100644 --- a/src/core/tests/type_prop/dft.cpp +++ b/src/core/tests/type_prop/dft.cpp @@ -1,24 +1,15 @@ -//***************************************************************************** -// Copyright 2017-2022 Intel Corporation +// Copyright (C) 2018-2023 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -//***************************************************************************** + +#include "openvino/op/dft.hpp" + +#include #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "openvino/op/constant.hpp" -using namespace ngraph; +using namespace ov; struct ConstantAxesAndConstantSignalSizeTestParams { PartialShape input_shape; @@ -34,15 +25,15 @@ struct ConstantAxesAndConstantSignalSizeTest : ::testing::TestWithParam(element::f32, params.input_shape); - auto axes_input = op::Constant::create(element::i64, params.axes_shape, params.axes); + auto data = std::make_shared(element::f32, params.input_shape); + auto axes_input = ov::op::v0::Constant::create(element::i64, params.axes_shape, params.axes); std::shared_ptr dft; if (params.signal_size.empty()) { dft = std::make_shared(data, axes_input); } else { auto signal_size_input = - op::Constant::create(element::i64, params.signal_size_shape, params.signal_size); + ov::op::v0::Constant::create(element::i64, params.signal_size_shape, params.signal_size); dft = std::make_shared(data, axes_input, signal_size_input); } @@ -187,8 +178,8 @@ TEST(type_prop, dft_dynamic_axes) { const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), Dimension(1, 18)}; - auto data = std::make_shared(element::f32, input_shape); - auto axes_input = std::make_shared(element::i64, axes_shape); + auto data = std::make_shared(element::f32, input_shape); + auto axes_input = std::make_shared(element::i64, axes_shape); auto dft = std::make_shared(data, axes_input); EXPECT_EQ(dft->get_element_type(), element::f32); @@ -206,8 +197,8 @@ struct NonConstantAxesTest : ::testing::TestWithParam TEST_P(NonConstantAxesTest, dft_non_constant_axes) { auto params = GetParam(); - auto data = std::make_shared(element::f32, params.input_shape); - auto axes_input = std::make_shared(element::i64, params.axes_shape); + auto data = std::make_shared(element::f32, params.input_shape); + auto axes_input = std::make_shared(element::i64, params.axes_shape); auto dft = std::make_shared(data, axes_input); EXPECT_EQ(dft->get_element_type(), element::f32); @@ -279,9 +270,9 @@ struct NonConstantSignalSizeTest : ::testing::TestWithParam(element::f32, params.input_shape); - auto axes_input = op::Constant::create(element::i64, params.axes_shape, params.axes); - auto signal_size_input = std::make_shared(element::i64, params.signal_size_shape); + auto data = std::make_shared(element::f32, params.input_shape); + auto axes_input = ov::op::v0::Constant::create(element::i64, params.axes_shape, params.axes); + auto signal_size_input = std::make_shared(element::i64, params.signal_size_shape); auto dft = std::make_shared(data, axes_input, signal_size_input); EXPECT_EQ(dft->get_element_type(), element::f32); @@ -310,10 +301,10 @@ INSTANTIATE_TEST_SUITE_P( PrintToDummyParamName()); TEST(type_prop, dft_invalid_input) { - auto axes = op::Constant::create(element::i64, Shape{2}, {0, 1}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, 1}); try { - auto data = std::make_shared(element::f32, Shape{2}); + auto data = std::make_shared(element::f32, Shape{2}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid input."; } catch (const NodeValidationFailure& error) { @@ -321,7 +312,7 @@ TEST(type_prop, dft_invalid_input) { } try { - auto data = std::make_shared(element::f32, Shape{4, 3}); + auto data = std::make_shared(element::f32, Shape{4, 3}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid input."; } catch (const NodeValidationFailure& error) { @@ -329,7 +320,7 @@ TEST(type_prop, dft_invalid_input) { } try { - auto data = std::make_shared(element::f32, Shape{4, 2}); + auto data = std::make_shared(element::f32, Shape{4, 2}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid input."; } catch (const NodeValidationFailure& error) { @@ -338,10 +329,10 @@ TEST(type_prop, dft_invalid_input) { } TEST(type_prop, dft_invalid_axes) { - auto data = std::make_shared(element::f32, Shape{4, 3, 2}); + auto data = std::make_shared(element::f32, Shape{4, 3, 2}); try { - auto axes = op::Constant::create(element::i64, Shape{1}, {3}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {3}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid axes."; } catch (const NodeValidationFailure& error) { @@ -349,7 +340,7 @@ TEST(type_prop, dft_invalid_axes) { } try { - auto axes = op::Constant::create(element::i64, Shape{1}, {-3}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {-3}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid axes."; } catch (const NodeValidationFailure& error) { @@ -357,7 +348,7 @@ TEST(type_prop, dft_invalid_axes) { } try { - auto axes = op::Constant::create(element::i64, Shape{2}, {0, -2}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, -2}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid axes."; } catch (const NodeValidationFailure& error) { @@ -365,7 +356,7 @@ TEST(type_prop, dft_invalid_axes) { } try { - auto axes = op::Constant::create(element::i64, Shape{1}, {2}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {2}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid axes."; } catch (const NodeValidationFailure& error) { @@ -373,7 +364,7 @@ TEST(type_prop, dft_invalid_axes) { } try { - auto axes = op::Constant::create(element::i64, Shape{1, 2}, {0, 1}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{1, 2}, {0, 1}); auto dft = std::make_shared(data, axes); FAIL() << "DFT node was created with invalid axes."; } catch (const NodeValidationFailure& error) { @@ -382,11 +373,11 @@ TEST(type_prop, dft_invalid_axes) { } TEST(type_prop, dft_invalid_signal_size) { - auto data = std::make_shared(element::f32, Shape{4, 3, 2}); - auto axes = op::Constant::create(element::i64, Shape{1}, {0}); + auto data = std::make_shared(element::f32, Shape{4, 3, 2}); + auto axes = ov::op::v0::Constant::create(element::i64, Shape{1}, {0}); try { - auto signal_size = op::Constant::create(element::i64, Shape{1, 2}, {0, 1}); + auto signal_size = ov::op::v0::Constant::create(element::i64, Shape{1, 2}, {0, 1}); auto dft = std::make_shared(data, axes, signal_size); FAIL() << "DFT node was created with invalid signal size."; } catch (const NodeValidationFailure& error) { @@ -394,7 +385,7 @@ TEST(type_prop, dft_invalid_signal_size) { } try { - auto signal_size = op::Constant::create(element::i64, Shape{2}, {0, 1}); + auto signal_size = ov::op::v0::Constant::create(element::i64, Shape{2}, {0, 1}); auto dft = std::make_shared(data, axes, signal_size); FAIL() << "DFT node was created with invalid signal size."; } catch (const NodeValidationFailure& error) { @@ -408,9 +399,9 @@ TEST(type_prop, dft_dynamic_types) { const auto signal_size_shape = PartialShape::dynamic(); const auto ref_output_shape = PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), 2}; - auto data = std::make_shared(element::dynamic, input_shape); - auto axes_input = std::make_shared(element::dynamic, axes_shape); - auto signal_size_input = std::make_shared(element::dynamic, signal_size_shape); + auto data = std::make_shared(element::dynamic, input_shape); + auto axes_input = std::make_shared(element::dynamic, axes_shape); + auto signal_size_input = std::make_shared(element::dynamic, signal_size_shape); auto dft = std::make_shared(data, axes_input, signal_size_input); EXPECT_EQ(dft->get_element_type(), element::dynamic); diff --git a/src/core/tests/type_prop/dyn_reshape.cpp b/src/core/tests/type_prop/dyn_reshape.cpp index 37a3b0c9d33..6d018b4ef14 100644 --- a/src/core/tests/type_prop/dyn_reshape.cpp +++ b/src/core/tests/type_prop/dyn_reshape.cpp @@ -2,27 +2,29 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "openvino/op/constant.hpp" +#include "openvino/op/reshape.hpp" using namespace std; -using namespace ngraph; +using namespace ov; TEST(type_prop, reshape_v1_arg_rank_static_pattern_zero) { - auto arg = make_shared(element::f32, Shape{2, 0, 2, 8}); - auto pattern = op::Constant::create(element::i64, Shape{4}, {1, 2, 0, 32}); + auto arg = make_shared(element::f32, Shape{2, 0, 2, 8}); + auto pattern = ov::op::v0::Constant::create(element::i64, Shape{4}, {1, 2, 0, 32}); auto reshape_v1_static = make_shared(arg, pattern, true); EXPECT_EQ(reshape_v1_static->get_output_shape(0), Shape({1, 2, 2, 32})); - auto dynamic_arg = make_shared(element::f32, PartialShape::dynamic()); + auto dynamic_arg = make_shared(element::f32, PartialShape::dynamic()); auto reshape_v1_dynamic = make_shared(dynamic_arg, pattern, true); EXPECT_TRUE( reshape_v1_dynamic->get_output_partial_shape(0).same_scheme(PartialShape{1, 2, Dimension::dynamic(), 32})); try { - auto static_shape_parameter = make_shared(element::f32, Shape{1, 2, 3, 4}); - auto reshape_output_pattern = op::Constant::create(element::i64, Shape{4}, {2, 2, 3, 4}); + auto static_shape_parameter = make_shared(element::f32, Shape{1, 2, 3, 4}); + auto reshape_output_pattern = ov::op::v0::Constant::create(element::i64, Shape{4}, {2, 2, 3, 4}); auto reshape = make_shared(static_shape_parameter, reshape_output_pattern, true); FAIL() << "Expected failure on reshape construction"; } catch (const NodeValidationFailure& error) { diff --git a/src/core/tests/type_prop/einsum.cpp b/src/core/tests/type_prop/einsum.cpp index f0371f20402..ebbb189d03e 100644 --- a/src/core/tests/type_prop/einsum.cpp +++ b/src/core/tests/type_prop/einsum.cpp @@ -2,29 +2,31 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/einsum.hpp" + +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gmock/gmock.h" -#include "ngraph/ngraph.hpp" #include "openvino/core/dimension_tracker.hpp" #include "openvino/pass/graph_rewrite.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; namespace { constexpr size_t exp_einsum_outputs_count = 1; } -class TypePropEinsumTest : public TypePropOpTest { +class TypePropEinsumTest : public TypePropOpTest { protected: template OutputVector make_inputs(const element::Type dtype, ShapeContainer&& input_shapes) const { OutputVector inputs; inputs.reserve(input_shapes.size()); for (auto&& shape : input_shapes) { - inputs.push_back(std::make_shared(dtype, shape)); + inputs.push_back(std::make_shared(dtype, shape)); } return inputs; } @@ -58,7 +60,7 @@ TEST_F(TypePropEinsumTest, static_shape_trace) { const std::string equation = "kii->k"; constexpr auto et = element::f32; - const auto input = make_shared(et, Shape{2, 3, 3}); + const auto input = make_shared(et, Shape{2, 3, 3}); const auto o = make_op(OutputVector{input}, equation); EXPECT_EQ(o->get_equation(), equation); @@ -71,7 +73,7 @@ TEST_F(TypePropEinsumTest, static_shape_diag_extraction) { const std::string equation = "kii->ki"; constexpr auto et = element::f32; - const auto input = make_shared(et, Shape{2, 3, 3}); + const auto input = make_shared(et, Shape{2, 3, 3}); const auto o = make_op(OutputVector{input}, equation); EXPECT_EQ(o->get_equation(), equation); @@ -84,7 +86,7 @@ TEST_F(TypePropEinsumTest, static_shape_transpose) { const std::string equation = "ijk->kij"; constexpr auto et = element::f32; - const auto input = make_shared(et, Shape{1, 2, 3}); + const auto input = make_shared(et, Shape{1, 2, 3}); const auto o = make_op(OutputVector{input}, equation); EXPECT_EQ(o->get_equation(), equation); @@ -109,7 +111,7 @@ TEST_F(TypePropEinsumTest, static_shape_ellipsis_one_input) { const std::string equation = "a...->..."; constexpr auto et = element::f32; - const auto input = make_shared(et, Shape{5, 3}); + const auto input = make_shared(et, Shape{5, 3}); const auto o = make_op(OutputVector{input}, equation); EXPECT_EQ(o->get_equation(), equation); @@ -167,7 +169,7 @@ TEST_F(TypePropEinsumTest, dynamic_shape_diag_extraction) { auto input_shape = PartialShape{{2, 7}, {1, 5}, 4, {3, 5}, 3}; set_shape_labels(input_shape, 10); - const auto input = make_shared(et, input_shape); + const auto input = make_shared(et, input_shape); const auto o = make_op(OutputVector{input}, equation); EXPECT_EQ(o->get_equation(), equation); @@ -201,7 +203,7 @@ TEST_F(TypePropEinsumTest, implicit_mode_mixed_case_letters) { auto input_shape = PartialShape{1, {2, 3}, {4, 5}}; set_shape_labels(input_shape, 10); - const auto input = make_shared(et, input_shape); + const auto input = make_shared(et, input_shape); const auto o = make_op(OutputVector{input}, equation); EXPECT_EQ(o->get_equation(), equation); @@ -337,7 +339,7 @@ TEST_F(TypePropEinsumTest, incorrect_equation_invalid_labels) { const auto inputs = make_inputs(element::f32, input_shapes); OV_EXPECT_THROW(auto o = make_op(inputs, equation), - CheckFailure, + AssertFailure, HasSubstr("Input subscript of Einsum equation must consist of either only alphabetic " "letters or alphabetic letters with one ellipsis.")); } @@ -349,7 +351,7 @@ TEST_F(TypePropEinsumTest, incorrect_equation_incompatible_shapes) { const auto inputs = make_inputs(element::f32, input_shapes); OV_EXPECT_THROW(auto o = make_op(inputs, equation), - CheckFailure, + AssertFailure, HasSubstr("Different input dimensions indicated by the same labels " "for Einsum must be compatible.")); } @@ -372,7 +374,7 @@ TEST_F(TypePropEinsumTest, incorrect_equation_missed_ellipsis) { const auto inputs = make_inputs(element::f32, input_shapes); OV_EXPECT_THROW(auto o = make_op(inputs, equation), - CheckFailure, + AssertFailure, HasSubstr("Output subscript of Einsum equation must contain one " "ellipsis if ellipsis is met in any input subscript.")); } diff --git a/src/core/tests/type_prop/elu.cpp b/src/core/tests/type_prop/elu.cpp index 28a4478bfda..df6c57a2a24 100644 --- a/src/core/tests/type_prop/elu.cpp +++ b/src/core/tests/type_prop/elu.cpp @@ -2,17 +2,18 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/elu.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; TEST(type_prop, elu) { - Shape data_shape{2, 4}; - auto data = make_shared(element::f32, data_shape); - auto elu = make_shared(data, 1); - ASSERT_EQ(elu->get_element_type(), element::f32); + ov::Shape data_shape{2, 4}; + auto data = make_shared(ov::element::f32, data_shape); + auto elu = make_shared(data, 1); + ASSERT_EQ(elu->get_element_type(), ov::element::f32); ASSERT_EQ(elu->get_shape(), data_shape); } diff --git a/src/core/tests/type_prop/embedding_segments_sum.cpp b/src/core/tests/type_prop/embedding_segments_sum.cpp index 26041fdbbc7..4a8b41e80ab 100644 --- a/src/core/tests/type_prop/embedding_segments_sum.cpp +++ b/src/core/tests/type_prop/embedding_segments_sum.cpp @@ -2,24 +2,27 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/embedding_segments_sum.hpp" + +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" -#include "ngraph/op/constant.hpp" -#include "ngraph/opsets/opset3.hpp" +#include "openvino/op/constant.hpp" +#include "openvino/op/shape_of.hpp" +#include "openvino/op/squeeze.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, ess_default_ctor) { - auto emb_table = make_shared(element::f32, Shape{5, 2, 6}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2, 6}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto op = make_shared(); op->set_arguments(OutputVector{emb_table, indices, segment_ids, num_segments, default_index, per_sample_weights}); @@ -30,12 +33,12 @@ TEST(type_prop, ess_default_ctor) { } TEST(type_prop, ess) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto ess = make_shared(emb_table, indices, @@ -51,12 +54,12 @@ TEST(type_prop, ess) { } TEST(type_prop, ess_dynamic_emb_table_number_segment) { - auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto ess = make_shared(emb_table, indices, @@ -69,12 +72,12 @@ TEST(type_prop, ess_dynamic_emb_table_number_segment) { } TEST(type_prop, ess_fail_indices_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::f32, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::f32, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -92,12 +95,12 @@ TEST(type_prop, ess_fail_indices_element_type) { } TEST(type_prop, ess_fail_segment_ids_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::f32, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::f32, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -115,12 +118,12 @@ TEST(type_prop, ess_fail_segment_ids_element_type) { } TEST(type_prop, ess_fail_number_segments_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::f32, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::f32, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -138,12 +141,12 @@ TEST(type_prop, ess_fail_number_segments_element_type) { } TEST(type_prop, ess_fail_default_index_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::f32, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::f32, Shape{}); try { auto ess = make_shared(emb_table, @@ -161,12 +164,12 @@ TEST(type_prop, ess_fail_default_index_element_type) { } TEST(type_prop, ess_fail_mismatch_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i32, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i32, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -185,12 +188,12 @@ TEST(type_prop, ess_fail_mismatch_element_type) { } TEST(type_prop, ess_fail_mismatch_element_type_1) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i32, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i32, Shape{}); try { auto ess = make_shared(emb_table, @@ -209,12 +212,12 @@ TEST(type_prop, ess_fail_mismatch_element_type_1) { } TEST(type_prop, ess_fail_mismatch_element_type_2) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::i64, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::i64, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -234,12 +237,12 @@ TEST(type_prop, ess_fail_mismatch_element_type_2) { } TEST(type_prop, ess_fail_mismatch_element_type_3) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i32, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i32, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -258,12 +261,12 @@ TEST(type_prop, ess_fail_mismatch_element_type_3) { } TEST(type_prop, ess_fail_mismatch_shape) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{3}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{3}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -281,12 +284,12 @@ TEST(type_prop, ess_fail_mismatch_shape) { } TEST(type_prop, ess_fail_num_segments_scalar) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{2}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{2}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -304,12 +307,12 @@ TEST(type_prop, ess_fail_num_segments_scalar) { } TEST(type_prop, ess_fail_default_index_scalar) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{2}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{2}); try { auto ess = make_shared(emb_table, @@ -327,12 +330,12 @@ TEST(type_prop, ess_fail_default_index_scalar) { } TEST(type_prop, ess_fail_indices_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4, 2}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4, 2}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -350,12 +353,12 @@ TEST(type_prop, ess_fail_indices_1d) { } TEST(type_prop, ess_fail_segment_ids_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{3, 2}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{3, 2}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -373,12 +376,12 @@ TEST(type_prop, ess_fail_segment_ids_1d) { } TEST(type_prop, ess_fail_per_sample_weights_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4, 2}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4, 2}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, @@ -396,12 +399,12 @@ TEST(type_prop, ess_fail_per_sample_weights_1d) { } TEST(type_prop, ess_fail_emb_table_0d) { - auto emb_table = make_shared(element::f32, Shape{}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); OV_EXPECT_THROW(auto op = make_shared(emb_table, indices, @@ -414,10 +417,10 @@ TEST(type_prop, ess_fail_emb_table_0d) { } TEST(type_prop, ess_4_args_api) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); auto ess = make_shared(emb_table, indices, segment_ids, num_segments); EXPECT_TRUE(ess->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 2})); @@ -427,10 +430,10 @@ TEST(type_prop, ess_4_args_api) { } TEST(type_prop, ess_fail_indices_element_type_4_args_api) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::f32, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::f32, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = make_shared(element::i64, Shape{}); try { auto ess = make_shared(emb_table, indices, segment_ids, num_segments); @@ -443,10 +446,10 @@ TEST(type_prop, ess_fail_indices_element_type_4_args_api) { } TEST(type_prop, ess_num_segment_const) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); - auto num_segments = opset3::Constant::create(element::i64, Shape{}, {3}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); + auto num_segments = ov::op::v0::Constant::create(element::i64, Shape{}, {3}); auto ess = make_shared(emb_table, indices, segment_ids, num_segments); EXPECT_TRUE(ess->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); @@ -461,13 +464,13 @@ TEST(type_prop, ess_num_segment_interval_label_propagation) { auto num_segm_shape = PartialShape{{6, 8}}; set_shape_labels(num_segm_shape, 20); - auto num_segments = make_shared(element::i64, num_segm_shape); + auto num_segments = make_shared(element::i64, num_segm_shape); auto shape_of = make_shared(num_segments); auto num_segm_squeeze = make_shared(shape_of); - auto emb_table = make_shared(element::f32, emb_shape); - auto indices = make_shared(element::i64, Shape{4}); - auto segment_ids = make_shared(element::i64, Shape{4}); + auto emb_table = make_shared(element::f32, emb_shape); + auto indices = make_shared(element::i64, Shape{4}); + auto segment_ids = make_shared(element::i64, Shape{4}); auto op = make_shared(emb_table, indices, segment_ids, num_segm_squeeze); EXPECT_EQ(op->get_output_element_type(0), element::f32); diff --git a/src/core/tests/type_prop/embeddingbag_offsetssum.cpp b/src/core/tests/type_prop/embeddingbag_offsetssum.cpp index b4e4b6bc291..86359c8e2b3 100644 --- a/src/core/tests/type_prop/embeddingbag_offsetssum.cpp +++ b/src/core/tests/type_prop/embeddingbag_offsetssum.cpp @@ -2,21 +2,22 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" +#include "openvino/op/embeddingbag_offsets_sum.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, ebos_default_ctor) { - auto emb_table = make_shared(element::f32, Shape{5, 2, 6}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2, 6}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto op = make_shared(); op->set_arguments(OutputVector{emb_table, indices, offsets, default_index, per_sample_weights}); @@ -32,11 +33,11 @@ TEST(type_prop, ebos_labeled_interval_dims) { auto off_shape = PartialShape{{6, 8}}; set_shape_labels(off_shape, 20); - auto emb_table = make_shared(element::f32, emb_shape); - auto indices = make_shared(element::i64, PartialShape{{3, 4}}); - auto offsets = make_shared(element::i64, off_shape); - auto per_sample_weights = make_shared(element::f32, PartialShape{{3, 4}}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, emb_shape); + auto indices = make_shared(element::i64, PartialShape{{3, 4}}); + auto offsets = make_shared(element::i64, off_shape); + auto per_sample_weights = make_shared(element::f32, PartialShape{{3, 4}}); + auto default_index = make_shared(element::i64, Shape{}); auto op = make_shared(emb_table, indices, offsets, default_index, per_sample_weights); @@ -46,11 +47,11 @@ TEST(type_prop, ebos_labeled_interval_dims) { } TEST(type_prop, ebos) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto ebos = make_shared(emb_table, indices, offsets, default_index, per_sample_weights); @@ -62,11 +63,11 @@ TEST(type_prop, ebos) { } TEST(type_prop, ebos_dynamic_emb_table) { - auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto ebos = make_shared(emb_table, indices, offsets, default_index, per_sample_weights); @@ -75,11 +76,11 @@ TEST(type_prop, ebos_dynamic_emb_table) { } TEST(type_prop, ebos_dynamic_offsets) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, PartialShape{Dimension::dynamic()}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, PartialShape{Dimension::dynamic()}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto ebos = make_shared(emb_table, indices, offsets, default_index, per_sample_weights); @@ -88,11 +89,11 @@ TEST(type_prop, ebos_dynamic_offsets) { } TEST(type_prop, ebos_dynamic_emb_table_offsets) { - auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, PartialShape{Dimension::dynamic()}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, PartialShape{Dimension::dynamic()}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); auto ebos = make_shared(emb_table, indices, offsets, default_index, per_sample_weights); @@ -102,11 +103,11 @@ TEST(type_prop, ebos_dynamic_emb_table_offsets) { } TEST(type_prop, ebos_fail_indices_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::f32, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::f32, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -120,11 +121,11 @@ TEST(type_prop, ebos_fail_indices_element_type) { } TEST(type_prop, ebos_fail_offsets_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::f32, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::f32, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -138,11 +139,11 @@ TEST(type_prop, ebos_fail_offsets_element_type) { } TEST(type_prop, ebos_fail_default_index_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::f32, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::f32, Shape{}); try { auto ebos = @@ -156,11 +157,11 @@ TEST(type_prop, ebos_fail_default_index_element_type) { } TEST(type_prop, ebos_fail_mismatch_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i32, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i32, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -175,11 +176,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type) { } TEST(type_prop, ebos_fail_mismatch_element_type_1) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i32, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i32, Shape{}); try { auto ebos = @@ -194,11 +195,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type_1) { } TEST(type_prop, ebos_fail_mismatch_element_type_2) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::i64, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::i64, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -214,11 +215,11 @@ TEST(type_prop, ebos_fail_mismatch_element_type_2) { } TEST(type_prop, ebos_fail_mismatch_shape) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{3}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{3}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -232,11 +233,11 @@ TEST(type_prop, ebos_fail_mismatch_shape) { } TEST(type_prop, ebos_fail_default_index_scalar) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{2}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{2}); try { auto ebos = @@ -250,11 +251,11 @@ TEST(type_prop, ebos_fail_default_index_scalar) { } TEST(type_prop, ebos_fail_indices_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4, 2}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4, 2}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -268,11 +269,11 @@ TEST(type_prop, ebos_fail_indices_1d) { } TEST(type_prop, ebos_fail_emb_table_0d) { - auto emb_table = make_shared(element::f32, Shape{}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); OV_EXPECT_THROW( auto op = @@ -282,11 +283,11 @@ TEST(type_prop, ebos_fail_emb_table_0d) { } TEST(type_prop, ebos_fail_offsets_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3, 2}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3, 2}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -300,11 +301,11 @@ TEST(type_prop, ebos_fail_offsets_1d) { } TEST(type_prop, ebos_fail_per_sample_weights_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); - auto per_sample_weights = make_shared(element::f32, Shape{4, 2}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); + auto per_sample_weights = make_shared(element::f32, Shape{4, 2}); + auto default_index = make_shared(element::i64, Shape{}); try { auto ebos = @@ -318,9 +319,9 @@ TEST(type_prop, ebos_fail_per_sample_weights_1d) { } TEST(type_prop, ebos_3_args_api) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); auto ebos = make_shared(emb_table, indices, offsets); EXPECT_TRUE(ebos->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); @@ -330,9 +331,9 @@ TEST(type_prop, ebos_3_args_api) { } TEST(type_prop, ebos_fail_indices_element_type_3_args_api) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::f32, Shape{4}); - auto offsets = make_shared(element::i64, Shape{3}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::f32, Shape{4}); + auto offsets = make_shared(element::i64, Shape{3}); try { auto ebos = make_shared(emb_table, indices, offsets); diff --git a/src/core/tests/type_prop/embeddingbag_packedsum.cpp b/src/core/tests/type_prop/embeddingbag_packedsum.cpp index 40da2daeb41..2da948a764b 100644 --- a/src/core/tests/type_prop/embeddingbag_packedsum.cpp +++ b/src/core/tests/type_prop/embeddingbag_packedsum.cpp @@ -2,19 +2,21 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/embeddingbag_packedsum.hpp" + +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; +using namespace ov; using namespace testing; TEST(type_prop, ebps_default_ctor) { - auto emb_table = make_shared(element::f32, Shape{5, 2, 6}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2, 6}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); auto op = make_shared(); op->set_arguments(OutputVector{emb_table, indices, per_sample_weights}); @@ -30,8 +32,8 @@ TEST(type_prop, ebps_labeled_interval_dims_2in) { auto ind_shape = PartialShape{{6, 8}, 4}; set_shape_labels(ind_shape, 20); - auto emb_table = make_shared(element::f32, emb_shape); - auto indices = make_shared(element::i64, ind_shape); + auto emb_table = make_shared(element::f32, emb_shape); + auto indices = make_shared(element::i64, ind_shape); auto op = make_shared(emb_table, indices); EXPECT_EQ(op->get_output_element_type(0), element::f32); @@ -47,9 +49,9 @@ TEST(type_prop, ebps_labeled_interval_dims_3in) { auto sample_shape = PartialShape{{4, 8}, 4}; set_shape_labels(sample_shape, 30); - auto emb_table = make_shared(element::f32, emb_shape); - auto indices = make_shared(element::i64, ind_shape); - auto per_sample_weights = make_shared(element::f32, sample_shape); + auto emb_table = make_shared(element::f32, emb_shape); + auto indices = make_shared(element::i64, ind_shape); + auto per_sample_weights = make_shared(element::f32, sample_shape); auto op = make_shared(emb_table, indices, per_sample_weights); EXPECT_EQ(op->get_output_element_type(0), element::f32); @@ -58,9 +60,9 @@ TEST(type_prop, ebps_labeled_interval_dims_3in) { } TEST(type_prop, ebps) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); auto ebps = make_shared(emb_table, indices, per_sample_weights); EXPECT_TRUE(ebps->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); @@ -70,10 +72,10 @@ TEST(type_prop, ebps) { } TEST(type_prop, ebps_dynamic_emb_table) { - auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); - auto default_index = make_shared(element::i64, Shape{}); + auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); + auto default_index = make_shared(element::i64, Shape{}); auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -81,9 +83,9 @@ TEST(type_prop, ebps_dynamic_emb_table) { } TEST(type_prop, ebps_dynamic_indices) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, PartialShape{Dimension::dynamic(), 4}); - auto per_sample_weights = make_shared(element::f32, PartialShape{Dimension::dynamic(), 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, PartialShape{Dimension::dynamic(), 4}); + auto per_sample_weights = make_shared(element::f32, PartialShape{Dimension::dynamic(), 4}); auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -91,9 +93,9 @@ TEST(type_prop, ebps_dynamic_indices) { } TEST(type_prop, ebps_dynamic_emb_table_indices) { - auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); - auto indices = make_shared(element::i64, PartialShape{Dimension::dynamic(), 4}); - auto per_sample_weights = make_shared(element::f32, PartialShape{Dimension::dynamic(), 4}); + auto emb_table = make_shared(element::f32, PartialShape{5, Dimension::dynamic()}); + auto indices = make_shared(element::i64, PartialShape{Dimension::dynamic(), 4}); + auto per_sample_weights = make_shared(element::f32, PartialShape{Dimension::dynamic(), 4}); auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -102,9 +104,9 @@ TEST(type_prop, ebps_dynamic_emb_table_indices) { } TEST(type_prop, ebps_fail_indices_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::f32, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::f32, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); try { auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -117,9 +119,9 @@ TEST(type_prop, ebps_fail_indices_element_type) { } TEST(type_prop, ebps_fail_mismatch_element_type) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::i64, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::i64, Shape{3, 4}); try { auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -134,9 +136,9 @@ TEST(type_prop, ebps_fail_mismatch_element_type) { } TEST(type_prop, ebps_fail_mismatch_shape) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{4, 3}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{4, 3}); try { auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -149,9 +151,9 @@ TEST(type_prop, ebps_fail_mismatch_shape) { } TEST(type_prop, ebps_fail_indices_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{4}); - auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{4}); + auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); try { auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -164,9 +166,9 @@ TEST(type_prop, ebps_fail_indices_1d) { } TEST(type_prop, ebps_fail_emb_table_0d) { - auto emb_table = make_shared(element::f32, Shape{}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{3, 4}); OV_EXPECT_THROW(auto op = make_shared(emb_table, indices, per_sample_weights), NodeValidationFailure, @@ -174,9 +176,9 @@ TEST(type_prop, ebps_fail_emb_table_0d) { } TEST(type_prop, ebps_fail_per_sample_weights_1d) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{3, 4}); - auto per_sample_weights = make_shared(element::f32, Shape{4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{3, 4}); + auto per_sample_weights = make_shared(element::f32, Shape{4}); try { auto ebps = make_shared(emb_table, indices, per_sample_weights); @@ -189,8 +191,8 @@ TEST(type_prop, ebps_fail_per_sample_weights_1d) { } TEST(type_prop, ebps_2_args_api) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::i64, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::i64, Shape{3, 4}); auto ebps = make_shared(emb_table, indices); EXPECT_TRUE(ebps->get_output_partial_shape(0).same_scheme(PartialShape{3, 2})); @@ -199,8 +201,8 @@ TEST(type_prop, ebps_2_args_api) { } TEST(type_prop, ebps_fail_indices_element_type_2_args_api) { - auto emb_table = make_shared(element::f32, Shape{5, 2}); - auto indices = make_shared(element::f32, Shape{3, 4}); + auto emb_table = make_shared(element::f32, Shape{5, 2}); + auto indices = make_shared(element::f32, Shape{3, 4}); try { auto ebps = make_shared(emb_table, indices); diff --git a/src/core/tests/type_prop/erf.cpp b/src/core/tests/type_prop/erf.cpp index f904979300b..20696b4241f 100644 --- a/src/core/tests/type_prop/erf.cpp +++ b/src/core/tests/type_prop/erf.cpp @@ -4,6 +4,6 @@ #include "unary_ops.hpp" -using Type = ::testing::Types; +using Type = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_erf, UnaryOperator, Type); diff --git a/src/core/tests/type_prop/exp.cpp b/src/core/tests/type_prop/exp.cpp index 29581de6c5a..c1188c53bc4 100644 --- a/src/core/tests/type_prop/exp.cpp +++ b/src/core/tests/type_prop/exp.cpp @@ -4,6 +4,6 @@ #include "unary_ops.hpp" -using Type = ::testing::Types; +using Type = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_exp, UnaryOperator, Type); diff --git a/src/core/tests/type_prop/experimental_detectron_detection_output.cpp b/src/core/tests/type_prop/experimental_detectron_detection_output.cpp index 13f645d525d..dfcb17aae0c 100644 --- a/src/core/tests/type_prop/experimental_detectron_detection_output.cpp +++ b/src/core/tests/type_prop/experimental_detectron_detection_output.cpp @@ -2,9 +2,10 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gmock/gmock.h" #include "openvino/opsets/opset11.hpp" using namespace ov; diff --git a/src/core/tests/type_prop/experimental_detectron_generate_proposals.cpp b/src/core/tests/type_prop/experimental_detectron_generate_proposals.cpp index e3b432afc44..a95aa022c3c 100644 --- a/src/core/tests/type_prop/experimental_detectron_generate_proposals.cpp +++ b/src/core/tests/type_prop/experimental_detectron_generate_proposals.cpp @@ -2,11 +2,12 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gmock/gmock.h" #include "openvino/opsets/opset11.hpp" using namespace ov; diff --git a/src/core/tests/type_prop/experimental_detectron_prior_grid_generator.cpp b/src/core/tests/type_prop/experimental_detectron_prior_grid_generator.cpp index 6e0ca75bfc2..0a88a2a7a99 100644 --- a/src/core/tests/type_prop/experimental_detectron_prior_grid_generator.cpp +++ b/src/core/tests/type_prop/experimental_detectron_prior_grid_generator.cpp @@ -2,9 +2,10 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gmock/gmock.h" #include "openvino/opsets/opset11.hpp" using namespace ov; diff --git a/src/core/tests/type_prop/experimental_detectron_roi_feature_extractor.cpp b/src/core/tests/type_prop/experimental_detectron_roi_feature_extractor.cpp index bddd4efd79d..7aed790d1a0 100644 --- a/src/core/tests/type_prop/experimental_detectron_roi_feature_extractor.cpp +++ b/src/core/tests/type_prop/experimental_detectron_roi_feature_extractor.cpp @@ -2,11 +2,12 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gmock/gmock.h" #include "openvino/opsets/opset11.hpp" using namespace ov; diff --git a/src/core/tests/type_prop/experimental_detectron_topkrois.cpp b/src/core/tests/type_prop/experimental_detectron_topkrois.cpp index 5cc0c673414..ce6dba3b855 100644 --- a/src/core/tests/type_prop/experimental_detectron_topkrois.cpp +++ b/src/core/tests/type_prop/experimental_detectron_topkrois.cpp @@ -2,9 +2,10 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" #include "openvino/opsets/opset11.hpp" using namespace ov; diff --git a/src/core/tests/type_prop/eye.cpp b/src/core/tests/type_prop/eye.cpp index 59a3f4f0330..f69d0e135e1 100644 --- a/src/core/tests/type_prop/eye.cpp +++ b/src/core/tests/type_prop/eye.cpp @@ -2,10 +2,11 @@ // SPDX-License-Identifier: Apache-2.0 // +#include + #include "common_test_utils/test_assertions.hpp" #include "common_test_utils/type_prop.hpp" #include "eye_shape_inference.hpp" -#include "gtest/gtest.h" #include "openvino/core/dimension_tracker.hpp" #include "openvino/opsets/opset10.hpp" diff --git a/src/core/tests/type_prop/fake_quantize.cpp b/src/core/tests/type_prop/fake_quantize.cpp index 4b7a7ce39e5..2b5cbe9f387 100644 --- a/src/core/tests/type_prop/fake_quantize.cpp +++ b/src/core/tests/type_prop/fake_quantize.cpp @@ -2,52 +2,54 @@ // SPDX-License-Identifier: Apache-2.0 // +#include "openvino/op/fake_quantize.hpp" + +#include + #include "common_test_utils/type_prop.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" using namespace std; -using namespace ngraph; +using namespace ov; TEST(type_prop, fake_quantize) { - const auto data = make_shared(element::f32, Shape{1, 2, 3, 4}); - const auto input_low = make_shared(element::f32, Shape{}); - const auto input_high = make_shared(element::f32, Shape{}); - const auto output_low = make_shared(element::f32, Shape{}); - const auto output_high = make_shared(element::f32, Shape{}); + const auto data = make_shared(element::f32, Shape{1, 2, 3, 4}); + const auto input_low = make_shared(element::f32, Shape{}); + const auto input_high = make_shared(element::f32, Shape{}); + const auto output_low = make_shared(element::f32, Shape{}); + const auto output_high = make_shared(element::f32, Shape{}); const size_t levels = 5; const auto fake_quantize = - make_shared(data, input_low, input_high, output_low, output_high, levels); + make_shared(data, input_low, input_high, output_low, output_high, levels); EXPECT_EQ(fake_quantize->get_element_type(), element::f32); EXPECT_EQ(fake_quantize->get_shape(), (Shape{1, 2, 3, 4})); } TEST(type_prop, fake_quantize_autob) { - const auto data = make_shared(element::f32, Shape{1, 2, 3, 4}); - const auto input_low = make_shared(element::f32, Shape{3, 1}); - const auto input_high = make_shared(element::f32, Shape{1, 2, 3, 4}); - const auto output_low = make_shared(element::f32, Shape{4}); - const auto output_high = make_shared(element::f32, Shape{}); + const auto data = make_shared(element::f32, Shape{1, 2, 3, 4}); + const auto input_low = make_shared(element::f32, Shape{3, 1}); + const auto input_high = make_shared(element::f32, Shape{1, 2, 3, 4}); + const auto output_low = make_shared(element::f32, Shape{4}); + const auto output_high = make_shared(element::f32, Shape{}); const size_t levels = 5; const auto fake_quantize = - make_shared(data, input_low, input_high, output_low, output_high, levels); + make_shared(data, input_low, input_high, output_low, output_high, levels); EXPECT_EQ(fake_quantize->get_element_type(), element::f32); EXPECT_EQ(fake_quantize->get_shape(), (Shape{1, 2, 3, 4})); } TEST(type_prop, fake_quantize_invalid_autob) { - const auto data = make_shared(element::f32, Shape{1, 2, 3, 4}); - auto input_low = make_shared(element::f32, Shape{3}); - auto input_high = make_shared(element::f32, Shape{}); - auto output_low = make_shared(element::f32, Shape{}); - auto output_high = make_shared(element::f32, Shape{}); + const auto data = make_shared(element::f32, Shape{1, 2, 3, 4}); + auto input_low = make_shared(element::f32, Shape{3}); + auto input_high = make_shared(element::f32, Shape{}); + auto output_low = make_shared(element::f32, Shape{}); + auto output_high = make_shared(element::f32, Shape{}); const size_t levels = 5; try { const auto fake_quantize = - make_shared(data, input_low, input_high, output_low, output_high, levels); + make_shared(data, input_low, input_high, output_low, output_high, levels); EXPECT_FALSE(fake_quantize.get()) << "FakeQuantize validation did not work. Op node was created with incorrect params."; } catch (const NodeValidationFailure& error) { diff --git a/src/core/tests/type_prop/floor.cpp b/src/core/tests/type_prop/floor.cpp index cbbf22cba60..68c08afbe8b 100644 --- a/src/core/tests/type_prop/floor.cpp +++ b/src/core/tests/type_prop/floor.cpp @@ -4,6 +4,6 @@ #include "unary_ops.hpp" -using Type = ::testing::Types; +using Type = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_floor, UnaryOperator, Type);