diff --git a/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp b/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp
index 6494a212175765..df423516bd8984 100644
--- a/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp
+++ b/src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp
@@ -48,9 +48,11 @@ class LP_TRANSFORMATIONS_API DataPrecision {
             hasZeroPoint(hasZeroPoint) {}
 
     bool empty() const noexcept {
-        assert(((precision == element::dynamic) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint)) ||
-               ((precision != element::dynamic) && (max != 0.f)));
-        return (precision == element::dynamic) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint);
+        OPENVINO_SUPPRESS_DEPRECATED_START
+        assert(((precision == element::dynamic || precisoin == element::undefined) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint)) ||
+               ((precision != element::dynamic && precision != element::undefined) && (max != 0.f)));
+        return (precision == element::dynamic || precision == element::undefined) && (min == 0.f) && (max == 0.f) && (!hasZeroPoint);
+        OPENVINO_SUPPRESS_DEPRECATED_END
     }
 
     static bool isSupported(const element::Type& precision) {
diff --git a/src/common/low_precision_transformations/tests/concat_with_fq_tranformation.cpp b/src/common/low_precision_transformations/tests/concat_with_fq_tranformation.cpp
index 6b70f4bb9404ca..227aaaf9873043 100644
--- a/src/common/low_precision_transformations/tests/concat_with_fq_tranformation.cpp
+++ b/src/common/low_precision_transformations/tests/concat_with_fq_tranformation.cpp
@@ -116,20 +116,21 @@ class ConcatWithFQTransformation : public LayerTransformation,
         if (!testValues.actual.dequantization2.multiply.empty()) {
             testValues.actual.dequantization2.multiply.outPrecision = precision;
         }
-
+        OPENVINO_SUPPRESS_DEPRECATED_START
         actualFunction = ov::builder::subgraph::ConcatFunction::get(precision,
-                                                                    shape,
-                                                                    testValues.actual.fakeQuantize1,
-                                                                    testValues.actual.convert1,
-                                                                    testValues.actual.dequantization1,
-                                                                    testValues.actual.fakeQuantize2,
-                                                                    testValues.actual.convert2,
-                                                                    testValues.actual.dequantization2,
-                                                                    {},
-                                                                    ov::element::dynamic,
-                                                                    {},
-                                                                    testValues.axis,
-                                                                    testValues.addNotPrecisionPreservedOperation);
+                                                                        shape,
+                                                                        testValues.actual.fakeQuantize1,
+                                                                        testValues.actual.convert1,
+                                                                        testValues.actual.dequantization1,
+                                                                        testValues.actual.fakeQuantize2,
+                                                                        testValues.actual.convert2,
+                                                                        testValues.actual.dequantization2,
+                                                                        {},
+                                                                        ov::element::undefined,
+                                                                        {},
+                                                                        testValues.axis,
+                                                                        testValues.addNotPrecisionPreservedOperation);
+        OPENVINO_SUPPRESS_DEPRECATED_END                                                                        
         auto supportedPrecisionsOnActivation = std::vector<ov::pass::low_precision::PrecisionsRestriction>(
             {ov::pass::low_precision::PrecisionsRestriction::create<ov::op::v1::AvgPool>(
                 {{{0}, testValues.params.precisionsOnActivations}})});
diff --git a/src/common/low_precision_transformations/tests/concat_with_not_quantized_parent_transformation.cpp b/src/common/low_precision_transformations/tests/concat_with_not_quantized_parent_transformation.cpp
index 5330248d5eecb9..251a092f214641 100644
--- a/src/common/low_precision_transformations/tests/concat_with_not_quantized_parent_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/concat_with_not_quantized_parent_transformation.cpp
@@ -137,22 +137,25 @@ class ConcatWithNotQuantizedParentTransformation :
             testValues.actual.dequantization2.multiply.outPrecision = precision;
         }
 
-        actualFunction = ov::builder::subgraph::ConcatFunction::get(precision,
-                                                                    shapes.first,
-                                                                    testValues.actual.fakeQuantize1,
-                                                                    testValues.actual.convert1,
-                                                                    testValues.actual.dequantization1,
-                                                                    false,
-                                                                    shapes.second,
-                                                                    testValues.actual.fakeQuantize2,
-                                                                    testValues.actual.convert2,
-                                                                    testValues.actual.dequantization2,
-                                                                    true,
-                                                                    {},
-                                                                    ov::element::dynamic,
-                                                                    {},
-                                                                    testValues.axis,
-                                                                    testValues.addNotPrecisionPreservedOperation);
+        OPENVINO_SUPPRESS_DEPRECATED_START
+        actualFunction = ov::builder::subgraph::ConcatFunction::get(
+            precision,
+            shapes.first,
+            testValues.actual.fakeQuantize1,
+            testValues.actual.convert1,
+            testValues.actual.dequantization1,
+            false,
+            shapes.second,
+            testValues.actual.fakeQuantize2,
+            testValues.actual.convert2,
+            testValues.actual.dequantization2,
+            true,
+            {},
+            ov::element::undefined,
+            {},
+            testValues.axis,
+            testValues.addNotPrecisionPreservedOperation);
+        OPENVINO_SUPPRESS_DEPRECATED_END           
 
         auto precisionsRestrictions = std::vector<ov::pass::low_precision::PrecisionsRestriction>({
             ov::pass::low_precision::PrecisionsRestriction::create<ov::op::v1::Convolution>({
diff --git a/src/common/low_precision_transformations/tests/gather_transformation.cpp b/src/common/low_precision_transformations/tests/gather_transformation.cpp
index b13e1be2af126a..fcd29006fdec99 100644
--- a/src/common/low_precision_transformations/tests/gather_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/gather_transformation.cpp
@@ -111,7 +111,6 @@ namespace testValues1 {
 const std::vector<int> opset_version = {1, 7, 8};
 
 const std::vector<ov::PartialShape> inputShapes3D = {{3, 3, 4}, {-1, -1, -1}};
-
 const std::vector<GatherTransformationTestValues> testValues = {
     // U8: per-tensor quantization
     {{1},
@@ -119,7 +118,8 @@ const std::vector<GatherTransformationTestValues> testValues = {
      {0},
      std::int64_t{0},
      LayerTransformation::createParamsU8I8(),
-     {ov::element::u8, {{ov::element::f32}, {{128}, ov::element::f32, {}, true, 1, ov::element::u8, true}, {0.1f}}},
+     {ov::element::u8,
+      {{ov::element::f32}, {{128}, ov::element::f32, {}, true, 1, ov::element::u8, true}, {0.1f}}},
      {ov::element::u8,
       {{}, {}, {}},
       ov::element::u8,
diff --git a/src/common/low_precision_transformations/tests/move_fake_quantize_transformation.cpp b/src/common/low_precision_transformations/tests/move_fake_quantize_transformation.cpp
index a299f72de3cde3..c8e8e3eb26245d 100644
--- a/src/common/low_precision_transformations/tests/move_fake_quantize_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/move_fake_quantize_transformation.cpp
@@ -118,21 +118,21 @@ class MoveFakeQuantizeTransformation : public LayerTransformation,
         ov::IntervalsAlignmentSharedValue::Interval interval{-1.28f, 2.55f};
 
         actualFunction = ov::builder::subgraph::MoveFakeQuantize::get(precision,
-                                                                      inputShapes,
-                                                                      testValues.actual.number_of_operations,
-                                                                      testValues.actual.fakeQuantizeBefore,
-                                                                      testValues.actual.convertBefore,
-                                                                      testValues.actual.dequantizationBefore,
-                                                                      testValues.actual.operation,
-                                                                      testValues.actual.fakeQuantizeAfter,
-                                                                      testValues.actual.convertAfter,
-                                                                      testValues.actual.dequantizationAfter,
-                                                                      {ov::PrecisionPreservedAttribute(true),
-                                                                       ov::IntervalsAlignmentAttribute(interval, 256),
-                                                                       ov::QuantizationAlignmentAttribute(false)},
-                                                                      ov::element::dynamic,
-                                                                      testValues.axis,
-                                                                      oneInputWithSplit);
+                                                                          inputShapes,
+                                                                          testValues.actual.number_of_operations,
+                                                                          testValues.actual.fakeQuantizeBefore,
+                                                                          testValues.actual.convertBefore,
+                                                                          testValues.actual.dequantizationBefore,
+                                                                          testValues.actual.operation,
+                                                                          testValues.actual.fakeQuantizeAfter,
+                                                                          testValues.actual.convertAfter,
+                                                                          testValues.actual.dequantizationAfter,
+                                                                          {ov::PrecisionPreservedAttribute(true),
+                                                                           ov::IntervalsAlignmentAttribute(interval, 256),
+                                                                           ov::QuantizationAlignmentAttribute(false)},
+                                                                          ov::element::dynamic,
+                                                                          testValues.axis,
+                                                                          oneInputWithSplit);
 
         auto supportedPrecisionsOnActivation = std::vector<ov::pass::low_precision::PrecisionsRestriction>(
             {ov::pass::low_precision::PrecisionsRestriction::create<ov::op::v1::AvgPool>(
diff --git a/src/common/low_precision_transformations/tests/pad_transformation.cpp b/src/common/low_precision_transformations/tests/pad_transformation.cpp
index ead730e4848e47..bf6c70f11d81d8 100644
--- a/src/common/low_precision_transformations/tests/pad_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/pad_transformation.cpp
@@ -277,26 +277,81 @@ std::vector<ov::op::PadMode> modesInWhichSubPropagated = {
 };
 
 const std::vector<PadTransformationTestValues> deqWithSub = {
-    {LayerTransformation::createParamsU8I8(),
-     {ov::element::u8, {{ov::element::f32}, {128.f}, {3.f}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {128.f}, {3.f}}}},
-    {LayerTransformation::createParamsI8I8(),
-     {ov::element::i8, {{ov::element::f32}, {64.f}, {3.f}}},
-     {ov::element::i8, {{}, {}, {}}, ov::element::i8, {{ov::element::f32}, {64.f}, {3.f}}}},
-    {LayerTransformation::createParamsI8I8(),
-     {ov::element::i8, {{ov::element::f32}, {{64.f, 32.f, 16.f}}, {{3.f, 1.f, 2.f}}}},
-     {ov::element::i8, {{}, {}, {}}, ov::element::i8, {{ov::element::f32}, {{64.f, 32.f, 16.f}}, {{3.f, 1.f, 2.f}}}}},
-    {LayerTransformation::createParamsU8I8(),
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{3.f, 1.f, 2.f}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{3.f, 1.f, 2.f}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {3.f}}
+        },
+        {
+            ov::element::u8,
+            {{}, {}, {}},
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {3.f}}
+        }
+    },
+    {
+        LayerTransformation::createParamsI8I8(),
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {64.f}, {3.f}}
+        },
+        {
+            ov::element::i8,
+            {{}, {}, {}},
+            ov::element::i8,
+            {{ov::element::f32}, {64.f}, {3.f}}
+        }
+    },
+    {
+        LayerTransformation::createParamsI8I8(),
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{64.f, 32.f, 16.f}}, {{3.f, 1.f, 2.f}}}
+        },
+        {
+            ov::element::i8,
+            {{}, {}, {}},
+            ov::element::i8,
+            {{ov::element::f32}, {{64.f, 32.f, 16.f}}, {{3.f, 1.f, 2.f}}}
+        }
+    },
+    {
+        LayerTransformation::createParamsU8I8(),
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{3.f, 1.f, 2.f}}}
+        },
+        {
+            ov::element::u8,
+            {{}, {}, {}},
+            ov::element::u8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{3.f, 1.f, 2.f}}}
+        }
+    },
     // int8 subtraction with Convert from u8 to fp32
-    {LayerTransformation::createParamsU8I8(),
-     {ov::element::u8,
-      {{ov::element::f32}, {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true}, {3.f}}},
-     {ov::element::u8,
-      {{}, {}, {}},
-      ov::element::u8,
-      {{ov::element::f32}, {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true}, {3.f}}}}};
+    {
+        LayerTransformation::createParamsU8I8(),
+        {
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true},
+                {3.f}
+            }
+        },
+        {
+            ov::element::u8,
+            {{}, {}, {}},
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true},
+                {3.f}
+            }
+        }
+    }
+};
 
 INSTANTIATE_TEST_SUITE_P(
     smoke_LPT,
diff --git a/src/common/low_precision_transformations/tests/reshape_transformation.cpp b/src/common/low_precision_transformations/tests/reshape_transformation.cpp
index a870a5eb3f021c..95cb6c2ad66bdc 100644
--- a/src/common/low_precision_transformations/tests/reshape_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/reshape_transformation.cpp
@@ -91,7 +91,7 @@ TEST_P(ReshapeTransformation, CompareFunctions) {
 
     ASSERT_TRUE(LayerTransformation::allNamesAreUnique(actualFunction)) << "Not all names are unique";
 }
-
+OPENVINO_SUPPRESS_DEPRECATED_START
 const std::vector<ReshapeTransformationTestValues> testValues = {
     // U8: no subtract 3D -> 4D: channels are not affected
     {{1, 384, 1024},
@@ -221,8 +221,12 @@ const std::vector<ReshapeTransformationTestValues> testValues = {
     {{100, 4, 1, 1},
      {-1, 1, 400},
      LayerTransformation::createParamsU8I8(),
-     {ov::element::u8, {{ov::element::f32}, {}, {{0.1f, 0.1f, 0.1f, 0.1f}, ov::element::f32, {1, 4, 1, 1}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f, 0.1f, 0.1f, 0.1f}, ov::element::f32, {1, 4, 1, 1}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: no subtract 4D -> 6D: channels are not affected: no subtract
     {{1, 3, 4, 5},
      {1, 3, 20, 1, 1, 1},
@@ -346,7 +350,8 @@ const std::vector<ReshapeTransformationTestValues> testValues = {
     {{1, 3, 4, 5},
      {0, -1},
      LayerTransformation::createParamsU8I8(),
-     {ov::element::u8, {{ov::element::f32}, {{128.f}, ov::element::f32, {}}, {{0.1f}, ov::element::f32, {}}}},
+     {ov::element::u8,
+      {{ov::element::f32}, {{128.f}, ov::element::f32, {}}, {{0.1f}, ov::element::f32, {}}}},
      {ov::element::u8,
       {},
       ov::element::u8,
@@ -480,42 +485,61 @@ const std::vector<ReshapeTransformationTestValues> testValues = {
      {1, -1},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: no subtract 4D -> 2D
     {{2, 2048, 1, 1},
      {2, -1},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {1ul}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: no subtract 4D -> 2D
     {{1, 2048, 1, 1},
      {1, -1},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {1, 1, 1, 1}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: no subtract 4D -> 2D: channels are not affected
     {{2, 2048, 1, 1},
      {2, -1},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {1, 1, 1, 1}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: no subtract 4D -> 2D: channels are not affected, dynamic batch
     {{-1, 2048, 1, 1},
      {0, -1},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {1, 1, 1, 1}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: no subtract 4D -> 4D: channels are affected
     {{1, 64, 320, 1},
      {0, 2, 3, 1},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}},
-     {ov::element::u8, {{}, {}, {}}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
+     {ov::element::u8,
+      {{}, {}, {}},
+      ov::element::u8,
+      {{ov::element::f32}, {}, {{0.1f}, ov::element::f32, {}}}}},
     // U8: with subtract 4D -> 4D: channels are affected
     {{1, 64, 320, 1},
      {0, 2, 3, 1},
      LayerTransformation::createParamsU8I8(),
-     {ov::element::u8, {{ov::element::f32}, {{128.f}, ov::element::f32, {}}, {{0.1f}, ov::element::f32, {}}}},
+     {ov::element::u8,
+      {{ov::element::f32}, {{128.f}, ov::element::f32, {}}, {{0.1f}, ov::element::f32, {}}}},
      {ov::element::u8,
       {{}, {}, {}},
       ov::element::u8,
@@ -587,8 +611,12 @@ const std::vector<ReshapeTransformationTestValues> testValues = {
      {},
      LayerTransformation::createParamsU8I8(),
      {ov::element::u8, {{ov::element::f32}, {{128.f, 124.f, 120.f}}, {{0.1f, 1.f, 10.f}}}},
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 124.f, 120.f}}, {{0.1f, 1.f, 10.f}}}, ov::element::f32, {}}},
+     {ov::element::u8,
+      {{ov::element::f32}, {{128.f, 124.f, 120.f}}, {{0.1f, 1.f, 10.f}}},
+      ov::element::f32,
+      {}}},
 };
+OPENVINO_SUPPRESS_DEPRECATED_END
 
 INSTANTIATE_TEST_SUITE_P(smoke_LPT,
                          ReshapeTransformation,
diff --git a/src/common/low_precision_transformations/tests/shuffle_channels_transformation.cpp b/src/common/low_precision_transformations/tests/shuffle_channels_transformation.cpp
index 32b32c81b528c5..7cdf9b40628127 100644
--- a/src/common/low_precision_transformations/tests/shuffle_channels_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/shuffle_channels_transformation.cpp
@@ -108,95 +108,205 @@ const std::vector<ov::PartialShape> inputShapes = {
 
 const std::vector<ShuffleChannelsTransformationTestValues> testValues = {
     // U8 per tensor quantization
-    {LayerTransformation::createParamsU8I8(),
-     1,  // axis
-     1,  // group
-     {ov::element::u8, {{ov::element::f32}, {128.f}, {0.02f}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {128.f}, {0.02f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        1, // axis
+        1, // group
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {0.02f}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {0.02f}}
+        }
+    },
     // U8 per channel quantization
-    {LayerTransformation::createParamsU8I8(),
-     1,
-     1,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        1,
+        1,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        }
+    },
     // subtraction with Convert from u8 to fp32
-    {LayerTransformation::createParamsU8I8(),
-     1,
-     1,
-     {ov::element::u8,
-      {{ov::element::f32}, {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true}, {3.f}}},
-     {ov::element::u8,
-      {},
-      ov::element::u8,
-      {{ov::element::f32}, {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true}, {3.f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        1,
+        1,
+        {
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true},
+                {3.f}
+            }
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true},
+                {3.f}
+            }
+        }
+    },
     // U8 quantization by spatial dimension, shuffling by the same dimension
-    {LayerTransformation::createParamsU8I8(),
-     2,
-     4,
-     {ov::element::u8,
-      {{ov::element::f32},
-       {{121.f, 122.f, 123.f, 124.f, 125.f, 126.f, 127.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
-       {{1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}}}},
-     {ov::element::u8,
-      {},
-      ov::element::u8,
-      {
-          {ov::element::f32},
-          {{121.f, 123.f, 125.f, 127.f, 122.f, 124.f, 126.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
-          {{1.f, 3.f, 5.f, 7.f, 2.f, 4.f, 6.f, 8.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
-      }}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        2,
+        4,
+        {
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{121.f, 122.f, 123.f, 124.f, 125.f, 126.f, 127.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
+                {{1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}}
+            }
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{121.f, 123.f, 125.f, 127.f, 122.f, 124.f, 126.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
+                {{1.f, 3.f, 5.f, 7.f, 2.f, 4.f, 6.f, 8.f}, ov::element::f32, ov::Shape {1, 1, 8, 1}},
+            }
+        }
+    },
     // U8 per channel quantization, shuffling by spatial dimension
-    {LayerTransformation::createParamsU8I8(),
-     -2,
-     4,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        -2,
+        4,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        }
+    },
     // I8 per tensor quantization
-    {LayerTransformation::createParamsI8I8(),
-     1,
-     1,
-     {ov::element::i8, {{ov::element::f32}, {128.f}, {0.02f}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {128.f}, {0.02f}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        1,
+        1,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {128.f}, {0.02f}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, {128.f}, {0.02f}}
+        }
+    },
     // I8 per channel quantization
-    {LayerTransformation::createParamsI8I8(),
-     1,
-     1,
-     {ov::element::i8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        1,
+        1,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        }
+    },
     // I8 quantization by spatial dimension, shuffling by the same dimension
-    {LayerTransformation::createParamsI8I8(),
-     2,
-     4,
-     {ov::element::i8,
-      {{ov::element::f32},
-       {{121.f, 122.f, 123.f, 124.f, 125.f, 126.f, 127.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
-       {{1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}}}},
-     {ov::element::i8,
-      {},
-      ov::element::i8,
-      {
-          {ov::element::f32},
-          {{121.f, 123.f, 125.f, 127.f, 122.f, 124.f, 126.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
-          {{1.f, 3.f, 5.f, 7.f, 2.f, 4.f, 6.f, 8.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
-      }}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        2,
+        4,
+        {
+            ov::element::i8,
+            {
+                {ov::element::f32},
+                {{121.f, 122.f, 123.f, 124.f, 125.f, 126.f, 127.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
+                {{1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}}
+            }
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {
+                {ov::element::f32},
+                {{121.f, 123.f, 125.f, 127.f, 122.f, 124.f, 126.f, 128.f}, ov::element::f32, ov::Shape{1, 1, 8, 1}},
+                {{1.f, 3.f, 5.f, 7.f, 2.f, 4.f, 6.f, 8.f}, ov::element::f32, ov::Shape {1, 1, 8, 1}},
+            }
+        }
+    },
     // I8 per channel quantization, shuffling by spatial dimension
-    {LayerTransformation::createParamsI8I8(),
-     -2,
-     4,
-     {ov::element::i8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        -2,
+        4,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.01f, 0.02f, 0.03f}}}
+        }
+    },
     // U8 per tensor quantization, not update precision
-    {LayerTransformation::createParamsU8I8().setUpdatePrecisions(false),
-     3,
-     5,
-     {ov::element::f32, {{}, {128.f}, {0.02f}}},
-     {ov::element::f32, {}, ov::element::f32, {{}, {128.f}, {0.02f}}}},
+    {
+        LayerTransformation::createParamsU8I8().setUpdatePrecisions(false),
+        3,
+        5,
+        {
+            ov::element::f32,
+            {{}, {128.f}, {0.02f}}
+        },
+        {
+            ov::element::f32,
+            {},
+            ov::element::f32,
+            {{}, {128.f}, {0.02f}}
+        }
+    },
     // U8 without dequantization operations
-    {LayerTransformation::createParamsU8I8(),
-     2,
-     4,
-     {ov::element::u8, {{}, {}, {}}},
-     {ov::element::u8, {}, ov::element::u8, {{}, {}, {}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        2,
+        4,
+        {
+            ov::element::u8,
+            {{}, {}, {}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{}, {}, {}}
+        }
+    },
 };
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/src/common/low_precision_transformations/tests/split_transformation.cpp b/src/common/low_precision_transformations/tests/split_transformation.cpp
index 46928929380425..0b2ecb650946a7 100644
--- a/src/common/low_precision_transformations/tests/split_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/split_transformation.cpp
@@ -99,7 +99,6 @@ TEST_P(SplitTransformation, CompareFunctions) {
 }
 
 const std::vector<ov::element::Type> precisions = {ov::element::f32, ov::element::f16};
-
 const std::vector<SplitTransformationTestValues> testValues = {
     // U8 per tensor quantization
     {{1, 3, 16, 16},
@@ -137,7 +136,8 @@ const std::vector<SplitTransformationTestValues> testValues = {
      size_t{2},
      LayerTransformation::createParamsU8I8(),
      // ActualValues
-     {ov::element::u8, {{ov::element::f32}, {{128.f}, element::dynamic, {}, false, 1ul, element::f16, true}, {3.f}}},
+     {ov::element::u8,
+      {{ov::element::f32}, {{128.f}, element::dynamic, {}, false, 1ul, element::f16, true}, {3.f}}},
      // ExpectedValues
      {ov::element::u8,
       {},
@@ -334,7 +334,9 @@ const std::vector<SplitTransformationTestValues> testValues = {
      {ov::element::i8,
       {},
       ov::element::i8,
-      {{{ov::element::f32}, {1.f}, {11.f}}, {{ov::element::f32}, {1.f}, {11.f}}, {{ov::element::f32}, {1.f}, {11.f}}}}},
+      {{{ov::element::f32}, {1.f}, {11.f}},
+       {{ov::element::f32}, {1.f}, {11.f}},
+       {{ov::element::f32}, {1.f}, {11.f}}}}},
     // U8 split second dimension
     {{1, 3, 16, 16},
      std::int64_t{-1},
diff --git a/src/common/low_precision_transformations/tests/strided_slice_transformation.cpp b/src/common/low_precision_transformations/tests/strided_slice_transformation.cpp
index 072cd31d860ebe..3dc1e80a33c7f8 100644
--- a/src/common/low_precision_transformations/tests/strided_slice_transformation.cpp
+++ b/src/common/low_precision_transformations/tests/strided_slice_transformation.cpp
@@ -197,137 +197,349 @@ const std::vector<ov::PartialShape> inputShapes = {
     {1, 3, 24, 24},
     {-1, -1, -1, -1}
 };
-
 const std::vector<StridedSliceTransformationTestValues> stridedSliceTransformationTestValues = {
     // U8: channel slice, per-tensor quantization
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, { 128.f }, { 0.1f }}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, { 128.f }, { 0.1f }}
+        }
+    },
     // U8: channel slice, per-channel quantization with the same values
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 128.f, 128.f}}, {{0.1f, 0.1f, 0.1f}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 128.f, 128.f }}, {{ 0.1f, 0.1f, 0.1f }}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, { 128.f }, { 0.1f }}
+        }
+    },
     // U8: channel slice, per-channel quantization with the same values, subtraction with Convert from u8 to fp32
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::u8,
-      {{ov::element::f32}, {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true}, {3.f}}},
-     {ov::element::u8,
-      {},
-      ov::element::u8,
-      {{ov::element::f32}, {{128.f}, element::dynamic, {}, false, 1ul, element::u8, true}, {3.f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{128.f}, element::dynamic, {1, 3, 1, 1}, false, 1ul, element::u8, true},
+                {3.f}
+            }
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                {{128.f}, element::dynamic, {}, false, 1ul, element::u8, true},
+                {3.f}
+            }
+        }
+    },
     // U8: channel slice, per-channel quantization with different values
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 128.f}}, {{0.1f, 0.01f, 1.f}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {{128.f, 64.f}}, {{0.1f, 0.01f}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 64.f, 128.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 64.f }}, {{ 0.1f, 0.01f }}}
+        }
+    },
     // U8: channel slice, per-channel quantization with different values
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice2D,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 128.f}}, {{0.1f, 0.01f, 1.f}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {{128.f, 64.f}}, {{0.1f, 0.01f}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice2D,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 64.f, 128.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 64.f }}, {{ 0.1f, 0.01f }}}
+        }
+    },
     // U8: without subtract
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::u8, {{ov::element::f32}, {}, {0.1f}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {}, { 0.1f }}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {}, { 0.1f }}
+        }
+    },
     // I8: channel slice, per-tensor quantization
-    {LayerTransformation::createParamsI8I8(),
-     channelSlice,
-     {ov::element::i8, {{ov::element::f32}, {32.f}, {0.1f}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {32.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        channelSlice,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, { 32.f }, { 0.1f }}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, { 32.f }, { 0.1f }}
+        }
+    },
     // I8: channel slice, per-channel quantization with the same values
-    {LayerTransformation::createParamsI8I8(),
-     channelSlice,
-     {ov::element::i8, {{ov::element::f32}, {{32.f, 32.f, 32.f}}, {{0.1f, 0.1f, 0.1f}}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {32.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        channelSlice,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 32.f, 32.f }}, {{ 0.1f, 0.1f, 0.1f }}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, { 32.f }, { 0.1f }}
+        }
+    },
     // I8: channel slice, per-channel quantization with different values
-    {LayerTransformation::createParamsI8I8(),
-     channelSlice,
-     {ov::element::i8, {{ov::element::f32}, {{32.f, 64.f, 32.f}}, {{0.1f, 0.01f, 1.f}}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {{32.f, 64.f}}, {{0.1f, 0.01f}}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        channelSlice,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 64.f, 32.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 64.f }}, {{ 0.1f, 0.01f }}}
+        }
+    },
     // channel slice, not update precisions
-    {LayerTransformation::createParamsU8I8().setUpdatePrecisions(false),
-     channelSlice,
-     {ov::element::f32, {{}, {128.f}, {0.1f}}},
-     {ov::element::f32, {}, ov::element::f32, {{}, {128.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8().setUpdatePrecisions(false),
+        channelSlice,
+        {
+            ov::element::f32,
+            {{}, { 128.f }, { 0.1f }}
+        },
+        {
+            ov::element::f32,
+            {},
+            ov::element::f32,
+            {{}, { 128.f }, { 0.1f }}
+        }
+    },
     // channel slice, no dequantization
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::f32, {}},
-     {ov::element::f32, {}, ov::element::f32, {}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::f32,
+            {}
+        },
+        {
+            ov::element::f32,
+            {},
+            ov::element::f32,
+            {}
+        }
+    },
     // quantization after convolution
-    {LayerTransformation::createParamsU8I8(),
-     spatialDimensionSlice,
-     {ov::element::u8, {{ov::element::f32}, {}, {{0.1f, 0.01f, 1.f}, ov::element::f32, {3, 1, 1}}}},
-     {ov::element::u8,
-      {},
-      ov::element::u8,
-      {{ov::element::f32}, {}, {{0.1f, 0.01f, 1.f}, ov::element::f32, {1, 3, 1, 1}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        spatialDimensionSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {}, { {0.1f, 0.01f, 1.f}, ov::element::f32, {3, 1, 1} }}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {}, { {0.1f, 0.01f, 1.f}, ov::element::f32, {1, 3, 1, 1} }}
+        }
+    },
     // quantization after convolution
-    {LayerTransformation::createParamsU8I8(),
-     channelSlice,
-     {ov::element::u8, {{ov::element::f32}, {}, {{0.1f, 0.01f, 1.f}, ov::element::f32, {3, 1, 1}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {}, {{0.1f, 0.01f}, ov::element::f32, {1, 2, 1, 1}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        channelSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {}, { {0.1f, 0.01f, 1.f}, ov::element::f32, {3, 1, 1} }}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {}, { {0.1f, 0.01f}, ov::element::f32, {1, 2, 1, 1} }}
+        }
+    },
     // U8: special dimension slice, per-channel quantization with different values
-    {LayerTransformation::createParamsU8I8(),
-     spatialDimensionSlice,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 128.f}}, {{0.1f, 0.01f, 1.f}}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 128.f}}, {{0.1f, 0.01f, 1.f}}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        spatialDimensionSlice,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 64.f, 128.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {{ 128.f, 64.f, 128.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        }
+    },
     // U8: without convert
-    {LayerTransformation::createParamsU8I8(),
-     spatialDimensionSlice,
-     {ov::element::f32, {{}, {128.f}, {0.1f}}},
-     {ov::element::f32, {}, ov::element::f32, {{}, {128.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        spatialDimensionSlice,
+        {
+            ov::element::f32,
+            {{}, { 128.f }, { 0.1f }}
+        },
+        {
+            ov::element::f32,
+            {},
+            ov::element::f32,
+            {{}, { 128.f }, { 0.1f }}
+        }
+    },
     // I8: special dimension slice, per-channel quantization with different values
-    {LayerTransformation::createParamsI8I8(),
-     spatialDimensionSlice,
-     {ov::element::i8, {{ov::element::f32}, {{32.f, 64.f, 32.f}}, {{0.1f, 0.01f, 1.f}}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {{32.f, 64.f, 32.f}}, {{0.1f, 0.01f, 1.f}}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        spatialDimensionSlice,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 64.f, 32.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 64.f, 32.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        }
+    },
     // I8: special dimension end slice, per-channel quantization with different values
-    {LayerTransformation::createParamsI8I8(),
-     spatialDimensionEndSlice,
-     {ov::element::i8, {{ov::element::f32}, {{32.f, 64.f, 32.f}}, {{0.1f, 0.01f, 1.f}}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {{32.f, 64.f, 32.f}}, {{0.1f, 0.01f, 1.f}}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        spatialDimensionEndSlice,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 64.f, 32.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, {{ 32.f, 64.f, 32.f }}, {{ 0.1f, 0.01f, 1.f }}}
+        }
+    },
     // I8: special dimension end slice, per-tensor quantization with different values
-    {LayerTransformation::createParamsI8I8(),
-     spatialDimensionEndSlice,
-     {ov::element::i8, {{ov::element::f32}, {32.f}, {0.1f}}},
-     {ov::element::i8, {}, ov::element::i8, {{ov::element::f32}, {32.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsI8I8(),
+        spatialDimensionEndSlice,
+        {
+            ov::element::i8,
+            {{ov::element::f32}, { 32.f }, { 0.1f }}
+        },
+        {
+            ov::element::i8,
+            {},
+            ov::element::i8,
+            {{ov::element::f32}, { 32.f }, { 0.1f }}
+        }
+    },
     // U8: channel slice, per-tensor quantization
-    {LayerTransformation::createParamsU8I8(),
-     sliceWithRemovedAxis,
-     {ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        sliceWithRemovedAxis,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {0.1f}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {0.1f}}
+        }
+    },
     // U8: channel slice, per-channel quantization
-    {LayerTransformation::createParamsU8I8(),
-     sliceWithRemovedAxis,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.1f, 0.2f, 0.3f}}}},
-     {
-         ov::element::u8,
-         {},
-         ov::element::u8,
-         {{ov::element::f32}, {64.f}, {0.2f}},
-     }},
+    {
+        LayerTransformation::createParamsU8I8(),
+        sliceWithRemovedAxis,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, { {128.f, 64.f, 32.f} }, { {0.1f, 0.2f, 0.3f} }}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {64.f}, {0.2f}},
+        }
+    },
     // U8: channel slice, per-tensor quantization
-    {LayerTransformation::createParamsU8I8(),
-     sliceWithAdditionalAxis,
-     {ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}},
-     {ov::element::u8, {}, ov::element::u8, {{ov::element::f32}, {128.f}, {0.1f}}}},
+    {
+        LayerTransformation::createParamsU8I8(),
+        sliceWithAdditionalAxis,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {0.1f}}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {{ov::element::f32}, {128.f}, {0.1f}}
+        }
+    },
     // U8: channel slice, per-channel quantization
-    {LayerTransformation::createParamsU8I8(),
-     sliceWithAdditionalAxis,
-     {ov::element::u8, {{ov::element::f32}, {{128.f, 64.f, 32.f}}, {{0.1f, 0.2f, 0.3f}}}},
-     {
-         ov::element::u8,
-         {},
-         ov::element::u8,
-         {{ov::element::f32},
-          {{128.f, 64.f, 32.f}, ov::element::f32, {1, 1, 3, 1, 1}},
-          {{0.1f, 0.2f, 0.3f}, ov::element::f32, {1, 1, 3, 1, 1}}},
-     }},
+    {
+        LayerTransformation::createParamsU8I8(),
+        sliceWithAdditionalAxis,
+        {
+            ov::element::u8,
+            {{ov::element::f32}, { {128.f, 64.f, 32.f} }, { {0.1f, 0.2f, 0.3f} }}
+        },
+        {
+            ov::element::u8,
+            {},
+            ov::element::u8,
+            {
+                {ov::element::f32},
+                { {128.f, 64.f, 32.f}, ov::element::f32, {1, 1, 3, 1, 1} },
+                { {0.1f, 0.2f, 0.3f}, ov::element::f32, {1, 1, 3, 1, 1} }
+            },
+        }
+    },
 };
 
 INSTANTIATE_TEST_SUITE_P(