remove reader tests #3

src/core/tests/CMakeLists.txt

@@ -263,6 +263,7 @@ set(SRC
     visitors/dimension.cpp
     visitors/user_op.cpp
     visitors/value_map.cpp
+    visitors/op/abs.cpp
     visitors/op/acos.cpp
     visitors/op/acosh.cpp
     visitors/op/adaptive_avg_pool.cpp

src/core/tests/visitors/op/abs.cpp

@@ -0,0 +1,9 @@
+// Copyright (C) 2018-2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "unary_ops.hpp"
+
+using Type = ::testing::Types<UnaryOperatorType<ngraph::op::Abs, ngraph::element::f32>>;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(visitor_without_attribute, UnaryOperatorVisitor, Type, UnaryOperatorTypeName);

src/core/tests/visitors/op/convolution.cpp

@@ -40,3 +40,27 @@ TEST(attributes, convolution) {
     EXPECT_EQ(g_convolution->get_dilations(), convolution->get_dilations());
     EXPECT_EQ(g_convolution->get_auto_pad(), convolution->get_auto_pad());
 }
+
+TEST(attributes, convolution2) {
+    NodeBuilder::get_ops().register_factory<op::v1::Convolution>();
+    auto data = make_shared<op::Parameter>(element::f32, Shape{1, 3, 227, 227});
+    auto filters = make_shared<op::Parameter>(element::f32, Shape{96, 3, 227, 227});
+    auto strides = Strides{4, 4};
+    auto pads_begin = CoordinateDiff{0, 0};
+    auto pads_end = CoordinateDiff{0, 0};
+    auto dilations = Strides{1, 1};
+    auto convolution =
+        make_shared<op::v1::Convolution>(data, filters, strides, pads_begin, pads_end, dilations, op::PadType::VALID);
+    NodeBuilder builder(convolution);
+    auto g_convolution = ov::as_type_ptr<op::v1::Convolution>(builder.create());
+
+    // attribute count
+    const auto expected_attr_count = 5;
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+
+    EXPECT_EQ(g_convolution->get_strides(), convolution->get_strides());
+    EXPECT_EQ(g_convolution->get_pads_begin(), convolution->get_pads_begin());
+    EXPECT_EQ(g_convolution->get_pads_end(), convolution->get_pads_end());
+    EXPECT_EQ(g_convolution->get_dilations(), convolution->get_dilations());
+    EXPECT_EQ(g_convolution->get_auto_pad(), convolution->get_auto_pad());
+}

src/core/tests/visitors/op/matmul.cpp

@@ -89,3 +89,16 @@ TEST(attributes, matmul_op5) {
     EXPECT_EQ(g_matmul->get_transpose_a(), matmul->get_transpose_a());
     EXPECT_EQ(g_matmul->get_transpose_b(), matmul->get_transpose_b());
 }
+
+TEST(attributes, matmul_op6) {
+    NodeBuilder::get_ops().register_factory<opset1::MatMul>();
+    auto A = make_shared<op::Parameter>(element::f32, Shape{1, 2048});
+    auto B = make_shared<op::Parameter>(element::f32, Shape{2048, 1000});
+
+    auto matmul = make_shared<opset1::MatMul>(A, B);
+    NodeBuilder builder(matmul);
+    auto g_matmul = ov::as_type_ptr<opset1::MatMul>(builder.create());
+
+    EXPECT_EQ(g_matmul->get_transpose_a(), matmul->get_transpose_a());
+    EXPECT_EQ(g_matmul->get_transpose_b(), matmul->get_transpose_b());
+}

src/core/tests/visitors/op/prior_box.cpp

@@ -59,6 +59,48 @@ TEST(attributes, prior_box_op) {
     EXPECT_EQ(g_prior_box_attrs.scale_all_sizes, prior_box_attrs.scale_all_sizes);
 }
 
+TEST(attributes, prior_box_op2) {
+    NodeBuilder::get_ops().register_factory<opset1::PriorBox>();
+    const auto layer_shape = make_shared<op::Parameter>(element::i64, Shape{2});
+    const auto image_shape = make_shared<op::Parameter>(element::i64, Shape{2});
+
+    op::v0::PriorBox::Attributes attrs;
+    attrs.min_size = vector<float>{0.1f, 0.141421f};
+    attrs.max_size = vector<float>{};
+    attrs.aspect_ratio = vector<float>{2.0f, 0.5f};
+    attrs.density = vector<float>{};
+    attrs.fixed_ratio = vector<float>{};
+    attrs.fixed_size = vector<float>{};
+    attrs.clip = false;
+    attrs.flip = false;
+    attrs.step = 0.03333333f;
+    attrs.offset = 0.5f;
+    attrs.variance = vector<float>{0.1f, 0.1f, 0.2f, 0.2f};
+    attrs.scale_all_sizes = false;
+
+    auto prior_box = make_shared<opset1::PriorBox>(layer_shape, image_shape, attrs);
+    NodeBuilder builder(prior_box);
+    auto g_prior_box = ov::as_type_ptr<opset1::PriorBox>(builder.create());
+
+    const auto prior_box_attrs = prior_box->get_attrs();
+    const auto g_prior_box_attrs = g_prior_box->get_attrs();
+
+    const auto expected_attr_count = 12;
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+    EXPECT_EQ(g_prior_box_attrs.min_size, prior_box_attrs.min_size);
+    EXPECT_EQ(g_prior_box_attrs.max_size, prior_box_attrs.max_size);
+    EXPECT_EQ(g_prior_box_attrs.aspect_ratio, prior_box_attrs.aspect_ratio);
+    EXPECT_EQ(g_prior_box_attrs.density, prior_box_attrs.density);
+    EXPECT_EQ(g_prior_box_attrs.fixed_ratio, prior_box_attrs.fixed_ratio);
+    EXPECT_EQ(g_prior_box_attrs.fixed_size, prior_box_attrs.fixed_size);
+    EXPECT_EQ(g_prior_box_attrs.clip, prior_box_attrs.clip);
+    EXPECT_EQ(g_prior_box_attrs.flip, prior_box_attrs.flip);
+    EXPECT_EQ(g_prior_box_attrs.step, prior_box_attrs.step);
+    EXPECT_EQ(g_prior_box_attrs.offset, prior_box_attrs.offset);
+    EXPECT_EQ(g_prior_box_attrs.variance, prior_box_attrs.variance);
+    EXPECT_EQ(g_prior_box_attrs.scale_all_sizes, prior_box_attrs.scale_all_sizes);
+}
+
 TEST(attributes, prior_box_v8_op) {
     NodeBuilder::get_ops().register_factory<opset8::PriorBox>();
     const auto layer_shape = make_shared<op::Parameter>(element::i64, Shape{128, 128});

src/core/tests/visitors/op/prior_box_clustered.cpp

@@ -44,3 +44,36 @@ TEST(attributes, prior_box_clustered_op) {
     EXPECT_EQ(g_pbc_attrs.offset, pbc_attrs.offset);
     EXPECT_EQ(g_pbc_attrs.variances, pbc_attrs.variances);
 }
+
+TEST(attributes, prior_box_clustered_op2) {
+    NodeBuilder::get_ops().register_factory<opset1::PriorBoxClustered>();
+    const auto layer_shape = make_shared<op::Parameter>(element::i64, Shape{32, 32});
+    const auto image_shape = make_shared<op::Parameter>(element::i64, Shape{300, 300});
+
+    op::PriorBoxClusteredAttrs attrs;
+    attrs.heights = {44.0f, 10.0f, 30.0f, 19.0f, 94.0f, 32.0f, 61.0f, 53.0f, 17.0};
+    attrs.widths = {86.0f, 13.0f, 57.0f, 39.0f, 68.0f, 34.0f, 142.0f, 50.0f, 23.0};
+    attrs.clip = false;
+    attrs.step_widths = 0.0f;
+    attrs.step_heights = 0.0f;
+    attrs.step = 16.0f;
+    attrs.offset = 0.5f;
+    attrs.variances = {0.1f, 0.1f, 0.2f, 0.2};
+
+    auto pbc = make_shared<opset1::PriorBoxClustered>(layer_shape, image_shape, attrs);
+    NodeBuilder builder(pbc);
+    auto g_pbc = ov::as_type_ptr<opset1::PriorBoxClustered>(builder.create());
+    const auto pbc_attrs = pbc->get_attrs();
+    const auto g_pbc_attrs = g_pbc->get_attrs();
+    const auto expected_attr_count = 8;
+
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+    EXPECT_EQ(g_pbc_attrs.heights, pbc_attrs.heights);
+    EXPECT_EQ(g_pbc_attrs.widths, pbc_attrs.widths);
+    EXPECT_EQ(g_pbc_attrs.clip, pbc_attrs.clip);
+    EXPECT_EQ(g_pbc_attrs.step_widths, pbc_attrs.step_widths);
+    EXPECT_EQ(g_pbc_attrs.step_heights, pbc_attrs.step_heights);
+    EXPECT_EQ(g_pbc_attrs.step, pbc_attrs.step);
+    EXPECT_EQ(g_pbc_attrs.offset, pbc_attrs.offset);
+    EXPECT_EQ(g_pbc_attrs.variances, pbc_attrs.variances);
+}