Eliminate reader tests (#13409)

* remove reader tests #1

* remove reader tests #2

* remove reader tests #3

* remove reader tests #4

* Add clone_with_new_inputs to visitor tests

* fixes

src/core/tests/CMakeLists.txt

@@ -270,6 +270,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
@@ -288,6 +289,7 @@ set(SRC
     visitors/op/bucketize.cpp
     visitors/op/ceiling.cpp
     visitors/op/clamp.cpp
+    visitors/op/concat.cpp
     visitors/op/constant.cpp
     visitors/op/convert.cpp
     visitors/op/convert_color_i420.cpp
@@ -380,6 +382,7 @@ set(SRC
     visitors/op/proposal.cpp
     visitors/op/psroi_pooling.cpp
     visitors/op/random_uniform.cpp
+    visitors/op/range.cpp
     visitors/op/rdft.cpp
     visitors/op/read_value.cpp
     visitors/op/reduce_l1.cpp
@@ -430,6 +433,7 @@ set(SRC
     visitors/op/tan.cpp
     visitors/op/tanh.cpp
     visitors/op/tensor_iterator.cpp
+    visitors/op/tile.cpp
     visitors/op/topk.cpp
     visitors/op/transpose.cpp
     visitors/op/unsqueeze.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/adaptive_avg_pool.cpp

@@ -18,7 +18,7 @@ TEST(attributes, adaptive_avg_pool_op) {
     const auto out_shape = op::Constant::create<int64_t>(element::i64, Shape{2}, {4, 3});
 
     const auto adaptive_pool = make_shared<opset8::AdaptiveAvgPool>(A, out_shape);
-    NodeBuilder builder(adaptive_pool);
+    NodeBuilder builder(adaptive_pool, {A, out_shape});
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -18,7 +18,7 @@ TEST(attributes, adaptive_max_pool_op) {
     const auto out_shape = op::Constant::create<int64_t>(element::i64, Shape{2}, {4, 3});
 
     const auto adaptive_pool = make_shared<opset8::AdaptiveMaxPool>(A, out_shape);
-    NodeBuilder builder(adaptive_pool);
+    NodeBuilder builder(adaptive_pool, {A, out_shape});
     auto g_adaptive_pool = ov::as_type_ptr<opset8::AdaptiveMaxPool>(builder.create());
 
     const auto expected_attr_count = 1;

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

@@ -20,7 +20,7 @@ TEST(attributes, assign_v3_op) {
     const string variable_id = "v0";
     const auto read_value = make_shared<opset3::ReadValue>(in, variable_id);
     const auto assign = make_shared<opset3::Assign>(read_value, variable_id);
-    NodeBuilder builder(assign);
+    NodeBuilder builder(assign, {read_value});
 
     // attribute count
     const auto expected_attr_count = 1;
@@ -33,7 +33,7 @@ TEST(attributes, assign_v6_op) {
     const auto variable = std::make_shared<Variable>(VariableInfo{PartialShape::dynamic(), element::dynamic, "v0"});
     const auto read_value = make_shared<opset6::ReadValue>(in, variable);
     const auto assign = make_shared<opset6::Assign>(read_value, variable);
-    NodeBuilder builder(assign);
+    NodeBuilder builder(assign, {read_value});
 
     // attribute count
     const auto expected_attr_count = 1;

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

@@ -29,7 +29,7 @@ TEST(attributes, avg_pool_op) {
     auto avg_pool =
         make_shared<opset1::AvgPool>(data, strides, pads_begin, pads_end, kernel, exclude_pad, rounding_mode, auto_pad);
 
-    NodeBuilder builder(avg_pool);
+    NodeBuilder builder(avg_pool, {data});
     auto g_avg_pool = ov::as_type_ptr<opset1::AvgPool>(builder.create());
 
     EXPECT_EQ(g_avg_pool->get_strides(), avg_pool->get_strides());
@@ -54,7 +54,7 @@ TEST(attributes, avg_pool_v8_op) {
 
     const auto avg_pool =
         make_shared<opset8::AvgPool>(data, strides, pads_begin, pads_end, kernel, exclude_pad, rounding_mode, auto_pad);
-    NodeBuilder builder(avg_pool);
+    NodeBuilder builder(avg_pool, {data});
     auto g_avg_pool = ov::as_type_ptr<opset8::AvgPool>(builder.create());
 
     EXPECT_EQ(g_avg_pool->get_strides(), avg_pool->get_strides());

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

@@ -16,34 +16,44 @@ using namespace ngraph;
 using ngraph::test::NodeBuilder;
 using ngraph::test::ValueMap;
 
-template <class T>
+TEST(attributes, batch_norm_inference_op_v5) {
-class BatchNormAttrTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(BatchNormAttrTest);
-
-TYPED_TEST_P(BatchNormAttrTest, batch_norm_inference_op) {
     PartialShape in_shape{1, 10};
     PartialShape ch_shape{in_shape[1]};
     element::Type et = element::f32;
     double epsilon = 0.001;
 
-    NodeBuilder::get_ops().register_factory<TypeParam>();
+    NodeBuilder::get_ops().register_factory<op::v5::BatchNormInference>();
     auto data_batch = make_shared<op::Parameter>(et, in_shape);
     auto gamma = make_shared<op::Parameter>(et, ch_shape);
     auto beta = make_shared<op::Parameter>(et, ch_shape);
     auto mean = make_shared<op::Parameter>(et, ch_shape);
     auto var = make_shared<op::Parameter>(et, ch_shape);
-    auto batch_norm = make_shared<TypeParam>(data_batch, gamma, beta, mean, var, epsilon);
+    auto batch_norm = make_shared<op::v5::BatchNormInference>(data_batch, gamma, beta, mean, var, epsilon);
 
     const auto expected_attr_count = 1;
-    NodeBuilder builder(batch_norm);
+    NodeBuilder builder(batch_norm, {data_batch, gamma, beta, mean, var});
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
-    auto g_batch_norm = ov::as_type_ptr<TypeParam>(builder.create());
+    auto g_batch_norm = ov::as_type_ptr<op::v5::BatchNormInference>(builder.create());
     EXPECT_EQ(g_batch_norm->get_eps_value(), batch_norm->get_eps_value());
 }
 
-REGISTER_TYPED_TEST_SUITE_P(BatchNormAttrTest, batch_norm_inference_op);
+TEST(attributes, batch_norm_inference_op_v0) {
+    PartialShape in_shape{1, 10};
+    PartialShape ch_shape{in_shape[1]};
+    element::Type et = element::f32;
+    double epsilon = 0.001;
 
-using Types = ::testing::Types<op::v0::BatchNormInference, op::v5::BatchNormInference>;
+    NodeBuilder::get_ops().register_factory<op::v0::BatchNormInference>();
+    auto data_batch = make_shared<op::Parameter>(et, in_shape);
+    auto gamma = make_shared<op::Parameter>(et, ch_shape);
+    auto beta = make_shared<op::Parameter>(et, ch_shape);
+    auto mean = make_shared<op::Parameter>(et, ch_shape);
+    auto var = make_shared<op::Parameter>(et, ch_shape);
+    auto batch_norm = make_shared<op::v0::BatchNormInference>(data_batch, gamma, beta, mean, var, epsilon);
 
-INSTANTIATE_TYPED_TEST_SUITE_P(attributes, BatchNormAttrTest, Types);
+    const auto expected_attr_count = 1;
+    NodeBuilder builder(batch_norm, {gamma, beta, data_batch, mean, var});
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+    auto g_batch_norm = ov::as_type_ptr<op::v0::BatchNormInference>(builder.create());
+    EXPECT_EQ(g_batch_norm->get_eps_value(), batch_norm->get_eps_value());
+}

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

@@ -19,7 +19,7 @@ TEST(attributes, batch_to_space_op) {
     auto crops_end = make_shared<op::Constant>(element::i64, Shape{2}, vector<int64_t>{0, 0});
     auto batch2space = make_shared<op::v1::BatchToSpace>(data, block_shape, crops_begin, crops_end);
 
-    NodeBuilder builder(batch2space);
+    NodeBuilder builder(batch2space, {data});
     const auto expected_attr_count = 0;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -40,7 +40,7 @@ TEST(attributes, bin_convolution) {
                                                        mode,
                                                        pad_value,
                                                        auto_pad);
-    NodeBuilder builder(conv);
+    NodeBuilder builder(conv, {data_batch, filters});
     auto g_convolution = ov::as_type_ptr<op::v1::BinaryConvolution>(builder.create());
 
     // attribute count

src/core/tests/visitors/op/binary_ops.hpp

@@ -49,7 +49,7 @@ TYPED_TEST_P(BinaryOperatorVisitor, Auto_Broadcast)
     auto auto_broadcast = ngraph::op::AutoBroadcastType::NUMPY;
 
     const auto op_func = std::make_shared<OP_Type>(A, B, auto_broadcast);
-    ngraph::test::NodeBuilder builder(op_func);
+    ngraph::test::NodeBuilder builder(op_func, {A, B});
     const auto g_op_func = ngraph::as_type_ptr<OP_Type>(builder.create());
 
     const auto expected_attr_count = 1;
@@ -57,4 +57,24 @@ TYPED_TEST_P(BinaryOperatorVisitor, Auto_Broadcast)
     EXPECT_EQ(op_func->get_autob(), g_op_func->get_autob());
 }
 
-REGISTER_TYPED_TEST_SUITE_P(BinaryOperatorVisitor, Auto_Broadcast);
+TYPED_TEST_P(BinaryOperatorVisitor, No_Broadcast)
+{
+    using OP_Type = typename TypeParam::op_type;
+    const ngraph::element::Type_t element_type = TypeParam::element_type;
+
+    ngraph::test::NodeBuilder::get_ops().register_factory<OP_Type>();
+    const auto A =
+        std::make_shared<ngraph::op::Parameter>(element_type, ngraph::PartialShape{1, 2, 3});
+    const auto B =
+        std::make_shared<ngraph::op::Parameter>(element_type, ngraph::PartialShape{1, 2, 3});
+
+    const auto op_func = std::make_shared<OP_Type>(A, B);
+    ngraph::test::NodeBuilder builder(op_func, {A, B});
+    const auto g_op_func = ngraph::as_type_ptr<OP_Type>(builder.create());
+
+    const auto expected_attr_count = 1;
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+    EXPECT_EQ(op_func->get_autob(), g_op_func->get_autob());
+}
+
+REGISTER_TYPED_TEST_SUITE_P(BinaryOperatorVisitor, Auto_Broadcast, No_Broadcast);

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

@@ -7,8 +7,6 @@
 #include "ngraph/op/util/attr_types.hpp"
 #include "ngraph/opsets/opset1.hpp"
 #include "ngraph/opsets/opset3.hpp"
-#include "ngraph/opsets/opset4.hpp"
-#include "ngraph/opsets/opset5.hpp"
 #include "util/visitor.hpp"
 
 using namespace std;
@@ -16,6 +14,20 @@ using namespace ngraph;
 using ngraph::test::NodeBuilder;
 using ngraph::test::ValueMap;
 
+TEST(attributes, broadcast_v1) {
+    NodeBuilder::get_ops().register_factory<opset1::Broadcast>();
+    const auto arg = make_shared<op::Parameter>(element::i64, Shape{1, 3, 1});
+    const auto shape = make_shared<op::Parameter>(element::i64, Shape{3});
+    const auto axes_mapping = make_shared<op::Parameter>(element::i64, Shape{3});
+    const auto broadcast_spec = ov::op::AutoBroadcastType::NONE;
+
+    const auto broadcast_v3 = make_shared<op::v1::Broadcast>(arg, shape, axes_mapping, broadcast_spec);
+    NodeBuilder builder(broadcast_v3, {arg, shape, axes_mapping});
+    auto g_broadcast_v3 = ov::as_type_ptr<opset1::Broadcast>(builder.create());
+
+    EXPECT_EQ(g_broadcast_v3->get_broadcast_spec().m_type, broadcast_spec);
+}
+
 TEST(attributes, broadcast_v3) {
     NodeBuilder::get_ops().register_factory<opset3::Broadcast>();
     const auto arg = make_shared<op::Parameter>(element::i64, Shape{1, 3, 1});
@@ -23,7 +35,21 @@ TEST(attributes, broadcast_v3) {
     const auto broadcast_spec = op::BroadcastType::BIDIRECTIONAL;
 
     const auto broadcast_v3 = make_shared<op::v3::Broadcast>(arg, shape, broadcast_spec);
-    NodeBuilder builder(broadcast_v3);
+    NodeBuilder builder(broadcast_v3, {arg, shape});
+    auto g_broadcast_v3 = ov::as_type_ptr<opset3::Broadcast>(builder.create());
+
+    EXPECT_EQ(g_broadcast_v3->get_broadcast_spec(), broadcast_spec);
+}
+
+TEST(attributes, broadcast_v3_explicit) {
+    NodeBuilder::get_ops().register_factory<opset3::Broadcast>();
+    const auto arg = make_shared<op::Parameter>(element::i64, Shape{1, 3, 1});
+    const auto shape = make_shared<op::Parameter>(element::i64, Shape{3});
+    const auto axes_mapping = make_shared<op::Parameter>(element::i64, Shape{3});
+    const auto broadcast_spec = op::BroadcastType::EXPLICIT;
+
+    const auto broadcast_v3 = make_shared<op::v3::Broadcast>(arg, shape, axes_mapping, broadcast_spec);
+    NodeBuilder builder(broadcast_v3, {arg, shape, axes_mapping});
     auto g_broadcast_v3 = ov::as_type_ptr<opset3::Broadcast>(builder.create());
 
     EXPECT_EQ(g_broadcast_v3->get_broadcast_spec(), broadcast_spec);

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

@@ -21,7 +21,7 @@ TEST(attributes, bucketize_v3_op_default_attributes) {
     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 3, 4});
     auto buckets = make_shared<op::Parameter>(element::f32, Shape{5});
     auto bucketize = make_shared<opset3::Bucketize>(data, buckets);
-    NodeBuilder builder(bucketize);
+    NodeBuilder builder(bucketize, {data, buckets});
 
     auto g_bucketize = ov::as_type_ptr<opset3::Bucketize>(builder.create());
 
@@ -37,7 +37,7 @@ TEST(attributes, bucketize_v3_op_custom_attributes) {
     bool with_right_bound = false;
 
     auto bucketize = make_shared<opset3::Bucketize>(data, buckets, output_type, with_right_bound);
-    NodeBuilder builder(bucketize);
+    NodeBuilder builder(bucketize, {data, buckets});
 
     auto g_bucketize = ov::as_type_ptr<opset3::Bucketize>(builder.create());
 

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

@@ -21,7 +21,7 @@ TEST(attributes, clamp_op) {
     double max = 5.6;
 
     const auto clamp = make_shared<opset1::Clamp>(data, min, max);
-    NodeBuilder builder(clamp);
+    NodeBuilder builder(clamp, {data});
     auto g_clamp = ov::as_type_ptr<opset1::Clamp>(builder.create());
 
     const auto expected_attr_count = 2;

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

@@ -0,0 +1,28 @@
+// Copyright (C) 2018-2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "gtest/gtest.h"
+#include "ngraph/ngraph.hpp"
+#include "ngraph/op/util/attr_types.hpp"
+#include "ngraph/opsets/opset1.hpp"
+#include "util/visitor.hpp"
+
+using namespace std;
+using namespace ngraph;
+using ngraph::test::NodeBuilder;
+using ngraph::test::ValueMap;
+
+TEST(attributes, concat_op) {
+    NodeBuilder::get_ops().register_factory<opset1::Concat>();
+    auto input1 = make_shared<op::Parameter>(element::i64, Shape{1, 2, 3});
+    auto input2 = make_shared<op::Parameter>(element::i64, Shape{1, 2, 3});
+    auto input3 = make_shared<op::Parameter>(element::i64, Shape{1, 2, 3});
+    int64_t axis = 2;
+
+    auto concat = make_shared<opset1::Concat>(ov::NodeVector{input1, input2, input3}, axis);
+    NodeBuilder builder(concat, {input1, input2, input3});
+    auto g_concat = ov::as_type_ptr<opset1::Concat>(builder.create());
+
+    EXPECT_EQ(g_concat->get_axis(), concat->get_axis());
+}

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

@@ -18,7 +18,7 @@ TEST(attributes, convert_op_v0) {
     const element::Type destination_type = element::Type_t::i32;
 
     const auto convert = std::make_shared<Convert>(data, destination_type);
-    NodeBuilder builder(convert);
+    NodeBuilder builder(convert, {data});
 
     // attribute count
     const auto expected_attr_count = 1;

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

@@ -17,7 +17,9 @@ TEST(attributes, convert_color_i420_rgb) {
     NodeBuilder::get_ops().register_factory<op::v8::I420toRGB>();
     auto data = make_shared<op::v0::Parameter>(element::u8, Shape{3, 720, 640, 1});
     auto convert_color = make_shared<op::v8::I420toRGB>(data);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::I420toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -26,7 +28,9 @@ TEST(attributes, convert_color_i420_bgr) {
     NodeBuilder::get_ops().register_factory<op::v8::I420toBGR>();
     auto data = make_shared<op::v0::Parameter>(element::u8, Shape{3, 720, 640, 1});
     auto convert_color = make_shared<op::v8::I420toBGR>(data);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::I420toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -37,7 +41,9 @@ TEST(attributes, convert_color_i420_rgb_3planes) {
     auto data2 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 240, 320, 1});
     auto data3 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 240, 320, 1});
     auto convert_color = make_shared<op::v8::I420toRGB>(data1, data2, data3);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data1, data2, data3});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::I420toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -48,7 +54,9 @@ TEST(attributes, convert_color_i420_bgr_3planes) {
     auto data2 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 240, 320, 1});
     auto data3 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 240, 320, 1});
     auto convert_color = make_shared<op::v8::I420toBGR>(data1, data2, data3);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data1, data2, data3});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::I420toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -17,7 +17,9 @@ TEST(attributes, convert_color_nv12_rgb) {
     NodeBuilder::get_ops().register_factory<op::v8::NV12toRGB>();
     auto data = make_shared<op::v0::Parameter>(element::u8, Shape{3, 720, 640, 1});
     auto convert_color = make_shared<op::v8::NV12toRGB>(data);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::NV12toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -26,7 +28,9 @@ TEST(attributes, convert_color_nv12_bgr) {
     NodeBuilder::get_ops().register_factory<op::v8::NV12toBGR>();
     auto data = make_shared<op::v0::Parameter>(element::u8, Shape{3, 720, 640, 1});
     auto convert_color = make_shared<op::v8::NV12toBGR>(data);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::NV12toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -36,7 +40,9 @@ TEST(attributes, convert_color_nv12_rgb_2planes) {
     auto data1 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 480, 640, 1});
     auto data2 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 240, 320, 2});
     auto convert_color = make_shared<op::v8::NV12toRGB>(data1, data2);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data1, data2});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::NV12toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -46,7 +52,9 @@ TEST(attributes, convert_color_nv12_bgr_2planes) {
     auto data1 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 480, 640, 1});
     auto data2 = make_shared<op::v0::Parameter>(element::u8, Shape{3, 240, 320, 2});
     auto convert_color = make_shared<op::v8::NV12toBGR>(data1, data2);
-    NodeBuilder builder(convert_color);
+    NodeBuilder builder(convert_color, {data1, data2});
+    EXPECT_NO_THROW(auto g_concat = ov::as_type_ptr<op::v8::NV12toRGB>(builder.create()));
+
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -27,7 +27,7 @@ TEST(attributes, convolution) {
     auto convolution =
         make_shared<op::v1::Convolution>(data, filters, strides, pads_begin, pads_end, dilations, op::PadType::VALID);
 
-    NodeBuilder builder(convolution);
+    NodeBuilder builder(convolution, {data, filters});
     auto g_convolution = ov::as_type_ptr<op::v1::Convolution>(builder.create());
 
     // attribute count
@@ -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, {data, filters});
+    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/convolution_backprop.cpp

@@ -31,7 +31,7 @@ TEST(attributes, convolution_backprop_op) {
                                                                     pads_end,
                                                                     dilations,
                                                                     op::PadType::VALID);
-    NodeBuilder builder(convolution);
+    NodeBuilder builder(convolution, {data, filters});
     auto g_convolution = ov::as_type_ptr<opset1::ConvolutionBackpropData>(builder.create());
 
     // attribute count
@@ -74,7 +74,7 @@ TEST(attributes, convolution_backprop_output_shape_output_padding) {
                                                                               dilations,
                                                                               padType,
                                                                               output_padding);
-        NodeBuilder builder(convolution);
+        NodeBuilder builder(convolution, {data, filter});
         const auto g_convolution = ov::as_type_ptr<opset1::ConvolutionBackpropData>(builder.create());
 
         // attribute count

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

@@ -19,7 +19,7 @@ TEST(attributes, ctc_greedy_decoder_op) {
     auto masks = make_shared<op::Parameter>(element::i32, Shape{3, 1});
     auto decoder = make_shared<op::v0::CTCGreedyDecoder>(data, masks, m_ctc_merge_repeated);
 
-    NodeBuilder builder(decoder);
+    NodeBuilder builder(decoder, {data, masks});
     auto g_decoder = ov::as_type_ptr<opset1::CTCGreedyDecoder>(builder.create());
 
     EXPECT_EQ(g_decoder->get_ctc_merge_repeated(), decoder->get_ctc_merge_repeated());

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

@@ -21,7 +21,7 @@ TEST(attributes, ctc_greedy_decoder_seq_len_op) {
     auto blank_index = op::Constant::create<int32_t>(element::i32, Shape{}, {2});
     auto decoder = make_shared<op::v6::CTCGreedyDecoderSeqLen>(data, seq_len, blank_index, merge_repeated);
 
-    NodeBuilder builder(decoder);
+    NodeBuilder builder(decoder, {data, seq_len, blank_index});
     auto g_decoder = ov::as_type_ptr<opset6::CTCGreedyDecoderSeqLen>(builder.create());
 
     EXPECT_EQ(g_decoder->get_merge_repeated(), decoder->get_merge_repeated());

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

@@ -26,7 +26,7 @@ TEST(attributes, ctc_loss) {
     auto blank_index = make_shared<op::Parameter>(element::i32, Shape{});
 
     auto ctc_loss = make_shared<opset4::CTCLoss>(logits, logit_length, labels, label_length, blank_index);
-    NodeBuilder builder(ctc_loss);
+    NodeBuilder builder(ctc_loss, {logits, logit_length, labels, label_length, blank_index});
     auto g_ctc_loss = as_type_ptr<opset4::CTCLoss>(builder.create());
 
     // attribute count

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

@@ -19,7 +19,7 @@ TEST(attributes, cum_sum_op_default_attributes_no_axis_input) {
     auto A = make_shared<op::Parameter>(element::f32, shape);
     auto cs = make_shared<op::CumSum>(A);
 
-    NodeBuilder builder(cs);
+    NodeBuilder builder(cs, {A});
     auto g_cs = ov::as_type_ptr<opset3::CumSum>(builder.create());
 
     const auto expected_attr_count = 2;
@@ -37,7 +37,7 @@ TEST(attributes, cum_sum_op_default_attributes) {
     auto axis = make_shared<op::Parameter>(element::i32, Shape{1});
     auto cs = make_shared<op::CumSum>(A, axis);
 
-    NodeBuilder builder(cs);
+    NodeBuilder builder(cs, {A, axis});
     auto g_cs = ov::as_type_ptr<opset3::CumSum>(builder.create());
 
     const auto expected_attr_count = 2;
@@ -57,7 +57,7 @@ TEST(attributes, cum_sum_op_custom_attributes) {
     bool reverse = true;
     auto cs = make_shared<op::CumSum>(A, axis, exclusive, reverse);
 
-    NodeBuilder builder(cs);
+    NodeBuilder builder(cs, {A, axis});
     auto g_cs = ov::as_type_ptr<opset3::CumSum>(builder.create());
 
     const auto expected_attr_count = 2;

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

@@ -26,7 +26,7 @@ TEST(attributes, deformable_convolution_default_attributes) {
     auto dilations = Strides{1, 1};
     auto convolution =
         make_shared<opset1::DeformableConvolution>(data, offsets, filters, strides, pads_begin, pads_end, dilations);
-    NodeBuilder builder(convolution);
+    NodeBuilder builder(convolution, {data, offsets, filters});
     auto g_convolution = ov::as_type_ptr<opset1::DeformableConvolution>(builder.create());
 
     // attribute count
@@ -62,7 +62,7 @@ TEST(attributes, deformable_convolution_attributes) {
                                                                   op::PadType::SAME_LOWER,
                                                                   2,
                                                                   2);
-    NodeBuilder builder(convolution);
+    NodeBuilder builder(convolution, {data, offsets, filters});
     auto g_convolution = ov::as_type_ptr<opset1::DeformableConvolution>(builder.create());
 
     // attribute count
@@ -90,7 +90,7 @@ TEST(attributes, deformable_convolution_v8_default_attributes) {
     auto dilations = Strides{1, 1};
     auto convolution =
         make_shared<opset8::DeformableConvolution>(data, offsets, filters, strides, pads_begin, pads_end, dilations);
-    NodeBuilder builder(convolution);
+    NodeBuilder builder(convolution, {data, offsets, filters});
     auto g_convolution = ov::as_type_ptr<opset8::DeformableConvolution>(builder.create());
 
     // attribute count
@@ -130,7 +130,7 @@ TEST(attributes, deformable_convolution_v8_attributes) {
                                                                   2,
                                                                   2,
                                                                   true);
-    NodeBuilder builder(convolution);
+    NodeBuilder builder(convolution, {data, offsets, filters, mask});
     auto g_convolution = ov::as_type_ptr<opset8::DeformableConvolution>(builder.create());
 
     // attribute count
@@ -145,4 +145,4 @@ TEST(attributes, deformable_convolution_v8_attributes) {
     EXPECT_EQ(g_convolution->get_group(), convolution->get_group());
     EXPECT_EQ(g_convolution->get_deformable_group(), convolution->get_deformable_group());
     EXPECT_EQ(g_convolution->get_bilinear_interpolation_pad(), convolution->get_bilinear_interpolation_pad());
-}
+}

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

@@ -37,7 +37,7 @@ TEST(attributes, deformable_psroi_pooling_op) {
                                                           spatial_bins_y,
                                                           trans_std,
                                                           part_size);
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {input, coords});
     auto g_op = ov::as_type_ptr<opset1::DeformablePSROIPooling>(builder.create());
 
     EXPECT_EQ(g_op->get_output_dim(), op->get_output_dim());

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

@@ -23,7 +23,7 @@ TEST(attributes, depth_to_space) {
     const auto mode = "blocks_first";
 
     const auto dts = std::make_shared<opset1::DepthToSpace>(data, mode, block_size);
-    NodeBuilder builder(dts);
+    NodeBuilder builder(dts, {data});
     auto g_dts = ov::as_type_ptr<opset1::DepthToSpace>(builder.create());
 
     // attribute count

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

@@ -66,7 +66,7 @@ TEST(attributes, detection_output_op) {
 
     auto detection_output =
         make_shared<op::v0::DetectionOutput>(box_logits, class_preds, proposals, aux_class_preds, aux_box_pred, attrs);
-    NodeBuilder builder(detection_output);
+    NodeBuilder builder(detection_output, {box_logits, class_preds, proposals, aux_class_preds, aux_box_pred});
     auto g_detection_output = ov::as_type_ptr<op::v0::DetectionOutput>(builder.create());
 
     const auto do_attrs = detection_output->get_attrs();
@@ -90,7 +90,7 @@ TEST(attributes, detection_output_v8) {
 
     auto detection_output =
         make_shared<v8::DetectionOutput>(box_logits, class_preds, proposals, aux_class_preds, aux_box_pred, attrs);
-    NodeBuilder builder(detection_output);
+    NodeBuilder builder(detection_output, {box_logits, class_preds, proposals, aux_class_preds, aux_box_pred});
     auto g_detection_output = ov::as_type_ptr<v8::DetectionOutput>(builder.create());
 
     const auto do_attrs = detection_output->get_attrs();

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

@@ -17,8 +17,9 @@ TEST(attributes, dft_op) {
     auto axes = op::v0::Constant::create<int64_t>(element::i64, Shape{1}, {2});
     auto dft = make_shared<op::v7::DFT>(data, axes);
 
-    NodeBuilder builder(dft);
+    NodeBuilder builder(dft, {data, axes});
     const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_dft = ov::as_type_ptr<op::v7::DFT>(builder.create()));
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
@@ -30,8 +31,9 @@ TEST(attributes, dft_op_signal) {
     auto axes = op::v0::Constant::create<int64_t>(element::i64, Shape{1}, {2});
     auto dft = make_shared<op::v7::DFT>(data, axes, signal);
 
-    NodeBuilder builder(dft);
+    NodeBuilder builder(dft, {data, axes, signal});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_dft = ov::as_type_ptr<op::v7::DFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -31,7 +31,7 @@ TEST(attributes, divide) {
     const op::AutoBroadcastSpec& auto_broadcast = op::AutoBroadcastSpec(op::AutoBroadcastType::NUMPY);
     const auto divide = make_shared<opset1::Divide>(in1, in2, pythondiv, auto_broadcast);
 
-    NodeBuilder builder(divide);
+    NodeBuilder builder(divide, {in1, in2});
     auto g_divide = ov::as_type_ptr<opset1::Divide>(builder.create());
 
     const auto expected_attr_count = 2;

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

@@ -19,7 +19,7 @@ TEST(attributes, einsum_v7_op) {
     auto input2 = make_shared<opset1::Parameter>(element::i32, Shape{3, 4});
     std::string equation = "ab,bc->ac";
     auto einsum = make_shared<opset7::Einsum>(OutputVector{input1, input2}, equation);
-    NodeBuilder builder(einsum);
+    NodeBuilder builder(einsum, {input1, input2});
     auto g_einsum = ov::as_type_ptr<opset7::Einsum>(builder.create());
     EXPECT_EQ(g_einsum->get_equation(), einsum->get_equation());
 }

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

@@ -23,7 +23,7 @@ TEST(attributes, elu_op) {
     double alpha = 0.1;
 
     const auto elu = make_shared<opset1::Elu>(data, alpha);
-    NodeBuilder builder(elu);
+    NodeBuilder builder(elu, {data});
     auto g_elu = ov::as_type_ptr<opset1::Elu>(builder.create());
 
     EXPECT_EQ(g_elu->get_alpha(), elu->get_alpha());

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

@@ -29,7 +29,8 @@ TEST(visitor_without_attribute, embedding_segments_sum_op) {
                                                          num_segments,
                                                          default_index,
                                                          per_sample_weights);
-    NodeBuilder builder(ess);
+    NodeBuilder builder(ess, {emb_table, indices, segment_ids, num_segments, default_index, per_sample_weights});
+    EXPECT_NO_THROW(auto g_ess = ov::as_type_ptr<opset3::EmbeddingSegmentsSum>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -24,7 +24,8 @@ TEST(visitor_without_attribute, embedding_bag_offsets_sum_op) {
 
     auto ebos =
         make_shared<opset3::EmbeddingBagOffsetsSum>(emb_table, indices, offsets, default_index, per_sample_weights);
-    NodeBuilder builder(ebos);
+    NodeBuilder builder(ebos, {emb_table, indices, offsets, default_index, per_sample_weights});
+    EXPECT_NO_THROW(auto g_ebos = ov::as_type_ptr<opset3::EmbeddingBagOffsetsSum>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -19,8 +19,9 @@ TEST(visitor_without_attribute, embedding_bag_packed_sum_op) {
     auto indices = make_shared<op::Parameter>(element::i64, Shape{3, 4});
     auto per_sample_weights = make_shared<op::Parameter>(element::f32, Shape{3, 4});
 
-    auto ebos = make_shared<opset3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
+    auto ebps = make_shared<opset3::EmbeddingBagPackedSum>(emb_table, indices, per_sample_weights);
-    NodeBuilder builder(ebos);
+    NodeBuilder builder(ebps, {emb_table, indices, per_sample_weights});
+    EXPECT_NO_THROW(auto g_ebps = ov::as_type_ptr<opset3::EmbeddingBagPackedSum>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -38,7 +38,7 @@ TEST(attributes, detectron_detection_output) {
 
     auto detection = std::make_shared<ExperimentalDetection>(rois, deltas, scores, im_info, attrs);
 
-    NodeBuilder builder(detection);
+    NodeBuilder builder(detection, {rois, deltas, scores, im_info});
 
     auto g_detection = ov::as_type_ptr<ExperimentalDetection>(builder.create());
 

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

@@ -34,7 +34,7 @@ TEST(attributes, detectron_proposals) {
 
     auto proposals = std::make_shared<ExperimentalProposals>(im_info, anchors, deltas, scores, attrs);
 
-    NodeBuilder builder(proposals);
+    NodeBuilder builder(proposals, {im_info, anchors, deltas, scores});
 
     auto g_proposals = ov::as_type_ptr<ExperimentalProposals>(builder.create());
 

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

@@ -34,7 +34,7 @@ TEST(attributes, detectron_prior_grid_generator) {
 
     auto proposals = std::make_shared<ExperimentalGenerator>(priors, feature_map, im_data, attrs);
 
-    NodeBuilder builder(proposals);
+    NodeBuilder builder(proposals, {priors, feature_map, im_data});
 
     auto g_proposals = ov::as_type_ptr<ExperimentalGenerator>(builder.create());
 

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

@@ -20,7 +20,7 @@ TEST(attributes, experimental_detectron_topkrois_op) {
     auto input_probs = std::make_shared<op::Parameter>(element::f32, Shape{2});
     auto topkrois = std::make_shared<op::v6::ExperimentalDetectronTopKROIs>(input_rois, input_probs, num_rois);
 
-    NodeBuilder builder(topkrois);
+    NodeBuilder builder(topkrois, {input_rois, input_probs});
     auto g_topkrois = ov::as_type_ptr<opset6::ExperimentalDetectronTopKROIs>(builder.create());
 
     EXPECT_EQ(g_topkrois->get_max_rois(), topkrois->get_max_rois());

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

@@ -26,7 +26,7 @@ TEST(attributes, extractimagepatches_op) {
     auto padtype_padding = ngraph::op::PadType::VALID;
 
     auto extractimagepatches = make_shared<opset3::ExtractImagePatches>(data, sizes, strides, rates, padtype_padding);
-    NodeBuilder builder(extractimagepatches);
+    NodeBuilder builder(extractimagepatches, {data});
     auto g_extractimagepatches = ov::as_type_ptr<opset3::ExtractImagePatches>(builder.create());
 
     const auto expected_attr_count = 4;

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

@@ -20,7 +20,7 @@ TEST(attributes, eye_op) {
     auto diagonal_index = make_shared<op::v0::Constant>(element::i32, Shape{}, 0);
 
     const auto eye = make_shared<op::v9::Eye>(num_rows, num_columns, diagonal_index, element::Type_t::u8);
-    NodeBuilder builder(eye);
+    NodeBuilder builder(eye, {num_rows, num_columns, diagonal_index});
     auto g_eye = ov::as_type_ptr<op::v9::Eye>(builder.create());
 
     const auto expected_attr_count = 1;
@@ -36,7 +36,7 @@ TEST(attributes, eye_batch_shape_op) {
     auto batch_shape = make_shared<op::v0::Constant>(element::i32, Shape{3}, std::vector<int32_t>{1, 2, 3});
 
     const auto eye = make_shared<op::v9::Eye>(num_rows, num_columns, diagonal_index, batch_shape, element::Type_t::i32);
-    NodeBuilder builder(eye);
+    NodeBuilder builder(eye, {num_rows, num_columns, diagonal_index, batch_shape});
     auto g_eye = ov::as_type_ptr<op::v9::Eye>(builder.create());
 
     const auto expected_attr_count = 1;

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

@@ -29,7 +29,7 @@ TEST(attributes, fake_quantize_op) {
 
     const auto fake_quantize =
         make_shared<op::FakeQuantize>(data, input_low, input_high, output_low, output_high, levels, auto_broadcast);
-    NodeBuilder builder(fake_quantize);
+    NodeBuilder builder(fake_quantize, {data, input_low, input_high, output_low, output_high});
     auto g_fake_quantize = ov::as_type_ptr<opset1::FakeQuantize>(builder.create());
 
     // attribute count

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

@@ -14,6 +14,19 @@ using namespace ngraph;
 using ngraph::test::NodeBuilder;
 using ngraph::test::ValueMap;
 
+TEST(attributes, gather_v1_op) {
+    NodeBuilder::get_ops().register_factory<opset1::Gather>();
+    auto data = make_shared<opset1::Parameter>(element::i32, Shape{2, 3, 4});
+    auto indices = make_shared<opset1::Parameter>(element::i32, Shape{2});
+    auto axis = make_shared<opset1::Constant>(element::i32, Shape{}, 2);
+
+    auto gather = make_shared<opset1::Gather>(data, indices, axis);
+    NodeBuilder builder(gather, {data, indices, axis});
+    auto g_gather = ov::as_type_ptr<opset1::Gather>(builder.create());
+
+    EXPECT_EQ(g_gather->get_batch_dims(), gather->get_batch_dims());
+}
+
 TEST(attributes, gather_v7_op) {
     NodeBuilder::get_ops().register_factory<opset7::Gather>();
     auto data = make_shared<opset1::Parameter>(element::i32, Shape{2, 3, 4});
@@ -22,7 +35,7 @@ TEST(attributes, gather_v7_op) {
     int64_t batch_dims = 1;
 
     auto gather = make_shared<opset7::Gather>(data, indices, axis, batch_dims);
-    NodeBuilder builder(gather);
+    NodeBuilder builder(gather, {data, indices, axis});
     auto g_gather = ov::as_type_ptr<opset7::Gather>(builder.create());
 
     EXPECT_EQ(g_gather->get_batch_dims(), gather->get_batch_dims());
@@ -36,7 +49,7 @@ TEST(attributes, gather_v8_op) {
     int64_t batch_dims = 1;
 
     auto gather = make_shared<opset8::Gather>(data, indices, axis, batch_dims);
-    NodeBuilder builder(gather);
+    NodeBuilder builder(gather, {data, indices, axis});
     auto g_gather = ov::as_type_ptr<opset8::Gather>(builder.create());
 
     EXPECT_EQ(g_gather->get_batch_dims(), gather->get_batch_dims());

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

@@ -20,7 +20,7 @@ TEST(attributes, gather_elements_op) {
     int64_t axis = 0;
 
     auto gather_el = make_shared<opset6::GatherElements>(arg1, arg2, axis);
-    NodeBuilder builder(gather_el);
+    NodeBuilder builder(gather_el, {arg1, arg2});
     auto g_gather_el = ov::as_type_ptr<opset6::GatherElements>(builder.create());
 
     EXPECT_EQ(g_gather_el->get_axis(), gather_el->get_axis());

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

@@ -21,7 +21,7 @@ TEST(attributes, gather_nd_v5_op) {
     auto I = make_shared<op::Parameter>(element::i32, Shape{2, 1});
     auto G = make_shared<op::v5::GatherND>(P, I, batch_dims);
 
-    NodeBuilder builder(G);
+    NodeBuilder builder(G, {P, I});
     auto g_G = ov::as_type_ptr<opset5::GatherND>(builder.create());
 
     EXPECT_EQ(g_G->get_batch_dims(), G->get_batch_dims());
@@ -34,7 +34,7 @@ TEST(attributes, gather_nd_v8_op) {
     auto I = make_shared<op::Parameter>(element::i32, Shape{2, 1});
     auto G = make_shared<op::v8::GatherND>(P, I, batch_dims);
 
-    NodeBuilder builder(G);
+    NodeBuilder builder(G, {P, I});
     auto g_G = ov::as_type_ptr<opset8::GatherND>(builder.create());
 
     EXPECT_EQ(g_G->get_batch_dims(), G->get_batch_dims());

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

@@ -21,7 +21,8 @@ TEST(attributes, gather_tree_op) {
     auto end_token = std::make_shared<op::Parameter>(element::f32, Shape{});
 
     auto gather_tree = std::make_shared<opset1::GatherTree>(step_ids, parent_idx, max_seq_len, end_token);
-    NodeBuilder builder(gather_tree);
+    NodeBuilder builder(gather_tree, {step_ids, parent_idx, max_seq_len, end_token});
+    EXPECT_NO_THROW(auto g_gather_tree = ov::as_type_ptr<opset1::GatherTree>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -5,6 +5,7 @@
 #include "gtest/gtest.h"
 #include "ngraph/ngraph.hpp"
 #include "ngraph/op/util/attr_types.hpp"
+#include "ngraph/opsets/opset2.hpp"
 #include "ngraph/opsets/opset7.hpp"
 #include "util/visitor.hpp"
 
@@ -12,13 +13,45 @@ using namespace std;
 using namespace ngraph;
 using ngraph::test::NodeBuilder;
 
-TEST(attributes, gelu_op) {
+TEST(attributes, gelu_op_erf) {
     NodeBuilder::get_ops().register_factory<opset7::Gelu>();
     const auto data_input = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
     const auto approximation_mode = op::GeluApproximationMode::ERF;
     const auto gelu = make_shared<opset7::Gelu>(data_input, approximation_mode);
-    NodeBuilder builder(gelu);
+    NodeBuilder builder(gelu, {data_input});
     auto g_gelu = ov::as_type_ptr<opset7::Gelu>(builder.create());
 
     EXPECT_EQ(g_gelu->get_approximation_mode(), gelu->get_approximation_mode());
 }
+
+TEST(attributes, gelu_op_tanh) {
+    NodeBuilder::get_ops().register_factory<opset7::Gelu>();
+    const auto data_input = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
+    const auto approximation_mode = op::GeluApproximationMode::TANH;
+    const auto gelu = make_shared<opset7::Gelu>(data_input, approximation_mode);
+    NodeBuilder builder(gelu, {data_input});
+    auto g_gelu = ov::as_type_ptr<opset7::Gelu>(builder.create());
+
+    EXPECT_EQ(g_gelu->get_approximation_mode(), gelu->get_approximation_mode());
+}
+
+TEST(attributes, gelu_op) {
+    NodeBuilder::get_ops().register_factory<opset7::Gelu>();
+    const auto data_input = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
+    const auto gelu = make_shared<opset7::Gelu>(data_input);
+    NodeBuilder builder(gelu, {data_input});
+    auto g_gelu = ov::as_type_ptr<opset7::Gelu>(builder.create());
+
+    EXPECT_EQ(g_gelu->get_approximation_mode(), gelu->get_approximation_mode());
+}
+
+TEST(attributes, gelu_v0_op) {
+    NodeBuilder::get_ops().register_factory<opset2::Gelu>();
+    const auto data_input = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
+    const auto gelu = make_shared<opset2::Gelu>(data_input);
+    NodeBuilder builder(gelu, {data_input});
+    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_gelu = ov::as_type_ptr<op::v7::DFT>(builder.create()));
+
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+}

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

@@ -36,7 +36,7 @@ TEST(attributes, generate_proposals) {
 
     auto proposals = std::make_shared<GenerateProposals>(im_info, anchors, deltas, scores, attrs);
 
-    NodeBuilder builder(proposals);
+    NodeBuilder builder(proposals, {im_info, anchors, deltas, scores});
 
     auto g_proposals = ov::as_type_ptr<GenerateProposals>(builder.create());
 

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

@@ -18,7 +18,8 @@ TEST(attributes, grid_sample_defaults) {
     const auto grid = make_shared<opset9::Parameter>(element::f32, Shape{1, 5, 5, 2});
 
     const auto op = make_shared<opset9::GridSample>(data, grid, opset9::GridSample::Attributes{});
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data, grid});
+    EXPECT_NO_THROW(auto g_op = ov::as_type_ptr<opset9::GridSample>(builder.create()));
 
     const auto expected_attr_count = 3;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -19,7 +19,7 @@ TEST(attributes, grn_op) {
     float bias = 1.25f;
 
     auto grn = make_shared<opset1::GRN>(data, bias);
-    NodeBuilder builder(grn);
+    NodeBuilder builder(grn, {data});
     auto g_grn = ov::as_type_ptr<opset1::GRN>(builder.create());
 
     const auto expected_attr_count = 1;

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

@@ -31,7 +31,7 @@ TEST(attributes, group_conv_op) {
                                                             pads_end,
                                                             dilations,
                                                             op::PadType::VALID);
-    NodeBuilder builder(group_conv);
+    NodeBuilder builder(group_conv, {data, filters});
     auto g_group_conv = ov::as_type_ptr<opset1::GroupConvolution>(builder.create());
     EXPECT_EQ(g_group_conv->get_strides(), group_conv->get_strides());
     EXPECT_EQ(g_group_conv->get_pads_begin(), group_conv->get_pads_begin());
@@ -62,7 +62,7 @@ TEST(attributes, group_conv_backprop_data_op) {
                                                                         dilations,
                                                                         auto_pad,
                                                                         output_padding);
-    NodeBuilder builder(gcbd);
+    NodeBuilder builder(gcbd, {data, filter});
     const auto g_gcbd = ov::as_type_ptr<opset1::GroupConvolutionBackpropData>(builder.create());
 
     EXPECT_EQ(g_gcbd->get_strides(), gcbd->get_strides());

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

@@ -39,7 +39,7 @@ TEST(attributes, gru_cell_op) {
                                                        activations_beta,
                                                        clip,
                                                        false);
-    NodeBuilder builder(gru_cell);
+    NodeBuilder builder(gru_cell, {X, initial_hidden_state, W, R});
     auto g_gru_cell = ov::as_type_ptr<opset5::GRUCell>(builder.create());
 
     EXPECT_EQ(g_gru_cell->get_hidden_size(), gru_cell->get_hidden_size());

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

@@ -53,7 +53,7 @@ TEST(attributes, gru_sequence_op) {
                                                                activations_alpha,
                                                                activations_beta,
                                                                clip_threshold);
-    NodeBuilder builder(gru_sequence);
+    NodeBuilder builder(gru_sequence, {X, initial_hidden_state, sequence_lengths, W, R, B});
     auto g_gru_sequence = ov::as_type_ptr<opset5::GRUSequence>(builder.create());
 
     EXPECT_EQ(g_gru_sequence->get_hidden_size(), gru_sequence->get_hidden_size());

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

@@ -19,7 +19,8 @@ TEST(attributes, hardsigmoid_op) {
     const auto beta = make_shared<op::Parameter>(element::f32, Shape{});
 
     const auto hardsigmoid = make_shared<opset1::HardSigmoid>(data, alpha, beta);
-    NodeBuilder builder(hardsigmoid);
+    NodeBuilder builder(hardsigmoid, {data, alpha, beta});
+    EXPECT_NO_THROW(auto g_hardsigmoid = ov::as_type_ptr<opset1::HardSigmoid>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -17,9 +17,10 @@ TEST(attributes, idft_op) {
     auto axes = op::Constant::create<int64_t>(element::Type_t::i64, Shape{1}, {2});
     auto idft = make_shared<op::v7::IDFT>(data, axes);
 
-    NodeBuilder builder(idft);
+    NodeBuilder builder(idft, {data, axes});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_idft = ov::as_type_ptr<op::v7::IDFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
 
@@ -30,8 +31,9 @@ TEST(attributes, idft_op_signal) {
     auto signal = op::Constant::create<int64_t>(element::Type_t::i64, Shape{1}, {20});
     auto idft = make_shared<op::v7::IDFT>(data, axes, signal);
 
-    NodeBuilder builder(idft);
+    NodeBuilder builder(idft, {data, axes, signal});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_idft = ov::as_type_ptr<op::v7::IDFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -30,7 +30,7 @@ TEST(attributes, interpolate_op1) {
     interp_atrs.pads_end = vector<size_t>{0, 0};
 
     auto interpolate = make_shared<opset1::Interpolate>(img, out_shape, interp_atrs);
-    NodeBuilder builder(interpolate);
+    NodeBuilder builder(interpolate, {img, out_shape});
     auto g_interpolate = ov::as_type_ptr<opset1::Interpolate>(builder.create());
 
     const auto i_attrs = interpolate->get_attrs();
@@ -61,7 +61,7 @@ TEST(attributes, interpolate_op4) {
     attrs.cube_coeff = -0.75;
 
     auto interpolate = make_shared<opset4::Interpolate>(img, out_shape, scales, attrs);
-    NodeBuilder builder(interpolate);
+    NodeBuilder builder(interpolate, {img, out_shape, scales});
     auto g_interpolate = ov::as_type_ptr<opset4::Interpolate>(builder.create());
 
     const auto i_attrs = interpolate->get_attrs();

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

@@ -17,9 +17,10 @@ TEST(attributes, irdft_op) {
     auto axes = op::v0::Constant::create<int64_t>(element::i64, Shape{1}, {2});
     auto irdft = make_shared<op::v9::IRDFT>(data, axes);
 
-    NodeBuilder builder(irdft);
+    NodeBuilder builder(irdft, {data, axes});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_irdft = ov::as_type_ptr<op::v9::IRDFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
 
@@ -30,8 +31,9 @@ TEST(attributes, irdft_op_signal) {
     auto axes = op::v0::Constant::create<int64_t>(element::i64, Shape{1}, {2});
     auto irdft = make_shared<op::v9::IRDFT>(data, axes, signal);
 
-    NodeBuilder builder(irdft);
+    NodeBuilder builder(irdft, {data, axes, signal});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_irdft = ov::as_type_ptr<op::v9::IRDFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -23,7 +23,7 @@ TEST(attributes, logsoftmax_op) {
     int64_t axis = 2;
 
     const auto logsoftmax = make_shared<opset5::LogSoftmax>(data, axis);
-    NodeBuilder builder(logsoftmax);
+    NodeBuilder builder(logsoftmax, {data});
     auto g_logsoftmax = ov::as_type_ptr<opset5::LogSoftmax>(builder.create());
 
     const auto expected_attr_count = 1;

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

@@ -27,7 +27,7 @@ TEST(attributes, lrn_op) {
     const size_t size = 4;
 
     const auto lrn = make_shared<opset1::LRN>(arg, axes, alpha, beta, bias, size);
-    NodeBuilder builder(lrn);
+    NodeBuilder builder(lrn, {arg, axes});
     auto g_lrn = ov::as_type_ptr<opset1::LRN>(builder.create());
 
     EXPECT_EQ(g_lrn->get_alpha(), lrn->get_alpha());

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

@@ -16,7 +16,45 @@ using namespace ngraph;
 using ngraph::test::NodeBuilder;
 using ngraph::test::ValueMap;
 
-TEST(attributes, lstm_cell_op) {
+TEST(attributes, lstm_cell_v0_op) {
+    NodeBuilder::get_ops().register_factory<opset1::LSTMCell>();
+    auto X = make_shared<op::Parameter>(element::f32, Shape{2, 3});
+    auto H = make_shared<op::Parameter>(element::f32, Shape{2, 3});
+    auto W = make_shared<op::Parameter>(element::f32, Shape{12, 3});
+    auto R = make_shared<op::Parameter>(element::f32, Shape{12, 3});
+    const auto initial_hidden_state = make_shared<op::Parameter>(element::f32, Shape{2, 3});
+    const auto initial_cell_state = make_shared<op::Parameter>(element::f32, Shape{2, 3});
+
+    const auto hidden_size = 3;
+    auto weights_format = ov::op::LSTMWeightsFormat::IFCO;
+    const std::vector<std::string> activations = {"tanh", "sigmoid", "tanh"};
+    auto activations_alpha = std::vector<float>{1.0, 1.5};
+    auto activations_beta = std::vector<float>{2.0, 1.0};
+    const float clip = 0.5f;
+    auto input_forget = false;
+    const auto lstm_cell = make_shared<opset1::LSTMCell>(X,
+                                                         initial_hidden_state,
+                                                         initial_cell_state,
+                                                         W,
+                                                         R,
+                                                         hidden_size,
+                                                         weights_format,
+                                                         activations,
+                                                         activations_alpha,
+                                                         activations_beta,
+                                                         clip,
+                                                         input_forget);
+    NodeBuilder builder(lstm_cell, {X, initial_hidden_state, initial_cell_state, W, R});
+    auto g_lstm_cell = ov::as_type_ptr<opset1::LSTMCell>(builder.create());
+
+    EXPECT_EQ(g_lstm_cell->get_hidden_size(), lstm_cell->get_hidden_size());
+    EXPECT_EQ(g_lstm_cell->get_activations(), lstm_cell->get_activations());
+    EXPECT_EQ(g_lstm_cell->get_activations_alpha(), lstm_cell->get_activations_alpha());
+    EXPECT_EQ(g_lstm_cell->get_activations_beta(), lstm_cell->get_activations_beta());
+    EXPECT_EQ(g_lstm_cell->get_clip(), lstm_cell->get_clip());
+}
+
+TEST(attributes, lstm_cell_v4_op) {
     NodeBuilder::get_ops().register_factory<opset4::LSTMCell>();
     auto X = make_shared<op::Parameter>(element::f32, Shape{2, 3});
     auto H = make_shared<op::Parameter>(element::f32, Shape{2, 3});
@@ -40,7 +78,7 @@ TEST(attributes, lstm_cell_op) {
                                                          activations_alpha,
                                                          activations_beta,
                                                          clip);
-    NodeBuilder builder(lstm_cell);
+    NodeBuilder builder(lstm_cell, {X, initial_hidden_state, initial_cell_state, W, R});
     auto g_lstm_cell = ov::as_type_ptr<opset4::LSTMCell>(builder.create());
 
     EXPECT_EQ(g_lstm_cell->get_hidden_size(), lstm_cell->get_hidden_size());

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

@@ -54,7 +54,7 @@ TEST(attributes, lstm_sequence_op) {
                                                                  activations_beta,
                                                                  activations,
                                                                  clip_threshold);
-    NodeBuilder builder(lstm_sequence);
+    NodeBuilder builder(lstm_sequence, {X, initial_hidden_state, initial_cell_state, sequence_lengths, W, R, B});
     auto g_lstm_sequence = ov::as_type_ptr<opset5::LSTMSequence>(builder.create());
 
     EXPECT_EQ(g_lstm_sequence->get_hidden_size(), lstm_sequence->get_hidden_size());
@@ -109,7 +109,7 @@ TEST(attributes, lstm_sequence_v1_op) {
                                                                  activations,
                                                                  clip_threshold,
                                                                  input_forget);
-    NodeBuilder builder(lstm_sequence);
+    NodeBuilder builder(lstm_sequence, {X, initial_hidden_state, initial_cell_state, sequence_lengths, W, R, B, P});
     auto g_lstm_sequence = ov::as_type_ptr<opset1::LSTMSequence>(builder.create());
 
     EXPECT_EQ(g_lstm_sequence->get_hidden_size(), lstm_sequence->get_hidden_size());

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

@@ -25,7 +25,78 @@ TEST(attributes, matmul_op) {
     bool transpose_b = true;
 
     auto matmul = make_shared<opset1::MatMul>(A, B, transpose_a, transpose_b);
-    NodeBuilder builder(matmul);
+    NodeBuilder builder(matmul, {A, B});
+    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());
+}
+
+TEST(attributes, matmul_op2) {
+    NodeBuilder::get_ops().register_factory<opset1::MatMul>();
+    auto A = make_shared<op::Parameter>(element::f32, Shape{10, 2});
+    auto B = make_shared<op::Parameter>(element::f32, Shape{2, 1});
+
+    bool transpose_a = false;
+    bool transpose_b = false;
+
+    auto matmul = make_shared<opset1::MatMul>(A, B, transpose_a, transpose_b);
+    NodeBuilder builder(matmul, {A, B});
+    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());
+}
+
+TEST(attributes, matmul_op3) {
+    NodeBuilder::get_ops().register_factory<opset1::MatMul>();
+    auto A = make_shared<op::Parameter>(element::f32, Shape{2, 10});
+    auto B = make_shared<op::Parameter>(element::f32, Shape{2, 1});
+
+    bool transpose_a = true;
+    bool transpose_b = false;
+
+    auto matmul = make_shared<opset1::MatMul>(A, B, transpose_a, transpose_b);
+    NodeBuilder builder(matmul, {A, B});
+    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());
+}
+
+TEST(attributes, matmul_op4) {
+    NodeBuilder::get_ops().register_factory<opset1::MatMul>();
+    auto A = make_shared<op::Parameter>(element::f32, Shape{2, 3, 2});
+    auto B = make_shared<op::Parameter>(element::f32, Shape{3, 2, 2, 1});
+
+    auto matmul = make_shared<opset1::MatMul>(A, B);
+    NodeBuilder builder(matmul, {A, B});
+    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());
+}
+
+TEST(attributes, matmul_op5) {
+    NodeBuilder::get_ops().register_factory<opset1::MatMul>();
+    auto A = make_shared<op::Parameter>(element::f32, Shape{2});
+    auto B = make_shared<op::Parameter>(element::f32, Shape{2, 10});
+
+    auto matmul = make_shared<opset1::MatMul>(A, B);
+    NodeBuilder builder(matmul, {A, B});
+    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());
+}
+
+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, {A, B});
     auto g_matmul = ov::as_type_ptr<opset1::MatMul>(builder.create());
 
     EXPECT_EQ(g_matmul->get_transpose_a(), matmul->get_transpose_a());

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

@@ -36,7 +36,7 @@ TEST(attributes, matrix_nms_v8_op_custom_attributes) {
     attrs.normalized = false;
 
     auto nms = make_shared<opset8::MatrixNms>(boxes, scores, attrs);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset8::MatrixNms>(builder.create());
     const auto expected_attr_count = 11;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -75,7 +75,7 @@ TEST(attributes, matrix_nms_v8_op_default_attributes) {
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
     auto nms = make_shared<opset8::MatrixNms>(boxes, scores, opset8::MatrixNms::Attributes());
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset8::MatrixNms>(builder.create());
     const auto expected_attr_count = 11;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -26,7 +26,7 @@ TEST(attributes, max_pool_op) {
     auto auto_pad = op::PadType::EXPLICIT;
 
     auto max_pool = make_shared<opset1::MaxPool>(data, strides, pads_begin, pads_end, kernel, rounding_mode, auto_pad);
-    NodeBuilder builder(max_pool);
+    NodeBuilder builder(max_pool, {data});
     auto g_max_pool = ov::as_type_ptr<opset1::MaxPool>(builder.create());
 
     EXPECT_EQ(g_max_pool->get_strides(), max_pool->get_strides());
@@ -59,7 +59,7 @@ TEST(attributes, max_pool_v8_op) {
                                                        rounding_mode,
                                                        auto_pad,
                                                        index_element_type);
-    NodeBuilder builder(max_pool);
+    NodeBuilder builder(max_pool, {data});
     auto g_max_pool = ov::as_type_ptr<opset8::MaxPool>(builder.create());
 
     EXPECT_EQ(g_max_pool->get_strides(), max_pool->get_strides());

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

@@ -17,7 +17,8 @@ TEST(attributes, mish_op) {
     const auto A = make_shared<op::Parameter>(element::f32, Shape{5, 2});
 
     const auto mish = make_shared<opset4::Mish>(A);
-    NodeBuilder builder(mish);
+    NodeBuilder builder(mish, {A});
+    EXPECT_NO_THROW(auto g_mish = ov::as_type_ptr<opset4::Mish>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -33,7 +33,7 @@ TEST(attributes, multiclass_nms_v8_op_custom_attributes) {
     attrs.normalized = false;
 
     auto nms = make_shared<opset8::MulticlassNms>(boxes, scores, attrs);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset8::MulticlassNms>(builder.create());
     const auto expected_attr_count = 10;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -70,7 +70,7 @@ TEST(attributes, multiclass_nms_v8_op_default_attributes) {
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
     auto nms = make_shared<opset8::MulticlassNms>(boxes, scores, opset8::MulticlassNms::Attributes());
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset8::MulticlassNms>(builder.create());
     const auto expected_attr_count = 10;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -109,7 +109,7 @@ TEST(attributes, multiclass_nms_v9_op_custom_attributes) {
     attrs.normalized = false;
 
     auto nms = make_shared<opset9::MulticlassNms>(boxes, scores, roisnum, attrs);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores, roisnum});
     auto g_nms = ov::as_type_ptr<opset9::MulticlassNms>(builder.create());
     const auto expected_attr_count = 10;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -147,7 +147,7 @@ TEST(attributes, multiclass_nms_v9_op_default_attributes) {
     auto roisnum = make_shared<op::Parameter>(element::i32, Shape{2});
 
     auto nms = make_shared<opset9::MulticlassNms>(boxes, scores, roisnum, opset9::MulticlassNms::Attributes());
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores, roisnum});
     auto g_nms = ov::as_type_ptr<opset9::MulticlassNms>(builder.create());
     const auto expected_attr_count = 10;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -25,7 +25,7 @@ TEST(attributes, mvn_v1_op) {
 
     const auto op = make_shared<opset3::MVN>(data, true, false, 0.1);
     op->set_reduction_axes(axes);
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data});
     const auto g_op = ov::as_type_ptr<opset3::MVN>(builder.create());
     const auto expected_attr_count = 4;
 
@@ -43,7 +43,7 @@ TEST(attributes, mvn_v6_op) {
 
     const auto op = make_shared<opset6::MVN>(data, axes, false, 0.1, op::MVNEpsMode::INSIDE_SQRT);
 
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data, axes});
     const auto g_op = ov::as_type_ptr<opset6::MVN>(builder.create());
     const auto expected_attr_count = 3;
 

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

@@ -25,7 +25,7 @@ TEST(attributes, non_max_suppression_op_custom_attributes) {
     bool sort_result_descending = false;
 
     auto nms = make_shared<opset1::NonMaxSuppression>(boxes, scores, box_encoding, sort_result_descending);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset1::NonMaxSuppression>(builder.create());
 
     EXPECT_EQ(g_nms->get_box_encoding(), nms->get_box_encoding());
@@ -38,7 +38,7 @@ TEST(attributes, non_max_suppression_op_default_attributes) {
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
     auto nms = make_shared<opset1::NonMaxSuppression>(boxes, scores);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset1::NonMaxSuppression>(builder.create());
 
     EXPECT_EQ(g_nms->get_box_encoding(), nms->get_box_encoding());
@@ -55,7 +55,7 @@ TEST(attributes, non_max_suppression_v3_op_custom_attributes) {
     element::Type output_type = element::i32;
 
     auto nms = make_shared<opset3::NonMaxSuppression>(boxes, scores, box_encoding, sort_result_descending, output_type);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset3::NonMaxSuppression>(builder.create());
 
     EXPECT_EQ(g_nms->get_box_encoding(), nms->get_box_encoding());
@@ -69,7 +69,7 @@ TEST(attributes, non_max_suppression_v3_op_default_attributes) {
     auto scores = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
 
     auto nms = make_shared<opset3::NonMaxSuppression>(boxes, scores);
-    NodeBuilder builder(nms);
+    NodeBuilder builder(nms, {boxes, scores});
     auto g_nms = ov::as_type_ptr<opset3::NonMaxSuppression>(builder.create());
 
     EXPECT_EQ(g_nms->get_box_encoding(), nms->get_box_encoding());

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

@@ -18,7 +18,9 @@ TEST(attributes, non_zero_op_default) {
     const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1});
     const auto non_zero = make_shared<op::NonZero>(data_node);
 
-    NodeBuilder builder(non_zero);
+    NodeBuilder builder(non_zero, {data_node});
+    EXPECT_NO_THROW(auto g_non_zero = ov::as_type_ptr<opset3::NonZero>(builder.create()));
+
     const auto expected_attr_count = 1;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -30,7 +32,8 @@ TEST(attributes, non_zero_op_i32) {
     const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1});
     const auto non_zero = make_shared<op::NonZero>(data_node, element::i32);
 
-    NodeBuilder builder(non_zero);
+    NodeBuilder builder(non_zero, {data_node});
+    EXPECT_NO_THROW(auto g_non_zero = ov::as_type_ptr<opset3::NonZero>(builder.create()));
     const auto expected_attr_count = 1;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -42,7 +45,8 @@ TEST(attributes, non_zero_op_i32_string) {
     const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1});
     const auto non_zero = make_shared<op::NonZero>(data_node, "i32");
 
-    NodeBuilder builder(non_zero);
+    NodeBuilder builder(non_zero, {data_node});
+    EXPECT_NO_THROW(auto g_non_zero = ov::as_type_ptr<opset3::NonZero>(builder.create()));
     const auto expected_attr_count = 1;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -54,7 +58,8 @@ TEST(attributes, non_zero_op_i64) {
     const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1});
     const auto non_zero = make_shared<op::NonZero>(data_node, element::i64);
 
-    NodeBuilder builder(non_zero);
+    NodeBuilder builder(non_zero, {data_node});
+    EXPECT_NO_THROW(auto g_non_zero = ov::as_type_ptr<opset3::NonZero>(builder.create()));
     const auto expected_attr_count = 1;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -66,7 +71,8 @@ TEST(attributes, non_zero_op_i64_string) {
     const auto data_node = make_shared<op::Parameter>(element::f32, Shape{1});
     const auto non_zero = make_shared<op::NonZero>(data_node, "i64");
 
-    NodeBuilder builder(non_zero);
+    NodeBuilder builder(non_zero, {data_node});
+    EXPECT_NO_THROW(auto g_non_zero = ov::as_type_ptr<opset3::NonZero>(builder.create()));
     const auto expected_attr_count = 1;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -18,7 +18,7 @@ void static test_normalize_l2_attributes(float eps, op::EpsMode eps_mode) {
     const auto axes = make_shared<op::Constant>(element::i32, Shape{}, vector<int32_t>{1});
 
     auto normalize_l2 = make_shared<opset1::NormalizeL2>(data, axes, eps, eps_mode);
-    NodeBuilder builder(normalize_l2);
+    NodeBuilder builder(normalize_l2, {data, axes});
     auto g_normalize_l2 = ov::as_type_ptr<opset1::NormalizeL2>(builder.create());
 
     const auto expected_attr_count = 2;

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

@@ -26,7 +26,7 @@ TEST(attributes, one_hot_op) {
     int64_t axis = 3;
 
     auto one_hot = make_shared<opset1::OneHot>(indices, depth, on_value, off_value, axis);
-    NodeBuilder builder(one_hot);
+    NodeBuilder builder(one_hot, {indices, depth, on_value, off_value});
     auto g_one_hot = ov::as_type_ptr<opset1::OneHot>(builder.create());
 
     EXPECT_EQ(g_one_hot->get_axis(), one_hot->get_axis());

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

@@ -25,8 +25,28 @@ TEST(attributes, pad_op) {
     auto pad_mode = op::PadMode::EDGE;
 
     auto pad = make_shared<opset1::Pad>(arg, pads_begin, pads_end, pad_mode);
-    NodeBuilder builder(pad);
+    NodeBuilder builder(pad, {arg, pads_begin, pads_end});
     auto g_pad = ov::as_type_ptr<opset1::Pad>(builder.create());
 
     EXPECT_EQ(g_pad->get_pad_mode(), pad->get_pad_mode());
+    EXPECT_EQ(g_pad->get_pads_begin(), pad->get_pads_begin());
+    EXPECT_EQ(g_pad->get_pads_end(), pad->get_pads_end());
+}
+
+TEST(attributes, pad_op2) {
+    NodeBuilder::get_ops().register_factory<opset1::Pad>();
+    auto arg = make_shared<op::Parameter>(element::f32, Shape{1, 2, 3});
+    auto pads_begin = make_shared<op::Parameter>(element::i64, Shape{1});
+    auto pads_end = make_shared<op::Parameter>(element::i64, Shape{1});
+    auto pad_value = make_shared<op::Parameter>(element::f32, Shape{});
+
+    auto pad_mode = op::PadMode::CONSTANT;
+
+    auto pad = make_shared<opset1::Pad>(arg, pads_begin, pads_end, pad_value, pad_mode);
+    NodeBuilder builder(pad, {arg, pads_begin, pads_end, pad_value});
+    auto g_pad = ov::as_type_ptr<opset1::Pad>(builder.create());
+
+    EXPECT_EQ(g_pad->get_pad_mode(), pad->get_pad_mode());
+    EXPECT_EQ(g_pad->get_pads_begin(), pad->get_pads_begin());
+    EXPECT_EQ(g_pad->get_pads_end(), pad->get_pads_end());
 }

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

@@ -18,7 +18,8 @@ TEST(attributes, prelu_op) {
     const auto slope = make_shared<op::Parameter>(element::f32, Shape{5});
 
     const auto prelu = make_shared<opset1::PRelu>(data, slope);
-    NodeBuilder builder(prelu);
+    NodeBuilder builder(prelu, {data, slope});
+    EXPECT_NO_THROW(auto g_prelu = ov::as_type_ptr<opset1::PRelu>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -37,7 +37,7 @@ TEST(attributes, prior_box_op) {
     attrs.scale_all_sizes = true;
 
     auto prior_box = make_shared<opset1::PriorBox>(layer_shape, image_shape, attrs);
-    NodeBuilder builder(prior_box);
+    NodeBuilder builder(prior_box, {layer_shape, image_shape});
     auto g_prior_box = ov::as_type_ptr<opset1::PriorBox>(builder.create());
 
     const auto prior_box_attrs = prior_box->get_attrs();
@@ -57,6 +57,50 @@ TEST(attributes, prior_box_op) {
     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);
+    EXPECT_EQ(g_prior_box->has_evaluate(), prior_box->has_evaluate());
+}
+
+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, {layer_shape, image_shape});
+    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);
+    EXPECT_EQ(g_prior_box->has_evaluate(), prior_box->has_evaluate());
 }
 
 TEST(attributes, prior_box_v8_op) {
@@ -80,7 +124,7 @@ TEST(attributes, prior_box_v8_op) {
     attrs.min_max_aspect_ratios_order = false;
 
     auto prior_box = make_shared<opset8::PriorBox>(layer_shape, image_shape, attrs);
-    NodeBuilder builder(prior_box);
+    NodeBuilder builder(prior_box, {layer_shape, image_shape});
     auto g_prior_box = ov::as_type_ptr<opset8::PriorBox>(builder.create());
 
     const auto prior_box_attrs = prior_box->get_attrs();
@@ -101,4 +145,5 @@ TEST(attributes, prior_box_v8_op) {
     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);
     EXPECT_EQ(g_prior_box_attrs.min_max_aspect_ratios_order, prior_box_attrs.min_max_aspect_ratios_order);
+    EXPECT_EQ(g_prior_box->has_evaluate(), prior_box->has_evaluate());
 }

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

@@ -28,7 +28,7 @@ TEST(attributes, prior_box_clustered_op) {
     attrs.variances = {0.1f};
 
     auto pbc = make_shared<opset1::PriorBoxClustered>(layer_shape, image_shape, attrs);
-    NodeBuilder builder(pbc);
+    NodeBuilder builder(pbc, {layer_shape, image_shape});
     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();
@@ -43,4 +43,39 @@ TEST(attributes, prior_box_clustered_op) {
     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);
+    EXPECT_EQ(g_pbc->has_evaluate(), pbc->has_evaluate());
+}
+
+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, {layer_shape, image_shape});
+    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);
+    EXPECT_EQ(g_pbc->has_evaluate(), pbc->has_evaluate());
 }

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

@@ -39,7 +39,46 @@ TEST(attributes, proposal_op) {
     attrs.framework = string{"nGraph"};
 
     auto proposal = make_shared<opset1::Proposal>(class_probs, class_logits, image_shape, attrs);
-    NodeBuilder builder(proposal);
+    NodeBuilder builder(proposal, {class_probs, class_logits, image_shape});
+    auto g_proposal = ov::as_type_ptr<opset1::Proposal>(builder.create());
+
+    const auto proposal_attrs = proposal->get_attrs();
+    const auto g_proposal_attrs = g_proposal->get_attrs();
+
+    EXPECT_EQ(g_proposal_attrs.base_size, proposal_attrs.base_size);
+    EXPECT_EQ(g_proposal_attrs.pre_nms_topn, proposal_attrs.pre_nms_topn);
+    EXPECT_EQ(g_proposal_attrs.post_nms_topn, proposal_attrs.post_nms_topn);
+    EXPECT_EQ(g_proposal_attrs.nms_thresh, proposal_attrs.nms_thresh);
+    EXPECT_EQ(g_proposal_attrs.feat_stride, proposal_attrs.feat_stride);
+    EXPECT_EQ(g_proposal_attrs.min_size, proposal_attrs.min_size);
+    EXPECT_EQ(g_proposal_attrs.ratio, proposal_attrs.ratio);
+    EXPECT_EQ(g_proposal_attrs.scale, proposal_attrs.scale);
+    EXPECT_EQ(g_proposal_attrs.clip_before_nms, proposal_attrs.clip_before_nms);
+    EXPECT_EQ(g_proposal_attrs.clip_after_nms, proposal_attrs.clip_after_nms);
+    EXPECT_EQ(g_proposal_attrs.normalize, proposal_attrs.normalize);
+    EXPECT_EQ(g_proposal_attrs.box_size_scale, proposal_attrs.box_size_scale);
+    EXPECT_EQ(g_proposal_attrs.box_coordinate_scale, proposal_attrs.box_coordinate_scale);
+    EXPECT_EQ(g_proposal_attrs.framework, proposal_attrs.framework);
+}
+
+TEST(attributes, proposal_op2) {
+    NodeBuilder::get_ops().register_factory<opset1::Proposal>();
+    const auto class_probs = make_shared<op::Parameter>(element::f32, Shape{1, 12, 34, 62});
+    const auto class_logits = make_shared<op::Parameter>(element::f32, Shape{1, 24, 34, 62});
+    const auto image_shape = make_shared<op::Parameter>(element::f32, Shape{3});
+
+    op::ProposalAttrs attrs;
+    attrs.base_size = 16;
+    attrs.pre_nms_topn = 6000;
+    attrs.post_nms_topn = 200;
+    attrs.nms_thresh = 0.6f;
+    attrs.feat_stride = 16;
+    attrs.min_size = 16;
+    attrs.ratio = vector<float>{2.669f};
+    attrs.scale = vector<float>{4.0f, 6.0f, 9.0f, 16.0f, 24.0f, 32.0f};
+
+    auto proposal = make_shared<opset1::Proposal>(class_probs, class_logits, image_shape, attrs);
+    NodeBuilder builder(proposal, {class_probs, class_logits, image_shape});
     auto g_proposal = ov::as_type_ptr<opset1::Proposal>(builder.create());
 
     const auto proposal_attrs = proposal->get_attrs();

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

@@ -36,7 +36,7 @@ TEST(attributes, psroi_pooling_op) {
                                                         spatial_bins_x,
                                                         spatial_bins_y,
                                                         mode);
-    NodeBuilder builder(psroi_pool);
+    NodeBuilder builder(psroi_pool, {input, coords});
     auto g_psroi_pool = ov::as_type_ptr<opset1::PSROIPooling>(builder.create());
 
     EXPECT_EQ(g_psroi_pool->get_output_dim(), psroi_pool->get_output_dim());

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

@@ -21,7 +21,7 @@ TEST(attributes, random_uniform_op) {
 
     const auto random_uniform =
         make_shared<opset8::RandomUniform>(out_shape, min_val, max_val, element::Type_t::f32, 150, 10);
-    NodeBuilder builder(random_uniform);
+    NodeBuilder builder(random_uniform, {out_shape, min_val, max_val});
     auto g_random_uniform = ov::as_type_ptr<opset8::RandomUniform>(builder.create());
 
     const auto expected_attr_count = 3;

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

@@ -0,0 +1,29 @@
+// Copyright (C) 2018-2022 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "gtest/gtest.h"
+#include "ngraph/ngraph.hpp"
+#include "ngraph/op/util/attr_types.hpp"
+#include "ngraph/opsets/opset1.hpp"
+#include "ngraph/opsets/opset4.hpp"
+#include "util/visitor.hpp"
+
+using namespace std;
+using namespace ngraph;
+using ngraph::test::NodeBuilder;
+using ngraph::test::ValueMap;
+
+TEST(attributes, range_op) {
+    NodeBuilder::get_ops().register_factory<opset4::Range>();
+    auto start = make_shared<op::Parameter>(element::i64, Shape{});
+    auto stop = make_shared<op::Parameter>(element::i64, Shape{});
+    auto step = make_shared<op::Parameter>(element::i64, Shape{});
+    auto output_type = element::f32;
+
+    auto range = make_shared<opset4::Range>(start, stop, step, output_type);
+    NodeBuilder builder(range, {start, stop, step});
+    auto g_range = ov::as_type_ptr<opset4::Range>(builder.create());
+
+    EXPECT_EQ(g_range->get_output_type(), range->get_output_type());
+}

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

@@ -17,9 +17,10 @@ TEST(attributes, rdft_op) {
     auto axes = op::v0::Constant::create<int64_t>(element::i64, Shape{1}, {2});
     auto rdft = make_shared<op::v9::RDFT>(data, axes);
 
-    NodeBuilder builder(rdft);
+    NodeBuilder builder(rdft, {data, axes});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_rdft = ov::as_type_ptr<op::v9::RDFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
 
@@ -30,8 +31,9 @@ TEST(attributes, rdft_op_signal) {
     auto axes = op::v0::Constant::create<int64_t>(element::i64, Shape{1}, {2});
     auto rdft = make_shared<op::v9::RDFT>(data, axes, signal);
 
-    NodeBuilder builder(rdft);
+    NodeBuilder builder(rdft, {data, axes, signal});
-    const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_rdft = ov::as_type_ptr<op::v9::RDFT>(builder.create()));
 
+    const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -19,7 +19,8 @@ TEST(attributes, readvalue_v3_op) {
     const auto in = make_shared<op::Parameter>(element::f32, Shape{1});
     const string variable_id = "v0";
     const auto read_value = make_shared<opset3::ReadValue>(in, variable_id);
-    NodeBuilder builder(read_value);
+    NodeBuilder builder(read_value, {in});
+    EXPECT_NO_THROW(auto g_read_value = ov::as_type_ptr<opset3::ReadValue>(builder.create()));
 
     // attribute count
     const auto expected_attr_count = 1;
@@ -31,7 +32,8 @@ TEST(attributes, readvalue_v6_op) {
     const auto in = make_shared<op::Parameter>(element::f32, Shape{1});
     const auto variable = std::make_shared<Variable>(VariableInfo{PartialShape::dynamic(), element::dynamic, "v0"});
     const auto read_value = make_shared<opset6::ReadValue>(in, variable);
-    NodeBuilder builder(read_value);
+    NodeBuilder builder(read_value, {in});
+    EXPECT_NO_THROW(auto g_read_value = ov::as_type_ptr<opset6::ReadValue>(builder.create()));
 
     // attribute count
     const auto expected_attr_count = 1;

src/core/tests/visitors/op/reduce_ops.hpp

@@ -59,7 +59,7 @@ TYPED_TEST_P(ReduceOperatorVisitor, keep_dims_3D)
     const auto reduction_axes = make_shared<op::Parameter>(axes_et, axes_shape);
     const auto reduce_op = make_shared<OP_Type>(data, reduction_axes, keep_dims);
 
-    NodeBuilder builder(reduce_op);
+    NodeBuilder builder(reduce_op, {data, reduction_axes});
     const auto expected_attr_count = 1;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
     auto g_reduce_op = as_type_ptr<OP_Type>(builder.create());
@@ -83,7 +83,7 @@ TYPED_TEST_P(ReduceOperatorVisitor, do_not_keep_dims_3D)
     const auto reduction_axes = make_shared<op::Parameter>(axes_et, axes_shape);
     const auto reduce_op = make_shared<OP_Type>(data, reduction_axes, keep_dims);
 
-    NodeBuilder builder(reduce_op);
+    NodeBuilder builder(reduce_op, {data, reduction_axes});
     const auto expected_attr_count = 1;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
     auto g_reduce_op = ov::as_type_ptr<OP_Type>(builder.create());

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

@@ -38,7 +38,7 @@ TEST(attributes, region_yolo_op) {
                                                        axis,
                                                        end_axis,
                                                        anchors);
-    NodeBuilder builder(region_yolo);
+    NodeBuilder builder(region_yolo, {data});
     auto g_region_yolo = ov::as_type_ptr<opset1::RegionYolo>(builder.create());
 
     EXPECT_EQ(g_region_yolo->get_num_coords(), region_yolo->get_num_coords());

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

@@ -21,7 +21,7 @@ TEST(attributes, reorg_yolo_op_stride) {
     const auto data = make_shared<op::Parameter>(element::i32, Shape{1, 64, 26, 26});
 
     const auto op = make_shared<op::v0::ReorgYolo>(data, 2);
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data});
     const auto g_op = ov::as_type_ptr<op::v0::ReorgYolo>(builder.create());
 
     EXPECT_EQ(g_op->get_strides(), op->get_strides());
@@ -32,7 +32,7 @@ TEST(attributes, reorg_yolo_op_strides) {
     const auto data = make_shared<op::Parameter>(element::i32, Shape{1, 64, 26, 26});
 
     const auto op = make_shared<op::v0::ReorgYolo>(data, Strides{2});
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data});
     const auto g_op = ov::as_type_ptr<op::v0::ReorgYolo>(builder.create());
 
     EXPECT_EQ(g_op->get_strides(), op->get_strides());

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

@@ -24,7 +24,7 @@ TEST(attributes, reshape_op) {
     bool special_zero = true;
 
     auto reshape = make_shared<opset1::Reshape>(data, pattern, special_zero);
-    NodeBuilder builder(reshape);
+    NodeBuilder builder(reshape, {data, pattern});
     auto g_reshape = ov::as_type_ptr<opset1::Reshape>(builder.create());
 
     const auto expected_attr_count = 1;

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

@@ -22,7 +22,7 @@ TEST(attributes, reverse_op_enum_mode) {
     auto reversed_axes = make_shared<op::Parameter>(element::i32, Shape{200});
 
     auto reverse = make_shared<opset1::Reverse>(data, reversed_axes, opset1::Reverse::Mode::INDEX);
-    NodeBuilder builder(reverse);
+    NodeBuilder builder(reverse, {data, reversed_axes});
     auto g_reverse = ov::as_type_ptr<opset1::Reverse>(builder.create());
 
     EXPECT_EQ(g_reverse->get_mode(), reverse->get_mode());
@@ -36,7 +36,7 @@ TEST(attributes, reverse_op_string_mode) {
     std::string mode = "index";
 
     auto reverse = make_shared<opset1::Reverse>(data, reversed_axes, mode);
-    NodeBuilder builder(reverse);
+    NodeBuilder builder(reverse, {data, reversed_axes});
     auto g_reverse = ov::as_type_ptr<opset1::Reverse>(builder.create());
 
     EXPECT_EQ(g_reverse->get_mode(), reverse->get_mode());

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

@@ -26,7 +26,7 @@ TEST(attributes, reverse_sequence_op) {
 
     auto reverse_sequence = make_shared<opset1::ReverseSequence>(data, seq_indices, batch_axis, seq_axis);
 
-    NodeBuilder builder(reverse_sequence);
+    NodeBuilder builder(reverse_sequence, {data, seq_indices});
     const auto expected_attr_count = 2;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 

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

@@ -32,7 +32,7 @@ TEST(attributes, rnn_cell_op_custom_attributes) {
     auto rnn_cell =
         make_shared<opset1::RNNCell>(X, H, W, R, hidden_size, activations, activations_alpha, activations_beta, clip);
 
-    NodeBuilder builder(rnn_cell);
+    NodeBuilder builder(rnn_cell, {X, H, W, R});
     auto g_rnn_cell = ov::as_type_ptr<opset1::RNNCell>(builder.create());
 
     EXPECT_EQ(g_rnn_cell->get_hidden_size(), rnn_cell->get_hidden_size());
@@ -53,7 +53,7 @@ TEST(attributes, rnn_cell_op_default_attributes) {
 
     auto rnn_cell = make_shared<opset1::RNNCell>(X, H, W, R, hidden_size);
 
-    NodeBuilder builder(rnn_cell);
+    NodeBuilder builder(rnn_cell, {X, H, W, R});
     auto g_rnn_cell = ov::as_type_ptr<opset1::RNNCell>(builder.create());
 
     EXPECT_EQ(g_rnn_cell->get_hidden_size(), rnn_cell->get_hidden_size());

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

@@ -51,7 +51,7 @@ TEST(attributes, rnn_sequence_op) {
                                                                activations_alpha,
                                                                activations_beta,
                                                                clip_threshold);
-    NodeBuilder builder(rnn_sequence);
+    NodeBuilder builder(rnn_sequence, {X, initial_hidden_state, sequence_lengths, W, R, B});
     auto g_rnn_sequence = ov::as_type_ptr<opset5::RNNSequence>(builder.create());
 
     EXPECT_EQ(g_rnn_sequence->get_hidden_size(), rnn_sequence->get_hidden_size());

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

@@ -22,7 +22,7 @@ TEST(attributes, roi_pooling_op) {
     const auto coords = make_shared<op::Parameter>(element::f32, Shape{2, 5});
 
     const auto op = make_shared<opset3::ROIPooling>(data, coords, Shape{5, 5}, 0.123, "bilinear");
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data, coords});
     const auto g_op = ov::as_type_ptr<opset3::ROIPooling>(builder.create());
 
     EXPECT_EQ(g_op->get_output_size(), op->get_output_size());

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

@@ -19,7 +19,8 @@ TEST(attributes, roll_op) {
     const auto C = make_shared<op::Constant>(element::i32, Shape{3});
 
     const auto roll = make_shared<opset7::Roll>(A, B, C);
-    NodeBuilder builder(roll);
+    NodeBuilder builder(roll, {A, B, C});
+    EXPECT_NO_THROW(auto g_roll = ov::as_type_ptr<opset7::Roll>(builder.create()));
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -20,7 +20,7 @@ void static test_mode(opset5::Round::RoundMode mode) {
     NodeBuilder::get_ops().register_factory<opset5::Round>();
     auto data = make_shared<op::Parameter>(element::f32, Shape{200});
     auto round = make_shared<opset5::Round>(data, mode);
-    NodeBuilder builder(round);
+    NodeBuilder builder(round, {data});
     auto g_round = ov::as_type_ptr<opset5::Round>(builder.create());
 
     EXPECT_EQ(g_round->get_mode(), round->get_mode());

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

@@ -21,7 +21,7 @@ TEST(attributes, scatter_elements_update) {
     auto axis = std::make_shared<op::Parameter>(element::i16, Shape{});
 
     auto scatter = std::make_shared<opset3::ScatterElementsUpdate>(data, indices, updates, axis);
-    NodeBuilder builder(scatter);
+    NodeBuilder builder(scatter, {data, indices, updates, axis});
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -29,7 +29,7 @@ TEST(attributes, scatter_update_op) {
     auto A = op::Constant::create(element::i16, Shape{}, {1});
     auto op = make_shared<ScatterUpdate>(R, I, U, A);
 
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {R, I, U, A});
     const auto expected_attr_count = 0;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -12,7 +12,7 @@ using namespace ngraph;
 using ngraph::test::NodeBuilder;
 using ngraph::test::ValueMap;
 
-TEST(attributes, select) {
+TEST(attributes, select_fp32) {
     NodeBuilder::get_ops().register_factory<opset1::Select>();
     auto in_cond = std::make_shared<op::Parameter>(element::boolean, Shape{3, 2});
     auto in_then = std::make_shared<op::Parameter>(element::f32, Shape{3, 2});
@@ -21,7 +21,25 @@ TEST(attributes, select) {
     auto auto_broadcast = op::AutoBroadcastType::NUMPY;
 
     auto select = std::make_shared<opset1::Select>(in_cond, in_then, in_else, auto_broadcast);
-    NodeBuilder builder(select);
+    NodeBuilder builder(select, {in_cond, in_then, in_else});
+
+    const auto expected_attr_count = 1;
+    EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
+
+    auto g_select = ov::as_type_ptr<opset1::Select>(builder.create());
+    EXPECT_EQ(g_select->get_autob(), select->get_autob());
+}
+
+TEST(attributes, select_i32) {
+    NodeBuilder::get_ops().register_factory<opset1::Select>();
+    auto in_cond = std::make_shared<op::Parameter>(element::boolean, Shape{3, 2});
+    auto in_then = std::make_shared<op::Parameter>(element::i32, Shape{3, 2});
+    auto in_else = std::make_shared<op::Parameter>(element::i32, Shape{3, 2});
+
+    auto auto_broadcast = op::AutoBroadcastType::NUMPY;
+
+    auto select = std::make_shared<opset1::Select>(in_cond, in_then, in_else, auto_broadcast);
+    NodeBuilder builder(select, {in_cond, in_then, in_else});
 
     const auto expected_attr_count = 1;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -20,8 +20,9 @@ TEST(attributes, selu_op) {
 
     const auto op = make_shared<opset1::Selu>(data_input, alpha, lambda);
 
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data_input, alpha, lambda});
     const auto expected_attr_count = 0;
+    EXPECT_NO_THROW(auto g_op = ov::as_type_ptr<opset1::Selu>(builder.create()));
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }

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

@@ -19,7 +19,7 @@ TEST(attributes, shapeof_op1) {
     NodeBuilder::get_ops().register_factory<op::v0::ShapeOf>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4});
     auto shapeof = make_shared<op::v0::ShapeOf>(data);
-    NodeBuilder builder(shapeof);
+    NodeBuilder builder(shapeof, {data});
     auto g_shapeof = ov::as_type_ptr<op::v0::ShapeOf>(builder.create());
 
     const auto expected_attr_count = 0;
@@ -30,7 +30,7 @@ TEST(attributes, shapeof_op3) {
     NodeBuilder::get_ops().register_factory<op::v3::ShapeOf>();
     auto data = make_shared<op::Parameter>(element::i32, Shape{2, 3, 4});
     auto shapeof = make_shared<op::v3::ShapeOf>(data, element::Type_t::i64);
-    NodeBuilder builder(shapeof);
+    NodeBuilder builder(shapeof, {data});
     auto g_shapeof = ov::as_type_ptr<op::v3::ShapeOf>(builder.create());
 
     const auto expected_attr_count = 1;

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

@@ -19,7 +19,7 @@ TEST(attributes, shuffle_channels_op) {
     auto axis = 1;
     auto groups = 2;
     auto shuffle_channels = make_shared<ShuffleChannels>(data, axis, groups);
-    NodeBuilder builder(shuffle_channels);
+    NodeBuilder builder(shuffle_channels, {data});
     auto g_shuffle_channels = ov::as_type_ptr<ShuffleChannels>(builder.create());
 
     const auto expected_attr_count = 2;

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

@@ -20,7 +20,7 @@ TEST(attributes, slice_op_no_axes) {
     const auto step = make_shared<op::Parameter>(element::i32, Shape{4});
 
     const auto op = make_shared<opset8::Slice>(data, start, stop, step);
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data, start, stop, step});
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
@@ -35,7 +35,7 @@ TEST(attributes, slice_op_with_axes) {
     const auto axes = make_shared<op::Parameter>(element::i32, Shape{4});
 
     const auto op = make_shared<opset8::Slice>(data, start, stop, step, axes);
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data, start, stop, step, axes});
 
     const auto expected_attr_count = 0;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);

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

@@ -21,7 +21,7 @@ TEST(attributes, softmax_op) {
     auto data = make_shared<op::Parameter>(element::i32, Shape{200});
     auto axis = 0;
     auto softmax = make_shared<opset1::Softmax>(data, axis);
-    NodeBuilder builder(softmax);
+    NodeBuilder builder(softmax, {data});
     auto g_softmax = ov::as_type_ptr<opset1::Softmax>(builder.create());
 
     EXPECT_EQ(g_softmax->get_axis(), softmax->get_axis());

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

@@ -22,7 +22,8 @@ TEST(attributes, space_to_batch_op) {
     auto pads_end = make_shared<op::Constant>(element::i64, Shape{2}, vector<int64_t>{0, 0});
     auto op = make_shared<SpaceToBatch>(data, block_shape, pads_begin, pads_end);
 
-    NodeBuilder builder(op);
+    NodeBuilder builder(op, {data, block_shape, pads_begin, pads_end});
+    EXPECT_NO_THROW(auto g_op = ov::as_type_ptr<SpaceToBatch>(builder.create()));
     const auto expected_attr_count = 0;
 
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);