Update Transformations tests to check tensor and node names (#8100)

* Check tensor names in pass tests

* Update Transformations tests to check tensor and node names

* Check input node names; default TENSOR_NAMES comparison; fix transformations to keep node names

inference-engine/src/gna_plugin/transformations/decompose_2d_convolution.cpp

@@ -320,7 +320,7 @@ static std::shared_ptr<ngraph::Node> Create1DConv(const GraphData& graph_data, c
 
         // Activation function & fake quantize
         if (graph_data.af && graph_data.conv_count == 1) {
-            last_conv_block_op = graph_data.af->copy_with_new_inputs({last_conv_block_op});
+            last_conv_block_op = graph_data.af->clone_with_new_inputs({last_conv_block_op});
             copy_runtime_info(conv, last_conv_block_op);
             last_conv_block_op = InsertFQLayer(graph_data.fq_af, last_conv_block_op);
         }
@@ -453,7 +453,7 @@ static void Decompose(const GraphData& graph_data, ConvData& conv_data) {
 
     // Activation function after trailing Transpose NCHW->NHWC
     if (graph_data.af && graph_data.conv_count > 1) {
-        auto af_result = graph_data.af->copy_with_new_inputs({conv_result});
+        auto af_result = graph_data.af->clone_with_new_inputs({conv_result});
         copy_runtime_info(graph_data.conv, af_result);
         conv_result = af_result;
     }

inference-engine/src/legacy_api/src/transformations/convert_opset1_to_legacy/convert_matmul_to_fc_or_gemm.cpp

@@ -231,7 +231,7 @@ ngraph::pass::ConvertMatMulToGemm::ConvertMatMulToGemm() {
             new_ops.push_back(fc_input_b.get_node_shared_ptr());
         }
 
-        auto gemm = matmul->copy_with_new_inputs({ fc_input_a, fc_input_b });
+        auto gemm = matmul->clone_with_new_inputs({ fc_input_a, fc_input_b });
         new_ops.push_back(gemm);
 
         if (gemm->get_shape() != output_shape) {

inference-engine/src/legacy_api/src/transformations/convert_opset1_to_legacy/fc_bias_fusion.cpp

@@ -23,11 +23,11 @@ ngraph::pass::FullyConnectedBiasFusion::FullyConnectedBiasFusion() {
     auto m_add = ngraph::pattern::wrap_type<opset1::Add>({m_fc, m_bias});
 
     ngraph::matcher_pass_callback callback = [=](pattern::Matcher &m) {
-        auto & pattern_to_output = m.get_pattern_value_map();
+        const auto & pattern_to_output = m.get_pattern_value_map();
 
-        auto add = pattern_to_output[m_add].get_node_shared_ptr();
-        auto bias = pattern_to_output[m_bias].get_node_shared_ptr();
-        auto fc = std::dynamic_pointer_cast<op::FullyConnected>(pattern_to_output[m_fc].get_node_shared_ptr());
+        auto add = pattern_to_output.at(m_add).get_node_shared_ptr();
+        auto bias = pattern_to_output.at(m_bias).get_node_shared_ptr();
+        auto fc = std::dynamic_pointer_cast<op::FullyConnected>(pattern_to_output.at(m_fc).get_node_shared_ptr());
         if (!fc) {
             return false;
         }

inference-engine/src/low_precision_transformations/src/convolution.cpp

@@ -229,7 +229,7 @@ bool ConvolutionTransformation::transform(TransformationContext &context, ngraph
             }
 
             if (reshapeFromWeights != nullptr) {
-                reshapeFromWeights = ov::as_type_ptr<opset1::Reshape>(reshapeFromWeights->copy_with_new_inputs({
+                reshapeFromWeights = ov::as_type_ptr<opset1::Reshape>(reshapeFromWeights->clone_with_new_inputs({
                     multiplyFromWeights->input_value(0),
                     reshapeFromWeights->input_value(1) }));
             }
@@ -290,7 +290,7 @@ bool ConvolutionTransformation::transform(TransformationContext &context, ngraph
                 convolution->input_value(0),
                 childNode.get() == convolution.get() ?
                     convolution->get_input_node_ptr(1)->input_value(0) :
-                    childNode->copy_with_new_inputs({convertFromWeights->input_value(0), childNode->input_value(1)})});
+                    childNode->clone_with_new_inputs({convertFromWeights->input_value(0), childNode->input_value(1)})});
             replace_node(convolution, newConvolution);
             NetworkHelper::copyInfo(convolution, newConvolution);
             convolution = newConvolution;

inference-engine/src/low_precision_transformations/src/convolution_backprop_data.cpp

@@ -109,7 +109,7 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con
             dequantization.multiplyConstant->cast_vector<float>()[0]);
         auto inputs = convolutionBackpropData->input_values();
         inputs[0] = dequantization.multiply->input_value(0);
-        const auto copyNode = convolutionBackpropData->copy_with_new_inputs(inputs);
+        const auto copyNode = convolutionBackpropData->clone_with_new_inputs(inputs);
 
         const auto relaxedConvolutionBackpropData = std::make_shared<op::TypeRelaxed<opset1::ConvolutionBackpropData>>(
             *ov::as_type_ptr<opset1::ConvolutionBackpropData>(copyNode),
@@ -126,7 +126,7 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con
         convolutionBackpropData = newMultiplyAfter->get_input_node_shared_ptr(0);
         inputs[0] = convolutionBackpropData->get_input_node_ptr(0)->input_value(0);
         if (ov::is_type<opset1::Convert>(convolutionBackpropData->get_input_node_ptr(0))) {
-            auto newConvolution = convolutionBackpropData->copy_with_new_inputs(inputs);
+            auto newConvolution = convolutionBackpropData->clone_with_new_inputs(inputs);
             replace_node(convolutionBackpropData, newConvolution);
             convolutionBackpropData = newConvolution;
         }
@@ -155,7 +155,7 @@ bool ConvolutionBackpropDataTransformation::transform(TransformationContext &con
             auto inputs = convolutionBackpropData->input_values();
             inputs[1] = multiplyFromWeights->input_value(0);
             auto newMultiplyAfter = std::make_shared<opset1::Multiply>(
-                convolutionBackpropData->copy_with_new_inputs(inputs),
+                convolutionBackpropData->clone_with_new_inputs(inputs),
                 foldConvert(
                     fold_reshape<opset1::Reshape>(
                         multiplyFromWeights->input_value(1),

inference-engine/src/low_precision_transformations/src/multiply_to_group_convolution.cpp

@@ -134,7 +134,7 @@ bool MultiplyToGroupConvolutionTransformation::transform(TransformationContext&
         lastNode->set_friendly_name(convolution->get_friendly_name() + "/Add");
     }
 
-    lastNode = multiply->copy_with_new_inputs({ lastNode, constant });
+    lastNode = multiply->clone_with_new_inputs({ lastNode, constant });
 
     replace_node(multiply, lastNode);
     NetworkHelper::copyInfo(multiply, lastNode);

inference-engine/src/low_precision_transformations/src/mvn.cpp

@@ -147,9 +147,9 @@ bool MVNTransformation::transform(TransformationContext &context, ngraph::patter
 
     std::shared_ptr<Node> newMVN;
     if (ov::is_type<op::MVN>(mvn)) {
-        newMVN = mvn->copy_with_new_inputs({dequantization.data});
+        newMVN = mvn->clone_with_new_inputs({dequantization.data});
     } else {
-        newMVN = mvn->copy_with_new_inputs({dequantization.data, mvn->input_value(1)});
+        newMVN = mvn->clone_with_new_inputs({dequantization.data, mvn->input_value(1)});
     }
     NetworkHelper::setOutDataPrecisionForTypeRelaxed(newMVN, deqPrecision);
     NetworkHelper::copyInfo(mvn, newMVN);

inference-engine/src/low_precision_transformations/src/subtract.cpp

@@ -54,14 +54,14 @@ bool SubtractTransformation::transform(TransformationContext& context, ngraph::p
         // before: Y = X * SC - SH, after:  Y = (X - SH') * SC
         //    X * SC - SH = X * SC - SH' * SC
         //    SH' = SH / SC
-        std::shared_ptr<opset1::Subtract> newSubtract = ov::as_type_ptr<opset1::Subtract>(subtract->copy_with_new_inputs({
+        std::shared_ptr<opset1::Subtract> newSubtract = ov::as_type_ptr<opset1::Subtract>(subtract->clone_with_new_inputs({
             dequantization.multiply->input_value(0),
             ngraph::pass::low_precision::fold<ngraph::opset1::Divide>(
                 subtract->input_value(1),
                 dequantization.multiply->input_value(1))
         }));
 
-        std::shared_ptr<Node> newMultiply = dequantization.multiply->copy_with_new_inputs({
+        std::shared_ptr<Node> newMultiply = dequantization.multiply->clone_with_new_inputs({
             newSubtract,
             dequantization.multiplyConstant
         });
@@ -71,7 +71,7 @@ bool SubtractTransformation::transform(TransformationContext& context, ngraph::p
     }
 
     if (dequantization.subtract != nullptr) {
-        std::shared_ptr<opset1::Subtract> newSubtract = ov::as_type_ptr<opset1::Subtract>(subtract->copy_with_new_inputs({
+        std::shared_ptr<opset1::Subtract> newSubtract = ov::as_type_ptr<opset1::Subtract>(subtract->clone_with_new_inputs({
             dequantization.subtract->input_value(0),
             fold<ngraph::opset1::Add>(subtract->input_value(1), dequantization.subtractConstant)
         }));

inference-engine/src/snippets/src/op/subgraph.cpp

@@ -88,7 +88,7 @@ auto snippets::op::Subgraph::wrap_node_as_subgraph(const std::shared_ptr<ngraph:
         }
     }
 
-    auto body_node = node->copy_with_new_inputs(body_inputs);
+    auto body_node = node->clone_with_new_inputs(body_inputs);
     body_node->set_friendly_name(node->get_friendly_name());
 
     if (node->get_output_size() != body_node->get_output_size()) {

inference-engine/src/transformations/src/transformations/common_optimizations/binarize_weights.cpp

@@ -165,7 +165,6 @@ pass::BinarizeWeights::BinarizeWeights() {
         auto quantized_weights_const = op::Constant::create(element::f32, weights_const->get_shape(), quantized_weights);
         quantized_weights_const->set_friendly_name(weights_const->get_friendly_name());
         auto new_conv = conv->clone_with_new_inputs({new_activations_fq, quantized_weights_const});
-        new_conv->set_friendly_name(conv->get_friendly_name());
 
         std::vector<int64_t> norm_factor_shape = {-1};
         for (size_t i = 2; i < weights_const->get_shape().size(); i++)
@@ -179,6 +178,7 @@ pass::BinarizeWeights::BinarizeWeights() {
 
         copy_runtime_info({activations_fq, weights_fq, conv},
                           {new_activations_fq, new_conv, activations_norm_factor_reshaped, mul, weights_norm_factor_reshaped, mul2});
+        mul2->set_friendly_name(conv->get_friendly_name());
         replace_node(conv, mul2);
         return true;
     };

inference-engine/src/transformations/src/transformations/common_optimizations/conv_mul_fusion.cpp

@@ -69,7 +69,7 @@ ngraph::pass::ConvolutionMultiplyFusion::ConvolutionMultiplyFusion() {
         auto weights_multiply = std::make_shared<opset4::Multiply>(m_weights, final_const);
 
         // Replace Convolution->Multiply with Convolution with new inputs
-        auto new_conv = m_conv->copy_with_new_inputs({m_input, weights_multiply});
+        auto new_conv = m_conv->clone_with_new_inputs({m_input, weights_multiply});
         new_conv->set_friendly_name(m_mul->get_friendly_name());
         copy_runtime_info({m_conv, m_mul}, {new_conv, final_const.get_node_shared_ptr(), weights_multiply});
         replace_node(m_mul, new_conv);
@@ -220,7 +220,7 @@ ngraph::pass::ConvolutionBackpropDataMultiplyFusion::ConvolutionBackpropDataMult
         auto weights_multiply = std::make_shared<opset4::Multiply>(m_weights, final_const);
 
         // Replace Convolution->Multiply with Convolution with new inputs
-        auto new_conv = m_conv->copy_with_new_inputs({m_input, weights_multiply});
+        auto new_conv = m_conv->clone_with_new_inputs({m_input, weights_multiply});
         new_conv->set_friendly_name(m_mul->get_friendly_name());
         copy_runtime_info({m_conv, m_mul}, {new_conv, final_const.get_node_shared_ptr(), weights_multiply});
         replace_node(m_mul, new_conv);
@@ -286,7 +286,7 @@ ngraph::pass::GroupConvolutionBackpropDataMultiplyFusion::GroupConvolutionBackpr
         auto weights_multiply = std::make_shared<opset4::Multiply>(m_weights, final_const);
 
         // Replace Convolution->Multiply with Convolution with new inputs
-        auto new_conv = m_conv->copy_with_new_inputs({m_input, weights_multiply});
+        auto new_conv = m_conv->clone_with_new_inputs({m_input, weights_multiply});
         new_conv->set_friendly_name(m_mul->get_friendly_name());
         copy_runtime_info({m_conv, m_mul}, {new_conv, final_const.get_node_shared_ptr(), weights_multiply});
         replace_node(m_mul, new_conv);

inference-engine/src/transformations/src/transformations/common_optimizations/fq_mul_fusion.cpp

@@ -140,7 +140,7 @@ ngraph::pass::FakeQuantizeMulFusion::FakeQuantizeMulFusion() {
 
         replace_node(mul_node, new_fq_node);
 
-        new_fq_node->set_friendly_name(fq_node->get_friendly_name());
+        new_fq_node->set_friendly_name(mul_node->get_friendly_name());
         copy_runtime_info({fq_node, mul_node}, new_fq_node);
 
         return true;

inference-engine/src/transformations/src/transformations/common_optimizations/fq_reshape_fusion.cpp

@@ -59,7 +59,7 @@ ngraph::pass::FakeQuantizeReshapeFusion::FakeQuantizeReshapeFusion() {
                     if (new_limit_shape == limit_input.get_shape())
                         renewed_inputs.push_back(limit_input);
                     else
-                        renewed_inputs.push_back(reshape_node->copy_with_new_inputs(
+                        renewed_inputs.push_back(reshape_node->clone_with_new_inputs(
                                 {limit_input, opset4::Constant::create(element::i64, {new_limit_shape.size()}, new_limit_shape)}));
                     continue;
                 }
@@ -71,7 +71,7 @@ ngraph::pass::FakeQuantizeReshapeFusion::FakeQuantizeReshapeFusion() {
             copy_runtime_info({reshape_node, fq_node}, new_input.get_node_shared_ptr());
         const auto new_fq_node = fq_node->clone_with_new_inputs(renewed_inputs);
         replace_node(reshape_node, new_fq_node);
-        new_fq_node->set_friendly_name(fq_node->get_friendly_name());
+        new_fq_node->set_friendly_name(reshape_node->get_friendly_name());
         copy_runtime_info({fq_node, reshape_node}, new_fq_node);
         return true;
     };

inference-engine/src/transformations/src/transformations/common_optimizations/pull_transpose_through_fq.cpp

@@ -59,14 +59,14 @@ ngraph::pass::PullTransposeThroughFQUp::PullTransposeThroughFQUp() {
                                                                        opset1::Constant::create(element::i64, Shape{unsqueeze_axes.size()}, unsqueeze_axes));
                 new_ops.push_back(fq_input.get_node_shared_ptr());
             }
-            fq_input = transpose->copy_with_new_inputs({fq_input, transpose->input_value(1)});
+            fq_input = transpose->clone_with_new_inputs({fq_input, transpose->input_value(1)});
             ngraph::copy_runtime_info(transpose, fq_input.get_node_shared_ptr());
             fq_inputs.push_back(fq_input);
         }
 
-        auto new_fq = fq->copy_with_new_inputs(fq_inputs);
+        auto new_fq = fq->clone_with_new_inputs(fq_inputs);
         new_ops.push_back(new_fq);
-        new_fq->set_friendly_name(fq->get_friendly_name());
+        new_fq->set_friendly_name(transpose->get_friendly_name());
         ngraph::copy_runtime_info({fq, transpose}, new_ops);
         ngraph::replace_node(transpose, new_fq);
 

inference-engine/src/transformations/src/transformations/common_optimizations/random_uniform_fusion.cpp

@@ -67,7 +67,6 @@ ngraph::pass::RandomUniformFusion::RandomUniformFusion() {
         const auto new_ru = ru->clone_with_new_inputs({data,
                                                        folded_const1 ? folded_const1 : new_mul_add1,
                                                        folded_const2 ? folded_const2 : new_mul_add2});
-        new_ru->set_friendly_name(m.get_match_root()->get_friendly_name());
 
         if (pattern_map.count(convert_pattern)) {
             const auto& convert = pattern_map.at(convert_pattern);
@@ -78,9 +77,11 @@ ngraph::pass::RandomUniformFusion::RandomUniformFusion() {
                 return false;
             const auto new_ru_conv = cvt->clone_with_new_inputs({new_ru});
             copy_runtime_info({ru, cvt, mul_add.get_node_shared_ptr()}, {new_mul_add1, new_mul_add2, new_ru, new_ru_conv});
+            new_ru_conv->set_friendly_name(m.get_match_root()->get_friendly_name());
             ngraph::replace_node(m.get_match_root(), new_ru_conv);
         } else {
             copy_runtime_info({ru, mul_add.get_node_shared_ptr()}, {new_mul_add1, new_mul_add2, new_ru});
+            new_ru->set_friendly_name(m.get_match_root()->get_friendly_name());
             ngraph::replace_node(m.get_match_root(), new_ru);
         }
 

inference-engine/src/transformations/src/transformations/common_optimizations/transpose_sinking.cpp

@@ -93,7 +93,7 @@ ngraph::pass::TransposeReduction::TransposeReduction() {
         auto new_axes = ngraph::op::util::make_try_fold<ngraph::opset6::Gather>(
                 transpose_order, reduction_axes, ngraph::opset6::Constant::create(ngraph::element::i64, {}, {0}));
         new_ops.push_back(new_axes);
-        auto new_reduce = reduction->copy_with_new_inputs({transpose->input_value(0), new_axes});
+        auto new_reduce = reduction->clone_with_new_inputs({transpose->input_value(0), new_axes});
         new_ops.push_back(new_reduce);
 
         auto updated_order = transpose_order;
@@ -158,7 +158,7 @@ ngraph::pass::TransposeFQReduction::TransposeFQReduction() {
             new_ops.push_back(transposed_input);
             fq_inputs.push_back(transposed_input);
         }
-        auto new_fq = fq->copy_with_new_inputs(fq_inputs);
+        auto new_fq = fq->clone_with_new_inputs(fq_inputs);
         new_ops.push_back(new_fq);
 
         auto new_transpose = std::make_shared<ngraph::opset6::Transpose>(new_fq, transpose_order);

inference-engine/src/transformations/src/transformations/common_optimizations/weights_dequantize_to_fake_quantize.cpp

@@ -62,6 +62,7 @@ ngraph::pass::WeightsDequantizeToFakeQuantize::WeightsDequantizeToFakeQuantize()
 
         ngraph::copy_runtime_info(nodes_to_copy_RT_info_from, fq);
         multiply_node->output(0).replace(fq->output(0));
+        fq->set_friendly_name(multiply_node->get_friendly_name());
 
         if (ov::constant_folding_is_disabled(convert_node))
             ov::enable_constant_folding(convert_node);

inference-engine/src/vpu/common/src/ngraph/transformations/dynamic_to_static_shape_binary_elementwise.cpp

@@ -22,7 +22,7 @@ void processBinaryEltwise(std::shared_ptr<ngraph::Node> eltwise, size_t lhsIndex
     const auto lhsRank = eltwise->input_value(lhsIndex).get_partial_shape().rank();
     const auto rhsRank = eltwise->input_value(rhsIndex).get_partial_shape().rank();
 
-    const auto copied = eltwise->copy_with_new_inputs(eltwise->input_values());
+    const auto copied = eltwise->clone_with_new_inputs(eltwise->input_values());
 
     const auto lhsDSR = ngraph::as_type_ptr<ngraph::vpu::op::DynamicShapeResolver>(eltwise->input_value(lhsIndex).get_node_shared_ptr());
     const auto rhsDSR = ngraph::as_type_ptr<ngraph::vpu::op::DynamicShapeResolver>(eltwise->input_value(rhsIndex).get_node_shared_ptr());

inference-engine/src/vpu/common/src/ngraph/transformations/extract_dynamic_batch/extract_dynamic_batch.cpp

@@ -251,7 +251,7 @@ std::shared_ptr<ngraph::opset5::Loop> makeLoop(ngraph::Node* root, ngraph::Node*
         const auto& currentInputs = source->input_values();
         std::transform(currentInputs.cbegin(), currentInputs.cend(), std::back_inserter(newInputs), getInput);
 
-        auto cloned = source->copy_with_new_inputs(newInputs);
+        auto cloned = source->clone_with_new_inputs(newInputs);
         cloned->set_friendly_name(source->get_friendly_name());
         VPU_THROW_UNLESS(cloned->get_output_size() == source->get_output_size(),
                          "Encountered mismatch in output count between original node {} and copy without batch {}", source, cloned);

inference-engine/src/vpu/common/src/ngraph/transformations/merge_subsequent_dsr_operations.cpp

@@ -21,7 +21,7 @@ MergeSubsequentDSROperations::MergeSubsequentDSROperations() {
             return false;
         }
         // this will create a new DSR with correct inputs
-        auto newDsr = dsr->copy_with_new_inputs({predecessor->input_value(0), dsr->input_value(1)});
+        auto newDsr = dsr->clone_with_new_inputs({predecessor->input_value(0), dsr->input_value(1)});
         newDsr->set_friendly_name(dsr->get_friendly_name());
         // replace DSR2 with new so DSR2 will lose all consumers so it will die after pass execution
         ngraph::replace_node(dsr, newDsr);

inference-engine/tests/functional/inference_engine/transformations/add_fake_quantize_fusion.cpp

@@ -23,9 +23,7 @@ using namespace testing;
 using namespace ngraph;
 
 
-TEST(TransformationTests, AddFakeQuantizeFusion) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, AddFakeQuantizeFusion) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -38,12 +36,8 @@ TEST(TransformationTests, AddFakeQuantizeFusion) {
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -54,16 +48,11 @@ TEST(TransformationTests, AddFakeQuantizeFusion) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, AddFakeQuantizeFusionWithConvolutionAndScalarConstant) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, AddFakeQuantizeFusionWithConvolutionAndScalarConstant) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -79,12 +68,8 @@ TEST(TransformationTests, AddFakeQuantizeFusionWithConvolutionAndScalarConstant)
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -98,16 +83,11 @@ TEST(TransformationTests, AddFakeQuantizeFusionWithConvolutionAndScalarConstant)
         auto fq = std::make_shared<opset5::FakeQuantize>(conv, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, AddFakeQuantizeFusionConstantOnFirstInput) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, AddFakeQuantizeFusionConstantOnFirstInput) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -120,12 +100,8 @@ TEST(TransformationTests, AddFakeQuantizeFusionConstantOnFirstInput) {
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -136,16 +112,11 @@ TEST(TransformationTests, AddFakeQuantizeFusionConstantOnFirstInput) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, AddFakeQuantizeFusionConstantWithEqualValues) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, AddFakeQuantizeFusionConstantWithEqualValues) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -158,12 +129,8 @@ TEST(TransformationTests, AddFakeQuantizeFusionConstantWithEqualValues) {
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -174,16 +141,11 @@ TEST(TransformationTests, AddFakeQuantizeFusionConstantWithEqualValues) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, AddFakeQuantizeFusionReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, AddFakeQuantizeFusionReshape) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -196,12 +158,8 @@ TEST(TransformationTests, AddFakeQuantizeFusionReshape) {
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -212,16 +170,11 @@ TEST(TransformationTests, AddFakeQuantizeFusionReshape) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeAddFakeQuantizeFusionNotAConstant) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeAddFakeQuantizeFusionNotAConstant) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -234,12 +187,8 @@ TEST(TransformationTests, NegativeAddFakeQuantizeFusionNotAConstant) {
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, add_2nd_input});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, add_2nd_input});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -252,16 +201,11 @@ TEST(TransformationTests, NegativeAddFakeQuantizeFusionNotAConstant) {
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, add_2nd_input});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, add_2nd_input});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeAddFakeQuantizeFusionWithConvolutionAndNonScalarConstant) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeAddFakeQuantizeFusionWithConvolutionAndNonScalarConstant) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -277,12 +221,8 @@ TEST(TransformationTests, NegativeAddFakeQuantizeFusionWithConvolutionAndNonScal
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::AddFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
+        manager.register_pass<pass::AddFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -298,16 +238,11 @@ TEST(TransformationTests, NegativeAddFakeQuantizeFusionWithConvolutionAndNonScal
         auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, filter});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeAddFakeQuantizeFusionLowPrecision) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeAddFakeQuantizeFusionLowPrecision) {
     Shape data_shape{1, 3, 14, 14};
     auto data = std::make_shared<opset5::Parameter>(element::f16, data_shape);
     auto add_const = opset5::Constant::create(element::f16, Shape{1}, {2});
@@ -319,14 +254,7 @@ TEST(TransformationTests, NegativeAddFakeQuantizeFusionLowPrecision) {
     auto fq = std::make_shared<opset5::FakeQuantize>(add, input_low,
                                                      input_high, output_low,
                                                      output_high, 11);
-    f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-    f_ref = clone_function(*f);
-    pass::Manager m;
-    m.register_pass<pass::InitNodeInfo>();
-    m.register_pass<pass::AddFakeQuantizeFusion>();
-    m.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+    function_ref = clone_function(*function);
+    manager.register_pass<pass::AddFakeQuantizeFusion>();
 }

inference-engine/tests/functional/inference_engine/transformations/batch_norm_decompositoin.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, BatchNormDecompositionDynamic) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, BatchNormDecompositionDynamic) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic());
         auto gamma = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3}, {3});
@@ -29,12 +28,8 @@ TEST(TransformationTests, BatchNormDecompositionDynamic) {
         auto broadcast = std::make_shared<ngraph::opset1::BatchNormInference>(input, gamma, beta, mean, var, 0.001);
         broadcast->set_friendly_name("broadcast");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{broadcast}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{broadcast}, ngraph::ParameterVector{input});
+        function_ref = ngraph::clone_function(*function);
         manager.register_pass<ngraph::pass::BatchNormDecomposition>();
-        ASSERT_NO_THROW(manager.run_passes(f));
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 }

inference-engine/tests/functional/inference_engine/transformations/batch_to_space_decomposition_test.cpp

@@ -23,9 +23,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, BatchToSpaceDecompositionByElements) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, BatchToSpaceDecompositionByElements) {
     {
         auto data = std::make_shared<opset3::Parameter>(element::f32, Shape{100, 7, 13, 3});
         auto block_shape = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{1, 10, 5, 1});
@@ -33,14 +31,9 @@ TEST(TransformationTests, BatchToSpaceDecompositionByElements) {
         auto crops_end = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 3, 0, 0});
         auto batch_to_space = std::make_shared<ngraph::opset3::BatchToSpace>(data, block_shape, crops_begin, crops_end);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
+        function =  std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertBatchToSpace>();
-        m.run_passes(f);
-
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertBatchToSpace>();
     }
 
     {
@@ -76,15 +69,11 @@ TEST(TransformationTests, BatchToSpaceDecompositionByElements) {
         std::vector<int64_t> end_mask(4, 0);
         auto ss = std::make_shared<opset3::StridedSlice>(reshape_after_3, begin, end, begin_mask, end_mask);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        function_ref =  std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SpaceToBatchDecompositionByElements) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, SpaceToBatchDecompositionByElements) {
     {
         auto data = std::make_shared<opset3::Parameter>(element::f32, Shape{2, 64, 64, 3});
         auto block_shape = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{1, 10, 5, 1});
@@ -92,14 +81,9 @@ TEST(TransformationTests, SpaceToBatchDecompositionByElements) {
         auto pads_end = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 3, 0, 0});
         auto batch_to_space = std::make_shared<ngraph::opset3::SpaceToBatch>(data, block_shape, pads_begin, pads_end);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
+        function =  std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertSpaceToBatch>();
-        m.run_passes(f);
-
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertSpaceToBatch>();
     }
 
     {
@@ -140,15 +124,11 @@ TEST(TransformationTests, SpaceToBatchDecompositionByElements) {
         auto permute_4 = std::make_shared<ngraph::opset3::Transpose> (reshape_before_4, axis_order_4);
         auto reshape_after_4 = std::make_shared<ngraph::opset3::Reshape> (permute_4, squeezed_order_4, false);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after_4}, ngraph::ParameterVector{data});
+        function_ref =  std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after_4}, ngraph::ParameterVector{data});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SpaceToBatchDecomposition) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, SpaceToBatchDecomposition) {
     {
         auto data = std::make_shared<opset3::Parameter>(element::f32, Shape{2, 64, 64, 3});
         auto block_shape = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{1, 10, 5, 1});
@@ -156,14 +136,9 @@ TEST(TransformationTests, SpaceToBatchDecomposition) {
         auto pads_end = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 3, 0, 0});
         auto batch_to_space = std::make_shared<ngraph::opset3::SpaceToBatch>(data, block_shape, pads_begin, pads_end);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
+        function =  std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertSpaceToBatch>(false);
-        m.run_passes(f);
-
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertSpaceToBatch>(false);
     }
 
     {
@@ -182,15 +157,11 @@ TEST(TransformationTests, SpaceToBatchDecomposition) {
         auto permute = std::make_shared<ngraph::opset3::Transpose>(reshape_before, axis_order);
         auto reshape_after = std::make_shared<ngraph::opset3::Reshape>(permute, squeezed_order, false);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{data});
+        function_ref =  std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{data});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, BatchToSpaceDecomposition) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, BatchToSpaceDecomposition) {
     {
         auto data = std::make_shared<opset3::Parameter>(element::f32, Shape{100, 7, 13, 3});
         auto block_shape = std::make_shared<opset3::Constant>(element::i64, Shape{4},
@@ -199,14 +170,9 @@ TEST(TransformationTests, BatchToSpaceDecomposition) {
         auto crops_end = std::make_shared<opset3::Constant>(element::i64, Shape{4}, std::vector<int64_t>{0, 3, 0, 0});
         auto batch_to_space = std::make_shared<ngraph::opset3::BatchToSpace>(data, block_shape, crops_begin, crops_end);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
+        function =  std::make_shared<ngraph::Function>(ngraph::NodeVector{batch_to_space}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertBatchToSpace>(false);
-        m.run_passes(f);
-
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertBatchToSpace>(false);
     }
 
     {
@@ -227,8 +193,6 @@ TEST(TransformationTests, BatchToSpaceDecomposition) {
         std::vector<int64_t> begin_mask(4, 0);
         std::vector<int64_t> end_mask(4, 0);
         auto ss = std::make_shared<opset3::StridedSlice>(reshape_after, begin, end, begin_mask, end_mask);
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        function_ref =  std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/batch_to_space_fusion.cpp

@@ -23,8 +23,7 @@ using namespace testing;
 using namespace ngraph;
 
 
-TEST(TransformationTests, BatchToSpaceFusionTranspose) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, BatchToSpaceFusionTranspose) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
@@ -34,13 +33,8 @@ TEST(TransformationTests, BatchToSpaceFusionTranspose) {
                 op::Constant::create(element::i64, Shape{4}, {2, 1, -1, 2}),
                 std::vector<int64_t>{0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BatchToSpaceFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        manager.register_pass<pass::BatchToSpaceFusion>();
     }
 
     {
@@ -49,16 +43,11 @@ TEST(TransformationTests, BatchToSpaceFusionTranspose) {
             op::Constant::create(element::i64, Shape{4}, {1, 1, 2, 2}),
             op::Constant::create(element::i64, Shape{4}, {0, 0, 2, 1}),
             op::Constant::create(element::i64, Shape{4}, {1, 2, 1, 14}));
-
-        f_ref = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, BatchToSpaceFusionReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, BatchToSpaceFusionReshape) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{4, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
@@ -68,13 +57,8 @@ TEST(TransformationTests, BatchToSpaceFusionReshape) {
                 op::Constant::create(element::i64, Shape{4}, {2, 1, 7, -2}),
                 std::vector<int64_t>{0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0});
         auto reshape_after = std::make_shared<opset6::Reshape>(slice, op::Constant::create(element::i64, Shape{4}, {1, 2, 4, 14}), false);
-        f = std::make_shared<Function>(NodeVector{reshape_after}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BatchToSpaceFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{reshape_after}, ParameterVector{data});
+        manager.register_pass<pass::BatchToSpaceFusion>();
     }
 
     {
@@ -83,16 +67,11 @@ TEST(TransformationTests, BatchToSpaceFusionReshape) {
             op::Constant::create(element::i64, Shape{4}, {1, 1, 2, 2}),
             op::Constant::create(element::i64, Shape{4}, {0, 0, 3, 0}),
             op::Constant::create(element::i64, Shape{4}, {1, 0, 1, 2}));
-
-        f_ref = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidTransposePerm) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeBatchToSpaceFusionInvalidTransposePerm) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {2, 0, 1, 3}));
@@ -102,13 +81,8 @@ TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidTransposePerm) {
                 op::Constant::create(element::i64, Shape{4}, {2, 1, -1, 2}),
                 std::vector<int64_t>{0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BatchToSpaceFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        manager.register_pass<pass::BatchToSpaceFusion>();
     }
 
     {
@@ -120,15 +94,11 @@ TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidTransposePerm) {
                 op::Constant::create(element::i64, Shape{4}, {2, 1, -1, 2}),
                 std::vector<int64_t>{0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidMode) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeBatchToSpaceFusionInvalidMode) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
@@ -138,13 +108,8 @@ TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidMode) {
                 op::Constant::create(element::i64, Shape{4}, {2, 1, -1, 2}),
                 std::vector<int64_t>{0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BatchToSpaceFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        manager.register_pass<pass::BatchToSpaceFusion>();
     }
 
     {
@@ -156,15 +121,11 @@ TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidMode) {
                 op::Constant::create(element::i64, Shape{4}, {2, 1, -1, 2}),
                 std::vector<int64_t>{0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidRank) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeBatchToSpaceFusionInvalidRank) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
@@ -174,15 +135,9 @@ TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidRank) {
                 op::Constant::create(element::i64, Shape{5}, {2, 1, -1, 2, 2}),
                 std::vector<int64_t>{0, 0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BatchToSpaceFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        manager.register_pass<pass::BatchToSpaceFusion>();
     }
-
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
@@ -192,16 +147,8 @@ TEST(TransformationTests, NegativeBatchToSpaceFusionInvalidRank) {
                 op::Constant::create(element::i64, Shape{5}, {2, 1, -1, 2, 2}),
                 std::vector<int64_t>{0, 0, 0, 0, 0}, std::vector<int64_t>{0, 0, 0, 0, 0});
         auto trans_after = std::make_shared<opset6::Transpose>(slice, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BatchToSpaceFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        manager.register_pass<pass::BatchToSpaceFusion>();
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 

inference-engine/tests/functional/inference_engine/transformations/binarize_weights.cpp

@@ -23,8 +23,7 @@ using namespace testing;
 using namespace ngraph;
 
 
-TEST(TransformationTests, BinarizeWeightsActivationsOutputLowZero) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, BinarizeWeightsActivationsOutputLowZero) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 3, 2, 2});
         auto act_in_low = opset5::Constant::create(element::f32, Shape{1}, {1.0f});
@@ -40,14 +39,9 @@ TEST(TransformationTests, BinarizeWeightsActivationsOutputLowZero) {
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BinarizeWeights>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        manager.register_pass<pass::BinarizeWeights>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -62,15 +56,11 @@ TEST(TransformationTests, BinarizeWeightsActivationsOutputLowZero) {
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{1, 1, 1}, {0.7f}));
         auto mul2 = std::make_shared<opset5::Multiply>(mul, opset5::Constant::create(element::f32, Shape{1, 1, 1}, {0.2f}));
 
-        f_ref = std::make_shared<Function>(NodeVector{mul2}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{mul2}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, BinarizeWeightsActivationsOutputLowNegative) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, BinarizeWeightsActivationsOutputLowNegative) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 3, 2, 2});
         auto act_in_low = opset5::Constant::create(element::f32, Shape{1}, {1.0f});
@@ -86,14 +76,9 @@ TEST(TransformationTests, BinarizeWeightsActivationsOutputLowNegative) {
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BinarizeWeights>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        manager.register_pass<pass::BinarizeWeights>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -108,15 +93,11 @@ TEST(TransformationTests, BinarizeWeightsActivationsOutputLowNegative) {
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{1, 1, 1}, {0.7f}));
         auto mul2 = std::make_shared<opset5::Multiply>(mul, opset5::Constant::create(element::f32, Shape{1, 1, 1}, {0.2f}));
 
-        f_ref = std::make_shared<Function>(NodeVector{mul2}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{mul2}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeBinarizeWeightsInvalidLevels) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeBinarizeWeightsInvalidLevels) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 3, 2, 2});
         auto act_in_low = opset5::Constant::create(element::f32, Shape{1}, {1.0f});
@@ -132,14 +113,9 @@ TEST(TransformationTests, NegativeBinarizeWeightsInvalidLevels) {
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BinarizeWeights>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        manager.register_pass<pass::BinarizeWeights>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -157,15 +133,11 @@ TEST(TransformationTests, NegativeBinarizeWeightsInvalidLevels) {
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeBinarizeWeightsInvalidActivationsOutputLowHigh) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeBinarizeWeightsInvalidActivationsOutputLowHigh) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 3, 2, 2});
         auto act_in_low = opset5::Constant::create(element::f32, Shape{1}, {1.0f});
@@ -181,14 +153,9 @@ TEST(TransformationTests, NegativeBinarizeWeightsInvalidActivationsOutputLowHigh
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BinarizeWeights>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        manager.register_pass<pass::BinarizeWeights>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -206,15 +173,11 @@ TEST(TransformationTests, NegativeBinarizeWeightsInvalidActivationsOutputLowHigh
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeBinarizeWeightsInvalidOutputLowHigh) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeBinarizeWeightsInvalidOutputLowHigh) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 3, 2, 2});
         auto act_in_low = opset5::Constant::create(element::f32, Shape{1}, {1.0f});
@@ -230,14 +193,9 @@ TEST(TransformationTests, NegativeBinarizeWeightsInvalidOutputLowHigh) {
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
-
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::BinarizeWeights>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        manager.register_pass<pass::BinarizeWeights>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -255,9 +213,6 @@ TEST(TransformationTests, NegativeBinarizeWeightsInvalidOutputLowHigh) {
         auto weights_fq = std::make_shared<opset5::FakeQuantize>(weights, weights_in_low, weights_in_high, weights_out_low, weights_out_high, 2);
         auto conv = std::make_shared<opset5::Convolution>(act_fq, weights_fq, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
 
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/clamp_fusion.cpp

@@ -23,75 +23,54 @@ using namespace testing;
 using namespace ngraph;
 
 
-TEST(TransformationTests, ClampFusion) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ClampFusion) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{2, 2});
         auto min_const = opset5::Constant::create(element::f32, Shape{1}, {0.1});
         auto max_const = opset5::Constant::create(element::f32, Shape{1}, {5});
         auto max = std::make_shared<opset5::Maximum>(data, min_const);
         auto min = std::make_shared<opset5::Minimum>(max, max_const);
-        f = std::make_shared<Function>(NodeVector{min}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{min}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ClampFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ClampFusion>();
     }
 
     {
         auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto clamp = std::make_shared<opset5::Clamp>(data, 0.1, 5);
-        f_ref = std::make_shared<Function>(NodeVector{clamp}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{clamp}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ClampFusionScalars) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ClampFusionScalars) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{2, 2});
         auto min_const = opset5::Constant::create(element::f32, Shape{}, {0.1});
         auto max_const = opset5::Constant::create(element::f32, Shape{}, {5});
         auto max = std::make_shared<opset5::Maximum>(data, min_const);
         auto min = std::make_shared<opset5::Minimum>(max, max_const);
-        f = std::make_shared<Function>(NodeVector{min}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{min}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ClampFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ClampFusion>();
     }
 
     {
         auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto clamp = std::make_shared<opset5::Clamp>(data, 0.1, 5);
-        f_ref = std::make_shared<Function>(NodeVector{clamp}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{clamp}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ClampFusionNonConstMin) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ClampFusionNonConstMin) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{2, 2});
         auto min_val = std::make_shared<opset5::Parameter>(element::f32, Shape{});
         auto max_const = opset5::Constant::create(element::f32, Shape{}, {5});
         auto max = std::make_shared<opset5::Maximum>(data, min_val);
         auto min = std::make_shared<opset5::Minimum>(max, max_const);
-        f = std::make_shared<Function>(NodeVector{min}, ParameterVector{data, min_val});
+        function = std::make_shared<Function>(NodeVector{min}, ParameterVector{data, min_val});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ClampFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ClampFusion>();
     }
 
     {
@@ -100,9 +79,6 @@ TEST(TransformationTests, ClampFusionNonConstMin) {
         auto max_const = opset5::Constant::create(element::f32, Shape{}, {5});
         auto max = std::make_shared<opset5::Maximum>(data, min_val);
         auto min = std::make_shared<opset5::Minimum>(max, max_const);
-        f_ref = std::make_shared<Function>(NodeVector{min}, ParameterVector{data, min_val});
+        function_ref = std::make_shared<Function>(NodeVector{min}, ParameterVector{data, min_val});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/conv_fusion_test.cpp

@@ -113,13 +113,19 @@ private:
 };
 
 TEST_P(ConvFusionTests, CompareFunctions) {
-    ngraph::pass::InitNodeInfo().run_on_function(f);
-    ngraph::pass::ConvFusion().run_on_function(f);
-    ngraph::pass::ConstantFolding().run_on_function(f);
-    f->validate_nodes_and_infer_types();
-    // ASSERT_NO_THROW(check_rt_info(f));
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+    ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
+    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    manager.register_pass<ngraph::pass::ConvFusion>();
+    manager.register_pass<ngraph::pass::ConstantFolding>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+    manager.run_passes(f);
+    ASSERT_NO_THROW(check_rt_info(f));
+
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 using add = ngraph::opset5::Add;
@@ -210,51 +216,38 @@ INSTANTIATE_TEST_SUITE_P(DISABLED_ConvMulFusionNegative, ConvFusionTests,
                                         mul::get_type_info_static(), EltwiseShape{9, 1, 1, 1, 1}, true)));
 
 
-TEST(GroupConvMulFusion, WeightsWithReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, WeightsWithReshape) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{4, 1, 3, 3}, std::vector<float>(36, 1));
         auto reshape = std::make_shared<opset5::Reshape>(weights, opset5::Constant::create(element::i64, Shape{5}, Shape{4, 1, 1, 3, 3}), false);
         auto conv = std::make_shared<opset5::GroupConvolution>(data, reshape, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{4, 1, 1}, std::vector<float>(4, 2)));
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GroupConvolutionMultiplyFusion>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GroupConvolutionMultiplyFusion>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{4, 1, 1, 3, 3}, std::vector<float>(36, 2));
         auto conv = std::make_shared<opset5::GroupConvolution>(data, weights, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(GroupConvMulFusion, NegativeWeightsWithReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeWeightsWithReshape) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{36}, std::vector<float>(36, 1));
         auto reshape = std::make_shared<opset5::Reshape>(weights, opset5::Constant::create(element::i64, Shape{5}, Shape{4, 1, 1, 3, 3}), false);
         auto conv = std::make_shared<opset5::GroupConvolution>(data, reshape, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{4, 1, 1}, std::vector<float>(4, 2)));
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GroupConvolutionMultiplyFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GroupConvolutionMultiplyFusion>();
     }
 
     {
@@ -263,75 +256,55 @@ TEST(GroupConvMulFusion, NegativeWeightsWithReshape) {
         auto reshape = std::make_shared<opset5::Reshape>(weights, opset5::Constant::create(element::i64, Shape{5}, Shape{4, 1, 1, 3, 3}), false);
         auto conv = std::make_shared<opset5::GroupConvolution>(data, reshape, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{4, 1, 1}, std::vector<float>(4, 2)));
-        f_ref = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(GroupConvMulFusion, WeightsWithReshapeScalarMultiplier) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, WeightsWithReshapeScalarMultiplier) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{36}, std::vector<float>(36, 1));
         auto reshape = std::make_shared<opset5::Reshape>(weights, opset5::Constant::create(element::i64, Shape{5}, Shape{4, 1, 1, 3, 3}), false);
         auto conv = std::make_shared<opset5::GroupConvolution>(data, reshape, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{1}, {2.0f}));
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GroupConvolutionMultiplyFusion>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GroupConvolutionMultiplyFusion>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{4, 1, 1, 3, 3}, std::vector<float>(36, 2));
         auto conv = std::make_shared<opset5::GroupConvolution>(data, weights, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(GroupConvMulFusion, WeightsWithoutReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, WeightsWithoutReshape) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{4, 1, 1, 3, 3}, std::vector<float>(36, 1));
         auto conv = std::make_shared<opset5::GroupConvolution>(data, weights, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{4, 1, 1}, std::vector<float>(4, 2)));
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GroupConvolutionMultiplyFusion>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GroupConvolutionMultiplyFusion>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{4, 1, 1, 3, 3}, std::vector<float>(36, 2));
         auto conv = std::make_shared<opset5::GroupConvolution>(data, weights, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(GroupConvMulFusion, WeightsWithFakeQuantizeAndReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, WeightsWithFakeQuantizeAndReshape) {
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 4, 7, 7});
         auto weights = opset5::Constant::create(element::f32, Shape{6, 2, 3, 3}, std::vector<float>(108, 1));
@@ -343,14 +316,10 @@ TEST(GroupConvMulFusion, WeightsWithFakeQuantizeAndReshape) {
         auto reshape = std::make_shared<opset5::Reshape>(fq, opset5::Constant::create(element::i64, Shape{5}, Shape{2, 3, 2, 3, 3}), false);
         auto conv = std::make_shared<opset5::GroupConvolution>(data, reshape, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
         auto mul = std::make_shared<opset5::Multiply>(conv, opset5::Constant::create(element::f32, Shape{6, 1, 1}, std::vector<float>(6, 2)));
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GroupConvolutionMultiplyFusion>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GroupConvolutionMultiplyFusion>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -364,9 +333,6 @@ TEST(GroupConvMulFusion, WeightsWithFakeQuantizeAndReshape) {
         auto mul = std::make_shared<opset5::Multiply>(fq, opset5::Constant::create(element::f32, Shape{6, 1, 1, 1}, std::vector<float>(6, 2)));
         auto reshape = std::make_shared<opset5::Reshape>(mul, opset5::Constant::create(element::i64, Shape{5}, Shape{2, 3, 2, 3, 3}), false);
         auto conv = std::make_shared<opset5::GroupConvolution>(data, reshape, Strides{1, 1}, CoordinateDiff{0, 0}, CoordinateDiff{0, 0}, Strides{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_broadcast_to_tiles_test.cpp

@@ -21,14 +21,13 @@
 using namespace testing;
 
 TEST(TransformationTests, ConvertBroadcastToTilesDynamic) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto target_shape = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{3}, std::vector<int64_t>{3, 5, 2});
         auto broadcast = std::make_shared<ngraph::opset1::Broadcast>(input1, target_shape);
         broadcast->set_friendly_name("broadcast");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{broadcast}, ngraph::ParameterVector{input1});
+        auto f = std::make_shared<ngraph::Function>(ngraph::NodeVector{broadcast}, ngraph::ParameterVector{input1});
 
         ngraph::pass::Manager manager;
         manager.register_pass<ngraph::pass::InitNodeInfo>();
@@ -36,5 +35,6 @@ TEST(TransformationTests, ConvertBroadcastToTilesDynamic) {
         ASSERT_NO_THROW(manager.run_passes(f));
         ASSERT_NO_THROW(check_rt_info(f));
     }
+    // TODO: construct reference graph and use TEST_F
 }
 

inference-engine/tests/functional/inference_engine/transformations/convert_cells_to_cells_ie_test.cpp

@@ -26,8 +26,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, GRUCellConversionTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GRUCellConversionTest) {
     std::shared_ptr<ngraph::opset3::GRUCell> cell;
 
     const size_t batch_size = 2;
@@ -45,12 +44,8 @@ TEST(TransformationTests, GRUCellConversionTest) {
         cell = std::make_shared<ngraph::opset3::GRUCell>(X, H_t, W, R, B, hidden_size);
         cell->set_friendly_name("test_cell");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t});
         manager.register_pass<ngraph::pass::ConvertGRUCellMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -71,19 +66,12 @@ TEST(TransformationTests, GRUCellConversionTest) {
                                                                cell->get_linear_before_reset());
         cell_ie->set_friendly_name("test_cell");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto cell_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell") << "Transformation ConvertGRUCellToGRUCellIE should keep output names.\n";
 }
 
-TEST(TransformationTests, RNNCellConversionTest) {
+TEST_F(TransformationTestsF, RNNCellConversionTest) {
     const size_t hidden_size = 3;
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     std::shared_ptr<ngraph::opset3::RNNCell> cell;
 
     {
@@ -96,12 +84,8 @@ TEST(TransformationTests, RNNCellConversionTest) {
         cell = std::make_shared<ngraph::opset3::RNNCell>(X, H, W, R, B, hidden_size);
         cell->set_friendly_name("test_cell");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H});
         manager.register_pass<ngraph::pass::ConvertRNNCellMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -119,24 +103,16 @@ TEST(TransformationTests, RNNCellConversionTest) {
                                                                cell->get_clip());
 
         cell_ie->set_friendly_name("test_cell");
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto cell_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell") << "Transformation ConvertRNNCellToRNNCellIE should keep output names.\n";
 }
 
-TEST(TransformationTests, LSTMCellConversionTest_opset3) {
+TEST_F(TransformationTestsF, LSTMCellConversionTest_opset3) {
     const size_t batch_size = 2;
     const size_t input_size = 3;
     const size_t hidden_size = 3;
     const size_t gates_count = 4;
 
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     std::shared_ptr<ngraph::opset3::LSTMCell> cell;
     {
         const auto X = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{batch_size, input_size});
@@ -151,12 +127,8 @@ TEST(TransformationTests, LSTMCellConversionTest_opset3) {
         cell = std::make_shared<ngraph::opset3::LSTMCell>(X, H_t, C_t, W, R, B, hidden_size);
         cell->set_friendly_name("test_cell");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t, C_t});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t, C_t});
         manager.register_pass<ngraph::pass::ConvertLSTMCellMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -178,24 +150,16 @@ TEST(TransformationTests, LSTMCellConversionTest_opset3) {
                                                                 cell->get_clip());
         cell_ie->set_friendly_name("test_cell");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t, C_t});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t, C_t});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto cell_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell") << "Transformation ConvertLSTMCellToLSTMCellIE should keep output names.\n";
 }
 
-TEST(TransformationTests, LSTMCellConversionTest_opset4) {
+TEST_F(TransformationTestsF, LSTMCellConversionTest_opset4) {
     const size_t batch_size = 2;
     const size_t input_size = 3;
     const size_t hidden_size = 3;
     const size_t gates_count = 4;
 
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     std::shared_ptr<ngraph::opset4::LSTMCell> cell;
     {
         const auto X = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32,
@@ -214,14 +178,9 @@ TEST(TransformationTests, LSTMCellConversionTest_opset4) {
                                                                   ngraph::Shape{gates_count * hidden_size});
 
         cell = std::make_shared<ngraph::opset4::LSTMCell>(X, H_t, C_t, W, R, B, hidden_size);
-        cell->set_friendly_name("test_cell");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t, C_t});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t, C_t});
         manager.register_pass<ngraph::pass::ConvertLSTMCellMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -247,16 +206,6 @@ TEST(TransformationTests, LSTMCellConversionTest_opset4) {
                                                                 cell->get_activations_alpha(),
                                                                 cell->get_activations_beta(),
                                                                 cell->get_clip());
-        cell_ie->set_friendly_name("test_cell");
-
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t, C_t});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t, C_t});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto cell_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell")
-                                << "Transformation ConvertLSTMCellToLSTMCellIE should keep output names.\n";
 }

inference-engine/tests/functional/inference_engine/transformations/convert_deformable_conv_v8_to_v1_test.cpp

@@ -19,8 +19,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertDeformableConv8to1) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertDeformableConv8to1) {
     {
         const Strides strides{1, 1};
         const CoordinateDiff padding{0, 0};
@@ -42,13 +41,8 @@ TEST(TransformationTests, ConvertDeformableConv8to1) {
                                                                                padding,
                                                                                dilations);
 
-        f = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter, offsets});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
+        function = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter, offsets});
         manager.register_pass<pass::ConvertDeformableConv8To1>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -72,15 +66,11 @@ TEST(TransformationTests, ConvertDeformableConv8to1) {
                                                                                padding,
                                                                                dilations);
 
-        f_ref = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter, offsets});
+        function_ref = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter, offsets});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertDeformableConv8to1_mask) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertDeformableConv8to1_mask) {
     {
         const Strides strides{1, 1};
         const CoordinateDiff padding{0, 0};
@@ -105,22 +95,15 @@ TEST(TransformationTests, ConvertDeformableConv8to1_mask) {
                                                                                padding,
                                                                                dilations);
 
-        f = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter,
+        function = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter,
                                                                                     mask, offsets});
 
         pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertDeformableConv8To1>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
-    // mask input is provided, DeformableConvolution-8 must remain
-    ASSERT_EQ(count_ops_of_type<opset1::DeformableConvolution>(f), 0);
-    ASSERT_EQ(count_ops_of_type<opset8::DeformableConvolution>(f), 1);
 }
 
-TEST(TransformationTests, ConvertDeformableConv8to1_bilinear_interpolation_padding) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertDeformableConv8to1_bilinear_interpolation_padding) {
     {
         const Strides strides{1, 1};
         const CoordinateDiff padding{0, 0};
@@ -146,15 +129,9 @@ TEST(TransformationTests, ConvertDeformableConv8to1_bilinear_interpolation_paddi
                                                                                1,
                                                                                true);
 
-        f = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter, offsets});
+        function = std::make_shared<Function>(NodeVector{deformable_conv}, ParameterVector{data, filter, offsets});
 
         pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertDeformableConv8To1>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
-    //  use_bilinear_interpolation_padding is true, DeformableConvolution-8 must remain
-    ASSERT_EQ(count_ops_of_type<opset1::DeformableConvolution>(f), 0);
-    ASSERT_EQ(count_ops_of_type<opset8::DeformableConvolution>(f), 1);
 }

inference-engine/tests/functional/inference_engine/transformations/convert_divide.cpp

@@ -19,20 +19,15 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertDivide) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertDivide) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto divide_constant = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{1}, {1.5});
         auto divide = std::make_shared<ngraph::opset1::Divide>(data, divide_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertDivide>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertDivide>();
     }
 
     {
@@ -42,27 +37,19 @@ TEST(TransformationTests, ConvertDivide) {
                                                            ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{}, {-1}));
         auto mul = std::make_shared<ngraph::opset1::Multiply>(data, pow);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertDivideNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertDivideNegative) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i32, ngraph::Shape{3, 1, 2});
         auto divide_constant = ngraph::opset1::Constant::create(ngraph::element::i32, ngraph::Shape{1}, {2});
         auto divide = std::make_shared<ngraph::opset1::Divide>(data, divide_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertDivide>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertDivide>();
     }
 
     {
@@ -70,29 +57,21 @@ TEST(TransformationTests, ConvertDivideNegative) {
         auto divide_constant = ngraph::opset1::Constant::create(ngraph::element::i32, ngraph::Shape{1}, {2});
         auto divide = std::make_shared<ngraph::opset1::Divide>(data, divide_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertDivideScalar) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertDivideScalar) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{});
         auto divide_constant = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{}, {1.5});
         auto divide = std::make_shared<ngraph::opset1::Divide>(data, divide_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{data});
 
         NGRAPH_CHECK(divide->get_output_partial_shape(0).rank().get_length() == 0);
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertDivide>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertDivide>();
     }
 
     {
@@ -102,11 +81,8 @@ TEST(TransformationTests, ConvertDivideScalar) {
                                                            ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{}, {-1}));
         auto mul = std::make_shared<ngraph::opset1::Multiply>(data, pow);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{data});
 
         NGRAPH_CHECK(mul->get_output_partial_shape(0).rank().get_length() == 0);
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_gather_0d_test.cpp

@@ -20,22 +20,17 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertGather0DStatic1) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather0DStatic1) {
     {
         auto input = std::make_shared<opset1::Parameter>(element::f32, Shape{6, 12, 10, 24});
         auto indices = std::make_shared<opset1::Parameter>(element::f32, Shape{15, 4, 20, 28});
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
+        function = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
 
         pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertGather0D>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -44,29 +39,19 @@ TEST(TransformationTests, ConvertGather0DStatic1) {
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f_ref = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
+        function_ref = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertGather0DStatic2) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather0DStatic2) {
     {
         auto input = std::make_shared<opset1::Parameter>(element::f32, Shape{6, 12, 10, 24});
         auto indices = std::make_shared<opset1::Parameter>(element::f32, Shape{});
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
+        function = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
         manager.register_pass<pass::ConvertGather0D>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -77,9 +62,6 @@ TEST(TransformationTests, ConvertGather0DStatic2) {
         auto gather = std::make_shared<opset1::Gather>(input, unsqueeze, axis_const);
         auto squeeze = std::make_shared<opset1::Squeeze>(gather, opset1::Constant::create(element::i64, Shape{1}, {1}));
 
-        f_ref = std::make_shared<Function>(NodeVector{squeeze}, ParameterVector{input, indices});
+        function_ref = std::make_shared<Function>(NodeVector{squeeze}, ParameterVector{input, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_gather_downgrade_test.cpp

@@ -19,8 +19,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertGather7toGather1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather7toGather1) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3});
         auto indices = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i32, ngraph::Shape{2, 2});
@@ -28,13 +27,8 @@ TEST(TransformationTests, ConvertGather7toGather1) {
 
         auto gather_v7 = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
         manager.register_pass<ngraph::pass::ConvertGather7ToGather1>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -44,15 +38,11 @@ TEST(TransformationTests, ConvertGather7toGather1) {
 
         auto gather_v1 = std::make_shared<ngraph::opset1::Gather>(data, indices, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v1}, ngraph::ParameterVector{data, indices});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v1}, ngraph::ParameterVector{data, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertGather7toGather1_nonzero_batch_dims) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather7toGather1_nonzero_batch_dims) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3});
         auto indices = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i32, ngraph::Shape{2, 2});
@@ -60,22 +50,12 @@ TEST(TransformationTests, ConvertGather7toGather1_nonzero_batch_dims) {
 
         auto gather_v7 = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, -1);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
         manager.register_pass<ngraph::pass::ConvertGather7ToGather1>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
-
-    // if batch_dims != 0 Gather-7 must remain
-    ASSERT_EQ(count_ops_of_type<ngraph::opset1::Gather>(f), 0);
-    ASSERT_EQ(count_ops_of_type<ngraph::opset7::Gather>(f), 1);
 }
 
-TEST(TransformationTests, ConvertGather8toGather7) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather8toGather7) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3});
         auto indices = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i32, ngraph::Shape{2, 2});
@@ -84,13 +64,9 @@ TEST(TransformationTests, ConvertGather8toGather7) {
 
         auto gather_v8 = std::make_shared<ngraph::opset8::Gather>(data, indices, axis, batch_dims);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v8}, ngraph::ParameterVector{data, indices});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v8}, ngraph::ParameterVector{data, indices});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertGather8ToGather7>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -101,9 +77,6 @@ TEST(TransformationTests, ConvertGather8toGather7) {
 
         auto gather_v7 = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, batch_dims);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_gather_to_gather_ie.cpp

@@ -21,22 +21,15 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertGatherToGatherIEStatic1) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGatherToGatherIEStatic1) {
     {
         auto input = std::make_shared<opset1::Parameter>(element::f32, Shape{6, 12, 10, 24});
         auto indices = std::make_shared<opset1::Parameter>(element::f32, Shape{15, 4, 20, 28});
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
+        function = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
         manager.register_pass<pass::ConvertGatherToGatherIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -44,29 +37,19 @@ TEST(TransformationTests, ConvertGatherToGatherIEStatic1) {
         auto indices = std::make_shared<opset1::Parameter>(element::f32, Shape{15, 4, 20, 28});
         auto gather = std::make_shared<op::GatherIE>(input, indices, 1);
 
-        f_ref = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
+        function_ref = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertGatherToGatherIEStatic2) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGatherToGatherIEStatic2) {
     {
         auto input = std::make_shared<opset1::Parameter>(element::f32, Shape{6, 12, 10, 24});
         auto indices = std::make_shared<opset1::Parameter>(element::f32, Shape{});
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
+        function = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
         manager.register_pass<pass::ConvertGatherToGatherIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -76,28 +59,19 @@ TEST(TransformationTests, ConvertGatherToGatherIEStatic2) {
         auto gather = std::make_shared<op::GatherIE>(input, unsqueeze, 1);
         auto squeeze = std::make_shared<opset1::Squeeze>(gather, opset1::Constant::create(element::i64, Shape{1}, {1}));
 
-        f_ref = std::make_shared<Function>(NodeVector{squeeze}, ParameterVector{input, indices});
+        function_ref = std::make_shared<Function>(NodeVector{squeeze}, ParameterVector{input, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertGatherToGatherIEDynamic1) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGatherToGatherIEDynamic1) {
     {
         auto input = std::make_shared<opset1::Parameter>(element::f32, PartialShape{DYN, DYN, DYN, DYN});
         auto indices = std::make_shared<opset1::Parameter>(element::f32, PartialShape{DYN, DYN});
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
+        function = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
         manager.register_pass<pass::ConvertGatherToGatherIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -105,28 +79,19 @@ TEST(TransformationTests, ConvertGatherToGatherIEDynamic1) {
         auto indices = std::make_shared<opset1::Parameter>(element::f32, PartialShape{DYN, DYN});
         auto gather = std::make_shared<op::GatherIE>(input, indices, 1);
 
-        f_ref = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
+        function_ref = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertGatherToGatherIEDynamic2) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGatherToGatherIEDynamic2) {
     {
         auto input = std::make_shared<opset1::Parameter>(element::f32, PartialShape{DYN, DYN});
         auto indices = std::make_shared<opset1::Parameter>(element::f32, Shape{});
         auto axis_const = opset1::Constant::create(element::i64, Shape{}, {1});
         auto gather = std::make_shared<opset1::Gather>(input, indices, axis_const);
 
-        f = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
-
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
+        function = std::make_shared<Function>(NodeVector{gather}, ParameterVector{input, indices});
         manager.register_pass<pass::ConvertGatherToGatherIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -136,9 +101,6 @@ TEST(TransformationTests, ConvertGatherToGatherIEDynamic2) {
         auto gather = std::make_shared<op::GatherIE>(input, unsqueeze, 1);
         auto squeeze = std::make_shared<opset1::Squeeze>(gather, opset1::Constant::create(element::i64, Shape{1}, {1}));
 
-        f_ref = std::make_shared<Function>(NodeVector{squeeze}, ParameterVector{input, indices});
+        function_ref = std::make_shared<Function>(NodeVector{squeeze}, ParameterVector{input, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_gather_upgrade_test.cpp

@@ -20,8 +20,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertGather1toGather7) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather1toGather7) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3});
         auto indices = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i32, ngraph::Shape{2, 2});
@@ -29,13 +28,8 @@ TEST(TransformationTests, ConvertGather1toGather7) {
 
         auto gather_v1 = std::make_shared<ngraph::opset1::Gather>(data, indices, axis);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v1}, ngraph::ParameterVector{data, indices});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v1}, ngraph::ParameterVector{data, indices});
         manager.register_pass<ngraph::pass::ConvertGather1ToGather7>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -45,15 +39,11 @@ TEST(TransformationTests, ConvertGather1toGather7) {
 
         auto gather_v7 = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertGather7toGather8) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertGather7toGather8) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3});
         auto indices = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::i32, ngraph::Shape{2, 2});
@@ -61,13 +51,9 @@ TEST(TransformationTests, ConvertGather7toGather8) {
         int64_t batch_dims = 1;
         auto gather_v7 = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, batch_dims);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v7}, ngraph::ParameterVector{data, indices});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertGather7ToGather8>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -78,9 +64,6 @@ TEST(TransformationTests, ConvertGather7toGather8) {
 
         auto gather_v8 = std::make_shared<ngraph::opset8::Gather>(data, indices, axis, batch_dims);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v8}, ngraph::ParameterVector{data, indices});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather_v8}, ngraph::ParameterVector{data, indices});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_interpolate1_to_interpolate4_test.cpp

@@ -21,8 +21,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertInterpolate1ToInterpolate4) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertInterpolate1ToInterpolate4) {
     {
         auto data_node = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 4, 30, 30});
         auto out_shape_node = opset1::Constant::create(element::i32, Shape{4}, {2, 4, 40, 40});
@@ -37,13 +36,9 @@ TEST(TransformationTests, ConvertInterpolate1ToInterpolate4) {
 
         auto interpolate1 = std::make_shared<opset1::Interpolate>(data_node, out_shape_node, interpolate1_attr);
 
-        f = std::make_shared<Function>(NodeVector{interpolate1}, ParameterVector{data_node});
+        function = std::make_shared<Function>(NodeVector{interpolate1}, ParameterVector{data_node});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertInterpolate1ToInterpolate4>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertInterpolate1ToInterpolate4>();
     }
 
     {
@@ -59,15 +54,11 @@ TEST(TransformationTests, ConvertInterpolate1ToInterpolate4) {
 
         auto interpolate4 = std::make_shared<opset4::Interpolate>(data_node, out_shape_node, default_scales_node, axes_node, interpolate4_attr);
 
-        f_ref = std::make_shared<Function>(NodeVector{interpolate4}, ParameterVector{data_node});
+        function_ref = std::make_shared<Function>(NodeVector{interpolate4}, ParameterVector{data_node});
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertInterpolate1ToInterpolate4_1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertInterpolate1ToInterpolate4_1) {
     {
         auto data_node = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 4, 30, 30});
         auto out_shape_node = opset1::Constant::create(element::i32, Shape{2}, {40, 40});
@@ -82,13 +73,9 @@ TEST(TransformationTests, ConvertInterpolate1ToInterpolate4_1) {
 
         auto interpolate1 = std::make_shared<opset1::Interpolate>(data_node, out_shape_node, interpolate1_attr);
 
-        f = std::make_shared<Function>(NodeVector{interpolate1}, ParameterVector{data_node});
+        function = std::make_shared<Function>(NodeVector{interpolate1}, ParameterVector{data_node});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertInterpolate1ToInterpolate4>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertInterpolate1ToInterpolate4>();
     }
 
     {
@@ -104,9 +91,6 @@ TEST(TransformationTests, ConvertInterpolate1ToInterpolate4_1) {
 
         auto interpolate4 = std::make_shared<opset4::Interpolate>(data_node, out_shape_node, default_scales_node, axes_node, interpolate4_attr);
 
-        f_ref = std::make_shared<Function>(NodeVector{interpolate4}, ParameterVector{data_node});
+        function_ref = std::make_shared<Function>(NodeVector{interpolate4}, ParameterVector{data_node});
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_matmul_test.cpp

@@ -27,21 +27,16 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertMatMulTest1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest1) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto input2 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2, 1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
     }
 
     {
@@ -52,28 +47,20 @@ TEST(TransformationTests, ConvertMatMulTest1) {
 
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, reshape, false, false);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMatMulTest2) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest2) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto input2 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
 
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
     }
 
     {
@@ -86,27 +73,19 @@ TEST(TransformationTests, ConvertMatMulTest2) {
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, reshape, false, false);
         auto reshape_output = ngraph::op::util::reshapeTo(matmul, {3, 1});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_output}, ngraph::ParameterVector{input1, input2});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_output}, ngraph::ParameterVector{input1, input2});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMatMulTest3) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest3) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{2});
         auto input2 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2, 1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
     }
 
     {
@@ -119,27 +98,19 @@ TEST(TransformationTests, ConvertMatMulTest3) {
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(reshape, input2, false, false);
         auto reshape_output = ngraph::op::util::reshapeTo(matmul, {3, 1});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_output}, ngraph::ParameterVector{input1, input2});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_output}, ngraph::ParameterVector{input1, input2});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMatMulTest4) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest4) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto input2 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2, 1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
     }
 
     {
@@ -147,27 +118,19 @@ TEST(TransformationTests, ConvertMatMulTest4) {
         auto input2 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2, 1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, false);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1, input2});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMatMulTest5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest5) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2, 2});
         auto input2 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{2, 2}, {1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, true);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
     }
 
     {
@@ -176,28 +139,20 @@ TEST(TransformationTests, ConvertMatMulTest5) {
         auto input3 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{2}, {1});
         auto matmul = std::make_shared<ngraph::op::FullyConnected>(input1, input2, input3, ngraph::Shape{3, 2, 2});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMatMulTest6) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest6) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2, 2});
         auto input2 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{2, 2}, {1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, true);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.register_pass<ngraph::pass::ReshapeFullyConnected>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
+        manager.register_pass<ngraph::pass::ReshapeFullyConnected>();
     }
 
     {
@@ -208,28 +163,22 @@ TEST(TransformationTests, ConvertMatMulTest6) {
         auto fc = std::make_shared<ngraph::op::FullyConnected>(reshape_begin, input2, input3, ngraph::Shape{6, 2});
         auto reshape_end = ngraph::op::util::reshapeTo(fc, ngraph::Shape{3, 2, 2});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_end}, ngraph::ParameterVector{input1});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_end}, ngraph::ParameterVector{input1});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMatMulTest7) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatMulTest7) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2, 2});
         auto input2 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{2, 2}, {1});
         auto matmul = std::make_shared<ngraph::opset1::MatMul>(input1, input2, false, true);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
 
-        ngraph::pass::Manager m;
-        auto pass_config = m.get_pass_config();
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::ConvertMatMulToFC>();
-        m.register_pass<ngraph::pass::ConvertMatMulToGemm>();
-        m.register_pass<ngraph::pass::ReshapeFullyConnected>();
+        auto pass_config = manager.get_pass_config();
+        manager.register_pass<ngraph::pass::ConvertMatMulToFC>();
+        manager.register_pass<ngraph::pass::ConvertMatMulToGemm>();
+        manager.register_pass<ngraph::pass::ReshapeFullyConnected>();
 
         auto callback = [](const std::shared_ptr<const ngraph::Node> & node) -> bool {
             if (auto fc_op = std::dynamic_pointer_cast<const ngraph::op::FullyConnected>(node)) {
@@ -241,9 +190,6 @@ TEST(TransformationTests, ConvertMatMulTest7) {
         };
 
         pass_config->set_callback<ngraph::pass::ReshapeFullyConnected>(callback);
-
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -252,11 +198,8 @@ TEST(TransformationTests, ConvertMatMulTest7) {
         auto input3 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{2}, {1});
         auto matmul = std::make_shared<ngraph::op::FullyConnected>(input1, input2, input3, ngraph::Shape{3, 2, 2});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{matmul}, ngraph::ParameterVector{input1});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 TEST(TransformationTests, ConvertMatMulDynamic) {

inference-engine/tests/functional/inference_engine/transformations/convert_matrix_nms_to_matrix_nms_ie_internal.cpp

@@ -25,23 +25,17 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertMatrixNmsToMatrixNmsIE) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMatrixNmsToMatrixNmsIE) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
 
         auto nms = std::make_shared<opset8::MatrixNms>(boxes, scores, opset8::MatrixNms::Attributes());
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertMatrixNmsToMatrixNmsIE>();
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -49,10 +43,6 @@ TEST(TransformationTests, ConvertMatrixNmsToMatrixNmsIE) {
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
         auto nms = std::make_shared<op::internal::NmsStaticShapeIE<ngraph::opset8::MatrixNms>>(boxes, scores, opset8::MatrixNms::Attributes());
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_multiclass_nms_to_multiclass_nms_ie_internal.cpp

@@ -25,23 +25,17 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertMulticlassNmsToMulticlassNmsIE) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMulticlassNmsToMulticlassNmsIE) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
 
         auto nms = std::make_shared<opset8::MulticlassNms>(boxes, scores, opset8::MulticlassNms::Attributes());
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertMulticlassNmsToMulticlassNmsIE>();
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -49,10 +43,6 @@ TEST(TransformationTests, ConvertMulticlassNmsToMulticlassNmsIE) {
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
         auto nms = std::make_shared<op::internal::NmsStaticShapeIE<ngraph::opset8::MulticlassNms>>(boxes, scores, opset8::MulticlassNms::Attributes());
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_mvn1_to_mvn6_test.cpp

@@ -19,19 +19,14 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertMVN1ToMVN6) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMVN1ToMVN6) {
     {
         auto data = std::make_shared<ngraph::opset2::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 3, 4 });
         auto mvn = std::make_shared<ngraph::op::v0::MVN>(data, false, true, 1e-5);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertMVN1ToMVN6>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -39,26 +34,18 @@ TEST(TransformationTests, ConvertMVN1ToMVN6) {
         auto axes_const = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 2 }, { 2, 3 });
         auto mvn = std::make_shared<ngraph::op::v6::MVN>(data, axes_const, true, 1e-5, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMVN1ToMVN6_across_channels) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMVN1ToMVN6_across_channels) {
     {
         auto data = std::make_shared<ngraph::opset2::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 3, 4 });
         auto mvn = std::make_shared<ngraph::op::v0::MVN>(data, true, true, 1e-5);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertMVN1ToMVN6>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -66,26 +53,18 @@ TEST(TransformationTests, ConvertMVN1ToMVN6_across_channels) {
         auto axes_const = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::op::v6::MVN>(data, axes_const, true, 1e-5, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertMVN1ToMVN6_5D) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertMVN1ToMVN6_5D) {
     {
         auto data = std::make_shared<ngraph::opset2::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 3, 4, 5 });
         auto mvn = std::make_shared<ngraph::op::v0::MVN>(data, false, true, 1e-5);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertMVN1ToMVN6>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -93,9 +72,6 @@ TEST(TransformationTests, ConvertMVN1ToMVN6_5D) {
         auto axes_const = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 3 }, { 2, 3, 4 });
         auto mvn = std::make_shared<ngraph::op::v6::MVN>(data, axes_const, true, 1e-5, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_nms5_test.cpp

@@ -20,8 +20,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEStaticSixInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEStaticSixInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -32,14 +31,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticSixInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                soft_nms_sigma, opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
     }
 
     {
@@ -65,18 +59,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticSixInputs) {
                                                                                              one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               new_soft_nms_sigma, 0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEStaticFiveInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEStaticFiveInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -86,14 +74,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticFiveInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
     }
 
     {
@@ -115,18 +98,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticFiveInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEStaticFourInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEStaticFourInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -135,14 +112,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticFourInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
     }
 
     {
@@ -164,18 +136,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticFourInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEStaticThreeInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEStaticThreeInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -183,14 +149,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticThreeInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
     }
 
     {
@@ -212,32 +173,21 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticThreeInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEStaticTwoInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEStaticTwoInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, Shape{1, 1, 1000});
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
     }
 
     {
@@ -259,18 +209,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEStaticTwoInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).same_scheme(PartialShape{Dimension::dynamic(), 3}));
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1SixInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic1SixInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
@@ -281,14 +225,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1SixInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                soft_nms_sigma, opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -314,17 +253,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1SixInputs) {
                                                                                              one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               new_soft_nms_sigma, 0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1FiveInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic1FiveInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
@@ -334,14 +268,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1FiveInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -363,17 +292,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1FiveInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1FourInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic1FourInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
@@ -382,14 +306,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1FourInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -411,17 +330,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1FourInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1ThreeInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic1ThreeInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
@@ -429,14 +343,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1ThreeInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -458,31 +367,21 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1ThreeInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1TwoInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic1TwoInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape::dynamic());
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -504,17 +403,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic1TwoInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2SixInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic2SixInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1, 1000});
@@ -525,14 +419,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2SixInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                soft_nms_sigma, opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -558,17 +447,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2SixInputs) {
                                                                                              one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               new_soft_nms_sigma, 0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2FiveInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic2FiveInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1, 1000});
@@ -578,14 +462,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2FiveInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -607,17 +486,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2FiveInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2FourInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic2FourInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1, 1000});
@@ -626,14 +500,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2FourInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -655,17 +524,12 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2FourInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2ThreeInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic2ThreeInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1, 1000});
@@ -673,14 +537,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2ThreeInputs) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -702,31 +561,21 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2ThreeInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2TwoInputs) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEDynamic2TwoInputs) {
     {
         auto boxes = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1000, 4});
         auto scores = std::make_shared<opset5::Parameter>(element::f32, PartialShape{DYN, 1, 1000});
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNMS5ToLegacyMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -748,13 +597,9 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEDynamic2TwoInputs) {
                                                                                               one_dim_shape), true);
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, new_max_per_class, new_iou_threshold, new_score_threshold,
                                                               0, true, element::i32);
-        nms->set_friendly_name("nms");
 
         auto convert_0 = std::make_shared<opset1::Convert>(nms->output(0), element::i64);
 
-        f_ref = std::make_shared<Function>(NodeVector{convert_0}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{convert_0}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_nms_gather_path_to_unsigned_test.cpp

@@ -15,9 +15,8 @@ using namespace testing;
 using namespace ngraph;
 using namespace std;
 
-TEST(TransformationTests, test_convert_to_unsigned_nms_gather_1) {
+TEST_F(TransformationTestsF, test_convert_to_unsigned_nms_gather_1) {
     // if Convert doesn't exist
-    shared_ptr<Function> f(nullptr), f_ref(nullptr);
     {
         auto boxes = make_shared<opset8::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = make_shared<opset8::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -34,13 +33,9 @@ TEST(TransformationTests, test_convert_to_unsigned_nms_gather_1) {
         auto reshape_node = make_shared<opset8::Reshape>(scores, opset8::Constant::create(element::i32, Shape{1}, {-1}), true);
         auto gather = make_shared<opset8::Gather>(reshape_node, squeeze_node, opset8::Constant::create(element::i32, Shape{1}, {0}));
 
-        f = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
+        function = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNmsGatherPathToUnsigned>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -59,16 +54,12 @@ TEST(TransformationTests, test_convert_to_unsigned_nms_gather_1) {
         auto reshape_node = make_shared<opset8::Reshape>(scores, opset8::Constant::create(element::i32, Shape{1}, {-1}), true);
         auto gather = make_shared<opset8::Gather>(reshape_node, convert, opset8::Constant::create(element::i32, Shape{1}, {0}));
 
-        f_ref = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
+        function_ref = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, test_convert_to_unsigned_nms_gather_2) {
+TEST_F(TransformationTestsF, test_convert_to_unsigned_nms_gather_2) {
     // if Convert already exists
-    shared_ptr<Function> f(nullptr), f_ref(nullptr);
     {
         auto boxes = make_shared<opset8::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = make_shared<opset8::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -86,13 +77,9 @@ TEST(TransformationTests, test_convert_to_unsigned_nms_gather_2) {
         auto reshape_node = make_shared<opset8::Reshape>(scores, opset8::Constant::create(element::i32, Shape{1}, {-1}), true);
         auto gather = make_shared<opset8::Gather>(reshape_node, convert, opset8::Constant::create(element::i32, Shape{1}, {0}));
 
-        f = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
+        function = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertNmsGatherPathToUnsigned>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -111,11 +98,8 @@ TEST(TransformationTests, test_convert_to_unsigned_nms_gather_2) {
         auto reshape_node = make_shared<opset8::Reshape>(scores, opset8::Constant::create(element::i32, Shape{1}, {-1}), true);
         auto gather = make_shared<opset8::Gather>(reshape_node, convert, opset8::Constant::create(element::i32, Shape{1}, {0}));
 
-        f_ref = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
+        function_ref = make_shared<Function>(NodeVector{gather}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 TEST(TransformationTests, test_convert_to_unsigned_nms_gather_3) {

inference-engine/tests/functional/inference_engine/transformations/convert_nms_to_nms_ie_internal_test.cpp

@@ -25,8 +25,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertNMS1ToNMSIEInternal) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS1ToNMSIEInternal) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -36,16 +35,15 @@ TEST(TransformationTests, ConvertNMS1ToNMSIEInternal) {
         auto nms = std::make_shared<opset1::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, op::v1::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMS1ToNMS5>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEInternal>();
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
+
+        // as inside test infrastructure we can not predict output names for given Function
+        // we have to enable soft names comparison manually
+        enable_soft_names_comparison();
     }
 
     {
@@ -58,16 +56,11 @@ TEST(TransformationTests, ConvertNMS1ToNMSIEInternal) {
                 iou_threshold, score_threshold, 0, true, element::i32);
         auto convert = std::make_shared<opset1::Convert>(nms->output(0), element::i64);
 
-        f_ref = std::make_shared<Function>(NodeVector{convert}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{convert}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS3ToNMSIEInternal) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS3ToNMSIEInternal) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -77,16 +70,11 @@ TEST(TransformationTests, ConvertNMS3ToNMSIEInternal) {
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset3::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMS3ToNMS5>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEInternal>();
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -98,16 +86,11 @@ TEST(TransformationTests, ConvertNMS3ToNMSIEInternal) {
         auto nms = std::make_shared<op::internal::NonMaxSuppressionIEInternal>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, 0, true, element::i32);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS4ToNMSIEInternal) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS4ToNMSIEInternal) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -117,16 +100,11 @@ TEST(TransformationTests, ConvertNMS4ToNMSIEInternal) {
         auto nms = std::make_shared<opset4::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset4::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMS4ToNMS5>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEInternal>();
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -138,16 +116,11 @@ TEST(TransformationTests, ConvertNMS4ToNMSIEInternal) {
         auto nms = std::make_shared<op::internal::NonMaxSuppressionIEInternal>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, 0, true, element::i32);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS5ToNMSIEInternal) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS5ToNMSIEInternal) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -158,15 +131,10 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEInternal) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, soft_nms_sigma, opset5::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEInternal>();
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -179,10 +147,6 @@ TEST(TransformationTests, ConvertNMS5ToNMSIEInternal) {
         auto nms = std::make_shared<op::internal::NonMaxSuppressionIEInternal>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, soft_nms_sigma, 0, true, element::i32);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_nms_to_nms_ie_test.cpp

@@ -24,8 +24,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertNMSToNMSIEStatic) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMSToNMSIEStatic) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -35,14 +34,13 @@ TEST(TransformationTests, ConvertNMSToNMSIEStatic) {
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset3::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
+
+        // as inside test infrastructure we can not predict output names for given Function
+        // we have to enable soft names comparison manually
+        enable_soft_names_comparison();
     }
 
     {
@@ -56,16 +54,11 @@ TEST(TransformationTests, ConvertNMSToNMSIEStatic) {
                 std::make_shared<opset1::Unsqueeze>(score_threshold, opset1::Constant::create(element::i64, Shape{1}, {0})),
                 0, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMSToNMSIEDynamic1) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMSToNMSIEDynamic1) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, PartialShape::dynamic());
         auto scores = std::make_shared<opset1::Parameter>(element::f32, PartialShape::dynamic());
@@ -75,14 +68,9 @@ TEST(TransformationTests, ConvertNMSToNMSIEDynamic1) {
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset3::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -96,15 +84,11 @@ TEST(TransformationTests, ConvertNMSToNMSIEDynamic1) {
                 std::make_shared<opset1::Unsqueeze>(score_threshold, opset1::Constant::create(element::i64, Shape{1}, {0})),
                 0, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMSToNMSIEDynamic2) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMSToNMSIEDynamic2) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, PartialShape{DYN, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, PartialShape{DYN, 1, 1000});
@@ -114,14 +98,9 @@ TEST(TransformationTests, ConvertNMSToNMSIEDynamic2) {
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset3::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertNMSToNMSIEMatcher>();
-        manager.run_passes(f);
-        f->validate_nodes_and_infer_types();
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -135,15 +114,11 @@ TEST(TransformationTests, ConvertNMSToNMSIEDynamic2) {
                 std::make_shared<opset1::Unsqueeze>(score_threshold, opset1::Constant::create(element::i64, Shape{1}, {0})),
                 0, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMST1oNMSIE) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMST1oNMSIE) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -153,14 +128,9 @@ TEST(TransformationTests, ConvertNMST1oNMSIE) {
         auto nms = std::make_shared<opset1::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, op::v1::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertOpSet1ToLegacy>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -173,16 +143,11 @@ TEST(TransformationTests, ConvertNMST1oNMSIE) {
                 iou_threshold, score_threshold, 0, true, element::i32);
         auto convert = std::make_shared<opset1::Convert>(nms->output(0), element::i64);
 
-        f_ref = std::make_shared<Function>(NodeVector{convert}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{convert}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMST3oNMSIE) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMST3oNMSIE) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -192,14 +157,9 @@ TEST(TransformationTests, ConvertNMST3oNMSIE) {
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset3::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertOpSet1ToLegacy>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -211,16 +171,11 @@ TEST(TransformationTests, ConvertNMST3oNMSIE) {
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, 0, true, element::i32);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMST4oNMSIE) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMST4oNMSIE) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -230,14 +185,9 @@ TEST(TransformationTests, ConvertNMST4oNMSIE) {
         auto nms = std::make_shared<opset4::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, opset4::NonMaxSuppression::BoxEncodingType::CORNER, true, element::i32);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertOpSet1ToLegacy>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -249,10 +199,6 @@ TEST(TransformationTests, ConvertNMST4oNMSIE) {
         auto nms = std::make_shared<op::NonMaxSuppressionIE3>(boxes, scores, max_output_boxes_per_class,
                 iou_threshold, score_threshold, 0, true, element::i32);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
-        ASSERT_TRUE(f_ref->get_output_partial_shape(0).is_static()) << "Shape " << f_ref->get_output_partial_shape(0) << " should be static";
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_pad_to_group_conv.cpp

@@ -20,8 +20,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertPadToConv) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertPadToConv) {
     {
         auto input = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 3, 64, 64});
         auto pad_begin = opset4::Constant::create(element::i64, Shape{4}, {0, 0, 1, 0});
@@ -29,14 +28,9 @@ TEST(TransformationTests, ConvertPadToConv) {
         auto pad_value = opset4::Constant::create(element::f32, Shape{}, {0});
         auto pad_mode = op::PadMode::CONSTANT;
         auto pad = std::make_shared<opset4::Pad>(input, pad_begin, pad_end, pad_value, pad_mode);
-        f = std::make_shared<Function>(NodeVector{pad}, ParameterVector{input});
+        function = std::make_shared<Function>(NodeVector{pad}, ParameterVector{input});
 
-        pass::Manager manager;
-        manager.register_pass<pass::InitNodeInfo>();
         manager.register_pass<pass::ConvertPadToGroupConvolution>();
-        manager.run_passes(f);
-
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -46,14 +40,11 @@ TEST(TransformationTests, ConvertPadToConv) {
         CoordinateDiff pad_begin{1, 0}, pad_end{0, 1};
         auto conv = std::make_shared<opset4::GroupConvolution>(input, weights, stride, pad_begin, pad_end, stride);
 
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{input});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertPadToConvNeg1) {
+TEST_F(TransformationTestsF, ConvertPadToConvNeg1) {
     auto get_function = []() -> std::shared_ptr<Function> {
         auto input = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 3, 64, 64});
         auto pad_begin = opset4::Constant::create(element::i64, Shape{4}, {1, 0, 1, 0}); // Batch dim padding
@@ -64,19 +55,12 @@ TEST(TransformationTests, ConvertPadToConvNeg1) {
         return std::make_shared<Function>(NodeVector{pad}, ParameterVector{input});
     };
 
-    std::shared_ptr<Function> f(get_function()), f_ref(get_function());
-    pass::Manager manager;
-    manager.register_pass<pass::InitNodeInfo>();
+    function = get_function();
+    function_ref = get_function();
     manager.register_pass<pass::ConvertPadToGroupConvolution>();
-    manager.run_passes(f);
-
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertPadToConvNeg2) {
+TEST_F(TransformationTestsF, ConvertPadToConvNeg2) {
     auto get_function = []() -> std::shared_ptr<Function> {
         auto input = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 3, 64, 64});
         auto pad_begin = opset4::Constant::create(element::i64, Shape{4}, {0, 0, 1, 0});
@@ -87,19 +71,12 @@ TEST(TransformationTests, ConvertPadToConvNeg2) {
         return std::make_shared<Function>(NodeVector{pad}, ParameterVector{input});
     };
 
-    std::shared_ptr<Function> f(get_function()), f_ref(get_function());
-    pass::Manager manager;
-    manager.register_pass<pass::InitNodeInfo>();
+    function = get_function();
+    function_ref = get_function();
     manager.register_pass<pass::ConvertPadToGroupConvolution>();
-    manager.run_passes(f);
-
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertPadToConvNeg3) {
+TEST_F(TransformationTestsF, ConvertPadToConvNeg3) {
     auto get_function = []() -> std::shared_ptr<Function> {
         auto input = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 3, 64, 64});
         auto pad_begin = opset4::Constant::create(element::i64, Shape{4}, {0, 0, 1, 0});
@@ -110,20 +87,13 @@ TEST(TransformationTests, ConvertPadToConvNeg3) {
         return std::make_shared<Function>(NodeVector{pad}, ParameterVector{input});
     };
 
-    std::shared_ptr<Function> f(get_function()), f_ref(get_function());
-    pass::Manager manager;
-    manager.register_pass<pass::InitNodeInfo>();
+    function = get_function();
+    function_ref = get_function();
     manager.register_pass<pass::ConvertPadToGroupConvolution>();
-    manager.run_passes(f);
-
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, ConvertPadToConvNeg4) {
+TEST_F(TransformationTestsF, ConvertPadToConvNeg4) {
     auto get_function = []() -> std::shared_ptr<Function> {
         auto input = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 3, 64, 64});
         auto pad_begin = opset4::Constant::create(element::i64, Shape{4}, {0, 0, 1, 0});
@@ -134,14 +104,7 @@ TEST(TransformationTests, ConvertPadToConvNeg4) {
         return std::make_shared<Function>(NodeVector{pad}, ParameterVector{input});
     };
 
-    std::shared_ptr<Function> f(get_function()), f_ref(get_function());
-    pass::Manager manager;
-    manager.register_pass<pass::InitNodeInfo>();
+    function = get_function();
+    function_ref = get_function();
     manager.register_pass<pass::ConvertPadToGroupConvolution>();
-    manager.run_passes(f);
-
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_previous_nms_to_nms_5.cpp

@@ -23,8 +23,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, ConvertNMS4FiveInputsToNMS5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS4FiveInputsToNMS5) {
     {
         auto boxes = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -34,13 +33,9 @@ TEST(TransformationTests, ConvertNMS4FiveInputsToNMS5) {
         auto nms = std::make_shared<opset4::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                opset4::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertNMS4ToNMS5>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertNMS4ToNMS5>();
     }
 
     {
@@ -52,27 +47,19 @@ TEST(TransformationTests, ConvertNMS4FiveInputsToNMS5) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,  iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS4TwoInputsToNMS5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS4TwoInputsToNMS5) {
     {
         auto boxes = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset4::Parameter>(element::f32, Shape{1, 1, 1000});
         auto nms = std::make_shared<opset4::NonMaxSuppression>(boxes, scores, opset4::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertNMS4ToNMS5>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertNMS4ToNMS5>();
     }
 
     {
@@ -84,15 +71,11 @@ TEST(TransformationTests, ConvertNMS4TwoInputsToNMS5) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,  iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS3FiveInputsToNMS5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS3FiveInputsToNMS5) {
     {
         auto boxes = std::make_shared<opset3::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset3::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -102,13 +85,9 @@ TEST(TransformationTests, ConvertNMS3FiveInputsToNMS5) {
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                opset3::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertNMS3ToNMS5>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertNMS3ToNMS5>();
     }
 
     {
@@ -120,27 +99,19 @@ TEST(TransformationTests, ConvertNMS3FiveInputsToNMS5) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,  iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS3TwoInputsToNMS5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS3TwoInputsToNMS5) {
     {
         auto boxes = std::make_shared<opset3::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset3::Parameter>(element::f32, Shape{1, 1, 1000});
         auto nms = std::make_shared<opset3::NonMaxSuppression>(boxes, scores, opset3::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertNMS3ToNMS5>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertNMS3ToNMS5>();
     }
 
     {
@@ -152,15 +123,11 @@ TEST(TransformationTests, ConvertNMS3TwoInputsToNMS5) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,  iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS1FiveInputsToNMS5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS1FiveInputsToNMS5) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
@@ -170,13 +137,9 @@ TEST(TransformationTests, ConvertNMS1FiveInputsToNMS5) {
         auto nms = std::make_shared<opset1::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold,
                                                                opset1::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertNMS1ToNMS5>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertNMS1ToNMS5>();
     }
 
     {
@@ -188,27 +151,19 @@ TEST(TransformationTests, ConvertNMS1FiveInputsToNMS5) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,  iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertNMS1TwoInputsToNMS5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertNMS1TwoInputsToNMS5) {
     {
         auto boxes = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1000, 4});
         auto scores = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 1, 1000});
         auto nms = std::make_shared<opset1::NonMaxSuppression>(boxes, scores, opset1::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ConvertNMS1ToNMS5>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::ConvertNMS1ToNMS5>();
     }
 
     {
@@ -220,9 +175,6 @@ TEST(TransformationTests, ConvertNMS1TwoInputsToNMS5) {
         auto nms = std::make_shared<opset5::NonMaxSuppression>(boxes, scores, max_output_boxes_per_class,  iou_threshold, score_threshold,
                                                                opset5::NonMaxSuppression::BoxEncodingType::CORNER, true);
 
-        f_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
+        function_ref = std::make_shared<Function>(NodeVector{nms}, ParameterVector{boxes, scores});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_reduce_to_pooling_test.cpp

@@ -115,11 +115,18 @@ public:
 };
 
 TEST_P(ConvertReduceToPoolingTests, CompareFunctions) {
-    ngraph::pass::InitNodeInfo().run_on_function(f);
-    ngraph::pass::ConvertReduceToPooling().run_on_function(f);
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+    ngraph::pass::Manager m;
+    m.register_pass<ngraph::pass::InitUniqueNames>(unh);
+    m.register_pass<ngraph::pass::InitNodeInfo>();
+    m.register_pass<ngraph::pass::ConvertReduceToPooling>();
+    m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+    m.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 #define MAX std::make_shared<ngraph::opset1::ReduceMax>()

inference-engine/tests/functional/inference_engine/transformations/convert_scatter_elements_to_scatter_test.cpp

@@ -76,15 +76,19 @@ std::shared_ptr<ngraph::Function> get_reference_function(const ngraph::PartialSh
 }
 
 void test(std::shared_ptr<ngraph::Function> f, std::shared_ptr<ngraph::Function> f_ref) {
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
     ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
     manager.register_pass<ngraph::pass::InitNodeInfo>();
     manager.register_pass<ngraph::pass::ConvertScatterElementsToScatter>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
     manager.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
     ngraph::pass::ConstantFolding().run_on_function(f);
 
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 void test(std::shared_ptr<ngraph::Function> f) {

inference-engine/tests/functional/inference_engine/transformations/convert_sequences_to_sequences_ie_test.cpp

@@ -23,8 +23,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, GRUSequenceConversionTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GRUSequenceConversionTest) {
     std::shared_ptr<ngraph::opset5::GRUSequence> sequence;
 
     const size_t batch_size = 2;
@@ -49,14 +48,9 @@ TEST(TransformationTests, GRUSequenceConversionTest) {
         const auto seq_len = std::make_shared<ngraph::opset5::Constant>(ngraph::element::i32, ngraph::Shape{batch_size});
         sequence = std::make_shared<ngraph::opset5::GRUSequence>(X, H_t, seq_len, W, R, B, hidden_size,
                                                                  ngraph::op::RecurrentSequenceDirection::FORWARD);
-        sequence->set_friendly_name("test_sequence");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sequence}, ngraph::ParameterVector{X, H_t});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sequence}, ngraph::ParameterVector{X, H_t});
         manager.register_pass<ngraph::pass::ConvertGRUSequenceMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -92,26 +86,18 @@ TEST(TransformationTests, GRUSequenceConversionTest) {
                                                                        sequence->get_activations_beta(),
                                                                        sequence->get_clip(),
                                                                        sequence->get_linear_before_reset());
-        sequence_ie->set_friendly_name("test_sequence");
 
         auto unsqueeze_axis = ngraph::opset5::Constant::create(ngraph::element::i64, ngraph::Shape{1}, {1});
         auto unsqueeze_1 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(0), unsqueeze_axis);
         auto unsqueeze_2 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(1), unsqueeze_axis);
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{unsqueeze_1}, ngraph::ParameterVector{X, H_t});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{unsqueeze_1}, ngraph::ParameterVector{X, H_t});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto sequence_node = result_node_of_converted_f->input_value(0).get_node_shared_ptr()
-            ->input_value(0).get_node_shared_ptr();
 }
 
-TEST(TransformationTests, RNNSequenceConversionTest) {
+TEST_F(TransformationTestsF, RNNSequenceConversionTest) {
     const size_t hidden_size = 3;
     const size_t num_directions = 1;
     const size_t batch_size = 2;
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     std::shared_ptr<ngraph::opset5::RNNSequence> sequence;
 
     {
@@ -123,14 +109,9 @@ TEST(TransformationTests, RNNSequenceConversionTest) {
         auto seq_len = std::make_shared<ngraph::opset5::Constant>(ngraph::element::f32, ngraph::Shape{2});
         sequence = std::make_shared<ngraph::opset5::RNNSequence>(X, H, seq_len, W, R, B, hidden_size,
                                                                  ngraph::op::RecurrentSequenceDirection::FORWARD);
-        sequence->set_friendly_name("test_sequence");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sequence}, ngraph::ParameterVector{X, H});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sequence}, ngraph::ParameterVector{X, H});
         manager.register_pass<ngraph::pass::ConvertRNNSequenceMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -161,25 +142,16 @@ TEST(TransformationTests, RNNSequenceConversionTest) {
         auto unsqueeze_axis = ngraph::opset5::Constant::create(ngraph::element::i64, ngraph::Shape{1}, {1});
         auto unsqueeze_1 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(0), unsqueeze_axis);
         auto unsqueeze_2 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(1), unsqueeze_axis);
-        sequence_ie->set_friendly_name("test_sequence");
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{unsqueeze_1}, ngraph::ParameterVector{X, H});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{unsqueeze_1}, ngraph::ParameterVector{X, H});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto sequence_node = result_node_of_converted_f->input_value(0).get_node_shared_ptr()
-            ->input_value(0).get_node_shared_ptr();
 }
 
-TEST(TransformationTests, LSTMSequenceConversionTest) {
+TEST_F(TransformationTestsF, LSTMSequenceConversionTest) {
     const size_t batch_size = 2;
     const size_t input_size = 3;
     const size_t hidden_size = 3;
     const size_t gates_count = 4;
     const size_t num_directions = 1;
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     std::shared_ptr<ngraph::opset5::LSTMSequence> sequence;
     {
         const auto X = std::make_shared<ngraph::opset5::Parameter>(ngraph::element::f32,
@@ -206,12 +178,8 @@ TEST(TransformationTests, LSTMSequenceConversionTest) {
                                                                   ngraph::op::RecurrentSequenceDirection::FORWARD);
         sequence->set_friendly_name("test_sequence");
 
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{sequence->output(0)}, ngraph::ParameterVector{X, H_t, C_t});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{sequence->output(0)}, ngraph::ParameterVector{X, H_t, C_t});
         manager.register_pass<ngraph::pass::ConvertLSTMSequenceMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -254,19 +222,11 @@ TEST(TransformationTests, LSTMSequenceConversionTest) {
                                                                         sequence->get_activations_alpha(),
                                                                         sequence->get_activations_beta(),
                                                                         sequence->get_clip());
-        sequence_ie->set_friendly_name("test_sequence");
         auto unsqueeze_axis = ngraph::opset5::Constant::create(ngraph::element::i64, ngraph::Shape{1}, {1});
         auto unsqueeze_1 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(0), unsqueeze_axis);
         auto unsqueeze_2 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(1), unsqueeze_axis);
         auto unsqueeze_3 = std::make_shared<ngraph::opset5::Unsqueeze>(sequence_ie->output(2), unsqueeze_axis);
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{unsqueeze_1},
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{unsqueeze_1},
                                                    ngraph::ParameterVector{X, H_t, C_t});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto sequence_node = result_node_of_converted_f->input_value(0).get_node_shared_ptr()
-            ->input_value(0).get_node_shared_ptr();
 }

inference-engine/tests/functional/inference_engine/transformations/convert_shapeof3.cpp

@@ -18,67 +18,40 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertShapeOf3WithI64) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertShapeOf3WithI64) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
         auto shapeof = std::make_shared<ngraph::opset3::ShapeOf>(input, ngraph::element::i64);
         shapeof->set_friendly_name("shapeof");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{shapeof}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{shapeof}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertShapeOf3>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
         auto shapeof = std::make_shared<ngraph::opset1::ShapeOf>(input);
-        shapeof->set_friendly_name("shapeof");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{shapeof}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{shapeof}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "shapeof") << "Transformation ConvertShapeOf3 should keep output names.\n";
 }
 
-TEST(TransformationTests, ConvertShapeOf3WithI32) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertShapeOf3WithI32) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
         auto shapeof = std::make_shared<ngraph::opset3::ShapeOf>(input, ngraph::element::i32);
-        shapeof->set_friendly_name("shapeof");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{shapeof}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{shapeof}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertShapeOf3>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
         auto shapeof = std::make_shared<ngraph::opset1::ShapeOf>(input);
         auto convert = std::make_shared<ngraph::opset1::Convert>(shapeof, ngraph::element::i32);
-        convert->set_friendly_name("shapeof");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{convert}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{convert}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "shapeof") << "Transformation ConvertShapeOf3 should keep output names.\n";
 }

inference-engine/tests/functional/inference_engine/transformations/convert_shuffle_channels3_test.cpp

@@ -22,23 +22,14 @@ using namespace ngraph;
 std::shared_ptr<ngraph::Function> buildInputGraph(int64_t axis, int64_t group, const ::PartialShape& p) {
     auto input = std::make_shared<::opset3::Parameter>(::element::f32, p);
     auto shuffle_channels = std::make_shared<::opset3::ShuffleChannels>(input, axis, group);
-    shuffle_channels->set_friendly_name("shc");
-
-    auto f = std::make_shared<::Function>(::NodeVector{shuffle_channels}, ::ParameterVector{input});
-
-    ngraph::pass::Manager manager;
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
-    manager.register_pass<ngraph::pass::ConvertShuffleChannels3>();
-    manager.run_passes(f);
-    f->validate_nodes_and_infer_types();
-    return f;
+    return std::make_shared<::Function>(::NodeVector{shuffle_channels}, ::ParameterVector{input});
 }
 
-TEST(TransformationTests, ConvertShuffleChannelsAxis0) {
+TEST_F(TransformationTestsF, ConvertShuffleChannelsAxis0) {
     int64_t group = 4;
     auto ps = ::PartialShape{12, Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic()};
-    std::shared_ptr<ngraph::Function> f = buildInputGraph(0, group, ps), f_ref(nullptr);
-    ASSERT_NO_THROW(check_rt_info(f));
+    function = buildInputGraph(0, group, ps);
+    manager.register_pass<ngraph::pass::ConvertShuffleChannels3>();
 
     auto input = std::make_shared<::opset3::Parameter>(::element::f32, ps);
 
@@ -61,21 +52,14 @@ TEST(TransformationTests, ConvertShuffleChannelsAxis0) {
                                                                                       {1, 0, 2}));
     auto reshape_back = std::make_shared<::opset2::Reshape>(transpose->output(0), original_shape->output(0), false);
 
-    f_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "shc") << "ConvertShuffleChannels3 should keep output names.\n";
+    function_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
 }
 
-TEST(TransformationTests, ConvertShuffleChannelsAxis1) {
+TEST_F(TransformationTestsF, ConvertShuffleChannelsAxis1) {
     int64_t group = 4;
     auto ps = ::PartialShape{Dimension::dynamic(), 12, Dimension::dynamic(), Dimension::dynamic()};
-    std::shared_ptr<ngraph::Function> f = buildInputGraph(1, group, ps), f_ref(nullptr);
-    ASSERT_NO_THROW(check_rt_info(f));
+    function = buildInputGraph(1, group, ps);
+    manager.register_pass<ngraph::pass::ConvertShuffleChannels3>();
 
     auto input = std::make_shared<::opset3::Parameter>(::element::f32, ps);
 
@@ -99,21 +83,14 @@ TEST(TransformationTests, ConvertShuffleChannelsAxis1) {
                                                                                       {0, 2, 1, 3}));
     auto reshape_back = std::make_shared<::opset2::Reshape>(transpose->output(0), original_shape->output(0), false);
 
-    f_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "shc") << "ConvertShuffleChannels3 should keep output names.\n";
+    function_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
 }
 
-TEST(TransformationTests, ConvertShuffleChannelsAxis2) {
+TEST_F(TransformationTestsF, ConvertShuffleChannelsAxis2) {
     int64_t group = 4;
     auto ps = ::PartialShape{Dimension::dynamic(), Dimension::dynamic(), 12, Dimension::dynamic()};
-    std::shared_ptr<ngraph::Function> f = buildInputGraph(2, group, ps), f_ref(nullptr);
-    ASSERT_NO_THROW(check_rt_info(f));
+    function = buildInputGraph(2, group, ps);
+    manager.register_pass<ngraph::pass::ConvertShuffleChannels3>();
 
     auto input = std::make_shared<::opset3::Parameter>(::element::f32, ps);
 
@@ -137,21 +114,14 @@ TEST(TransformationTests, ConvertShuffleChannelsAxis2) {
                                                                                       {0, 2, 1, 3}));
     auto reshape_back = std::make_shared<::opset2::Reshape>(transpose->output(0), original_shape->output(0), false);
 
-    f_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "shc") << "ConvertShuffleChannels3 should keep output names.\n";
+    function_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
 }
 
-TEST(TransformationTests, ConvertShuffleChannelsLastAxis) {
+TEST_F(TransformationTestsF, ConvertShuffleChannelsLastAxis) {
     int64_t group = 4;
     auto ps = ::PartialShape{Dimension::dynamic(), Dimension::dynamic(), Dimension::dynamic(), 12};
-    std::shared_ptr<ngraph::Function> f = buildInputGraph(-1, group, ps), f_ref(nullptr);
-    ASSERT_NO_THROW(check_rt_info(f));
+    function = buildInputGraph(-1, group, ps);
+    manager.register_pass<ngraph::pass::ConvertShuffleChannels3>();
 
     auto input = std::make_shared<::opset3::Parameter>(::element::f32, ps);
 
@@ -174,12 +144,5 @@ TEST(TransformationTests, ConvertShuffleChannelsLastAxis) {
                                                                                       {0, 2, 1}));
     auto reshape_back = std::make_shared<::opset2::Reshape>(transpose->output(0), original_shape->output(0), false);
 
-    f_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "shc") << "ConvertShuffleChannels3 should keep output names.\n";
+    function_ref = std::make_shared<::Function>(::NodeVector{reshape_back}, ::ParameterVector{input});
 }

inference-engine/tests/functional/inference_engine/transformations/convert_strided_slice_to_crop_test.cpp

@@ -29,8 +29,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertStridedSliceToCropTests1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertStridedSliceToCropTests1) {
     {
         auto input        = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 384, 640});
         auto slice_begin  = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 1, 0, 0});
@@ -48,13 +47,8 @@ TEST(TransformationTests, ConvertStridedSliceToCropTests1) {
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertStridedSliceToCropMatcher>();
-        manager.run_passes(f);
-
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -70,22 +64,11 @@ TEST(TransformationTests, ConvertStridedSliceToCropTests1) {
         auto reshape      = ngraph::op::util::reshapeTo(crop, {1, 384, 640});
         reshape->set_friendly_name("strided_slice");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto reshape_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    auto crop_node = reshape_node->input(0).get_source_output().get_node_shared_ptr();
-    bool names_are_correct = (crop_node->get_friendly_name() == "strided_slice/Crop") &&
-                             (reshape_node->get_friendly_name() == "strided_slice");
-    ASSERT_TRUE(names_are_correct) << "Transformation ConvertStridedSliceToCrop should keep output names.\n";
 }
 
-TEST(TransformationTests, ConvertStridedSliceToCropTests2) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertStridedSliceToCropTests2) {
     {
         auto input        = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 384, 640});
         auto slice_begin  = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 0, 0, 0});
@@ -103,12 +86,8 @@ TEST(TransformationTests, ConvertStridedSliceToCropTests2) {
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertStridedSliceToCropMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -124,22 +103,11 @@ TEST(TransformationTests, ConvertStridedSliceToCropTests2) {
         auto reshape      = ngraph::op::util::reshapeTo(crop, {1, 384, 640});
         reshape->set_friendly_name("strided_slice");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto reshape_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    auto crop_node = reshape_node->input(0).get_source_output().get_node_shared_ptr();
-    bool names_are_correct = (crop_node->get_friendly_name() == "strided_slice/Crop") &&
-                             (reshape_node->get_friendly_name() == "strided_slice");
-    ASSERT_TRUE(names_are_correct) << "Transformation ConvertStridedSliceToCrop should keep output names.\n";
 }
 
-TEST(TransformationTests, ConvertStridedSliceToCropNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertStridedSliceToCropNegative) {
     {
         auto input        = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(4));
         auto slice_begin  = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 1, 0, 0});
@@ -157,12 +125,8 @@ TEST(TransformationTests, ConvertStridedSliceToCropNegative) {
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertStridedSliceToCropMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -182,16 +146,12 @@ TEST(TransformationTests, ConvertStridedSliceToCropNegative) {
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 // in this test the Crop will get 3D input which is not supported so the transformation will not be applied
-TEST(TransformationTests, ConvertStridedSliceToCropNegative2) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertStridedSliceToCropNegative2) {
     {
         auto input        = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{128, 1});
         auto slice_begin  = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{3}, {0, 0, 0});
@@ -209,12 +169,8 @@ TEST(TransformationTests, ConvertStridedSliceToCropNegative2) {
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertStridedSliceToCropMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -234,17 +190,13 @@ TEST(TransformationTests, ConvertStridedSliceToCropNegative2) {
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, ConvertStridedSliceToCropNoneZeroBeginValuesWithMask) {
+TEST_F(TransformationTestsF, ConvertStridedSliceToCropNoneZeroBeginValuesWithMask) {
     // when begin_mask/end_mask are present begin/end values should not affect output shape
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input        = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 4});
         auto slice_begin  = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 3, 2, 1});
@@ -262,12 +214,8 @@ TEST(TransformationTests, ConvertStridedSliceToCropNoneZeroBeginValuesWithMask)
                                                                      new_axis_mask, shrink_axis_mask, ellipsis_mask);
         sslice->set_friendly_name("strided_slice");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{sslice}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertStridedSliceToCropMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -283,9 +231,6 @@ TEST(TransformationTests, ConvertStridedSliceToCropNoneZeroBeginValuesWithMask)
         auto crop = std::make_shared<ngraph::op::CropIE>(reshape, axes, dim, offset);
         crop->set_friendly_name("strided_slice");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{crop}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{crop}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/convert_topk3_test.cpp

@@ -22,8 +22,7 @@
 using namespace testing;
 
 // check that the first output from the TopK-3 with I32 output indices is equal to the TopK-1 first output
-TEST(TransformationTests, ConvertTopK3I32Output0) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopK3I32Output0) {
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
@@ -31,14 +30,8 @@ TEST(TransformationTests, ConvertTopK3I32Output0) {
         topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
-
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopK3>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -48,125 +41,73 @@ TEST(TransformationTests, ConvertTopK3I32Output0) {
         topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto topk_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(topk_node->get_friendly_name() == "topk") << "Transformation ConvertTopK3 should keep output names.\n";
 }
 
 // check that the second output from the TopK-3 with I32 output indices is equal to the TopK-1 second output
-TEST(TransformationTests, ConvertTopK3I32Output1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopK3I32Output1) {
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset3::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
-        topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(1)}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(1)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopK3>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset2::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
-        topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(1)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(1)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto topk_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(topk_node->get_friendly_name() == "topk") << "Transformation ConvertTopK3 should keep output names.\n";
 }
 
 // check that the first output from the TopK-3 with I64 output indices is equal to the TopK-1 first output
-TEST(TransformationTests, ConvertTopK3I64Output0) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopK3I64Output0) {
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset3::TopK>(input, k, 1, "min", "value", ngraph::element::i64);
-        topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopK3>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset2::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
-        topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto topk_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(topk_node->get_friendly_name() == "topk") << "Transformation ConvertTopK3 should keep output names.\n";
 }
 
 // check that the second output from the TopK-3 with I64 output indices is equal to the TopK-1 second output converted to I64
-TEST(TransformationTests, ConvertTopK3I64Output1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopK3I64Output1) {
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset3::TopK>(input, k, 1, "min", "value", ngraph::element::i64);
-        topk->set_friendly_name("topk");
 
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(1)}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(1)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopK3>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset2::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
-        auto convert = std::make_shared<ngraph::opset2::Convert>(topk->output(1), topk->get_index_element_type());
-        topk->set_friendly_name("topk");
+        auto convert = std::make_shared<ngraph::opset2::Convert>(topk->output(1), ngraph::element::i64);
 
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{convert}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{convert}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto convert_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(convert_node->get_friendly_name() == "topk.1") << "Transformation ConvertTopK3 should keep output names.\n";
 }

inference-engine/tests/functional/inference_engine/transformations/convert_topk_test.cpp

@@ -21,24 +21,19 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ConvertTopKToTopKIEStatic) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopKToTopKIEStatic) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset1::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ConvertTopKToTopKIEMatcher>();
         manager.register_pass<ngraph::pass::InjectionPass>([](std::shared_ptr<ngraph::Function> f) {
             check_rt_info(f);
         });
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        ASSERT_NO_THROW(manager.run_passes(f));
-        ASSERT_TRUE(f->get_output_partial_shape(0).is_static()) << "Shape " << f->get_output_partial_shape(0) << " should be static";
     }
 
     {
@@ -48,28 +43,19 @@ TEST(TransformationTests, ConvertTopKToTopKIEStatic) {
         auto topk = std::make_shared<ngraph::op::TopKIE>(input, k, 1, ngraph::op::TopKMode::MIN,
                 ngraph::op::TopKSortType::SORT_VALUES);
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertTopKToTopKIEDynamic1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopKToTopKIEDynamic1) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape{DYN, 20, 3});
         auto k = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset1::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopKToTopKIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
 
     {
@@ -79,28 +65,19 @@ TEST(TransformationTests, ConvertTopKToTopKIEDynamic1) {
         auto topk = std::make_shared<ngraph::op::TopKIE>(input, k, 1, ngraph::op::TopKMode::MIN,
                 ngraph::op::TopKSortType::SORT_VALUES);
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertTopKToTopKIEDynamic2) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopKToTopKIEDynamic2) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape{1, DYN, 3});
         auto k = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset1::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopKToTopKIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
 
     {
@@ -110,28 +87,19 @@ TEST(TransformationTests, ConvertTopKToTopKIEDynamic2) {
         auto topk = std::make_shared<ngraph::op::TopKIE>(input, k, 1, ngraph::op::TopKMode::MIN,
                 ngraph::op::TopKSortType::SORT_VALUES);
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertTopKToTopKIEDynamic3) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopKToTopKIEDynamic3) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape{1, 20, DYN});
         auto k = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{}, {10});
         auto topk = std::make_shared<ngraph::opset1::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
         manager.register_pass<ngraph::pass::ConvertTopKToTopKIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
 
     {
@@ -141,28 +109,19 @@ TEST(TransformationTests, ConvertTopKToTopKIEDynamic3) {
         auto topk = std::make_shared<ngraph::op::TopKIE>(input, k, 1, ngraph::op::TopKMode::MIN,
                 ngraph::op::TopKSortType::SORT_VALUES);
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ConvertTopKToTopKIENegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ConvertTopKToTopKIENegative) {
     {
         auto input = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{15, 20, 3});
         auto k = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic());
         auto topk = std::make_shared<ngraph::opset1::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
         // due to the 'compare_functions' limitation we will check only one output
-        f = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input, k});
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input, k});
         manager.register_pass<ngraph::pass::ConvertTopKToTopKIEMatcher>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
 
     {
@@ -170,9 +129,6 @@ TEST(TransformationTests, ConvertTopKToTopKIENegative) {
         auto k = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic());
         auto topk = std::make_shared<ngraph::opset1::TopK>(input, k, 1, "min", "value", ngraph::element::i32);
         // due to the 'compare_functions' limitation we will check only one output
-        f_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input, k});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::OutputVector{topk->output(0)}, ngraph::ParameterVector{input, k});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/depth_to_space_fusion_test.cpp

@@ -24,8 +24,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, DepthToSpaceFusionDepthFirst) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DepthToSpaceFusionDepthFirst) {
     {
         auto input0 = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 720, 480});
         auto shape_reshape_before = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{6}, {1, 32, 2, 2, 720, 480});
@@ -36,35 +35,27 @@ TEST(TransformationTests, DepthToSpaceFusionDepthFirst) {
         auto permute = std::make_shared<ngraph::opset3::Transpose> (reshape_before, permutation);
         auto reshape_after = std::make_shared<ngraph::opset3::Reshape> (permute, shape_reshape_after, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0});
 
         auto callback = [](const std::shared_ptr<const ngraph::Node> & node) -> bool {
             return std::dynamic_pointer_cast<const ngraph::opset3::DepthToSpace>(node) != nullptr;
         };
 
-        ngraph::pass::Manager manager;
 
         auto pass_config = manager.get_pass_config();
         pass_config->set_callback<ngraph::pass::DepthToSpaceFusion>(callback);
 
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DepthToSpaceFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input0 = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 720, 480});
         auto depth_to_space = std::make_shared<ngraph::opset3::DepthToSpace>(input0, ngraph::opset3::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST, 2);
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{depth_to_space}, ngraph::ParameterVector{input0});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{depth_to_space}, ngraph::ParameterVector{input0});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, DepthToSpaceFusionBlockFirst) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DepthToSpaceFusionBlockFirst) {
     {
         auto input0 = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 720, 480});
         auto shape_reshape_before = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{6}, {1, 2, 2, 32, 720, 480});
@@ -75,35 +66,27 @@ TEST(TransformationTests, DepthToSpaceFusionBlockFirst) {
         auto permute = std::make_shared<ngraph::opset3::Transpose> (reshape_before, permutation);
         auto reshape_after = std::make_shared<ngraph::opset3::Reshape> (permute, shape_reshape_after, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0});
 
         auto callback = [](const std::shared_ptr<const ngraph::Node> & node) -> bool {
             return std::dynamic_pointer_cast<const ngraph::opset3::DepthToSpace>(node) != nullptr;
         };
 
-        ngraph::pass::Manager manager;
 
         auto pass_config = manager.get_pass_config();
         pass_config->set_callback<ngraph::pass::DepthToSpaceFusion>(callback);
 
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DepthToSpaceFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input0 = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 720, 480});
         auto depth_to_space = std::make_shared<ngraph::opset3::DepthToSpace>(input0, ngraph::opset3::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, 2);
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{depth_to_space}, ngraph::ParameterVector{input0});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{depth_to_space}, ngraph::ParameterVector{input0});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, DepthToSpaceFusionDynamicShape) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DepthToSpaceFusionDynamicShape) {
     {
         auto input0 = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 720, 480});
         auto shape_reshape_before = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::i64, ngraph::Shape{6});
@@ -114,21 +97,17 @@ TEST(TransformationTests, DepthToSpaceFusionDynamicShape) {
         auto permute = std::make_shared<ngraph::opset3::Transpose> (reshape_before, permutation);
         auto reshape_after = std::make_shared<ngraph::opset3::Reshape> (permute, shape_reshape_after, false);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0, shape_reshape_before});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0, shape_reshape_before});
 
         auto callback = [](const std::shared_ptr<const ngraph::Node> & node) -> bool {
             return std::dynamic_pointer_cast<const ngraph::opset3::DepthToSpace>(node) != nullptr;
         };
 
-        ngraph::pass::Manager manager;
 
         auto pass_config = manager.get_pass_config();
         pass_config->set_callback<ngraph::pass::DepthToSpaceFusion>(callback);
 
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DepthToSpaceFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -141,11 +120,8 @@ TEST(TransformationTests, DepthToSpaceFusionDynamicShape) {
         auto permute = std::make_shared<ngraph::opset3::Transpose> (reshape_before, permutation);
         auto reshape_after = std::make_shared<ngraph::opset3::Reshape> (permute, shape_reshape_after, false);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0, shape_reshape_before});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_after}, ngraph::ParameterVector{input0, shape_reshape_before});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 TEST(TransformationTests, DepthToSpaceFusionSeveralConsumers) {

inference-engine/tests/functional/inference_engine/transformations/dilated_convolution_converter.cpp

@@ -22,8 +22,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, DilatedConvolutionConverter) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DilatedConvolutionConverter) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 10, 10});
         auto filters = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 3, 3});
@@ -37,28 +36,20 @@ TEST(TransformationTests, DilatedConvolutionConverter) {
                 op::Constant::create(element::i64, Shape{4}, {1, 1, 2, 2}),
                 op::Constant::create(element::i64, Shape{4}, {0, 0, 0, 0}),
                 op::Constant::create(element::i64, Shape{4}, {0, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data, filters});
+        function = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data, filters});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::DilatedConvolutionConverter>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::DilatedConvolutionConverter>();
     }
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 10, 10});
         auto filters = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 3, 3});
         auto conv = std::make_shared<opset6::Convolution>(data, filters,
                 Strides{1, 1}, CoordinateDiff{1, 1}, CoordinateDiff{-1, -2}, Strides{2, 2}, op::PadType::EXPLICIT);
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeDilatedConvolutionConverterNonZeroPadsForNC) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeDilatedConvolutionConverterNonZeroPadsForNC) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 10, 10});
         auto filters = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 5, 3, 3});
@@ -72,13 +63,9 @@ TEST(TransformationTests, NegativeDilatedConvolutionConverterNonZeroPadsForNC) {
                 op::Constant::create(element::i64, Shape{4}, {1, 1, 2, 2}),
                 op::Constant::create(element::i64, Shape{4}, {0, 0, 0, 0}),
                 op::Constant::create(element::i64, Shape{4}, {0, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data, filters});
+        function = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data, filters});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::DilatedConvolutionConverter>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::DilatedConvolutionConverter>();
     }
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 10, 10});
@@ -93,9 +80,6 @@ TEST(TransformationTests, NegativeDilatedConvolutionConverterNonZeroPadsForNC) {
                 op::Constant::create(element::i64, Shape{4}, {1, 1, 2, 2}),
                 op::Constant::create(element::i64, Shape{4}, {0, 0, 0, 0}),
                 op::Constant::create(element::i64, Shape{4}, {0, 0, 2, 3}));
-        f_ref = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{batch_to_space}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/disable_shapeof_constant_folding_tests.cpp

@@ -18,19 +18,16 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, DisableShapeOfConstantFolding) {
-    std::shared_ptr<Function> f, f_ref;
+TEST_F(TransformationTestsF, DisableShapeOfConstantFolding) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{1, 4, 10, 10});
         auto shape_of = std::make_shared<opset6::ShapeOf>(data);
         auto abs = std::make_shared<opset6::Abs>(shape_of);
         auto reshape = std::make_shared<opset6::Reshape>(data, abs, false);
-        f = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::DisableShapeOfConstantFolding>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
+        manager.register_pass<pass::DisableShapeOfConstantFolding>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -38,14 +35,11 @@ TEST(TransformationTests, DisableShapeOfConstantFolding) {
         auto shape_of = std::make_shared<opset6::ShapeOf>(data);
         auto abs = std::make_shared<opset6::Abs>(shape_of);
         auto reshape = std::make_shared<opset6::Reshape>(data, abs, false);
-        f_ref = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ShapeOfShapeOfConstantFolding) {
+TEST_F(TransformationTestsF, ShapeOfShapeOfConstantFolding) {
     std::shared_ptr<Function> f, f_ref;
     {
         auto data = std::make_shared<opset6::Parameter>(element::i64, Shape{1, 4, 10, 10});
@@ -53,12 +47,10 @@ TEST(TransformationTests, ShapeOfShapeOfConstantFolding) {
         auto reshape = std::make_shared<opset6::Reshape>(data, shape_of, false);
         auto rank = std::make_shared<opset6::ShapeOf>(shape_of);
         auto mul = std::make_shared<opset6::Multiply>(reshape, rank);
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::DisableShapeOfConstantFolding>();
-        m.register_pass<pass::ConstantFolding>();
-        m.run_passes(f);
+        manager.register_pass<pass::DisableShapeOfConstantFolding>();
+        manager.register_pass<pass::ConstantFolding>();
     }
 
     {
@@ -66,9 +58,6 @@ TEST(TransformationTests, ShapeOfShapeOfConstantFolding) {
         auto shape_of = std::make_shared<opset6::ShapeOf>(data);
         auto reshape = std::make_shared<opset6::Reshape>(data, shape_of, false);
         auto mul = std::make_shared<opset6::Multiply>(reshape, opset6::Constant::create(element::i64, Shape{1}, {4}));
-        f_ref = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/dropout_with_random_uniform_replacer_test.cpp

@@ -16,8 +16,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerCase1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerCase1) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -32,13 +31,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerCase1) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -50,15 +45,11 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerCase1) {
         auto add = std::make_shared<ngraph::opset8::Add>(broadcast, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerCase2) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerCase2) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.0});
@@ -73,13 +64,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerCase2) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -91,15 +78,11 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerCase2) {
         auto add = std::make_shared<ngraph::opset8::Add>(broadcast, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerWithConvert) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerWithConvert) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -115,13 +98,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerWithConvert) {
         auto add = std::make_shared<ngraph::opset8::Add>(convert, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -134,16 +113,12 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerWithConvert) {
         auto add = std::make_shared<ngraph::opset8::Add>(convert, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerAddConstNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerAddConstNegative) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -158,13 +133,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerAddConstNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -181,16 +152,12 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerAddConstNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerNonFloatRUNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerNonFloatRUNegative) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::i32, ngraph::Shape{}, {0});
@@ -205,13 +172,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerNonFloatRUNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -228,15 +191,11 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerNonFloatRUNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidMinNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerInvalidMinNegative) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {-2.0});
@@ -251,13 +210,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidMinNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -274,15 +229,11 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidMinNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidMaxNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerInvalidMaxNegative) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -297,13 +248,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidMaxNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -320,16 +267,12 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidMaxNegative) {
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidAddConstRankNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, DropoutWithRandomUniformReplacerInvalidAddConstRankNegative) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -344,13 +287,9 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidAddConstRankNeg
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::DropoutWithRandomUniformReplacer>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -367,9 +306,6 @@ TEST(TransformationTests, DropoutWithRandomUniformReplacerInvalidAddConstRankNeg
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
         auto floor = std::make_shared<ngraph::opset8::Floor>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{floor}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/fc_bias_fusion_test.cpp

@@ -24,8 +24,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, FullyConnectedBiasFusionTest3D) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, FullyConnectedBiasFusionTest3D) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto weights = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{786, 3072}, {1});
@@ -35,16 +34,13 @@ TEST(TransformationTests, FullyConnectedBiasFusionTest3D) {
         auto const_bias = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{786}, {1});
         auto add = std::make_shared<ngraph::opset1::Add>(fc, const_bias);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input1});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input1});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::FullyConnectedBiasFusion>();
         manager.register_pass<ngraph::pass::InjectionPass>([](std::shared_ptr<ngraph::Function> f) {
             check_rt_info(f);
         });
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        ASSERT_NO_THROW(manager.run_passes(f));
     }
 
     {
@@ -53,15 +49,11 @@ TEST(TransformationTests, FullyConnectedBiasFusionTest3D) {
         auto bias = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{786}, {1});
         auto fc = std::make_shared<ngraph::op::FullyConnected>(input1, weights, bias, ngraph::Shape{1, 128, 786});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{input1});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{input1});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, FullyConnectedBiasFusionTest2D) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, FullyConnectedBiasFusionTest2D) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128});
         auto weights = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{786, 128}, {1});
@@ -71,15 +63,12 @@ TEST(TransformationTests, FullyConnectedBiasFusionTest2D) {
         auto const_bias = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{1, 786}, {1});
         auto add = std::make_shared<ngraph::opset1::Add>(fc, const_bias);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input1});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input1});
         manager.register_pass<ngraph::pass::FullyConnectedBiasFusion>();
         manager.register_pass<ngraph::pass::InjectionPass>([](std::shared_ptr<ngraph::Function> f) {
             check_rt_info(f);
         });
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        ASSERT_NO_THROW(manager.run_passes(f));
     }
 
     {
@@ -88,16 +77,12 @@ TEST(TransformationTests, FullyConnectedBiasFusionTest2D) {
         auto empty_bias = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{786}, {0});
         auto fc = std::make_shared<ngraph::op::FullyConnected>(input1, weights, empty_bias, ngraph::Shape{1, 786});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{input1});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{input1});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, FullyConnectedBiasFusionTestBias1x1) {
-    std::shared_ptr<ngraph::Function> function(nullptr), function_ref(nullptr);
+TEST_F(TransformationTestsF, FullyConnectedBiasFusionTestBias1x1) {
     {
         auto input1 = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128});
 
@@ -109,14 +94,12 @@ TEST(TransformationTests, FullyConnectedBiasFusionTestBias1x1) {
         auto add = std::make_shared<ngraph::opset1::Add>(fc, const_bias);
 
         function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input1});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+
         manager.register_pass<ngraph::pass::FullyConnectedBiasFusion>();
         manager.register_pass<ngraph::pass::InjectionPass>([](std::shared_ptr<ngraph::Function> function) {
             check_rt_info(function);
         });
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        ASSERT_NO_THROW(manager.run_passes(function));
     }
 
     {
@@ -127,9 +110,6 @@ TEST(TransformationTests, FullyConnectedBiasFusionTestBias1x1) {
 
         function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{input1});
     }
-
-    auto res = compare_functions(function, function_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 TEST(TransformationTests, FullyConnectedBiasFusionDynamic) {

inference-engine/tests/functional/inference_engine/transformations/fq_mul_fusion_test.cpp

@@ -82,15 +82,19 @@ public:
 };
 
 TEST_P(FQMulFusion, ExpectFusion) {
-  ngraph::pass::Manager manager;
-  manager.register_pass<ngraph::pass::InitNodeInfo>();
-  manager.register_pass<ngraph::pass::FakeQuantizeMulFusion>();
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+    ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
+    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    manager.register_pass<ngraph::pass::FakeQuantizeMulFusion>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
 
-  manager.run_passes(m_function);
-  ASSERT_NO_THROW(check_rt_info(m_function));
+    manager.run_passes(m_function);
+    ASSERT_NO_THROW(check_rt_info(m_function));
 
-  const auto res = compare_functions(m_function, m_expected_function);
-  ASSERT_TRUE(res.first) << res.second;
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(m_function, m_expected_function);
+    ASSERT_TRUE(res.valid) << res.message;
 };
 
 namespace {

inference-engine/tests/functional/inference_engine/transformations/fq_reshape_fusion.cpp

@@ -103,14 +103,19 @@ private:
 };
 
 TEST_P(nGraphFQReshapeFusionTests, ReshapeMatMul) {
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
     ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
     manager.register_pass<ngraph::pass::InitNodeInfo>();
     manager.register_pass<ngraph::pass::FakeQuantizeReshapeFusion>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
 
     manager.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
-    auto res = compare_functions(f, ref_f);
-    ASSERT_TRUE(res.first) << res.second;
+
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, ref_f);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 INSTANTIATE_TEST_SUITE_P(NGraph, nGraphFQReshapeFusionTests, testing::Values(
@@ -123,7 +128,7 @@ INSTANTIATE_TEST_SUITE_P(NGraph, nGraphFQReshapeFusionTests, testing::Values(
     FQReshapeFusionTestCase{{1, 2, 1, 3}, {2, 1, 1}, {1}, {1, 1}, {1, 2, 1, 1}, {6}, {}, {},  {}, {}, true}));
 }  // namespace
 
-TEST(nGraphFQReshapeFusionTests, FQReshapeGroupConvolution) {
+TEST_F(TransformationTestsF, FQReshapeGroupConvolution) {
     auto get_function = [](const FQReshapeFusionTestCase & test_case) {
         const auto & data =  std::make_shared<ngraph::opset4::Constant>(ngraph::element::f32, test_case.data_shape, 0);
         auto il = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, test_case.il_shape);
@@ -156,15 +161,9 @@ TEST(nGraphFQReshapeFusionTests, FQReshapeGroupConvolution) {
     params.oh_shape = {1, 2, 1, 1};
     params.reshape_pattern = {2, 3, 1, 1, 1};
 
-    auto f = get_function(params);
+    function = get_function(params);
 
     ngraph::pass::Manager manager;
     manager.register_pass<ngraph::pass::InitNodeInfo>();
     manager.register_pass<ngraph::pass::FakeQuantizeReshapeFusion>();
-    manager.run_passes(f);
-
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, get_function(params));
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/gather_normalize_negative_indices_test.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{1, 15, 128});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -27,13 +26,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -52,15 +47,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize) {
             throw ngraph::ngraph_error("indices should've been constant folded");
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, const_add, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_neg_axis) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_neg_axis) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{1, 15, 128});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -68,13 +59,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_neg_axis) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -93,15 +80,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_neg_axis) {
             throw ngraph::ngraph_error("indices should've been constant folded");
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, const_add, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_dif_input_types) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_dif_input_types) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{1, 15, 128});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -109,13 +92,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_dif_input_types) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -134,15 +113,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_dif_input_types) {
             throw ngraph::ngraph_error("indices should've been constant folded");
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, const_add, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_static_axis_dim) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_static_axis_dim) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::PartialShape{DYN, 15, DYN});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -150,13 +125,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_static_axis_dim) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -172,15 +143,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_static_axis_dim) {
         auto add = std::make_shared<ngraph::opset7::Add>(input_gather, indices);
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, add, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_static_axis_dim_neg_axis) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_static_axis_dim_neg_axis) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::PartialShape{DYN, 15, DYN});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -188,13 +155,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_static_axis_dim_neg_axi
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -210,15 +173,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_static_axis_dim_neg_axi
         auto add = std::make_shared<ngraph::opset7::Add>(input_gather, indices);
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, add, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_non_static_axis_dim) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_non_static_axis_dim) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::PartialShape{DYN, DYN, DYN});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -226,13 +185,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_non_static_axis_dim) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -244,15 +199,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_non_static_axis_dim) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_positive_ind) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_positive_ind) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{2, 3});
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {1});
@@ -260,13 +211,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_positive_ind) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -276,15 +223,11 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_positive_ind) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GatherNegativeIndicesNormalize_non_static_rank) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GatherNegativeIndicesNormalize_non_static_rank) {
     {
         auto data = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(ngraph::Rank::dynamic()));
         auto indices = ngraph::opset7::Constant::create(ngraph::element::i32, ngraph::Shape{}, {-1});
@@ -292,13 +235,9 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_non_static_rank) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -308,9 +247,6 @@ TEST(TransformationTests, GatherNegativeIndicesNormalize_non_static_rank) {
 
         auto gather = std::make_shared<ngraph::opset7::Gather>(data, indices, axis);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gather}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/gelu7_downgrade.cpp

@@ -16,35 +16,21 @@
 
 using namespace testing;
 
-TEST(TransformationTests, Gelu7Downgrade) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, Gelu7Downgrade) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
         auto gelu = std::make_shared<ngraph::opset7::Gelu>(input, ngraph::op::GeluApproximationMode::ERF);
-        gelu->set_friendly_name("gelu7");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{gelu}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{gelu}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::Gelu7Downgrade>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{1, 2, 3});
         auto gelu = std::make_shared<ngraph::opset2::Gelu>(input);
-        gelu->set_friendly_name("gelu7");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gelu}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{gelu}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "gelu7") << "Transformation Gelu7Downgrade should keep output names.\n";
 }
 

inference-engine/tests/functional/inference_engine/transformations/gelu_fusion.cpp

@@ -23,8 +23,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, GeluFusionPatternOne) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GeluFusionPatternOne) {
     {
         auto data =
             std::make_shared<opset7::Parameter>(element::f32, Shape{2, 2});
@@ -42,29 +41,21 @@ TEST(TransformationTests, GeluFusionPatternOne) {
         auto mul_first = std::make_shared<opset7::Multiply>(data, mul_const);
         auto mul = std::make_shared<opset7::Multiply>(mul_first, add);
 
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GeluFusionWithErfOne>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GeluFusionWithErfOne>();
     }
 
     {
         auto data =
             std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto gelu = std::make_shared<opset7::Gelu>(data);
-        f_ref =
+        function_ref =
             std::make_shared<Function>(NodeVector{gelu}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GeluFusionPatternTwo) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GeluFusionPatternTwo) {
     {
         auto data =
             std::make_shared<opset7::Parameter>(element::f32, Shape{2, 2});
@@ -82,29 +73,21 @@ TEST(TransformationTests, GeluFusionPatternTwo) {
         auto mul_first = std::make_shared<opset7::Multiply>(data, add);
         auto mul = std::make_shared<opset7::Multiply>(mul_first, mul_const);
 
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GeluFusionWithErfTwo>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GeluFusionWithErfTwo>();
     }
 
     {
         auto data =
             std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto gelu = std::make_shared<opset7::Gelu>(data);
-        f_ref =
+        function_ref =
             std::make_shared<Function>(NodeVector{gelu}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GeluFusionPatternThree) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GeluFusionPatternThree) {
     {
         auto data =
             std::make_shared<opset7::Parameter>(element::f32, Shape{2, 2});
@@ -122,29 +105,21 @@ TEST(TransformationTests, GeluFusionPatternThree) {
         auto mul_first = std::make_shared<opset7::Multiply>(add, mul_const);
         auto mul = std::make_shared<opset7::Multiply>(data, mul_first);
 
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GeluFusionWithErfThree>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GeluFusionWithErfThree>();
     }
 
     {
         auto data =
             std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto gelu = std::make_shared<opset7::Gelu>(data);
-        f_ref =
+        function_ref =
             std::make_shared<Function>(NodeVector{gelu}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GeluFusionPatternIncorrectDivConstValue) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GeluFusionPatternIncorrectDivConstValue) {
     {
         auto data =
             std::make_shared<opset7::Parameter>(element::f32, Shape{2, 2});
@@ -162,23 +137,15 @@ TEST(TransformationTests, GeluFusionPatternIncorrectDivConstValue) {
         auto mul_first = std::make_shared<opset7::Multiply>(data, add);
         auto mul = std::make_shared<opset7::Multiply>(mul_first, mul_const);
 
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
-        f_ref =
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function_ref =
             std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GeluFusionWithErfTwo>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GeluFusionWithErfTwo>();
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, GeluFusionPatternTooShortDivConstValue) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, GeluFusionPatternTooShortDivConstValue) {
     {
         auto data =
             std::make_shared<opset7::Parameter>(element::f32, Shape{2, 2});
@@ -196,17 +163,10 @@ TEST(TransformationTests, GeluFusionPatternTooShortDivConstValue) {
         auto mul_first = std::make_shared<opset7::Multiply>(data, add);
         auto mul = std::make_shared<opset7::Multiply>(mul_first, mul_const);
 
-        f = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
-        f_ref =
+        function = std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
+        function_ref =
             std::make_shared<Function>(NodeVector{mul}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::GeluFusionWithErfTwo>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::GeluFusionWithErfTwo>();
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/hsigmoid_decomposition_test.cpp

@@ -18,19 +18,14 @@
 
 using namespace testing;
 
-TEST(TransformationTests, HSigmoidDecompositionTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidDecompositionTest) {
     {
         auto input = std::make_shared<ngraph::opset5::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset5::HSigmoid>(input);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidDecomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -43,9 +38,6 @@ TEST(TransformationTests, HSigmoidDecompositionTest) {
         auto mul_constant = ngraph::opset5::Constant::create(ngraph::element::f32, ngraph::Shape{}, {(1.0/6.0)});  // const(1/6)
         auto mul = std::make_shared<ngraph::opset5::Multiply>(min, mul_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/hsigmoid_fusion_test.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, HSigmoidFusionWithReluDivF16) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithReluDivF16) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -30,28 +29,20 @@ TEST(TransformationTests, HSigmoidFusionWithReluDivF16) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithReluDivF32) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithReluDivF32) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{});
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f32, ngraph::Shape{}, {3.0});
@@ -62,28 +53,20 @@ TEST(TransformationTests, HSigmoidFusionWithReluDivF32) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f32, ngraph::Shape{}, {6.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{});
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithReluMul) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithReluMul) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -94,28 +77,20 @@ TEST(TransformationTests, HSigmoidFusionWithReluMul) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.1666666716});
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(min, mul_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithoutRelu) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithoutRelu) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -127,28 +102,20 @@ TEST(TransformationTests, HSigmoidFusionWithoutRelu) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithClampMul) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithClampMul) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -157,28 +124,20 @@ TEST(TransformationTests, HSigmoidFusionWithClampMul) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {1.0 / 6.0});
         auto mul_first = std::make_shared<ngraph::opset7::Multiply>(clamp, mul_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_first}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_first}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithClampDiv) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithClampDiv) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset6::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -187,28 +146,20 @@ TEST(TransformationTests, HSigmoidFusionWithClampDiv) {
         auto div_constant = ngraph::opset6::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.0});
         auto div = std::make_shared<ngraph::opset6::Divide>(clamp, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hsigmoid}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithReluMulWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithReluMulWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -219,13 +170,9 @@ TEST(TransformationTests, HSigmoidFusionWithReluMulWrongConstValue) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.167});
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(min, mul_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -238,15 +185,11 @@ TEST(TransformationTests, HSigmoidFusionWithReluMulWrongConstValue) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.167});
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(min, mul_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithReluDivWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithReluDivWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::Shape{});
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.01});
@@ -257,13 +200,9 @@ TEST(TransformationTests, HSigmoidFusionWithReluDivWrongConstValue) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -276,15 +215,11 @@ TEST(TransformationTests, HSigmoidFusionWithReluDivWrongConstValue) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithoutReluWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithoutReluWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.11});
@@ -296,13 +231,9 @@ TEST(TransformationTests, HSigmoidFusionWithoutReluWrongConstValue) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.002});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -316,15 +247,11 @@ TEST(TransformationTests, HSigmoidFusionWithoutReluWrongConstValue) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.002});
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSigmoidFusionWithClampWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSigmoidFusionWithClampWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.11});
@@ -333,13 +260,9 @@ TEST(TransformationTests, HSigmoidFusionWithClampWrongConstValue) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.98 / 6.15});
         auto mul_first = std::make_shared<ngraph::opset7::Multiply>(clamp, mul_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_first}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_first}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSigmoidFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -350,9 +273,6 @@ TEST(TransformationTests, HSigmoidFusionWithClampWrongConstValue) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.98 / 6.15});
         auto mul_first = std::make_shared<ngraph::opset7::Multiply>(clamp, mul_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_first}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_first}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/hswish_decomposition_test.cpp

@@ -18,19 +18,14 @@
 
 using namespace testing;
 
-TEST(TransformationTests, HSwishDecompositionTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishDecompositionTest) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset4::HSwish>(input);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishDecomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -44,9 +39,6 @@ TEST(TransformationTests, HSwishDecompositionTest) {
         auto mul_constant = ngraph::opset4::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.1666666716});
         auto mul_second = std::make_shared<ngraph::opset4::Multiply>(mul_first, mul_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/hswish_fusion_test.cpp

@@ -19,8 +19,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, HSwishFusionWithReluDivF16) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithReluDivF16) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -32,28 +31,20 @@ TEST(TransformationTests, HSwishFusionWithReluDivF16) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(mul, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithReluDivF32) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithReluDivF32) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{});
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f32, ngraph::Shape{}, {3.0});
@@ -65,28 +56,20 @@ TEST(TransformationTests, HSwishFusionWithReluDivF32) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f32, ngraph::Shape{}, {6.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(mul, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{});
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithReluMul) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithReluMul) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -98,28 +81,20 @@ TEST(TransformationTests, HSwishFusionWithReluMul) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.1666666716});
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(mul_first, mul_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithoutRelu) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithoutRelu) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -132,30 +107,22 @@ TEST(TransformationTests, HSwishFusionWithoutRelu) {
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSigmoidFusion>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithClampMul) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithClampMul) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -165,30 +132,22 @@ TEST(TransformationTests, HSwishFusionWithClampMul) {
         auto mul_first = std::make_shared<ngraph::opset7::Multiply>(clamp, mul_constant);
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(input, mul_first);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSigmoidFusion>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithClampDiv) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithClampDiv) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -198,30 +157,22 @@ TEST(TransformationTests, HSwishFusionWithClampDiv) {
         auto div = std::make_shared<ngraph::opset7::Divide>(clamp, div_constant);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSigmoidFusion>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithReluMulWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithReluMulWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -233,13 +184,9 @@ TEST(TransformationTests, HSwishFusionWithReluMulWrongConstValue) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.167});
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(mul_first, mul_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -253,15 +200,11 @@ TEST(TransformationTests, HSwishFusionWithReluMulWrongConstValue) {
         auto mul_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.167});
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(mul_first, mul_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithReluDivWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithReluDivWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::Shape{});
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.01});
@@ -273,13 +216,9 @@ TEST(TransformationTests, HSwishFusionWithReluDivWrongConstValue) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(mul, div_constant);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -293,15 +232,11 @@ TEST(TransformationTests, HSwishFusionWithReluDivWrongConstValue) {
         auto div_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {0.0});
         auto div = std::make_shared<ngraph::opset7::Divide>(mul, div_constant);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithoutReluWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithoutReluWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.11});
@@ -314,15 +249,11 @@ TEST(TransformationTests, HSwishFusionWithoutReluWrongConstValue) {
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSigmoidFusion>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -337,15 +268,11 @@ TEST(TransformationTests, HSwishFusionWithoutReluWrongConstValue) {
         auto div = std::make_shared<ngraph::opset7::Divide>(min, div_constant);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, div);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithClampWrongConstValue) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithClampWrongConstValue) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.11});
@@ -355,15 +282,11 @@ TEST(TransformationTests, HSwishFusionWithClampWrongConstValue) {
         auto mul_first = std::make_shared<ngraph::opset7::Multiply>(clamp, mul_constant);
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(input, mul_first);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSigmoidFusion>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -375,43 +298,31 @@ TEST(TransformationTests, HSwishFusionWithClampWrongConstValue) {
         auto mul_first = std::make_shared<ngraph::opset7::Multiply>(clamp, mul_constant);
         auto mul_second = std::make_shared<ngraph::opset7::Multiply>(input, mul_first);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul_second}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithHSigmoidMul) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithHSigmoidMul) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hsigmoid = std::make_shared<ngraph::opset7::HSigmoid>(input);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, hsigmoid);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto hswish = std::make_shared<ngraph::opset7::HSwish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{hswish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, HSwishFusionWithClamp) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithClamp) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.0});
@@ -419,14 +330,10 @@ TEST(TransformationTests, HSwishFusionWithClamp) {
         auto clamp = std::make_shared<ngraph::opset7::Clamp>(add, 0.0f, 6.0f);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, clamp);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -435,15 +342,11 @@ TEST(TransformationTests, HSwishFusionWithClamp) {
         auto mul_const = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {6.0});
         auto mul = std::make_shared<ngraph::opset7::Multiply>(hswish, mul_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, HSwishFusionWithClampWithWrongConstant) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, HSwishFusionWithClampWithWrongConstant) {
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto add_constant = ngraph::opset7::Constant::create(ngraph::element::f16, ngraph::Shape{}, {3.11});
@@ -451,14 +354,10 @@ TEST(TransformationTests, HSwishFusionWithClampWithWrongConstant) {
         auto clamp = std::make_shared<ngraph::opset7::Clamp>(add, 0.11f, 6.32f);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, clamp);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         auto gr = manager.register_pass<ngraph::pass::GraphRewrite>();
         gr->add_matcher<ngraph::pass::HSwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -468,9 +367,6 @@ TEST(TransformationTests, HSwishFusionWithClampWithWrongConstant) {
         auto clamp = std::make_shared<ngraph::opset7::Clamp>(add, 0.11f, 6.32f);
         auto mul = std::make_shared<ngraph::opset7::Multiply>(input, clamp);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/leaky_relu_fusion.cpp

@@ -22,83 +22,59 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, LeakyReluFusionConstant) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, LeakyReluFusionConstant) {
     {
         auto data = std::make_shared<opset8::Parameter>(element::f32, Shape{2, 2});
         auto alpha = opset8::Constant::create(element::f32, Shape{1}, {0.1});
         auto multiply = std::make_shared<opset8::Multiply>(data, alpha);
         auto max = std::make_shared<opset8::Maximum>(data, multiply);
-        f = std::make_shared<Function>(NodeVector{max}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{max}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::LeakyReluFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::LeakyReluFusion>();
     }
 
     {
         auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto alpha = opset8::Constant::create(element::f32, Shape{1}, {0.1});
         auto leaky_relu = std::make_shared<opset8::PRelu>(data, alpha);
-        f_ref = std::make_shared<Function>(NodeVector{leaky_relu}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{leaky_relu}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, LeakyReluFusionScalar) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, LeakyReluFusionScalar) {
     {
         auto data = std::make_shared<opset8::Parameter>(element::f32, Shape{2, 2});
         auto alpha = opset8::Constant::create(element::f32, Shape{}, {0.1});
         auto multiply = std::make_shared<opset8::Multiply>(data, alpha);
         auto max = std::make_shared<opset8::Maximum>(data, multiply);
-        f = std::make_shared<Function>(NodeVector{max}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{max}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::LeakyReluFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::LeakyReluFusion>();
     }
 
     {
         auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto alpha = opset8::Constant::create(element::f32, Shape{}, {0.1});
         auto leaky_relu = std::make_shared<opset8::PRelu>(data, alpha);
-        f_ref = std::make_shared<Function>(NodeVector{leaky_relu}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{leaky_relu}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, LeakyReluFusionParameter) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, LeakyReluFusionParameter) {
     {
         auto data = std::make_shared<opset8::Parameter>(element::f32, Shape{2, 2});
         auto alpha = std::make_shared<opset8::Parameter>(element::f32, Shape{});
         auto multiply = std::make_shared<opset8::Multiply>(data, alpha);
         auto max = std::make_shared<opset8::Maximum>(data, multiply);
-        f = std::make_shared<Function>(NodeVector{max}, ParameterVector{data, alpha});
+        function = std::make_shared<Function>(NodeVector{max}, ParameterVector{data, alpha});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::LeakyReluFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::LeakyReluFusion>();
     }
 
     {
         auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{2, 2});
         auto alpha = std::make_shared<opset8::Parameter>(element::f32, Shape{});
         auto leaky_relu = std::make_shared<opset8::PRelu>(data, alpha);
-        f_ref = std::make_shared<Function>(NodeVector{leaky_relu}, ParameterVector{data, alpha});
+        function_ref = std::make_shared<Function>(NodeVector{leaky_relu}, ParameterVector{data, alpha});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/lin_op_sequence_fusion_test.cpp

@@ -25,9 +25,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, MulAddMulAddFusion) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulAddMulAddFusion) {
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto mul1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {2});
@@ -40,15 +38,10 @@ TEST(TransformationTests, MulAddMulAddFusion) {
         auto mul2 = std::make_shared<opset3::Multiply>(add1, mul2_const);
         auto add2 = std::make_shared<opset3::Add>(mul2, add2_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add2}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add2}, ngraph::ParameterVector{input});
+        manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
     }
 
-    pass::Manager manager;
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
-    manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
-    manager.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto mul1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {6});
@@ -57,16 +50,11 @@ TEST(TransformationTests, MulAddMulAddFusion) {
         auto mul1 = std::make_shared<opset3::Multiply>(input, mul1_const);
         auto add1 = std::make_shared<opset3::Add>(mul1, add1_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{add1}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{add1}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MulMulMulFusion) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulMulMulFusion) {
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto mul1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {2});
@@ -77,14 +65,10 @@ TEST(TransformationTests, MulMulMulFusion) {
         auto mul2 = std::make_shared<opset3::Multiply>(mul1, mul2_const);
         auto mul3 = std::make_shared<opset3::Multiply>(mul2, mul3_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul2}, ngraph::ParameterVector{input});
-    }
 
-    pass::Manager manager;
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
-    manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
-    manager.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul2}, ngraph::ParameterVector{input});
+        manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
+    }
 
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
@@ -92,16 +76,11 @@ TEST(TransformationTests, MulMulMulFusion) {
 
         auto mul1 = std::make_shared<opset3::Multiply>(input, mul1_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul1}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul1}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, AddAddAddFusion) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, AddAddAddFusion) {
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto add1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {2});
@@ -112,31 +91,21 @@ TEST(TransformationTests, AddAddAddFusion) {
         auto add2 = std::make_shared<opset3::Add>(add1, add2_const);
         auto add3 = std::make_shared<opset3::Add>(add2, add3_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add3}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add3}, ngraph::ParameterVector{input});
+        manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
     }
 
-    pass::Manager manager;
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
-    manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
-    manager.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto add1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {8});
 
         auto add1 = std::make_shared<opset3::Add>(input, add1_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{add1}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{add1}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MulAddAddMulFusion) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulAddAddMulFusion) {
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto mul1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {2});
@@ -149,15 +118,10 @@ TEST(TransformationTests, MulAddAddMulFusion) {
         auto add2 = std::make_shared<opset3::Add>(add1, add2_const);
         auto mul2 = std::make_shared<opset3::Multiply>(add2, mul2_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul2}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul2}, ngraph::ParameterVector{input});
+        manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
     }
 
-    pass::Manager manager;
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
-    manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
-    manager.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-
     {
         auto input = std::make_shared<opset3::Parameter>(ngraph::element::f32, ngraph::Shape{1, 128, 3072});
         auto mul1_const = opset3::Constant::create(ngraph::element::f32, ngraph::Shape{128, 1}, {10});
@@ -166,9 +130,6 @@ TEST(TransformationTests, MulAddAddMulFusion) {
         auto mul1 = std::make_shared<opset3::Multiply>(input, mul1_const);
         auto add1 = std::make_shared<opset3::Add>(mul1, add1_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{add1}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{add1}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/log_softmax_decomposition_test.cpp

@@ -18,23 +18,18 @@
 
 using namespace testing;
 
-TEST(TransformationTests, LogSoftmaxDecomposition) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, LogSoftmaxDecomposition) {
     {
         auto data = std::make_shared<ngraph::opset5::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2});
         auto log_softmax = std::make_shared<ngraph::opset5::LogSoftmax>(data, 1);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{log_softmax}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{log_softmax}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::LogSoftmaxDecomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
-        auto input0 = std::make_shared<ngraph::opset5::Parameter>(ngraph::element::f64, ngraph::Shape{3, 2});
+        auto input0 = std::make_shared<ngraph::opset5::Parameter>(ngraph::element::f32, ngraph::Shape{3, 2});
         auto axis1_const = ngraph::opset5::Constant::create(ngraph::element::i64, ngraph::Shape{1}, {1});
         auto max = std::make_shared<ngraph::opset5::ReduceMax>(input0, axis1_const, true);
         auto sub = std::make_shared<ngraph::opset5::Subtract>(input0, max);
@@ -44,9 +39,6 @@ TEST(TransformationTests, LogSoftmaxDecomposition) {
         auto log = std::make_shared<ngraph::opset5::Log>(sum);
         auto sub_end = std::make_shared<ngraph::opset5::Subtract>(sub, log);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sub_end}, ngraph::ParameterVector{input0});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sub_end}, ngraph::ParameterVector{input0});
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/mish_fusion_test.cpp

@@ -21,8 +21,7 @@ using namespace testing;
 
 // LPT to nGraph migration: temporary disabling unexpected not reproduced fails on CI:
 // https://openvino-ci.intel.com/job/private-ci/job/ie/job/build-linux-ubuntu18_i386/478/
-TEST(TransformationTests, MishFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MishFusing) {
     {
         auto input0 = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f64, ngraph::Shape{3, 1, 2});
         auto exp = std::make_shared<ngraph::opset4::Exp>(input0);
@@ -32,51 +31,36 @@ TEST(TransformationTests, MishFusing) {
         auto tanh = std::make_shared<ngraph::opset4::Tanh>(log);
         auto mul = std::make_shared<ngraph::opset4::Multiply>(input0, tanh);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input0});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f64, ngraph::Shape{3, 1, 2});
         auto mish = std::make_shared<ngraph::opset4::Mish>(data);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mish}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mish}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, MishWithSoftPlusFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MishWithSoftPlusFusing) {
     {
         auto input0 = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f64, ngraph::Shape{3, 1, 2});
         auto softplus = std::make_shared<ngraph::opset4::SoftPlus>(input0);
         auto tanh = std::make_shared<ngraph::opset4::Tanh>(softplus);
         auto mul = std::make_shared<ngraph::opset4::Multiply>(input0, tanh);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input0});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SoftPlusToMishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f64, ngraph::Shape{3, 1, 2});
         auto mish = std::make_shared<ngraph::opset4::Mish>(data);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mish}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mish}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/mul_add_conversion_test.cpp

@@ -141,25 +141,39 @@ public:
 class MulOrAddConversionTests: public MulAddConversionTests {};
 
 TEST_P(MulAddConversionTests, CompareFunctions) {
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+
     ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
     manager.register_pass<ngraph::pass::InitNodeInfo>();
     manager.register_pass<ngraph::pass::ConvertMulAddToScaleShiftOrPower>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
     manager.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
     ngraph::pass::ConstantFolding().run_on_function(f);
     f->validate_nodes_and_infer_types();
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 TEST_P(MulOrAddConversionTests, CompareFunctions) {
-    ngraph::pass::InitNodeInfo().run_on_function(f);
-    ngraph::pass::ConvertMulOrAddFinally().run_on_function(f);
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+
+    ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
+    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    manager.register_pass<ngraph::pass::ConvertMulOrAddFinally>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+    manager.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
     ngraph::pass::ConstantFolding().run_on_function(f);
     f->validate_nodes_and_infer_types();
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 #define CONST(A, B) ConstantParams(A, B)

inference-engine/tests/functional/inference_engine/transformations/mul_fake_quantize_fusion.cpp

@@ -23,9 +23,7 @@ using namespace testing;
 using namespace ngraph;
 
 
-TEST(TransformationTests, MulFakeQuantizeFusionPositiveConstant) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulFakeQuantizeFusionPositiveConstant) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -38,12 +36,8 @@ TEST(TransformationTests, MulFakeQuantizeFusionPositiveConstant) {
         auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::MulFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::MulFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -54,16 +48,11 @@ TEST(TransformationTests, MulFakeQuantizeFusionPositiveConstant) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MulFakeQuantizeFusionConstantOnFirstInput) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulFakeQuantizeFusionConstantOnFirstInput) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -76,12 +65,8 @@ TEST(TransformationTests, MulFakeQuantizeFusionConstantOnFirstInput) {
         auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::MulFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::MulFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -92,16 +77,11 @@ TEST(TransformationTests, MulFakeQuantizeFusionConstantOnFirstInput) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MulFakeQuantizeFusionReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulFakeQuantizeFusionReshape) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -114,12 +94,8 @@ TEST(TransformationTests, MulFakeQuantizeFusionReshape) {
         auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::MulFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::MulFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -130,16 +106,11 @@ TEST(TransformationTests, MulFakeQuantizeFusionReshape) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MulFakeQuantizeFusionConstantNonScalarWithEqualValues) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, MulFakeQuantizeFusionConstantNonScalarWithEqualValues) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -152,12 +123,8 @@ TEST(TransformationTests, MulFakeQuantizeFusionConstantNonScalarWithEqualValues)
         auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::MulFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::MulFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -168,16 +135,11 @@ TEST(TransformationTests, MulFakeQuantizeFusionConstantNonScalarWithEqualValues)
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeMulFakeQuantizeFusionNotAConstant) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeMulFakeQuantizeFusionNotAConstant) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -190,12 +152,8 @@ TEST(TransformationTests, NegativeMulFakeQuantizeFusionNotAConstant) {
         auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, mul_2nd_input});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::MulFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, mul_2nd_input});
+        manager.register_pass<pass::MulFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -208,16 +166,11 @@ TEST(TransformationTests, NegativeMulFakeQuantizeFusionNotAConstant) {
         auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, mul_2nd_input});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data, mul_2nd_input});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeMulFakeQuantizeFusionLowPrecision) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeMulFakeQuantizeFusionLowPrecision) {
     Shape data_shape{1, 3, 14, 14};
     auto data = std::make_shared<opset5::Parameter>(element::f16, data_shape);
     auto mul_const = opset5::Constant::create(element::f16, Shape{1}, {2});
@@ -229,21 +182,12 @@ TEST(TransformationTests, NegativeMulFakeQuantizeFusionLowPrecision) {
     auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                      input_high, output_low,
                                                      output_high, 11);
-    f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-    f_ref = clone_function(*f);
-    pass::Manager m;
-    m.register_pass<pass::InitNodeInfo>();
-    m.register_pass<pass::MulFakeQuantizeFusion>();
-    m.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+    function_ref = clone_function(*function);
+    manager.register_pass<pass::MulFakeQuantizeFusion>();
 }
 
-TEST(TransformationTests, NegativeMulFakeQuantizeFusionConstantAllNegative) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeMulFakeQuantizeFusionConstantAllNegative) {
     Shape data_shape{1, 3, 14, 14};
     auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
     auto mul_const = opset5::Constant::create(element::f32, Shape{1}, {-2});
@@ -255,20 +199,12 @@ TEST(TransformationTests, NegativeMulFakeQuantizeFusionConstantAllNegative) {
     auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                      input_high, output_low,
                                                      output_high, 11);
-    f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-    f_ref = clone_function(*f);
-    pass::Manager m;
-    m.register_pass<pass::InitNodeInfo>();
-    m.register_pass<pass::MulFakeQuantizeFusion>();
-    m.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+    function_ref = clone_function(*function);
+    manager.register_pass<pass::MulFakeQuantizeFusion>();
 }
 
-TEST(TransformationTests, NegativeMulFakeQuantizeFusionConstantSomeNegative) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativeMulFakeQuantizeFusionConstantSomeNegative) {
     Shape data_shape{1, 3, 14, 14};
     auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
     auto mul_const = opset5::Constant::create(element::f32, Shape{3, 1, 1}, {2, 1, -2});
@@ -280,13 +216,7 @@ TEST(TransformationTests, NegativeMulFakeQuantizeFusionConstantSomeNegative) {
     auto fq = std::make_shared<opset5::FakeQuantize>(mul, input_low,
                                                      input_high, output_low,
                                                      output_high, 20);
-    f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-    f_ref = clone_function(*f);
-    pass::Manager m;
-    m.register_pass<pass::InitNodeInfo>();
-    m.register_pass<pass::MulFakeQuantizeFusion>();
-    m.run_passes(f);
-    ASSERT_NO_THROW(check_rt_info(f));
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+    function_ref = clone_function(*function);
+    manager.register_pass<pass::MulFakeQuantizeFusion>();
 }

inference-engine/tests/functional/inference_engine/transformations/mvn6_decomposition_test.cpp

@@ -18,20 +18,15 @@
 
 using namespace testing;
 
-TEST(TransformationTests, MVN6Decomposition_No_Variance) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVN6Decomposition_No_Variance) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 3, 4 });
         auto axes_const = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 2 }, { 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(data, axes_const, false, 1e-5, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVN6Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -40,27 +35,19 @@ TEST(TransformationTests, MVN6Decomposition_No_Variance) {
         auto mean = std::make_shared<ngraph::opset6::ReduceMean>(input0, axes_const, true);
         auto mean_normalization = std::make_shared<ngraph::opset6::Subtract>(input0, mean);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mean_normalization }, ngraph::ParameterVector{ input0 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mean_normalization }, ngraph::ParameterVector{ input0 });
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVN6Decomposition_Inside_Sqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVN6Decomposition_Inside_Sqrt) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 3, 4 });
         auto axes_const = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 2 }, { 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(data, axes_const, true, 1e-5, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVN6Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -79,27 +66,19 @@ TEST(TransformationTests, MVN6Decomposition_Inside_Sqrt) {
         auto sqrt = std::make_shared<ngraph::opset6::Sqrt>(eps_add);
         auto div = std::make_shared<ngraph::opset6::Divide>(mean_normalization, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input0 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input0 });
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVN6Decomposition_Outside_Sqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVN6Decomposition_Outside_Sqrt) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 3, 4 });
         auto axes_const = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 2 }, { 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(data, axes_const, true, 1e-5, ngraph::op::MVNEpsMode::OUTSIDE_SQRT);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ data });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVN6Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -118,9 +97,6 @@ TEST(TransformationTests, MVN6Decomposition_Outside_Sqrt) {
         auto eps_add = std::make_shared<ngraph::opset6::Add>(sqrt, eps_node);
         auto div = std::make_shared<ngraph::opset6::Divide>(mean_normalization, eps_add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input0 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input0 });
     }
-
-    auto res = compare_functions(f, f_ref, false, false, false, false);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/mvn_fusion_test.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, MVNFusionTestOutside) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestOutside) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -40,13 +39,9 @@ TEST(TransformationTests, MVNFusionTestOutside) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(add_eps, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -54,15 +49,11 @@ TEST(TransformationTests, MVNFusionTestOutside) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::OUTSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestReuseSub) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestReuseSub) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -80,13 +71,9 @@ TEST(TransformationTests, MVNFusionTestReuseSub) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(add_eps, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -94,15 +81,11 @@ TEST(TransformationTests, MVNFusionTestReuseSub) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::OUTSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestWithConvert) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestWithConvert) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -121,13 +104,9 @@ TEST(TransformationTests, MVNFusionTestWithConvert) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(add_eps, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -135,15 +114,11 @@ TEST(TransformationTests, MVNFusionTestWithConvert) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::OUTSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestSqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestSqrt) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -160,13 +135,9 @@ TEST(TransformationTests, MVNFusionTestSqrt) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(add_eps, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -174,15 +145,11 @@ TEST(TransformationTests, MVNFusionTestSqrt) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::OUTSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestAltDiv) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestAltDiv) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -198,13 +165,9 @@ TEST(TransformationTests, MVNFusionTestAltDiv) {
         auto add_eps = std::make_shared<ngraph::opset6::Add>(power_sqrt, eps);
         auto div = std::make_shared<ngraph::opset6::Divide>(sub1, add_eps);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -212,15 +175,11 @@ TEST(TransformationTests, MVNFusionTestAltDiv) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::OUTSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestInsideSqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestInsideSqrt) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -241,13 +200,9 @@ TEST(TransformationTests, MVNFusionTestInsideSqrt) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(power_sqrt, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -255,15 +210,11 @@ TEST(TransformationTests, MVNFusionTestInsideSqrt) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestReuseSubInsideSqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestReuseSubInsideSqrt) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -281,13 +232,9 @@ TEST(TransformationTests, MVNFusionTestReuseSubInsideSqrt) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(power_sqrt, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -295,15 +242,11 @@ TEST(TransformationTests, MVNFusionTestReuseSubInsideSqrt) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestWithConvertInsideSqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestWithConvertInsideSqrt) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -322,13 +265,9 @@ TEST(TransformationTests, MVNFusionTestWithConvertInsideSqrt) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(power_sqrt, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -336,15 +275,11 @@ TEST(TransformationTests, MVNFusionTestWithConvertInsideSqrt) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestSqrtInsideSqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestSqrtInsideSqrt) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -361,13 +296,9 @@ TEST(TransformationTests, MVNFusionTestSqrtInsideSqrt) {
         auto power_div = std::make_shared<ngraph::opset6::Power>(power_sqrt, const_neg_1);
         auto div = std::make_shared<ngraph::opset6::Multiply>(sub1, power_div);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -375,15 +306,11 @@ TEST(TransformationTests, MVNFusionTestSqrtInsideSqrt) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestAltDivInsideSqrt) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestAltDivInsideSqrt) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
@@ -399,13 +326,9 @@ TEST(TransformationTests, MVNFusionTestAltDivInsideSqrt) {
         auto power_sqrt = std::make_shared<ngraph::opset6::Power>(add_eps, const_0_5);
         auto div = std::make_shared<ngraph::opset6::Divide>(sub1, power_sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ div }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -413,15 +336,11 @@ TEST(TransformationTests, MVNFusionTestAltDivInsideSqrt) {
         auto axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 3 }, { 1, 2, 3 });
         auto mvn = std::make_shared<ngraph::opset6::MVN>(input, axes, true, 1e-9, ngraph::op::MVNEpsMode::INSIDE_SQRT);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ mvn }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, MVNFusionTestWithParametersInside) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MVNFusionTestWithParametersInside) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 224 });
         auto mean1_axes = ngraph::opset6::Constant::create(ngraph::element::i32, ngraph::Shape{ 1 }, { 2 });
@@ -441,13 +360,9 @@ TEST(TransformationTests, MVNFusionTestWithParametersInside) {
         auto sub = std::make_shared<ngraph::opset6::Subtract>(beta, mul2);
         auto add = std::make_shared<ngraph::opset6::Add>(mul1, sub);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::MVNFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -459,9 +374,6 @@ TEST(TransformationTests, MVNFusionTestWithParametersInside) {
         auto beta = ngraph::opset6::Constant::create(ngraph::element::f32, ngraph::Shape{}, { -1 });
         auto add = std::make_shared<ngraph::opset6::Add>(mul_gamma, beta);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/ngraph_1d_ops_reshape_test.cpp

@@ -89,8 +89,7 @@ TEST(TransformationTests, ConvBiasReshapeTest1) {
     }
 }
 
-TEST(TransformationTests, MaxPoolReshapeTest1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, MaxPoolReshapeTest1) {
     {
         auto input = std::make_shared<opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 64});
 
@@ -98,10 +97,8 @@ TEST(TransformationTests, MaxPoolReshapeTest1) {
         ngraph::Shape pads_begin{0}, pads_end{0}, kernel{3};
         auto pool = std::make_shared<ngraph::opset1::MaxPool>(input, strides, pads_begin, pads_end, kernel, ngraph::op::RoundingType::FLOOR);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{pool}, ngraph::ParameterVector{input});
-        ngraph::pass::InitNodeInfo().run_on_function(f);
-        ngraph::pass::Reshape1DOps().run_on_function(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{pool}, ngraph::ParameterVector{input});
+        manager.register_pass<ngraph::pass::Reshape1DOps>();
     }
 
     {
@@ -115,15 +112,11 @@ TEST(TransformationTests, MaxPoolReshapeTest1) {
 
         auto reshape_end = std::make_shared<opset1::Reshape>(pool, opset1::Constant::create(element::i64, Shape{3}, {1, 3, 62}), true);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_end}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_end}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, AvgPoolReshapeTest1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, AvgPoolReshapeTest1) {
     {
         auto input = std::make_shared<opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 64});
 
@@ -131,10 +124,8 @@ TEST(TransformationTests, AvgPoolReshapeTest1) {
         ngraph::Shape pads_begin{0}, pads_end{0}, kernel{3};
         auto pool = std::make_shared<ngraph::opset1::AvgPool>(input, strides, pads_begin, pads_end, kernel, false, ngraph::op::RoundingType::FLOOR);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{pool}, ngraph::ParameterVector{input});
-        ngraph::pass::InitNodeInfo().run_on_function(f);
-        ngraph::pass::Reshape1DOps().run_on_function(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{pool}, ngraph::ParameterVector{input});
+        manager.register_pass<ngraph::pass::Reshape1DOps>();
     }
 
     {
@@ -148,11 +139,8 @@ TEST(TransformationTests, AvgPoolReshapeTest1) {
 
         auto reshape_end = std::make_shared<opset1::Reshape>(pool, opset1::Constant::create(element::i64, Shape{3}, {1, 3, 62}), true);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_end}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reshape_end}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 TEST(TransformationTests, ReshapeDynamicTest1) {

inference-engine/tests/functional/inference_engine/transformations/ngraph_fq_transpose_test.cpp

@@ -23,8 +23,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, FQTransposeTest1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, FQTransposeTest1) {
     {
         auto data = ngraph::op::Constant::create(ngraph::element::f32, ngraph::Shape{1, 1, 3}, {1, 2, 3});
         auto input_low = ngraph::op::Constant::create(ngraph::element::f32, ngraph::Shape{1}, {2});
@@ -36,16 +35,13 @@ TEST(TransformationTests, FQTransposeTest1) {
         auto fq = std::make_shared<ngraph::op::FakeQuantize>(data, input_low, input_high, output_low, output_high, 1);
         auto transpose = std::make_shared<ngraph::op::Transpose>(fq, transpose_order);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{transpose}, ngraph::ParameterVector{});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{transpose}, ngraph::ParameterVector{});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::PullTransposeThroughFQUp>();
         manager.register_pass<ngraph::pass::InjectionPass>([](std::shared_ptr<ngraph::Function> f) {
             check_rt_info(f);
         });
         manager.register_pass<ngraph::pass::ConstantFolding>();
-        ASSERT_NO_THROW(manager.run_passes(f));
     }
     {
         auto data = ngraph::op::Constant::create(ngraph::element::f32, ngraph::Shape{1, 3, 1}, {1, 2, 3});
@@ -56,10 +52,8 @@ TEST(TransformationTests, FQTransposeTest1) {
 
         auto fq = std::make_shared<ngraph::op::FakeQuantize>(data, input_low, input_high, output_low, output_high, 1);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fq}, ngraph::ParameterVector{});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{fq}, ngraph::ParameterVector{});
     }
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 TEST(TransformationTests, FQTransposeDynamic) {

inference-engine/tests/functional/inference_engine/transformations/ngraph_mode_decomposition_test.cpp

@@ -31,9 +31,12 @@ TEST(TransformationTests, ModDecompositionTests) {
         auto mod = std::make_shared<ngraph::op::v1::Mod>(data1, data2);
 
         f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mod}, ngraph::ParameterVector{});
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
         ngraph::pass::Manager m;
+        m.register_pass<ngraph::pass::InitUniqueNames>(unh);
         m.register_pass<ngraph::pass::InitNodeInfo>();
         m.register_pass<ngraph::pass::ConvertMod>();
+        m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
         m.run_passes(f);
         ASSERT_NO_THROW(check_rt_info(f));
     }

inference-engine/tests/functional/inference_engine/transformations/normalize_l2_decomposition_test.cpp

@@ -18,21 +18,16 @@
 
 using namespace testing;
 
-TEST(TransformationTests, NormalizeL2DecomositionFusionWithMax) {
-    std::shared_ptr<ngraph::Function> f, f_ref;
+TEST_F(TransformationTestsF, NormalizeL2DecomositionFusionWithMax) {
     const float eps_value = 0.000099f;
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(3));
         auto axes_const = ngraph::opset8::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {1, 2});
         auto normalize_l2 = std::make_shared<ngraph::opset8::NormalizeL2>(input, axes_const, eps_value, ngraph::op::EpsMode::MAX);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -46,29 +41,20 @@ TEST(TransformationTests, NormalizeL2DecomositionFusionWithMax) {
         auto sqrt = std::make_shared<ngraph::opset8::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset8::Divide>(input, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }
 
-TEST(TransformationTests, NormalizeL2DecomositionFusionWithAdd) {
-    std::shared_ptr<ngraph::Function> f, f_ref;
+TEST_F(TransformationTestsF, NormalizeL2DecomositionFusionWithAdd) {
     const float eps_value = 0.000099f;
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(3));
         auto axes_const = ngraph::opset8::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {0, 1});
         auto normalize_l2 = std::make_shared<ngraph::opset8::NormalizeL2>(input, axes_const, eps_value, ngraph::op::EpsMode::ADD);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -82,10 +68,6 @@ TEST(TransformationTests, NormalizeL2DecomositionFusionWithAdd) {
         auto sqrt = std::make_shared<ngraph::opset8::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset8::Divide>(input, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }

inference-engine/tests/functional/inference_engine/transformations/normalize_l2_fusion_test.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, NormalizeL2FusionWithMax) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NormalizeL2FusionWithMax) {
     const float eps_value = 0.000099f;
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(3));
@@ -32,13 +31,9 @@ TEST(TransformationTests, NormalizeL2FusionWithMax) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Fusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -46,16 +41,11 @@ TEST(TransformationTests, NormalizeL2FusionWithMax) {
         auto axes_const = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {0, 1});
         auto normalize_l2 = std::make_shared<ngraph::opset4::NormalizeL2>(input, axes_const, eps_value, ngraph::op::EpsMode::MAX);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }
 
-TEST(TransformationTests, NormalizeL2FusionWithMaxIncorrectExp) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NormalizeL2FusionWithMaxIncorrectExp) {
     const float eps_value = 0.0009f;
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(2));
@@ -68,12 +58,9 @@ TEST(TransformationTests, NormalizeL2FusionWithMaxIncorrectExp) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Fusion>();
-        manager.run_passes(f);
     }
 
     {
@@ -87,16 +74,11 @@ TEST(TransformationTests, NormalizeL2FusionWithMaxIncorrectExp) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }
 
-TEST(TransformationTests, NormalizeL2FusionWithMaxIncorrectEpsValueShape) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NormalizeL2FusionWithMaxIncorrectEpsValueShape) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(2));
         auto exp = ngraph::opset4::Constant::create(ngraph::element::f16, ngraph::Shape{}, {2.f});
@@ -108,12 +90,9 @@ TEST(TransformationTests, NormalizeL2FusionWithMaxIncorrectEpsValueShape) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Fusion>();
-        manager.run_passes(f);
     }
 
     {
@@ -127,16 +106,11 @@ TEST(TransformationTests, NormalizeL2FusionWithMaxIncorrectEpsValueShape) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(max);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }
 
-TEST(TransformationTests, NormalizeL2FusionWithAdd) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NormalizeL2FusionWithAdd) {
     const float eps_value = 0.000099f;
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(3));
@@ -149,13 +123,9 @@ TEST(TransformationTests, NormalizeL2FusionWithAdd) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(add);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Fusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -163,16 +133,11 @@ TEST(TransformationTests, NormalizeL2FusionWithAdd) {
         auto axes_const = ngraph::opset4::Constant::create(ngraph::element::i64, ngraph::Shape{2}, {0, 1});
         auto normalize_l2 = std::make_shared<ngraph::opset4::NormalizeL2>(input, axes_const, eps_value, ngraph::op::EpsMode::ADD);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{normalize_l2}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }
 
-TEST(TransformationTests, NormalizeL2FusionWithAddIncorrectExp) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NormalizeL2FusionWithAddIncorrectExp) {
     const float eps_value = 0.0009f;
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(2));
@@ -185,13 +150,9 @@ TEST(TransformationTests, NormalizeL2FusionWithAddIncorrectExp) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(add);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Fusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -205,16 +166,11 @@ TEST(TransformationTests, NormalizeL2FusionWithAddIncorrectExp) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(add);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }
 
-TEST(TransformationTests, NormalizeL2FusionWithAddIncorrectEpsValueShape) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NormalizeL2FusionWithAddIncorrectEpsValueShape) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(4));
         auto exp = ngraph::opset4::Constant::create(ngraph::element::f16, ngraph::Shape{}, {2.f});
@@ -226,12 +182,9 @@ TEST(TransformationTests, NormalizeL2FusionWithAddIncorrectEpsValueShape) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(add);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::NormalizeL2Fusion>();
-        manager.run_passes(f);
     }
 
     {
@@ -245,10 +198,6 @@ TEST(TransformationTests, NormalizeL2FusionWithAddIncorrectEpsValueShape) {
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(add);
         auto divide = std::make_shared<ngraph::opset4::Divide>(input, sqrt);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{divide}, ngraph::ParameterVector{input});
     }
-
-    const auto fc = FunctionsComparator::with_default().enable(FunctionsComparator::ATTRIBUTES);
-    const auto res = fc.compare(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }

inference-engine/tests/functional/inference_engine/transformations/optimize_strided_slice_test.cpp

@@ -23,8 +23,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, OptimizeSS_UselessDeletion_Negative1) {
-    std::shared_ptr<ngraph::Function> f(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_UselessDeletion_Negative1) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
         auto begin = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 0, 0, 0});
@@ -36,17 +35,13 @@ TEST(TransformationTests, OptimizeSS_UselessDeletion_Negative1) {
 
         auto ss = std::make_shared<ngraph::opset1::StridedSlice>(data, begin, end, stride, begin_mask, end_mask);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
-
-    auto res = compare_functions(f, f);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_UselessDeletion_Negative2) {
-    std::shared_ptr<ngraph::Function> f(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_UselessDeletion_Negative2) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(4));
         auto relu = std::make_shared<ngraph::opset1::Relu>(data);
@@ -59,17 +54,13 @@ TEST(TransformationTests, OptimizeSS_UselessDeletion_Negative2) {
 
         auto ss = std::make_shared<ngraph::opset1::StridedSlice>(relu, begin, end, stride, begin_mask, end_mask);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
-
-    auto res = compare_functions(f, f);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_UselessDeletion) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_UselessDeletion) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
         auto relu = std::make_shared<ngraph::opset1::Relu>(data);
@@ -82,22 +73,18 @@ TEST(TransformationTests, OptimizeSS_UselessDeletion) {
 
         auto ss = std::make_shared<ngraph::opset1::StridedSlice>(relu, begin, end, stride, begin_mask, end_mask);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
         auto relu = std::make_shared<ngraph::opset1::Relu>(data);
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{relu}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{relu}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_SkipUselessDeletionRevertCase) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_SkipUselessDeletionRevertCase) {
     {
         auto data = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
         auto begin = ngraph::opset3::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 0, 0, 0});
@@ -110,9 +97,9 @@ TEST(TransformationTests, OptimizeSS_SkipUselessDeletionRevertCase) {
         auto ss = std::make_shared<ngraph::opset3::StridedSlice>(data, begin, end, stride, begin_mask, end_mask);
         auto relu = std::make_shared<ngraph::opset3::Relu>(ss);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{relu}, ngraph::ParameterVector{data});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{relu}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
     {
         auto data = std::make_shared<ngraph::opset3::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
@@ -126,15 +113,11 @@ TEST(TransformationTests, OptimizeSS_SkipUselessDeletionRevertCase) {
         auto ss = std::make_shared<ngraph::opset3::StridedSlice>(data, begin, end, stride, begin_mask, end_mask);
         auto relu = std::make_shared<ngraph::opset3::Relu>(ss);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{relu}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{relu}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_Usefull_Test) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_Usefull_Test) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
         auto begin = ngraph::opset1::Constant::create(ngraph::element::i64, ngraph::Shape{4}, {0, 0, 0, 0});
@@ -146,9 +129,9 @@ TEST(TransformationTests, OptimizeSS_Usefull_Test) {
 
         auto ss = std::make_shared<ngraph::opset1::StridedSlice>(data, begin, end, stride, begin_mask, end_mask);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
@@ -161,15 +144,11 @@ TEST(TransformationTests, OptimizeSS_Usefull_Test) {
 
         auto ss = std::make_shared<ngraph::opset1::StridedSlice>(data, begin, end, stride, begin_mask, end_mask);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ss}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_Shared_Test) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_Shared_Test) {
     {
         auto source = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
 
@@ -189,9 +168,9 @@ TEST(TransformationTests, OptimizeSS_Shared_Test) {
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::NodeVector{ss1, ss2}, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
     {
         auto source = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
@@ -205,14 +184,11 @@ TEST(TransformationTests, OptimizeSS_Shared_Test) {
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::NodeVector{ss1, ss1}, 0);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
     }
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_NotShared_Test) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_NotShared_Test) {
     {
         auto source = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 6, 5, 5});
 
@@ -235,9 +211,9 @@ TEST(TransformationTests, OptimizeSS_NotShared_Test) {
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::NodeVector{ss1, ss2}, 0);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
     {
         auto source = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 6, 5, 5});
@@ -261,15 +237,11 @@ TEST(TransformationTests, OptimizeSS_NotShared_Test) {
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::NodeVector{ss1, ss2}, 0);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, OptimizeSS_Groupped_Test) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, OptimizeSS_Groupped_Test) {
     {
         auto source = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
 
@@ -289,9 +261,9 @@ TEST(TransformationTests, OptimizeSS_Groupped_Test) {
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::NodeVector{ss1, ss2}, 1);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
-        ngraph::pass::StridedSliceOptimization().run_on_function(f);
-        ngraph::pass::ConstantFolding().run_on_function(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
+        manager.register_pass<ngraph::pass::StridedSliceOptimization>();
+        manager.register_pass<ngraph::pass::ConstantFolding>();
     }
     {
         auto source = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{5, 5, 5, 5});
@@ -302,9 +274,6 @@ TEST(TransformationTests, OptimizeSS_Groupped_Test) {
 
         auto concat = std::make_shared<ngraph::opset1::Concat>(ngraph::OutputVector{variadic_split->output(0), variadic_split->output(1)}, 1);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{concat}, ngraph::ParameterVector{source});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/pad_fusion.cpp

@@ -23,46 +23,30 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, PadElimination) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadElimination) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
-        set_tensor_name(data, "param");
         auto pads_begin = opset5::Constant::create(element::i32, Shape{4}, {0, 0, 0, 0});
         auto pads_end = opset5::Constant::create(element::i32, Shape{4}, {0, 0, 0, 0});
         auto pad = std::make_shared<opset5::Pad>(data, pads_begin, pads_end, op::PadMode::CONSTANT);
-        set_tensor_name(pad, "pad");
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        set_tensor_name(conv, "conv");
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::EliminatePad>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::EliminatePad>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
-        set_tensor_names(data, {"param", "pad"});
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(data, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1},
                                                           op::PadType::EXPLICIT);
-        set_tensor_name(conv, "conv");
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionAvgPoolExcludePad) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionAvgPoolExcludePad) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -72,28 +56,19 @@ TEST(TransformationTests, PadFusionAvgPoolExcludePad) {
         auto avg_pool = std::make_shared<opset5::AvgPool>(pad, Strides{1, 1},
                                                           Shape{0, 0}, Shape{0, 0},
                                                           Shape{4, 4}, true, op::RoundingType::FLOOR);
-        f = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
         auto avg_pool = std::make_shared<opset5::AvgPool>(data, Strides{1, 1},
                                                           Shape{1, 1}, Shape{2, 2}, Shape{4, 4},
                                                           false, op::RoundingType::FLOOR, op::PadType::EXPLICIT);
-        f_ref = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionAvgPoolDontExcludePad) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionAvgPoolDontExcludePad) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -103,28 +78,19 @@ TEST(TransformationTests, PadFusionAvgPoolDontExcludePad) {
         auto avg_pool = std::make_shared<opset5::AvgPool>(pad, Strides{1, 1},
                                                           Shape{0, 0}, Shape{1, 1},
                                                           Shape{4, 4}, false, op::RoundingType::FLOOR);
-        f = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
         auto avg_pool = std::make_shared<opset5::AvgPool>(data, Strides{1, 1},
                                                           Shape{1, 1}, Shape{3, 3}, Shape{4, 4},
                                                           false, op::RoundingType::FLOOR, op::PadType::EXPLICIT);
-        f_ref = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionMaxPool) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionMaxPool) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -133,28 +99,19 @@ TEST(TransformationTests, PadFusionMaxPool) {
         auto pad = std::make_shared<opset5::Pad>(data, pads_begin, pads_end, op::PadMode::CONSTANT);
         auto max_pool = std::make_shared<opset5::MaxPool>(pad, Strides{1, 1},
                                                           Shape{0, 0}, Shape{1, 1}, Shape{4, 4});
-        f = std::make_shared<Function>(NodeVector{max_pool}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{max_pool}, ParameterVector{data});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
         auto max_pool = std::make_shared<opset5::MaxPool>(data, Strides{1, 1},
                                                           Shape{1, 1}, Shape{3, 3}, Shape{4, 4},
                                                           op::RoundingType::FLOOR, op::PadType::EXPLICIT);
-        f_ref = std::make_shared<Function>(NodeVector{max_pool}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{max_pool}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionConvolution) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionConvolution) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -164,12 +121,8 @@ TEST(TransformationTests, PadFusionConvolution) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -177,16 +130,11 @@ TEST(TransformationTests, PadFusionConvolution) {
         auto conv = std::make_shared<opset5::Convolution>(data, filters, Strides{1, 1},
                                                           CoordinateDiff{1, 1}, CoordinateDiff{3, 3}, Shape{1, 1},
                                                           op::PadType::EXPLICIT);
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionConvolutionBackpropData) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionConvolutionBackpropData) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -199,12 +147,8 @@ TEST(TransformationTests, PadFusionConvolutionBackpropData) {
                                                                       CoordinateDiff{4, 4}, CoordinateDiff{3, 3}, Shape{1, 1});
         set_tensor_name(conv, "conv");
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -213,16 +157,11 @@ TEST(TransformationTests, PadFusionConvolutionBackpropData) {
                                                                       CoordinateDiff{3, 3}, CoordinateDiff{1, 1}, Shape{1, 1});
         set_tensor_name(conv, "conv");
 
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionGroupConvolution) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionGroupConvolution) {
     Shape data_shape{1, 4, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -233,12 +172,8 @@ TEST(TransformationTests, PadFusionGroupConvolution) {
         auto conv = std::make_shared<opset5::GroupConvolution>(pad, filters, Strides{1, 1},
                                                                CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -246,16 +181,11 @@ TEST(TransformationTests, PadFusionGroupConvolution) {
         auto conv = std::make_shared<opset5::GroupConvolution>(data, filters, Strides{1, 1},
                                                                CoordinateDiff{1, 1}, CoordinateDiff{3, 3}, Shape{1, 1},
                                                                op::PadType::EXPLICIT);
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, PadFusionGroupConvolutionBackpropData) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, PadFusionGroupConvolutionBackpropData) {
     Shape data_shape{1, 4, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -265,28 +195,19 @@ TEST(TransformationTests, PadFusionGroupConvolutionBackpropData) {
         auto filters = std::make_shared<opset5::Parameter>(element::f32, Shape{2, 2, 1, 5, 5});
         auto conv = std::make_shared<opset5::GroupConvolutionBackpropData>(pad, filters, Strides{1, 1},
                                                                CoordinateDiff{3, 2}, CoordinateDiff{4, 3}, Shape{1, 1});
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
         auto filters = std::make_shared<opset5::Parameter>(element::f32, Shape{2, 2, 1, 5, 5});
         auto conv = std::make_shared<opset5::GroupConvolutionBackpropData>(data, filters, Strides{1, 1},
                                                                            CoordinateDiff{2, 1}, CoordinateDiff{1, 2}, Shape{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativePadFusionNonConstantPadMode) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativePadFusionNonConstantPadMode) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -296,12 +217,8 @@ TEST(TransformationTests, NegativePadFusionNonConstantPadMode) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -311,16 +228,11 @@ TEST(TransformationTests, NegativePadFusionNonConstantPadMode) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativePadFusionNonZeroPadValue) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativePadFusionNonZeroPadValue) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -331,12 +243,8 @@ TEST(TransformationTests, NegativePadFusionNonZeroPadValue) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -347,16 +255,11 @@ TEST(TransformationTests, NegativePadFusionNonZeroPadValue) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativePadFusionPadForBatchSize) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativePadFusionPadForBatchSize) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -367,12 +270,8 @@ TEST(TransformationTests, NegativePadFusionPadForBatchSize) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -383,16 +282,11 @@ TEST(TransformationTests, NegativePadFusionPadForBatchSize) {
         auto filters = std::make_shared<opset5::Parameter>(element::i32, Shape{1, 3, 4, 4});
         auto conv = std::make_shared<opset5::Convolution>(pad, filters, Strides{1, 1},
                                                           CoordinateDiff{0, 0}, CoordinateDiff{1, 1}, Shape{1, 1});
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativePadFusionAvgPoolExcludePadNonZeroPads) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativePadFusionAvgPoolExcludePadNonZeroPads) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -402,12 +296,8 @@ TEST(TransformationTests, NegativePadFusionAvgPoolExcludePadNonZeroPads) {
         auto avg_pool = std::make_shared<opset5::AvgPool>(pad, Strides{1, 1},
                                                           Shape{0, 0}, Shape{1, 1},
                                                           Shape{4, 4}, true, op::RoundingType::FLOOR);
-        f = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::i32, data_shape);
@@ -417,16 +307,11 @@ TEST(TransformationTests, NegativePadFusionAvgPoolExcludePadNonZeroPads) {
         auto avg_pool = std::make_shared<opset5::AvgPool>(pad, Strides{1, 1},
                                                           Shape{0, 0}, Shape{1, 1},
                                                           Shape{4, 4}, true, op::RoundingType::FLOOR);
-        f_ref = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{avg_pool}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativePadFusionConvolutionBackpropDataTooSmallPad) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, NegativePadFusionConvolutionBackpropDataTooSmallPad) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -440,12 +325,8 @@ TEST(TransformationTests, NegativePadFusionConvolutionBackpropDataTooSmallPad) {
                                                                       CoordinateDiff{1, 1}, CoordinateDiff{1, 1}, Shape{1, 1});
         set_tensor_name(conv, "conv");
 
-        f = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::PadFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        manager.register_pass<pass::PadFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -459,9 +340,6 @@ TEST(TransformationTests, NegativePadFusionConvolutionBackpropDataTooSmallPad) {
                                                                       CoordinateDiff{1, 1}, CoordinateDiff{1, 1}, Shape{1, 1});
         set_tensor_name(conv, "conv");
 
-        f_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
+        function_ref = std::make_shared<Function>(NodeVector{conv}, ParameterVector{data, filters});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/random_uniform_fusion_test.cpp

@@ -17,8 +17,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, RandomUniformMulFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, RandomUniformMulFusing) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -33,13 +32,9 @@ TEST(TransformationTests, RandomUniformMulFusing) {
         auto mul_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{1, 1, 1}, {30.0});
         auto mul = std::make_shared<ngraph::opset8::Multiply>(ru, mul_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::RandomUniformFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -53,15 +48,11 @@ TEST(TransformationTests, RandomUniformMulFusing) {
                                                                   100,
                                                                   200);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ru}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ru}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, RandomUniformAddFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, RandomUniformAddFusing) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -76,13 +67,9 @@ TEST(TransformationTests, RandomUniformAddFusing) {
         auto add_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{1, 1, 1, 1}, {-10.0});
         auto add = std::make_shared<ngraph::opset8::Add>(ru, add_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::RandomUniformFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -96,15 +83,11 @@ TEST(TransformationTests, RandomUniformAddFusing) {
                                                                   100,
                                                                   200);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ru}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ru}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, RandomUniformWithConvertMulFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, RandomUniformWithConvertMulFusing) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -120,13 +103,9 @@ TEST(TransformationTests, RandomUniformWithConvertMulFusing) {
         auto mul_const = ngraph::opset8::Constant::create(ngraph::element::f16, ngraph::Shape{}, {30.0});
         auto mul = std::make_shared<ngraph::opset8::Multiply>(conv, mul_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::RandomUniformFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -142,15 +121,11 @@ TEST(TransformationTests, RandomUniformWithConvertMulFusing) {
                                                                   200);
         auto conv = std::make_shared<ngraph::opset8::Convert>(ru, ngraph::element::f16);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, RandomUniformWithConvertAddFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, RandomUniformWithConvertAddFusing) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -166,13 +141,9 @@ TEST(TransformationTests, RandomUniformWithConvertAddFusing) {
         auto add_const = ngraph::opset8::Constant::create(ngraph::element::f16, ngraph::Shape{}, {-10.0});
         auto add = std::make_shared<ngraph::opset8::Add>(conv, add_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{add}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::RandomUniformFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -188,16 +159,12 @@ TEST(TransformationTests, RandomUniformWithConvertAddFusing) {
                                                                   200);
         auto conv = std::make_shared<ngraph::opset8::Convert>(ru, ngraph::element::f16);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, RandomUniformFusingInvalidRUType) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, RandomUniformFusingInvalidRUType) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::i32, ngraph::Shape{}, {0});
@@ -212,13 +179,9 @@ TEST(TransformationTests, RandomUniformFusingInvalidRUType) {
         auto mul_const = ngraph::opset8::Constant::create(ngraph::element::i32, ngraph::Shape{}, {30});
         auto mul = std::make_shared<ngraph::opset8::Multiply>(ru, mul_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::RandomUniformFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -235,16 +198,12 @@ TEST(TransformationTests, RandomUniformFusingInvalidRUType) {
         auto mul_const = ngraph::opset8::Constant::create(ngraph::element::i32, ngraph::Shape{}, {30});
         auto mul = std::make_shared<ngraph::opset8::Multiply>(ru, mul_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 
-TEST(TransformationTests, RandomUniformFusingInvalidConstShape) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, RandomUniformFusingInvalidConstShape) {
     {
         auto input = std::make_shared<ngraph::opset8::Parameter>(ngraph::element::i32, ngraph::Shape{3});
         auto min_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{}, {0.0});
@@ -259,13 +218,9 @@ TEST(TransformationTests, RandomUniformFusingInvalidConstShape) {
         auto mul_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{3}, {30, 20, 15});
         auto mul = std::make_shared<ngraph::opset8::Multiply>(ru, mul_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::RandomUniformFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -282,9 +237,6 @@ TEST(TransformationTests, RandomUniformFusingInvalidConstShape) {
         auto mul_const = ngraph::opset8::Constant::create(ngraph::element::f32, ngraph::Shape{3}, {30, 20, 15});
         auto mul = std::make_shared<ngraph::opset8::Multiply>(ru, mul_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/reduce_l1_decomposition_test.cpp

@@ -18,20 +18,15 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ReduceL1DecompositionTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ReduceL1DecompositionTest) {
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto axes = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::i32, ngraph::Shape{1});
         auto reduce_l1 = std::make_shared<ngraph::opset4::ReduceL1>(data, axes, true);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{reduce_l1}, ngraph::ParameterVector{data, axes});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{reduce_l1}, ngraph::ParameterVector{data, axes});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::ReduceL1Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -40,9 +35,6 @@ TEST(TransformationTests, ReduceL1DecompositionTest) {
         auto abs = std::make_shared<ngraph::opset4::Abs>(data);
         auto reduce_l1 = std::make_shared<ngraph::opset4::ReduceSum>(abs, axes, true);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reduce_l1}, ngraph::ParameterVector{data, axes});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{reduce_l1}, ngraph::ParameterVector{data, axes});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/reduce_l2_decomposition_test.cpp

@@ -18,20 +18,14 @@
 
 using namespace testing;
 
-TEST(TransformationTests, ReduceL2DecompositionTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, ReduceL2DecompositionTest) {
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto axes = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::i32, ngraph::Shape{1});
         auto reduce_l2 = std::make_shared<ngraph::opset4::ReduceL2>(data, axes, true);
-        reduce_l2->set_friendly_name("reduce_l2");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{reduce_l2}, ngraph::ParameterVector{data, axes});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{reduce_l2}, ngraph::ParameterVector{data, axes});
         manager.register_pass<ngraph::pass::ReduceL2Decomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -41,13 +35,6 @@ TEST(TransformationTests, ReduceL2DecompositionTest) {
         auto reduce_sum = std::make_shared<ngraph::opset4::ReduceSum>(pow, axes, true);
         auto sqrt = std::make_shared<ngraph::opset4::Sqrt>(reduce_sum);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sqrt}, ngraph::ParameterVector{data, axes});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{sqrt}, ngraph::ParameterVector{data, axes});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
-
-    auto result_node_of_converted_f = f->get_output_op(0);
-    auto output_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr();
-    ASSERT_TRUE(output_node->get_friendly_name() == "reduce_l2") << "Transformation ReduceL2Decomposition should keep output names.\n";
 }

inference-engine/tests/functional/inference_engine/transformations/relu_fake_quantize_fusion.cpp

@@ -22,9 +22,7 @@ using namespace testing;
 using namespace ngraph;
 
 
-TEST(TransformationTests, ReluFakeQuantizeFusion) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, ReluFakeQuantizeFusion) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -36,12 +34,8 @@ TEST(TransformationTests, ReluFakeQuantizeFusion) {
         auto fq = std::make_shared<opset5::FakeQuantize>(relu, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ReluFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::ReluFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -52,16 +46,11 @@ TEST(TransformationTests, ReluFakeQuantizeFusion) {
         auto fq = std::make_shared<opset5::FakeQuantize>(data, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ReluFakeQuantizeFusionNegativeInputLow) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, ReluFakeQuantizeFusionNegativeInputLow) {
     Shape data_shape{1, 3, 14, 14};
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -73,12 +62,8 @@ TEST(TransformationTests, ReluFakeQuantizeFusionNegativeInputLow) {
         auto fq = std::make_shared<opset5::FakeQuantize>(relu, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::ReluFakeQuantizeFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        manager.register_pass<pass::ReluFakeQuantizeFusion>();
     }
     {
         auto data = std::make_shared<opset5::Parameter>(element::f32, data_shape);
@@ -90,9 +75,6 @@ TEST(TransformationTests, ReluFakeQuantizeFusionNegativeInputLow) {
         auto fq = std::make_shared<opset5::FakeQuantize>(relu, input_low,
                                                          input_high, output_low,
                                                          output_high, 11);
-        f_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{fq}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/reshape_fc_fusion_test.cpp

@@ -34,10 +34,14 @@ TEST(TransformationTests, ReshapeFCFusiuonTest1) {
         auto fc = std::make_shared<ngraph::op::FullyConnected>(reshape, fc_weights, fc_biases, ngraph::Shape{1, 6});
 
         f = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
-        manager.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
-        manager.run_passes(f);
+
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+        ngraph::pass::Manager m;
+        m.register_pass<ngraph::pass::InitUniqueNames>(unh);
+        m.register_pass<ngraph::pass::InitNodeInfo>();
+        m.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
+        m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+        m.run_passes(f);
         ASSERT_NO_THROW(check_rt_info(f));
     }
     ASSERT_EQ(f->get_ops().size(), 5);
@@ -55,10 +59,13 @@ TEST(TransformationTests, ReshapeFCFusiuonTest2) {
         auto fc = std::make_shared<ngraph::op::FullyConnected>(reshape, fc_weights, fc_biases, ngraph::Shape{1, 6});
 
         f = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
-        manager.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
-        manager.run_passes(f);
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+        ngraph::pass::Manager m;
+        m.register_pass<ngraph::pass::InitUniqueNames>(unh);
+        m.register_pass<ngraph::pass::InitNodeInfo>();
+        m.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
+        m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+        m.run_passes(f);
         ASSERT_NO_THROW(check_rt_info(f));
     }
     ASSERT_EQ(f->get_ops().size(), 5);
@@ -76,10 +83,13 @@ TEST(TransformationTests, ReshapeFCFusiuonTest3) {
         auto fc = std::make_shared<ngraph::op::FullyConnected>(reshape, fc_weights, fc_biases, ngraph::Shape{2, 6});
 
         f = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{});
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
-        manager.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
-        manager.run_passes(f);
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+        ngraph::pass::Manager m;
+        m.register_pass<ngraph::pass::InitUniqueNames>(unh);
+        m.register_pass<ngraph::pass::InitNodeInfo>();
+        m.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
+        m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+        m.run_passes(f);
         ASSERT_NO_THROW(check_rt_info(f));
     }
     ASSERT_EQ(f->get_ops().size(), 7);
@@ -95,7 +105,12 @@ TEST(TransformationTests, ReshapeFCFusiuonDynamic) {
     auto fc = std::make_shared<ngraph::op::FullyConnected>(reshape, fc_weights, fc_biases, ngraph::Shape{1, 6});
 
     auto f = std::make_shared<ngraph::Function>(ngraph::NodeVector{fc}, ngraph::ParameterVector{});
-    ngraph::pass::Manager manager;
-    manager.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
-    ASSERT_NO_THROW(manager.run_passes(f));
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+    ngraph::pass::Manager m;
+    m.register_pass<ngraph::pass::InitUniqueNames>(unh);
+    m.register_pass<ngraph::pass::InitNodeInfo>();
+    m.register_pass<ngraph::pass::ReshapeFullyConnectedFusion>();
+    m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+    m.run_passes(f);
+    ASSERT_NO_THROW(check_rt_info(f));
 }

inference-engine/tests/functional/inference_engine/transformations/shuffle_channels_fusion_test.cpp

@@ -58,10 +58,13 @@ public:
             auto reshape_after = std::make_shared<ngraph::opset6::Reshape>(permute, shape_reshape_after, false);
             f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ reshape_after }, ngraph::ParameterVector{ input0 });
 
+            auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
             ngraph::pass::Manager manager;
             auto pass_config = manager.get_pass_config();
+            manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
             manager.register_pass<ngraph::pass::InitNodeInfo>();
             manager.register_pass<ngraph::pass::ShuffleChannelsFusion>(values.check_reshape_values);
+            manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
             manager.run_passes(f);
             ASSERT_NO_THROW(check_rt_info(f));
         }
@@ -98,8 +101,9 @@ protected:
 };
 
 TEST_P(ShuffleChannelsFusion, CompareFunctions) {
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 const std::vector<ShuffleChannelsFusionTestValues> testValues = {

inference-engine/tests/functional/inference_engine/transformations/simplify_ctc_greedy_decoder_seq_len_test.cpp

@@ -19,8 +19,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 3, 7 });
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i64, ngraph::Shape{ 1 });
@@ -29,13 +28,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenTest) {
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -104,15 +99,11 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenTest) {
         auto output_seq_len = std::make_shared<ngraph::opset6::ReduceSum>(output_seq_mask, seq_mask_axis);
         auto output_seq_len_i = std::make_shared<ngraph::opset6::Convert>(output_seq_len->output(0), sl_type);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i }, ngraph::ParameterVector{ data1, seq_len1 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i }, ngraph::ParameterVector{ data1, seq_len1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicInputShapeTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenDynamicInputShapeTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic());
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i32, ngraph::Shape{ 1 });
@@ -121,13 +112,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicInputShapeTest) {
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -196,15 +183,11 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicInputShapeTest) {
         auto output_seq_len = std::make_shared<ngraph::opset6::ReduceSum>(output_seq_mask, seq_mask_axis);
         auto output_seq_len_i = std::make_shared<ngraph::opset6::Convert>(output_seq_len->output(0), sl_type);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i }, ngraph::ParameterVector{ data1, seq_len1 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i }, ngraph::ParameterVector{ data1, seq_len1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicBatchTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenDynamicBatchTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::PartialShape{Dimension::dynamic(), 3, 7});
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i32, ngraph::PartialShape{Dimension::dynamic()});
@@ -213,13 +196,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicBatchTest) {
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -288,15 +267,11 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicBatchTest) {
         auto output_seq_len = std::make_shared<ngraph::opset6::ReduceSum>(output_seq_mask, seq_mask_axis);
         auto output_seq_len_i = std::make_shared<ngraph::opset6::Convert>(output_seq_len->output(0), sl_type);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i }, ngraph::ParameterVector{ data1, seq_len1 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i }, ngraph::ParameterVector{ data1, seq_len1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::PartialShape{2, Dimension::dynamic(), 7});
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i32, ngraph::PartialShape{2});
@@ -305,13 +280,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenTest) {
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -380,16 +351,12 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenTest) {
         auto output_seq_len = std::make_shared<ngraph::opset6::ReduceSum>(output_seq_mask, seq_mask_axis);
         auto output_seq_len_i = std::make_shared<ngraph::opset6::Convert>(output_seq_len->output(0), sl_type);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i },
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i },
                                                    ngraph::ParameterVector{ data1, seq_len1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenWrongBlankIndexTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenWrongBlankIndexTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::PartialShape{2, Dimension::dynamic(), 7});
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i32, ngraph::PartialShape{2});
@@ -400,13 +367,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenWrongBlankIndexTest) {
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -419,15 +382,11 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenWrongBlankIndexTest) {
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data1, seq_len1 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data1, seq_len1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenWithBlankIndexTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenWithBlankIndexTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::PartialShape{2, Dimension::dynamic(), 7});
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i32, ngraph::PartialShape{2});
@@ -438,13 +397,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenWithBlankIn
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -513,16 +468,12 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenWithBlankIn
         auto output_seq_len = std::make_shared<ngraph::opset6::ReduceSum>(output_seq_mask, seq_mask_axis);
         auto output_seq_len_i = std::make_shared<ngraph::opset6::Convert>(output_seq_len->output(0), sl_type);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i },
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ output_i, output_seq_len_i },
                                                    ngraph::ParameterVector{ data1, seq_len1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenParamWithBlankIndexTest) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenParamWithBlankIndexTest) {
     {
         auto data = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::PartialShape{2, Dimension::dynamic(), 7});
         auto seq_len = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::i32, ngraph::PartialShape{2});
@@ -533,13 +484,9 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenParamWithBl
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len, blank_index });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data, seq_len, blank_index });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -552,9 +499,6 @@ TEST(TransformationTests, SimplifyCTCGreedyDecoderSeqLenDynamicSeqLenParamWithBl
         auto res_1 = std::make_shared<opset6::Result>(decoder_v6->output(0));
         auto res_2 = std::make_shared<opset6::Result>(decoder_v6->output(1));
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data1, seq_len1, blank_index1 });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ res_1, res_2 }, ngraph::ParameterVector{ data1, seq_len1, blank_index1 });
     }
-
-    auto res = compare_functions(f, f_ref, true, false, false, true, true);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/simplify_shape_of_sub_graph.cpp

@@ -30,9 +30,7 @@ auto gather = [](const std::shared_ptr<Node> input, std::vector<int64_t> indices
             input, indices_node, opset7::Constant::create(element::i64, {}, {0}));
 };
 
-TEST(TransformationTests, ShapeSubGraphTest) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, ShapeSubGraphTest) {
     Shape data_shape{1, 2, 3, 4};
     {
         auto data = std::make_shared<opset7::Parameter>(element::f32, data_shape);
@@ -53,13 +51,8 @@ TEST(TransformationTests, ShapeSubGraphTest) {
         auto concat = std::make_shared<opset7::Concat>(OutputVector{unsqueeze_1, unsqueeze_2, const_1, const_2}, 0);
 
         auto reshape = std::make_shared<opset7::Reshape>(data, concat, false);
-        f = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SimplifyShapeOfSubGraph>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
-        ASSERT_EQ(reshape->get_output_partial_shape(0), PartialShape({2, 3, 2, 2}));
+        function = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
+        manager.register_pass<pass::SimplifyShapeOfSubGraph>();
     }
     {
         auto data = std::make_shared<opset7::Parameter>(element::f32, data_shape);
@@ -73,16 +66,11 @@ TEST(TransformationTests, ShapeSubGraphTest) {
         auto concat = std::make_shared<opset7::Concat>(OutputVector{gather_1, const_1, const_2}, 0);
 
         auto reshape = std::make_shared<opset7::Reshape>(data, concat, false);
-        f_ref = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, ShapeNopSubGraphTest) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
-
+TEST_F(TransformationTestsF, ShapeNopSubGraphTest) {
     PartialShape data_shape{-1, -1};
     {
         auto data = std::make_shared<opset7::Parameter>(element::f32, data_shape);
@@ -100,20 +88,13 @@ TEST(TransformationTests, ShapeNopSubGraphTest) {
         auto concat = std::make_shared<opset7::Concat>(OutputVector{unsqueeze_1, unsqueeze_2}, 0);
 
         auto reshape = std::make_shared<opset7::Reshape>(data, concat, false);
-        f = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SimplifyShapeOfSubGraph>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        function = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
+        manager.register_pass<pass::SimplifyShapeOfSubGraph>();
     }
     {
         auto data = std::make_shared<opset7::Parameter>(element::f32, data_shape);
         auto shape_op_1 = std::make_shared<opset7::ShapeOf>(data);
         auto reshape = std::make_shared<opset7::Reshape>(data, shape_op_1, false);
-        f_ref = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{reshape}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/softmax_fusion.cpp

@@ -9,6 +9,7 @@
 #include <transformations/common_optimizations/softmax_fusion.hpp>
 #include <transformations/init_node_info.hpp>
 #include <ngraph/pass/manager.hpp>
+#include <transformations/serialize.hpp>
 
 #include "common_test_utils/ngraph_test_utils.hpp"
 
@@ -37,9 +38,12 @@ TEST_P(SoftmaxFusionFixture, SoftmaxFusion) {
         auto div = std::make_shared<opset6::Divide>(exp, reduce_sum);
         f = std::make_shared<Function>(NodeVector{div}, ParameterVector{data});
 
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
         pass::Manager m;
+        m.register_pass<pass::InitUniqueNames>(unh);
         m.register_pass<pass::InitNodeInfo>();
         m.register_pass<pass::SoftmaxFusion>();
+        m.register_pass<pass::CheckUniqueNames>(unh);
         m.run_passes(f);
         ASSERT_NO_THROW(check_rt_info(f));
     }
@@ -51,8 +55,9 @@ TEST_P(SoftmaxFusionFixture, SoftmaxFusion) {
         f_ref = std::make_shared<Function>(NodeVector{softmax}, ParameterVector{data});
     }
 
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 INSTANTIATE_TEST_SUITE_P(SoftmaxFusionTests, SoftmaxFusionFixture,
@@ -87,9 +92,12 @@ TEST_P(NegativeSoftmaxFusionFixture, NegativeSoftmaxFusion) {
         auto div = std::make_shared<opset6::Divide>(exp, reduce_sum);
         f = std::make_shared<Function>(NodeVector{div}, ParameterVector{data});
 
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
         pass::Manager m;
+        m.register_pass<pass::InitUniqueNames>(unh);
         m.register_pass<pass::InitNodeInfo>();
         m.register_pass<pass::SoftmaxFusion>();
+        m.register_pass<pass::CheckUniqueNames>(unh);
         m.run_passes(f);
         ASSERT_NO_THROW(check_rt_info(f));
     }
@@ -105,8 +113,9 @@ TEST_P(NegativeSoftmaxFusionFixture, NegativeSoftmaxFusion) {
         f_ref = std::make_shared<Function>(NodeVector{div}, ParameterVector{data});
     }
 
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 INSTANTIATE_TEST_SUITE_P(NegativeSoftmaxFusionTests, NegativeSoftmaxFusionFixture,

inference-engine/tests/functional/inference_engine/transformations/softplus_decomposition_test.cpp

@@ -18,19 +18,14 @@
 
 using namespace testing;
 
-TEST(TransformationTests, SoftPlusDecompositionFP32) {
-    std::shared_ptr<ngraph::Function> f, f_ref;
+TEST_F(TransformationTestsF, SoftPlusDecompositionFP32) {
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto softplus = std::make_shared<ngraph::opset4::SoftPlus>(data);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SoftPlusDecomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -40,26 +35,18 @@ TEST(TransformationTests, SoftPlusDecompositionFP32) {
             ngraph::opset4::Constant::create(ngraph::element::f32, ngraph::Shape{1}, {1.0}));
         auto log = std::make_shared<ngraph::opset4::Log>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SoftPlusDecompositionFP16) {
-    std::shared_ptr<ngraph::Function> f, f_ref;
+TEST_F(TransformationTestsF, SoftPlusDecompositionFP16) {
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::Shape{3, 1, 2});
         auto softplus = std::make_shared<ngraph::opset4::SoftPlus>(data);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SoftPlusDecomposition>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -69,9 +56,6 @@ TEST(TransformationTests, SoftPlusDecompositionFP16) {
             ngraph::opset4::Constant::create(ngraph::element::f16, ngraph::Shape{1}, {1.0}));
         auto log = std::make_shared<ngraph::opset4::Log>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/softplus_fusion_test.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, SoftPlusFusing) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SoftPlusFusing) {
     {
         auto input0 = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto exp = std::make_shared<ngraph::opset4::Exp>(input0);
@@ -27,28 +26,20 @@ TEST(TransformationTests, SoftPlusFusing) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, input_const);
         auto log = std::make_shared<ngraph::opset4::Log>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SoftPlusFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{3, 1, 2});
         auto softplus = std::make_shared<ngraph::opset4::SoftPlus>(data);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SoftPlusFusingDynamic) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SoftPlusFusingDynamic) {
     {
         auto input0 = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto exp = std::make_shared<ngraph::opset4::Exp>(input0);
@@ -56,28 +47,20 @@ TEST(TransformationTests, SoftPlusFusingDynamic) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, input_const);
         auto log = std::make_shared<ngraph::opset4::Log>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SoftPlusFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto data = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto softplus = std::make_shared<ngraph::opset4::SoftPlus>(data);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{softplus}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SoftPlusFusingNegative) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SoftPlusFusingNegative) {
     {
         auto input0 = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto exp = std::make_shared<ngraph::opset4::Exp>(input0);
@@ -85,13 +68,9 @@ TEST(TransformationTests, SoftPlusFusingNegative) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, input_const);
         auto log = std::make_shared<ngraph::opset4::Log>(add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SoftPlusFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -101,9 +80,6 @@ TEST(TransformationTests, SoftPlusFusingNegative) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, input_const);
         auto log = std::make_shared<ngraph::opset4::Log>(add);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{log}, ngraph::ParameterVector{input0});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/space_to_batch_fusion.cpp

@@ -22,8 +22,7 @@
 using namespace testing;
 using namespace ngraph;
 
-TEST(TransformationTests, SpaceToBatchFusionTranspose) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SpaceToBatchFusionTranspose) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
@@ -33,13 +32,9 @@ TEST(TransformationTests, SpaceToBatchFusionTranspose) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SpaceToBatchFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::SpaceToBatchFusion>();
     }
 
     {
@@ -49,15 +44,11 @@ TEST(TransformationTests, SpaceToBatchFusionTranspose) {
             op::Constant::create(element::i64, Shape{4}, {1, 1, 1, 1}),
             op::Constant::create(element::i64, Shape{4}, {2, 2, 3, 3}));
 
-        f_ref = std::make_shared<Function>(NodeVector{space_to_batch}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{space_to_batch}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SpaceToBatchFusionReshape) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SpaceToBatchFusionReshape) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto reshape_before = std::make_shared<opset6::Reshape>(data, op::Constant::create(element::i64, Shape{4}, {3, 12, 4, 8}), false);
@@ -67,13 +58,9 @@ TEST(TransformationTests, SpaceToBatchFusionReshape) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SpaceToBatchFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::SpaceToBatchFusion>();
     }
 
     {
@@ -83,15 +70,11 @@ TEST(TransformationTests, SpaceToBatchFusionReshape) {
             op::Constant::create(element::i64, Shape{4}, {1, 1, 1, 1}),
             op::Constant::create(element::i64, Shape{4}, {2, 2, 3, 3}));
 
-        f_ref = std::make_shared<Function>(NodeVector{space_to_batch}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{space_to_batch}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidTransposePerm) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeSpaceToBatchFusionInvalidTransposePerm) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {3, 0, 2, 1}));
@@ -101,13 +84,9 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidTransposePerm) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SpaceToBatchFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::SpaceToBatchFusion>();
     }
 
     {
@@ -119,15 +98,11 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidTransposePerm) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidPad) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeSpaceToBatchFusionInvalidPad) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
@@ -137,13 +112,9 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidPad) {
                 op::Constant::create(element::f32, Shape{}, {1}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SpaceToBatchFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::SpaceToBatchFusion>();
     }
 
     {
@@ -155,15 +126,11 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidPad) {
                 op::Constant::create(element::f32, Shape{}, {1}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidMode) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeSpaceToBatchFusionInvalidMode) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
@@ -173,13 +140,9 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidMode) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SpaceToBatchFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::SpaceToBatchFusion>();
     }
 
     {
@@ -191,15 +154,11 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidMode) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{4}, {1, 0, 2, 3}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidRank) {
-    std::shared_ptr<Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, NegativeSpaceToBatchFusionInvalidRank) {
     {
         auto data = std::make_shared<opset6::Parameter>(element::f32, Shape{12, 3, 4, 8, 8});
         auto trans_before = std::make_shared<opset6::Transpose>(data, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
@@ -209,13 +168,9 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidRank) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
-        f = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
 
-        pass::Manager m;
-        m.register_pass<pass::InitNodeInfo>();
-        m.register_pass<pass::SpaceToBatchFusion>();
-        m.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
+        manager.register_pass<pass::SpaceToBatchFusion>();
     }
 
     {
@@ -227,10 +182,7 @@ TEST(TransformationTests, NegativeSpaceToBatchFusionInvalidRank) {
                 op::Constant::create(element::f32, Shape{}, {0}), op::PadMode::CONSTANT);
         auto space_to_depth = std::make_shared<opset6::SpaceToDepth>(pad, opset6::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST, 2);
         auto trans_after = std::make_shared<opset6::Transpose>(space_to_depth, op::Constant::create(element::i64, Shape{5}, {1, 0, 2, 3, 4}));
-        f_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
+        function_ref = std::make_shared<Function>(NodeVector{trans_after}, ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 

inference-engine/tests/functional/inference_engine/transformations/split_squeeze_concat_fusion_test.cpp

@@ -18,10 +18,9 @@
 
 using namespace testing;
 
-TEST(TransformationTests, SplitSqueezeConcatFusion) {
+TEST_F(TransformationTestsF, SplitSqueezeConcatFusion) {
     size_t num_splits = 4;
 
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, num_splits, 640, 20, 2 });
         auto split_axis = ngraph::opset7::Constant::create(ngraph::element::i64, ngraph::Shape{}, { 2 });
@@ -35,13 +34,9 @@ TEST(TransformationTests, SplitSqueezeConcatFusion) {
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SplitSqueezeConcatFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -52,17 +47,13 @@ TEST(TransformationTests, SplitSqueezeConcatFusion) {
                                                                        { 1, 2, 640, 20, 2 * (int64_t)num_splits });
         auto reshape = std::make_shared<ngraph::opset7::Reshape>(transpose, reshape_shape, false);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ reshape }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ reshape }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseNotAllSplitOutputsGoToSqueeze) {
+TEST_F(TransformationTestsF, SplitSqueezeConcatFusionNegativeCaseNotAllSplitOutputsGoToSqueeze) {
     size_t num_splits = 4;
 
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, num_splits, 640, 20, 2 });
         auto split_axis = ngraph::opset7::Constant::create(ngraph::element::i64, ngraph::Shape{}, { 2 });
@@ -76,14 +67,10 @@ TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseNotAllSplitOutputs
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SplitSqueezeConcatFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -99,17 +86,13 @@ TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseNotAllSplitOutputs
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseSplitOutputsGoInDifferentOrder) {
+TEST_F(TransformationTestsF, SplitSqueezeConcatFusionNegativeCaseSplitOutputsGoInDifferentOrder) {
     size_t num_splits = 4;
 
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, num_splits, 640, 20, 2 });
         auto split_axis = ngraph::opset7::Constant::create(ngraph::element::i64, ngraph::Shape{}, { 2 });
@@ -125,14 +108,10 @@ TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseSplitOutputsGoInDi
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SplitSqueezeConcatFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -150,17 +129,13 @@ TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseSplitOutputsGoInDi
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseSplitAxisDifferentFromSqueezeAxis) {
+TEST_F(TransformationTestsF, SplitSqueezeConcatFusionNegativeCaseSplitAxisDifferentFromSqueezeAxis) {
     size_t num_splits = 4;
 
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input = std::make_shared<ngraph::opset7::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, num_splits, 640, 20, 2 });
         auto split_axis = ngraph::opset7::Constant::create(ngraph::element::i64, ngraph::Shape{}, { 2 });
@@ -174,14 +149,10 @@ TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseSplitAxisDifferent
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SplitSqueezeConcatFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -197,9 +168,6 @@ TEST(TransformationTests, SplitSqueezeConcatFusionNegativeCaseSplitAxisDifferent
 
         auto concat = std::make_shared<ngraph::opset7::Concat>(squeeze_vec, 4);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ concat }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/strides_optimization.cpp

@@ -18,8 +18,7 @@ using namespace testing;
 // In description of unit tests below will be used next syntax: Operation(NxM,XxY), where NxM - kernel size, XxY - stride
 
 // Pl->Conv(1x1,1x1)->Conv(1x1,2x2) => Pl->Conv(1x1,2x2)->Conv(1x1,1x1)
-TEST(TransformationTests, StridesOptimization1) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization1) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 1, 1}, {128});
@@ -29,11 +28,8 @@ TEST(TransformationTests, StridesOptimization1) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(conv_1, weights_2, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -44,16 +40,12 @@ TEST(TransformationTests, StridesOptimization1) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(conv_1, weights_2, ngraph::Strides{},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 // Pl->Conv(3x3,2x2)->Conv(1x1,2x2) => Pl->Conv(3x3,4x4)->Conv(1x1,1x1)
-TEST(TransformationTests, StridesOptimization2) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization2) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 3, 3}, {128});
@@ -63,11 +55,8 @@ TEST(TransformationTests, StridesOptimization2) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(conv_1, weights_2, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -78,16 +67,12 @@ TEST(TransformationTests, StridesOptimization2) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(conv_1, weights_2, ngraph::Strides{},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 // Pl->Conv(3x3,2x2)->Conv(3x3,2x2) => Same
-TEST(TransformationTests, StridesOptimization3) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization3) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 3, 3}, {128});
@@ -97,11 +82,8 @@ TEST(TransformationTests, StridesOptimization3) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(conv_1, weights_2, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -112,17 +94,13 @@ TEST(TransformationTests, StridesOptimization3) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(conv_1, weights_2, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 // Pl--->Conv(3x3,2x2)->ReLU--->Eltwise-->Conv(1x1,2x2) => Pl--->Conv(3x3,4x4)->ReLU--->Eltwise-->Conv(1x1,1x1)
 //   `-->Conv(3x3,2x2)->ReLU---`                             `-->Conv(3x3,4x4)->ReLU---`
-TEST(TransformationTests, StridesOptimization4) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization4) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 3, 3}, {128});
@@ -138,11 +116,8 @@ TEST(TransformationTests, StridesOptimization4) {
         auto conv_3 = std::make_shared<ngraph::opset7::Convolution>(add, weights_3, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -159,17 +134,13 @@ TEST(TransformationTests, StridesOptimization4) {
         auto conv_3 = std::make_shared<ngraph::opset7::Convolution>(add, weights_3, ngraph::Strides{1, 1},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 // Pl--->Conv(1x1,1x1)->ReLU--->Eltwise-->Conv(1x1,2x2) => Pl--->Conv(1x1,2x2)->ReLU--->Eltwise-->Conv(1x1,1x1)
 //   `----------------->ReLU---`                             `-->Pool(1x1,2x2)->ReLU---`
-TEST(TransformationTests, StridesOptimization5) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization5) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 1, 1}, {128});
@@ -182,11 +153,8 @@ TEST(TransformationTests, StridesOptimization5) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(add, weights_2, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -201,18 +169,17 @@ TEST(TransformationTests, StridesOptimization5) {
         auto conv_2 = std::make_shared<ngraph::opset7::Convolution>(add, weights_2, ngraph::Strides{1, 1},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_2}, ngraph::ParameterVector{data});
     }
 
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    // TODO: update transformation and remove this check XXX-68696
+    disable_rt_info_check();
 }
 
 // Pl->Conv(1x1,1x1)->Conv(1x1,2x2)->Conv(3x3,1x1)->Conv(1x1,2x2)
 //       =>
 // Pl->Conv(1x1,2x2)->Conv(1x1,1x1)->Conv(3x3,2x2)->Conv(1x1,1x1)
-TEST(TransformationTests, StridesOptimization6) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization6) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 1, 1}, {128});
@@ -228,11 +195,8 @@ TEST(TransformationTests, StridesOptimization6) {
         auto conv_4 = std::make_shared<ngraph::opset7::Convolution>(conv_3, weights_4, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_4}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_4}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -249,11 +213,8 @@ TEST(TransformationTests, StridesOptimization6) {
         auto conv_4 = std::make_shared<ngraph::opset7::Convolution>(conv_3, weights_4, ngraph::Strides{1, 1},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_4}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_4}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
 // Pl->Conv(1x1,1x1) --> Conv(1x1,2x2) --> Conv(1x1,2x2)
@@ -261,8 +222,7 @@ TEST(TransformationTests, StridesOptimization6) {
 //       =>
 // Pl->Conv(1x1,1x1) ---> Conv(1x1,4x4) --> Conv(1x1,1x1)
 //                   `--> Pool(1x1, 2x2) -> Relu --> Conv(1x1,1x1)
-TEST(TransformationTests, StridesOptimization7) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization7) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 1, 1}, {128});
@@ -279,11 +239,8 @@ TEST(TransformationTests, StridesOptimization7) {
         auto conv_4 = std::make_shared<ngraph::opset7::Convolution>(relu, weights_4, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3, conv_4}, ngraph::ParameterVector{data});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3, conv_4}, ngraph::ParameterVector{data});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -302,11 +259,10 @@ TEST(TransformationTests, StridesOptimization7) {
         auto conv_4 = std::make_shared<ngraph::opset7::Convolution>(relu, weights_4, ngraph::Strides{1, 1},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3, conv_4}, ngraph::ParameterVector{data});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3, conv_4}, ngraph::ParameterVector{data});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    // TODO: update transformation and remove this check XXX-68696
+    disable_rt_info_check();
 }
 
 // Pl--->Conv(1x1,1x1)->ReLU--->Eltwise-->Conv(1x1,2x2)-->Eltwise-->Conv(1x1, 2x2)
@@ -314,8 +270,7 @@ TEST(TransformationTests, StridesOptimization7) {
 // =>
 // Pl----->Conv(1x1,1x4)----->ReLU---->Eltwise------>Conv(1x1,1x1)------>Eltwise---->Conv(1x1, 1x1)
 // Const-->MaxPool(1x1,4x4)-->Squeeze`  Pl--->MaxPool(1x1,2x2)-->Squeeze`
-TEST(TransformationTests, StridesOptimization8) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization8) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 1, 1}, {128});
@@ -334,11 +289,8 @@ TEST(TransformationTests, StridesOptimization8) {
         auto conv_3 = std::make_shared<ngraph::opset7::Convolution>(add_2, weights_3, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -364,11 +316,10 @@ TEST(TransformationTests, StridesOptimization8) {
         auto conv_3 = std::make_shared<ngraph::opset7::Convolution>(add_2, weights_3, ngraph::Strides{1, 1},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    // TODO: update transformation and remove this check XXX-68696
+    disable_rt_info_check();
 }
 
 // Pl------->Conv(1x1,1x1)------>Eltwise------>Conv(1x1,2x2)---->Eltwise-->Conv(1x1, 2x2)
@@ -378,8 +329,7 @@ TEST(TransformationTests, StridesOptimization8) {
 // Pl------->Conv(1x1,4x4)------->Eltwise---->Conv(1x1,1x1)-->Eltwise-->Conv(1x1, 1x1)
 // Pl----->Eltwise----->Eltwise--`    Eltwise------>Eltwise--`
 // Const--`      Const-`        Const--`     Const-`
-TEST(TransformationTests, StridesOptimization9) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, StridesOptimization9) {
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
         auto weights_1 = ngraph::opset1::Constant::create(ngraph::element::f32, ngraph::Shape{3, 3, 1, 1}, {128});
@@ -407,11 +357,8 @@ TEST(TransformationTests, StridesOptimization9) {
         auto conv_3 = std::make_shared<ngraph::opset7::Convolution>(add_6, weights_3, ngraph::Strides{2, 2},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2, data_3});
-        ngraph::pass::Manager m;
-        m.register_pass<ngraph::pass::InitNodeInfo>();
-        m.register_pass<ngraph::pass::StridesOptimization>();
-        m.run_passes(f);
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2, data_3});
+        manager.register_pass<ngraph::pass::StridesOptimization>();
     }
     {
         auto data = std::make_shared<ngraph::opset1::Parameter>(ngraph::element::f32, ngraph::Shape{1, 3, 224, 224});
@@ -452,9 +399,8 @@ TEST(TransformationTests, StridesOptimization9) {
         auto conv_3 = std::make_shared<ngraph::opset7::Convolution>(add_6, weights_3, ngraph::Strides{1, 1},
                 ngraph::CoordinateDiff{}, ngraph::CoordinateDiff{}, ngraph::Strides{});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2, data_3});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{conv_3}, ngraph::ParameterVector{data, data_2, data_3});
     }
-
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    // TODO: update transformation and remove this check XXX-68696
+    disable_rt_info_check();
 }

inference-engine/tests/functional/inference_engine/transformations/swish_fusion_test.cpp

@@ -18,8 +18,7 @@
 
 using namespace testing;
 
-TEST(TransformationTests, SwishFusionWithBeta) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SwishFusionWithBeta) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::PartialShape::dynamic(1));
         auto beta = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{});
@@ -30,13 +29,9 @@ TEST(TransformationTests, SwishFusionWithBeta) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, constant);
         auto div = std::make_shared<ngraph::opset4::Divide>(input, add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input, beta});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input, beta});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -44,15 +39,11 @@ TEST(TransformationTests, SwishFusionWithBeta) {
         auto beta = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f32, ngraph::Shape{});
         auto swish = std::make_shared<ngraph::opset4::Swish>(input, beta);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input, beta});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input, beta});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SwishFusionWithoutBeta) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SwishFusionWithoutBeta) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto neg = std::make_shared<ngraph::opset4::Negative>(input);
@@ -61,28 +52,20 @@ TEST(TransformationTests, SwishFusionWithoutBeta) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, constant);
         auto div = std::make_shared<ngraph::opset4::Divide>(input, add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto swish = std::make_shared<ngraph::opset4::Swish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SwishFusionWithoutBetaNonOneAddConstant) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SwishFusionWithoutBetaNonOneAddConstant) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto neg = std::make_shared<ngraph::opset4::Negative>(input);
@@ -91,13 +74,9 @@ TEST(TransformationTests, SwishFusionWithoutBetaNonOneAddConstant) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, constant);
         auto div = std::make_shared<ngraph::opset4::Divide>(input, add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -108,44 +87,32 @@ TEST(TransformationTests, SwishFusionWithoutBetaNonOneAddConstant) {
         auto add = std::make_shared<ngraph::opset4::Add>(exp, constant);
         auto div = std::make_shared<ngraph::opset4::Divide>(input, add);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{div}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SwishFusionWithSigmoid) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SwishFusionWithSigmoid) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto sig = std::make_shared<ngraph::opset4::Sigmoid>(input);
         auto mul = std::make_shared<ngraph::opset4::Multiply>(input, sig);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto swish = std::make_shared<ngraph::opset4::Swish>(input);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SwishFusionWithSigmoidWithBeta) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, SwishFusionWithSigmoidWithBeta) {
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto beta = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::Shape{});
@@ -153,13 +120,9 @@ TEST(TransformationTests, SwishFusionWithSigmoidWithBeta) {
         auto sig = std::make_shared<ngraph::opset4::Sigmoid>(mul_beta);
         auto mul = std::make_shared<ngraph::opset4::Multiply>(input, sig);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input, beta});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input, beta});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -167,16 +130,12 @@ TEST(TransformationTests, SwishFusionWithSigmoidWithBeta) {
         auto beta = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::Shape{});
         auto swish = std::make_shared<ngraph::opset4::Swish>(input, beta);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input, beta});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input, beta});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, SwishFusionWithSigmoidWithBetaConstant) {
+TEST_F(TransformationTestsF, SwishFusionWithSigmoidWithBetaConstant) {
     // test where the beta constant has multiple but the same value
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
     {
         auto input = std::make_shared<ngraph::opset4::Parameter>(ngraph::element::f16, ngraph::PartialShape::dynamic(1));
         auto beta = ngraph::opset4::Constant::create(ngraph::element::f16, ngraph::Shape{3}, {2.0, 2.0, 2.0});
@@ -184,13 +143,9 @@ TEST(TransformationTests, SwishFusionWithSigmoidWithBetaConstant) {
         auto sig = std::make_shared<ngraph::opset4::Sigmoid>(mul_beta);
         auto mul = std::make_shared<ngraph::opset4::Multiply>(input, sig);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{mul}, ngraph::ParameterVector{input});
 
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
         manager.register_pass<ngraph::pass::SwishFusion>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -198,9 +153,6 @@ TEST(TransformationTests, SwishFusionWithSigmoidWithBetaConstant) {
         auto beta = ngraph::opset4::Constant::create(ngraph::element::f16, ngraph::Shape{}, {2.0});
         auto swish = std::make_shared<ngraph::opset4::Swish>(input, beta);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input});
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{swish}, ngraph::ParameterVector{input});
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }

inference-engine/tests/functional/inference_engine/transformations/transpose_sinking_test.cpp

@@ -82,15 +82,21 @@ public:
 };
 
 TEST_P(TransposeSinkingFQ, TransposeFQReduce) {
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
     ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
     manager.register_pass<ngraph::pass::InitNodeInfo>();
     manager.register_pass<ngraph::pass::TransposeFQReduction>();
     manager.register_pass<ngraph::pass::TransposeReduction>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
     manager.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
 
-    auto res = compare_functions(f, f_ref, true);
-    ASSERT_TRUE(res.first) << res.second;
+    auto fc = FunctionsComparator::no_default()
+            .enable(FunctionsComparator::PRECISIONS)
+            .enable(FunctionsComparator::CONST_VALUES);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 
@@ -163,15 +169,21 @@ private:
 };
 
 TEST_P(TransposeSinking, TransposeReduction) {
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
     ngraph::pass::Manager manager;
+    manager.register_pass<ngraph::pass::InitUniqueNames>(unh);
     manager.register_pass<ngraph::pass::InitNodeInfo>();
     manager.register_pass<ngraph::pass::TransposeReduction>();
+    manager.register_pass<ngraph::pass::CheckUniqueNames>(unh);
     manager.run_passes(f);
     ASSERT_NO_THROW(check_rt_info(f));
 
-    auto res = compare_functions(f, f_ref, true);
+    auto fc = FunctionsComparator::no_default()
+            .enable(FunctionsComparator::PRECISIONS)
+            .enable(FunctionsComparator::CONST_VALUES);
 
-ASSERT_TRUE(res.first) << res.second;
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 
@@ -201,8 +213,7 @@ INSTANTIATE_TEST_SUITE_P(TransposeSinkingSqueeze, TransposeSinking, testing::Com
         testing::Values(
             ngraph::opset6::Squeeze::get_type_info_static())));
 
-TEST(TransformationTests, TransposeFuseEliminatesTranspose) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, TransposeFuseEliminatesTranspose) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 640, 20, 2 });
         auto tr1_order = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 5 }, { 0, 2, 3, 4, 1 });
@@ -212,13 +223,8 @@ TEST(TransformationTests, TransposeFuseEliminatesTranspose) {
         auto add_const = ngraph::opset6::Constant::create(ngraph::element::f32, ngraph::Shape{ 1 }, { 1 });
         auto add = std::make_shared<ngraph::opset6::Add>(transpose2, add_const);
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
         manager.register_pass<ngraph::pass::TransposeFuse>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -226,15 +232,11 @@ TEST(TransformationTests, TransposeFuseEliminatesTranspose) {
         auto add_const = ngraph::opset6::Constant::create(ngraph::element::f32, ngraph::Shape{ 1 }, { 1 });
         auto add = std::make_shared<ngraph::opset6::Add>(input, add_const);
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
     }
-
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
 }
 
-TEST(TransformationTests, TransposeFuses) {
-    std::shared_ptr<ngraph::Function> f(nullptr), f_ref(nullptr);
+TEST_F(TransformationTestsF, TransposeFuses) {
     {
         auto input = std::make_shared<ngraph::opset6::Parameter>(ngraph::element::f32, ngraph::Shape{ 1, 2, 640, 20, 2, 2 });
         auto tr1_order = ngraph::opset6::Constant::create(ngraph::element::i64, ngraph::Shape{ 6 }, { 0, 5, 1, 2, 3, 4 });
@@ -247,13 +249,8 @@ TEST(TransformationTests, TransposeFuses) {
         auto add = std::make_shared<ngraph::opset6::Add>(transpose2, add_const);
         add->set_friendly_name("add");
 
-        f = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
-
-        ngraph::pass::Manager manager;
-        manager.register_pass<ngraph::pass::InitNodeInfo>();
+        function = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
         manager.register_pass<ngraph::pass::TransposeFuse>();
-        manager.run_passes(f);
-        ASSERT_NO_THROW(check_rt_info(f));
     }
 
     {
@@ -265,10 +262,6 @@ TEST(TransformationTests, TransposeFuses) {
         auto add = std::make_shared<ngraph::opset6::Add>(transpose, add_const);
         add->set_friendly_name("add");
 
-        f_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
+        function_ref = std::make_shared<ngraph::Function>(ngraph::NodeVector{ add }, ngraph::ParameterVector{ input });
     }
-
-    const FunctionsComparator func_comparator = FunctionsComparator::with_default().enable(FunctionsComparator::NAMES);
-    const FunctionsComparator::Result res = func_comparator(f, f_ref);
-    ASSERT_TRUE(res.valid) << res.message;
 }

inference-engine/tests/functional/inference_engine/transformations/transpose_to_reshape_test.cpp

@@ -99,14 +99,19 @@ private:
 };
 
 TEST_P(TransposeToReshapeTests, CompareFunctions) {
-    ngraph::pass::Manager manager;
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
-    manager.register_pass<ngraph::pass::TransposeToReshape>();
-    manager.run_passes(f);
+    auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+    pass::Manager m;
+    m.register_pass<pass::InitUniqueNames>(unh);
+    m.register_pass<ngraph::pass::InitNodeInfo>();
+    m.register_pass<ngraph::pass::TransposeToReshape>();
+    m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+    m.run_passes(f);
     f->validate_nodes_and_infer_types();
     ASSERT_NO_THROW(check_rt_info(f));
-    auto res = compare_functions(f, f_ref);
-    ASSERT_TRUE(res.first) << res.second;
+
+    auto fc = FunctionsComparator::no_default().enable(FunctionsComparator::PRECISIONS);
+    auto res = fc.compare(f, f_ref);
+    ASSERT_TRUE(res.valid) << res.message;
 }
 
 #define SAME_FUNCTION    ReferenceParams(true, false)
@@ -181,10 +186,14 @@ TEST(TransformationTests, replace_transpose_with_reshape) {
         auto baseline_f = make_shared<Function>(transpose1, ParameterVector{param});
         auto optimized_f = clone_function(*baseline_f);
 
-        pass::Manager pass_manager;
-        pass_manager.register_pass<pass::Validate>();
-        pass_manager.register_pass<pass::TransposeToReshape>();
-        pass_manager.run_passes(optimized_f);
+        auto unh = std::make_shared<ngraph::pass::UniqueNamesHolder>();
+        pass::Manager m;
+        m.register_pass<pass::InitUniqueNames>(unh);
+        m.register_pass<ngraph::pass::InitNodeInfo>();
+        m.register_pass<ngraph::pass::Validate>();
+        m.register_pass<ngraph::pass::TransposeToReshape>();
+        m.register_pass<ngraph::pass::CheckUniqueNames>(unh);
+        m.run_passes(optimized_f);
 
         auto ps = baseline_f->get_results()[0]->get_output_partial_shape(0);
         auto ps_r = optimized_f->get_results()[0]->get_output_partial_shape(0);