diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/include/conv_with_zero_point_fuse.hpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/include/conv_with_zero_point_fuse.hpp
index 0059a9c21ce..03380cff38c 100644
--- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/include/conv_with_zero_point_fuse.hpp
+++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/include/conv_with_zero_point_fuse.hpp
@@ -4,23 +4,23 @@
 
 #pragma once
 
+#include <string>
 #include <tuple>
 #include <vector>
-#include <string>
 
-#include "test_utils/cpu_test_utils.hpp"
-#include "shared_test_classes/base/layer_test_utils.hpp"
-#include "ov_models/utils/ov_helpers.hpp"
 #include "ov_models/builders.hpp"
+#include "ov_models/utils/ov_helpers.hpp"
+#include "shared_test_classes/base/ov_subgraph.hpp"
+#include "test_utils/cpu_test_utils.hpp"
 
 using namespace CPUTestUtils;
 
-namespace SubgraphTestsDefinitions {
+namespace ov {
+namespace test {
 
-using convConcatCPUParams = std::tuple<
-    nodeType,                           // Ngraph convolution type
-    InferenceEngine::SizeVector         // Input shapes
->;
+using convConcatCPUParams = std::tuple<nodeType,  // Node convolution type
+                                       ov::Shape  // Input shapes
+                                       >;
 
 // Subgraph:
 /*
@@ -44,7 +44,7 @@ using convConcatCPUParams = std::tuple<
 
 class ConvWithZeroPointFuseSubgraphTest : public testing::WithParamInterface<convConcatCPUParams>,
                                           public CPUTestsBase,
-                                          virtual public LayerTestsUtils::LayerTestsCommon {
+                                          virtual public SubgraphBaseStaticTest {
 public:
     static std::string getTestCaseName(testing::TestParamInfo<convConcatCPUParams> obj);
 
@@ -53,4 +53,5 @@ protected:
     std::string pluginTypeNode;
 };
 
-} // namespace SubgraphTestsDefinitions
+}  // namespace test
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_with_zero_point_fuse.cpp b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_with_zero_point_fuse.cpp
index d2b01842ddc..9832fa0ac18 100644
--- a/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_with_zero_point_fuse.cpp
+++ b/src/plugins/intel_cpu/tests/functional/subgraph_tests/src/conv_with_zero_point_fuse.cpp
@@ -2,19 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "ngraph/opsets/opset1.hpp"
-#include "test_utils/convolution_params.hpp"
 #include "subgraph_tests/include/conv_with_zero_point_fuse.hpp"
 
-using namespace InferenceEngine;
+#include "common_test_utils/node_builders/convolution.hpp"
+#include "common_test_utils/node_builders/group_convolution.hpp"
+#include "test_utils/convolution_params.hpp"
+
 using namespace CPUTestUtils;
 
-namespace SubgraphTestsDefinitions {
+namespace ov {
+namespace test {
 
 std::string ConvWithZeroPointFuseSubgraphTest::getTestCaseName(testing::TestParamInfo<convConcatCPUParams> obj) {
     std::ostringstream result;
     nodeType type;
-    SizeVector inputShapes;
+    ov::Shape inputShapes;
     std::tie(type, inputShapes) = obj.param;
 
     result << "Type=" << nodeType2str(type) << "_";
@@ -26,115 +28,110 @@ std::string ConvWithZeroPointFuseSubgraphTest::getTestCaseName(testing::TestPara
 void ConvWithZeroPointFuseSubgraphTest::SetUp() {
     targetDevice = ov::test::utils::DEVICE_CPU;
     nodeType type;
-    SizeVector inputShapes;
+    ov::Shape inputShapes;
     std::tie(type, inputShapes) = this->GetParam();
     pluginTypeNode = nodeType2PluginType(type);
 
-    const ngraph::op::PadType paddingType { ngraph::op::PadType::EXPLICIT };
+    const ov::op::PadType paddingType{ov::op::PadType::EXPLICIT};
     const size_t numOutChannels = 256;
-    const SizeVector dilation { 1, 1 };
-    const SizeVector kernelSize { 1, 1 };
-    const SizeVector strides { 1, 1 };
-    const std::vector<ptrdiff_t> padBegin { 0, 0 };
-    const std::vector<ptrdiff_t> padEnd { 0, 0 };
+    const std::vector<size_t> dilation{1, 1};
+    const std::vector<size_t> kernelSize{1, 1};
+    const std::vector<size_t> strides{1, 1};
+    const std::vector<ptrdiff_t> padBegin{0, 0};
+    const std::vector<ptrdiff_t> padEnd{0, 0};
 
-    selectedType = ".*_I8";
+    selectedType = ".*_i8";
 
-    ov::ParameterVector inputParams {std::make_shared<ov::op::v0::Parameter>(ngraph::element::f32, ov::Shape(inputShapes))};
-    const auto fq = ngraph::builder::makeFakeQuantize(
-        inputParams[0],
-        ov::element::f32,
-        256,
-        {1, 1, 1, 1},
-        {-12.8f},
-        {12.7f},
-        {-12.8f},
-        {12.7f});
+    ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, inputShapes)};
+    const auto fq = ngraph::builder::makeFakeQuantize(inputParams[0],
+                                                      ov::element::f32,
+                                                      256,
+                                                      {1, 1, 1, 1},
+                                                      {-12.8f},
+                                                      {12.7f},
+                                                      {-12.8f},
+                                                      {12.7f});
 
     std::vector<std::shared_ptr<ngraph::Node>> branches(2);
     {
-        ngraph::Strides strides{1, 1};
-        ngraph::Shape pads_begin{0, 0}, pads_end{0, 0}, kernel{1, 1};
-        branches[0] = std::make_shared<ngraph::opset1::MaxPool>(fq,
-                                                                        strides,
-                                                                        pads_begin,
-                                                                        pads_end,
-                                                                        kernel);
+        ov::Strides strides{1, 1};
+        ov::Shape pads_begin{0, 0}, pads_end{0, 0}, kernel{1, 1};
+        branches[0] = std::make_shared<ov::op::v1::MaxPool>(fq, strides, pads_begin, pads_end, kernel);
     }
     {
-        const auto fq_conv_data = ngraph::builder::makeFakeQuantize(
-            fq,
-            ov::element::f32,
-            256,
-            {1, 1, 1, 1},
-            {-12.8f},
-            {12.7f},
-            {-12.8f},
-            {12.7f});
+        const auto fq_conv_data = ngraph::builder::makeFakeQuantize(fq,
+                                                                    ov::element::f32,
+                                                                    256,
+                                                                    {1, 1, 1, 1},
+                                                                    {-12.8f},
+                                                                    {12.7f},
+                                                                    {-12.8f},
+                                                                    {12.7f});
 
-        const InferenceEngine::SizeVector weights_const_shape = {numOutChannels, inputShapes[1], kernelSize[0], kernelSize[1]};
-        const auto weights_const_values = std::vector<int>(ngraph::shape_size(weights_const_shape), 1);
-        const auto weights_const = ngraph::builder::makeConstant(ov::element::i8, weights_const_shape, weights_const_values);
+        const ov::Shape weights_const_shape = {numOutChannels, inputShapes[1], kernelSize[0], kernelSize[1]};
+        const auto weights_const_values = std::vector<int>(ov::shape_size(weights_const_shape), 1);
+        const auto weights_const =
+            ngraph::builder::makeConstant(ov::element::i8, weights_const_shape, weights_const_values);
 
         const auto weights_convert = std::make_shared<ov::op::v0::Convert>(weights_const, ov::element::f32);
 
         const auto weights_multiply = std::make_shared<ov::opset10::Multiply>(
             weights_convert,
             ngraph::builder::makeConstant(ov::element::f32,
-                                            {numOutChannels, 1, 1, 1},
-                                            std::vector<float>(numOutChannels, 1.0)));
+                                          {numOutChannels, 1, 1, 1},
+                                          std::vector<float>(numOutChannels, 1.0)));
 
         switch (type) {
-            case nodeType::convolution: {
-                branches[1] = ngraph::builder::makeConvolution(fq_conv_data,
-                                                               weights_multiply,
-                                                               ngraph::element::f32,
-                                                               kernelSize,
-                                                               strides,
-                                                               padBegin,
-                                                               padEnd,
-                                                               dilation,
-                                                               paddingType,
-                                                               numOutChannels);
-                break;
-            }
-            case nodeType::groupConvolution: {
-                branches[1] = ngraph::builder::makeGroupConvolution(
-                    fq_conv_data,
-                    std::make_shared<ov::opset10::Reshape>(
-                        weights_multiply,
-                        ngraph::builder::makeConstant(
-                            ov::element::i32,
-                            {5},
-                            std::vector<size_t>{1, numOutChannels, inputShapes[1], kernelSize[0], kernelSize[1]}),
-                        true),
-                    ngraph::element::f32,
-                    strides,
-                    padBegin,
-                    padEnd,
-                    dilation,
-                    paddingType);
-                break;
-            }
-            default: {
-                throw std::runtime_error("Subgraph concat test doesn't support this type of operation");
-            }
+        case nodeType::convolution: {
+            branches[1] = ov::test::utils::make_convolution(fq_conv_data,
+                                                            weights_multiply,
+                                                            ov::element::f32,
+                                                            kernelSize,
+                                                            strides,
+                                                            padBegin,
+                                                            padEnd,
+                                                            dilation,
+                                                            paddingType,
+                                                            numOutChannels);
+            break;
+        }
+        case nodeType::groupConvolution: {
+            branches[1] = ov::test::utils::make_group_convolution(
+                fq_conv_data,
+                std::make_shared<ov::opset10::Reshape>(
+                    weights_multiply,
+                    ngraph::builder::makeConstant(
+                        ov::element::i32,
+                        {5},
+                        std::vector<size_t>{1, numOutChannels, inputShapes[1], kernelSize[0], kernelSize[1]}),
+                    true),
+                ov::element::f32,
+                strides,
+                padBegin,
+                padEnd,
+                dilation,
+                paddingType);
+            break;
+        }
+        default: {
+            throw std::runtime_error("Subgraph concat test doesn't support this type of operation");
+        }
         }
     }
 
     auto concat = std::make_shared<ov::op::v0::Concat>(ov::NodeVector{branches[0], branches[1]}, 1);
 
-    ngraph::ResultVector results{std::make_shared<ngraph::opset4::Result>(concat)};
-    function = std::make_shared<ngraph::Function>(results, inputParams, "ConvWithZeroPointFuseSubgraphTest");
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(concat)};
+    function = std::make_shared<ov::Model>(results, inputParams, "ConvWithZeroPointFuseSubgraphTest");
 }
 
 TEST_P(ConvWithZeroPointFuseSubgraphTest, CompareWithRefs) {
-    Run();
+    run();
 
-    CheckPluginRelatedResults(executableNetwork, pluginTypeNode);
+    CheckPluginRelatedResults(compiledModel, pluginTypeNode);
 };
 
-const SizeVector inputShapes2D = {1, 32, 136, 136};
+const ov::Shape inputShapes2D = {1, 32, 136, 136};
 
 const auto params2DConv = ::testing::Combine(::testing::ValuesIn({nodeType::convolution, nodeType::groupConvolution}),
                                              ::testing::Values(inputShapes2D));
@@ -144,4 +141,5 @@ INSTANTIATE_TEST_SUITE_P(smoke_ConvWithZeroPointFuse,
                          params2DConv,
                          ConvWithZeroPointFuseSubgraphTest::getTestCaseName);
 
-}  // namespace SubgraphTestsDefinitions
+}  // namespace test
+}  // namespace ov