diff --git a/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution.cpp b/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution.cpp
index 974da83708..d33d28b465 100644
--- a/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution.cpp
+++ b/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution.cpp
@@ -7,27 +7,42 @@
 #include <cuda_test_constants.hpp>
 #include <vector>
 
+#include "average_finder.hpp"
 #include "common_test_utils/test_constants.hpp"
-#include "finite_comparer.hpp"
 
 using namespace LayerTestsDefinitions;
 
 namespace LayerTestsDefinitions {
 
-class ConvolutionLayerThresholdTest : public FiniteComparer<ConvolutionLayerTest> {
+constexpr uint32_t RANGE = 10;
+constexpr int32_t START_FROM = -5;
+constexpr int32_t RESOLUTION = 1;
+constexpr int SEED = 1;
+
+constexpr float THRESHOLD_BASE_FP32 = 1e-4f;
+constexpr float THRESHOLD_BASE_FP16 = 0.01f;
+
+class ConvolutionLayerThresholdTest : public AverageFinder<ConvolutionLayerTest> {
+public:
+    InferenceEngine::Blob::Ptr GenerateInput(const InferenceEngine::InputInfo& info) const override {
+        return FuncTestUtils::createAndFillBlob(info.getTensorDesc(), RANGE, START_FROM, RESOLUTION, SEED);
+    }
+
 protected:
     void SetUp() override {
         ConvolutionLayerTest::SetUp();
+
+        const auto& netPrecision = std::get<1>(this->GetParam());
+        if (netPrecision == InferenceEngine::Precision::FP32) {
+            this->threshold_base = THRESHOLD_BASE_FP32;
+        } else if (netPrecision == InferenceEngine::Precision::FP16) {
+            this->threshold_base = THRESHOLD_BASE_FP16;
+        }
     }
 };
 
 TEST_P(ConvolutionLayerThresholdTest, CompareWithRefs) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
-
-    auto params = GetParam();
-    inPrc = std::get<2>(params);
-    outPrc = std::get<3>(params);
-
     Run();
 }
 
diff --git a/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution_biasadd_activation.cpp b/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution_biasadd_activation.cpp
index e0a8c87ae4..482e002d41 100644
--- a/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution_biasadd_activation.cpp
+++ b/modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution_biasadd_activation.cpp
@@ -18,63 +18,64 @@
 #include <tuple>
 #include <vector>
 
-#include "finite_comparer.hpp"
+#include "average_finder.hpp"
 
 namespace LayerTestsDefinitions {
 
-class ConvolutionBiasAddActivationLayerFiniteComparerTest
-    : public FiniteComparer<ConvolutionBiasAddActivationLayerTest> {
+constexpr uint32_t RANGE = 10;
+constexpr int32_t START_FROM = -5;
+constexpr int32_t RESOLUTION = 1;
+constexpr int SEED = 1;
+
+constexpr float THRESHOLD_BASE_FP32 = 1e-4f;
+constexpr float THRESHOLD_BASE_FP16 = 0.02f;
+
+class ConvolutionBiasAddActivationThresholdLayerTest : public AverageFinder<ConvolutionBiasAddActivationLayerTest> {
 public:
     InferenceEngine::Blob::Ptr GenerateInput(const InferenceEngine::InputInfo& info) const override {
-        return FuncTestUtils::createAndFillBlob(info.getTensorDesc(), 20, -10, 1, 1);
+        return FuncTestUtils::createAndFillBlob(info.getTensorDesc(), RANGE, START_FROM, RESOLUTION, SEED);
     }
 
 protected:
     void SetUp() override {
         ConvolutionBiasAddActivationLayerTest::SetUp();
 
-        auto params = this->GetParam();
-        auto netPrecision = std::get<1>(std::get<0>(params));
-        if (netPrecision.getPrecVal() == InferenceEngine::Precision::FP16) {
-            this->threshold = 0.5;
-            this->infinity_value = std::numeric_limits<std::uint16_t>::max();
+        auto netPrecision = std::get<1>(std::get<0>(this->GetParam()));
+        if (netPrecision == InferenceEngine::Precision::FP32) {
+            this->threshold_base = THRESHOLD_BASE_FP32;
+        } else if (netPrecision == InferenceEngine::Precision::FP16) {
+            this->threshold_base = THRESHOLD_BASE_FP16;
         }
     }
 };
 
-class ConvolutionBiasAddAddActivationLayerFiniteComparerTest
-    : public FiniteComparer<ConvolutionBiasAddAddActivationLayerTest> {
+class ConvolutionBiasAddAddActivationThresholdLayerTest
+    : public AverageFinder<ConvolutionBiasAddAddActivationLayerTest> {
 public:
     InferenceEngine::Blob::Ptr GenerateInput(const InferenceEngine::InputInfo& info) const override {
-        return FuncTestUtils::createAndFillBlob(info.getTensorDesc(), 20, -10, 1, 1);
+        return FuncTestUtils::createAndFillBlob(info.getTensorDesc(), RANGE, START_FROM, RESOLUTION, SEED);
     }
 
 protected:
     void SetUp() override {
         ConvolutionBiasAddAddActivationLayerTest::SetUp();
 
-        auto params = this->GetParam();
-        auto netPrecision = std::get<1>(std::get<0>(params));
-        if (netPrecision.getPrecVal() == InferenceEngine::Precision::FP16) {
-            this->threshold = 0.5;
-            this->infinity_value = std::numeric_limits<std::uint16_t>::max();
+        auto netPrecision = std::get<1>(std::get<0>(this->GetParam()));
+        if (netPrecision == InferenceEngine::Precision::FP32) {
+            this->threshold_base = THRESHOLD_BASE_FP32;
+        } else if (netPrecision == InferenceEngine::Precision::FP16) {
+            this->threshold_base = THRESHOLD_BASE_FP16;
         }
     }
 };
 
-TEST_P(ConvolutionBiasAddActivationLayerFiniteComparerTest, CompareWithRefs) {
+TEST_P(ConvolutionBiasAddActivationThresholdLayerTest, CompareWithRefs) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
-    auto params = GetParam();
-    inPrc = std::get<2>(std::get<0>(params));
-    outPrc = std::get<3>(std::get<0>(params));
     Run();
 }
 
-TEST_P(ConvolutionBiasAddAddActivationLayerFiniteComparerTest, CompareWithRefs) {
+TEST_P(ConvolutionBiasAddAddActivationThresholdLayerTest, CompareWithRefs) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
-    auto params = GetParam();
-    inPrc = std::get<2>(std::get<0>(params));
-    outPrc = std::get<3>(std::get<0>(params));
     Run();
 }
 
@@ -143,7 +144,7 @@ const auto conv2DParams_AutoPadValid = ::testing::Combine(::testing::ValuesIn(ke
 
 INSTANTIATE_TEST_CASE_P(
     smoke_Convolution2DBiasAddActivation_ExplicitPaddingSymmetric1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(::testing::Combine(conv2DParams_ExplicitPaddingSymmetric1,
                                           ::testing::ValuesIn(netPrecisions),
                                           ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
@@ -153,11 +154,11 @@ INSTANTIATE_TEST_CASE_P(
                                           ::testing::Values(std::vector<size_t>({1, 3, 30, 30})),
                                           ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
                        ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_CASE_P(
     smoke_Convolution2DBiasAddActivation_ExplicitPaddingSymmetric2_FP32,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(::testing::Combine(conv2DParams_ExplicitPaddingSymmetric2,
                                           ::testing::ValuesIn(netPrecisions),
                                           ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
@@ -167,11 +168,11 @@ INSTANTIATE_TEST_CASE_P(
                                           ::testing::Values(std::vector<size_t>({1, 3, 30, 30})),
                                           ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
                        ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_CASE_P(
     DISABLED_smoke_Convolution2DBiasAddActivation_ExplicitPaddingSymmetric2_FP16,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(::testing::Combine(conv2DParams_ExplicitPaddingSymmetric2,
                                           ::testing::Values(InferenceEngine::Precision::FP16),
                                           ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
@@ -181,11 +182,11 @@ INSTANTIATE_TEST_CASE_P(
                                           ::testing::Values(std::vector<size_t>({1, 3, 30, 30})),
                                           ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
                        ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_CASE_P(
     DISABLED_smoke_Convolution2DBiasAddActivation_ExplicitPaddingAsymmetric1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(::testing::Combine(conv2DParams_ExplicitPaddingAsymmetric1,
                                           ::testing::ValuesIn(netPrecisions),
                                           ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
@@ -195,11 +196,11 @@ INSTANTIATE_TEST_CASE_P(
                                           ::testing::Values(std::vector<size_t>({1, 3, 30, 30})),
                                           ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
                        ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_CASE_P(
     DISABLED_smoke_Convolution2DBiasAddActivation_ExplicitPaddingAsymmetric2,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(::testing::Combine(conv2DParams_ExplicitPaddingAsymmetric2,
                                           ::testing::ValuesIn(netPrecisions),
                                           ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
@@ -209,11 +210,11 @@ INSTANTIATE_TEST_CASE_P(
                                           ::testing::Values(std::vector<size_t>({1, 3, 30, 30})),
                                           ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
                        ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_CASE_P(
     smoke_Convolution2DBiasAddActivation_AutoPadValid,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(::testing::Combine(conv2DParams_AutoPadValid,
                                           ::testing::ValuesIn(netPrecisions),
                                           ::testing::Values(InferenceEngine::Precision::UNSPECIFIED),
@@ -223,11 +224,11 @@ INSTANTIATE_TEST_CASE_P(
                                           ::testing::Values(std::vector<size_t>({1, 3, 30, 30})),
                                           ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
                        ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 INSTANTIATE_TEST_CASE_P(
     smoke_Convolution2DBiasAddActivation_Negative_CUDNN_CONVOLUTION_FWD_ALGO_FFT_TILING,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // strides
@@ -244,7 +245,7 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 88, 10, 10})),               // Input shape
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::Values(ngraph::helpers::ActivationTypes::None)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 /* ============= resnet50/vgg16 Convolutions ============= */
 
@@ -252,7 +253,7 @@ INSTANTIATE_TEST_CASE_P(
 // in: (1, 256, 28, 28), (256, 256, 3, 3); out: (1, 256, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group1_1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -269,13 +270,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '2,2', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 128, 56, 56), (128, 128, 3, 3); out: (1, 128, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group1_2,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -292,13 +293,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 128, 56, 56})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '2,2', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 512, 14, 14), (512, 512, 3, 3); out: (1, 512, 7, 7)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group1_3,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -315,13 +316,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 14, 14})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '2,2', 'dilations': '1,1', 'pads_begin': '3,3', 'pads_end': '3,3'},
 // in: (1, 3, 224, 224), (64, 3, 7, 7); out: (1, 64, 112, 112)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group2_1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({7, 7})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -338,13 +339,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 3, 224, 224})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'valid', 'strides': '2,2', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 256, 56, 56), (512, 256, 1, 1); out: (1, 512, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group3_1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -361,13 +362,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 56, 56})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'valid', 'strides': '2,2', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 1024, 14, 14), (2048, 1024, 1, 1); out: (1, 2048, 7, 7)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group3_2,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -384,13 +385,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 1024, 14, 14})),             // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'valid', 'strides': '2,2', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 512, 28, 28), (1024, 512, 1, 1); out: (1, 1024, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group3_3,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({2, 2})),     // stride
@@ -407,13 +408,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 256, 14, 14), (1024, 256, 1, 1); out: (1, 1024, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -430,13 +431,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 14, 14})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 64, 56, 56), (64, 64, 1, 1); out: (1, 64, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_2,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -453,13 +454,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 64, 56, 56})),               // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 128, 28, 28), (512, 128, 1, 1); out: (1, 512, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_3,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -476,13 +477,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 128, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 256, 14, 14), (256, 256, 3, 3); out: (1, 256, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_4,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -499,13 +500,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 14, 14})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 64, 56, 56), (256, 64, 1, 1); out: (1, 256, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_5,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -522,13 +523,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 64, 56, 56})),               // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 64, 56, 56), (64, 64, 3, 3); out: (1, 64, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_6,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -545,13 +546,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 64, 56, 56})),               // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 256, 56, 56), (64, 256, 1, 1); out: (1, 64, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_7,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -568,13 +569,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 56, 56})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 512, 28, 28), (128, 512, 1, 1); out: (1, 128, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_8,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -591,13 +592,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 2048, 7, 7), (512, 2048, 1, 1); out: (1, 512, 7, 7)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_9,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -614,13 +615,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 2048, 7, 7})),               // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 1024, 14, 14), (512, 1024, 1, 1); out: (1, 512, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_10,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -637,13 +638,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 1024, 14, 14})),             // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 512, 7, 7), (512, 512, 3, 3); out: (1, 512, 7, 7)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_11,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -660,13 +661,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 7, 7})),                // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 256, 56, 56), (128, 256, 1, 1); out: (1, 128, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_12,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -683,13 +684,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 56, 56})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 512, 28, 28), (256, 512, 1, 1); out: (1, 256, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_13,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -706,13 +707,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 512, 7, 7), (2048, 512, 1, 1); out: (1, 2048, 7, 7)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_14,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -729,13 +730,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 7, 7})),                // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 128, 28, 28), (128, 128, 3, 3); out: (1, 128, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_15,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -752,13 +753,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 128, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'same_upper', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0'},
 // in: (1, 1024, 14, 14), (256, 1024, 1, 1); out: (1, 256, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group4_16,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({1, 1})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -775,13 +776,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 1024, 14, 14})),             // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 64, 224, 224), (64, 64, 3, 3); out: (1, 64, 224, 224)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_1,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -798,13 +799,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 64, 224, 224})),             // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 3, 224, 224), (64, 3, 3, 3); out: (1, 64, 224, 224)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_2,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -821,13 +822,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 3, 224, 224})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 128, 56, 56), (256, 128, 3, 3); out: (1, 256, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_3,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -844,13 +845,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 128, 56, 56})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 512, 28, 28), (512, 512, 3, 3); out: (1, 512, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_4,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -867,13 +868,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 512, 14, 14), (512, 512, 3, 3); out: (1, 512, 14, 14)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_5,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -890,13 +891,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 512, 14, 14})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 256, 28, 28), (512, 256, 3, 3); out: (1, 512, 28, 28)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_6,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -913,13 +914,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 28, 28})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 256, 56, 56), (256, 256, 3, 3); out: (1, 256, 56, 56)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_7,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -936,13 +937,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 256, 56, 56})),              // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 64, 112, 112), (128, 64, 3, 3); out: (1, 128, 112, 112)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_8,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -959,13 +960,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 64, 112, 112})),             // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 128, 112, 112), (128, 128, 3, 3); out: (1, 128, 112, 112)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_9,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -982,13 +983,13 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 128, 112, 112})),            // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // attrs: {'auto_pad': 'explicit', 'strides': '1,1', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1'},
 // in: (1, 128, 112, 112), (128, 128, 3, 3); out: (1, 128, 112, 112)
 INSTANTIATE_TEST_CASE_P(
     resnet50_vgg16_group5_9,
-    ConvolutionBiasAddAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(::testing::Combine(::testing::Values(std::vector<size_t>({3, 3})),     // kernel
                                               ::testing::Values(std::vector<size_t>({1, 1})),     // stride
@@ -1005,7 +1006,7 @@ INSTANTIATE_TEST_CASE_P(
                            ::testing::Values(std::vector<size_t>({1, 128, 112, 112})),            // Input shapes
                            ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(netActivations)),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 //
 // Test generation for CUDA Fused Convolutions requires transformed models
@@ -1025,7 +1026,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid3' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid3,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1044,7 +1045,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 1, 128, 128})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1053,7 +1054,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid27' [FP32], '2d_unet-graph-transform-cuda:opid45' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid27,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1072,7 +1073,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 128, 16, 16})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1081,7 +1082,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid53' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid53,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1100,7 +1101,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 128, 32, 32})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1109,7 +1110,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid31' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid31,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1128,7 +1129,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 128, 8, 8})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1137,7 +1138,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid6' [FP32], '2d_unet-graph-transform-cuda:opid78' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid6,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1156,7 +1157,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 16, 128, 128})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1165,7 +1166,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid10' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid10,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1184,7 +1185,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 16, 64, 64})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1193,7 +1194,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid42' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid42,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1212,7 +1213,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 256, 16, 16})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1221,7 +1222,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid34' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid34,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1240,7 +1241,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 256, 8, 8})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1249,7 +1250,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid75' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid75,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1268,7 +1269,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 32, 128, 128})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1277,7 +1278,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid17' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid17,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1296,7 +1297,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 32, 32, 32})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1305,7 +1306,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid13' [FP32], '2d_unet-graph-transform-cuda:opid67' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid13,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1324,7 +1325,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 32, 64, 64})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1333,7 +1334,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid24' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid24,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1352,7 +1353,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 64, 16, 16})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1361,7 +1362,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid20' [FP32], '2d_unet-graph-transform-cuda:opid56' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid20,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1380,7 +1381,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 64, 32, 32})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1', 'pads_begin': '1,1', 'pads_end': '1,1', 'strides': '1,1'}
@@ -1389,7 +1390,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid64' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid64,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1408,7 +1409,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 64, 64, 64})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1417,7 +1418,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid3' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid3,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1436,7 +1437,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 1, 144, 144, 144})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1445,7 +1446,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid27' [FP32], '3d_unet-graph-transform-cuda:opid45' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid27,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1464,7 +1465,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 128, 18, 18, 18})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1473,7 +1474,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid53' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid53,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1492,7 +1493,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 128, 36, 36, 36})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1501,7 +1502,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid31' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid31,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1520,7 +1521,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 128, 9, 9, 9})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1529,7 +1530,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid6' [FP32], '3d_unet-graph-transform-cuda:opid78' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid6,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1548,7 +1549,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 16, 144, 144, 144})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1557,7 +1558,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid10' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid10,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1576,7 +1577,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 16, 72, 72, 72})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1585,7 +1586,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid42' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid42,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1604,7 +1605,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 256, 18, 18, 18})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1613,7 +1614,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid34' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid34,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1632,7 +1633,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 256, 9, 9, 9})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1641,7 +1642,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid75' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid75,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1660,7 +1661,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 32, 144, 144, 144})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1669,7 +1670,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid17' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid17,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1688,7 +1689,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 32, 36, 36, 36})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1697,7 +1698,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid13' [FP32], '3d_unet-graph-transform-cuda:opid67' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid13,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1716,7 +1717,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 32, 72, 72, 72})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1725,7 +1726,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid24' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid24,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1744,7 +1745,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 64, 18, 18, 18})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1753,7 +1754,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid20' [FP32], '3d_unet-graph-transform-cuda:opid56' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid20,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1772,7 +1773,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 64, 36, 36, 36})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'same_upper', 'dilations': '1,1,1', 'pads_begin': '1,1,1', 'pads_end': '1,1,1', 'strides': '1,1,1'}
@@ -1781,7 +1782,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid64' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid64,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1800,7 +1801,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 64, 72, 72, 72})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'valid', 'dilations': '1,1', 'pads_begin': '0,0', 'pads_end': '0,0', 'strides': '1,1'}
@@ -1809,7 +1810,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '2d_unet-graph-transform-cuda:opid81' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_2d_unet_graph_transform_cuda_opid81,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1828,7 +1829,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 16, 128, 128})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 
 // Attrs:  {'auto_pad': 'valid', 'dilations': '1,1,1', 'pads_begin': '0,0,0', 'pads_end': '0,0,0', 'strides': '1,1,1'}
@@ -1837,7 +1838,7 @@ INSTANTIATE_TEST_CASE_P(
 // Operators: '3d_unet-graph-transform-cuda:opid81' [FP32]
 INSTANTIATE_TEST_CASE_P(
     autogen_FusedConvolution_3d_unet_graph_transform_cuda_opid81,
-    ConvolutionBiasAddActivationLayerFiniteComparerTest,
+    ConvolutionBiasAddActivationThresholdLayerTest,
     ::testing::Combine(
         ::testing::Combine(
             ::testing::Combine(
@@ -1856,7 +1857,7 @@ INSTANTIATE_TEST_CASE_P(
             ::testing::Values(std::vector<size_t>({1, 16, 144, 144, 144})), // Input shape
             ::testing::Values(ov::test::utils::DEVICE_NVIDIA)),
         ::testing::ValuesIn(std::vector<ngraph::helpers::ActivationTypes>{ngraph::helpers::ActivationTypes::None,ngraph::helpers::ActivationTypes::Relu})),
-    ConvolutionBiasAddActivationLayerFiniteComparerTest::getTestCaseName);
+    ConvolutionBiasAddActivationThresholdLayerTest::getTestCaseName);
 
 // {AUTOGENERATED_TESTS_END_TAG}
 // clang-format on