// Copyright (C) 2018-2026 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#include "openvino/core/visibility.hpp"
#include "functional_test_utils/skip_tests_config.hpp"
#include "openvino/runtime/system_conf.hpp"
#include "utils/precision_support.h"
#include "snippets/utils.hpp"
#if defined(OPENVINO_ARCH_RISCV64)
#   include "nodes/kernels/riscv64/cpu_isa_traits.hpp"
#endif
#include <string>
#include <vector>

#include "utils/cpu_test_utils.hpp"

const std::vector<std::regex>& disabled_test_patterns() {
    auto get_patterns = []() {
        std::vector<std::regex> patterns{
            // Skip platforms that do not support BF16 (i.e. sse, avx, avx2)
            std::regex(R"(.*(BF|bf)16.*(jit_avx(?!5)|jit_sse).*)"),
            // TODO: Incorrect blob sizes for node BinaryConvolution_X
            std::regex(R"(.*BinaryConvolutionLayerTest.*)"),
            // TODO: 53618. BF16 gemm ncsp convolution crash
            std::regex(R"(.*_GroupConv.*_inFmts=nc.*_primitive=jit_gemm.*ENFORCE_BF16=YES.*)"),
            // TODO: 157596 convolution bf16 leftover test case
            std::regex(R"(smoke_JIT_AVX512_DW_GroupConv/GroupConvolutionLayerCPUTest.*ndhwc.*jit_avx512_dw.*INFERENCE_PRECISION_HINT=bf16.*)"),
            std::regex(R"(smoke_Conv_1D_1x1_BF16/ConvolutionLayerCPUTest\.CompareWithRefs/IS=\[\]_TS=\(\((1|2)\.6(4|7)\.7\)_\)_K\(1\)_S\(1\)_PB\(0\)_PE\(0\)_D=\(1\)_O=63_AP=explicit_netPRC=f32_inPRC=dynamic_outPRC=dynamic_trgDev=CPU_inFmts=nhwc_outFmts=nhwc_primitive=jit_avx512_1x1_.*PluginConf_INFERENCE_PRECISION_HINT=bf16)"),
            std::regex(R"(smoke_Conv_1D_1x1_BF16/ConvolutionLayerCPUTest\.CompareWithRefs/IS=\[1\.\.200\.64\.\?\]_TS=\(\(2\.64\.7\)_\(1\.64\.5\)_\)_K\(1\)_S\(1\)_PB\(0\)_PE\(0\)_D=\(1\)_O=63_AP=explicit_netPRC=f32_inPRC=dynamic_outPRC=dynamic_trgDev=CPU_inFmts=nhwc_outFmts=nhwc_primitive=jit_avx512_1x1_.*PluginConf_INFERENCE_PRECISION_HINT=bf16)"),
            std::regex(R"(smoke_Conv_1D_1x1_BF16/ConvolutionLayerCPUTest\.CompareWithRefs/IS=\[\?\.6(4|7)\.1\.\.200\]_TS=\(\(2\.6(4|7)\.7\)_\(1\.6(4|7)\.9\)_\)_K\(1\)_S\(1\)_PB\(0\)_PE\(0\)_D=\(1\)_O=63_AP=explicit_netPRC=f32_inPRC=dynamic_outPRC=dynamic_trgDev=CPU_inFmts=nhwc_outFmts=nhwc_primitive=jit_avx512_1x1_.*PluginConf_INFERENCE_PRECISION_HINT=bf16)"),
            std::regex(R"(smoke_GroupConv_brgemm_2D_BF16/GroupConvolutionLayerCPUTest\.CompareWithRefs/IS=\[\]_TS=\(\(1\.64\.7\.7\)_\)_K\(3\.3\)_S\(2\.2\)_PB\((0|1)\.(0|1)\)_PE\(0\.0\)_D=\(2\.2\)_O=64_G=2_AP=explicit_netPRC=f32_inPRC=dynamic_outPRC=dynamic_trgDev=CPU_inFmts=nhwc_outFmts=nhwc_primitive=brgconv_avx512_amx_.*PluginConf_INFERENCE_PRECISION_HINT=bf16)"),
            std::regex(R"(smoke_JIT_AVX512_DW_GroupConv/GroupConvolutionLayerCPUTest.*inFmts=nCdhw16c.*INFERENCE_PRECISION_HINT=bf16.*)"),
            std::regex(R"(smoke_Conv_1D_BF16/ConvolutionLayerCPUTest.*IS=\[\].*K\(3\).*S\(2\).*PE\(0\).*D=\(1\).*O=6(3|4).*brgconv_avx512_amx.*)"),
            // TODO: 56827. Sporadic test failures
            std::regex(R"(.*smoke_Conv.+_FP32.ConvolutionLayerCPUTest\.CompareWithRefs.*TS=\(\(.\.67.+\).*inFmts=n.+c.*_primitive=jit_avx2.*)"),
            // incorrect jit_uni_planar_convolution with dilation = {1, 2, 1} and output channel 1
            std::regex(R"(.*smoke_Convolution3D.*D=\(1.2.1\)_O=1.*)"),

            // TODO: Issue: 35627. CPU Normalize supports from 2D to 4D blobs
            std::regex(R"(.*NormalizeL2_1D.*)"),
            std::regex(R"(.*NormalizeL2_5D.*)"),
            // Issue: 59788. dnnl_normalize_nchw applies eps after sqrt for across_spatial
            std::regex(R"(.*NormalizeL2_.*axes=\(1.2.*_eps=100.*)"),
            std::regex(R"(.*NormalizeL2_.*axes=\(2.1.*_eps=100.*)"),
            std::regex(R"(.*NormalizeL2_.*axes=\(3.1.2.*_eps=100.*)"),

            // Not expected behavior
            std::regex(R"(.*Behavior.*CorrectConfigCheck.*(canSetConfigAndCheckGetConfig|canSetConfigTwiceAndCheckGetConfig).*CPU_BIND_THREAD=YES.*)"),
            // Issue: 72021 Unreasonable abs_threshold for comparing bf16 results
            std::regex(R"(.*smoke_Reduce.*type=(Prod|Min).*INFERENCE_PRECISION_HINT=(BF|bf)16.*)"),

            // CPU does not support dynamic rank
            // Issue: 66778
            std::regex(R"(.*smoke_BehaviorTests.*InferFullyDynamicNetworkWith(S|G)etTensor.*)"),
            std::regex(R"(.*smoke_BehaviorTests.*DynamicOutputToDynamicInput.*)"),
            std::regex(R"(.*smoke_BehaviorTests.*DynamicInputToDynamicOutput.*)"),
            // unsupported metrics
            std::regex(R"(.*OVGetMetricPropsTest.*OVGetMetricPropsTest.*(MAX_BATCH_SIZE).*)"),
            // supports only '' as device id
            std::regex(R"(.*OVClassQueryModelTest.*QueryModelWithDeviceID.*)"),
            // Issue 67214
            std::regex(R"(smoke_PrePostProcess.*resize_and_convert_layout_i8.*)"),
            // Issue: 69086
            // need to add support convert BIN -> FP32
            // if we set output precision as BIN, when we create output blob precision looks like UNSPECIFIED
            std::regex(R"(.*smoke_FakeQuantizeLayerCPUTest.*bin.*)"),
            // Issue: 71756
            std::regex(R"(.*GroupDeconv_2D_DW_BF16/GroupDeconvolutionLayerCPUTest.CompareWithRefs.*PRC=f32.*inFmts=nChw16c_outFmts=nChw16c_primitive=jit_avx512_dw_Fused=Multiply\(PerChannel\).Add\(PerChannel\)_PluginConf_INFERENCE_PRECISION_HINT=bf16*)"),
            std::regex(R"(.*smoke_GroupDeconv_(2|3)D_Blocked_BF16.*S=(\(2\.2\)|\(2\.2\.2\))_PB=(\(0\.0\)|\(0\.0\.0\))_PE=(\(0\.0\)|\(0\.0\.0\))_D=(\(1\.1\)|\(1\.1\.1\))_.*_O=64_G=4.*)"),
            // Issue:
            // New API tensor tests
            std::regex(R"(.*OVInferRequestCheckTensorPrecision.*type=u1.*)"),
            // Issue: 77390
            std::regex(R"(.*LoopLayerCPUTest.*exec_cond=0.*)"),
            std::regex(R"(.*LoopLayerCPUTest.*trip_count=0.*)"),
            std::regex(R"(.*LoopForDiffShapesLayerCPUTest.*exec_cond=0.*)"),
            std::regex(R"(.*LoopForDiffShapesLayerCPUTest.*trip_count=0.*)"),
            std::regex(R"(.*LoopForConcatLayerCPUTest.*exec_cond=0.*)"),
            std::regex(R"(.*LoopForConcatLayerCPUTest.*trip_count=0.*)"),
            // [ INFO ] Can't compile network without cache for ..  with precision ..
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*KSOFunction.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*NonMaxSuppression.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*Nms.*)"),
            // 94982. FP32->I32 conversion issue in the reference implementation. There can be some garbage in the rest of
            // float values like 0.333333745.
            // The kernel does not have such garbage. The diff 0.000000745 is taken into account in calculations and affects
            // further type conversion.
            // Reorder->GridSample->Reorder also does not work here. Potential fix is to use nearest conversion instead of
            // truncation.
            std::regex(R"(.*GridSampleLayerTestCPU.*(BILINEAR|BICUBIC).*(i32|i8).*)"),
            std::regex(R"(.*smoke_static/GridSampleLayerTestCPU.CompareWithRefs/.*_TS=.*(1.7.5.3|2.6.3.10).*_interpMode=NEAREST_padMode=REFLECTION_alignCorners=False_dataPrc=(f32|i32)_gridPrc=f32_.*)"),
            std::regex(R"(.*smoke_static/GridSampleLayerTestCPU.CompareWithRefs/.*_TS=.*5.3.2.13.*_interpMode=BICUBIC_padMode=REFLECTION_alignCorners=True_dataPrc=f32_gridPrc=f32_.*)"),
            std::regex(R"(.*smoke_static/GridSampleLayerTestCPU.CompareWithRefs/.*_TS=.*2.1.6.16.*_interpMode=NEAREST_padMode=(BORDER|REFLECTION)_alignCorners=(True|False)_dataPrc=(f32|i32)_gridPrc=f32_.*)"),
            std::regex(R"(.*smoke_dynamic/GridSampleLayerTestCPU.CompareWithRefs/IS=\(\[2..15.\?.\?.\?\]_\[\?.3.7.2\]\)_.*_interpMode=NEAREST_padMode=REFLECTION_alignCorners=False_dataPrc=f32_gridPrc=f32_.*)"),
            std::regex(R"(.*smoke_dynamic/GridSampleLayerTestCPU.CompareWithRefs/IS=\(\[\?.\?.\?.\?\]_\[\?.\?.\?.\?\]\).*interpMode=NEAREST_padMode=REFLECTION_alignCorners=False_dataPrc=f32_gridPrc=f32_.*)"),
            std::regex(R"(.*smoke_dynamic/GridSampleLayerTestCPU.CompareWithRefs/IS=\(\[\?.3.\?.\?\]_\[\?.\?.\?.2\]\).*interpMode=BICUBIC_padMode=REFLECTION_alignCorners=True_dataPrc=f32_gridPrc=f32_.*)"),
            // AdaptiveAvgPool is converted into Reduce op for suitable parameters. CPU Reduce impl doesn't support non
            // planar layout for 3D case
            std::regex(R"(.*StaticAdaPoolAvg3DLayoutTest.*OS=\(1\).*_inFmts=(nwc|nCw16c|nCw8c).*)"),
            // Issue: 111404
            std::regex(R"(.*smoke_set1/GatherElementsCPUTest.*)"),
            // Issue: 111406
            std::regex(R"(.*smoke_InterpolateLinearOnnx_Layout_Test/InterpolateLayerCPUTest.*)"),
            std::regex(R"(.*smoke_InterpolateLinear_Layout_Test/InterpolateLayerCPUTest.*)"),
            std::regex(R"(.*smoke_InterpolateCubic_Layout_Test/InterpolateLayerCPUTest.*)"),
            // Issue: 111412
            std::regex(R"(.*smoke_Proposal_(Static|Dynamic)_Test_Case1/ProposalLayerCPUTest.*)"),
            // Issue: 111418
            std::regex(R"(.*smoke_Snippets_ConvertStub/ConvertStub\.CompareWithRefImpl/IS.*_OT=\(bf16\)_#N=2_#S=2_targetDevice=CPU.*)"),
            std::regex(R"(.*smoke_Snippets_Convert/Convert\.CompareWithRefImpl/IS.*_IT=\((f32|f16)\)_OT=\(u8\)_#N=1_#S=1_targetDevice=CPU.*)"),
            std::regex(R"(.*smoke_Snippets_ConvertManyOnInputs/ConvertManyOnInputs\.CompareWithRefImpl/IS.*_IT=\(f32\.u8\)_OT=\(\)_#N=1_#S=1_targetDevice=CPU.*)"),
            // New plugin API doesn't support changes of pre-processing
            std::regex(R"(.*InferRequestPreprocessTest.*SetPreProcessToInputInfo.*)"),
            std::regex(R"(.*InferRequestPreprocessTest.*SetPreProcessToInferRequest.*)"),
            // Plugin version was changed to ov::Version
            std::regex(R"(.*VersionTest.pluginCurrentVersionIsCorrect.*)"),
            // Issue: 114765
            std::regex(R"(.*smoke_PSROIPoolingAverageLayoutTest/PSROIPoolingLayerCPUTest.*bf16.*)"),
            std::regex(R"(.*smoke_PSROIPoolingBilinearLayoutTest/PSROIPoolingLayerCPUTest.*bf16.*)"),
            // Issue: 120222
            std::regex(R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=1_axis=3_.*_modelType=f16_trgDev=CPU.*)"),
            std::regex(R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=7_axis=3_.*_modelType=f16_trgDev=CPU.*)"),
            std::regex(R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=1_axis=1_.*_modelType=f16_trgDev=CPU.*)"),
            std::regex(R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=7_axis=1_.*_modelType=f16_trgDev=CPU.*)"),
            std::regex(R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=18_.*_modelType=f16_trgDev=CPU.*)"),
            std::regex(R"(.*smoke_TopK/TopKLayerTest.Inference.*_k=21_.*_sort=value_modelType=f16_trgDev=CPU.*)"),
            // Issue: 121812
            std::regex(R"(.*ConvertCPULayerTest.*outFmts=(nhwc|nChw8c|nChw16c).*)"),
            // Issue: 123320
            // Input precision bf16 is converted to fp32 by logic in core_config.cpp during ngraph reference test.
            std::regex(R"(.*FakeConvertLayerTest.*dataPrecision=bf16.*)"),
            // Need to generate sequence exactly in the i64 data type. Enable in scope of i64 enabling.
            std::regex(R"(.*RandomUniformLayerTestCPU.*OutPrc=i64.*)"),
            // Issue: 123815 (Tests are sensintive to available thread count on testing machines)
            std::regex(R"(.*smoke_Snippets_MHA_.?D_SplitDimensionM_static.*)"),
            // Issue: 126095
            std::regex(R"(^smoke_Multinomial(?:Static|Dynamic)+(?:Log)*.*seed_g=0_seed_o=0.*device=CPU.*)"),
            // Issue: 129931
            std::regex(R"(smoke_LPT/ConvolutionTransformation.CompareWithRefImpl/f32_\[.*,3,16,16\]_CPU_f32_rank=4D_fq_on_data=\{level=256_shape=\[1\]_input_low=\{ 0 \}_input_high=\{ 255 \}_output_low=\{ .*18.7 \}_output_high\{ 18.8 \}_precision=\}_fq_on_weights=\{_255_\[6,1,1,1\]_\{ .*1.52806e.*39, .*0.2, .*0.3, .*0.3, .*0.2, .*0.1 \}_\{ 1.52806e.*39, 0.2, 0.3, 0.3, 0.2, 0.1 \}\})"),
            // TODO: 141068
            std::regex(R"(smoke_Snippets_FQDecomposition.*netPRC=f16_D=CPU.*)"),
            // Issue: 160734
            std::regex(R"(.*smoke_LPT/ConvolutionTransformation.CompareWithRefImpl/f32_\[(1|4),3,16,16\]_CPU_f32_rank=4D_fq_on_data=\{level=256_shape=\[1\]_input_low=\{ 0 \}_input_high=\{ 255 \}_output_low=\{ -18.7 \}_output_high\{ 18.8 \}_precision=\}_fq_on_weights=\{_255_\[1\]_\{ -18.7 \}_\{ 18.7 \}\}.*)"),
            // Issue: 160735
            std::regex(R"(.*smoke_TestsDFT_4d/DFTLayerTest.Inference/.*TS=\{\((10.4.20.32.2|1.120.128.1.2)\)\}.*Precision=f32.*signal_size=\(\).*)"),
            // by calc abs_threshold with expected value
            std::regex(R"(.*smoke_.*_4D.*/GatherLayerTestCPU.CompareWithRefs.*INFERENCE_PRECISION_HINT=bf16.*)"),
            std::regex(R"(.*smoke.*Mvn6LayerTest.Inference/.*TS.*1.10.5.7.8.*_ModelType=f32.*_Ax=\((2.3.4|-3.-2.-1)\).*)"),
            std::regex(R"(.*smoke.*Mvn6LayerTest.Inference/.*TS.*2.55.*_ModelType=f32.*)"),
            std::regex(R"(.*smoke_ConvWithZeroPointFuse/ConvWithZeroPointFuseSubgraphTest.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_FakeQuantize/FakeQuantizeLayerTest.Inference.*TS=.*3.49.7.5.6.*LEVELS=(255|256).*netPRC=f32.*)"),
            std::regex(R"(.*smoke_FakeQuantize/FakeQuantizeLayerTest.Inference.*TS=.*(2.16.4.3.18|3.10.2.5.6|3.49.5.6|2.16.3.18|2.8.5.18|3.10.5.6|2.8.1.5.18).*LEVELS=255.*netPRC=f32.*)"),
            std::regex(R"(.*smoke_FakeQuantize.*/FakeQuantizeLayerTest.Inference.*TS=.*3.4.2.5.*LEVELS=255.*)"),
            std::regex(R"(.*smoke_FakeQuantizePerChannel.*/FakeQuantizeLayerTest.Inference.*TS=.*11.10.22.19.*LEVELS=(255|256).*netPRC=f32.*)"),
            std::regex(R"(.*smoke_MVN_5D/Mvn6LayerTest.Inference.*TS=.*3.4.2.5.*LEVELS=255.*netPRC=f16.*)"),
            std::regex(R"(.*smoke_static/ConvertFqRnnToQuantizedRnn.*2.1.5.*2.1.1.*2.1.1.*)"),
            std::regex(R"(.*smoke_InterpolateBicubicPillow_Layout_Test/InterpolateLayerCPUTest.CompareWithRefs/ShapeCalcMode=sizes_IS=\[?.2..20.?.?\]_TS.*1.17.4.4.*2.3.10.12.*1.17.4.4.*Sizes.*4.4.*10.20.*10.4.*PARAMETER.*0.0.0.0.*0.0.1.1.*2.3.*)"),
            std::regex(R"(.*smoke_LoopForCommon/LoopLayerCPUTest.CompareWithRefs/.*_netType=bf16.*)"),
            std::regex(R"(.*smoke_FuseScaleShiftAndFakeQuantize/FuseScaleShiftAndFakeQuantizeTest.CompareWithRefs/.*Scale=\[ 30 \]_Shift=\[ 17 \]_Intervals=\[ -1 \],\[ 5 \],\[ -5 \],\[ 1 \].*)"),
            std::regex(R"(.*smoke_QuantizedConvolutionBatchNorm.*/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_quantize.*)"),
            std::regex(R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{3\}_OS=\[4,3,210\]_Min=-50_Max=0_ShapePrc=.*_OutPrc=f32_GlobalSeed=8_OperationalSeed=(0|3).*)"),
            std::regex(R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{3\}_OS=\[4,3,210\]_Min=-50_Max=50_ShapePrc=.*_OutPrc=f32_GlobalSeed=8_OperationalSeed=(5|3|0).*)"),
            std::regex(R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{3\}_OS=\[4,3,210\]_Min=-50_Max=50_ShapePrc=.*_OutPrc=f32_GlobalSeed=0_OperationalSeed=5.*)"),
            std::regex(R"(.*smoke_Param/RandomUniformLayerTestCPU.CompareWithRefs/IS=\{1\}_OS=\[500\]_Min=-50_Max=50_ShapePrc=.*_OutPrc=f32_GlobalSeed=0_OperationalSeed=5.*)"),
            std::regex(R"(.*smoke.*/RNNCellCPUTest.CompareWithRefs.*activations=.*relu.*INFERENCE_PRECISION_HINT=bf16.*)"),
            std::regex(R"(.*smoke_InterpolateBicubicPillow_Layout_Test/InterpolateLayerCPUTest.CompareWithRefs/ShapeCalcMode=sizes_IS=\[\?.2..20.\?.\?\]_TS=\(1.17.4.4\)_\(2.3.10.12\)_\(1.17.4.4\)_Sizes=\(4.4\)_\(10.20\)_\(10.4\)_PARAMETER.*P.*.1.1.*.*)"),
            std::regex(R"(.*smoke_InterpolateBicubicPillow_Layout_Test/InterpolateLayerCPUTest.CompareWithRefs/ShapeCalcMode=scales_IS=\[\?.2..20.\?.\?\]_TS=\(1.11.4.4\)_\(2.7.6.5\)_\(1.11.4.4\)_Scales=\(1.25.0.75\)_CONSTANT_.*PB=\(0.0.0.0\)_PE=\(0.0.1.1\).*)"),
            std::regex(R"(.*smoke_Conv_Sum_Broadcast_BF16/ConvSumInPlaceTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=bf16.*)"),
            std::regex(R"(.*smoke_Interpolate_Basic_Down_Sample_Tail/InterpolateLayerTest.Inference.*InterpolateMode=cubic_ShapeCalcMode=scales_CoordinateTransformMode=(pytorch_half_pixel|half_pixel).*netType=f32.*)"),
            std::regex(R"(.*smoke_basic/PermConvPermConcat.CompareWithRefs/IS=\(1.1.8.16\)_KS=\(1.5\)_OC=.*_ET=f32_targetDevice=CPU.*)"),
            std::regex(R"(.*smoke_basic/PermConvPermConcat.CompareWithRefs/IS=\(1.1.7.32\)_KS=\(1.3\)_OC=.*_ET=f32_targetDevice=CPU.*)"),
            std::regex(R"(.*smoke_BasicNegative/RangeAddSubgraphTest.*Step=-0.1_ET=f16.*)"),
            std::regex(R"(.*smoke_ConvertRangeSubgraphCPUTest/ConvertRangeSubgraphCPUTest.CompareWithRefs.*bf16.*)"),
            std::regex(R"(.*smoke_FQLayerDQBias_4D.*FQLayerDQBias.smoke_CompareWithRefs.*_TS=\(\(1.3.64.64\)_\)_layer_type=MatMul.*)"),
            std::regex(R"(.*smoke_Snippets_ConvMul/ConvEltwise.CompareWithRefImpl/IS\[0\]=\(1.10.16.16\)_IS\[1\]=\(1.10.16.16\)_Op=Multiply_#N=6_#S=1.*)"),
            std::regex(R"(.*smoke_InterpolateBicubicPillow_LayoutAlign_Test/InterpolateLayerCPUTest.CompareWithRefs/.*Sizes=\(6.8\).*)"),
            std::regex(R"(.*smoke_RDFT_CPU_1D/RDFTTestCPU.CompareWithRefs/prec=f32_.*TS0=\(\((106|246|245|510|1022)\)\).*)"),
            std::regex(R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_TS0=\(\((1022.64|24.39|126.32|510.64)\)\)_constAxes=true_axes=\(\(0.1\)\)_isInverse=false_primitive=jit_avx2.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_TS0=\(\((1022.64|126.32|510.64)\)\)_constAxes=true_axes=\(\(0\)\)_isInverse=false_primitive=jit_avx2.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_isInverse=false_primitive=jit_avx512.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_.*_TS0=\(\((20.126|20.510|20.1022)\)\)_constAxes=true_axes=\(\(1\)\)_isInverse=false_primitive=jit_avx512.*)"),
            std::regex(R"(.*smoke_TestsDFT_3d/DFTLayerTest.Inference/.*TS=.*1.120.128.1.2.*_Precision=f32.*signal_size=\(\).*)"),
            std::regex(R"(.*smoke_TestsDFT_2d/DFTLayerTest.Inference.*TS=\{\(1.120.128.1.2\)\}_Precision=f32_Axes=\(2.1\)_signal_size=\(\)_Inverse=0.*)"),
            std::regex(R"(.*smoke_FakeQuantizeLayerCPUTest_4D_(jit|ref)/FakeQuantizeLayerCPUTest.CompareWithRefs/IS=\[\?.\?.\?.\?\]_TS=\(\(4.16.6.7\)\).*inPrec=f32.*LEVELS=255.*)"),
            std::regex(R"(.*smoke_FakeQuantizeLayerCPUTest_5D_(jit|ref)/FakeQuantizeLayerCPUTest.CompareWithRefs/IS=\[\?.\?.\?.\?.\?\]_TS=\(\((4|3).16.6.7.8\)\).*inPrec=f32.*LEVELS=255.*)"),
            std::regex(R"(.*smoke_FakeQuantizeLayerCPUTest_Decompos/FakeQuantizeLayerCPUTest.CompareWithRefs/IS.*\(\((4.5.6.7|1.1.6.7|1.1.6.1|1.5.1.6)\)\)_inPrec=f32.*LEVELS=255.*)"),
            std::regex(R"(.*smoke_CompareWithRefs/LRNLayerCPUTest.CompareWithRefs/f32_IS.*axes=\(1.2.3\).*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(9.16.32.126\)\)_constAxes=true_axes=\(\((0.1.2.3|3.1|_2._1)\)\).*isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(1.192.36.64\)\)_constAxes=true_axes=\(\((0.1.2.3|3.2|_2._1|0.1|1)\)\).*isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(1.192.36.64\)\)_constAxes=true_axes=\(\((0|_2._1|0.1.2.3)\)_.*isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=.*_TS0=\(\(1.192.36.64\)_.*constAxes=false.*isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(46.10.128.65\)\)_constAxes=true_axes=\(\((1.0|0.1.2.3|3.1|_2._1)\)\).*isInverse=false.*primitive=jit_avx512.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(10.46.128.65\)\)_constAxes=true_axes=\(\((0.1|1.2)\)\).*isInverse=false.*primitive=jit_avx512.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\?.192.36.64\]_.*_axes=\(\((0|_2._1|_1|1)\)_.*isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_4D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\((1.120.64.64|1.120.96.96|\?.\?.\?.\?|1.192.\?.\?|1..2.\?.\?.1..100)\)\).*isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_2d/RDFTLayerTest.Inference/IS=\(100.16\)_modelType=f32_Axes=\((0.1|_2._1|1.0)\)_SignalSize=\(\).*)"),
            // Issue: 138520
            std::regex(R"(.*smoke_MM_Static/MatMulLayerCPUTest.CompareWithRefs/MatMul_IS=\[\]_\[\]_TS=\(\(55.12\)\)_\(\(12.55\)\)_.*\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[\]_\[\]_TS=\(\(1.32.120\)\)_\(\(120.5\)\).*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[\]_\[\]_TS=\(\(1.32.120\)\)_\(\(120.50\)\).*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[\]_\[\]_TS=\(\(1.1.120\)\)_\(\(120.120\)\).*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[\]_\[\]_TS=\(\(3.1.120\)\)_\(\(120.120\)\).*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[.*\]_\[.*\]_TS=\(\(1.5.32\)_\(1.5.32\)\).*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[..60...60...60\]_\[14.10\]_TS=\(\(1.3.14\)_\(1.7.14\)\)_\(\(14.10\)_\(14.10\)\)_.*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*nightly_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[\]_\[\]_TS=\(\(1.32.120\)\)_\(\(120.5.*\)\)_.*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*nightly_FC_3D_BF16/MatMulLayerCPUTest.CompareWithRefs/FullyConnected_IS=\[\?.\?.50\]_\[50.7\]_TS=\(\(1.2.50\)_\(1.10.50\)_\(1.2.50\)_\(2.2.50\)\)_\(\(50.7\)_\(50.7\)_\(50.7\)_\(50.7\)\)_.*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*smoke_MM_Dynamic_Fusing/MatMulLayerCPUTest.CompareWithRefs/MatMul_IS=\[\?.\?\]_\[\?.33\]_TS=\(\(16.12\)_\(33.7\)_\(16.12\)\)_\(\(12.33\)_\(7.33\)_\(12.33\)\)_transpose_a=0_transpose_b=0_secondaryInputType=PARAMETER_.*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=jit_gemm.*)"),
            std::regex(R"(.*(nightly|smoke)_MM_Brgemm_Static/MatMulLayerCPUTest.CompareWithRefs/MatMul_IS=\[\]_\[\]_TS=\(\(55.12\)\)_\(\(12.55\)\)_.*config=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=brgemm_avx512.*)"),
            std::regex(R"(.*smoke_MM_Brgemm_Dynamic_Fusing/MatMulLayerCPUTest.CompareWithRefs/MatMul_IS=\[\?.\?\]_\[\?.33\]_TS=\(\(16.12\)_\(33.7\)_\(16.12\)\)_\(\(12.33\)_\(7.33\)_\(12.33\)\)_transpose_a=0_transpose_b=0_secondaryInputType=PARAMETER_netPRC=f32_inPRC=dynamic_outPRC=dynamic_trgDev=CPUconfig=\(INFERENCE_PRECISION_HINT=bf16_\)_Fused=Multiply\(PerChannel\)_primitive=brgemm_avx512.*)"),
            // Issue: 140389
            std::regex(R"(.*FQLayerDQBias.smoke_CompareWithRefs.*)"),
            std::regex(R"(.*smoke_matmulBrgemmInt8/MatmulBrgemmInt8Test.CompareWithRefs.*MatMul.*InputType=i8_OutputType=i8.*)"),
            std::regex(R"(.*smoke_Snippets_MHAWOTransposeOnInputs_4D/MHAWOTransposeOnInputs.CompareWithRefImpl.*)"),
            // Issue: 142448
            std::regex(R"(smoke_Snippets_BroadcastSelect_Dynamic.*)"),
            // Issue: 141705
            std::regex(R"(.*smoke_LoopForCommon/LoopLayerCPUTest.CompareWithRefs/.*trip_count=5_exec_cond=1_netType=i8.*)"),
            std::regex(R"(.*smoke_LoopForCommon/LoopLayerCPUTest.CompareWithRefs/Input0_IS=\[\?.1.\?\]_TS=\(10.1.10\)_\(1.1.1\)_\(1.1.1\)_\(5.1.3\)_Input1_IS=\[\?.\?.\?\]_TS=.*_Input2_IS=\[\?.1.\?\]_.*_types=0_0_1_trip_count_type=.*_trip_count=(1|5)_exec_cond=1_netType=i8.*)"),
            std::regex(R"(.*smoke_LoopForCommon/LoopLayerCPUTest.CompareWithRefs/Input0_IS=\[1..10.1.1..10\]_.*_Input1_IS=\[1..8.1.1..8\]_.*_Input2_IS=\[1..10.\?.1..10\]_TS=.*_types=0_0_1_trip_count_type=.*_trip_count=(1|5)_exec_cond=1_netType=i8.*)"),
            // Issue: 142997
            std::regex(R"(.*smoke_TestsROIAlign.*)"),
            // Issue: 136881
            std::regex(R"(.*smoke_CompareWithRefs_4D_BitwiseShift_overflow_i32_cast.*_eltwise_op_type=BitwiseLeft.*_model_type=.*(i16|u16).*)"),
            // Issue: 163083
            // Issue: 163116
            std::regex(R"(.*RandomUniformLayerTestCPU.*OutPrc=bf16.*)"),
            // Issue: 163117
            std::regex(R"(.*InterpolateCubic_Layout_Test.*)"),
            // Issue: 163171
            std::regex(R"(.*CPUDetectionOutputDynamic3InLargeTensor.*)"),
            // Issue: 163168
            std::regex(R"(.*UniqueLayerTestCPU.*)"),
            // Issue: 163175
            std::regex(R"(.*GridSampleLayerTestCPU.*dataPrc=i8.*)"),
            std::regex(R"(.*GridSampleLayerTestCPU.*dataPrc=bf16.*)"),
            // Issue: 163177
            std::regex(R"(.*NmsRotatedOpTest.*ScoreThr=0\.4.*)"),
            // Issue: 163222
            std::regex(R"(.*bf16.*LSTMSequenceCPUTest.*)"),
            // Issue: 163223
            std::regex(R"(.*bf16.*AUGRUSequenceCPUTest.*)"),
            // Issue: 163224
            std::regex(R"(.*bf16.*GRUSequenceCPUTest.*)"),
            // Issue: 163227
            std::regex(R"(.*QuantizedModelsTests\.MaxPoolFQ.*)"),
            std::regex(R"(.*QuantizedModelsTests\.MaxPoolQDQ.*)"),
            // Issue: 163268
            std::regex(R"(.*QuantizedModelsTests\.ConvolutionQDQ.*)"),
            std::regex(R"(.*QuantizedModelsTests\.ConvolutionFQ.*)"),
            // Issue: 163230
            std::regex(R"(.*ProposalLayerTest.*)"),
            // Issue: 163232
            std::regex(R"(.*FC_3D_BF16.*MatMulLayerCPUTest.*)"),
            // Issue: 163242
            std::regex(R"(.*bf16.*RNNSequenceCPUTest.*)"),
            std::regex(R"(.*WeightlessCacheAccuracy.TiWithLstmCell.*model_dtype=bf16.*)"),
            // Issue: 163250
            std::regex(R"(.*OnnxModelWithExtensionFromDSO.*)"),
            // Issue: 163273
            // todo: define correct area
            std::regex(R"(.*Deconv_2D_Planar_FP16.*DeconvolutionLayerCPUTest.*)"),
            // Issue: 163275
            std::regex(R"(.*NoReshapeAndReshapeDynamic.*CodegenGelu.*)"),
            // Issue: 163351
            std::regex(R"(.*CoreThreadingTestsWithIter.*nightly_AsyncInfer_ShareInput.*)"),
            // Sporadic failings with ASAN enabled
            std::regex(R"(.*CoreThreadingTest.*)"),
            std::regex(R"(.*smoke_BehaviorTest.*)"),
            // This transformation is disabled on CPU
            std::regex(R"(.*smoke_LPT.*MultiplyToGroupConvolutionTransformation.*)"),
            // Disabled due to sporadic failures in CI, Issue: 157267
            std::regex(R"(.*smoke_CompareWithRefs_4D_Blocked_Blocked_Fusing\/EltwiseLayerCPUTest.CompareWithRefs\/IS=\(\[\]_\)_TS.*2.4.4.1.*eltwise_op_type=(Sum|Mod|SqDiff|Prod)_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f32_InType=dynamic_OutType=dynamic_trgDev=CPU_config_item=INFERENCE_PRECISION_HINT=f32_inFmts=nChw16c.nChw16c_outFmts=nChw16c_Fused=FakeQuantize\(PerChannel\).*)"),
            std::regex(R"(.*smoke_CachingSupportCase_CPU\/CompileModelCacheTestBase.CompareWithRefImpl\/SplitConvConcatNestedInBranchNestedOut_i16_batch1_CPU.*)"),
            std::regex(R"(.*smoke_CompareWithRefs_5D_MemOrder_Blocked_Blocked\/EltwiseLayerCPUTest.CompareWithRefs\/IS=\(\[\]_\[\]_\)_TS=.*2.17.6.5.1.*_.*1.17.1.1.4.*_\)_eltwise_op_type=Sub_secondary_input_type=CONSTANT_opType=VECTOR_model_type=bf16_InType=dynamic_OutType=dynamic_trgDev=CPU_config_item=INFERENCE_PRECISION_HINT=f32_inFmts=nCdhw16c.nCdhw16c_outFmts=nCdhw16c_enforceSnippets=0.*)"),
            std::regex(R"(.*.*smoke_CompareWithRefs_4D_Fusing_Blocked_Blocked\/EltwiseLayerCPUTest.CompareWithRefs\/IS=\(\[\]_\)_TS=\(\(2.4.4.1\)_\)_eltwise_op_type=Mod_secondary_input_type=PARAMETER_opType=VECTOR_model_type=f32_InType=dynamic_OutType=dynamic_trgDev=CPU_config_item=INFERENCE_PRECISION_HINT=f32_inFmts=nChw16c.nChw16c_outFmts=nChw16c_Fused=FakeQuantize\(PerChannel\).Sigmoid.FakeQuantize\(PerTensor\)_enforceSnippets=0.*)"),
            std::regex(R"(.*smoke_Conv_1D_GEMM_FP32\/ConvolutionLayerCPUTest.CompareWithRefs\/IS=\[\]_TS=\(\(2.12.7\)_\)_K\(3\)_S\(2\)_PB\(1\)_PE\(0\)_D=\(1\)_O=6_AP=explicit_netPRC=f32_inPRC=dynamic_outPRC=dynamic_trgDev=CPU_inFmts=ncw_outFmts=ncw_primitive=jit_gemm_Fused=Relu.*)"),
            // fp32 floor for bf16 models: conversion issue
            std::regex(R"(.*smoke.*ActivationLayerCPUTest.*CompareWithRefs/(Floor|Ceiling)_.*netPRC=bf16.*)"),
            // Issue: 170623
            std::regex(R"(.*smoke_ConcatSDPTransposeTestWrongBeamIdx.*)"),

            // Disabled due to dependency on tests execution order, issue: 178036
#if !(defined(__APPLE__) && defined(__MACH__)) && (defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_ARM))
            std::regex(R"(.*smoke_ScaledAttn_CPU\/ScaledAttnLayerCPUTest.CompareWithRefs\/netPRC=f32_IS=\[\?.8.\?.64]_\[\?.8.\?.64]_\[\?.1.\?.\?\]_TS=\(1.8.100.64\)_\(1.8.1.64\)_\(2.8.10.64\)_\(2.8.10.64\)_\(1.8.100.64\)_\(1.8.1.64\)_\(2.8.10.64\)_\(2.8.10.64\)_\(1.1.1.100\)_\(1.1.1.1\)_\(2.1.1.10\)_\(2.1.10.10\)_is_causal=0_has_attn=0_has_scale=0_trgDev=CPU_primitive=ref_any.*)"),
#endif
#if defined(OPENVINO_ARCH_X86)
            std::regex(R"(.*DetectionOutputLayerTest.*)"),
            // WIP: plugin cannot be loaded for some reason
            std::regex(R"(.*IEClassBasicTestP.*)"),
#elif defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_ARM)
            std::regex(R"(smoke_CompareWithRefs_static_check_collapsing/EltwiseLayerTest.Inference/IS.*_eltwise_op_type=Div_secondary_input_type=PARAMETER_opType=VECTOR_model_type=i32_InType=dynamic_OutType=dynamic_trgDev=CPU.*)"),
            // Issue: 123321
            std::regex(R"(.*smoke_RNNSequenceCommonZeroClip/RNNSequenceTest.Inference.*hidden_size=1.*relu.*direction=reverse.*)"),
            // Ticket: 134601
            std::regex(R"(.*smoke_GroupNormalization.*)"),
            // by calc abs_threshold with expected value
            std::regex(R"(.*smoke_Interpolate_Basic_Down_Sample_Tail/InterpolateLayerTest.Inference.*InterpolateMode=(linear|linear_onnx)_ShapeCalcMode=scales_CoordinateTransformMode=half_pixel.*PE=\(0.0.0.0\).*netType=f32.*)"),
            std::regex(R"(.*smoke_ConversionLayerTest/ConversionLayerTest.Inference/conversionOpType=Convert_.*_inputPRC=f16_targetPRC=(u8|i8).*)"),
            std::regex(R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference/.*TS=\{\((1.16.5.8|2.19.5.10)\)\}_ModelType=f32_.*_Ax=\(0.1.2.3\)_NormVariance=FALSE.*)"),
            std::regex(R"(.*smoke_Decomposition_4D/Mvn6LayerTest.Inference/.*TS=\{\(2.19.5.10\)\}_ModelType=f32_.*_Ax=\(1\).*)"),
            std::regex(R"(.*smoke_LogSoftmax4D/LogSoftmaxLayerTest.Inference/.*TS=\{\(2.3.4.5\)\}_modelType=f32_axis=(-4|-3|-2|0|1|2).*)"),
            std::regex(R"(.*smoke_Interpolate_Basic/InterpolateLayerTest.Inference/.*InterpolateMode=cubic_ShapeCalcMode=sizes_CoordinateTransformMode=tf_half_pixel.*PB=\(0.0.0.0\)_PE=\(0.0.1.1\)_.*netType=f32.*)"),
            // Ticket: 144845
            std::regex(R"(.*LSTMCellFusion/LSTMCellFusionWithSplitWeights.SubgraphFusedToLSTMCell/(1|8|15))"),
            // Ticket: 131541
            std::regex(R"(.*smoke_MulticlassNmsLayerTest_dynamic2.*_outType=i32_.*)"),
            // Ticket: 162434
            std::regex(R"(smoke_LPT/MatMulTransformation.*)"),
            // Ticket: 162260
            std::regex(R"(smoke_Snippets_FQDecomposition.*netPRC=f32_D=CPU.*)"),
            // Ticket: 166771
            std::regex(R"(.*smoke_BroadcastEltwise/BroadcastEltwise.smoke_CompareWithRefs.*)"),
            // Ticket: 168863
            std::regex(R"(.*smoke_AvgPoolV14_CPU_4D/AvgPoolingV14LayerCPUTest.CompareWithRefs.*)"),
            // Ticket: 168931
            std::regex(R"(.*smoke_Reduce_OneAxis_dynamic_CPU/ReduceCPULayerTest.CompareWithRefs.*)"),
            // invalid test: checks u8 precision for runtime graph, while it should be f32
            std::regex(R"(smoke_NegativeQuantizedMatMulMultiplyFusion.*)"),
            // int8 specific
            std::regex(R"(smoke_Quantized.*)"),
            // Issue: 124309
            std::regex(R"(.*InferRequestPreprocessConversionTest.*oLT=NHWC.*)"),
            std::regex(R"(.*smoke_NoReshape/OVCompiledModelGraphUniqueNodeNamesTest.CheckUniqueNodeNames.*)"),
            std::regex(R"(.*smoke_BehaviorTests/InferRequestPerfCountersTest.CheckOperationInPerfMap.*)"),
            std::regex(R"(smoke_ExecGraph/ExecGraphRuntimePrecision.CheckRuntimePrecision/Function=FakeQuantizeBinaryConvolution.*)"),
            // Issue: 124395
            std::regex(R"(smoke_VariableStateBasic/InferRequestVariableStateTest.*)"),
            std::regex(R"(smoke_VariableState/OVInferRequestVariableStateTest.*)"),
            // Issue: 141705
            std::regex(R"(.*smoke_arm_Deconv_2D_Planar_FP16/DeconvolutionLayerCPUTest.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*ConcatMultiQuerySDPTest.*u8.*)"),
            std::regex(R"(.*smoke_ConcatSDPTransposeByChannelTest.*)"),
            // Issue: 168490
            std::regex(R"(.*CPU/CoreThreadingTest.smoke_QueryModel.*)"),
            std::regex(R"(.*WeightlessCacheAccuracy.*)"),
            // Ticket: 181107
            std::regex(R"(.*smoke_ConvAndFQ_CPU.*)"),
#endif
#if defined(OPENVINO_ARCH_ARM)
            // Issue: 144998
            std::regex(R"(.*smoke_CachingSupportCase_CPU.*_(i8|u8).*)"),
            std::regex(R"(.*smoke_Hetero_CachingSupportCase.*_(i8|u8).*)"),
            // TODO: rounding errors
            std::regex(R"(.*iv_secondaryInputType=PARAMETER_opType=VECTOR_NetType=i32.*)"),
            // not supported
            std::regex(R"(.*fma.*EltwiseLayerCPUTest.*)"),
            std::regex(R"(.*int_jit.*EltwiseLayerCPUTest.*)"),
            std::regex(R"(.*dyn.*EltwiseChainTest.*)"),
            std::regex(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=i8.*Conversion=i8.*)"),
            std::regex(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=u8.*Conversion=i8.*)"),
            std::regex(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=i16.*Conversion=i8.*)"),
            std::regex(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=u16.*Conversion=i8.*)"),
            std::regex(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*InPRC0=i32.*Conversion=i8.*)"),
            // by calc abs_threshold with expected value
            std::regex(R"(.*smoke_CompareWithRefs_static/EltwiseLayerTest.*_eltwise_op_type=Div_.*_model_type=i32_.*)"),
            // int8 / code-generation specific
            std::regex(R"(smoke_LPT.*)"),
            std::regex(R"(.*smoke_RoPETest.*)"),
            std::regex(R"(.*ActivationLayerTest.*Inference.*)"),
            std::regex(R"(.*AddConvertToReorderTest.*smoke_TestAddReorder_CPU.*)"),
            std::regex(R"(.*AddOutputsTest.*smoke_CheckOutputExist.*)"),
            std::regex(R"(.*CompileModelCacheRuntimePropertiesTestBase.*CanLoadFromFileWithoutException.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*2InputSubtract_f.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*ConvPoolRelu_f.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*MatMulBias_f.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*SimpleFunctionRelu_f.*)"),
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl/MatMulBias_f32_batch1_CPU)"),
            std::regex(R"(.*CompileModelLoadFromCacheTest.*CanGetCorrectLoadedFromCacheProperty.*)"),
            std::regex(R"(.*CompileModelLoadFromFileTestBase.*CanCreateCacheDirAndDumpBinariesUnicodePath.*)"),
            std::regex(R"(.*CompileModelLoadFromFileTestBase.*CanLoadFromFileWithoutException.*)"),
            std::regex(R"(.*CompileModelLoadFromMemoryTestBase.*CanLoadFromMemoryWithoutExecption.*)"),
            std::regex(R"(.*CompileModelLoadFromMemoryTestBase.*CanLoadFromMemoryWithoutWeightsANdExecption.*)"),
            std::regex(R"(.*CompileModelWithCacheEncryptionTest.*CanImportModelWithoutException.*)"),
            std::regex(R"(.*ConcatMultiQuerySDPTest.*f16.*)"),
            std::regex(R"(.*ConcatSDPTest.*f16.*)"),
            std::regex(R"(.*FakeConvertLayerTest.*f16.*)"),
            std::regex(R"(.*CoreThreadingTestsWithCacheEnabled.*smoke_compiled_model_cache_enabled.*)"),
            std::regex(R"(.*CoreThreadingTestsWithIter.*smoke_CompileModel.*)"),
            std::regex(R"(.*CustomOpConvertI64CPUTest.*CompareWithRefs.*)"),
            std::regex(R"(.*EltwiseLayerCPUTest.*CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*EltwiseLayerTest.*Inference.*)"),
            std::regex(R"(.*ExecGraphDuplicateInputsOutputsNames.*CheckOutputsMatch.*)"),
            std::regex(R"(.*ExecGraphKeepAssignNode.*KeepAssignNode.*)"),
            std::regex(R"(.*ExecGraphRemoveParameterNode.*RemoveParameterNode.*)"),
            std::regex(R"(.*IndexAddTest.*CompareWithRefs.*)"),
            std::regex(R"(.*InterpolateLayerCPUTest.*CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*MatMulLayerCPUTest.*CompareWithRefs.*)"),
            std::regex(R"(.*MatmulWeightsDecompression.*CompareWithRefs.*)"),
            std::regex(R"(.*MvnLayerCPUTest.*CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*NonInputInPlaceTest.*CompareWithRefs.*)"),
            std::regex(R"(.*OVClassCompiledModelGetPropertyTest_EXEC_DEVICES.*CanGetExecutionDeviceInfo.*)"),
            std::regex(R"(.*OVClassConfigTestCPU.*smoke_.*)"),
            std::regex(R"(.*OVClassConfigTestCPU.*smoke_CpuExecNetwork.*)"),
            std::regex(R"(.*OVInferenceChaining.*StaticOutputToDynamicInput.*)"),
            std::regex(R"(.*OVInferenceChaining.*StaticOutputToStaticInput.*)"),
            std::regex(R"(.*OVInferenceChainingStatic.*StaticOutputToStaticInput.*)"),
            std::regex(R"(.*ReduceCPULayerTest.*CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            // Issue: 164799
            std::regex(R"(.*CompileModelCacheTestBase.*CompareWithRefImpl.*)"),
            // Issue 167685
            std::regex(R"(.*importExportModelWithTypeRelaxedExt.*)"),
#endif
#if defined(OPENVINO_ARCH_RISCV64)
            // object is not initialized
            std::regex(R"(.*StaticLoopDynamicSubgraphCPUTest.smoke_StaticLoopWithDynSubgraph.*)"),
            // crash with 'double free or corruption (!prev)'
            std::regex(R"(.*smoke_InterpolateBilinearPillow_Layout_Test.*)"),
            std::regex(R"(.*smoke_InterpolateBicubicPillow_Layout_Test.*)"),
            // unsupported node type 'CausalMaskPreprocess'
            std::regex(R"(CausalMaskPreprocessCausalMaskPreprocess.smoke_CompareWithRefs)"),
            // fused op FakeQuantize has not been found
            std::regex(R"(ConvAndFQWithSharedConstants.smoke_ConvAndFQWithSharedConstants_CPU)"),
            // subgraphs code-generator is not supported on non-x64 platforms
            std::regex(R"(SubgraphSnippetSerializationTest.smoke_SerializeSubgraph(WithScalarConst)?)"),
            std::regex(R"(.*SubgraphWithBlockedFormat.*)"),
            // unsupported layout
            std::regex(R"(GatherAddAvgpool.smoke_CompareWithRefs)"),
            std::regex(R"(smoke_StaticAdaPoolAvg(4|5)DLayoutTest/AdaPoolLayerCPUTest.*_outFmts=nd?hwc_1)"),
            std::regex(R"(.*smoke_CompareWithRefs_Mvn(4|5)D(_Static)?/MvnLayerCPUTest.CompareWithRefs.*inFmts=nd?hwc.*)"),
            std::regex(R"(.*smoke_TopK(_int32|_bubble_BLK_on_channel_horiz)?(_dynamic)?/TopKLayerCPUTest.CompareWithRefs.*inFmts=(nhwc|nChw8c|nChw16c).x.*)"),
            std::regex(R"(.*smoke_(Group)?Convolution(2|3)D/ConvConcatSubgraphTest.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_FakeQuantizeCache_(4|5)D/FakeQuantizeCacheTest.CompareWithRefs.*inFmts=(nhwc|nChw8c|ndhwc|nCdhw8c).*)"),
            std::regex(R"(.*ReduceCPULayerTest.CompareWithRefs.*inFmts=nhwc.*)"),
            // only infer_precision=f32 is supported on riscv64 platforms
            std::regex(R"(.*smoke_CompareWithRefs_(4|5)D.*EltwiseLayerCPUTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*smoke_CompareWithRefs_Mvn[12345]D.*/MvnLayerCPUTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*ReduceCPULayerTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*RemoveUselessFP16ConvertCPUTest.*INFERENCE_PRECISION_HINT=f16.*)"),
            // fused op Add has not been found
            std::regex(R"(.*smoke_CompareWithRefs_fma_(4|5)D/EltwiseLayerCPUTest.CompareWithRefs.*)"),
            // primType is unexpected
            std::regex(R"(.*smoke_Param(Const)?/RandomUniformLayerTestCPU.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_Reduce_Int32_CPU/ReduceCPULayerTest.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_(static|dynamic)Shapes4D(C(16|32))?(_Transpose|_PermutePerChannels)/TransposeLayerCPUTest.CompareWithRefs.*netPRC=f32.*INFERENCE_PRECISION_HINT=f16.*)"),
            std::regex(R"(.*smoke_(static|dynamic)_1D/GatherLayerTestCPU.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_(1|2|4)D/RDFTTestCPU.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_CompareWithRefs(Numpy|None)_dynamic/SelectLayerCPUTest.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_Check/ConvPoolActivTest.CompareWithRefs.*)"),
            std::regex(R"(.*smoke_Conv_Sum_(1x1_)?Broadcast(_FP32|_Strided|_INT8|_Several_Consumers|_StaticShape)?/Conv(1x1)?Sum(InPlace(Test(Int8|SeveralConsumers)?|Strided)?|(Unsupported)?BroadcastTest).CompareWithRefs.*)"),
            std::regex(R"(.*smoke_ReshapeFc/ReshapeFcCPUTest.CompareWithRefs.*)"),
            // dimensions of shapes are mismatched
            std::regex(R"(.*CPUDetectionOutputDynamic3InLargeTensor/DetectionOutputLayerCPUTest.CompareWithRefs.*varEnc=0.*)"),
            // cannot get dims for non static shape
            std::regex(R"(.*nightly_/NmsRotatedOpTest.CompareWithRefs/IS=\(\[\]_\[\]\)_TS=\{\(3.11.5\)_\(3.15.11\)\}__BoxPrc=f16_MaxPrc=i64_ThrPrc=f16_OutPrc=i64_MaxBox=10.*ConstIn=\{True,True,True,True,True\}_Device=CPU.*)"),
            std::regex(R"(nightly_/NmsRotatedOpTest.CompareWithRefs/IS=\(\[\]_\[\]\)_TS=\{\(15.29.5\)_\(15.31.29\)\}__BoxPrc=f16_MaxPrc=i64_ThrPrc=f16_OutPrc=i64_MaxBox=10_IouThr=0.5_ScoreThr=0.4_SortDesc=False_Clockwise=True_ConstIn=\{True,True,True,True,True\}_Device=CPU)"),
            std::regex(R"(nightly_/NmsRotatedOpTest.CompareWithRefs/IS=\(\[\]_\[\]\)_TS=\{\(21.64.5\)_\(21.32.64\)\}__BoxPrc=f16_MaxPrc=i64_ThrPrc=f16_OutPrc=i64_MaxBox=10_IouThr=0.5_ScoreThr=0.4_SortDesc=False_Clockwise=True_ConstIn=\{True,True,True,True,True\}_Device=CPU)"),
            std::regex(R"(nightly_/NmsRotatedOpTest.CompareWithRefs/IS=\(\[\?.\?.5\]_\[\?.\?.\?\]\)_TS=\{\(7.35.5\)_\(7.30.35\)\}_\{\(7.35.5\)_\(7.100.35\)\}_\{\(7.35.5\)_\(7.133.35\)\}__BoxPrc=f16_MaxPrc=i64_ThrPrc=f16_OutPrc=i64_MaxBox=10_IouThr=0.5_ScoreThr=0.4_SortDesc=False_Clockwise=True_ConstIn=\{True,True,True,True,True\}_Device=CPU)"),
            // Accuracy problem
            std::regex(R"(.*InterpolateCubic_Layout_Test.*)"),
            std::regex(R"(.*nightly_(static|dynamic)/UniqueLayerTestCPU.*dataPrc=i8.*)"),
            std::regex(R"(.*smoke_Interpolate_Basic/InterpolateLayerTest.Inference/IS=\(\[\]\)_TS=\{\(1.4.6.6\)\}_TS=\(1.4.8.8\)_InterpolateMode=cubic_ShapeCalcMode=sizes_CoordinateTransformMode=tf_half_pixel_for_nn_NearestMode=round_prefer_floor_cube_coef=-0.75_Antialias=0_PB=\(0.0.0.0\)_PE=\(0.0.1.1\)_Axes=\(0.1.2.3\)_Scales=\(1.1.1.33333.1.33333\)_netType=f32_trgDev=CPU.*)"),
            std::regex(R"(.*smoke_MaxPool_ExplicitPad_CeilRounding.*K\(3.3\)_S\(\d.2\).*PE\(0.2\).*)"),
            // Incorrect number of input or output memory formats
            std::regex(R"(.*smoke_(static|dynamic)/RNNCellCPUTest.CompareWithRefs.*)"),
            // crash with code: 11
            std::regex(R"(.*smoke_static/ConvertFqRnnToQuantizedRnn.CompareWithRefs.*)"),
            // Fused op Elu has not been found
            std::regex(R"(.*smoke_Check/AlignMatMulInputRanksTest.CompareWithRefs/IS_A=\[\d.+\]_IS_B=\[\d.+\]__Fused=Elu.*)"),
            // Unsupported node type 'ScaledDotProductAttention'
            std::regex(R"(.*smoke_Concat(MultiQuery)?SDP(Transpose)?Test(SetState)?/.*)"),
            // Unexpected transpose count
            std::regex(R"(.*smoke_Basic/FuseTransposeAndReorderTest3.CompareWithRefs.*)"),
            // Unsupported node type 'Interaction'
            std::regex(R"(.*smoke_Interaction/IntertactionCPUTest.CompareWithRefs.*)"),
            // Unexpected count of the `Reorder` nodes
            std::regex(R"(.*smoke_MergeTransposeReorder_(static|dynamic)/MergeTransposeReorderCPUTest.CompareWithRefs.*)"),
            // Unexpected value of 'num_ops'
            std::regex(R"(.*smoke_RoPETest.*)"),
            // Unsupported node type 'ScaledDotProductAttention'
            std::regex(R"(.*smoke_SDPAGroupBeamSearchTest/SDPAGroupBeamSearchTest.CompareWithRefs.*)"),
            // Crash with code: 6
            std::regex(R"(^smoke_VirtualPlugin_BehaviorTests/OVHoldersTest.Orders/target_device=HETERO.CPU$)"),
            // Crash with code: 14, but can be launched with `--gtest_filter`
            std::regex(R"(.*CPU/CoreThreadingTest.smoke_QueryModel.*)"),
            // Target Static Shape is empty
            std::regex(R"(.*proposal_params/.*)"),
            // Quantized models unsupported
            std::regex(R"(.*Quantized.*)"),
            std::regex(R"(smoke_Snippets(?!_(Eltwise|ThreeInputsEltwise)(/|_)).*)"),
            std::regex(R"(.*_enforceSnippets=1.*)"),
#endif
#if !defined(OPENVINO_ARCH_X86_64)
            // very time-consuming test
            std::regex(R"(.*OVInferConsistencyTest.*)"),
            // TODO: generate new 'expected' runtime graph for non-x64 CPU
            std::regex(R"(smoke_serialization/ExecGraphSerializationTest.ExecutionGraph.*)"),
            
                std::regex(R"(smoke_ExecGraph/ExecGraphRuntimePrecision.CheckRuntimePrecision/Function=(EltwiseWithTwoDynamicInputs|FakeQuantizeRelu).*)"),
            // Issue 108803: bug in CPU scalar implementation
            std::regex(R"(smoke_TestsDFT_(1|2|3|4)d/DFTLayerTest.CompareWithRefs.*)"),
            std::regex(R"(smoke_TestsDFT_(1|2|3|4)d/DFTLayerTest.Inference.*)"),
            // Issue 88764, 91647, 108802: accuracy issue
            std::regex(R"(MultipleLSTMCellTest/MultipleLSTMCellTest.CompareWithRefs.*)"),
            // Compressed weights are not supported
            std::regex(R"(smoke_MatMulSharedCompressedWeights.*)"),
            std::regex(R"(smoke_Model_Distribution_MatMulSharedCompressedWeights.*)"),
            std::regex(R"(smoke_MatmulAndGatherSharedWeightsDecompression.*)"),
            // Issue: 170863
            std::regex(R"(smoke_Model_Distribution_MatMul_NoTranspose.*)"),
#endif
#if defined(OPENVINO_ARCH_ARM64)
            // Issue: 149216. For low precision model from original framework, Snippets PropagatePrecision should insert ConvertTruncation instead
            // of ConvertSaturation when converting larger integer to smaller integer to align with c++ standard and ngraph reference.
            std::regex(R"(.*smoke_EltwiseChain_MergeConvert_int8/.*Op0=Prod.*Conversion=i8.*)"),
            // Tests to be enabled on ARM64
            std::regex(R"(smoke_Snippets_ConvAdd/ConvEltwise.CompareWithRefImpl.*)"),
            std::regex(R"(smoke_Snippets_GroupNormalization.*)"),
            std::regex(R"(smoke_Snippets_PrecisionPropagation_Convertion.*)"),
#endif
#if !defined(OPENVINO_ARCH_ARM64) && !defined(OPENVINO_ARCH_X86_64) && !defined(OPENVINO_ARCH_RISCV64)
            // smoke_Snippets test cases are on platforms except x64, ARM64 and RISCV64
            std::regex(R"(smoke_Snippets.*)"),
#endif
#if defined(_WIN32)
            std::regex(R"(.*smoke_QuantizedConvolutionBatchNormTransposeOnWeights/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_quantize_type=fake_quantize_intervals_type=per_(tensor|channel)_transpose_on_weights=true_device=CPU.*)"),
            std::regex(R"(.*smoke_LPT/ConvolutionTransformation.CompareWithRefImpl/f32_\[(1|4),3,16,16\]_CPU_f32_rank=4D_fq_on_data=\{level=256_shape=\[1,1,1,1\]_input_low=\{ 0 \}_input_high=\{ 255 \}_output_low=\{ -12.7 \}_output_high\{ 12.8 \}_precision=\}_fq_on_weights=\{_255_\[1,1,1,1\]_\{ -12.7 \}_\{ 12.7 \}\}.*)"),
            std::regex(R"(.*smoke_LPT/FuseDequantizeToFakeQuantizeTransformation.CompareWithRefImpl/CPU_f32_0_dynamic_\[\]_f32__\{\}_\{\}__\{ 0.01, 0.1, 1 \}_f32_\[1,3\]_1_1_.*)"),
            std::regex(R"(.*smoke_QuantizedConvolutionBatchNorm/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_quantize_.*)"),
            std::regex(R"(.*smoke_QuantizedConvolutionBatchNorm/QuantizedConvolutionBatchNorm.CompareWithRefs/conv_type=convolution_backprop_quantize_type=(quantize_dequantize_intervals|compressed_weights_intervals).*)"),
            std::regex(R"(.*smoke_LPT/MatMulTransformation.CompareWithRefImpl/f32_CPU_\[(1|8|1,1,1),4,12,2\]_level=256_shape=\[\]_input_low=\{ (0|-12.8) \}_input_high=\{ (25.5|12.7) \}_output_low=\{ (0|-12.8) \}_output_high\{ (25.5|12.7) \}_.*)"),
            std::regex(R"(.*smoke_LPT/MatMulTransformation.CompareWithRefImpl/f32_CPU_\[(1|8|1,1,1),4,12,2\]_level=256_shape=\[\]_input_low=\{ (0|-12.8) \}_input_high=\{ (25.5|12.7) \}_output_low=\{ (0|-12.8) \}_output_high\{ (25.5|12.7) \}_.*)"),
            std::regex(R"(.*smoke_MatMulCompressedWeights_corner_cases_basic/MatmulWeightsDecompression.CompareWithRefs/data_shape=\[\?.\?.\?\]_\(\[1,1,4096\]\)_weights_shape=\[4096,4096\]_group_size=128_weights_precision=nf4_decompression_precision=f16_scale_precision=dynamic_transpose_weights=0_decompression_subtract=full_reshape_on_decompression=1_config=\(\).*)"),
            std::regex(R"(.*smoke_RDFT_CPU_1D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(126\)\)_constAxes=true_axes=\(\(0\)\)_isInverse=false.*)"),
            std::regex(R"(.*smoke_RDFT_CPU_2D/RDFTTestCPU.CompareWithRefs/prec=f32_IS0=\[\]_TS0=\(\(16.38\)\)_constAxes=true_axes=\(\(0.1\)\)_isInverse=false.*)"),
#endif
#ifdef SNIPPETS_LIBXSMM_TPP
            // GN in TPP requires exposing tmp Buffer results outside the loop (ticket: 151234)
            std::regex(R"(.*smoke_Snippets_GroupNormalization.*)"),
            // TPP performs precision conversion implicitly, it makes all Convert tests irrelevant
            std::regex(R"(.*smoke_Snippets_Convert.*)"),
            // ABS and ROUND operations are needed for TPP support. Disable, since low precisions are not supported by TPP yet.
            std::regex(R"(.*smoke_Snippets_FQ.*)"),
            std::regex(R"(.*smoke_Snippets_TransposeMatMulFQ.*)"),
            // TPP doesn't support op with 2 outs, when one of them is Result (ticket: 130642)
            std::regex(R"(.*smoke_Snippets_MaxNumParamsEltwise.*)"),
            std::regex(R"(.*smoke_Snippets_Eltwise_TwoResults.*)"),
            // Accuracy problem with Exp + Reciprocal combination on TPP side (ticket: 130699)
            std::regex(R"(.*smoke_Snippets_ExpReciprocal.*)"),
            std::regex(R"(.*smoke_Snippets_AddSoftmax.*)"),
            std::regex(R"(.*smoke_Snippets_TransposeSoftmaxEltwise.*)"),
            // Low-precision Matmuls are not supported by TPP yet
            std::regex(R"(.*smoke_Snippets.*=(BF16|bf16|i8|u8).*)"),
            std::regex(R"(.*smoke_Snippets.*MatMulFQ.*)"),
            std::regex(R"(.*smoke_Snippets.*MatMulBiasQuantized.*)"),
            std::regex(R"(.*smoke_Snippets.*MatMulsQuantized.*)"),
            std::regex(R"(.*smoke_Snippets.*MatMulsQuantizedSoftmax.*)"),
            std::regex(R"(.*smoke_Snippets.*MHAINT8MatMul.*)"),
            std::regex(R"(.*smoke_Snippets.*MHAQuantMatMul0.*)"),
            std::regex(R"(.*smoke_Snippets.*MHAFQ.*)"),
            std::regex(R"(.*smoke_Snippets.*PrecisionPropagation_Convertion.*)"),
            std::regex(R"(.*smoke_MHAQuant.*)"),
            std::regex(R"(.*smoke_Snippets_MLP.*)"),
#    if defined(OPENVINO_ARCH_ARM64)
            std::regex(R"(.*smoke_Snippets_GatedMLP_f32.*InputShape=\[\]_\(\[1\.32\.1024\]\).*)"),
            std::regex(R"(.*smoke_Snippets_MatMulTransposeB.*IS\[0\]=\[\]_.*T\[0\]=f32.*)"),
            std::regex(R"(.*smoke_Snippets_TransposeMatMulBias.*)"),
#    endif
#endif
        };


        if (!ov::intel_cpu::hasHardwareSupport(ov::element::bf16)) {
            // on platforms which do not support bfloat16, we are disabling bf16 tests since there are no bf16 primitives,
            // tests are useless on such platforms
            patterns.emplace_back(std::regex(R"(.*(BF|bf)16.*)"));
            patterns.emplace_back(std::regex(R"(.*bfloat16.*)"));
        }
        if (!ov::test::snippets::is_i8_supported_by_brgemm()) {
            patterns.emplace_back(std::regex(R"(.*Snippets.*MatMulFQ.*)"));
            patterns.emplace_back(std::regex(R"(.*Snippets.*MatMul.*Quantized.*)"));
            patterns.emplace_back(std::regex(R"(.*Snippets.*MHAFQ.*)"));
            patterns.emplace_back(std::regex(R"(.*Snippets.*MHAINT8.*)"));
            patterns.emplace_back(std::regex(R"(.*Snippets.*MHAQuant.*)"));
            patterns.emplace_back(std::regex(R"(.*Snippets.*MLP.*Quantized.*)"));
        }
        // MHA BF16 precision is only supported on BF16 supported platform
        if (!ov::test::snippets::is_bf16_supported_by_brgemm()) {
            // ignored for not supported bf16 platforms
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_EnforcePrecision_bf16.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHAWOTransposeEnforceBF16.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_FullyConnected_EnforceBF16.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHA.*EnforceBF16.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_.*MLP.*bf16.*)"));
            patterns.emplace_back(std::regex(R"(.*ConcatSDPTest.*bf16.*)"));
        }
        if (!ov::test::snippets::is_fp16_supported_by_brgemm()) {
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHA.*FP16.*)"));
        } else {
            // Skip failing FP16 MHA tests on ARM64 due to low accuracy (FP16 accumulator is used in Gemm)
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHAWOTransposeEnforceFP16/MHAWOTranspose\.CompareWithRefImpl.*IS\[0\]=\[\?\.\?\.\?\.\?\].*IS\[1\]=\[\?\.\?\.\?\.\?\].*IS\[2\]=\[\?\.\?\.\?\.\?\].*)"));
        }
        if (!ov::with_cpu_x86_avx512_core_amx_int8()) {
            // TODO: Issue 92895
            // on platforms which do not support AMX, we are disabling I8 input tests
            patterns.emplace_back(std::regex(R"(smoke_LPT/FakeQuantizeWithNotOptimalTransformation.CompareWithRefImpl.*CPU.*i8.*)"));
        }
        // RNN/LSTM/GRU/AUGRU BF16 tests on avx512 core ISA
        if (ov::with_cpu_x86_avx512_core() && !ov::with_cpu_x86_avx512_core_amx_bf16()) {
            patterns.emplace_back(std::regex(R"(smoke.*(AUGRUCellCPUTest|GRUCellCPUTest|RNNCellCPUTest|LSTMCellLayerCPUTest).CompareWithRefs.*INFERENCE_PRECISION_HINT=bf16.*)"));
            patterns.emplace_back(std::regex(R"(nightly.*bf16.*(AUGRUSequenceCPUTest|GRUSequenceCPUTest|LSTMSequenceCPUTest).CompareWithRefs.*INFERENCE_PRECISION_HINT=bf16.*)"));
        }
        if (ov::with_cpu_x86_avx512_core_amx()) {
            // Issue: 131475
            patterns.emplace_back(std::regex(R"(smoke_ExportImportTest/ExportOptimalNumStreams.OptimalNumStreams/.*)"));
            // by calc abs_threshold with expected value
            patterns.emplace_back(std::regex(R"(.*smoke_GatherCompressedWeights_basic/GatherWeightsDecompression.CompareWithRefs.*INFERENCE_PRECISION_HINT.*bf16.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Interaction/IntertactionCPUTest.CompareWithRefs.*Prc=i32.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_MatMulCompressedWeights_(amx|sym_amx|corner_cases_amx)/MatmulWeightsDecompression.CompareWithRefs.*INFERENCE_PRECISION_HINT.*bf16.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_EnforcePrecision_bf16/EnforcePrecisionTest.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHABF16_4D/MHA.CompareWithRefImpl/.*\[1.58.16.34\]_IS\[1\]=\[1.58.16.34\]_IS\[2\]=\[1.1.1.58\]_IS\[3\]=\[1.58.16.34\].*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHAWOTransposeBF16/MHAWOTranspose.CompareWithRefImpl/.*IS\[0\]=\[2.\?.64\].*IS\[1\]=\[2.64.\?\].*IS\[2\]=\[2.\?.64\].*)"));
            // Issue: 141705
            patterns.emplace_back(std::regex(R"(.*smoke_Deconv_(2|3)D_NSPC_INT8_AMX/DeconvolutionLayerCPUTest.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Deconv_(2|3)D_NSPC_INT8_AMX/DeconvolutionLayerCPUTest.*)"));
        }

        // Xattention only verified on AMX platform
        if (!ov::with_cpu_x86_avx512_core_amx()) {
            patterns.emplace_back(std::regex(R"(.*EnableXattn=1.*)"));
        }

        if (ov::with_cpu_x86_avx512_core_fp16() || CPUTestUtils::with_cpu_x86_avx2_vnni_2()) {
            // Issue: 143852
            patterns.emplace_back(std::regex(R"(smoke_ConvertRangeSubgraphCPUTest/ConvertRangeSubgraphCPUTest\.CompareWithRefs.*Prc=f16.*)"));
            patterns.emplace_back(std::regex(R"((smoke|nightly)_FC_3D_FP16/.*_Fused=Multiply\(PerChannel\).*)"));
            patterns.emplace_back(std::regex(R"((smoke|nightly)_MM_Brgemm_Static_FP16.*TS=\(\(55\.12\)\).*_Fused=Multiply\(PerChannel\).*)"));
            patterns.emplace_back(std::regex(R"(smoke_MM_Dynamic_Fusing_FP16/.*TS=\(\(16\.12\)_\(33\.7\)_\(16\.12\)\).*_Fused=Multiply\(PerChannel\).*)"));
            patterns.emplace_back(std::regex(R"(smoke_MM_Brgemm_Dynamic_Fusing_FP16/.*TS=\(\(16\.12\)_\(33\.7\)_\(16\.12\)\).*_Fused=Multiply\(PerChannel\).*)"));
            patterns.emplace_back(std::regex(R"(smoke_Conv_.*_FP16/.*_Fused=PRelu1D\.Multiply\(PerChannel\)\.Add\(PerChannel\).*)"));
            patterns.emplace_back(std::regex(R"(smoke_Conv_Sum_Broadcast_FP16/ConvSumInPlaceTest.*Relu\.Multiply\(PerChannel\)\.Add\(PerChannel\).*)"));
        }

        if (CPUTestUtils::with_cpu_x86_avx2_vnni_2()) {
            // jit_gemm_BF16 kernels are not supported for conv,inner_product,matmul on avx2_vnni_2 platforms
            patterns.emplace_back(std::regex(R"(smoke_Conv_.*D_GEMM_BF16.*)"));
            patterns.emplace_back(
                std::regex(R"(smoke_GroupConv_.*D_Gemm_BF16/GroupConvolutionLayerCPUTest.CompareWithRefs.*primitive=jit_gemm.*)"));
            patterns.emplace_back(std::regex(R"(smoke_.*MatMulLayerCPUTest.*INFERENCE_PRECISION_HINT=bf16.*_primitive=jit_gemm.*)"));
            // by calc abs_threshold with expected value
            patterns.emplace_back(std::regex(R"(smoke_Snippets_MHAWOTransposeBF16/MHAWOTranspose.CompareWithRefImpl/.*IS\[0\]=\[\]_\(\[12.128.100\]\).*)"));
            patterns.emplace_back(std::regex(R"(smoke_Snippets_MHAWOTransposeBF16/MHAWOTranspose.CompareWithRefImpl/.*IS\[0\]=\[2.\?.64\].*)"));
            patterns.emplace_back(std::regex(R"(smoke_Snippets_MHAWOTransposeBF16/MHAWOTranspose.CompareWithRefImpl/.*IS\[0\]=\[\?.\?.\?.\?\].*)"));
        }

#if defined(OPENVINO_ARCH_RISCV64)
        if (!ov::intel_cpu::riscv64::mayiuse(ov::intel_cpu::riscv64::gv)) {
            // Integer division is supported only by JIT Executor which is available on platforms with GV instruction sets.
            // In other cases there might be accuracy problems.
            patterns.emplace_back(std::regex(R"(.*smoke_EltwiseChain/EltwiseChainTest.CompareWithRefs.*InPRC3=i32_Op0=Div_Op1.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_CompareWithRefs_static.*eltwise_op_type=Div.*model_type=i32.*)"));
        }
#endif
#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
        if (!ov::with_cpu_x86_avx2()) {
            // MatMul in Snippets uses BRGEMM that is supported only on AVX2 (and newer) platforms
            // Disabled Snippets MHA tests as well because MHA pattern contains MatMul
            patterns.emplace_back(std::regex(R"(.*Snippets.*MHA.*)"));
            patterns.emplace_back(std::regex(R"(.*Snippets.*(MatMul|Matmul).*)"));
        }
        if (!ov::intel_cpu::hasHardwareSupport(ov::element::f16)) {
            // Skip fp16 tests for paltforms that don't support fp16 precision
            patterns.emplace_back(std::regex(R"(.*INFERENCE_PRECISION_HINT=(F|f)16.*)"));
            patterns.emplace_back(std::regex(R"(.*ConcatMultiQuerySDPTest.*f16.*)"));
            patterns.emplace_back(std::regex(R"(.*ConcatSDPTest.*f16.*)"));
            patterns.emplace_back(std::regex(R"(.*ConvertCPULayerTest.*f16.*)"));
        }
#elif defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_ARM)
        if (!ov::intel_cpu::hasIntDotProductSupport()) {
            patterns.emplace_back(std::regex(R"(.*smoke_MatMulCompressedWeights_Kleidiai.*)"));
        }
        if (!ov::intel_cpu::hasHardwareSupport(ov::element::f16)) {
            // Skip fp16 tests for paltforms that don't support fp16 precision
            patterns.emplace_back(std::regex(R"(.*INFERENCE_PRECISION_HINT=(F|f)16.*)"));
            patterns.emplace_back(std::regex(R"(.*Prc=f16.*)"));
            patterns.emplace_back(std::regex(R"(.*ConcatMultiQuerySDPTest.*f16.*HasShapeOf=1.*)"));
            patterns.emplace_back(std::regex(R"(.*ConvertCPULayerTest.*f16.*)"));
        }
#endif
#ifdef SNIPPETS_LIBXSMM_TPP
        if (!ov::with_cpu_x86_avx512_core_amx()) {
            // Issue: 165178
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_Softmax/Softmax\.CompareWithRefImpl/IS=\[\]_TS=\(\(.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_MHA.*IS\[0\]=\[\]_\(.*)"));
            patterns.emplace_back(std::regex(R"(.*smoke_Snippets_TransposeSoftmax/TransposeSoftmax\.CompareWithRefImpl/IS\[0\]=\[\]_TS\[0\]=\(\(.*)"));
        }
#endif

        return patterns;
    };

    const static std::vector<std::regex> patterns = get_patterns();

    return patterns;
}
