diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reduce_ops.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reduce_ops.cpp
index 48cdf0ce25b..f3b28017075 100644
--- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reduce_ops.cpp
+++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reduce_ops.cpp
@@ -2,19 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
-
-#include "single_layer_tests/reduce_ops.hpp"
+#include "single_op_tests/reduce_ops.hpp"
 #include "common_test_utils/test_constants.hpp"
 
-using namespace LayerTestsDefinitions;
-
 namespace {
-const std::vector<InferenceEngine::Precision> netPrecisions = {
-        InferenceEngine::Precision::FP32,
-        InferenceEngine::Precision::I32,
-        InferenceEngine::Precision::U8,
-        InferenceEngine::Precision::I8,
+using ov::test::ReduceOpsLayerTest;
+using ov::test::ReduceOpsLayerWithSpecificInputTest;
+
+const std::vector<ov::element::Type> netPrecisions = {
+        ov::element::f32,
+        ov::element::i32,
+        ov::element::u8,
+        ov::element::i8,
 };
 
 const std::vector<bool> keepDims = {
@@ -58,19 +57,19 @@ std::vector<ov::test::utils::OpType> opTypes = {
         ov::test::utils::OpType::VECTOR,
 };
 
-const std::vector<ngraph::helpers::ReductionType> reductionTypes = {
-        ngraph::helpers::ReductionType::Mean,
-        ngraph::helpers::ReductionType::Min,
-        ngraph::helpers::ReductionType::Max,
-        ngraph::helpers::ReductionType::Sum,
-        ngraph::helpers::ReductionType::Prod,
-        ngraph::helpers::ReductionType::L1,
-        ngraph::helpers::ReductionType::L2,
+const std::vector<ov::test::utils::ReductionType> reductionTypes = {
+        ov::test::utils::ReductionType::Mean,
+        ov::test::utils::ReductionType::Min,
+        ov::test::utils::ReductionType::Max,
+        ov::test::utils::ReductionType::Sum,
+        ov::test::utils::ReductionType::Prod,
+        ov::test::utils::ReductionType::L1,
+        ov::test::utils::ReductionType::L2,
 };
 
-const std::vector<ngraph::helpers::ReductionType> reductionLogicalTypes = {
-        ngraph::helpers::ReductionType::LogicalOr,
-        ngraph::helpers::ReductionType::LogicalAnd
+const std::vector<ov::test::utils::ReductionType> reductionLogicalTypes = {
+        ov::test::utils::ReductionType::LogicalOr,
+        ov::test::utils::ReductionType::LogicalAnd
 };
 
 INSTANTIATE_TEST_SUITE_P(smoke_ReduceOneAxis,
@@ -79,10 +78,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_ReduceOneAxis,
                                           testing::ValuesIn(opTypes),
                                           testing::Values(true, false),
                                           testing::ValuesIn(reductionTypes),
-                                          testing::Values(InferenceEngine::Precision::FP32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::element::f32),
                                           testing::ValuesIn(inputShapesOneAxis),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerTest::getTestCaseName);
@@ -93,10 +89,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_ReduceLogicalOneAxis,
                                           testing::ValuesIn(opTypes),
                                           testing::Values(true, false),
                                           testing::ValuesIn(reductionLogicalTypes),
-                                          testing::Values(InferenceEngine::Precision::BOOL),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::element::boolean),
                                           testing::ValuesIn(inputShapes),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerTest::getTestCaseName);
@@ -106,12 +99,9 @@ INSTANTIATE_TEST_SUITE_P(smoke_Reduce_Precisions,
                          testing::Combine(testing::Values(std::vector<int>{1, 3}),
                                           testing::Values(opTypes[1]),
                                           testing::ValuesIn(keepDims),
-                                          testing::Values(ngraph::helpers::ReductionType::Sum),
-                                          testing::Values(InferenceEngine::Precision::FP32,
-                                                          InferenceEngine::Precision::I32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::test::utils::ReductionType::Sum),
+                                          testing::Values(ov::element::f32,
+                                                          ov::element::i32),
                                           testing::Values(std::vector<size_t>{2, 2, 2, 2}),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerTest::getTestCaseName);
@@ -122,12 +112,9 @@ INSTANTIATE_TEST_SUITE_P(smoke_Reduce_Ranks,
                                                           std::vector<int>{-1, -2}),
                                           testing::Values(opTypes[1]),
                                           testing::ValuesIn(keepDims),
-                                          testing::Values(ngraph::helpers::ReductionType::Sum),
-                                          testing::Values(InferenceEngine::Precision::FP32,
-                                                          InferenceEngine::Precision::I32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::test::utils::ReductionType::Sum),
+                                          testing::Values(ov::element::f32,
+                                                          ov::element::i32),
                                           testing::Values(std::vector<size_t>{2, 3, 4, 5, 4, 3, 2, 3},
                                                           std::vector<size_t>{2, 3, 4, 5, 4, 3, 2}),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
@@ -138,11 +125,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Reduce_InputShapes,
                          testing::Combine(testing::Values(std::vector<int>{0}),
                                           testing::Values(opTypes[1]),
                                           testing::ValuesIn(keepDims),
-                                          testing::Values(ngraph::helpers::ReductionType::Mean),
-                                          testing::Values(InferenceEngine::Precision::FP32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::test::utils::ReductionType::Mean),
+                                          testing::Values(ov::element::f32),
                                           testing::Values(std::vector<size_t>{3},
                                                           std::vector<size_t>{3, 5},
                                                           std::vector<size_t>{2, 4, 6},
@@ -157,11 +141,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Reduce_Axes,
                          testing::Combine(testing::ValuesIn(axes),
                                           testing::Values(opTypes[1]),
                                           testing::ValuesIn(keepDims),
-                                          testing::Values(ngraph::helpers::ReductionType::Mean),
-                                          testing::Values(InferenceEngine::Precision::FP32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::test::utils::ReductionType::Mean),
+                                          testing::Values(ov::element::f32),
                                           testing::ValuesIn(inputShapes),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerTest::getTestCaseName);
@@ -172,10 +153,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_Reduce_ReductionTypes,
                                           testing::Values(opTypes[1]),
                                           testing::ValuesIn(keepDims),
                                           testing::ValuesIn(reductionTypes),
-                                          testing::Values(InferenceEngine::Precision::FP32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::element::f32),
                                           testing::Values(std::vector<size_t>{2, 9, 2, 9}),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerTest::getTestCaseName);
@@ -186,10 +164,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_ReduceLogical_ReductionTypes,
                                           testing::Values(opTypes[1]),
                                           testing::ValuesIn(keepDims),
                                           testing::ValuesIn(reductionLogicalTypes),
-                                          testing::Values(InferenceEngine::Precision::BOOL),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::element::boolean),
                                           testing::Values(std::vector<size_t>{2, 9, 2, 9}),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerTest::getTestCaseName);
@@ -199,12 +174,9 @@ INSTANTIATE_TEST_SUITE_P(smoke_Reduce,
                          testing::Combine(testing::ValuesIn(decltype(axes){{0}, {1}}),
                                           testing::Values(opTypes[1]),
                                           testing::Values(true),
-                                          testing::Values(ngraph::helpers::ReductionType::Sum),
-                                          testing::Values(InferenceEngine::Precision::FP32,
-                                                          InferenceEngine::Precision::I32),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                                          testing::Values(InferenceEngine::Layout::ANY),
+                                          testing::Values(ov::test::utils::ReductionType::Sum),
+                                          testing::Values(ov::element::f32,
+                                                          ov::element::i32),
                                           testing::Values(std::vector<size_t>{2, 10}),
                                           testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReduceOpsLayerWithSpecificInputTest::getTestCaseName);
diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/region_yolo.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/region_yolo.cpp
index 75736727d8f..3ded3b08bb5 100644
--- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/region_yolo.cpp
+++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/region_yolo.cpp
@@ -2,18 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
-
-#include "single_layer_tests/region_yolo.hpp"
+#include "single_op_tests/region_yolo.hpp"
 #include "common_test_utils/test_constants.hpp"
 
-using namespace LayerTestsDefinitions;
+using ov::test::RegionYoloLayerTest;
 
-const std::vector<ngraph::Shape> inShapes_caffe = {
+const std::vector<std::vector<size_t>> inShapes_caffe = {
     {1, 125, 13, 13}
 };
 
-const std::vector<ngraph::Shape> inShapes_mxnet = {
+const std::vector<std::vector<size_t>> inShapes_mxnet = {
     {1, 75, 52, 52},
     {1, 75, 32, 32},
     {1, 75, 26, 26},
@@ -22,7 +20,7 @@ const std::vector<ngraph::Shape> inShapes_mxnet = {
     {1, 75, 8, 8}
 };
 
-const std::vector<ngraph::Shape> inShapes_v3 = {
+const std::vector<std::vector<size_t>> inShapes_v3 = {
     {1, 255, 52, 52},
     {1, 255, 26, 26},
     {1, 255, 13, 13}
@@ -51,7 +49,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsRegionYolov3,
                                             ::testing::Values(masks[2]),
                                             ::testing::Values(start_axis),
                                             ::testing::Values(end_axis),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          RegionYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsRegionYoloMxnet,
@@ -64,7 +62,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsRegionYoloMxnet,
                                             ::testing::Values(masks[1]),
                                             ::testing::Values(start_axis),
                                             ::testing::Values(end_axis),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          RegionYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsRegionYoloCaffe,
@@ -77,6 +75,6 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsRegionYoloCaffe,
                                             ::testing::Values(masks[0]),
                                             ::testing::Values(start_axis),
                                             ::testing::Values(end_axis),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          RegionYoloLayerTest::getTestCaseName);
diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reorg_yolo.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reorg_yolo.cpp
index 63a5ca08794..6f14ee52b78 100644
--- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reorg_yolo.cpp
+++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reorg_yolo.cpp
@@ -2,18 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
-
-#include "single_layer_tests/reorg_yolo.hpp"
+#include "single_op_tests/reorg_yolo.hpp"
 #include "common_test_utils/test_constants.hpp"
 
-using namespace LayerTestsDefinitions;
+using ov::test::ReorgYoloLayerTest;
 
-const std::vector<ngraph::Shape> inShapes_caffe_yolov2 = {
+const std::vector<std::vector<size_t>> inShapes_caffe_yolov2 = {
     {1, 64, 26, 26},
 };
 
-const std::vector<ngraph::Shape> inShapes = {
+const std::vector<std::vector<size_t>> inShapes = {
     {1, 4, 4, 4},
     {1, 8, 4, 4},
     {1, 9, 3, 3},
@@ -29,41 +27,41 @@ INSTANTIATE_TEST_SUITE_P(smoke_TestsReorgYolo_caffe_YoloV2,
                          ReorgYoloLayerTest,
                          ::testing::Combine(::testing::ValuesIn(inShapes_caffe_yolov2),
                                             ::testing::Values(strides[0]),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReorgYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsReorgYolo_stride_2_smallest,
                          ReorgYoloLayerTest,
                          ::testing::Combine(::testing::Values(inShapes[0]),
                                             ::testing::Values(strides[0]),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReorgYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsReorgYolo_stride_2,
                          ReorgYoloLayerTest,
                          ::testing::Combine(::testing::Values(inShapes[1]),
                                             ::testing::Values(strides[0]),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReorgYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsReorgYolo_stride_3,
                          ReorgYoloLayerTest,
                          ::testing::Combine(::testing::Values(inShapes[2]),
                                             ::testing::Values(strides[1]),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReorgYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsReorgYolo_smaller_h,
                          ReorgYoloLayerTest,
                          ::testing::Combine(::testing::Values(inShapes[4]),
                                             ::testing::Values(strides[0]),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReorgYoloLayerTest::getTestCaseName);
 INSTANTIATE_TEST_SUITE_P(smoke_TestsReorgYolo_batch_2,
                          ReorgYoloLayerTest,
                          ::testing::Combine(::testing::Values(inShapes[3]),
                                             ::testing::Values(strides[0]),
-                                            ::testing::Values(InferenceEngine::Precision::FP32),
+                                            ::testing::Values(ov::element::f32),
                                             ::testing::Values(ov::test::utils::DEVICE_GPU)),
                          ReorgYoloLayerTest::getTestCaseName);
diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reshape.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reshape.cpp
index 1a5e7c84e6e..f4dd2c84c60 100644
--- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reshape.cpp
+++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reshape.cpp
@@ -2,45 +2,35 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
-#include "single_layer_tests/reshape.hpp"
+#include "single_op_tests/reshape.hpp"
 #include "common_test_utils/test_constants.hpp"
 
-using namespace LayerTestsDefinitions;
-
 namespace {
-const std::vector<InferenceEngine::Precision> netPrecisions = {
-            InferenceEngine::Precision::FP32,
-            InferenceEngine::Precision::FP16,
-            InferenceEngine::Precision::I64
+using ov::test::ReshapeLayerTest;
+using ov::test::reshapeParams;
+
+const std::vector<ov::element::Type> netPrecisions = {
+            ov::element::f32,
+            ov::element::f16,
+            ov::element::i64
 };
 
 INSTANTIATE_TEST_SUITE_P(smoke_ReshapeCheck, ReshapeLayerTest,
         ::testing::Combine(
                 ::testing::Values(true),
                 ::testing::ValuesIn(netPrecisions),
-                ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                ::testing::Values(InferenceEngine::Layout::ANY),
-                ::testing::Values(InferenceEngine::Layout::ANY),
                 ::testing::Values(std::vector<size_t>({10, 10, 10, 10})),
                 ::testing::Values(std::vector<int64_t>({10, 0, 100})),
-                ::testing::Values(ov::test::utils::DEVICE_GPU),
-                ::testing::Values(std::map<std::string, std::string>({}))),
+                ::testing::Values(ov::test::utils::DEVICE_GPU)),
                 ReshapeLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_SUITE_P(smoke_ReshapeCheckNegative, ReshapeLayerTest,
         ::testing::Combine(
                 ::testing::Values(true),
                 ::testing::ValuesIn(netPrecisions),
-                ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
-                ::testing::Values(InferenceEngine::Layout::ANY),
-                ::testing::Values(InferenceEngine::Layout::ANY),
                 ::testing::Values(std::vector<size_t>({10, 10, 10, 10})),
                 ::testing::Values(std::vector<int64_t>({10, -1, 100})),
-                ::testing::Values(ov::test::utils::DEVICE_GPU),
-                ::testing::Values(std::map<std::string, std::string>({}))),
+                ::testing::Values(ov::test::utils::DEVICE_GPU)),
                 ReshapeLayerTest::getTestCaseName);
 
 static std::vector<reshapeParams> generate_tests() {
@@ -62,11 +52,8 @@ static std::vector<reshapeParams> generate_tests() {
         {{2, 2, 3, 1, 3, 2, 4, 2}, {2, 2, 3, 1, 6, 8}},
     };
     for (auto& p : params) {
-        reshapeParams test_case = std::make_tuple(false, InferenceEngine::Precision::FP16,
-                                      InferenceEngine::Precision::UNSPECIFIED, InferenceEngine::Precision::UNSPECIFIED,
-                                      InferenceEngine::Layout::ANY, InferenceEngine::Layout::ANY,
-                                      p.first, p.second,
-                                      ov::test::utils::DEVICE_GPU, std::map<std::string, std::string>({}));
+        reshapeParams test_case = std::make_tuple(false, ov::element::f16,
+                                      p.first, p.second, ov::test::utils::DEVICE_GPU);
         res.push_back(test_case);
     }
 
diff --git a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reverse_sequence.cpp b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reverse_sequence.cpp
index c36ebaf2c61..9b20ce83324 100644
--- a/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reverse_sequence.cpp
+++ b/src/plugins/intel_gpu/tests/functional/shared_tests_instances/single_layer_tests/reverse_sequence.cpp
@@ -2,22 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
-
-#include "single_layer_tests/reverse_sequence.hpp"
+#include "single_op_tests/reverse_sequence.hpp"
 #include "common_test_utils/test_constants.hpp"
 
-using namespace LayerTestsDefinitions;
-
 namespace {
+using ov::test::ReverseSequenceLayerTest;
 
-const std::vector<InferenceEngine::Precision> netPrecisions = {
-        InferenceEngine::Precision::FP32,
-        InferenceEngine::Precision::FP16,
-        InferenceEngine::Precision::U8,
-        InferenceEngine::Precision::I8,
-        InferenceEngine::Precision::U16,
-        InferenceEngine::Precision::I32
+const std::vector<ov::element::Type> netPrecisions = {
+        ov::element::f32,
+        ov::element::f16,
+        ov::element::u8,
+        ov::element::i8,
+        ov::element::u16,
+        ov::element::i32
 };
 
 const std::vector<int64_t> batchAxisIndices = { 0L };
@@ -28,9 +25,9 @@ const std::vector<std::vector<size_t>> inputShapes = { {3, 10} }; //, 10, 20
 
 const std::vector<std::vector<size_t>> reversSeqLengthsVecShapes = { {3} };
 
-const std::vector<ngraph::helpers::InputLayerType> secondaryInputTypes = {
-        ngraph::helpers::InputLayerType::CONSTANT,
-        ngraph::helpers::InputLayerType::PARAMETER
+const std::vector<ov::test::utils::InputLayerType> secondaryInputTypes = {
+        ov::test::utils::InputLayerType::CONSTANT,
+        ov::test::utils::InputLayerType::PARAMETER
 };
 
 INSTANTIATE_TEST_SUITE_P(Basic_smoke, ReverseSequenceLayerTest,